redux-astroglide 0.1.0

package/dist/plugins/index.umd.js

@@ -0,0 +1,415 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+  typeof define === 'function' && define.amd ? define(['exports'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["redux-astroglide/plugins"] = {}));
+})(this, (function (exports) { 'use strict';
+
+  var index$2 = (function (callback) {
+    return {
+      constructor: function constructor(callback, value) {
+        this.value = value;
+        this.callback = callback;
+      },
+      update: function update(value, _ref) {
+        var draft = _ref.draft,
+          plugin = _ref.plugin;
+        return plugin.callback(value, {
+          draft: draft
+        });
+      }
+    };
+  });
+
+  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 _objectSpread2(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;
+  }
+  function _classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+      throw new TypeError("Cannot call a class as a function");
+    }
+  }
+  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, _toPropertyKey(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;
+  }
+  function _defineProperty(obj, key, value) {
+    key = _toPropertyKey(key);
+    if (key in obj) {
+      Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    } else {
+      obj[key] = value;
+    }
+    return obj;
+  }
+  function _setPrototypeOf(o, p) {
+    _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+      o.__proto__ = p;
+      return o;
+    };
+    return _setPrototypeOf(o, p);
+  }
+  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;
+    }
+  }
+  function _construct(Parent, args, Class) {
+    if (_isNativeReflectConstruct()) {
+      _construct = Reflect.construct.bind();
+    } else {
+      _construct = function _construct(Parent, args, Class) {
+        var a = [null];
+        a.push.apply(a, args);
+        var Constructor = Function.bind.apply(Parent, a);
+        var instance = new Constructor();
+        if (Class) _setPrototypeOf(instance, Class.prototype);
+        return instance;
+      };
+    }
+    return _construct.apply(null, arguments);
+  }
+  function _objectDestructuringEmpty(obj) {
+    if (obj == null) throw new TypeError("Cannot destructure " + obj);
+  }
+  function _toPrimitive(input, hint) {
+    if (typeof input !== "object" || input === null) return input;
+    var prim = input[Symbol.toPrimitive];
+    if (prim !== undefined) {
+      var res = prim.call(input, hint || "default");
+      if (typeof res !== "object") return res;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return (hint === "string" ? String : Number)(input);
+  }
+  function _toPropertyKey(arg) {
+    var key = _toPrimitive(arg, "string");
+    return typeof key === "symbol" ? key : String(key);
+  }
+
+  var checkPropTypes$1 = {exports: {}};
+
+  /**
+   * Copyright (c) 2013-present, Facebook, Inc.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   */
+  var ReactPropTypesSecret_1;
+  var hasRequiredReactPropTypesSecret;
+  function requireReactPropTypesSecret() {
+    if (hasRequiredReactPropTypesSecret) return ReactPropTypesSecret_1;
+    hasRequiredReactPropTypesSecret = 1;
+    var ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';
+    ReactPropTypesSecret_1 = ReactPropTypesSecret;
+    return ReactPropTypesSecret_1;
+  }
+
+  /**
+   * Copyright Facebook, ratehub.
+   * All rights reserved.
+   *
+   * This code is intended to closely match the behaviour of checkPropTypes() from
+   * facebook/prop-types. The license for that code can be found here:
+   * https://github.com/facebook/prop-types/blob/be165febc8133dfbe2c45133db6d25664dd68ad8/LICENSE
+   *
+   * That function's source:
+   * https://github.com/facebook/prop-types/blob/be165febc8133dfbe2c45133db6d25664dd68ad8/checkPropTypes.js
+   */
+
+  /**
+   * Check if the values match with the type specs
+   * Return a type error message or null
+   *
+   * @param {object} typeSpecs Map of name to a ReactPropType
+   * @param {object} values Runtime values that need to be type-checked
+   * @param {string} location e.g. "prop", "context", "child context"
+   * @param {string} componentName Name of the component for error messages.
+   * @param {?Function} getStack Returns the component stack.
+   */
+  function checkPropTypes(typeSpecs, values, location, componentName, getStack) {
+    if (process.env.NODE_ENV !== 'production') {
+      const ReactPropTypesSecret = requireReactPropTypesSecret();
+      var name = componentName || 'React class';
+      for (var typeSpecName in typeSpecs) {
+        if (typeSpecs.hasOwnProperty(typeSpecName)) {
+          var error;
+          if (typeof typeSpecs[typeSpecName] !== 'function') {
+            return name + ': ' + location + ' type `' + typeSpecName + '` is ' + 'invalid; it must be a function, usually from React.PropTypes.';
+          } else {
+            // Prop type validation may throw. In case they do, catch and save the
+            // exception as the error.
+            try {
+              error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret);
+            } catch (ex) {
+              error = ex;
+            }
+          }
+          if (error && !(error instanceof Error)) {
+            return name + ': type specification of ' + location + ' `' + typeSpecName + '` is invalid; the type checker function must ' + 'return `null` or an `Error` but returned a ' + typeof error + '. ' + 'You may have forgotten to pass an argument to the type checker ' + 'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' + 'shape all require an argument).';
+          }
+          if (error instanceof Error) {
+            var stack = getStack && getStack() || '';
+            return 'Failed ' + location + ' type: ' + error.message + stack;
+          }
+        }
+      }
+    }
+  }
+
+  /**
+   * Same as checkPropTypes but throws on error
+   */
+  function assertPropTypes() {
+    if (process.env.NODE_ENV !== 'production') {
+      var error = checkPropTypes.apply(null, arguments);
+      if (error) {
+        throw new Error(error);
+      }
+    }
+  }
+  checkPropTypes$1.exports = checkPropTypes;
+  checkPropTypes$1.exports.assertPropTypes = assertPropTypes;
+
+  var checkPropType = function checkPropType(propType, value, name) {
+    var extraProps = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+    return checkPropTypes$1.exports(_defineProperty({}, name, propType), _objectSpread2(_objectSpread2({}, extraProps), {}, _defineProperty({}, name, value)), name, undefined);
+  };
+  var checkProp = function checkProp(propType, value, name) {
+    var shouldTypeErrorPreventUpdate = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+    var result = checkPropType(propType, value, name);
+    if (result) {
+      var errorText = "Astroglide: prop  ".concat(name, "  with value  ").concat(value, "  is not of the specified type");
+      if (shouldTypeErrorPreventUpdate) {
+        throw Error(errorText);
+      } else {
+        console.warn(errorText);
+      }
+      return result;
+    }
+    return false;
+  };
+
+  var index$1 = (function () {
+    var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
+        preventUpdate: false
+      },
+      preventUpdate = _ref.preventUpdate;
+    return {
+      constructor: function constructor(propType, value) {
+        var config = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+        this.value = value; // value set here because constructor signature is different
+        this.propType = propType;
+        this.config = _objectSpread2(_objectSpread2({}, this.config), config);
+      },
+      getInitialValue: function getInitialValue(value, _ref2) {
+        var key = _ref2.key,
+          plugin = _ref2.plugin;
+        var propType = plugin.propType;
+        checkProp(propType, value, key);
+        return value;
+      },
+      update: function update(value, _ref3) {
+        var key = _ref3.key,
+          plugin = _ref3.plugin;
+        var propType = plugin.propType;
+        checkProp(propType, value, key, plugin.config.preventUpdate !== undefined ? plugin.config.preventUpdate : preventUpdate);
+        return value;
+      },
+      config: {
+        preventUpdate: false
+      }
+    };
+  });
+
+  var PERSISTENCE_KEY = "astroglide-persist";
+  var getPersistedStore = function getPersistedStore() {
+    var storage = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : localStorage;
+    var result = storage.getItem(PERSISTENCE_KEY);
+    return JSON.parse(result || "{}");
+  };
+  var storePersistedValue = function storePersistedValue(key, namespace, value) {
+    var storage = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : localStorage;
+    var store = getPersistedStore(storage);
+    if (namespace) {
+      store[namespace] = store[namespace] || {};
+      store[namespace][key] = value;
+    } else {
+      store[key] = value;
+    }
+    try {
+      storage.setItem(PERSISTENCE_KEY, JSON.stringify(store));
+    } catch (e) {
+      console.error(e);
+    }
+  };
+  var getPersistedValue = function getPersistedValue(key, namespace) {
+    var _scope2;
+    var storage = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : localStorage;
+    var scope = getPersistedStore(storage);
+    if (namespace) {
+      var _scope;
+      scope = (_scope = scope) === null || _scope === void 0 ? void 0 : _scope[namespace];
+    }
+    var retValue = (_scope2 = scope) === null || _scope2 === void 0 ? void 0 : _scope2[key];
+    console.log("retValue: ", retValue);
+    return retValue;
+  };
+  var index = (function () {
+    var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+      _ref$storageType = _ref.storageType,
+      storageType = _ref$storageType === void 0 ? localStorage : _ref$storageType;
+    return {
+      setup: function setup(plugin, _ref2) {
+        var sliceConfig = _ref2.sliceConfig;
+        return {
+          namespace: sliceConfig.name,
+          storageType: storageType
+        };
+      },
+      getInitialValue: function getInitialValue(value, _ref3) {
+        var sliceConfig = _ref3.sliceConfig,
+          key = _ref3.key;
+        var existingPersistedValue = getPersistedValue(key, sliceConfig.name);
+        if (existingPersistedValue !== undefined) {
+          return existingPersistedValue;
+        }
+        return value;
+      },
+      update: function update(value, _ref4) {
+        var key = _ref4.key,
+          sliceConfig = _ref4.sliceConfig;
+        storePersistedValue(key, sliceConfig.name, value, this.config.storageType !== undefined ? this.config.storageType : storageType);
+        return value;
+      }
+    };
+  });
+
+  var plugin = function plugin(_ref) {
+    var constructorFn = _ref.constructor,
+      setup = _ref.setup,
+      getInitialValue = _ref.getInitialValue,
+      update = _ref.update,
+      _ref$config = _ref.config,
+      config = _ref$config === void 0 ? {} : _ref$config;
+    return /*#__PURE__*/function () {
+      function _class(value) {
+        _classCallCheck(this, _class);
+        this.value = value;
+        this.setup = setup || this.setup;
+        this.getInitialValue = getInitialValue || this.getInitialValue;
+        this.update = update || this.update;
+        this.config = config;
+        for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+          args[_key - 1] = arguments[_key];
+        }
+        constructorFn === null || constructorFn === void 0 ? void 0 : constructorFn.call.apply(constructorFn, [this, value].concat(args));
+      }
+      _createClass(_class, [{
+        key: "getValue",
+        value: function getValue() {
+          return this.value;
+        }
+      }, {
+        key: "setValue",
+        value: function setValue(value) {
+          this.value = value;
+        }
+      }, {
+        key: "setConfig",
+        value: function setConfig(config) {
+          this.config = _objectSpread2(_objectSpread2({}, this.config), config);
+        }
+      }, {
+        key: "setup",
+        value: function setup(item, _ref2) {
+          _objectDestructuringEmpty(_ref2);
+          return {
+            plugin: item
+          };
+        }
+      }, {
+        key: "getInitialValue",
+        value: function getInitialValue(value, _ref3) {
+          _objectDestructuringEmpty(_ref3);
+          return value;
+        }
+      }, {
+        key: "update",
+        value: function update(value, _ref4) {
+          _objectDestructuringEmpty(_ref4);
+          return value;
+        }
+      }]);
+      return _class;
+    }();
+  };
+  var addPlugin = function addPlugin(config) {
+    var Class = plugin(config);
+    plugins.push(Class);
+    return function () {
+      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        args[_key2] = arguments[_key2];
+      }
+      return _construct(Class, args);
+    };
+  };
+  var addPlugins = function addPlugins() {
+    for (var _len3 = arguments.length, configs = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+      configs[_key3] = arguments[_key3];
+    }
+    return configs.map(addPlugin);
+  };
+  var plugins = [];
+
+  exports.addPlugin = addPlugin;
+  exports.addPlugins = addPlugins;
+  exports.persist = index;
+  exports.plugins = plugins;
+  exports.set = index$2;
+  exports.type = index$1;
+
+  Object.defineProperty(exports, '__esModule', { value: true });
+
+}));

package/dist/plugins/persist/index.es.js

@@ -0,0 +1,64 @@
+var PERSISTENCE_KEY = "astroglide-persist";
+var getPersistedStore = function getPersistedStore() {
+  var storage = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : localStorage;
+  var result = storage.getItem(PERSISTENCE_KEY);
+  return JSON.parse(result || "{}");
+};
+var storePersistedValue = function storePersistedValue(key, namespace, value) {
+  var storage = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : localStorage;
+  var store = getPersistedStore(storage);
+  if (namespace) {
+    store[namespace] = store[namespace] || {};
+    store[namespace][key] = value;
+  } else {
+    store[key] = value;
+  }
+  try {
+    storage.setItem(PERSISTENCE_KEY, JSON.stringify(store));
+  } catch (e) {
+    console.error(e);
+  }
+};
+var getPersistedValue = function getPersistedValue(key, namespace) {
+  var _scope2;
+  var storage = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : localStorage;
+  var scope = getPersistedStore(storage);
+  if (namespace) {
+    var _scope;
+    scope = (_scope = scope) === null || _scope === void 0 ? void 0 : _scope[namespace];
+  }
+  var retValue = (_scope2 = scope) === null || _scope2 === void 0 ? void 0 : _scope2[key];
+  console.log("retValue: ", retValue);
+  return retValue;
+};
+var index = (function () {
+  var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+    _ref$storageType = _ref.storageType,
+    storageType = _ref$storageType === void 0 ? localStorage : _ref$storageType;
+  return {
+    setup: function setup(plugin, _ref2) {
+      var sliceConfig = _ref2.sliceConfig;
+      return {
+        namespace: sliceConfig.name,
+        storageType: storageType
+      };
+    },
+    getInitialValue: function getInitialValue(value, _ref3) {
+      var sliceConfig = _ref3.sliceConfig,
+        key = _ref3.key;
+      var existingPersistedValue = getPersistedValue(key, sliceConfig.name);
+      if (existingPersistedValue !== undefined) {
+        return existingPersistedValue;
+      }
+      return value;
+    },
+    update: function update(value, _ref4) {
+      var key = _ref4.key,
+        sliceConfig = _ref4.sliceConfig;
+      storePersistedValue(key, sliceConfig.name, value, this.config.storageType !== undefined ? this.config.storageType : storageType);
+      return value;
+    }
+  };
+});
+
+export { index as default, getPersistedStore, getPersistedValue, storePersistedValue };

package/dist/plugins/persist/index.js

@@ -0,0 +1,71 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var PERSISTENCE_KEY = "astroglide-persist";
+var getPersistedStore = function getPersistedStore() {
+  var storage = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : localStorage;
+  var result = storage.getItem(PERSISTENCE_KEY);
+  return JSON.parse(result || "{}");
+};
+var storePersistedValue = function storePersistedValue(key, namespace, value) {
+  var storage = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : localStorage;
+  var store = getPersistedStore(storage);
+  if (namespace) {
+    store[namespace] = store[namespace] || {};
+    store[namespace][key] = value;
+  } else {
+    store[key] = value;
+  }
+  try {
+    storage.setItem(PERSISTENCE_KEY, JSON.stringify(store));
+  } catch (e) {
+    console.error(e);
+  }
+};
+var getPersistedValue = function getPersistedValue(key, namespace) {
+  var _scope2;
+  var storage = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : localStorage;
+  var scope = getPersistedStore(storage);
+  if (namespace) {
+    var _scope;
+    scope = (_scope = scope) === null || _scope === void 0 ? void 0 : _scope[namespace];
+  }
+  var retValue = (_scope2 = scope) === null || _scope2 === void 0 ? void 0 : _scope2[key];
+  console.log("retValue: ", retValue);
+  return retValue;
+};
+var index = (function () {
+  var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+    _ref$storageType = _ref.storageType,
+    storageType = _ref$storageType === void 0 ? localStorage : _ref$storageType;
+  return {
+    setup: function setup(plugin, _ref2) {
+      var sliceConfig = _ref2.sliceConfig;
+      return {
+        namespace: sliceConfig.name,
+        storageType: storageType
+      };
+    },
+    getInitialValue: function getInitialValue(value, _ref3) {
+      var sliceConfig = _ref3.sliceConfig,
+        key = _ref3.key;
+      var existingPersistedValue = getPersistedValue(key, sliceConfig.name);
+      if (existingPersistedValue !== undefined) {
+        return existingPersistedValue;
+      }
+      return value;
+    },
+    update: function update(value, _ref4) {
+      var key = _ref4.key,
+        sliceConfig = _ref4.sliceConfig;
+      storePersistedValue(key, sliceConfig.name, value, this.config.storageType !== undefined ? this.config.storageType : storageType);
+      return value;
+    }
+  };
+});
+
+exports["default"] = index;
+exports.getPersistedStore = getPersistedStore;
+exports.getPersistedValue = getPersistedValue;
+exports.storePersistedValue = storePersistedValue;

package/dist/plugins/persist/index.umd.js

@@ -0,0 +1,77 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+  typeof define === 'function' && define.amd ? define(['exports'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["redux-astroglide/plugins/persist"] = {}));
+})(this, (function (exports) { 'use strict';
+
+  var PERSISTENCE_KEY = "astroglide-persist";
+  var getPersistedStore = function getPersistedStore() {
+    var storage = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : localStorage;
+    var result = storage.getItem(PERSISTENCE_KEY);
+    return JSON.parse(result || "{}");
+  };
+  var storePersistedValue = function storePersistedValue(key, namespace, value) {
+    var storage = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : localStorage;
+    var store = getPersistedStore(storage);
+    if (namespace) {
+      store[namespace] = store[namespace] || {};
+      store[namespace][key] = value;
+    } else {
+      store[key] = value;
+    }
+    try {
+      storage.setItem(PERSISTENCE_KEY, JSON.stringify(store));
+    } catch (e) {
+      console.error(e);
+    }
+  };
+  var getPersistedValue = function getPersistedValue(key, namespace) {
+    var _scope2;
+    var storage = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : localStorage;
+    var scope = getPersistedStore(storage);
+    if (namespace) {
+      var _scope;
+      scope = (_scope = scope) === null || _scope === void 0 ? void 0 : _scope[namespace];
+    }
+    var retValue = (_scope2 = scope) === null || _scope2 === void 0 ? void 0 : _scope2[key];
+    console.log("retValue: ", retValue);
+    return retValue;
+  };
+  var index = (function () {
+    var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+      _ref$storageType = _ref.storageType,
+      storageType = _ref$storageType === void 0 ? localStorage : _ref$storageType;
+    return {
+      setup: function setup(plugin, _ref2) {
+        var sliceConfig = _ref2.sliceConfig;
+        return {
+          namespace: sliceConfig.name,
+          storageType: storageType
+        };
+      },
+      getInitialValue: function getInitialValue(value, _ref3) {
+        var sliceConfig = _ref3.sliceConfig,
+          key = _ref3.key;
+        var existingPersistedValue = getPersistedValue(key, sliceConfig.name);
+        if (existingPersistedValue !== undefined) {
+          return existingPersistedValue;
+        }
+        return value;
+      },
+      update: function update(value, _ref4) {
+        var key = _ref4.key,
+          sliceConfig = _ref4.sliceConfig;
+        storePersistedValue(key, sliceConfig.name, value, this.config.storageType !== undefined ? this.config.storageType : storageType);
+        return value;
+      }
+    };
+  });
+
+  exports["default"] = index;
+  exports.getPersistedStore = getPersistedStore;
+  exports.getPersistedValue = getPersistedValue;
+  exports.storePersistedValue = storePersistedValue;
+
+  Object.defineProperty(exports, '__esModule', { value: true });
+
+}));

package/dist/plugins/set/index.es.js

@@ -0,0 +1,17 @@
+var index = (function (callback) {
+  return {
+    constructor: function constructor(callback, value) {
+      this.value = value;
+      this.callback = callback;
+    },
+    update: function update(value, _ref) {
+      var draft = _ref.draft,
+        plugin = _ref.plugin;
+      return plugin.callback(value, {
+        draft: draft
+      });
+    }
+  };
+});
+
+export { index as default };

package/dist/plugins/set/index.js

@@ -0,0 +1,19 @@
+'use strict';
+
+var index = (function (callback) {
+  return {
+    constructor: function constructor(callback, value) {
+      this.value = value;
+      this.callback = callback;
+    },
+    update: function update(value, _ref) {
+      var draft = _ref.draft,
+        plugin = _ref.plugin;
+      return plugin.callback(value, {
+        draft: draft
+      });
+    }
+  };
+});
+
+module.exports = index;

package/dist/plugins/set/index.umd.js

@@ -0,0 +1,25 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+  typeof define === 'function' && define.amd ? define(factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global["redux-astroglide/plugins/set"] = factory());
+})(this, (function () { 'use strict';
+
+  var index = (function (callback) {
+    return {
+      constructor: function constructor(callback, value) {
+        this.value = value;
+        this.callback = callback;
+      },
+      update: function update(value, _ref) {
+        var draft = _ref.draft,
+          plugin = _ref.plugin;
+        return plugin.callback(value, {
+          draft: draft
+        });
+      }
+    };
+  });
+
+  return index;
+
+}));