react-wire-persisted 1.0.6 → 1.2.0

package/lib/react-wire-persisted.js

@@ -1 +1,802 @@
-!function(e,t){if("object"==typeof exports&&"object"==typeof module)module.exports=t();else if("function"==typeof define&&define.amd)define([],t);else{var r=t();for(var n in r)("object"==typeof exports?exports:e)[n]=r[n]}}(this,(function(){return(()=>{"use strict";var e={253:(e,t,r)=>{r.r(t),r.d(t,{addKey:()=>l,fakeLocalStorage:()=>g,getKeys:()=>p,getPrefixedKeys:()=>v,isPrimitive:()=>y,key:()=>f});const n=require("@babel/runtime/helpers/typeof");var o=r.n(n),i=r(779),a=r.n(i);function s(e,t){var r=Object.keys(e);if(Object.getOwnPropertySymbols){var n=Object.getOwnPropertySymbols(e);t&&(n=n.filter((function(t){return Object.getOwnPropertyDescriptor(e,t).enumerable}))),r.push.apply(r,n)}return r}function c(e){for(var t=1;t<arguments.length;t++){var r=null!=arguments[t]?arguments[t]:{};t%2?s(Object(r),!0).forEach((function(t){a()(e,t,r[t])})):Object.getOwnPropertyDescriptors?Object.defineProperties(e,Object.getOwnPropertyDescriptors(r)):s(Object(r)).forEach((function(t){Object.defineProperty(e,t,Object.getOwnPropertyDescriptor(r,t))}))}return e}var u={},l=function(e){u[e]=e},f=function(e){return l(e)},p=function(){return u},v=function(e){var t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:null,r=t||u;return e?Object.keys(r).reduce((function(t,n){return c(c({},t),{},a()({},n,"".concat(e,".").concat(r[n])))}),{}):r},g={__IS_FAKE_LOCAL_STORAGE__:!0,getItem:function(e){return g[e]},setItem:function(e,t){g[e]=t},removeItem:function(e){delete g[e]}},y=function(e){var t=o()(e);return null===e||!Array.isArray(e)&&("object"!==t&&"function"!==t)}},779:e=>{e.exports=require("@babel/runtime/helpers/defineProperty")}},t={};function r(n){var o=t[n];if(void 0!==o)return o.exports;var i=t[n]={exports:{}};return e[n](i,i.exports,r),i.exports}r.n=e=>{var t=e&&e.__esModule?()=>e.default:()=>e;return r.d(t,{a:t}),t},r.d=(e,t)=>{for(var n in t)r.o(t,n)&&!r.o(e,n)&&Object.defineProperty(e,n,{enumerable:!0,get:t[n]})},r.o=(e,t)=>Object.prototype.hasOwnProperty.call(e,t),r.r=e=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})};var n={};return(()=>{r.r(n),r.d(n,{createPersistedWire:()=>C,defaultOptions:()=>w,getNamespace:()=>x,getOptions:()=>E,getStorage:()=>q,setNamespace:()=>N,setOptions:()=>D,utils:()=>e});var e=r(253);const t=require("@babel/runtime/helpers/toConsumableArray");var o=r.n(t),i=r(779),a=r.n(i);const s=require("@forminator/react-wire"),c=require("@babel/runtime/helpers/slicedToArray");var u=r.n(c);const l=require("@babel/runtime/helpers/classCallCheck");var f=r.n(l);const p=require("@babel/runtime/helpers/createClass");var v=r.n(p);const g=require("@babel/runtime/helpers/inherits");var y=r.n(g);const h=require("@babel/runtime/helpers/possibleConstructorReturn");var m=r.n(h);const b=require("@babel/runtime/helpers/getPrototypeOf");var d=r.n(b);function O(e){var t=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(e){return!1}}();return function(){var r,n=d()(e);if(t){var o=d()(this).constructor;r=Reflect.construct(n,arguments,o)}else r=n.apply(this,arguments);return m()(this,r)}}var j=function(t){y()(n,t);var r=O(n);function n(){var e,t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:null,o=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};return f()(this,n),(e=r.call(this,t,o)).storage=e.getStorage(),e}return v()(n,[{key:"getStorage",value:function(){try{return window.localStorage}catch(t){return console.warn("LocalStorageProvider: localStorage not supported"),e.fakeLocalStorage}}},{key:"setNamespace",value:function(e){if(this.namespace){if(this.namespace!==e){var t=JSON.parse(JSON.stringify(this.getAll()));this.removeAll();for(var r=0,n=Object.entries(t);r<n.length;r++){var o=u()(n[r],2),i=o[0],a=o[1],s=i.replace(this.namespace,e);this.setItem(s,a)}this.namespace=e}}else this.namespace=e}},{key:"getItem",value:function(e){var t=this.storage.getItem(e);if(null==t)return null;try{return JSON.parse(t)}catch(e){return t}}},{key:"setItem",value:function(t,r){var n=r;return null!=n&&(n=(0,e.isPrimitive)(r)?r:JSON.stringify(r)),this.storage.setItem(t,n)}},{key:"removeItem",value:function(e){var t=arguments.length>1&&void 0!==arguments[1]&&arguments[1];return t&&delete this.registry[e],this.storage.removeItem(e)}},{key:"getAll",value:function(){var e=this,t="".concat(this.namespace,".");return Object.keys(this.storage).reduce((function(r,n){return e.namespace&&!n.startsWith(t)||(r[n]=e.storage.getItem(n)),r}),{})}},{key:"_resetAll",value:function(){var e=this,t=!(arguments.length>0&&void 0!==arguments[0])||arguments[0],r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:[],n=arguments.length>2&&void 0!==arguments[2]&&arguments[2],o="".concat(this.namespace,".");Object.keys(localStorage).forEach((function(i){var a=!e.namespace||i.startsWith(o),s=(null==r?void 0:r.includes(i))||!1;a&&!s&&(t?Object.prototype.hasOwnProperty.call(e.registry,i)?e.storage.setItem(i,e.registry[i]):e.storage.removeItem(i):(e.storage.removeItem(i),n&&delete e.registry[i]))}))}},{key:"resetAll",value:function(){var e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:[],t=arguments.length>1&&void 0!==arguments[1]&&arguments[1];this._resetAll(!0,e||[],t)}},{key:"removeAll",value:function(){var e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:[],t=arguments.length>1&&void 0!==arguments[1]&&arguments[1];this._resetAll(!1,e||[],t)}}]),n}(function(){function e(t,r){if(f()(this,e),(this instanceof e?this.constructor:void 0)===e)throw TypeError("StorageProvider is abstract. Extend this class to implement it");this.namespace=t||null,this.registry=r||{}}return v()(e,[{key:"setNamespace",value:function(e){}},{key:"register",value:function(e,t){this.registry[e]=t}},{key:"getItem",value:function(e){}},{key:"setItem",value:function(e,t){}},{key:"removeItem",value:function(e){}},{key:"getAll",value:function(){}},{key:"_resetAll",value:function(){}},{key:"resetAll",value:function(){}},{key:"removeAll",value:function(){}}]),e}());function P(e,t){var r=Object.keys(e);if(Object.getOwnPropertySymbols){var n=Object.getOwnPropertySymbols(e);t&&(n=n.filter((function(t){return Object.getOwnPropertyDescriptor(e,t).enumerable}))),r.push.apply(r,n)}return r}function k(e){for(var t=1;t<arguments.length;t++){var r=null!=arguments[t]?arguments[t]:{};t%2?P(Object(r),!0).forEach((function(t){a()(e,t,r[t])})):Object.getOwnPropertyDescriptors?Object.defineProperties(e,Object.getOwnPropertyDescriptors(r)):P(Object(r)).forEach((function(t){Object.defineProperty(e,t,Object.getOwnPropertyDescriptor(r,t))}))}return e}var w={logging:!1},S=j,A=new S,I=k({},w),_=[],x=function(){return A.namespace},q=function(){return A},E=function(){return I},N=function(e){A.setNamespace(e),A=new S(e||x())},D=function(e){if((I=k(k({},I),e)).logging)for(console.info("Flushing",_.length,"pending logs");_.length;){var t;(t=console).log.apply(t,o()(_.shift()))}},R=function(){for(var e,t=arguments.length,r=new Array(t),n=0;n<t;n++)r[n]=arguments[n];I.logging.enabled?(e=console).log.apply(e,r):_.push(r)},C=function(e){var t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:null;if(!e&&"number"!=typeof e)throw new Error("createPersistedWire: Key cannot be a falsey value (".concat(e,"}"));A.register(e,t);var r=(0,s.createWire)(t),n=function(){return r.getValue()},o=function(t){return A.setItem(e,t),r.setValue(t)},i=function(e){r.subscribe(e)},a=A.getItem(e),c=null===a?t:a;return R("react-wire-persisted: create",e,{value:t,storedValue:a,initialValue:c}),c!==t&&o(c),k(k({},r),{},{getValue:n,setValue:o,subscribe:i})}})(),n})()}));
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var reactWire = require('@forminator/react-wire');
+
+function unwrapExports (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+function createCommonjsModule(fn, module) {
+	return module = { exports: {} }, fn(module, module.exports), module.exports;
+}
+
+var defineProperty = createCommonjsModule(function (module) {
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+
+  return obj;
+}
+
+module.exports = _defineProperty, module.exports.__esModule = true, module.exports["default"] = module.exports;
+});
+
+var _defineProperty = unwrapExports(defineProperty);
+
+function ownKeys$1(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread$1(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$1(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$1(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+/**
+ * Convenience map of keys
+ */
+var storageKeys = {};
+/**
+ * Adds a key to the keys map
+ * 
+ * @param {String} value Key name
+ */
+
+var addKey = function addKey(value) {
+  storageKeys[value] = value;
+};
+/**
+ * Adds a key to the keys map
+ * (Alias for `addKey`)
+ * 
+ * @param {String} value Key name
+ */
+
+var key = function key(value) {
+  return addKey(value);
+};
+/**
+ * Convenience method to get internally managed storage keys
+ * 
+ * @returns {Object} Storage keys map
+ */
+
+var getKeys = function getKeys() {
+  return storageKeys;
+};
+/**
+ * Helper utility to prefix all keys in a map to use a namespace
+ * 
+ * @param {String} namespace Storage namespace prefix
+ * @param {Object} keys (Optional) Storage key/values. Defaults to the internally managed keys map
+ */
+
+var getPrefixedKeys = function getPrefixedKeys(namespace) {
+  var keys = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+  var items = keys || storageKeys;
+  if (!namespace) return items;
+  return Object.keys(items).reduce(function (acc, it) {
+    return _objectSpread$1(_objectSpread$1({}, acc), {}, _defineProperty({}, it, "".concat(namespace, ".").concat(items[it])));
+  }, {});
+};
+
+var fakeLocalStorage = {
+  getItem: function getItem(key) {
+    return fakeLocalStorage[key];
+  },
+  setItem: function setItem(key, value) {
+    fakeLocalStorage[key] = value;
+  },
+  removeItem: function removeItem(key) {
+    delete fakeLocalStorage[key];
+  }
+};
+
+/**
+ * Checks if a value is a primitive type
+ * 
+ * @param {*} val Value to check
+ * @returns {Boolean} True if value is a primitive type
+ */
+
+var isPrimitive = function isPrimitive(val) {
+  var type = typeof val;
+  if (val === null) return true;
+  if (Array.isArray(val)) return false;
+  if (type === 'object') return false;
+  return type !== 'function';
+};
+
+var index = /*#__PURE__*/Object.freeze({
+__proto__: null,
+isPrimitive: isPrimitive,
+addKey: addKey,
+key: key,
+getKeys: getKeys,
+getPrefixedKeys: getPrefixedKeys,
+fakeLocalStorage: fakeLocalStorage
+});
+
+var arrayLikeToArray = createCommonjsModule(function (module) {
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+
+  for (var i = 0, arr2 = new Array(len); i < len; i++) {
+    arr2[i] = arr[i];
+  }
+
+  return arr2;
+}
+
+module.exports = _arrayLikeToArray, module.exports.__esModule = true, module.exports["default"] = module.exports;
+});
+
+unwrapExports(arrayLikeToArray);
+
+var arrayWithoutHoles = createCommonjsModule(function (module) {
+function _arrayWithoutHoles(arr) {
+  if (Array.isArray(arr)) return arrayLikeToArray(arr);
+}
+
+module.exports = _arrayWithoutHoles, module.exports.__esModule = true, module.exports["default"] = module.exports;
+});
+
+unwrapExports(arrayWithoutHoles);
+
+var iterableToArray = createCommonjsModule(function (module) {
+function _iterableToArray(iter) {
+  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+
+module.exports = _iterableToArray, module.exports.__esModule = true, module.exports["default"] = module.exports;
+});
+
+unwrapExports(iterableToArray);
+
+var unsupportedIterableToArray = createCommonjsModule(function (module) {
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return arrayLikeToArray(o, minLen);
+}
+
+module.exports = _unsupportedIterableToArray, module.exports.__esModule = true, module.exports["default"] = module.exports;
+});
+
+unwrapExports(unsupportedIterableToArray);
+
+var nonIterableSpread = createCommonjsModule(function (module) {
+function _nonIterableSpread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+
+module.exports = _nonIterableSpread, module.exports.__esModule = true, module.exports["default"] = module.exports;
+});
+
+unwrapExports(nonIterableSpread);
+
+var toConsumableArray = createCommonjsModule(function (module) {
+function _toConsumableArray(arr) {
+  return arrayWithoutHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableSpread();
+}
+
+module.exports = _toConsumableArray, module.exports.__esModule = true, module.exports["default"] = module.exports;
+});
+
+var _toConsumableArray = unwrapExports(toConsumableArray);
+
+var arrayWithHoles = createCommonjsModule(function (module) {
+function _arrayWithHoles(arr) {
+  if (Array.isArray(arr)) return arr;
+}
+
+module.exports = _arrayWithHoles, module.exports.__esModule = true, module.exports["default"] = module.exports;
+});
+
+unwrapExports(arrayWithHoles);
+
+var iterableToArrayLimit = createCommonjsModule(function (module) {
+function _iterableToArrayLimit(arr, i) {
+  var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+
+  if (_i == null) return;
+  var _arr = [];
+  var _n = true;
+  var _d = false;
+
+  var _s, _e;
+
+  try {
+    for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
+      _arr.push(_s.value);
+
+      if (i && _arr.length === i) break;
+    }
+  } catch (err) {
+    _d = true;
+    _e = err;
+  } finally {
+    try {
+      if (!_n && _i["return"] != null) _i["return"]();
+    } finally {
+      if (_d) throw _e;
+    }
+  }
+
+  return _arr;
+}
+
+module.exports = _iterableToArrayLimit, module.exports.__esModule = true, module.exports["default"] = module.exports;
+});
+
+unwrapExports(iterableToArrayLimit);
+
+var nonIterableRest = createCommonjsModule(function (module) {
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+
+module.exports = _nonIterableRest, module.exports.__esModule = true, module.exports["default"] = module.exports;
+});
+
+unwrapExports(nonIterableRest);
+
+var slicedToArray = createCommonjsModule(function (module) {
+function _slicedToArray(arr, i) {
+  return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();
+}
+
+module.exports = _slicedToArray, module.exports.__esModule = true, module.exports["default"] = module.exports;
+});
+
+var _slicedToArray = unwrapExports(slicedToArray);
+
+var classCallCheck = createCommonjsModule(function (module) {
+function _classCallCheck(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+
+module.exports = _classCallCheck, module.exports.__esModule = true, module.exports["default"] = module.exports;
+});
+
+var _classCallCheck = unwrapExports(classCallCheck);
+
+var createClass = createCommonjsModule(function (module) {
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, descriptor.key, descriptor);
+  }
+}
+
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  Object.defineProperty(Constructor, "prototype", {
+    writable: false
+  });
+  return Constructor;
+}
+
+module.exports = _createClass, module.exports.__esModule = true, module.exports["default"] = module.exports;
+});
+
+var _createClass = unwrapExports(createClass);
+
+var setPrototypeOf = createCommonjsModule(function (module) {
+function _setPrototypeOf(o, p) {
+  module.exports = _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  }, module.exports.__esModule = true, module.exports["default"] = module.exports;
+  return _setPrototypeOf(o, p);
+}
+
+module.exports = _setPrototypeOf, module.exports.__esModule = true, module.exports["default"] = module.exports;
+});
+
+unwrapExports(setPrototypeOf);
+
+var inherits = createCommonjsModule(function (module) {
+function _inherits(subClass, superClass) {
+  if (typeof superClass !== "function" && superClass !== null) {
+    throw new TypeError("Super expression must either be null or a function");
+  }
+
+  subClass.prototype = Object.create(superClass && superClass.prototype, {
+    constructor: {
+      value: subClass,
+      writable: true,
+      configurable: true
+    }
+  });
+  Object.defineProperty(subClass, "prototype", {
+    writable: false
+  });
+  if (superClass) setPrototypeOf(subClass, superClass);
+}
+
+module.exports = _inherits, module.exports.__esModule = true, module.exports["default"] = module.exports;
+});
+
+var _inherits = unwrapExports(inherits);
+
+var _typeof_1 = createCommonjsModule(function (module) {
+function _typeof(obj) {
+  "@babel/helpers - typeof";
+
+  return (module.exports = _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
+    return typeof obj;
+  } : function (obj) {
+    return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+  }, module.exports.__esModule = true, module.exports["default"] = module.exports), _typeof(obj);
+}
+
+module.exports = _typeof, module.exports.__esModule = true, module.exports["default"] = module.exports;
+});
+
+unwrapExports(_typeof_1);
+
+var assertThisInitialized = createCommonjsModule(function (module) {
+function _assertThisInitialized(self) {
+  if (self === void 0) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+
+  return self;
+}
+
+module.exports = _assertThisInitialized, module.exports.__esModule = true, module.exports["default"] = module.exports;
+});
+
+unwrapExports(assertThisInitialized);
+
+var possibleConstructorReturn = createCommonjsModule(function (module) {
+var _typeof = _typeof_1["default"];
+
+
+
+function _possibleConstructorReturn(self, call) {
+  if (call && (_typeof(call) === "object" || typeof call === "function")) {
+    return call;
+  } else if (call !== void 0) {
+    throw new TypeError("Derived constructors may only return object or undefined");
+  }
+
+  return assertThisInitialized(self);
+}
+
+module.exports = _possibleConstructorReturn, module.exports.__esModule = true, module.exports["default"] = module.exports;
+});
+
+var _possibleConstructorReturn = unwrapExports(possibleConstructorReturn);
+
+var getPrototypeOf = createCommonjsModule(function (module) {
+function _getPrototypeOf(o) {
+  module.exports = _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
+    return o.__proto__ || Object.getPrototypeOf(o);
+  }, module.exports.__esModule = true, module.exports["default"] = module.exports;
+  return _getPrototypeOf(o);
+}
+
+module.exports = _getPrototypeOf, module.exports.__esModule = true, module.exports["default"] = module.exports;
+});
+
+var _getPrototypeOf = unwrapExports(getPrototypeOf);
+
+/**
+ * Base class to allow storage access
+ * @see `LocalStorageProvider.js` for an example implementation
+ */
+var StorageProvider = /*#__PURE__*/function () {
+  /**
+   * Initializes the class
+   * @param {String} namespace Namespace to prefix all keys with. Mostly used for the logging & reset functions
+   * @param {Object} registry (Optional) Initialize the storage provider with an existing registry
+   */
+  function StorageProvider(namespace, registry) {
+    _classCallCheck(this, StorageProvider);
+
+    // Simulate being an abstract class
+    if ((this instanceof StorageProvider ? this.constructor : void 0) === StorageProvider) throw TypeError("StorageProvider is abstract. Extend this class to implement it");
+    this.namespace = namespace || null;
+    this.registry = registry ||
+    /* istanbul ignore next */
+    {};
+  }
+  /**
+   * Sets the namespace for this storage provider, and migrates
+   * all stored values to the new namespace
+   * @param {String} namespace New namespace for this storage provider
+   */
+
+  /* istanbul ignore next */
+
+
+  _createClass(StorageProvider, [{
+    key: "setNamespace",
+    value: function setNamespace(namespace) {}
+    /**
+     * Registers an item with it's initial value. This is used for logging, resetting, etc.
+     * @param {String} key Storage item's key
+     * @param {*} initialValue Storage item's initial value
+     */
+
+  }, {
+    key: "register",
+    value: function register(key, initialValue) {
+      this.registry[key] = initialValue;
+    }
+    /**
+     * Reads an item from storage
+     * @param {String} key Key for the item to retrieve
+     */
+
+    /* istanbul ignore next */
+
+  }, {
+    key: "getItem",
+    value: function getItem(key) {}
+    /**
+     * Stores a value
+     * @param {String} key Item's storage key
+     * @param {String} value Item's value to store
+     */
+
+    /* istanbul ignore next */
+
+  }, {
+    key: "setItem",
+    value: function setItem(key, value) {}
+    /**
+     * Removes an item from storage
+     * @param {String} key Item's storage key
+     * @param {Boolean} fromRegistry (Optional) If the item should also be removed from the registry
+     */
+
+    /* istanbul ignore next */
+
+  }, {
+    key: "removeItem",
+    value: function removeItem(key) {
+    }
+    /**
+     * Gets all stored keys & values
+     * If a `namespace` was set, only keys prefixed with the namespace will be returned
+     */
+
+    /* istanbul ignore next */
+
+  }, {
+    key: "getAll",
+    value: function getAll() {}
+    /**
+     * 
+     * @param {Boolean} useInitialValues If values should be replaced with their initial values. If false, keys are removed
+     * @param {String[]} excludedKeys (Optional) List of keys to exclude
+     * @param {Boolean} clearRegistry (Optional) If the registry should also be cleared
+     */
+
+    /* istanbul ignore next */
+
+  }, {
+    key: "_resetAll",
+    value: function _resetAll() {
+    }
+    /**
+     * Resets all values to their initial values
+     * If a `namespace` is set, only keys prefixed with the namespace will be reset
+     * @param {String[]} excludedKeys (Optional) List of keys to exclude
+     */
+
+    /* istanbul ignore next */
+
+  }, {
+    key: "resetAll",
+    value: function resetAll() {
+    }
+    /**
+     * Removes all items from local storage.
+     * If a `namespace` is set, only keys prefixed with the namespace will be removed
+     * @param {String[]} excludedKeys (Optional) List of keys to exclude
+     */
+
+    /* istanbul ignore next */
+
+  }, {
+    key: "removeAll",
+    value: function removeAll() {
+    }
+  }]);
+
+  return StorageProvider;
+}();
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+/**
+ * A storage provider for `localStorage`
+ * @see `StorageProvider.js` for documentation
+ */
+
+var LocalStorageProvider = /*#__PURE__*/function (_StorageProvider) {
+  _inherits(LocalStorageProvider, _StorageProvider);
+
+  var _super = _createSuper(LocalStorageProvider);
+
+  function LocalStorageProvider() {
+    var _this;
+
+    var namespace = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+    var registry = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+    _classCallCheck(this, LocalStorageProvider);
+
+    _this = _super.call(this, namespace, registry);
+    _this.storage = _this.getStorage();
+    return _this;
+  }
+
+  _createClass(LocalStorageProvider, [{
+    key: "getStorage",
+    value: function getStorage() {
+      try {
+        return window.localStorage;
+      } catch (e) {
+        /* istanbul ignore next */
+        console.warn('LocalStorageProvider: localStorage not supported');
+        /* istanbul ignore next */
+
+        return fakeLocalStorage;
+      }
+    }
+  }, {
+    key: "setNamespace",
+    value: function setNamespace(namespace) {
+      if (!this.namespace) {
+        this.namespace = namespace;
+        return;
+      }
+
+      if (this.namespace === namespace) return;
+      var items = JSON.parse(JSON.stringify(this.getAll()));
+      this.removeAll();
+
+      for (var _i = 0, _Object$entries = Object.entries(items); _i < _Object$entries.length; _i++) {
+        var _ref3 = _Object$entries[_i];
+
+        var _ref2 = _slicedToArray(_ref3, 2);
+
+        var key = _ref2[0];
+        var value = _ref2[1];
+        var newKey = key.replace(this.namespace, namespace);
+        this.setItem(newKey, value);
+      }
+
+      this.namespace = namespace;
+    }
+  }, {
+    key: "getItem",
+    value: function getItem(key) {
+      var val = this.storage.getItem(key);
+      if (val === undefined || val === null) return null;
+
+      try {
+        return JSON.parse(val);
+      } catch (e) {
+        return val;
+      }
+    }
+  }, {
+    key: "setItem",
+    value: function setItem(key, value) {
+      var val = value; // Don't allow "null" & similar values to be stringified
+
+      if (val !== undefined && val !== null) val = isPrimitive(value) ? value : JSON.stringify(value);
+      return this.storage.setItem(key, val);
+    }
+  }, {
+    key: "removeItem",
+    value: function removeItem(key) {
+      var fromRegistry = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+      if (fromRegistry) delete this.registry[key];
+      return this.storage.removeItem(key);
+    }
+  }, {
+    key: "getAll",
+    value: function getAll() {
+      var _this2 = this;
+
+      var prefixNs = "".concat(this.namespace, ".");
+      return Object.keys(this.storage).reduce(function (acc, it) {
+        if (_this2.namespace ? it.startsWith(prefixNs) : true) acc[it] = _this2.storage.getItem(it);
+        return acc;
+      }, {});
+    }
+  }, {
+    key: "_resetAll",
+    value: function _resetAll() {
+      var _this3 = this;
+
+      var useInitialValues = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+      var excludedKeys = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+      var clearRegistry = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+      var prefixNs = "".concat(this.namespace, ".");
+      Object.keys(localStorage).forEach(function (it) {
+        var isAppKey = _this3.namespace ? it.startsWith(prefixNs) : true;
+        var isExcluded = (excludedKeys === null || excludedKeys === void 0 ? void 0 : excludedKeys.includes(it)) || false;
+        if (!isAppKey || isExcluded) return;
+
+        if (useInitialValues) {
+          var isRegistered = Object.prototype.hasOwnProperty.call(_this3.registry, it);
+          if (isRegistered) _this3.storage.setItem(it, _this3.registry[it]);else _this3.storage.removeItem(it);
+        } else {
+          _this3.storage.removeItem(it);
+
+          if (clearRegistry) delete _this3.registry[it];
+        }
+      });
+    }
+  }, {
+    key: "resetAll",
+    value: function resetAll() {
+      var excludedKeys = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+      var clearRegistry = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+
+      this._resetAll(true, excludedKeys || [], clearRegistry);
+    }
+  }, {
+    key: "removeAll",
+    value: function removeAll() {
+      var excludedKeys = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+      var clearRegistry = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+
+      this._resetAll(false, excludedKeys || [], clearRegistry);
+    }
+  }]);
+
+  return LocalStorageProvider;
+}(StorageProvider);
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+var defaultOptions = {
+  logging: {
+    enabled: false
+  }
+};
+var Provider = LocalStorageProvider;
+var storage = new Provider();
+
+var options = _objectSpread({}, defaultOptions);
+
+var pendingLogs = [];
+/**
+ * Gets the namespace of the storage provider
+ * 
+ * @returns {String}
+ */
+
+var getNamespace = function getNamespace() {
+  return storage.namespace;
+};
+/**
+ * Gets the current storage provider class instance
+ * 
+ * @returns {StorageProvider}
+ */
+
+var getStorage = function getStorage() {
+  return storage;
+};
+var getOptions = function getOptions() {
+  return options;
+};
+/**
+ * Sets the namespace for the storage provider
+ * 
+ * @param {String} namespace The namespace for the storage provider
+ */
+
+var setNamespace = function setNamespace(namespace) {
+  storage.setNamespace(namespace);
+  storage = new Provider(namespace || getNamespace());
+};
+var setOptions = function setOptions(value) {
+  options = _objectSpread(_objectSpread({}, options), value);
+  /* istanbul ignore next */
+
+  if (options.logging.enabled) {
+    console.info('Flushing', pendingLogs.length, 'pending logs');
+
+    while (pendingLogs.length) {
+      var _console;
+
+      /* istanbul ignore next */
+      (_console = console).log.apply(_console, _toConsumableArray(pendingLogs.shift()));
+    }
+  }
+};
+
+var log = function log() {
+  var _console2;
+
+  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+    args[_key] = arguments[_key];
+  }
+
+  /* istanbul ignore next */
+  if (options.logging.enabled)
+    /* istanbul ignore next */
+    (_console2 = console).log.apply(_console2, args);else pendingLogs.push(args);
+};
+/**
+ * Creates a persisted Wire using the `StorageProvider` that is currently set
+ * Defaults to `localStorage` via `LocalStorageProvider`
+ * 
+ * @param {String} key Unique key for storing this value
+ * @param {*} value Initial value of this Wire
+ * @returns A new Wire decorated with localStorage functionality
+ */
+
+
+var createPersistedWire = function createPersistedWire(key) {
+  var value = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+  // This check helps ensure no accidental key typos occur
+  if (!key && typeof key !== 'number') throw new Error("createPersistedWire: Key cannot be a falsey value (".concat(key, "}")); // Track this writable entry so we can easily clear all
+
+  storage.register(key, value); // The actual Wire backing object
+
+  var wire = reactWire.createWire(value);
+
+  var getValue = function getValue() {
+    return wire.getValue();
+  };
+
+  var setValue = function setValue(newValue) {
+    storage.setItem(key, newValue);
+    return wire.setValue(newValue);
+  };
+
+  var subscribe = function subscribe(fn) {
+    wire.subscribe(fn);
+  };
+
+  var storedValue = storage.getItem(key);
+  var initialValue = storedValue === null ? value : storedValue;
+  log('react-wire-persisted: create', key, {
+    value: value,
+    storedValue: storedValue,
+    initialValue: initialValue
+  });
+  if (initialValue !== value) setValue(initialValue);
+  return _objectSpread(_objectSpread({}, wire), {}, {
+    getValue: getValue,
+    setValue: setValue,
+    subscribe: subscribe
+  });
+};
+
+exports.createPersistedWire = createPersistedWire;
+exports.defaultOptions = defaultOptions;
+exports.getNamespace = getNamespace;
+exports.getOptions = getOptions;
+exports.getStorage = getStorage;
+exports.setNamespace = setNamespace;
+exports.setOptions = setOptions;
+exports.utils = index;