mobx-keystone 0.67.4 → 0.68.1-alpha

package/dist/src/actionMiddlewares/actionSerialization/applySerializedAction.mjs

@@ -0,0 +1,110 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+import { runInAction } from "mobx";
+import { applyAction } from "../../action/applyAction.mjs";
+import { frozenKey } from "../../frozen/Frozen.mjs";
+import { getModelIdPropertyName } from "../../model/getModelMetadata.mjs";
+import { isModel } from "../../model/utils.mjs";
+import { resolvePath } from "../../parent/path.mjs";
+import { applyPatches } from "../../patch/applyPatches.mjs";
+import { onPatches } from "../../patch/emitPatch.mjs";
+import { assertTweakedObject } from "../../tweaker/core.mjs";
+import { failure, isObject } from "../../utils/index.mjs";
+import { deserializeActionCall } from "./actionSerialization.mjs";
+function applySerializedActionAndTrackNewModelIds(subtreeRoot, call) {
+  if (!call.serialized) {
+    throw failure("cannot apply a non-serialized action call, use 'applyAction' instead");
+  }
+  assertTweakedObject(subtreeRoot, "subtreeRoot");
+  const deserializedCall = deserializeActionCall(call, subtreeRoot);
+  const modelIdOverrides = [];
+  const patchDisposer = onPatches(subtreeRoot, (patches) => {
+    scanPatchesForModelIdChanges(subtreeRoot, modelIdOverrides, patches);
+  });
+  try {
+    const returnValue = applyAction(subtreeRoot, deserializedCall);
+    return {
+      returnValue,
+      serializedActionCall: __spreadProps(__spreadValues({}, call), {
+        modelIdOverrides
+      })
+    };
+  } finally {
+    patchDisposer();
+  }
+}
+function scanPatchesForModelIdChanges(root, modelIdOverrides, patches) {
+  const len = patches.length;
+  for (let i = 0; i < len; i++) {
+    const patch = patches[i];
+    if (patch.op === "replace" || patch.op === "add") {
+      deepScanValueForModelIdChanges(root, modelIdOverrides, patch.value, patch.path);
+    }
+  }
+}
+function deepScanValueForModelIdChanges(root, modelIdOverrides, value, path) {
+  if (path.length >= 1 && typeof value === "string") {
+    const parent = resolvePath(root, path.slice(0, path.length - 1)).value;
+    if (isModel(parent)) {
+      const propertyName = path[path.length - 1];
+      if (propertyName === getModelIdPropertyName(parent.constructor)) {
+        modelIdOverrides.push({
+          op: "replace",
+          path: path.slice(),
+          value
+        });
+      }
+    }
+  } else if (Array.isArray(value)) {
+    const len = value.length;
+    for (let i = 0; i < len; i++) {
+      path.push(i);
+      deepScanValueForModelIdChanges(root, modelIdOverrides, value[i], path);
+      path.pop();
+    }
+  } else if (isObject(value)) {
+    if (!value[frozenKey]) {
+      const keys = Object.keys(value);
+      const len = keys.length;
+      for (let i = 0; i < len; i++) {
+        const propName = keys[i];
+        const propValue = value[propName];
+        path.push(propName);
+        deepScanValueForModelIdChanges(root, modelIdOverrides, propValue, path);
+        path.pop();
+      }
+    }
+  }
+}
+function applySerializedActionAndSyncNewModelIds(subtreeRoot, call) {
+  if (!call.serialized) {
+    throw failure("cannot apply a non-serialized action call, use 'applyAction' instead");
+  }
+  assertTweakedObject(subtreeRoot, "subtreeRoot");
+  const deserializedCall = deserializeActionCall(call, subtreeRoot);
+  let returnValue;
+  runInAction(() => {
+    returnValue = applyAction(subtreeRoot, deserializedCall);
+    applyPatches(subtreeRoot, call.modelIdOverrides);
+  });
+  return returnValue;
+}
+export { applySerializedActionAndSyncNewModelIds, applySerializedActionAndTrackNewModelIds };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"applySerializedAction.mjs","sources":["../../../../src/actionMiddlewares/actionSerialization/applySerializedAction.ts"],"sourcesContent":["import { runInAction } from \"mobx\"\nimport { applyAction } from \"../../action/applyAction\"\nimport { frozenKey } from \"../../frozen/Frozen\"\nimport { getModelIdPropertyName } from \"../../model/getModelMetadata\"\nimport { isModel } from \"../../model/utils\"\nimport { resolvePath } from \"../../parent/path\"\nimport type { WritablePath } from \"../../parent/pathTypes\"\nimport { applyPatches } from \"../../patch/applyPatches\"\nimport { onPatches } from \"../../patch/emitPatch\"\nimport type { Patch } from \"../../patch/Patch\"\nimport { assertTweakedObject } from \"../../tweaker/core\"\nimport { failure, isObject } from \"../../utils\"\nimport { deserializeActionCall, SerializedActionCall } from \"./actionSerialization\"\n\n/**\n * Serialized action call with model ID overrides.\n * Can be generated with `applySerializedActionAndTrackNewModelIds`.\n * To be applied with `applySerializedActionAndSyncNewModelIds`.\n */\nexport interface SerializedActionCallWithModelIdOverrides extends SerializedActionCall {\n  /**\n   * Model Id overrides to be applied at the end of applying the action.\n   */\n  readonly modelIdOverrides: ReadonlyArray<Patch>\n}\n\n/**\n * Applies (runs) a serialized action over a target object.\n * In this mode newly generated / modified model IDs will be tracked\n * so they can be later synchronized when applying it on another machine\n * via `applySerializedActionAndSyncNewModelIds`.\n * This means this method is usually used on the server side.\n *\n * If you intend to apply non-serialized actions check `applyAction` instead.\n *\n * @param subtreeRoot Subtree root target object to run the action over.\n * @param call The serialized action, usually as coming from the server/client.\n * @returns The return value of the action, if any, plus a new serialized action\n * with model overrides.\n */\nexport function applySerializedActionAndTrackNewModelIds<TRet = any>(\n  subtreeRoot: object,\n  call: SerializedActionCall\n): {\n  returnValue: TRet\n  serializedActionCall: SerializedActionCallWithModelIdOverrides\n} {\n  if (!call.serialized) {\n    throw failure(\"cannot apply a non-serialized action call, use 'applyAction' instead\")\n  }\n\n  assertTweakedObject(subtreeRoot, \"subtreeRoot\")\n\n  const deserializedCall = deserializeActionCall(call, subtreeRoot)\n\n  const modelIdOverrides: Patch[] = []\n\n  // set a patch listener to track changes to model ids\n  const patchDisposer = onPatches(subtreeRoot, (patches) => {\n    scanPatchesForModelIdChanges(subtreeRoot, modelIdOverrides, patches)\n  })\n\n  try {\n    const returnValue = applyAction(subtreeRoot, deserializedCall)\n\n    return {\n      returnValue,\n      serializedActionCall: {\n        ...call,\n        modelIdOverrides,\n      },\n    }\n  } finally {\n    patchDisposer()\n  }\n}\n\nfunction scanPatchesForModelIdChanges(root: object, modelIdOverrides: Patch[], patches: Patch[]) {\n  const len = patches.length\n  for (let i = 0; i < len; i++) {\n    const patch = patches[i]\n    if (patch.op === \"replace\" || patch.op === \"add\") {\n      deepScanValueForModelIdChanges(\n        root,\n        modelIdOverrides,\n        patch.value,\n        patch.path as WritablePath\n      )\n    }\n  }\n}\n\nfunction deepScanValueForModelIdChanges(\n  root: object,\n  modelIdOverrides: Patch[],\n  value: any,\n  path: WritablePath\n) {\n  if (path.length >= 1 && typeof value === \"string\") {\n    // ensure the parent is an actual model\n    const parent = resolvePath(root, path.slice(0, path.length - 1)).value\n\n    if (isModel(parent)) {\n      const propertyName = path[path.length - 1]\n      if (propertyName === getModelIdPropertyName(parent.constructor as any)) {\n        // found one\n        modelIdOverrides.push({\n          op: \"replace\",\n          path: path.slice(),\n          value: value,\n        })\n      }\n    }\n  } else if (Array.isArray(value)) {\n    const len = value.length\n    for (let i = 0; i < len; i++) {\n      path.push(i)\n      deepScanValueForModelIdChanges(root, modelIdOverrides, value[i], path)\n      path.pop()\n    }\n  } else if (isObject(value)) {\n    // skip frozen values\n    if (!value[frozenKey]) {\n      const keys = Object.keys(value)\n      const len = keys.length\n      for (let i = 0; i < len; i++) {\n        const propName = keys[i]\n        const propValue = value[propName]\n\n        path.push(propName)\n        deepScanValueForModelIdChanges(root, modelIdOverrides, propValue, path)\n        path.pop()\n      }\n    }\n  }\n}\n\n/**\n * Applies (runs) a serialized action over a target object.\n * In this mode newly generated / modified model IDs previously tracked\n * by `applySerializedActionAndTrackNewModelIds` will be synchronized after\n * the action is applied.\n * This means this method is usually used on the client side.\n *\n * If you intend to apply non-serialized actions check `applyAction` instead.\n *\n * @param subtreeRoot Subtree root target object to run the action over.\n * @param call The serialized action, usually as coming from the server/client.\n * @returns The return value of the action, if any.\n */\nexport function applySerializedActionAndSyncNewModelIds<TRet = any>(\n  subtreeRoot: object,\n  call: SerializedActionCallWithModelIdOverrides\n): TRet {\n  if (!call.serialized) {\n    throw failure(\"cannot apply a non-serialized action call, use 'applyAction' instead\")\n  }\n\n  assertTweakedObject(subtreeRoot, \"subtreeRoot\")\n\n  const deserializedCall = deserializeActionCall(call, subtreeRoot)\n\n  let returnValue: any\n  runInAction(() => {\n    returnValue = applyAction(subtreeRoot, deserializedCall)\n\n    // apply model id overrides\n    applyPatches(subtreeRoot, call.modelIdOverrides)\n  })\n\n  return returnValue\n}\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAyCE,aACA;MAKI,CAAC,KAAK,YAAY;UACd,QAAQ,sEAAsE;AAAA;sBAGlE,aAAa,aAAa;QAExC,mBAAmB,sBAAsB,MAAM,WAAW;QAE1D,mBAA4B;QAG5B,gBAAgB,UAAU,aAAa,CAAC;iCACf,aAAa,kBAAkB,OAAO;AAAA,GACpE;MAEG;UACI,cAAc,YAAY,aAAa,gBAAgB;WAEtD;AAAA,MACL;AAAA,MACA,sBAAsB,iCACjB,OADiB;AAAA,QAEpB;AAAA;;;;;AAMR;AAEA,sCAAsC,MAAc,kBAA2B;QACvE,MAAM,QAAQ;WACX,IAAI,GAAG,IAAI,KAAK,KAAK;UACtB,QAAQ,QAAQ;QAClB,MAAM,OAAO,aAAa,MAAM,OAAO,OAAO;qCAE9C,MACA,kBACA,MAAM,OACN,MAAM,IAAoB;AAAA;;AAIlC;AAEA,wCACE,MACA,kBACA,OACA;MAEI,KAAK,UAAU,KAAK,OAAO,UAAU,UAAU;UAE3C,SAAS,YAAY,MAAM,KAAK,MAAM,GAAG,KAAK,SAAS,CAAC,CAAC,EAAE;QAE7D,QAAQ,MAAM,GAAG;YACb,eAAe,KAAK,KAAK,SAAS;UACpC,iBAAiB,uBAAuB,OAAO,WAAkB,GAAG;yBAErD,KAAK;AAAA,UACpB,IAAI;AAAA,UACJ,MAAM,KAAK;UACX;AAAA,SACD;AAAA;;aAGI,MAAM,QAAQ,KAAK,GAAG;UACzB,MAAM,MAAM;aACT,IAAI,GAAG,IAAI,KAAK,KAAK;WACvB,KAAK,CAAC;qCACoB,MAAM,kBAAkB,MAAM,IAAI,IAAI;WAChE;;aAEE,SAAS,KAAK,GAAG;QAEtB,CAAC,MAAM,YAAY;YACf,OAAO,OAAO,KAAK,KAAK;YACxB,MAAM,KAAK;eACR,IAAI,GAAG,IAAI,KAAK,KAAK;cACtB,WAAW,KAAK;cAChB,YAAY,MAAM;aAEnB,KAAK,QAAQ;uCACa,MAAM,kBAAkB,WAAW,IAAI;aACjE;;;;AAIb;iDAgBE,aACA;MAEI,CAAC,KAAK,YAAY;UACd,QAAQ,sEAAsE;AAAA;sBAGlE,aAAa,aAAa;QAExC,mBAAmB,sBAAsB,MAAM,WAAW;MAE5D;cACQ;kBACI,YAAY,aAAa,gBAAgB;iBAG1C,aAAa,KAAK,gBAAgB;AAAA,GAChD;SAEM;AACT;;"}

package/dist/src/actionMiddlewares/actionSerialization/arraySerializer.mjs

@@ -0,0 +1,15 @@
+import { namespace, isArray } from "../../utils/index.mjs";
+import { cannotSerialize } from "./core.mjs";
+const arraySerializer = {
+  id: `${namespace}/array`,
+  serialize(value, serialize) {
+    if (!isArray(value))
+      return cannotSerialize;
+    return value.map(serialize);
+  },
+  deserialize(arr, deserialize) {
+    return arr.map(deserialize);
+  }
+};
+export { arraySerializer };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXJyYXlTZXJpYWxpemVyLm1qcyIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2FjdGlvbk1pZGRsZXdhcmVzL2FjdGlvblNlcmlhbGl6YXRpb24vYXJyYXlTZXJpYWxpemVyLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgSU9ic2VydmFibGVBcnJheSB9IGZyb20gXCJtb2J4XCJcbmltcG9ydCB7IGlzQXJyYXksIG5hbWVzcGFjZSB9IGZyb20gXCIuLi8uLi91dGlsc1wiXG5pbXBvcnQgeyBBY3Rpb25DYWxsQXJndW1lbnRTZXJpYWxpemVyLCBjYW5ub3RTZXJpYWxpemUgfSBmcm9tIFwiLi9jb3JlXCJcblxuZXhwb3J0IGNvbnN0IGFycmF5U2VyaWFsaXplcjogQWN0aW9uQ2FsbEFyZ3VtZW50U2VyaWFsaXplcjxhbnlbXSB8IElPYnNlcnZhYmxlQXJyYXk8YW55PiwgYW55W10+ID0ge1xuICBpZDogYCR7bmFtZXNwYWNlfS9hcnJheWAsXG5cbiAgc2VyaWFsaXplKHZhbHVlLCBzZXJpYWxpemUpIHtcbiAgICBpZiAoIWlzQXJyYXkodmFsdWUpKSByZXR1cm4gY2Fubm90U2VyaWFsaXplXG5cbiAgICAvLyB0aGlzIHdpbGwgYWxzbyB0cmFuc2Zvcm0gb2JzZXJ2YWJsZSBhcnJheXMgaW50byBub24tb2JzZXJ2YWJsZSBvbmVzXG4gICAgcmV0dXJuIHZhbHVlLm1hcChzZXJpYWxpemUpXG4gIH0sXG5cbiAgZGVzZXJpYWxpemUoYXJyLCBkZXNlcmlhbGl6ZSkge1xuICAgIHJldHVybiBhcnIubWFwKGRlc2VyaWFsaXplKVxuICB9LFxufVxuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O01BSWEsa0JBQXNGO0FBQUEsRUFDakcsSUFBSSxHQUFHO0FBQUEsRUFFUCxVQUFVLE9BQU87UUFDWCxDQUFDLFFBQVEsS0FBSzthQUFVO1dBR3JCLE1BQU0sSUFBSSxTQUFTO0FBQUE7RUFHNUIsWUFBWSxLQUFLO1dBQ1IsSUFBSSxJQUFJLFdBQVc7QUFBQTs7OyJ9

package/dist/src/actionMiddlewares/actionSerialization/core.mjs

@@ -0,0 +1,3 @@
+const cannotSerialize = Symbol("cannotSerialize");
+export { cannotSerialize };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29yZS5tanMiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9hY3Rpb25NaWRkbGV3YXJlcy9hY3Rpb25TZXJpYWxpemF0aW9uL2NvcmUudHMiXSwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNvbnN0IGNhbm5vdFNlcmlhbGl6ZSA9IFN5bWJvbChcImNhbm5vdFNlcmlhbGl6ZVwiKVxuXG4vKipcbiAqIFNlcmlhbGl6ZXIgb2YgYWN0aW9uIGNhbGwgYXJndW1lbnRzLlxuICovXG5leHBvcnQgaW50ZXJmYWNlIEFjdGlvbkNhbGxBcmd1bWVudFNlcmlhbGl6ZXI8VE9yaWdpbmFsLCBUU2VyaWFsaXplZD4ge1xuICAvKipcbiAgICogU2VyaWFsaXplciBJRCwgbXVzdCBiZSB1bmlxdWUuXG4gICAqL1xuICBpZDogc3RyaW5nXG5cbiAgLyoqXG4gICAqIFNlcmlhbGl6ZXMgYW4gYWN0aW9uIGNhbGwgYXJndW1lbnQsIHJldHVybmluZyBgY2Fubm90U2VyaWFsaXplYCBpZiBub3QgcG9zc2libGUuXG4gICAqXG4gICAqIEBwYXJhbSB2YWx1ZSBWYWx1ZSB0byBzZXJpYWxpemUuXG4gICAqIEBwYXJhbSB0YXJnZXRSb290IFRhcmdldCByb290LCBpZiBwcm92aWRlZC5cbiAgICogQHBhcmFtIHNlcmlhbGl6ZUNoaWxkIFNlcmlhbGl6ZSBhIGNoaWxkLlxuICAgKiBAcmV0dXJuc1xuICAgKi9cbiAgc2VyaWFsaXplKFxuICAgIHZhbHVlOiB1bmtub3duLFxuICAgIHNlcmlhbGl6ZUNoaWxkOiAodjogdW5rbm93bikgPT4gdW5rbm93bixcbiAgICB0YXJnZXRSb290OiBvYmplY3QgfCB1bmRlZmluZWRcbiAgKTogVFNlcmlhbGl6ZWQgfCB0eXBlb2YgY2Fubm90U2VyaWFsaXplXG5cbiAgLyoqXG4gICAqIERlc2VyaWFsaXplcyBhbiBhY3Rpb24gY2FsbCBhcmd1bWVudC5cbiAgICpcbiAgICogQHBhcmFtIHZhbHVlIFZhbHVlIHRvIGRlc2VyaWFsaXplLlxuICAgKiBAcGFyYW0gdGFyZ2V0Um9vdCBUYXJnZXQgcm9vdCwgaWYgcHJvdmlkZWQuXG4gICAqIEBwYXJhbSBkZXNlcmlhbGl6ZUNoaWxkIERlc2VyaWFsaXplIGEgY2hpbGQuXG4gICAqIEByZXR1cm5zXG4gICAqL1xuICBkZXNlcmlhbGl6ZShcbiAgICB2YWx1ZTogVFNlcmlhbGl6ZWQsXG4gICAgZGVzZXJpYWxpemVDaGlsZDogKHY6IHVua25vd24pID0+IHVua25vd24sXG4gICAgdGFyZ2V0Um9vdDogb2JqZWN0IHwgdW5kZWZpbmVkXG4gICk6IFRPcmlnaW5hbFxufVxuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJNQUFhLGtCQUFrQixPQUFPLGlCQUFpQjs7In0=

package/dist/src/actionMiddlewares/actionSerialization/dateSerializer.mjs

@@ -0,0 +1,15 @@
+import { namespace } from "../../utils/index.mjs";
+import { cannotSerialize } from "./core.mjs";
+const dateSerializer = {
+  id: `${namespace}/dateAsTimestamp`,
+  serialize(date) {
+    if (!(date instanceof Date))
+      return cannotSerialize;
+    return +date;
+  },
+  deserialize(timestamp) {
+    return new Date(timestamp);
+  }
+};
+export { dateSerializer };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0ZVNlcmlhbGl6ZXIubWpzIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvYWN0aW9uTWlkZGxld2FyZXMvYWN0aW9uU2VyaWFsaXphdGlvbi9kYXRlU2VyaWFsaXplci50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBuYW1lc3BhY2UgfSBmcm9tIFwiLi4vLi4vdXRpbHNcIlxuaW1wb3J0IHsgQWN0aW9uQ2FsbEFyZ3VtZW50U2VyaWFsaXplciwgY2Fubm90U2VyaWFsaXplIH0gZnJvbSBcIi4vY29yZVwiXG5cbmV4cG9ydCBjb25zdCBkYXRlU2VyaWFsaXplcjogQWN0aW9uQ2FsbEFyZ3VtZW50U2VyaWFsaXplcjxEYXRlLCBudW1iZXI+ID0ge1xuICBpZDogYCR7bmFtZXNwYWNlfS9kYXRlQXNUaW1lc3RhbXBgLFxuXG4gIHNlcmlhbGl6ZShkYXRlKSB7XG4gICAgaWYgKCEoZGF0ZSBpbnN0YW5jZW9mIERhdGUpKSByZXR1cm4gY2Fubm90U2VyaWFsaXplXG4gICAgcmV0dXJuICtkYXRlXG4gIH0sXG5cbiAgZGVzZXJpYWxpemUodGltZXN0YW1wKSB7XG4gICAgcmV0dXJuIG5ldyBEYXRlKHRpbWVzdGFtcClcbiAgfSxcbn1cbiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztNQUdhLGlCQUE2RDtBQUFBLEVBQ3hFLElBQUksR0FBRztBQUFBLEVBRVAsVUFBVTtRQUNKLGtCQUFrQjthQUFjO1dBQzdCLENBQUM7QUFBQTtFQUdWLFlBQVk7V0FDSCxJQUFJLEtBQUssU0FBUztBQUFBOzs7In0=

package/dist/src/actionMiddlewares/actionSerialization/mapSerializer.mjs

@@ -0,0 +1,32 @@
+import { isObservableMap } from "mobx";
+import { namespace } from "../../utils/index.mjs";
+import { cannotSerialize } from "./core.mjs";
+const mapSerializer = {
+  id: `${namespace}/mapAsArray`,
+  serialize(map, serialize) {
+    if (!(map instanceof Map) && !isObservableMap(map))
+      return cannotSerialize;
+    const arr = [];
+    const iter = map.keys();
+    let cur = iter.next();
+    while (!cur.done) {
+      const k = cur.value;
+      const v = map.get(k);
+      arr.push([serialize(k), serialize(v)]);
+      cur = iter.next();
+    }
+    return arr;
+  },
+  deserialize(arr, deserialize) {
+    const map = /* @__PURE__ */ new Map();
+    const len = arr.length;
+    for (let i = 0; i < len; i++) {
+      const k = arr[i][0];
+      const v = arr[i][1];
+      map.set(deserialize(k), deserialize(v));
+    }
+    return map;
+  }
+};
+export { mapSerializer };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/src/actionMiddlewares/actionSerialization/objectPathSerializer.mjs

@@ -0,0 +1,33 @@
+import { fastGetRootPath, resolvePathCheckingIds } from "../../parent/path.mjs";
+import { isTweakedObject } from "../../tweaker/core.mjs";
+import { namespace, failure } from "../../utils/index.mjs";
+import { rootPathToTargetPathIds } from "../utils.mjs";
+import { cannotSerialize } from "./core.mjs";
+const objectPathSerializer = {
+  id: `${namespace}/objectPath`,
+  serialize(value, _, targetRoot) {
+    if (typeof value !== "object" || value === null || !isTweakedObject(value, false))
+      return cannotSerialize;
+    if (targetRoot) {
+      const rootPath = fastGetRootPath(value);
+      if (rootPath.root === targetRoot) {
+        return {
+          targetPath: rootPath.path,
+          targetPathIds: rootPathToTargetPathIds(rootPath)
+        };
+      }
+    }
+    return cannotSerialize;
+  },
+  deserialize(ref, _, targetRoot) {
+    if (targetRoot) {
+      const result = resolvePathCheckingIds(targetRoot, ref.targetPath, ref.targetPathIds);
+      if (result.resolved) {
+        return result.value;
+      }
+    }
+    throw failure(`object at path ${JSON.stringify(ref.targetPath)} with ids ${JSON.stringify(ref.targetPathIds)} could not be resolved`);
+  }
+};
+export { objectPathSerializer };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/src/actionMiddlewares/actionSerialization/objectSnapshotSerializer.mjs

@@ -0,0 +1,18 @@
+import { fromSnapshot } from "../../snapshot/fromSnapshot.mjs";
+import { getSnapshot } from "../../snapshot/getSnapshot.mjs";
+import { isTweakedObject } from "../../tweaker/core.mjs";
+import { namespace } from "../../utils/index.mjs";
+import { cannotSerialize } from "./core.mjs";
+const objectSnapshotSerializer = {
+  id: `${namespace}/objectSnapshot`,
+  serialize(value) {
+    if (typeof value !== "object" || value === null || !isTweakedObject(value, false))
+      return cannotSerialize;
+    return getSnapshot(value);
+  },
+  deserialize(snapshot) {
+    return fromSnapshot(snapshot);
+  }
+};
+export { objectSnapshotSerializer };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib2JqZWN0U25hcHNob3RTZXJpYWxpemVyLm1qcyIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2FjdGlvbk1pZGRsZXdhcmVzL2FjdGlvblNlcmlhbGl6YXRpb24vb2JqZWN0U25hcHNob3RTZXJpYWxpemVyLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGZyb21TbmFwc2hvdCB9IGZyb20gXCIuLi8uLi9zbmFwc2hvdC9mcm9tU25hcHNob3RcIlxuaW1wb3J0IHsgZ2V0U25hcHNob3QgfSBmcm9tIFwiLi4vLi4vc25hcHNob3QvZ2V0U25hcHNob3RcIlxuaW1wb3J0IHsgaXNUd2Vha2VkT2JqZWN0IH0gZnJvbSBcIi4uLy4uL3R3ZWFrZXIvY29yZVwiXG5pbXBvcnQgeyBuYW1lc3BhY2UgfSBmcm9tIFwiLi4vLi4vdXRpbHNcIlxuaW1wb3J0IHsgQWN0aW9uQ2FsbEFyZ3VtZW50U2VyaWFsaXplciwgY2Fubm90U2VyaWFsaXplIH0gZnJvbSBcIi4vY29yZVwiXG5cbmV4cG9ydCBjb25zdCBvYmplY3RTbmFwc2hvdFNlcmlhbGl6ZXI6IEFjdGlvbkNhbGxBcmd1bWVudFNlcmlhbGl6ZXI8b2JqZWN0LCBvYmplY3Q+ID0ge1xuICBpZDogYCR7bmFtZXNwYWNlfS9vYmplY3RTbmFwc2hvdGAsXG5cbiAgc2VyaWFsaXplKHZhbHVlKSB7XG4gICAgaWYgKHR5cGVvZiB2YWx1ZSAhPT0gXCJvYmplY3RcIiB8fCB2YWx1ZSA9PT0gbnVsbCB8fCAhaXNUd2Vha2VkT2JqZWN0KHZhbHVlLCBmYWxzZSkpXG4gICAgICByZXR1cm4gY2Fubm90U2VyaWFsaXplXG5cbiAgICByZXR1cm4gZ2V0U25hcHNob3QodmFsdWUpXG4gIH0sXG5cbiAgZGVzZXJpYWxpemUoc25hcHNob3QpIHtcbiAgICByZXR1cm4gZnJvbVNuYXBzaG90KHNuYXBzaG90KVxuICB9LFxufVxuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O01BTWEsMkJBQXlFO0FBQUEsRUFDcEYsSUFBSSxHQUFHO0FBQUEsRUFFUCxVQUFVO1FBQ0osT0FBTyxVQUFVLFlBQVksVUFBVSxRQUFRLENBQUMsZ0JBQWdCLE9BQU8sS0FBSzthQUN2RTtXQUVGLFlBQVksS0FBSztBQUFBO0VBRzFCLFlBQVk7V0FDSCxhQUFhLFFBQVE7QUFBQTs7OyJ9

package/dist/src/actionMiddlewares/actionSerialization/plainObjectSerializer.mjs

@@ -0,0 +1,27 @@
+import { isObservableObject } from "mobx";
+import { namespace, isPlainObject } from "../../utils/index.mjs";
+import { cannotSerialize } from "./core.mjs";
+const plainObjectSerializer = {
+  id: `${namespace}/plainObject`,
+  serialize(value, serialize) {
+    if (!isPlainObject(value) && !isObservableObject(value))
+      return cannotSerialize;
+    return mapObjectFields(value, serialize);
+  },
+  deserialize(obj, serialize) {
+    return mapObjectFields(obj, serialize);
+  }
+};
+function mapObjectFields(originalObj, mapFn) {
+  const obj = {};
+  const keys = Object.keys(originalObj);
+  const len = keys.length;
+  for (let i = 0; i < len; i++) {
+    const k = keys[i];
+    const v = originalObj[k];
+    obj[k] = mapFn(v);
+  }
+  return obj;
+}
+export { plainObjectSerializer };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGxhaW5PYmplY3RTZXJpYWxpemVyLm1qcyIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2FjdGlvbk1pZGRsZXdhcmVzL2FjdGlvblNlcmlhbGl6YXRpb24vcGxhaW5PYmplY3RTZXJpYWxpemVyLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGlzT2JzZXJ2YWJsZU9iamVjdCB9IGZyb20gXCJtb2J4XCJcbmltcG9ydCB7IGlzUGxhaW5PYmplY3QsIG5hbWVzcGFjZSB9IGZyb20gXCIuLi8uLi91dGlsc1wiXG5pbXBvcnQgeyBBY3Rpb25DYWxsQXJndW1lbnRTZXJpYWxpemVyLCBjYW5ub3RTZXJpYWxpemUgfSBmcm9tIFwiLi9jb3JlXCJcblxuZXhwb3J0IGNvbnN0IHBsYWluT2JqZWN0U2VyaWFsaXplcjogQWN0aW9uQ2FsbEFyZ3VtZW50U2VyaWFsaXplcjxvYmplY3QsIG9iamVjdD4gPSB7XG4gIGlkOiBgJHtuYW1lc3BhY2V9L3BsYWluT2JqZWN0YCxcblxuICBzZXJpYWxpemUodmFsdWUsIHNlcmlhbGl6ZSkge1xuICAgIGlmICghaXNQbGFpbk9iamVjdCh2YWx1ZSkgJiYgIWlzT2JzZXJ2YWJsZU9iamVjdCh2YWx1ZSkpIHJldHVybiBjYW5ub3RTZXJpYWxpemVcblxuICAgIC8vIHRoaXMgd2lsbCBtYWtlIG9ic2VydmFibGUgb2JqZWN0cyBub24tb2JzZXJ2YWJsZSBvbmVzXG4gICAgcmV0dXJuIG1hcE9iamVjdEZpZWxkcyh2YWx1ZSwgc2VyaWFsaXplKVxuICB9LFxuXG4gIGRlc2VyaWFsaXplKG9iaiwgc2VyaWFsaXplKSB7XG4gICAgcmV0dXJuIG1hcE9iamVjdEZpZWxkcyhvYmosIHNlcmlhbGl6ZSlcbiAgfSxcbn1cblxuZnVuY3Rpb24gbWFwT2JqZWN0RmllbGRzKG9yaWdpbmFsT2JqOiBhbnksIG1hcEZuOiAoeDogYW55KSA9PiBhbnkpOiBhbnkge1xuICBjb25zdCBvYmo6IGFueSA9IHt9XG4gIGNvbnN0IGtleXMgPSBPYmplY3Qua2V5cyhvcmlnaW5hbE9iailcbiAgY29uc3QgbGVuID0ga2V5cy5sZW5ndGhcbiAgZm9yIChsZXQgaSA9IDA7IGkgPCBsZW47IGkrKykge1xuICAgIGNvbnN0IGsgPSBrZXlzW2ldXG4gICAgY29uc3QgdiA9IG9yaWdpbmFsT2JqW2tdXG4gICAgb2JqW2tdID0gbWFwRm4odilcbiAgfVxuICByZXR1cm4gb2JqXG59XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O01BSWEsd0JBQXNFO0FBQUEsRUFDakYsSUFBSSxHQUFHO0FBQUEsRUFFUCxVQUFVLE9BQU87UUFDWCxDQUFDLGNBQWMsS0FBSyxLQUFLLENBQUMsbUJBQW1CLEtBQUs7YUFBVTtXQUd6RCxnQkFBZ0IsT0FBTyxTQUFTO0FBQUE7RUFHekMsWUFBWSxLQUFLO1dBQ1IsZ0JBQWdCLEtBQUssU0FBUztBQUFBOztBQUl6Qyx5QkFBeUIsYUFBa0I7UUFDbkMsTUFBVztRQUNYLE9BQU8sT0FBTyxLQUFLLFdBQVc7UUFDOUIsTUFBTSxLQUFLO1dBQ1IsSUFBSSxHQUFHLElBQUksS0FBSyxLQUFLO1VBQ3RCLElBQUksS0FBSztVQUNULElBQUksWUFBWTtRQUNsQixLQUFLLE1BQU0sQ0FBQztBQUFBO1NBRVg7QUFDVDs7In0=

package/dist/src/actionMiddlewares/actionSerialization/primitiveSerializer.mjs

@@ -0,0 +1,39 @@
+import { namespace } from "../../utils/index.mjs";
+import { cannotSerialize } from "./core.mjs";
+const primitiveSerializer = {
+  id: `${namespace}/primitiveAsString`,
+  serialize(value) {
+    if (Number.isNaN(value)) {
+      return "nan";
+    }
+    switch (value) {
+      case Infinity:
+        return "+inf";
+      case -Infinity:
+        return "-inf";
+    }
+    if (typeof value === "bigint") {
+      return value.toString();
+    }
+    if (value === void 0) {
+      return "undefined";
+    }
+    return cannotSerialize;
+  },
+  deserialize(str) {
+    switch (str) {
+      case "nan":
+        return NaN;
+      case "+inf":
+        return Infinity;
+      case "-inf":
+        return -Infinity;
+      case "undefined":
+        return void 0;
+      default:
+        return BigInt(str);
+    }
+  }
+};
+export { primitiveSerializer };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJpbWl0aXZlU2VyaWFsaXplci5tanMiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9hY3Rpb25NaWRkbGV3YXJlcy9hY3Rpb25TZXJpYWxpemF0aW9uL3ByaW1pdGl2ZVNlcmlhbGl6ZXIudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgbmFtZXNwYWNlIH0gZnJvbSBcIi4uLy4uL3V0aWxzXCJcbmltcG9ydCB7IEFjdGlvbkNhbGxBcmd1bWVudFNlcmlhbGl6ZXIsIGNhbm5vdFNlcmlhbGl6ZSB9IGZyb20gXCIuL2NvcmVcIlxuXG5leHBvcnQgY29uc3QgcHJpbWl0aXZlU2VyaWFsaXplcjogQWN0aW9uQ2FsbEFyZ3VtZW50U2VyaWFsaXplcjxcbiAgbnVtYmVyIHwgYmlnaW50IHwgdW5kZWZpbmVkLFxuICBzdHJpbmdcbj4gPSB7XG4gIGlkOiBgJHtuYW1lc3BhY2V9L3ByaW1pdGl2ZUFzU3RyaW5nYCxcblxuICBzZXJpYWxpemUodmFsdWUpIHtcbiAgICAvLyBudW1iZXJcbiAgICBpZiAoTnVtYmVyLmlzTmFOKHZhbHVlKSkge1xuICAgICAgcmV0dXJuIFwibmFuXCJcbiAgICB9XG4gICAgc3dpdGNoICh2YWx1ZSkge1xuICAgICAgY2FzZSArSW5maW5pdHk6XG4gICAgICAgIHJldHVybiBcIitpbmZcIlxuICAgICAgY2FzZSAtSW5maW5pdHk6XG4gICAgICAgIHJldHVybiBcIi1pbmZcIlxuICAgIH1cblxuICAgIC8vIGJpZ2ludFxuICAgIGlmICh0eXBlb2YgdmFsdWUgPT09IFwiYmlnaW50XCIpIHtcbiAgICAgIHJldHVybiB2YWx1ZS50b1N0cmluZygpXG4gICAgfVxuXG4gICAgLy8gdW5kZWZpbmVkXG4gICAgaWYgKHZhbHVlID09PSB1bmRlZmluZWQpIHtcbiAgICAgIHJldHVybiBcInVuZGVmaW5lZFwiXG4gICAgfVxuXG4gICAgcmV0dXJuIGNhbm5vdFNlcmlhbGl6ZVxuICB9LFxuXG4gIGRlc2VyaWFsaXplKHN0cikge1xuICAgIHN3aXRjaCAoc3RyKSB7XG4gICAgICBjYXNlIFwibmFuXCI6XG4gICAgICAgIHJldHVybiBOYU5cbiAgICAgIGNhc2UgXCIraW5mXCI6XG4gICAgICAgIHJldHVybiArSW5maW5pdHlcbiAgICAgIGNhc2UgXCItaW5mXCI6XG4gICAgICAgIHJldHVybiAtSW5maW5pdHlcbiAgICAgIGNhc2UgXCJ1bmRlZmluZWRcIjpcbiAgICAgICAgcmV0dXJuIHVuZGVmaW5lZFxuICAgICAgZGVmYXVsdDpcbiAgICAgICAgcmV0dXJuIEJpZ0ludChzdHIpXG4gICAgfVxuICB9LFxufVxuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O01BR2Esc0JBR1Q7QUFBQSxFQUNGLElBQUksR0FBRztBQUFBLEVBRVAsVUFBVTtRQUVKLE9BQU8sTUFBTSxLQUFLLEdBQUc7YUFDaEI7QUFBQTtZQUVEO0FBQUEsV0FDRDtlQUNJO0FBQUEsV0FDSjtlQUNJO0FBQUE7UUFJUCxPQUFPLFVBQVUsVUFBVTthQUN0QixNQUFNOztRQUlYLFVBQVUsUUFBVzthQUNoQjtBQUFBO1dBR0Y7QUFBQTtFQUdULFlBQVk7WUFDRjtBQUFBLFdBQ0Q7ZUFDSTtBQUFBLFdBQ0o7ZUFDSTtBQUFBLFdBQ0o7ZUFDSTtBQUFBLFdBQ0o7ZUFDSTtBQUFBO2VBRUEsT0FBTyxHQUFHO0FBQUE7QUFBQTs7OyJ9

package/dist/src/actionMiddlewares/actionSerialization/setSerializer.mjs

@@ -0,0 +1,29 @@
+import { namespace } from "../../utils/index.mjs";
+import { cannotSerialize } from "./core.mjs";
+const setSerializer = {
+  id: `${namespace}/setAsArray`,
+  serialize(set, serialize) {
+    if (!(set instanceof Set))
+      return cannotSerialize;
+    const arr = [];
+    const iter = set.keys();
+    let cur = iter.next();
+    while (!cur.done) {
+      const k = cur.value;
+      arr.push(serialize(k));
+      cur = iter.next();
+    }
+    return arr;
+  },
+  deserialize(arr, deserialize) {
+    const set = /* @__PURE__ */ new Set();
+    const len = arr.length;
+    for (let i = 0; i < len; i++) {
+      const k = arr[i];
+      set.add(deserialize(k));
+    }
+    return set;
+  }
+};
+export { setSerializer };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2V0U2VyaWFsaXplci5tanMiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9hY3Rpb25NaWRkbGV3YXJlcy9hY3Rpb25TZXJpYWxpemF0aW9uL3NldFNlcmlhbGl6ZXIudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBPYnNlcnZhYmxlU2V0IH0gZnJvbSBcIm1vYnhcIlxuaW1wb3J0IHsgbmFtZXNwYWNlIH0gZnJvbSBcIi4uLy4uL3V0aWxzXCJcbmltcG9ydCB7IEFjdGlvbkNhbGxBcmd1bWVudFNlcmlhbGl6ZXIsIGNhbm5vdFNlcmlhbGl6ZSB9IGZyb20gXCIuL2NvcmVcIlxuXG5leHBvcnQgY29uc3Qgc2V0U2VyaWFsaXplcjogQWN0aW9uQ2FsbEFyZ3VtZW50U2VyaWFsaXplcjxTZXQ8YW55PiB8IE9ic2VydmFibGVTZXQ8YW55PiwgYW55W10+ID0ge1xuICBpZDogYCR7bmFtZXNwYWNlfS9zZXRBc0FycmF5YCxcblxuICBzZXJpYWxpemUoc2V0LCBzZXJpYWxpemUpIHtcbiAgICBpZiAoIShzZXQgaW5zdGFuY2VvZiBTZXQpKSByZXR1cm4gY2Fubm90U2VyaWFsaXplXG5cbiAgICBjb25zdCBhcnI6IGFueVtdID0gW11cblxuICAgIGNvbnN0IGl0ZXIgPSBzZXQua2V5cygpXG4gICAgbGV0IGN1ciA9IGl0ZXIubmV4dCgpXG4gICAgd2hpbGUgKCFjdXIuZG9uZSkge1xuICAgICAgY29uc3QgayA9IGN1ci52YWx1ZVxuICAgICAgYXJyLnB1c2goc2VyaWFsaXplKGspKVxuICAgICAgY3VyID0gaXRlci5uZXh0KClcbiAgICB9XG5cbiAgICByZXR1cm4gYXJyXG4gIH0sXG5cbiAgZGVzZXJpYWxpemUoYXJyLCBkZXNlcmlhbGl6ZSkge1xuICAgIGNvbnN0IHNldCA9IG5ldyBTZXQoKVxuXG4gICAgY29uc3QgbGVuID0gYXJyLmxlbmd0aFxuICAgIGZvciAobGV0IGkgPSAwOyBpIDwgbGVuOyBpKyspIHtcbiAgICAgIGNvbnN0IGsgPSBhcnJbaV1cbiAgICAgIHNldC5hZGQoZGVzZXJpYWxpemUoaykpXG4gICAgfVxuXG4gICAgcmV0dXJuIHNldFxuICB9LFxufVxuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O01BSWEsZ0JBQW9GO0FBQUEsRUFDL0YsSUFBSSxHQUFHO0FBQUEsRUFFUCxVQUFVLEtBQUs7UUFDVCxpQkFBaUI7YUFBYTtVQUU1QixNQUFhO1VBRWIsT0FBTyxJQUFJO1FBQ2IsTUFBTSxLQUFLO1dBQ1IsQ0FBQyxJQUFJLE1BQU07WUFDVixJQUFJLElBQUk7VUFDVixLQUFLLFVBQVUsQ0FBQyxDQUFDO1lBQ2YsS0FBSzs7V0FHTjtBQUFBO0VBR1QsWUFBWSxLQUFLO1VBQ1QsMEJBQVU7VUFFVixNQUFNLElBQUk7YUFDUCxJQUFJLEdBQUcsSUFBSSxLQUFLLEtBQUs7WUFDdEIsSUFBSSxJQUFJO1VBQ1YsSUFBSSxZQUFZLENBQUMsQ0FBQztBQUFBO1dBR2pCO0FBQUE7OzsifQ==