ima/storage/SessionStorage.js

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _GenericError = require('../error/GenericError');

var _GenericError2 = _interopRequireDefault(_GenericError);

var _Storage = require('./Storage');

var _Storage2 = _interopRequireDefault(_Storage);

var _Window = require('../window/Window');

var _Window2 = _interopRequireDefault(_Window);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * Implementation of the {@codelink Storage} interface that relies on the
 * native {@code sessionStorage} DOM storage for storing its entries.
 */
class SessionStorage extends _Storage2.default {
  static get $dependencies() {
    return [_Window2.default];
  }

  /**
   * Initializes the session storage.
   * @param {Window} window
   */
  constructor(window) {
    super();

    /**
     * The DOM storage providing the actual storage of the entries.
     *
     * @type {Storage}
     */
    this._storage = window.getWindow().sessionStorage;
  }

  /**
   * @inheritdoc
   */
  init() {
    return this;
  }

  /**
   * @inheritdoc
   */
  has(key) {
    return !!this._storage.getItem(key);
  }

  /**
   * @inheritdoc
   */
  get(key) {
    try {
      return JSON.parse(this._storage.getItem(key)).value;
    } catch (error) {
      throw new _GenericError2.default('ima.storage.SessionStorage.get: Failed to parse a session ' + `storage item value identified by the key ${key}: ` + error.message);
    }
  }

  /**
   * @inheritdoc
   */
  set(key, value) {
    try {
      this._storage.setItem(key, JSON.stringify({
        created: Date.now(),
        value
      }));
    } catch (error) {
      let storage = this._storage;
      let isItemTooBig = storage.length === 0 || storage.length === 1 && storage.key(0) === key;

      if (isItemTooBig) {
        throw error;
      }

      this._deleteOldestEntry();
      this.set(key, value);
    }

    return this;
  }

  /**
   * @inheritdoc
   */
  delete(key) {
    this._storage.removeItem(key);
    return this;
  }

  /**
   * @inheritdoc
   */
  clear() {
    this._storage.clear();
    return this;
  }

  /**
   * @inheritdoc
   */
  keys() {
    return new StorageIterator(this._storage);
  }

  /**
   * @override
   */
  size() {
    return this._storage.length;
  }

  /**
   * Deletes the oldest entry in this storage.
   */
  _deleteOldestEntry() {
    let oldestEntry = {
      key: null,
      created: Date.now() + 1
    };

    for (let key of this.keys()) {
      let value = JSON.parse(this._storage.getItem(key));
      if (value.created < oldestEntry.created) {
        oldestEntry = {
          key,
          created: value.created
        };
      }
    }

    if (typeof oldestEntry.key === 'string') {
      this.delete(oldestEntry.key);
    }
  }
}

exports.default = SessionStorage; /**
                                   * Implementation of the iterator protocol and the iterable protocol for DOM
                                   * storage keys.
                                   *
                                   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols
                                   */

class StorageIterator {
  /**
   * Initializes the DOM storage iterator.
   *
   * @param {Storage} storage The DOM storage to iterate through.
   */
  constructor(storage) {
    /**
     * The DOM storage being iterated.
     *
     * @type {Storage}
     */
    this._storage = storage;

    /**
     * The current index of the DOM storage key this iterator will return
     * next.
     *
     * @type {number}
     */
    this._currentKeyIndex = 0;
  }

  /**
   * Iterates to the next item. This method implements the iterator protocol.
   *
   * @return {{done: boolean, value: (undefined|string)}} The next value in
   *         the sequence and whether the iterator is done iterating through
   *         the values.
   */
  next() {
    if (this._currentKeyIndex >= this._storage.length) {
      return {
        done: true,
        value: undefined
      };
    }

    let key = this._storage.key(this._currentKeyIndex);
    this._currentKeyIndex++;

    return {
      done: false,
      value: key
    };
  }

  /**
   * Returns the iterator for this object (this iterator). This method
   * implements the iterable protocol and provides compatibility with the
   * {@code for..of} loops.
   *
   * @return {StorageIterator} This iterator.
   */
  [Symbol.iterator]() {
    return this;
  }
}

typeof $IMA !== 'undefined' && $IMA !== null && $IMA.Loader && $IMA.Loader.register('ima/storage/SessionStorage', [], function (_export, _context) {
 'use strict';
 return {
   setters: [],
   execute: function () {
     _export('default', exports.default);
   }
 };
});