@vve/immer 9.0.0-alpha.3 → 9.0.0-alpha.5

package/lib/immer.js

@@ -0,0 +1,272 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Immer = void 0;
+var legacyProxy = _interopRequireWildcard(require("./es5"));
+var modernProxy = _interopRequireWildcard(require("./proxy"));
+var _patches = require("./patches");
+var _common = require("./common");
+var _scope = require("./scope");
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+function verifyMinified() {}
+var configDefaults = {
+  useProxies: typeof Proxy !== "undefined" && typeof Reflect !== "undefined",
+  autoFreeze: typeof process !== "undefined" ? process.env.NODE_ENV !== "production" : verifyMinified.name === "verifyMinified",
+  onAssign: null,
+  onDelete: null,
+  onCopy: null
+};
+class Immer {
+  constructor(config) {
+    (0, _common.assign)(this, configDefaults, config);
+    this.setUseProxies(this.useProxies);
+    this.produce = this.produce.bind(this);
+  }
+  produce(base, recipe, patchListener) {
+    // curried invocation
+    if (typeof base === "function" && typeof recipe !== "function") {
+      var defaultBase = recipe;
+      recipe = base;
+      var self = this;
+      return function curriedProduce() {
+        var base = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : defaultBase;
+        for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+          args[_key - 1] = arguments[_key];
+        }
+        return self.produce(base, draft => recipe.call(this, draft, ...args)); // prettier-ignore
+      };
+    }
+
+    // prettier-ignore
+    {
+      if (typeof recipe !== "function") {
+        throw new Error("The first or second argument to `produce` must be a function");
+      }
+      if (patchListener !== undefined && typeof patchListener !== "function") {
+        throw new Error("The third argument to `produce` must be a function or undefined");
+      }
+    }
+    var result;
+
+    // Only plain objects, arrays, and "immerable classes" are drafted.
+    if ((0, _common.isDraftable)(base)) {
+      var scope = _scope.ImmerScope.enter();
+      var proxy = this.createProxy(base);
+      var hasError = true;
+      try {
+        result = recipe(proxy);
+        hasError = false;
+      } finally {
+        // finally instead of catch + rethrow better preserves original stack
+        if (hasError) scope.revoke();else scope.leave();
+      }
+      if (result instanceof Promise) {
+        return result.then(result => {
+          scope.usePatches(patchListener);
+          return this.processResult(result, scope);
+        }, error => {
+          scope.revoke();
+          throw error;
+        });
+      }
+      scope.usePatches(patchListener);
+      return this.processResult(result, scope);
+    } else {
+      result = recipe(base);
+      if (result === undefined) return base;
+      return result !== _common.NOTHING ? result : undefined;
+    }
+  }
+  createDraft(base) {
+    if (!(0, _common.isDraftable)(base)) {
+      throw new Error("First argument to `createDraft` must be a plain object, an array, or an immerable object"); // prettier-ignore
+    }
+
+    var scope = _scope.ImmerScope.enter();
+    var proxy = this.createProxy(base, null);
+    proxy[_common.DRAFT_STATE].isManual = true;
+    scope.leave();
+    return proxy;
+  }
+  finishDraft(draft, patchListener, keepAlive) {
+    var state = draft && draft[_common.DRAFT_STATE];
+    if (!state || !state.isManual) {
+      throw new Error("First argument to `finishDraft` must be a draft returned by `createDraft`"); // prettier-ignore
+    }
+
+    if (state.finalized) {
+      throw new Error("The given draft is already finalized"); // prettier-ignore
+    }
+
+    var scope = state.scope;
+    scope.usePatches(patchListener);
+    return this.processResult(undefined, scope, keepAlive);
+  }
+  setAutoFreeze(value) {
+    this.autoFreeze = value;
+  }
+  setUseProxies(value) {
+    this.useProxies = value;
+    (0, _common.assign)(this, value ? modernProxy : legacyProxy);
+  }
+  applyPatches(base, patches) {
+    // Mutate the base state when a draft is passed.
+    if ((0, _common.isDraft)(base)) {
+      return (0, _patches.applyPatches)(base, patches);
+    }
+    // Otherwise, produce a copy of the base state.
+    return this.produce(base, draft => (0, _patches.applyPatches)(draft, patches));
+  }
+  /** @internal */
+  processResult(result, scope, keepAlive) {
+    var baseDraft = scope.drafts[0];
+    var isReplaced = result !== undefined && result !== baseDraft;
+    this.willFinalize(scope, result, isReplaced);
+    if (isReplaced) {
+      if (baseDraft[_common.DRAFT_STATE].modified) {
+        scope.revoke(keepAlive);
+        throw new Error("An immer producer returned a new value *and* modified its draft. Either return a new value *or* modify the draft."); // prettier-ignore
+      }
+
+      if ((0, _common.isDraftable)(result)) {
+        // Finalize the result in case it contains (or is) a subset of the draft.
+        result = this.finalize(result, null, scope);
+      }
+      if (scope.patches) {
+        scope.patches.push({
+          op: "replace",
+          path: [],
+          value: result
+        });
+        scope.inversePatches.push({
+          op: "replace",
+          path: [],
+          value: baseDraft[_common.DRAFT_STATE].base
+        });
+      }
+    } else {
+      // Finalize the base draft.
+      result = this.finalize(baseDraft, [], scope, keepAlive);
+    }
+    scope.revoke(keepAlive);
+    if (scope.patches) {
+      scope.patchListener(scope.patches, scope.inversePatches);
+    }
+    return result !== _common.NOTHING ? result : undefined;
+  }
+  /**
+   * @internal
+   * Finalize a draft, returning either the unmodified base state or a modified
+   * copy of the base state.
+   */
+  finalize(draft, path, scope, keepAlive) {
+    var state = draft[_common.DRAFT_STATE];
+    if (!state) {
+      if (Object.isFrozen(draft)) return draft;
+      return this.finalizeTree(draft, null, scope);
+    }
+    // Never finalize drafts owned by another scope.
+    if (state.scope !== scope) {
+      return draft;
+    }
+    if (!state.modified) {
+      return state.base;
+    }
+    if (!state.finalized) {
+      if (!keepAlive) state.finalized = true;
+      this.finalizeTree(state.draft, path, scope);
+      if (this.onDelete) {
+        // The `assigned` object is unreliable with ES5 drafts.
+        if (this.useProxies) {
+          var assigned = state.assigned;
+          for (var prop in assigned) {
+            if (!assigned[prop]) this.onDelete(state, prop);
+          }
+        } else {
+          var base = state.base,
+            copy = state.copy;
+          (0, _common.each)(base, prop => {
+            if (!(0, _common.has)(copy, prop)) this.onDelete(state, prop);
+          });
+        }
+      }
+      if (this.onCopy) {
+        this.onCopy(state);
+      }
+
+      // At this point, all descendants of `state.copy` have been finalized,
+      // so we can be sure that `scope.canAutoFreeze` is accurate.
+      if (this.autoFreeze && scope.canAutoFreeze) {
+        Object.freeze(state.copy);
+      }
+      if (path && scope.patches) {
+        (0, _patches.generatePatches)(state, path, scope.patches, scope.inversePatches);
+      }
+    }
+    return state.copy;
+  }
+  /**
+   * @internal
+   * Finalize all drafts in the given state tree.
+   */
+  finalizeTree(root, rootPath, scope) {
+    var state = root[_common.DRAFT_STATE];
+    if (state) {
+      if (!this.useProxies) {
+        // Create the final copy, with added keys and without deleted keys.
+        state.copy = (0, _common.shallowCopy)(state.draft, true);
+      }
+      root = state.copy;
+    }
+    var needPatches = !!rootPath && !!scope.patches;
+    var finalizeProperty = (prop, value, parent) => {
+      if (value === parent) {
+        throw Error("Immer forbids circular references");
+      }
+
+      // In the `finalizeTree` method, only the `root` object may be a draft.
+      var isDraftProp = !!state && parent === root;
+      if ((0, _common.isDraft)(value)) {
+        var path = isDraftProp && needPatches && !state.assigned[prop] ? rootPath.concat(prop) : null;
+
+        // Drafts owned by `scope` are finalized here.
+        value = this.finalize(value, path, scope);
+
+        // Drafts from another scope must prevent auto-freezing.
+        if ((0, _common.isDraft)(value)) {
+          scope.canAutoFreeze = false;
+        }
+
+        // Preserve non-enumerable properties.
+        if (Array.isArray(parent) || (0, _common.isEnumerable)(parent, prop)) {
+          parent[prop] = value;
+        } else {
+          Object.defineProperty(parent, prop, {
+            value
+          });
+        }
+
+        // Unchanged drafts are never passed to the `onAssign` hook.
+        if (isDraftProp && value === state.base[prop]) return;
+      }
+      // Unchanged draft properties are ignored.
+      else if (isDraftProp && (0, _common.is)(value, state.base[prop])) {
+        return;
+      }
+      // Search new objects for unfinalized drafts. Frozen objects should never contain drafts.
+      else if ((0, _common.isDraftable)(value) && !Object.isFrozen(value)) {
+        (0, _common.each)(value, finalizeProperty);
+      }
+      if (isDraftProp && this.onAssign) {
+        this.onAssign(state, prop, value);
+      }
+    };
+    (0, _common.each)(root, finalizeProperty);
+    return root;
+  }
+}
+exports.Immer = Immer;
+//# sourceMappingURL=immer.js.map

package/lib/immer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"immer.js","names":["legacyProxy","_interopRequireWildcard","require","modernProxy","_patches","_common","_scope","_getRequireWildcardCache","nodeInterop","WeakMap","cacheBabelInterop","cacheNodeInterop","obj","__esModule","default","cache","has","get","newObj","hasPropertyDescriptor","Object","defineProperty","getOwnPropertyDescriptor","key","prototype","hasOwnProperty","call","desc","set","verifyMinified","configDefaults","useProxies","Proxy","Reflect","autoFreeze","process","env","NODE_ENV","name","onAssign","onDelete","onCopy","Immer","constructor","config","assign","setUseProxies","produce","bind","base","recipe","patchListener","defaultBase","self","curriedProduce","arguments","length","undefined","_len","args","Array","_key","draft","Error","result","isDraftable","scope","ImmerScope","enter","proxy","createProxy","hasError","revoke","leave","Promise","then","usePatches","processResult","error","NOTHING","createDraft","DRAFT_STATE","isManual","finishDraft","keepAlive","state","finalized","setAutoFreeze","value","applyPatches","patches","isDraft","baseDraft","drafts","isReplaced","willFinalize","modified","finalize","push","op","path","inversePatches","isFrozen","finalizeTree","assigned","prop","copy","each","canAutoFreeze","freeze","generatePatches","root","rootPath","shallowCopy","needPatches","finalizeProperty","parent","isDraftProp","concat","isArray","isEnumerable","is","exports"],"sources":["../immer.js"],"sourcesContent":["import * as legacyProxy from \"./es5\"\nimport * as modernProxy from \"./proxy\"\nimport {applyPatches, generatePatches} from \"./patches\"\nimport {\n    assign,\n    each,\n    has,\n    is,\n    isDraft,\n    isDraftable,\n    isEnumerable,\n    shallowCopy,\n    DRAFT_STATE,\n    NOTHING\n} from \"./common\"\nimport {ImmerScope} from \"./scope\"\n\nfunction verifyMinified() {}\n\nconst configDefaults = {\n    useProxies: typeof Proxy !== \"undefined\" && typeof Reflect !== \"undefined\",\n    autoFreeze:\n        typeof process !== \"undefined\"\n            ? process.env.NODE_ENV !== \"production\"\n            : verifyMinified.name === \"verifyMinified\",\n    onAssign: null,\n    onDelete: null,\n    onCopy: null\n}\n\nexport class Immer {\n    constructor(config) {\n        assign(this, configDefaults, config)\n        this.setUseProxies(this.useProxies)\n        this.produce = this.produce.bind(this)\n    }\n    produce(base, recipe, patchListener) {\n        // curried invocation\n        if (typeof base === \"function\" && typeof recipe !== \"function\") {\n            const defaultBase = recipe\n            recipe = base\n\n            const self = this\n            return function curriedProduce(base = defaultBase, ...args) {\n                return self.produce(base, draft => recipe.call(this, draft, ...args)) // prettier-ignore\n            }\n        }\n\n        // prettier-ignore\n        {\n            if (typeof recipe !== \"function\") {\n                throw new Error(\"The first or second argument to `produce` must be a function\")\n            }\n            if (patchListener !== undefined && typeof patchListener !== \"function\") {\n                throw new Error(\"The third argument to `produce` must be a function or undefined\")\n            }\n        }\n\n        let result\n\n        // Only plain objects, arrays, and \"immerable classes\" are drafted.\n        if (isDraftable(base)) {\n            const scope = ImmerScope.enter()\n            const proxy = this.createProxy(base)\n            let hasError = true\n            try {\n                result = recipe(proxy)\n                hasError = false\n            } finally {\n                // finally instead of catch + rethrow better preserves original stack\n                if (hasError) scope.revoke()\n                else scope.leave()\n            }\n            if (result instanceof Promise) {\n                return result.then(\n                    result => {\n                        scope.usePatches(patchListener)\n                        return this.processResult(result, scope)\n                    },\n                    error => {\n                        scope.revoke()\n                        throw error\n                    }\n                )\n            }\n            scope.usePatches(patchListener)\n            return this.processResult(result, scope)\n        } else {\n            result = recipe(base)\n            if (result === undefined) return base\n            return result !== NOTHING ? result : undefined\n        }\n    }\n    createDraft(base) {\n        if (!isDraftable(base)) {\n            throw new Error(\"First argument to `createDraft` must be a plain object, an array, or an immerable object\") // prettier-ignore\n        }\n        const scope = ImmerScope.enter()\n        const proxy = this.createProxy(base, null)\n        proxy[DRAFT_STATE].isManual = true\n        scope.leave()\n        return proxy\n    }\n    finishDraft(draft, patchListener, keepAlive) {\n        const state = draft && draft[DRAFT_STATE]\n        if (!state || !state.isManual) {\n            throw new Error(\"First argument to `finishDraft` must be a draft returned by `createDraft`\") // prettier-ignore\n        }\n        if (state.finalized) {\n            throw new Error(\"The given draft is already finalized\") // prettier-ignore\n        }\n        const {scope} = state\n        scope.usePatches(patchListener)\n        return this.processResult(undefined, scope, keepAlive)\n    }\n    setAutoFreeze(value) {\n        this.autoFreeze = value\n    }\n    setUseProxies(value) {\n        this.useProxies = value\n        assign(this, value ? modernProxy : legacyProxy)\n    }\n    applyPatches(base, patches) {\n        // Mutate the base state when a draft is passed.\n        if (isDraft(base)) {\n            return applyPatches(base, patches)\n        }\n        // Otherwise, produce a copy of the base state.\n        return this.produce(base, draft => applyPatches(draft, patches))\n    }\n    /** @internal */\n    processResult(result, scope, keepAlive) {\n        const baseDraft = scope.drafts[0]\n        const isReplaced = result !== undefined && result !== baseDraft\n        this.willFinalize(scope, result, isReplaced)\n        if (isReplaced) {\n            if (baseDraft[DRAFT_STATE].modified) {\n                scope.revoke(keepAlive)\n                throw new Error(\"An immer producer returned a new value *and* modified its draft. Either return a new value *or* modify the draft.\") // prettier-ignore\n            }\n            if (isDraftable(result)) {\n                // Finalize the result in case it contains (or is) a subset of the draft.\n                result = this.finalize(result, null, scope)\n            }\n            if (scope.patches) {\n                scope.patches.push({\n                    op: \"replace\",\n                    path: [],\n                    value: result\n                })\n                scope.inversePatches.push({\n                    op: \"replace\",\n                    path: [],\n                    value: baseDraft[DRAFT_STATE].base\n                })\n            }\n        } else {\n            // Finalize the base draft.\n            result = this.finalize(baseDraft, [], scope, keepAlive)\n        }\n        scope.revoke(keepAlive)\n        if (scope.patches) {\n            scope.patchListener(scope.patches, scope.inversePatches)\n        }\n        return result !== NOTHING ? result : undefined\n    }\n    /**\n     * @internal\n     * Finalize a draft, returning either the unmodified base state or a modified\n     * copy of the base state.\n     */\n    finalize(draft, path, scope, keepAlive) {\n        const state = draft[DRAFT_STATE]\n        if (!state) {\n            if (Object.isFrozen(draft)) return draft\n            return this.finalizeTree(draft, null, scope)\n        }\n        // Never finalize drafts owned by another scope.\n        if (state.scope !== scope) {\n            return draft\n        }\n        if (!state.modified) {\n            return state.base\n        }\n        if (!state.finalized) {\n            if (!keepAlive) state.finalized = true\n            this.finalizeTree(state.draft, path, scope)\n\n            if (this.onDelete) {\n                // The `assigned` object is unreliable with ES5 drafts.\n                if (this.useProxies) {\n                    const {assigned} = state\n                    for (const prop in assigned) {\n                        if (!assigned[prop]) this.onDelete(state, prop)\n                    }\n                } else {\n                    const {base, copy} = state\n                    each(base, prop => {\n                        if (!has(copy, prop)) this.onDelete(state, prop)\n                    })\n                }\n            }\n            if (this.onCopy) {\n                this.onCopy(state)\n            }\n\n            // At this point, all descendants of `state.copy` have been finalized,\n            // so we can be sure that `scope.canAutoFreeze` is accurate.\n            if (this.autoFreeze && scope.canAutoFreeze) {\n                Object.freeze(state.copy)\n            }\n\n            if (path && scope.patches) {\n                generatePatches(\n                    state,\n                    path,\n                    scope.patches,\n                    scope.inversePatches\n                )\n            }\n        }\n        return state.copy\n    }\n    /**\n     * @internal\n     * Finalize all drafts in the given state tree.\n     */\n    finalizeTree(root, rootPath, scope) {\n        const state = root[DRAFT_STATE]\n        if (state) {\n            if (!this.useProxies) {\n                // Create the final copy, with added keys and without deleted keys.\n                state.copy = shallowCopy(state.draft, true)\n            }\n            root = state.copy\n        }\n\n        const needPatches = !!rootPath && !!scope.patches\n        const finalizeProperty = (prop, value, parent) => {\n            if (value === parent) {\n                throw Error(\"Immer forbids circular references\")\n            }\n\n            // In the `finalizeTree` method, only the `root` object may be a draft.\n            const isDraftProp = !!state && parent === root\n\n            if (isDraft(value)) {\n                const path =\n                    isDraftProp && needPatches && !state.assigned[prop]\n                        ? rootPath.concat(prop)\n                        : null\n\n                // Drafts owned by `scope` are finalized here.\n                value = this.finalize(value, path, scope)\n\n                // Drafts from another scope must prevent auto-freezing.\n                if (isDraft(value)) {\n                    scope.canAutoFreeze = false\n                }\n\n                // Preserve non-enumerable properties.\n                if (Array.isArray(parent) || isEnumerable(parent, prop)) {\n                    parent[prop] = value\n                } else {\n                    Object.defineProperty(parent, prop, {value})\n                }\n\n                // Unchanged drafts are never passed to the `onAssign` hook.\n                if (isDraftProp && value === state.base[prop]) return\n            }\n            // Unchanged draft properties are ignored.\n            else if (isDraftProp && is(value, state.base[prop])) {\n                return\n            }\n            // Search new objects for unfinalized drafts. Frozen objects should never contain drafts.\n            else if (isDraftable(value) && !Object.isFrozen(value)) {\n                each(value, finalizeProperty)\n            }\n\n            if (isDraftProp && this.onAssign) {\n                this.onAssign(state, prop, value)\n            }\n        }\n\n        each(root, finalizeProperty)\n        return root\n    }\n}\n"],"mappings":"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"}

package/lib/index.js

@@ -0,0 +1,119 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "DRAFT_STATE", {
+  enumerable: true,
+  get: function get() {
+    return _common.DRAFT_STATE;
+  }
+});
+Object.defineProperty(exports, "Immer", {
+  enumerable: true,
+  get: function get() {
+    return _immer.Immer;
+  }
+});
+exports.finishDraft = exports.default = exports.createDraft = exports.applyPatches = void 0;
+Object.defineProperty(exports, "immerable", {
+  enumerable: true,
+  get: function get() {
+    return _common.DRAFTABLE;
+  }
+});
+Object.defineProperty(exports, "isDraft", {
+  enumerable: true,
+  get: function get() {
+    return _common.isDraft;
+  }
+});
+Object.defineProperty(exports, "isDraftable", {
+  enumerable: true,
+  get: function get() {
+    return _common.isDraftable;
+  }
+});
+Object.defineProperty(exports, "nothing", {
+  enumerable: true,
+  get: function get() {
+    return _common.NOTHING;
+  }
+});
+Object.defineProperty(exports, "original", {
+  enumerable: true,
+  get: function get() {
+    return _common.original;
+  }
+});
+exports.setUseProxies = exports.setAutoFreeze = exports.produce = void 0;
+var _immer = require("./immer");
+var _common = require("./common");
+var immer = new _immer.Immer();
+
+/**
+ * The `produce` function takes a value and a "recipe function" (whose
+ * return value often depends on the base state). The recipe function is
+ * free to mutate its first argument however it wants. All mutations are
+ * only ever applied to a __copy__ of the base state.
+ *
+ * Pass only a function to create a "curried producer" which relieves you
+ * from passing the recipe function every time.
+ *
+ * Only plain objects and arrays are made mutable. All other objects are
+ * considered uncopyable.
+ *
+ * Note: This function is __bound__ to its `Immer` instance.
+ *
+ * @param {any} base - the initial state
+ * @param {Function} producer - function that receives a proxy of the base state as first argument and which can be freely modified
+ * @param {Function} patchListener - optional function that will be called with all the patches produced here
+ * @returns {any} a new state, or the initial state if nothing was modified
+ */
+var produce = immer.produce;
+exports.produce = produce;
+var _default = produce;
+/**
+ * Pass true to automatically freeze all copies created by Immer.
+ *
+ * By default, auto-freezing is disabled in production.
+ */
+exports.default = _default;
+var setAutoFreeze = immer.setAutoFreeze.bind(immer);
+
+/**
+ * Pass true to use the ES2015 `Proxy` class when creating drafts, which is
+ * always faster than using ES5 proxies.
+ *
+ * By default, feature detection is used, so calling this is rarely necessary.
+ */
+exports.setAutoFreeze = setAutoFreeze;
+var setUseProxies = immer.setUseProxies.bind(immer);
+
+/**
+ * Apply an array of Immer patches to the first argument.
+ *
+ * This function is a producer, which means copy-on-write is in effect.
+ */
+exports.setUseProxies = setUseProxies;
+var applyPatches = immer.applyPatches.bind(immer);
+
+/**
+ * Create an Immer draft from the given base state, which may be a draft itself.
+ * The draft can be modified until you finalize it with the `finishDraft` function.
+ */
+exports.applyPatches = applyPatches;
+var createDraft = immer.createDraft.bind(immer);
+
+/**
+ * Finalize an Immer draft from a `createDraft` call, returning the base state
+ * (if no changes were made) or a modified copy. The draft must *not* be
+ * mutated afterwards.
+ *
+ * Pass a function as the 2nd argument to generate Immer patches based on the
+ * changes that were made.
+ */
+exports.createDraft = createDraft;
+var finishDraft = immer.finishDraft.bind(immer);
+exports.finishDraft = finishDraft;
+//# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["_immer","require","_common","immer","Immer","produce","exports","_default","default","setAutoFreeze","bind","setUseProxies","applyPatches","createDraft","finishDraft"],"sources":["../index.js"],"sourcesContent":["import {Immer} from \"./immer\"\n\nconst immer = new Immer()\n\n/**\n * The `produce` function takes a value and a \"recipe function\" (whose\n * return value often depends on the base state). The recipe function is\n * free to mutate its first argument however it wants. All mutations are\n * only ever applied to a __copy__ of the base state.\n *\n * Pass only a function to create a \"curried producer\" which relieves you\n * from passing the recipe function every time.\n *\n * Only plain objects and arrays are made mutable. All other objects are\n * considered uncopyable.\n *\n * Note: This function is __bound__ to its `Immer` instance.\n *\n * @param {any} base - the initial state\n * @param {Function} producer - function that receives a proxy of the base state as first argument and which can be freely modified\n * @param {Function} patchListener - optional function that will be called with all the patches produced here\n * @returns {any} a new state, or the initial state if nothing was modified\n */\nexport const produce = immer.produce\nexport default produce\n\n/**\n * Pass true to automatically freeze all copies created by Immer.\n *\n * By default, auto-freezing is disabled in production.\n */\nexport const setAutoFreeze = immer.setAutoFreeze.bind(immer)\n\n/**\n * Pass true to use the ES2015 `Proxy` class when creating drafts, which is\n * always faster than using ES5 proxies.\n *\n * By default, feature detection is used, so calling this is rarely necessary.\n */\nexport const setUseProxies = immer.setUseProxies.bind(immer)\n\n/**\n * Apply an array of Immer patches to the first argument.\n *\n * This function is a producer, which means copy-on-write is in effect.\n */\nexport const applyPatches = immer.applyPatches.bind(immer)\n\n/**\n * Create an Immer draft from the given base state, which may be a draft itself.\n * The draft can be modified until you finalize it with the `finishDraft` function.\n */\nexport const createDraft = immer.createDraft.bind(immer)\n\n/**\n * Finalize an Immer draft from a `createDraft` call, returning the base state\n * (if no changes were made) or a modified copy. The draft must *not* be\n * mutated afterwards.\n *\n * Pass a function as the 2nd argument to generate Immer patches based on the\n * changes that were made.\n */\nexport const finishDraft = immer.finishDraft.bind(immer)\n\nexport {\n    original,\n    isDraft,\n    isDraftable,\n    NOTHING as nothing,\n    DRAFTABLE as immerable,\n    DRAFT_STATE\n} from \"./common\"\n\nexport {Immer}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAgEA,IAAAC,OAAA,GAAAD,OAAA;AA9DA,IAAME,KAAK,GAAG,IAAIC,YAAK,EAAE;;AAEzB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,IAAMC,OAAO,GAAGF,KAAK,CAACE,OAAO;AAAAC,OAAA,CAAAD,OAAA,GAAAA,OAAA;AAAA,IAAAE,QAAA,GACrBF,OAAO;AAEtB;AACA;AACA;AACA;AACA;AAJAC,OAAA,CAAAE,OAAA,GAAAD,QAAA;AAKO,IAAME,aAAa,GAAGN,KAAK,CAACM,aAAa,CAACC,IAAI,CAACP,KAAK,CAAC;;AAE5D;AACA;AACA;AACA;AACA;AACA;AALAG,OAAA,CAAAG,aAAA,GAAAA,aAAA;AAMO,IAAME,aAAa,GAAGR,KAAK,CAACQ,aAAa,CAACD,IAAI,CAACP,KAAK,CAAC;;AAE5D;AACA;AACA;AACA;AACA;AAJAG,OAAA,CAAAK,aAAA,GAAAA,aAAA;AAKO,IAAMC,YAAY,GAAGT,KAAK,CAACS,YAAY,CAACF,IAAI,CAACP,KAAK,CAAC;;AAE1D;AACA;AACA;AACA;AAHAG,OAAA,CAAAM,YAAA,GAAAA,YAAA;AAIO,IAAMC,WAAW,GAAGV,KAAK,CAACU,WAAW,CAACH,IAAI,CAACP,KAAK,CAAC;;AAExD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAPAG,OAAA,CAAAO,WAAA,GAAAA,WAAA;AAQO,IAAMC,WAAW,GAAGX,KAAK,CAACW,WAAW,CAACJ,IAAI,CAACP,KAAK,CAAC;AAAAG,OAAA,CAAAQ,WAAA,GAAAA,WAAA"}

package/lib/patches.js

@@ -0,0 +1,156 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.applyPatches = applyPatches;
+exports.generatePatches = generatePatches;
+var _common = require("./common");
+function generatePatches(state, basePath, patches, inversePatches) {
+  Array.isArray(state.base) ? generateArrayPatches(state, basePath, patches, inversePatches) : generateObjectPatches(state, basePath, patches, inversePatches);
+}
+function generateArrayPatches(state, basePath, patches, inversePatches) {
+  var base = state.base,
+    copy = state.copy,
+    assigned = state.assigned;
+
+  // Reduce complexity by ensuring `base` is never longer.
+  if (copy.length < base.length) {
+    ;
+    var _ref = [copy, base];
+    base = _ref[0];
+    copy = _ref[1];
+    var _ref2 = [inversePatches, patches];
+    patches = _ref2[0];
+    inversePatches = _ref2[1];
+  }
+  var delta = copy.length - base.length;
+
+  // Find the first replaced index.
+  var start = 0;
+  while (base[start] === copy[start] && start < base.length) {
+    ++start;
+  }
+
+  // Find the last replaced index. Search from the end to optimize splice patches.
+  var end = base.length;
+  while (end > start && base[end - 1] === copy[end + delta - 1]) {
+    --end;
+  }
+
+  // Process replaced indices.
+  for (var i = start; i < end; ++i) {
+    if (assigned[i] && copy[i] !== base[i]) {
+      var path = basePath.concat([i]);
+      patches.push({
+        op: "replace",
+        path,
+        value: copy[i]
+      });
+      inversePatches.push({
+        op: "replace",
+        path,
+        value: base[i]
+      });
+    }
+  }
+  var useRemove = end != base.length;
+  var replaceCount = patches.length;
+
+  // Process added indices.
+  for (var _i = end + delta - 1; _i >= end; --_i) {
+    var _path = basePath.concat([_i]);
+    patches[replaceCount + _i - end] = {
+      op: "add",
+      path: _path,
+      value: copy[_i]
+    };
+    if (useRemove) {
+      inversePatches.push({
+        op: "remove",
+        path: _path
+      });
+    }
+  }
+
+  // One "replace" patch reverses all non-splicing "add" patches.
+  if (!useRemove) {
+    inversePatches.push({
+      op: "replace",
+      path: basePath.concat(["length"]),
+      value: base.length
+    });
+  }
+}
+function generateObjectPatches(state, basePath, patches, inversePatches) {
+  var base = state.base,
+    copy = state.copy;
+  (0, _common.each)(state.assigned, (key, assignedValue) => {
+    var origValue = base[key];
+    var value = copy[key];
+    var op = !assignedValue ? "remove" : key in base ? "replace" : "add";
+    if (origValue === value && op === "replace") return;
+    var path = basePath.concat(key);
+    patches.push(op === "remove" ? {
+      op,
+      path
+    } : {
+      op,
+      path,
+      value
+    });
+    inversePatches.push(op === "add" ? {
+      op: "remove",
+      path
+    } : op === "remove" ? {
+      op: "add",
+      path,
+      value: origValue
+    } : {
+      op: "replace",
+      path,
+      value: origValue
+    });
+  });
+}
+function applyPatches(draft, patches) {
+  for (var i = 0; i < patches.length; i++) {
+    var patch = patches[i];
+    var path = patch.path;
+    if (path.length === 0 && patch.op === "replace") {
+      draft = patch.value;
+    } else {
+      var base = draft;
+      for (var _i2 = 0; _i2 < path.length - 1; _i2++) {
+        base = base[path[_i2]];
+        if (!base || typeof base !== "object") throw new Error("Cannot apply patch, path doesn't resolve: " + path.join("/")); // prettier-ignore
+      }
+
+      var key = path[path.length - 1];
+      switch (patch.op) {
+        case "replace":
+          base[key] = patch.value;
+          break;
+        case "add":
+          if (Array.isArray(base)) {
+            // TODO: support "foo/-" paths for appending to an array
+            base.splice(key, 0, patch.value);
+          } else {
+            base[key] = patch.value;
+          }
+          break;
+        case "remove":
+          if (Array.isArray(base)) {
+            base.splice(key, 1);
+          } else {
+            delete base[key];
+          }
+          break;
+        default:
+          throw new Error("Unsupported patch operation: " + patch.op);
+      }
+    }
+  }
+  return draft;
+}
+//# sourceMappingURL=patches.js.map

package/lib/patches.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"patches.js","names":["_common","require","generatePatches","state","basePath","patches","inversePatches","Array","isArray","base","generateArrayPatches","generateObjectPatches","copy","assigned","length","_ref","_ref2","delta","start","end","i","path","concat","push","op","value","useRemove","replaceCount","each","key","assignedValue","origValue","applyPatches","draft","patch","Error","join","splice"],"sources":["../patches.js"],"sourcesContent":["import {each} from \"./common\"\n\nexport function generatePatches(state, basePath, patches, inversePatches) {\n    Array.isArray(state.base)\n        ? generateArrayPatches(state, basePath, patches, inversePatches)\n        : generateObjectPatches(state, basePath, patches, inversePatches)\n}\n\nfunction generateArrayPatches(state, basePath, patches, inversePatches) {\n    let {base, copy, assigned} = state\n\n    // Reduce complexity by ensuring `base` is never longer.\n    if (copy.length < base.length) {\n        ;[base, copy] = [copy, base]\n        ;[patches, inversePatches] = [inversePatches, patches]\n    }\n\n    const delta = copy.length - base.length\n\n    // Find the first replaced index.\n    let start = 0\n    while (base[start] === copy[start] && start < base.length) {\n        ++start\n    }\n\n    // Find the last replaced index. Search from the end to optimize splice patches.\n    let end = base.length\n    while (end > start && base[end - 1] === copy[end + delta - 1]) {\n        --end\n    }\n\n    // Process replaced indices.\n    for (let i = start; i < end; ++i) {\n        if (assigned[i] && copy[i] !== base[i]) {\n            const path = basePath.concat([i])\n            patches.push({\n                op: \"replace\",\n                path,\n                value: copy[i]\n            })\n            inversePatches.push({\n                op: \"replace\",\n                path,\n                value: base[i]\n            })\n        }\n    }\n\n    const useRemove = end != base.length\n    const replaceCount = patches.length\n\n    // Process added indices.\n    for (let i = end + delta - 1; i >= end; --i) {\n        const path = basePath.concat([i])\n        patches[replaceCount + i - end] = {\n            op: \"add\",\n            path,\n            value: copy[i]\n        }\n        if (useRemove) {\n            inversePatches.push({\n                op: \"remove\",\n                path\n            })\n        }\n    }\n\n    // One \"replace\" patch reverses all non-splicing \"add\" patches.\n    if (!useRemove) {\n        inversePatches.push({\n            op: \"replace\",\n            path: basePath.concat([\"length\"]),\n            value: base.length\n        })\n    }\n}\n\nfunction generateObjectPatches(state, basePath, patches, inversePatches) {\n    const {base, copy} = state\n    each(state.assigned, (key, assignedValue) => {\n        const origValue = base[key]\n        const value = copy[key]\n        const op = !assignedValue ? \"remove\" : key in base ? \"replace\" : \"add\"\n        if (origValue === value && op === \"replace\") return\n        const path = basePath.concat(key)\n        patches.push(op === \"remove\" ? {op, path} : {op, path, value})\n        inversePatches.push(\n            op === \"add\"\n                ? {op: \"remove\", path}\n                : op === \"remove\"\n                ? {op: \"add\", path, value: origValue}\n                : {op: \"replace\", path, value: origValue}\n        )\n    })\n}\n\nexport function applyPatches(draft, patches) {\n    for (let i = 0; i < patches.length; i++) {\n        const patch = patches[i]\n        const {path} = patch\n        if (path.length === 0 && patch.op === \"replace\") {\n            draft = patch.value\n        } else {\n            let base = draft\n            for (let i = 0; i < path.length - 1; i++) {\n                base = base[path[i]]\n                if (!base || typeof base !== \"object\")\n                    throw new Error(\"Cannot apply patch, path doesn't resolve: \" + path.join(\"/\")) // prettier-ignore\n            }\n            const key = path[path.length - 1]\n            switch (patch.op) {\n                case \"replace\":\n                    base[key] = patch.value\n                    break\n                case \"add\":\n                    if (Array.isArray(base)) {\n                        // TODO: support \"foo/-\" paths for appending to an array\n                        base.splice(key, 0, patch.value)\n                    } else {\n                        base[key] = patch.value\n                    }\n                    break\n                case \"remove\":\n                    if (Array.isArray(base)) {\n                        base.splice(key, 1)\n                    } else {\n                        delete base[key]\n                    }\n                    break\n                default:\n                    throw new Error(\"Unsupported patch operation: \" + patch.op)\n            }\n        }\n    }\n    return draft\n}\n"],"mappings":"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"}