mobx-keystone 0.68.0 → 0.68.1-alpha

package/dist/src/action/modelFlow.mjs

@@ -0,0 +1,251 @@
+import { checkModelDecoratorArgs } from "../modelShared/checkModelDecoratorArgs.mjs";
+import { decorateWrapMethodOrField, failure } from "../utils/index.mjs";
+import { getActionNameAndContextOverride } from "./actionDecoratorUtils.mjs";
+import { ActionContextActionType, ActionContextAsyncStepType } from "./context.mjs";
+import { wrapInAction } from "./wrapInAction.mjs";
+const modelFlowSymbol = Symbol("modelFlow");
+function flow({ nameOrNameFn, generator, overrideContext }) {
+  const flowFn = function(...args) {
+    const name = typeof nameOrNameFn === "function" ? nameOrNameFn() : nameOrNameFn;
+    const target = this;
+    let previousAsyncStepContext;
+    const ctxOverride = (stepType) => {
+      return (ctx, self) => {
+        if (overrideContext) {
+          overrideContext(ctx, self);
+        }
+        ctx.previousAsyncStepContext = previousAsyncStepContext;
+        ctx.spawnAsyncStepContext = previousAsyncStepContext ? previousAsyncStepContext.spawnAsyncStepContext : ctx;
+        ctx.asyncStepType = stepType;
+        ctx.args = args;
+        previousAsyncStepContext = ctx;
+      };
+    };
+    let generatorRun = false;
+    const gen = wrapInAction({
+      nameOrNameFn: name,
+      fn: () => {
+        generatorRun = true;
+        return generator.apply(target, args);
+      },
+      actionType: ActionContextActionType.Async,
+      overrideContext: ctxOverride(ActionContextAsyncStepType.Spawn)
+    }).apply(target);
+    if (!generatorRun) {
+      return gen instanceof Promise ? gen : Promise.resolve(gen);
+    }
+    const genNext = gen.next.bind(gen);
+    const genThrow = gen.throw.bind(gen);
+    const promise = new Promise(function(resolve, reject) {
+      function onFulfilled(res) {
+        let ret;
+        try {
+          ret = wrapInAction({
+            nameOrNameFn: name,
+            fn: genNext,
+            actionType: ActionContextActionType.Async,
+            overrideContext: ctxOverride(ActionContextAsyncStepType.Resume)
+          }).call(target, res);
+        } catch (e) {
+          wrapInAction({
+            nameOrNameFn: name,
+            fn: (err) => {
+              return {
+                value: err,
+                resolution: "reject",
+                accepter: resolve,
+                rejecter: reject
+              };
+            },
+            actionType: ActionContextActionType.Async,
+            overrideContext: ctxOverride(ActionContextAsyncStepType.Throw),
+            isFlowFinisher: true
+          }).call(target, e);
+          return;
+        }
+        next(ret);
+      }
+      function onRejected(err) {
+        let ret;
+        try {
+          ret = wrapInAction({
+            nameOrNameFn: name,
+            fn: genThrow,
+            actionType: ActionContextActionType.Async,
+            overrideContext: ctxOverride(ActionContextAsyncStepType.ResumeError)
+          }).call(target, err);
+        } catch (e) {
+          wrapInAction({
+            nameOrNameFn: name,
+            fn: (err2) => {
+              return {
+                value: err2,
+                resolution: "reject",
+                accepter: resolve,
+                rejecter: reject
+              };
+            },
+            actionType: ActionContextActionType.Async,
+            overrideContext: ctxOverride(ActionContextAsyncStepType.Throw),
+            isFlowFinisher: true
+          }).call(target, e);
+          return;
+        }
+        next(ret);
+      }
+      function next(ret) {
+        if (ret && typeof ret.then === "function") {
+          ret.then(next, reject);
+        } else if (ret.done) {
+          wrapInAction({
+            nameOrNameFn: name,
+            fn: (val) => {
+              return {
+                value: val,
+                resolution: "accept",
+                accepter: resolve,
+                rejecter: reject
+              };
+            },
+            actionType: ActionContextActionType.Async,
+            overrideContext: ctxOverride(ActionContextAsyncStepType.Return),
+            isFlowFinisher: true
+          }).call(target, ret.value);
+        } else {
+          Promise.resolve(ret.value).then(onFulfilled, onRejected);
+        }
+      }
+      onFulfilled(void 0);
+    });
+    return promise;
+  };
+  flowFn[modelFlowSymbol] = true;
+  return flowFn;
+}
+function isModelFlow(fn) {
+  return typeof fn === "function" && modelFlowSymbol in fn;
+}
+function modelFlow(target, propertyKey, baseDescriptor) {
+  const { actionName, overrideContext } = getActionNameAndContextOverride(target, propertyKey);
+  return decorateWrapMethodOrField("modelFlow", {
+    target,
+    propertyKey,
+    baseDescriptor
+  }, (data, fn) => {
+    if (isModelFlow(fn)) {
+      return fn;
+    } else {
+      checkModelFlowArgs(data.target, data.propertyKey, fn);
+      return flow({ nameOrNameFn: actionName, generator: fn, overrideContext });
+    }
+  });
+}
+function checkModelFlowArgs(target, propertyKey, value) {
+  if (typeof value !== "function") {
+    throw failure("modelFlow has to be used over functions");
+  }
+  checkModelDecoratorArgs("modelFlow", target, propertyKey);
+}
+function _async(fn) {
+  return fn;
+}
+function _await(promise) {
+  return promiseGenerator.call(promise);
+}
+const __generator = function(thisArg, body) {
+  let _ = {
+    label: 0,
+    sent: function() {
+      if (t[0] & 1)
+        throw t[1];
+      return t[1];
+    },
+    trys: [],
+    ops: []
+  }, f, y, t, g;
+  return g = { next: verb(0), throw: verb(1), return: verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+    return this;
+  }), g;
+  function verb(n) {
+    return function(v) {
+      return step([n, v]);
+    };
+  }
+  function step(op) {
+    if (f)
+      throw new TypeError("Generator is already executing.");
+    while (_)
+      try {
+        if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
+          return t;
+        if (y = 0, t)
+          op = [op[0] & 2, t.value];
+        switch (op[0]) {
+          case 0:
+          case 1:
+            t = op;
+            break;
+          case 4:
+            _.label++;
+            return { value: op[1], done: false };
+          case 5:
+            _.label++;
+            y = op[1];
+            op = [0];
+            continue;
+          case 7:
+            op = _.ops.pop();
+            _.trys.pop();
+            continue;
+          default:
+            if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+              _ = 0;
+              continue;
+            }
+            if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+              _.label = op[1];
+              break;
+            }
+            if (op[0] === 6 && _.label < t[1]) {
+              _.label = t[1];
+              t = op;
+              break;
+            }
+            if (t && _.label < t[2]) {
+              _.label = t[2];
+              _.ops.push(op);
+              break;
+            }
+            if (t[2])
+              _.ops.pop();
+            _.trys.pop();
+            continue;
+        }
+        op = body.call(thisArg, _);
+      } catch (e) {
+        op = [6, e];
+        y = 0;
+      } finally {
+        f = t = 0;
+      }
+    if (op[0] & 5)
+      throw op[1];
+    return { value: op[0] ? op[1] : void 0, done: true };
+  }
+};
+function promiseGenerator() {
+  let ret;
+  return __generator(this, function(_a) {
+    switch (_a.label) {
+      case 0:
+        return [4, this];
+      case 1:
+        ret = _a.sent();
+        return [2, ret];
+      default:
+        return;
+    }
+  });
+}
+export { _async, _await, flow, isModelFlow, modelFlow };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"modelFlow.mjs","sources":["../../../src/action/modelFlow.ts"],"sourcesContent":["import type { O } from \"ts-toolbelt\"\nimport { checkModelDecoratorArgs } from \"../modelShared/checkModelDecoratorArgs\"\nimport { decorateWrapMethodOrField, failure } from \"../utils\"\nimport { getActionNameAndContextOverride } from \"./actionDecoratorUtils\"\nimport { ActionContext, ActionContextActionType, ActionContextAsyncStepType } from \"./context\"\nimport { wrapInAction, WrapInActionOverrideContextFn } from \"./wrapInAction\"\n\nconst modelFlowSymbol = Symbol(\"modelFlow\")\n\n/**\n * @internal\n */\nexport function flow<R, Args extends any[]>({\n  nameOrNameFn,\n  generator,\n  overrideContext,\n}: {\n  nameOrNameFn: string | (() => string)\n  generator: (...args: Args) => IterableIterator<any>\n  overrideContext?: WrapInActionOverrideContextFn\n}): (...args: Args) => Promise<any> {\n  // Implementation based on https://github.com/tj/co/blob/master/index.js\n  const flowFn = function (this: any, ...args: any[]) {\n    const name = typeof nameOrNameFn === \"function\" ? nameOrNameFn() : nameOrNameFn\n\n    const target = this\n\n    let previousAsyncStepContext: ActionContext | undefined\n\n    const ctxOverride = (stepType: ActionContextAsyncStepType): WrapInActionOverrideContextFn => {\n      return (ctx: O.Writable<ActionContext>, self) => {\n        if (overrideContext) {\n          overrideContext(ctx, self)\n        }\n\n        ctx.previousAsyncStepContext = previousAsyncStepContext\n        ctx.spawnAsyncStepContext = previousAsyncStepContext\n          ? previousAsyncStepContext.spawnAsyncStepContext\n          : ctx\n        ctx.asyncStepType = stepType\n        ctx.args = args\n\n        previousAsyncStepContext = ctx\n      }\n    }\n\n    let generatorRun = false\n    const gen = wrapInAction({\n      nameOrNameFn: name,\n      fn: () => {\n        generatorRun = true\n        return generator.apply(target, args as Args)\n      },\n      actionType: ActionContextActionType.Async,\n      overrideContext: ctxOverride(ActionContextAsyncStepType.Spawn),\n    }).apply(target)\n\n    if (!generatorRun) {\n      // maybe it got overridden into a sync action\n\n      return gen instanceof Promise ? gen : Promise.resolve(gen)\n    }\n\n    // use bound functions to fix es6 compilation\n    const genNext = gen.next.bind(gen)\n    const genThrow = gen.throw!.bind(gen)\n\n    const promise = new Promise<R>(function (resolve, reject) {\n      function onFulfilled(res: any): void {\n        let ret\n        try {\n          ret = wrapInAction({\n            nameOrNameFn: name,\n            fn: genNext,\n            actionType: ActionContextActionType.Async,\n            overrideContext: ctxOverride(ActionContextAsyncStepType.Resume),\n          }).call(target, res)\n        } catch (e) {\n          wrapInAction({\n            nameOrNameFn: name,\n            fn: (err: any) => {\n              // we use a flow finisher to allow middlewares to tweak the return value before resolution\n              return {\n                value: err,\n                resolution: \"reject\",\n\n                accepter: resolve,\n                rejecter: reject,\n              } as FlowFinisher\n            },\n            actionType: ActionContextActionType.Async,\n            overrideContext: ctxOverride(ActionContextAsyncStepType.Throw),\n            isFlowFinisher: true,\n          }).call(target, e)\n          return\n        }\n\n        next(ret)\n      }\n\n      function onRejected(err: any): void {\n        let ret\n        try {\n          ret = wrapInAction({\n            nameOrNameFn: name,\n            fn: genThrow,\n            actionType: ActionContextActionType.Async,\n            overrideContext: ctxOverride(ActionContextAsyncStepType.ResumeError),\n          }).call(target, err)\n        } catch (e) {\n          wrapInAction({\n            nameOrNameFn: name,\n            fn: (err: any) => {\n              // we use a flow finisher to allow middlewares to tweak the return value before resolution\n              return {\n                value: err,\n                resolution: \"reject\",\n\n                accepter: resolve,\n                rejecter: reject,\n              } as FlowFinisher\n            },\n            actionType: ActionContextActionType.Async,\n            overrideContext: ctxOverride(ActionContextAsyncStepType.Throw),\n            isFlowFinisher: true,\n          }).call(target, e)\n          return\n        }\n\n        next(ret)\n      }\n\n      function next(ret: any): void {\n        if (ret && typeof ret.then === \"function\") {\n          // an async iterator\n          ret.then(next, reject)\n        } else if (ret.done) {\n          // done\n          wrapInAction({\n            nameOrNameFn: name,\n            fn: (val: any) => {\n              // we use a flow finisher to allow middlewares to tweak the return value before resolution\n              return {\n                value: val,\n                resolution: \"accept\",\n\n                accepter: resolve,\n                rejecter: reject,\n              } as FlowFinisher\n            },\n            actionType: ActionContextActionType.Async,\n            overrideContext: ctxOverride(ActionContextAsyncStepType.Return),\n            isFlowFinisher: true,\n          }).call(target, ret.value)\n        } else {\n          // continue\n          Promise.resolve(ret.value).then(onFulfilled, onRejected)\n        }\n      }\n\n      onFulfilled(undefined) // kick off the process\n    })\n\n    return promise\n  }\n  ;(flowFn as any)[modelFlowSymbol] = true\n\n  return flowFn\n}\n\n/**\n * @internal\n */\nexport interface FlowFinisher {\n  value: any\n  resolution: \"accept\" | \"reject\"\n\n  accepter(value: any): void\n  rejecter(value: any): void\n}\n\n/**\n * Returns if the given function is a model flow or not.\n *\n * @param fn Function to check.\n * @returns\n */\nexport function isModelFlow(fn: unknown) {\n  return typeof fn === \"function\" && modelFlowSymbol in fn\n}\n\n/**\n * Decorator that turns a function generator into a model flow.\n *\n * @param target\n * @param propertyKey\n * @param [baseDescriptor]\n * @returns\n */\nexport function modelFlow(\n  target: any,\n  propertyKey: string,\n  baseDescriptor?: PropertyDescriptor\n): void {\n  const { actionName, overrideContext } = getActionNameAndContextOverride(target, propertyKey)\n\n  return decorateWrapMethodOrField(\n    \"modelFlow\",\n    {\n      target,\n      propertyKey,\n      baseDescriptor,\n    },\n    (data, fn) => {\n      if (isModelFlow(fn)) {\n        return fn\n      } else {\n        checkModelFlowArgs(data.target, data.propertyKey, fn)\n\n        return flow({ nameOrNameFn: actionName, generator: fn, overrideContext })\n      }\n    }\n  )\n}\n\nfunction checkModelFlowArgs(target: any, propertyKey: string, value: any) {\n  if (typeof value !== \"function\") {\n    throw failure(\"modelFlow has to be used over functions\")\n  }\n  checkModelDecoratorArgs(\"modelFlow\", target, propertyKey)\n}\n\n/**\n * Tricks the TS compiler into thinking that a model flow generator function can be awaited\n * (is a promise).\n *\n * @typeparam A Function arguments.\n * @typeparam R Return value.\n * @param fn Flow function.\n * @returns\n */\nexport function _async<A extends any[], R>(\n  fn: (...args: A) => Generator<any, R, any>\n): (...args: A) => Promise<R> {\n  return fn as any\n}\n\n/**\n * Makes a promise a flow, so it can be awaited with yield*.\n *\n * @typeparam T Promise return type.\n * @param promise Promise.\n * @returns\n */\nexport function _await<T>(promise: Promise<T>): Generator<Promise<T>, T, unknown> {\n  return promiseGenerator.call(promise)\n}\n\n/*\nfunction* promiseGenerator<T>(\n  this: Promise<T>\n) {\n  const ret: T = yield this\n  return ret\n}\n*/\n\n// above code but compiled by TS for ES5\n// so we don't include a dependency to regenerator runtime\n\nconst __generator = function (thisArg: any, body: any) {\n  let _: any = {\n      label: 0,\n      sent: function () {\n        if (t[0] & 1) throw t[1]\n        return t[1]\n      },\n      trys: [],\n      ops: [],\n    },\n    f: any,\n    y: any,\n    t: any,\n    g: any\n  return (\n    (g = { next: verb(0), throw: verb(1), return: verb(2) }),\n    typeof Symbol === \"function\" &&\n      (g[Symbol.iterator] = function () {\n        return this\n      }),\n    g\n  )\n  function verb(n: any) {\n    return function (v: any) {\n      return step([n, v])\n    }\n  }\n  function step(op: any) {\n    if (f) throw new TypeError(\"Generator is already executing.\")\n    while (_)\n      try {\n        if (\n          ((f = 1),\n          y &&\n            (t =\n              op[0] & 2\n                ? y[\"return\"]\n                : op[0]\n                ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0)\n                : y.next) &&\n            !(t = t.call(y, op[1])).done)\n        )\n          return t\n        if (((y = 0), t)) op = [op[0] & 2, t.value]\n        switch (op[0]) {\n          case 0:\n          case 1:\n            t = op\n            break\n          case 4:\n            _.label++\n            return { value: op[1], done: false }\n          case 5:\n            _.label++\n            y = op[1]\n            op = [0]\n            continue\n          case 7:\n            op = _.ops.pop()\n            _.trys.pop()\n            continue\n          default:\n            if (\n              !((t = _.trys), (t = t.length > 0 && t[t.length - 1])) &&\n              (op[0] === 6 || op[0] === 2)\n            ) {\n              _ = 0\n              continue\n            }\n            if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) {\n              _.label = op[1]\n              break\n            }\n            if (op[0] === 6 && _.label < t[1]) {\n              _.label = t[1]\n              t = op\n              break\n            }\n            if (t && _.label < t[2]) {\n              _.label = t[2]\n              _.ops.push(op)\n              break\n            }\n            if (t[2]) _.ops.pop()\n            _.trys.pop()\n            continue\n        }\n        op = body.call(thisArg, _)\n      } catch (e) {\n        op = [6, e]\n        y = 0\n      } finally {\n        f = t = 0\n      }\n    if (op[0] & 5) throw op[1]\n    return { value: op[0] ? op[1] : void 0, done: true }\n  }\n}\n\nfunction promiseGenerator(this: Promise<any>) {\n  let ret\n  return __generator(this, function (this: any, _a: any) {\n    switch (_a.label) {\n      case 0:\n        return [4 /*yield*/, this]\n      case 1:\n        ret = _a.sent()\n        return [2 /*return*/, ret]\n      default:\n        return\n    }\n  })\n}\n"],"names":[],"mappings":";;;;;AAOA,MAAM,kBAAkB,OAAO,WAAW;cAKE,EAC1C,cACA,WACA;QAOM,SAAS,YAAwB;UAC/B,OAAO,OAAO,iBAAiB,aAAa,iBAAiB;UAE7D,SAAS;QAEX;UAEE,cAAc,CAAC;aACZ,CAAC,KAAgC;YAClC,iBAAiB;0BACH,KAAK,IAAI;AAAA;YAGvB,2BAA2B;YAC3B,wBAAwB,2BACxB,yBAAyB,wBACzB;YACA,gBAAgB;YAChB,OAAO;mCAEgB;AAAA;;QAI3B,eAAe;UACb,MAAM,aAAa;AAAA,MACvB,cAAc;AAAA,MACd,IAAI;uBACa;eACR,UAAU,MAAM,QAAQ,IAAY;AAAA;MAE7C,YAAY,wBAAwB;AAAA,MACpC,iBAAiB,YAAY,2BAA2B,KAAK;AAAA,KAC9D,EAAE,MAAM,MAAM;QAEX,CAAC,cAAc;aAGV,eAAe,UAAU,MAAM,QAAQ,QAAQ,GAAG;AAAA;UAIrD,UAAU,IAAI,KAAK,KAAK,GAAG;UAC3B,WAAW,IAAI,MAAO,KAAK,GAAG;UAE9B,UAAU,IAAI,QAAW,SAAU,SAAS;2BAC3B;YACf;YACA;gBACI,aAAa;AAAA,YACjB,cAAc;AAAA,YACd,IAAI;AAAA,YACJ,YAAY,wBAAwB;AAAA,YACpC,iBAAiB,YAAY,2BAA2B,MAAM;AAAA,WAC/D,EAAE,KAAK,QAAQ,GAAG;AAAA,iBACZ;uBACM;AAAA,YACX,cAAc;AAAA,YACd,IAAI,CAAC;qBAEI;AAAA,gBACL,OAAO;AAAA,gBACP,YAAY;AAAA,gBAEZ,UAAU;AAAA,gBACV,UAAU;AAAA;;YAGd,YAAY,wBAAwB;AAAA,YACpC,iBAAiB,YAAY,2BAA2B,KAAK;AAAA,YAC7D,gBAAgB;AAAA,WACjB,EAAE,KAAK,QAAQ,CAAC;;;aAId,GAAG;AAAA;0BAGU;YACd;YACA;gBACI,aAAa;AAAA,YACjB,cAAc;AAAA,YACd,IAAI;AAAA,YACJ,YAAY,wBAAwB;AAAA,YACpC,iBAAiB,YAAY,2BAA2B,WAAW;AAAA,WACpE,EAAE,KAAK,QAAQ,GAAG;AAAA,iBACZ;uBACM;AAAA,YACX,cAAc;AAAA,YACd,IAAI,CAAC;qBAEI;AAAA,gBACL,OAAO;AAAA,gBACP,YAAY;AAAA,gBAEZ,UAAU;AAAA,gBACV,UAAU;AAAA;;YAGd,YAAY,wBAAwB;AAAA,YACpC,iBAAiB,YAAY,2BAA2B,KAAK;AAAA,YAC7D,gBAAgB;AAAA,WACjB,EAAE,KAAK,QAAQ,CAAC;;;aAId,GAAG;AAAA;oBAGI;YACR,OAAO,OAAO,IAAI,SAAS,YAAY;cAErC,KAAK,MAAM,MAAM;AAAA,mBACZ,IAAI,MAAM;uBAEN;AAAA,YACX,cAAc;AAAA,YACd,IAAI,CAAC;qBAEI;AAAA,gBACL,OAAO;AAAA,gBACP,YAAY;AAAA,gBAEZ,UAAU;AAAA,gBACV,UAAU;AAAA;;YAGd,YAAY,wBAAwB;AAAA,YACpC,iBAAiB,YAAY,2BAA2B,MAAM;AAAA,YAC9D,gBAAgB;AAAA,WACjB,EAAE,KAAK,QAAQ,IAAI,KAAK;AAAA,eACpB;kBAEG,QAAQ,IAAI,KAAK,EAAE,KAAK,aAAa,UAAU;AAAA;;kBAI/C,MAAS;AAAA,KACtB;WAEM;AAAA;SAEQ,mBAAmB;SAE7B;AACT;qBAmB4B;SACnB,OAAO,OAAO,cAAc,mBAAmB;AACxD;mBAWE,QACA,aACA;QAEM,EAAE,YAAY,oBAAoB,gCAAgC,QAAQ,WAAW;SAEpF,0BACL,aACA;AAAA,IACE;AAAA,IACA;AAAA,IACA;AAAA,KAEF,CAAC,MAAM;QACD,YAAY,EAAE,GAAG;aACZ;AAAA,WACF;yBACc,KAAK,QAAQ,KAAK,aAAa,EAAE;aAE7C,KAAK,EAAE,cAAc,YAAY,WAAW,IAAI,iBAAiB;AAAA;GAE3E;AAEL;AAEA,4BAA4B,QAAa,aAAqB;MACxD,OAAO,UAAU,YAAY;UACzB,QAAQ,yCAAyC;AAAA;0BAEjC,aAAa,QAAQ,WAAW;AAC1D;gBAYE;SAEO;AACT;gBAS0B;SACjB,iBAAiB,KAAK,OAAO;AACtC;AAcA,MAAM,cAAc,SAAU,SAAc;MACtC,IAAS;AAAA,IACT,OAAO;AAAA,IACP,MAAM;UACA,EAAE,KAAK;cAAS,EAAE;aACf,EAAE;AAAA;IAEX,MAAM;IACN,KAAK;KAEP,GACA,GACA,GACA;SAEC,IAAI,EAAE,MAAM,KAAK,CAAC,GAAG,OAAO,KAAK,CAAC,GAAG,QAAQ,KAAK,CAAC,KACpD,OAAO,WAAW,iBACb,OAAO,YAAY;WACb;AAAA,MAEX;gBAEY;WACL,SAAU;aACR,KAAK,CAAC,GAAG,CAAC,CAAC;AAAA;;gBAGR;QACR;YAAS,IAAI,UAAU,iCAAiC;WACrD;UACD;YAEE,IAAI,GACN,UAEI,GAAG,KAAK,IACJ,EAAE,YACF,GAAG,KACH,EAAE,kBAAkB,EAAE,cAAc,EAAE,KAAK,CAAC,GAAG,KAC/C,EAAE,SACR,MAAM,EAAE,KAAK,GAAG,GAAG,EAAE,GAAG;iBAEnB;YACH,IAAI,GAAI;eAAS,CAAC,GAAG,KAAK,GAAG,EAAE,KAAK;gBAClC,GAAG;AAAA,eACJ;AAAA,eACA;gBACC;;eAED;cACD;mBACK,EAAE,OAAO,GAAG,IAAI,MAAM;eAC1B;cACD;gBACE,GAAG;iBACF,CAAC,CAAC;;eAEJ;iBACE,EAAE,IAAI;cACT,KAAK;;;gBAIL,MAAO,EAAE,MAAQ,IAAI,EAAE,SAAS,KAAK,EAAE,EAAE,SAAS,WAC9C,OAAO,KAAK,GAAG,OAAO,IAC1B;kBACI;;;gBAGF,GAAG,OAAO,OAAO,KAAM,GAAG,KAAK,EAAE,MAAM,GAAG,KAAK,EAAE,KAAM;gBACvD,QAAQ,GAAG;;;gBAGX,GAAG,OAAO,KAAK,EAAE,QAAQ,EAAE,IAAI;gBAC/B,QAAQ,EAAE;kBACR;;;gBAGF,KAAK,EAAE,QAAQ,EAAE,IAAI;gBACrB,QAAQ,EAAE;gBACV,IAAI,KAAK,EAAE;;;gBAGX,EAAE;gBAAM,IAAI;cACd,KAAK;;;aAGN,KAAK,KAAK,SAAS,CAAC;AAAA,eAClB;aACF,CAAC,GAAG,CAAC;YACN;AAAA;YAEA,IAAI;AAAA;QAER,GAAG,KAAK;YAAS,GAAG;WACjB,EAAE,OAAO,GAAG,KAAK,GAAG,KAAK,QAAQ,MAAM;;AAElD;AAEA;MACM;SACG,YAAY,MAAM,SAAqB;YACpC,GAAG;AAAA,WACJ;eACI,CAAC,GAAa,IAAI;AAAA,WACtB;cACG,GAAG;eACF,CAAC,GAAc,GAAG;AAAA;;;GAI9B;AACH;;"}

package/dist/src/action/pendingActions.mjs

@@ -0,0 +1,30 @@
+import { getCurrentActionContext } from "./context.mjs";
+import { getActionProtection } from "./protection.mjs";
+const pendingActions = [];
+function isActionRunning() {
+  return !getActionProtection() || getCurrentActionContext();
+}
+function enqueuePendingAction(action) {
+  if (isActionRunning()) {
+    pendingActions.push(action);
+  } else {
+    action();
+  }
+}
+let pendingActionsRunning = false;
+function tryRunPendingActions() {
+  if (isActionRunning() || pendingActionsRunning) {
+    return;
+  }
+  pendingActionsRunning = true;
+  try {
+    while (pendingActions.length > 0) {
+      const nextAction = pendingActions.shift();
+      nextAction();
+    }
+  } finally {
+    pendingActionsRunning = false;
+  }
+}
+export { enqueuePendingAction, tryRunPendingActions };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGVuZGluZ0FjdGlvbnMubWpzIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYWN0aW9uL3BlbmRpbmdBY3Rpb25zLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGdldEN1cnJlbnRBY3Rpb25Db250ZXh0IH0gZnJvbSBcIi4vY29udGV4dFwiXG5pbXBvcnQgeyBnZXRBY3Rpb25Qcm90ZWN0aW9uIH0gZnJvbSBcIi4vcHJvdGVjdGlvblwiXG5cbmNvbnN0IHBlbmRpbmdBY3Rpb25zOiAoKCkgPT4gdm9pZClbXSA9IFtdXG5cbmZ1bmN0aW9uIGlzQWN0aW9uUnVubmluZygpIHtcbiAgcmV0dXJuICFnZXRBY3Rpb25Qcm90ZWN0aW9uKCkgfHwgZ2V0Q3VycmVudEFjdGlvbkNvbnRleHQoKVxufVxuXG4vKipcbiAqIEBpbnRlcm5hbFxuICovXG5leHBvcnQgZnVuY3Rpb24gZW5xdWV1ZVBlbmRpbmdBY3Rpb24oYWN0aW9uOiAoKSA9PiB2b2lkKTogdm9pZCB7XG4gIC8vIGRlbGF5IGFjdGlvbiB1bnRpbCBhbGwgY3VycmVudCBhY3Rpb25zIGFyZSBmaW5pc2hlZFxuICBpZiAoaXNBY3Rpb25SdW5uaW5nKCkpIHtcbiAgICBwZW5kaW5nQWN0aW9ucy5wdXNoKGFjdGlvbilcbiAgfSBlbHNlIHtcbiAgICBhY3Rpb24oKVxuICB9XG59XG5cbmxldCBwZW5kaW5nQWN0aW9uc1J1bm5pbmcgPSBmYWxzZVxuXG4vKipcbiAqIEBpbnRlcm5hbFxuICovXG5leHBvcnQgZnVuY3Rpb24gdHJ5UnVuUGVuZGluZ0FjdGlvbnMoKTogdm9pZCB7XG4gIGlmIChpc0FjdGlvblJ1bm5pbmcoKSB8fCBwZW5kaW5nQWN0aW9uc1J1bm5pbmcpIHtcbiAgICByZXR1cm5cbiAgfVxuXG4gIHBlbmRpbmdBY3Rpb25zUnVubmluZyA9IHRydWVcblxuICB0cnkge1xuICAgIHdoaWxlIChwZW5kaW5nQWN0aW9ucy5sZW5ndGggPiAwKSB7XG4gICAgICBjb25zdCBuZXh0QWN0aW9uID0gcGVuZGluZ0FjdGlvbnMuc2hpZnQoKSFcbiAgICAgIG5leHRBY3Rpb24oKVxuICAgIH1cbiAgfSBmaW5hbGx5IHtcbiAgICBwZW5kaW5nQWN0aW9uc1J1bm5pbmcgPSBmYWxzZVxuICB9XG59XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFHQSxNQUFNLGlCQUFpQztBQUV2QztTQUNTLENBQUMseUJBQXlCO0FBQ25DOzhCQUtxQztNQUUvQixtQkFBbUI7bUJBQ04sS0FBSyxNQUFNO0FBQUEsU0FDckI7OztBQUdUO0FBRUEsSUFBSSx3QkFBd0I7O01BTXRCLHFCQUFxQix1QkFBdUI7OzswQkFJeEI7TUFFcEI7V0FDSyxlQUFlLFNBQVMsR0FBRztZQUMxQixhQUFhLGVBQWU7Ozs7NEJBSVo7QUFBQTtBQUU1Qjs7In0=

package/dist/src/action/protection.mjs

@@ -0,0 +1,19 @@
+import { failure } from "../utils/index.mjs";
+import { getCurrentActionContext } from "./context.mjs";
+function canWrite() {
+  return !getActionProtection() || !!getCurrentActionContext();
+}
+function assertCanWrite() {
+  if (!canWrite()) {
+    throw failure("data changes must be performed inside model actions");
+  }
+}
+let actionProtection = true;
+function getActionProtection() {
+  return actionProtection;
+}
+function setActionProtection(protection) {
+  actionProtection = protection;
+}
+export { assertCanWrite, getActionProtection, setActionProtection };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvdGVjdGlvbi5tanMiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9hY3Rpb24vcHJvdGVjdGlvbi50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBmYWlsdXJlIH0gZnJvbSBcIi4uL3V0aWxzXCJcbmltcG9ydCB7IGdldEN1cnJlbnRBY3Rpb25Db250ZXh0IH0gZnJvbSBcIi4vY29udGV4dFwiXG5cbmZ1bmN0aW9uIGNhbldyaXRlKCk6IGJvb2xlYW4ge1xuICByZXR1cm4gIWdldEFjdGlvblByb3RlY3Rpb24oKSB8fCAhIWdldEN1cnJlbnRBY3Rpb25Db250ZXh0KClcbn1cblxuLyoqXG4gKiBAaW50ZXJuYWxcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGFzc2VydENhbldyaXRlKCkge1xuICBpZiAoIWNhbldyaXRlKCkpIHtcbiAgICB0aHJvdyBmYWlsdXJlKFwiZGF0YSBjaGFuZ2VzIG11c3QgYmUgcGVyZm9ybWVkIGluc2lkZSBtb2RlbCBhY3Rpb25zXCIpXG4gIH1cbn1cblxubGV0IGFjdGlvblByb3RlY3Rpb24gPSB0cnVlXG5cbi8qKlxuICogQGludGVybmFsXG4gKlxuICogR2V0cyBpZiB0aGUgYWN0aW9uIHByb3RlY3Rpb24gaXMgY3VycmVudGx5IGVuYWJsZWQgb3Igbm90LlxuICpcbiAqIEByZXR1cm5zXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBnZXRBY3Rpb25Qcm90ZWN0aW9uKCkge1xuICByZXR1cm4gYWN0aW9uUHJvdGVjdGlvblxufVxuXG4vKipcbiAqIEBpbnRlcm5hbFxuICpcbiAqIFNldHMgaWYgdGhlIGFjdGlvbiBwcm90ZWN0aW9uIGlzIGN1cnJlbnRseSBlbmFibGVkIG9yIG5vdC5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHNldEFjdGlvblByb3RlY3Rpb24ocHJvdGVjdGlvbjogYm9vbGVhbikge1xuICBhY3Rpb25Qcm90ZWN0aW9uID0gcHJvdGVjdGlvblxufVxuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBR0E7U0FDUyxDQUFDLHlCQUF5QixDQUFDLENBQUM7QUFDckM7O01BTU0sQ0FBQyxZQUFZO1VBQ1QsUUFBUSxxREFBcUQ7QUFBQTtBQUV2RTtBQUVBLElBQUksbUJBQW1COztTQVVkO0FBQ1Q7NkJBT29DO3FCQUNmO0FBQ3JCOzsifQ==

package/dist/src/action/runUnprotected.mjs

@@ -0,0 +1,24 @@
+import { action } from "mobx";
+import { tryRunPendingActions } from "./pendingActions.mjs";
+import { setActionProtection, getActionProtection } from "./protection.mjs";
+function runUnprotected(arg1, arg2) {
+  const name = typeof arg1 === "string" ? arg1 : void 0;
+  const fn = typeof arg1 === "string" ? arg2 : arg1;
+  const innerAction = () => {
+    const oldActionProtection = getActionProtection();
+    setActionProtection(false);
+    try {
+      return fn();
+    } finally {
+      setActionProtection(oldActionProtection);
+      tryRunPendingActions();
+    }
+  };
+  if (name) {
+    return action(name, innerAction)();
+  } else {
+    return action(innerAction)();
+  }
+}
+export { runUnprotected };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/src/action/wrapInAction.mjs

@@ -0,0 +1,90 @@
+import { action } from "mobx";
+import { setCurrentActionContext, ActionContextActionType, getCurrentActionContext } from "./context.mjs";
+import { modelActionSymbol, isModelAction } from "./isModelAction.mjs";
+import { getActionMiddlewares } from "./middleware.mjs";
+import { tryRunPendingActions } from "./pendingActions.mjs";
+function wrapInAction({ nameOrNameFn, fn, actionType, overrideContext, isFlowFinisher = false }) {
+  let fnInAction = false;
+  const wrappedAction = function() {
+    const name = typeof nameOrNameFn === "function" ? nameOrNameFn() : nameOrNameFn;
+    if (!fnInAction) {
+      fnInAction = true;
+      fn = action(name, fn);
+    }
+    const target = this;
+    const parentContext = getCurrentActionContext();
+    const context = {
+      actionName: name,
+      type: actionType,
+      target,
+      args: Array.from(arguments),
+      parentContext,
+      data: {},
+      rootContext: void 0
+    };
+    if (overrideContext) {
+      overrideContext(context, this);
+    }
+    if (!context.rootContext) {
+      if (context.previousAsyncStepContext) {
+        context.rootContext = context.previousAsyncStepContext.rootContext;
+      } else if (context.parentContext) {
+        context.rootContext = context.parentContext.rootContext;
+      } else {
+        context.rootContext = context;
+      }
+    }
+    setCurrentActionContext(context);
+    let mwareFn = fn.bind(target, ...arguments);
+    const mwareIter = getActionMiddlewares(context.target)[Symbol.iterator]();
+    let mwareCur = mwareIter.next();
+    while (!mwareCur.done) {
+      const mware = mwareCur.value;
+      const filterPassed = mware.filter ? mware.filter(context) : true;
+      if (filterPassed) {
+        mwareFn = mware.middleware.bind(void 0, context, mwareFn);
+      }
+      mwareCur = mwareIter.next();
+    }
+    try {
+      const ret = mwareFn();
+      if (isFlowFinisher) {
+        const flowFinisher = ret;
+        const value = flowFinisher.value;
+        if (flowFinisher.resolution === "accept") {
+          flowFinisher.accepter(value);
+        } else {
+          flowFinisher.rejecter(value);
+        }
+        return value;
+      } else {
+        return ret;
+      }
+    } finally {
+      setCurrentActionContext(context.parentContext);
+      tryRunPendingActions();
+    }
+  };
+  wrappedAction[modelActionSymbol] = true;
+  return wrappedAction;
+}
+function wrapModelMethodInActionIfNeeded(model, propertyKey, name) {
+  const fn = model[propertyKey];
+  if (isModelAction(fn)) {
+    return;
+  }
+  const wrappedFn = wrapInAction({
+    nameOrNameFn: name,
+    fn,
+    actionType: ActionContextActionType.Sync
+  });
+  const proto = Object.getPrototypeOf(model);
+  const protoFn = proto[propertyKey];
+  if (protoFn === fn) {
+    proto[propertyKey] = wrappedFn;
+  } else {
+    model[propertyKey] = wrappedFn;
+  }
+}
+export { wrapInAction, wrapModelMethodInActionIfNeeded };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -0,0 +1,131 @@
+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 { assertTweakedObject } from "../../tweaker/core.mjs";
+import { failure, isJSONPrimitive, isPlainObject } from "../../utils/index.mjs";
+import { arraySerializer } from "./arraySerializer.mjs";
+import { cannotSerialize } from "./core.mjs";
+import { dateSerializer } from "./dateSerializer.mjs";
+import { mapSerializer } from "./mapSerializer.mjs";
+import { objectPathSerializer } from "./objectPathSerializer.mjs";
+import { objectSnapshotSerializer } from "./objectSnapshotSerializer.mjs";
+import { plainObjectSerializer } from "./plainObjectSerializer.mjs";
+import { primitiveSerializer } from "./primitiveSerializer.mjs";
+import { setSerializer } from "./setSerializer.mjs";
+const serializersArray = [];
+const serializersMap = /* @__PURE__ */ new Map();
+function registerActionCallArgumentSerializer(serializer) {
+  registerDefaultActionCallArgumentSerializers();
+  if (serializersArray.includes(serializer)) {
+    throw failure("action call argument serializer already registered");
+  }
+  if (serializersMap.has(serializer.id)) {
+    throw failure(`action call argument serializer with id '${serializer.id}' already registered`);
+  }
+  serializersArray.unshift(serializer);
+  serializersMap.set(serializer.id, serializer);
+  return () => {
+    const index = serializersArray.indexOf(serializer);
+    if (index >= 0) {
+      serializersArray.splice(index, 1);
+    }
+    serializersMap.delete(serializer.id);
+  };
+}
+function serializeActionCallArgument(argValue, targetRoot) {
+  registerDefaultActionCallArgumentSerializers();
+  if (isJSONPrimitive(argValue)) {
+    return argValue;
+  }
+  const origValue = argValue;
+  const serialize = (v) => serializeActionCallArgument(v, targetRoot);
+  for (let i = 0; i < serializersArray.length; i++) {
+    const serializer = serializersArray[i];
+    const serializedValue = serializer.serialize(argValue, serialize, targetRoot);
+    if (serializedValue !== cannotSerialize) {
+      return {
+        $mobxKeystoneSerializer: serializer.id,
+        value: serializedValue
+      };
+    }
+  }
+  throw failure(`serializeActionCallArgument could not serialize the given value: ${origValue}`);
+}
+function serializeActionCall(actionCall, targetRoot) {
+  if (actionCall.serialized) {
+    throw failure("cannot serialize an already serialized action call");
+  }
+  if (targetRoot !== void 0) {
+    assertTweakedObject(targetRoot, "targetRoot");
+  }
+  const serialize = (v) => serializeActionCallArgument(v, targetRoot);
+  return __spreadProps(__spreadValues({}, actionCall), {
+    serialized: true,
+    args: actionCall.args.map(serialize)
+  });
+}
+function deserializeActionCallArgument(argValue, targetRoot) {
+  registerDefaultActionCallArgumentSerializers();
+  if (isJSONPrimitive(argValue)) {
+    return argValue;
+  }
+  if (!isPlainObject(argValue) || typeof argValue.$mobxKeystoneSerializer !== "string") {
+    throw failure("invalid serialized action call argument");
+  }
+  const serializerId = argValue.$mobxKeystoneSerializer;
+  const serializer = serializersMap.get(serializerId);
+  if (!serializer) {
+    throw failure(`a serializer with id '${serializerId}' could not be found`);
+  }
+  const serializedValue = argValue;
+  const deserialize = (v) => deserializeActionCallArgument(v, targetRoot);
+  return serializer.deserialize(serializedValue.value, deserialize, targetRoot);
+}
+function deserializeActionCall(actionCall, targetRoot) {
+  if (!actionCall.serialized) {
+    throw failure("cannot deserialize a non-serialized action call");
+  }
+  if (targetRoot !== void 0) {
+    assertTweakedObject(targetRoot, "targetRoot");
+  }
+  const deserialize = (v) => deserializeActionCallArgument(v, targetRoot);
+  const deserializedActionCall = __spreadProps(__spreadValues({}, actionCall), {
+    serialized: void 0,
+    args: actionCall.args.map(deserialize)
+  });
+  delete deserializedActionCall.serialized;
+  return deserializedActionCall;
+}
+let defaultActionCallArgumentSerializersRegistered = false;
+function registerDefaultActionCallArgumentSerializers() {
+  if (defaultActionCallArgumentSerializersRegistered) {
+    return;
+  }
+  defaultActionCallArgumentSerializersRegistered = true;
+  registerActionCallArgumentSerializer(primitiveSerializer);
+  registerActionCallArgumentSerializer(plainObjectSerializer);
+  registerActionCallArgumentSerializer(setSerializer);
+  registerActionCallArgumentSerializer(mapSerializer);
+  registerActionCallArgumentSerializer(dateSerializer);
+  registerActionCallArgumentSerializer(arraySerializer);
+  registerActionCallArgumentSerializer(objectSnapshotSerializer);
+  registerActionCallArgumentSerializer(objectPathSerializer);
+}
+export { deserializeActionCall, deserializeActionCallArgument, registerActionCallArgumentSerializer, serializeActionCall, serializeActionCallArgument };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"actionSerialization.mjs","sources":["../../../../src/actionMiddlewares/actionSerialization/actionSerialization.ts"],"sourcesContent":["import type { O } from \"ts-toolbelt\"\nimport type { ActionCall } from \"../../action/applyAction\"\nimport { assertTweakedObject } from \"../../tweaker/core\"\nimport { failure, isJSONPrimitive, isPlainObject } from \"../../utils\"\nimport type { JSONPrimitiveValue } from \"../../utils/types\"\nimport { arraySerializer } from \"./arraySerializer\"\nimport { ActionCallArgumentSerializer, cannotSerialize } from \"./core\"\nimport { dateSerializer } from \"./dateSerializer\"\nimport { mapSerializer } from \"./mapSerializer\"\nimport { objectPathSerializer } from \"./objectPathSerializer\"\nimport { objectSnapshotSerializer } from \"./objectSnapshotSerializer\"\nimport { plainObjectSerializer } from \"./plainObjectSerializer\"\nimport { primitiveSerializer } from \"./primitiveSerializer\"\nimport { setSerializer } from \"./setSerializer\"\n\nconst serializersArray: ActionCallArgumentSerializer<any, any>[] = []\nconst serializersMap = new Map<string, ActionCallArgumentSerializer<any, any>>()\n\n/**\n * Registers a new action call argument serializers.\n * Serializers are called in the inverse order they are registered, meaning the\n * latest one registered will be called first.\n *\n * @param serializer Serializer to register.\n * @returns A disposer to unregister the serializer.\n */\nexport function registerActionCallArgumentSerializer(\n  serializer: ActionCallArgumentSerializer<any, any>\n): () => void {\n  registerDefaultActionCallArgumentSerializers()\n\n  if (serializersArray.includes(serializer)) {\n    throw failure(\"action call argument serializer already registered\")\n  }\n  if (serializersMap.has(serializer.id)) {\n    throw failure(`action call argument serializer with id '${serializer.id}' already registered`)\n  }\n\n  serializersArray.unshift(serializer)\n  serializersMap.set(serializer.id, serializer)\n\n  return () => {\n    const index = serializersArray.indexOf(serializer)\n    if (index >= 0) {\n      serializersArray.splice(index, 1)\n    }\n    serializersMap.delete(serializer.id)\n  }\n}\n\n/**\n * Serialized action call argument.\n */\nexport interface SerializedActionCallArgument {\n  /**\n   * Serializer id.\n   */\n  readonly $mobxKeystoneSerializer: string\n  /**\n   * Serialized value.\n   */\n  readonly value: any\n}\n\n/**\n * A serialized action call.\n */\nexport interface SerializedActionCall extends Omit<ActionCall, \"serialized\"> {\n  /**\n   * Serialized action arguments.\n   */\n  readonly args: ReadonlyArray<SerializedActionCallArgument | JSONPrimitiveValue>\n\n  /**\n   * Marks this action call as serialized.\n   */\n  serialized: true\n}\n\n/**\n * Transforms an action call argument by returning a `SerializedActionCallArgument`.\n * The following are supported out of the box:\n * - Primitives.\n * - Nodes that are under the same root node as the target root (when provided) will be serialized\n *   as a path.\n * - Nodes that are not under the same root node as the target root will be serialized as their snapshot.\n * - Arrays (observable or not).\n * - Dates.\n * - Maps (observable or not).\n * - Sets (observable or not).\n * - Plain objects (observable or not).\n *\n * If the value cannot be serialized it will throw an exception.\n *\n * @param argValue Argument value to be transformed into its serializable form.\n * @param [targetRoot] Target root node of the model where this action is being performed.\n * @returns The serializable form of the passed value.\n */\nexport function serializeActionCallArgument(\n  argValue: any,\n  targetRoot?: object\n): SerializedActionCallArgument | JSONPrimitiveValue {\n  registerDefaultActionCallArgumentSerializers()\n\n  if (isJSONPrimitive(argValue)) {\n    return argValue\n  }\n\n  const origValue = argValue\n\n  const serialize = (v: any) => serializeActionCallArgument(v, targetRoot)\n\n  // try serializers\n  for (let i = 0; i < serializersArray.length; i++) {\n    const serializer = serializersArray[i]\n    const serializedValue = serializer.serialize(argValue, serialize, targetRoot)\n    if (serializedValue !== cannotSerialize) {\n      return {\n        $mobxKeystoneSerializer: serializer.id,\n        value: serializedValue,\n      } as SerializedActionCallArgument\n    }\n  }\n\n  throw failure(`serializeActionCallArgument could not serialize the given value: ${origValue}`)\n}\n\n/**\n * Ensures that an action call is serializable by mapping the action arguments into its\n * serializable version by using `serializeActionCallArgument`.\n *\n * @param actionCall Action call to convert.\n * @param [targetRoot] Target root node of the model where this action is being performed.\n * @returns The serializable action call.\n */\nexport function serializeActionCall(\n  actionCall: ActionCall,\n  targetRoot?: object\n): SerializedActionCall {\n  if (actionCall.serialized) {\n    throw failure(\"cannot serialize an already serialized action call\")\n  }\n\n  if (targetRoot !== undefined) {\n    assertTweakedObject(targetRoot, \"targetRoot\")\n  }\n\n  const serialize = (v: any) => serializeActionCallArgument(v, targetRoot)\n\n  return {\n    ...actionCall,\n    serialized: true,\n    args: actionCall.args.map(serialize),\n  }\n}\n\n/**\n * Transforms an action call argument by returning its deserialized equivalent.\n *\n * @param argValue Argument value to be transformed into its deserialized form.\n * @param [targetRoot] Target root node of the model where this action is being performed.\n * @returns The deserialized form of the passed value.\n */\nexport function deserializeActionCallArgument(\n  argValue: SerializedActionCallArgument | JSONPrimitiveValue,\n  targetRoot?: object\n): any {\n  registerDefaultActionCallArgumentSerializers()\n\n  if (isJSONPrimitive(argValue)) {\n    return argValue\n  }\n\n  if (!isPlainObject(argValue) || typeof argValue.$mobxKeystoneSerializer !== \"string\") {\n    throw failure(\"invalid serialized action call argument\")\n  }\n\n  const serializerId = argValue.$mobxKeystoneSerializer\n  const serializer = serializersMap.get(serializerId)\n\n  if (!serializer) {\n    throw failure(`a serializer with id '${serializerId}' could not be found`)\n  }\n\n  const serializedValue = argValue as SerializedActionCallArgument\n\n  const deserialize = (v: any) => deserializeActionCallArgument(v, targetRoot)\n  return serializer.deserialize(serializedValue.value, deserialize, targetRoot)\n}\n\n/**\n * Ensures that an action call is deserialized by mapping the action arguments into its\n * deserialized version by using `deserializeActionCallArgument`.\n *\n * @param actionCall Action call to convert.\n * @param [targetRoot] Target root node of the model where this action is being performed.\n * @returns The deserialized action call.\n */\nexport function deserializeActionCall(\n  actionCall: SerializedActionCall,\n  targetRoot?: object\n): ActionCall {\n  if (!actionCall.serialized) {\n    throw failure(\"cannot deserialize a non-serialized action call\")\n  }\n\n  if (targetRoot !== undefined) {\n    assertTweakedObject(targetRoot, \"targetRoot\")\n  }\n\n  const deserialize = (v: any) => deserializeActionCallArgument(v, targetRoot)\n  const deserializedActionCall: ActionCall = {\n    ...actionCall,\n    serialized: undefined,\n    args: actionCall.args.map(deserialize),\n  }\n  delete (deserializedActionCall as O.Writable<ActionCall>).serialized\n  return deserializedActionCall\n}\n\nlet defaultActionCallArgumentSerializersRegistered = false\n\nfunction registerDefaultActionCallArgumentSerializers() {\n  if (defaultActionCallArgumentSerializersRegistered) {\n    return\n  }\n  defaultActionCallArgumentSerializersRegistered = true\n\n  // serializer registration (from low priority to high priority)\n\n  registerActionCallArgumentSerializer(primitiveSerializer)\n  registerActionCallArgumentSerializer(plainObjectSerializer)\n  registerActionCallArgumentSerializer(setSerializer)\n  registerActionCallArgumentSerializer(mapSerializer)\n  registerActionCallArgumentSerializer(dateSerializer)\n  registerActionCallArgumentSerializer(arraySerializer)\n  registerActionCallArgumentSerializer(objectSnapshotSerializer)\n  registerActionCallArgumentSerializer(objectPathSerializer)\n}\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAeA,MAAM,mBAA6D;AACnE,MAAM,qCAAqB;8CAWzB;;MAII,iBAAiB,SAAS,UAAU,GAAG;UACnC,QAAQ,oDAAoD;AAAA;MAEhE,eAAe,IAAI,WAAW,EAAE,GAAG;UAC/B,QAAQ,4CAA4C,WAAW,wBAAwB;AAAA;mBAG9E,QAAQ,UAAU;iBACpB,IAAI,WAAW,IAAI,UAAU;SAErC;UACC,QAAQ,iBAAiB,QAAQ,UAAU;QAC7C,SAAS,GAAG;uBACG,OAAO,OAAO,CAAC;AAAA;mBAEnB,OAAO,WAAW,EAAE;AAAA;AAEvC;qCAmDE,UACA;;MAII,gBAAgB,QAAQ,GAAG;WACtB;AAAA;QAGH,YAAY;QAEZ,YAAY,CAAC,MAAW,4BAA4B,GAAG,UAAU;WAG9D,IAAI,GAAG,IAAI,iBAAiB,QAAQ,KAAK;UAC1C,aAAa,iBAAiB;UAC9B,kBAAkB,WAAW,UAAU,UAAU,WAAW,UAAU;QACxE,oBAAoB,iBAAiB;aAChC;AAAA,QACL,yBAAyB,WAAW;AAAA,QACpC,OAAO;AAAA;;;QAKP,QAAQ,oEAAoE,WAAW;AAC/F;6BAWE,YACA;MAEI,WAAW,YAAY;UACnB,QAAQ,oDAAoD;AAAA;MAGhE,eAAe,QAAW;wBACR,YAAY,YAAY;AAAA;QAGxC,YAAY,CAAC,MAAW,4BAA4B,GAAG,UAAU;SAEhE,iCACF,aADE;AAAA,IAEL,YAAY;AAAA,IACZ,MAAM,WAAW,KAAK,IAAI,SAAS;AAAA;AAEvC;uCAUE,UACA;;MAII,gBAAgB,QAAQ,GAAG;WACtB;AAAA;MAGL,CAAC,cAAc,QAAQ,KAAK,OAAO,SAAS,4BAA4B,UAAU;UAC9E,QAAQ,yCAAyC;AAAA;QAGnD,eAAe,SAAS;QACxB,aAAa,eAAe,IAAI,YAAY;MAE9C,CAAC,YAAY;UACT,QAAQ,yBAAyB,kCAAkC;AAAA;QAGrE,kBAAkB;QAElB,cAAc,CAAC,MAAW,8BAA8B,GAAG,UAAU;SACpE,WAAW,YAAY,gBAAgB,OAAO,aAAa,UAAU;AAC9E;+BAWE,YACA;MAEI,CAAC,WAAW,YAAY;UACpB,QAAQ,iDAAiD;AAAA;MAG7D,eAAe,QAAW;wBACR,YAAY,YAAY;AAAA;QAGxC,cAAc,CAAC,MAAW,8BAA8B,GAAG,UAAU;QACrE,yBAAqC,iCACtC,aADsC;AAAA,IAEzC,YAAY;AAAA,IACZ,MAAM,WAAW,KAAK,IAAI,WAAW;AAAA;SAE/B,uBAAkD;SACnD;AACT;AAEA,IAAI,iDAAiD;AAErD;MACM,gDAAgD;;;mDAGH;uCAIZ,mBAAmB;uCACnB,qBAAqB;uCACrB,aAAa;uCACb,aAAa;uCACb,cAAc;uCACd,eAAe;uCACf,wBAAwB;uCACxB,oBAAoB;AAC3D;;"}