@browser-storage/localstorage-driver/dist-web/index.js

LocalStorage driver for BrowserStorage

import { Defer } from '@browser-storage/core';

function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
  try {
    var info = gen[key](arg);
    var value = info.value;
  } catch (error) {
    reject(error);
    return;
  }

  if (info.done) {
    resolve(value);
  } else {
    Promise.resolve(value).then(_next, _throw);
  }
}

function _asyncToGenerator(fn) {
  return function () {
    var self = this,
        args = arguments;
    return new Promise(function (resolve, reject) {
      var gen = fn.apply(self, args);

      function _next(value) {
        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
      }

      function _throw(err) {
        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
      }

      _next(undefined);
    });
  };
}

class LocalstorageSerializer {
  deserialize(value) {
    return _asyncToGenerator(function* () {
      return JSON.parse(value);
    })();
  }

  serialize(value) {
    return _asyncToGenerator(function* () {
      return JSON.stringify(value);
    })();
  }

}

function makePrefix(options) {
  return [options.name, options.storeName, options.version].filter(f => !!f).join('/') + '/';
}
class LocalstorageDriver {
  constructor() {
    let serializer = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : new LocalstorageSerializer();
    this.serializer = serializer;
    this._ready = new Defer();
  }

  get isSupported() {
    return typeof localStorage !== 'undefined';
  }

  get prefix() {
    return makePrefix(this.options);
  }

  clear() {
    var _this = this;

    return _asyncToGenerator(function* () {
      return _this.iterate(key => _this.removeItem(key));
    })();
  }

  getItem(key) {
    var _this2 = this;

    return _asyncToGenerator(function* () {
      const result = localStorage.getItem(_this2.makeKey(key));
      return _this2.serializer.deserialize(result);
    })();
  }

  setItem(key, item) {
    var _this3 = this;

    return _asyncToGenerator(function* () {
      const serializedItem = yield _this3.serializer.serialize(item);
      localStorage.setItem(_this3.makeKey(key), serializedItem);
      return item;
    })();
  }

  iterate(iterator) {
    var _this4 = this;

    return _asyncToGenerator(function* () {
      const keys = yield _this4.keys();
      return keys.reduceRight(
      /*#__PURE__*/
      function () {
        var _ref = _asyncToGenerator(function* (prev, key, index) {
          yield prev;
          const value = yield _this4.getItem(key);
          yield iterator(key, value, index);
        });

        return function (_x, _x2, _x3) {
          return _ref.apply(this, arguments);
        };
      }(), Promise.resolve());
    })();
  }

  key(index) {
    var _this5 = this;

    return _asyncToGenerator(function* () {
      return (yield _this5.keys())[index];
    })();
  }

  keys() {
    var _this6 = this;

    return _asyncToGenerator(function* () {
      const length = localStorage.length;
      const result = [];

      for (let i = 0; i < length; i++) {
        const key = localStorage.key(i);

        if (_this6.includes(key)) {
          result.push(key.substring(_this6.prefix.length));
        }
      }

      return result;
    })();
  }

  length() {
    var _this7 = this;

    return _asyncToGenerator(function* () {
      return (yield _this7.keys()).length;
    })();
  }

  removeItem(key) {
    var _this8 = this;

    return _asyncToGenerator(function* () {
      localStorage.removeItem(_this8.makeKey(key));
    })();
  }

  init(options) {
    var _this9 = this;

    return _asyncToGenerator(function* () {
      _this9.options = options;

      _this9._ready.resolve(true);
    })();
  }

  ready() {
    var _this10 = this;

    return _asyncToGenerator(function* () {
      return _this10._ready.promise;
    })();
  }

  hasItem(key) {
    var _this11 = this;

    return _asyncToGenerator(function* () {
      return (yield _this11.keys()).indexOf(key) > -1;
    })();
  }

  destroy() {
    return _asyncToGenerator(function* () {
      return undefined;
    })();
  }

  makeKey(key) {
    return this.prefix + key;
  }

  includes(fullKey) {
    return fullKey.indexOf(this.prefix) === 0;
  }

}

export { LocalstorageDriver, LocalstorageSerializer, makePrefix };