@jbrowse/mobx-state-tree 5.7.1 → 5.8.7

package/dist/middlewares/on-action.js

@@ -1,215 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.applyAction = applyAction;
-exports.recordActions = recordActions;
-exports.onAction = onAction;
-const mobx_1 = require("mobx");
-const internal_ts_1 = require("../internal.js");
-function serializeArgument(node, actionName, index, arg) {
-    if (arg instanceof Date) {
-        return { $MST_DATE: arg.getTime() };
-    }
-    if ((0, internal_ts_1.isPrimitive)(arg)) {
-        return arg;
-    }
-    // We should not serialize MST nodes, even if we can, because we don't know if the receiving party can handle a raw snapshot instead of an
-    // MST type instance. So if one wants to serialize a MST node that was pass in, either explitly pass: 1: an id, 2: a (relative) path, 3: a snapshot
-    if ((0, internal_ts_1.isStateTreeNode)(arg)) {
-        return serializeTheUnserializable(`[MSTNode: ${(0, internal_ts_1.getType)(arg).name}]`);
-    }
-    if (typeof arg === "function") {
-        return serializeTheUnserializable(`[function]`);
-    }
-    if (typeof arg === "object" && !(0, internal_ts_1.isPlainObject)(arg) && !(0, internal_ts_1.isArray)(arg)) {
-        return serializeTheUnserializable(`[object ${(arg && arg.constructor && arg.constructor.name) ||
-            "Complex Object"}]`);
-    }
-    try {
-        // Check if serializable, cycle free etc...
-        // MWE: there must be a better way....
-        JSON.stringify(arg); // or throws
-        return arg;
-    }
-    catch (e) {
-        return serializeTheUnserializable("" + e);
-    }
-}
-function deserializeArgument(adm, value) {
-    if (value && typeof value === "object" && "$MST_DATE" in value) {
-        return new Date(value["$MST_DATE"]);
-    }
-    return value;
-}
-function serializeTheUnserializable(baseType) {
-    return {
-        $MST_UNSERIALIZABLE: true,
-        type: baseType
-    };
-}
-/**
- * Applies an action or a series of actions in a single MobX transaction.
- * Does not return any value
- * Takes an action description as produced by the `onAction` middleware.
- *
- * @param target
- * @param actions
- */
-function applyAction(target, actions) {
-    // check all arguments
-    (0, internal_ts_1.assertIsStateTreeNode)(target, 1);
-    (0, internal_ts_1.assertArg)(actions, a => typeof a === "object", "object or array", 2);
-    (0, mobx_1.runInAction)(() => {
-        (0, internal_ts_1.asArray)(actions).forEach(action => baseApplyAction(target, action));
-    });
-}
-function baseApplyAction(target, action) {
-    const resolvedTarget = (0, internal_ts_1.tryResolve)(target, action.path || "");
-    if (!resolvedTarget) {
-        throw (0, internal_ts_1.fail)(`Invalid action path: ${action.path || ""}`);
-    }
-    const node = (0, internal_ts_1.getStateTreeNode)(resolvedTarget);
-    // Reserved functions
-    if (action.name === "@APPLY_PATCHES") {
-        return internal_ts_1.applyPatch.call(null, resolvedTarget, action.args[0]);
-    }
-    if (action.name === "@APPLY_SNAPSHOT") {
-        return internal_ts_1.applySnapshot.call(null, resolvedTarget, action.args[0]);
-    }
-    if (!(typeof resolvedTarget[action.name] === "function")) {
-        throw (0, internal_ts_1.fail)(`Action '${action.name}' does not exist in '${node.path}'`);
-    }
-    return resolvedTarget[action.name](...(action.args ? action.args.map(v => deserializeArgument(node, v)) : []));
-}
-/**
- * Small abstraction around `onAction` and `applyAction`, attaches an action listener to a tree and records all the actions emitted.
- * Returns an recorder object with the following signature:
- *
- * Example:
- * ```ts
- * export interface IActionRecorder {
- *      // the recorded actions
- *      actions: ISerializedActionCall[]
- *      // true if currently recording
- *      recording: boolean
- *      // stop recording actions
- *      stop(): void
- *      // resume recording actions
- *      resume(): void
- *      // apply all the recorded actions on the given object
- *      replay(target: IAnyStateTreeNode): void
- * }
- * ```
- *
- * The optional filter function allows to skip recording certain actions.
- *
- * @param subject
- * @returns
- */
-function recordActions(subject, filter) {
-    // check all arguments
-    (0, internal_ts_1.assertIsStateTreeNode)(subject, 1);
-    const actions = [];
-    const listener = (call) => {
-        const recordThis = filter ? filter(call, (0, internal_ts_1.getRunningActionContext)()) : true;
-        if (recordThis) {
-            actions.push(call);
-        }
-    };
-    let disposer;
-    const recorder = {
-        actions,
-        get recording() {
-            return !!disposer;
-        },
-        stop() {
-            if (disposer) {
-                disposer();
-                disposer = undefined;
-            }
-        },
-        resume() {
-            if (disposer) {
-                return;
-            }
-            disposer = onAction(subject, listener);
-        },
-        replay(target) {
-            applyAction(target, actions);
-        }
-    };
-    recorder.resume();
-    return recorder;
-}
-/**
- * Registers a function that will be invoked for each action that is called on the provided model instance, or to any of its children.
- * See [actions](https://github.com/mobxjs/mobx-state-tree#actions) for more details. onAction events are emitted only for the outermost called action in the stack.
- * Action can also be intercepted by middleware using addMiddleware to change the function call before it will be run.
- *
- * Not all action arguments might be serializable. For unserializable arguments, a struct like `{ $MST_UNSERIALIZABLE: true, type: "someType" }` will be generated.
- * MST Nodes are considered non-serializable as well (they could be serialized as there snapshot, but it is uncertain whether an replaying party will be able to handle such a non-instantiated snapshot).
- * Rather, when using `onAction` middleware, one should consider in passing arguments which are 1: an id, 2: a (relative) path, or 3: a snapshot. Instead of a real MST node.
- *
- * Example:
- * ```ts
- * const Todo = types.model({
- *   task: types.string
- * })
- *
- * const TodoStore = types.model({
- *   todos: types.array(Todo)
- * }).actions(self => ({
- *   add(todo) {
- *     self.todos.push(todo);
- *   }
- * }))
- *
- * const s = TodoStore.create({ todos: [] })
- *
- * let disposer = onAction(s, (call) => {
- *   console.log(call);
- * })
- *
- * s.add({ task: "Grab a coffee" })
- * // Logs: { name: "add", path: "", args: [{ task: "Grab a coffee" }] }
- * ```
- *
- * @param target
- * @param listener
- * @param attachAfter (default false) fires the listener *after* the action has executed instead of before.
- * @returns
- */
-function onAction(target, listener, attachAfter = false) {
-    // check all arguments
-    (0, internal_ts_1.assertIsStateTreeNode)(target, 1);
-    if ((0, internal_ts_1.devMode)()) {
-        if (!(0, internal_ts_1.isRoot)(target)) {
-            (0, internal_ts_1.warnError)("Warning: Attaching onAction listeners to non root nodes is dangerous: No events will be emitted for actions initiated higher up in the tree.");
-        }
-        if (!(0, internal_ts_1.isProtected)(target)) {
-            (0, internal_ts_1.warnError)("Warning: Attaching onAction listeners to non protected nodes is dangerous: No events will be emitted for direct modifications without action.");
-        }
-    }
-    return (0, internal_ts_1.addMiddleware)(target, function handler(rawCall, next) {
-        if (rawCall.type === "action" && rawCall.id === rawCall.rootId) {
-            const sourceNode = (0, internal_ts_1.getStateTreeNode)(rawCall.context);
-            const info = {
-                name: rawCall.name,
-                path: (0, internal_ts_1.getRelativePathBetweenNodes)((0, internal_ts_1.getStateTreeNode)(target), sourceNode),
-                args: rawCall.args.map((arg, index) => serializeArgument(sourceNode, rawCall.name, index, arg))
-            };
-            if (attachAfter) {
-                const res = next(rawCall);
-                listener(info);
-                return res;
-            }
-            else {
-                listener(info);
-                return next(rawCall);
-            }
-        }
-        else {
-            return next(rawCall);
-        }
-    });
-}
-//# sourceMappingURL=on-action.js.map

package/dist/middlewares/on-action.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"on-action.js","sourceRoot":"","sources":["../../src/middlewares/on-action.ts"],"names":[],"mappings":";;AAuGA,kCAWC;AAqDD,sCA2CC;AAwCD,4BA0CC;AApSD,+BAAkC;AAElC,gDAyBuB;AAgBvB,SAAS,iBAAiB,CACxB,IAAa,EACb,UAAkB,EAClB,KAAa,EACb,GAAQ;IAER,IAAI,GAAG,YAAY,IAAI,EAAE,CAAC;QACxB,OAAO,EAAE,SAAS,EAAE,GAAG,CAAC,OAAO,EAAE,EAAE,CAAA;IACrC,CAAC;IACD,IAAI,IAAA,yBAAW,EAAC,GAAG,CAAC,EAAE,CAAC;QACrB,OAAO,GAAG,CAAA;IACZ,CAAC;IACD,0IAA0I;IAC1I,mJAAmJ;IACnJ,IAAI,IAAA,6BAAe,EAAC,GAAG,CAAC,EAAE,CAAC;QACzB,OAAO,0BAA0B,CAAC,aAAa,IAAA,qBAAO,EAAC,GAAG,CAAC,CAAC,IAAI,GAAG,CAAC,CAAA;IACtE,CAAC;IACD,IAAI,OAAO,GAAG,KAAK,UAAU,EAAE,CAAC;QAC9B,OAAO,0BAA0B,CAAC,YAAY,CAAC,CAAA;IACjD,CAAC;IACD,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,CAAC,IAAA,2BAAa,EAAC,GAAG,CAAC,IAAI,CAAC,IAAA,qBAAO,EAAC,GAAG,CAAC,EAAE,CAAC;QACpE,OAAO,0BAA0B,CAC/B,WACE,CAAC,GAAG,IAAK,GAAW,CAAC,WAAW,IAAK,GAAW,CAAC,WAAW,CAAC,IAAI,CAAC;YAClE,gBACF,GAAG,CACJ,CAAA;IACH,CAAC;IACD,IAAI,CAAC;QACH,2CAA2C;QAC3C,sCAAsC;QACtC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAA,CAAC,YAAY;QAChC,OAAO,GAAG,CAAA;IACZ,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,OAAO,0BAA0B,CAAC,EAAE,GAAG,CAAC,CAAC,CAAA;IAC3C,CAAC;AACH,CAAC;AAED,SAAS,mBAAmB,CAAC,GAAY,EAAE,KAAU;IACnD,IAAI,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,WAAW,IAAI,KAAK,EAAE,CAAC;QAC/D,OAAO,IAAI,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,CAAA;IACrC,CAAC;IACD,OAAO,KAAK,CAAA;AACd,CAAC;AAED,SAAS,0BAA0B,CAAC,QAAgB;IAClD,OAAO;QACL,mBAAmB,EAAE,IAAI;QACzB,IAAI,EAAE,QAAQ;KACf,CAAA;AACH,CAAC;AAED;;;;;;;GAOG;AACH,SAAgB,WAAW,CACzB,MAAyB,EACzB,OAAwD;IAExD,sBAAsB;IACtB,IAAA,mCAAqB,EAAC,MAAM,EAAE,CAAC,CAAC,CAAA;IAChC,IAAA,uBAAS,EAAC,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,OAAO,CAAC,KAAK,QAAQ,EAAE,iBAAiB,EAAE,CAAC,CAAC,CAAA;IAEpE,IAAA,kBAAW,EAAC,GAAG,EAAE;QACf,IAAA,qBAAO,EAAC,OAAO,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,eAAe,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;IACrE,CAAC,CAAC,CAAA;AACJ,CAAC;AAED,SAAS,eAAe,CACtB,MAAyB,EACzB,MAA6B;IAE7B,MAAM,cAAc,GAAG,IAAA,wBAAU,EAAC,MAAM,EAAE,MAAM,CAAC,IAAI,IAAI,EAAE,CAAC,CAAA;IAC5D,IAAI,CAAC,cAAc,EAAE,CAAC;QACpB,MAAM,IAAA,kBAAI,EAAC,wBAAwB,MAAM,CAAC,IAAI,IAAI,EAAE,EAAE,CAAC,CAAA;IACzD,CAAC;IACD,MAAM,IAAI,GAAG,IAAA,8BAAgB,EAAC,cAAc,CAAC,CAAA;IAE7C,qBAAqB;IACrB,IAAI,MAAM,CAAC,IAAI,KAAK,gBAAgB,EAAE,CAAC;QACrC,OAAO,wBAAU,CAAC,IAAI,CAAC,IAAI,EAAE,cAAc,EAAE,MAAM,CAAC,IAAK,CAAC,CAAC,CAAC,CAAC,CAAA;IAC/D,CAAC;IACD,IAAI,MAAM,CAAC,IAAI,KAAK,iBAAiB,EAAE,CAAC;QACtC,OAAO,2BAAa,CAAC,IAAI,CAAC,IAAI,EAAE,cAAc,EAAE,MAAM,CAAC,IAAK,CAAC,CAAC,CAAC,CAAC,CAAA;IAClE,CAAC;IAED,IAAI,CAAC,CAAC,OAAO,cAAc,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,UAAU,CAAC,EAAE,CAAC;QACzD,MAAM,IAAA,kBAAI,EAAC,WAAW,MAAM,CAAC,IAAI,wBAAwB,IAAI,CAAC,IAAI,GAAG,CAAC,CAAA;IACxE,CAAC;IACD,OAAO,cAAc,CAAC,MAAM,CAAC,IAAI,CAAC,CAChC,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,mBAAmB,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAC3E,CAAA;AACH,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,SAAgB,aAAa,CAC3B,OAA0B,EAC1B,MAGY;IAEZ,sBAAsB;IACtB,IAAA,mCAAqB,EAAC,OAAO,EAAE,CAAC,CAAC,CAAA;IAEjC,MAAM,OAAO,GAA4B,EAAE,CAAA;IAC3C,MAAM,QAAQ,GAAG,CAAC,IAA2B,EAAE,EAAE;QAC/C,MAAM,UAAU,GAAG,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,EAAE,IAAA,qCAAuB,GAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAA;QAC1E,IAAI,UAAU,EAAE,CAAC;YACf,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;QACpB,CAAC;IACH,CAAC,CAAA;IAED,IAAI,QAA+B,CAAA;IACnC,MAAM,QAAQ,GAAoB;QAChC,OAAO;QACP,IAAI,SAAS;YACX,OAAO,CAAC,CAAC,QAAQ,CAAA;QACnB,CAAC;QACD,IAAI;YACF,IAAI,QAAQ,EAAE,CAAC;gBACb,QAAQ,EAAE,CAAA;gBACV,QAAQ,GAAG,SAAS,CAAA;YACtB,CAAC;QACH,CAAC;QACD,MAAM;YACJ,IAAI,QAAQ,EAAE,CAAC;gBACb,OAAM;YACR,CAAC;YACD,QAAQ,GAAG,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAA;QACxC,CAAC;QACD,MAAM,CAAC,MAAM;YACX,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;QAC9B,CAAC;KACF,CAAA;IAED,QAAQ,CAAC,MAAM,EAAE,CAAA;IACjB,OAAO,QAAQ,CAAA;AACjB,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,SAAgB,QAAQ,CACtB,MAAyB,EACzB,QAA+C,EAC/C,WAAW,GAAG,KAAK;IAEnB,sBAAsB;IACtB,IAAA,mCAAqB,EAAC,MAAM,EAAE,CAAC,CAAC,CAAA;IAChC,IAAI,IAAA,qBAAO,GAAE,EAAE,CAAC;QACd,IAAI,CAAC,IAAA,oBAAM,EAAC,MAAM,CAAC,EAAE,CAAC;YACpB,IAAA,uBAAS,EACP,8IAA8I,CAC/I,CAAA;QACH,CAAC;QACD,IAAI,CAAC,IAAA,yBAAW,EAAC,MAAM,CAAC,EAAE,CAAC;YACzB,IAAA,uBAAS,EACP,+IAA+I,CAChJ,CAAA;QACH,CAAC;IACH,CAAC;IAED,OAAO,IAAA,2BAAa,EAAC,MAAM,EAAE,SAAS,OAAO,CAAC,OAAO,EAAE,IAAI;QACzD,IAAI,OAAO,CAAC,IAAI,KAAK,QAAQ,IAAI,OAAO,CAAC,EAAE,KAAK,OAAO,CAAC,MAAM,EAAE,CAAC;YAC/D,MAAM,UAAU,GAAG,IAAA,8BAAgB,EAAC,OAAO,CAAC,OAAO,CAAC,CAAA;YACpD,MAAM,IAAI,GAAG;gBACX,IAAI,EAAE,OAAO,CAAC,IAAI;gBAClB,IAAI,EAAE,IAAA,yCAA2B,EAAC,IAAA,8BAAgB,EAAC,MAAM,CAAC,EAAE,UAAU,CAAC;gBACvE,IAAI,EAAE,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,GAAQ,EAAE,KAAa,EAAE,EAAE,CACjD,iBAAiB,CAAC,UAAU,EAAE,OAAO,CAAC,IAAI,EAAE,KAAK,EAAE,GAAG,CAAC,CACxD;aACF,CAAA;YACD,IAAI,WAAW,EAAE,CAAC;gBAChB,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,CAAA;gBACzB,QAAQ,CAAC,IAAI,CAAC,CAAA;gBACd,OAAO,GAAG,CAAA;YACZ,CAAC;iBAAM,CAAC;gBACN,QAAQ,CAAC,IAAI,CAAC,CAAA;gBACd,OAAO,IAAI,CAAC,OAAO,CAAC,CAAA;YACtB,CAAC;QACH,CAAC;aAAM,CAAC;YACN,OAAO,IAAI,CAAC,OAAO,CAAC,CAAA;QACtB,CAAC;IACH,CAAC,CAAC,CAAA;AACJ,CAAC","sourcesContent":["import { runInAction } from \"mobx\"\n\nimport {\n  type AnyNode,\n  type IActionContext,\n  type IAnyStateTreeNode,\n  type IDisposer,\n  addMiddleware,\n  applyPatch,\n  applySnapshot,\n  asArray,\n  assertArg,\n  assertIsStateTreeNode,\n  devMode,\n  fail,\n  getRelativePathBetweenNodes,\n  getRunningActionContext,\n  getStateTreeNode,\n  getType,\n  isArray,\n  isPlainObject,\n  isPrimitive,\n  isProtected,\n  isRoot,\n  isStateTreeNode,\n  tryResolve,\n  warnError\n} from \"../internal.ts\"\n\nexport interface ISerializedActionCall {\n  name: string\n  path?: string\n  args?: any[]\n}\n\nexport interface IActionRecorder {\n  actions: ReadonlyArray<ISerializedActionCall>\n  readonly recording: boolean\n  stop(): void\n  resume(): void\n  replay(target: IAnyStateTreeNode): void\n}\n\nfunction serializeArgument(\n  node: AnyNode,\n  actionName: string,\n  index: number,\n  arg: any\n): any {\n  if (arg instanceof Date) {\n    return { $MST_DATE: arg.getTime() }\n  }\n  if (isPrimitive(arg)) {\n    return arg\n  }\n  // We should not serialize MST nodes, even if we can, because we don't know if the receiving party can handle a raw snapshot instead of an\n  // MST type instance. So if one wants to serialize a MST node that was pass in, either explitly pass: 1: an id, 2: a (relative) path, 3: a snapshot\n  if (isStateTreeNode(arg)) {\n    return serializeTheUnserializable(`[MSTNode: ${getType(arg).name}]`)\n  }\n  if (typeof arg === \"function\") {\n    return serializeTheUnserializable(`[function]`)\n  }\n  if (typeof arg === \"object\" && !isPlainObject(arg) && !isArray(arg)) {\n    return serializeTheUnserializable(\n      `[object ${\n        (arg && (arg as any).constructor && (arg as any).constructor.name) ||\n        \"Complex Object\"\n      }]`\n    )\n  }\n  try {\n    // Check if serializable, cycle free etc...\n    // MWE: there must be a better way....\n    JSON.stringify(arg) // or throws\n    return arg\n  } catch (e) {\n    return serializeTheUnserializable(\"\" + e)\n  }\n}\n\nfunction deserializeArgument(adm: AnyNode, value: any): any {\n  if (value && typeof value === \"object\" && \"$MST_DATE\" in value) {\n    return new Date(value[\"$MST_DATE\"])\n  }\n  return value\n}\n\nfunction serializeTheUnserializable(baseType: string) {\n  return {\n    $MST_UNSERIALIZABLE: true,\n    type: baseType\n  }\n}\n\n/**\n * Applies an action or a series of actions in a single MobX transaction.\n * Does not return any value\n * Takes an action description as produced by the `onAction` middleware.\n *\n * @param target\n * @param actions\n */\nexport function applyAction(\n  target: IAnyStateTreeNode,\n  actions: ISerializedActionCall | ISerializedActionCall[]\n): void {\n  // check all arguments\n  assertIsStateTreeNode(target, 1)\n  assertArg(actions, a => typeof a === \"object\", \"object or array\", 2)\n\n  runInAction(() => {\n    asArray(actions).forEach(action => baseApplyAction(target, action))\n  })\n}\n\nfunction baseApplyAction(\n  target: IAnyStateTreeNode,\n  action: ISerializedActionCall\n): any {\n  const resolvedTarget = tryResolve(target, action.path || \"\")\n  if (!resolvedTarget) {\n    throw fail(`Invalid action path: ${action.path || \"\"}`)\n  }\n  const node = getStateTreeNode(resolvedTarget)\n\n  // Reserved functions\n  if (action.name === \"@APPLY_PATCHES\") {\n    return applyPatch.call(null, resolvedTarget, action.args![0])\n  }\n  if (action.name === \"@APPLY_SNAPSHOT\") {\n    return applySnapshot.call(null, resolvedTarget, action.args![0])\n  }\n\n  if (!(typeof resolvedTarget[action.name] === \"function\")) {\n    throw fail(`Action '${action.name}' does not exist in '${node.path}'`)\n  }\n  return resolvedTarget[action.name](\n    ...(action.args ? action.args.map(v => deserializeArgument(node, v)) : [])\n  )\n}\n\n/**\n * Small abstraction around `onAction` and `applyAction`, attaches an action listener to a tree and records all the actions emitted.\n * Returns an recorder object with the following signature:\n *\n * Example:\n * ```ts\n * export interface IActionRecorder {\n *      // the recorded actions\n *      actions: ISerializedActionCall[]\n *      // true if currently recording\n *      recording: boolean\n *      // stop recording actions\n *      stop(): void\n *      // resume recording actions\n *      resume(): void\n *      // apply all the recorded actions on the given object\n *      replay(target: IAnyStateTreeNode): void\n * }\n * ```\n *\n * The optional filter function allows to skip recording certain actions.\n *\n * @param subject\n * @returns\n */\nexport function recordActions(\n  subject: IAnyStateTreeNode,\n  filter?: (\n    action: ISerializedActionCall,\n    actionContext: IActionContext | undefined\n  ) => boolean\n): IActionRecorder {\n  // check all arguments\n  assertIsStateTreeNode(subject, 1)\n\n  const actions: ISerializedActionCall[] = []\n  const listener = (call: ISerializedActionCall) => {\n    const recordThis = filter ? filter(call, getRunningActionContext()) : true\n    if (recordThis) {\n      actions.push(call)\n    }\n  }\n\n  let disposer: IDisposer | undefined\n  const recorder: IActionRecorder = {\n    actions,\n    get recording() {\n      return !!disposer\n    },\n    stop() {\n      if (disposer) {\n        disposer()\n        disposer = undefined\n      }\n    },\n    resume() {\n      if (disposer) {\n        return\n      }\n      disposer = onAction(subject, listener)\n    },\n    replay(target) {\n      applyAction(target, actions)\n    }\n  }\n\n  recorder.resume()\n  return recorder\n}\n\n/**\n * Registers a function that will be invoked for each action that is called on the provided model instance, or to any of its children.\n * See [actions](https://github.com/mobxjs/mobx-state-tree#actions) for more details. onAction events are emitted only for the outermost called action in the stack.\n * Action can also be intercepted by middleware using addMiddleware to change the function call before it will be run.\n *\n * Not all action arguments might be serializable. For unserializable arguments, a struct like `{ $MST_UNSERIALIZABLE: true, type: \"someType\" }` will be generated.\n * MST Nodes are considered non-serializable as well (they could be serialized as there snapshot, but it is uncertain whether an replaying party will be able to handle such a non-instantiated snapshot).\n * Rather, when using `onAction` middleware, one should consider in passing arguments which are 1: an id, 2: a (relative) path, or 3: a snapshot. Instead of a real MST node.\n *\n * Example:\n * ```ts\n * const Todo = types.model({\n *   task: types.string\n * })\n *\n * const TodoStore = types.model({\n *   todos: types.array(Todo)\n * }).actions(self => ({\n *   add(todo) {\n *     self.todos.push(todo);\n *   }\n * }))\n *\n * const s = TodoStore.create({ todos: [] })\n *\n * let disposer = onAction(s, (call) => {\n *   console.log(call);\n * })\n *\n * s.add({ task: \"Grab a coffee\" })\n * // Logs: { name: \"add\", path: \"\", args: [{ task: \"Grab a coffee\" }] }\n * ```\n *\n * @param target\n * @param listener\n * @param attachAfter (default false) fires the listener *after* the action has executed instead of before.\n * @returns\n */\nexport function onAction(\n  target: IAnyStateTreeNode,\n  listener: (call: ISerializedActionCall) => void,\n  attachAfter = false\n): IDisposer {\n  // check all arguments\n  assertIsStateTreeNode(target, 1)\n  if (devMode()) {\n    if (!isRoot(target)) {\n      warnError(\n        \"Warning: Attaching onAction listeners to non root nodes is dangerous: No events will be emitted for actions initiated higher up in the tree.\"\n      )\n    }\n    if (!isProtected(target)) {\n      warnError(\n        \"Warning: Attaching onAction listeners to non protected nodes is dangerous: No events will be emitted for direct modifications without action.\"\n      )\n    }\n  }\n\n  return addMiddleware(target, function handler(rawCall, next) {\n    if (rawCall.type === \"action\" && rawCall.id === rawCall.rootId) {\n      const sourceNode = getStateTreeNode(rawCall.context)\n      const info = {\n        name: rawCall.name,\n        path: getRelativePathBetweenNodes(getStateTreeNode(target), sourceNode),\n        args: rawCall.args.map((arg: any, index: number) =>\n          serializeArgument(sourceNode, rawCall.name, index, arg)\n        )\n      }\n      if (attachAfter) {\n        const res = next(rawCall)\n        listener(info)\n        return res\n      } else {\n        listener(info)\n        return next(rawCall)\n      }\n    } else {\n      return next(rawCall)\n    }\n  })\n}\n"]}

package/dist/package.json

@@ -1 +0,0 @@
-{"type": "commonjs"}

package/dist/types/complex-types/array.d.ts

@@ -1,81 +0,0 @@
-import { type IArrayDidChange, type IArraySplice, type IArrayWillChange, type IArrayWillSplice, type IObservableArray } from "mobx";
-import { ComplexType } from "../../core/type/type.ts";
-import { type AnyNode, type AnyObjectNode, type ExtractCSTWithSTN, type IAnyType, type IChildNodesMap, type IHooksGetter, type IJsonPatch, type IType, type IValidationContext, type IValidationResult, TypeFlags } from "../../internal.ts";
-/** @hidden */
-export interface IMSTArray<IT extends IAnyType> extends IObservableArray<IT["Type"]> {
-    push(...items: IT["Type"][]): number;
-    push(...items: ExtractCSTWithSTN<IT>[]): number;
-    concat(...items: ConcatArray<IT["Type"]>[]): IT["Type"][];
-    concat(...items: ConcatArray<ExtractCSTWithSTN<IT>>[]): IT["Type"][];
-    concat(...items: (IT["Type"] | ConcatArray<IT["Type"]>)[]): IT["Type"][];
-    concat(...items: (ExtractCSTWithSTN<IT> | ConcatArray<ExtractCSTWithSTN<IT>>)[]): IT["Type"][];
-    splice(start: number, deleteCount?: number): IT["Type"][];
-    splice(start: number, deleteCount: number, ...items: IT["Type"][]): IT["Type"][];
-    splice(start: number, deleteCount: number, ...items: ExtractCSTWithSTN<IT>[]): IT["Type"][];
-    unshift(...items: IT["Type"][]): number;
-    unshift(...items: ExtractCSTWithSTN<IT>[]): number;
-}
-/** @hidden */
-export interface IArrayType<IT extends IAnyType> extends IType<readonly IT["CreationType"][] | undefined, IT["SnapshotType"][], IMSTArray<IT>> {
-    hooks(hooks: IHooksGetter<IMSTArray<IAnyType>>): IArrayType<IT>;
-}
-/**
- * @internal
- * @hidden
- */
-export declare class ArrayType<IT extends IAnyType> extends ComplexType<readonly IT["CreationType"][] | undefined, IT["SnapshotType"][], IMSTArray<IT>> {
-    private readonly _subType;
-    readonly flags = TypeFlags.Array;
-    private readonly hookInitializers;
-    constructor(name: string, _subType: IT, hookInitializers?: Array<IHooksGetter<IMSTArray<IT>>>);
-    hooks(hooks: IHooksGetter<IMSTArray<IT>>): ArrayType<IT>;
-    instantiate(parent: AnyObjectNode | null, subpath: string, environment: any, initialValue: this["C"] | this["T"]): this["N"];
-    initializeChildNodes(objNode: this["N"], snapshot?: this["C"]): IChildNodesMap;
-    createNewInstance(childNodes: IChildNodesMap): this["T"];
-    finalizeNewInstance(node: this["N"], instance: this["T"]): void;
-    describe(): string;
-    getChildren(node: this["N"]): AnyNode[];
-    getChildNode(node: this["N"], key: string): AnyNode;
-    willChange(change: IArrayWillChange<AnyNode> | IArrayWillSplice<AnyNode>): IArrayWillChange<AnyNode> | IArrayWillSplice<AnyNode> | null;
-    getSnapshot(node: this["N"]): this["S"];
-    processInitialSnapshot(childNodes: IChildNodesMap): this["S"];
-    didChange(change: IArrayDidChange<AnyNode> | IArraySplice<AnyNode>): void;
-    applyPatchLocally(node: this["N"], subpath: string, patch: IJsonPatch): void;
-    applySnapshot(node: this["N"], snapshot: this["C"]): void;
-    getChildType(): IAnyType;
-    isValidSnapshot(value: this["C"], context: IValidationContext): IValidationResult;
-    getDefaultSnapshot(): this["C"];
-    removeChild(node: this["N"], subpath: string): void;
-}
-/**
- * `types.array` - Creates an index based collection type who's children are all of a uniform declared type.
- *
- * This type will always produce [observable arrays](https://mobx.js.org/api.html#observablearray)
- *
- * Example:
- * ```ts
- * const Todo = types.model({
- *   task: types.string
- * })
- *
- * const TodoStore = types.model({
- *   todos: types.array(Todo)
- * })
- *
- * const s = TodoStore.create({ todos: [] })
- * unprotect(s) // needed to allow modifying outside of an action
- * s.todos.push({ task: "Grab coffee" })
- * console.log(s.todos[0]) // prints: "Grab coffee"
- * ```
- *
- * @param subtype
- * @returns
- */
-export declare function array<IT extends IAnyType>(subtype: IT): IArrayType<IT>;
-/**
- * Returns if a given value represents an array type.
- *
- * @param type
- * @returns `true` if the type is an array type.
- */
-export declare function isArrayType<Items extends IAnyType = IAnyType>(type: IAnyType): type is IArrayType<Items>;

package/dist/types/complex-types/array.js

@@ -1,353 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ArrayType = void 0;
-exports.array = array;
-exports.isArrayType = isArrayType;
-const mobx_1 = require("mobx");
-const type_ts_1 = require("../../core/type/type.js");
-const internal_ts_1 = require("../../internal.js");
-/**
- * @internal
- * @hidden
- */
-class ArrayType extends type_ts_1.ComplexType {
-    _subType;
-    flags = internal_ts_1.TypeFlags.Array;
-    hookInitializers = [];
-    constructor(name, _subType, hookInitializers = []) {
-        super(name);
-        this._subType = _subType;
-        this.hookInitializers = hookInitializers;
-    }
-    hooks(hooks) {
-        const hookInitializers = this.hookInitializers.length > 0
-            ? this.hookInitializers.concat(hooks)
-            : [hooks];
-        return new ArrayType(this.name, this._subType, hookInitializers);
-    }
-    instantiate(parent, subpath, environment, initialValue) {
-        return (0, internal_ts_1.createObjectNode)(this, parent, subpath, environment, initialValue);
-    }
-    initializeChildNodes(objNode, snapshot = []) {
-        const subType = objNode.type._subType;
-        const result = {};
-        snapshot.forEach((item, index) => {
-            const subpath = "" + index;
-            result[subpath] = subType.instantiate(objNode, subpath, undefined, item);
-        });
-        return result;
-    }
-    createNewInstance(childNodes) {
-        const options = { ...internal_ts_1.mobxShallow, name: this.name };
-        return mobx_1.observable.array((0, internal_ts_1.convertChildNodesToArray)(childNodes), options);
-    }
-    finalizeNewInstance(node, instance) {
-        (0, mobx_1._getAdministration)(instance).dehancer = node.unbox;
-        const type = node.type;
-        type.hookInitializers.forEach(initializer => {
-            const hooks = initializer(instance);
-            Object.keys(hooks).forEach(name => {
-                const hook = hooks[name];
-                const actionInvoker = (0, internal_ts_1.createActionInvoker)(instance, name, hook);
-                (!(0, internal_ts_1.devMode)() ? internal_ts_1.addHiddenFinalProp : internal_ts_1.addHiddenWritableProp)(instance, name, actionInvoker);
-            });
-        });
-        (0, mobx_1.intercept)(instance, this.willChange);
-        (0, mobx_1.observe)(instance, this.didChange);
-    }
-    describe() {
-        return this.name;
-    }
-    getChildren(node) {
-        return node.storedValue.slice();
-    }
-    getChildNode(node, key) {
-        const index = Number(key);
-        if (index < node.storedValue.length) {
-            return node.storedValue[index];
-        }
-        throw (0, internal_ts_1.fail)("Not a child: " + key);
-    }
-    willChange(change) {
-        const node = (0, internal_ts_1.getStateTreeNode)(change.object);
-        node.assertWritable({ subpath: "" + change.index });
-        const subType = node.type._subType;
-        const childNodes = node.getChildren();
-        switch (change.type) {
-            case "update":
-                {
-                    if (change.newValue === change.object[change.index]) {
-                        return null;
-                    }
-                    const updatedNodes = reconcileArrayChildren(node, subType, [childNodes[change.index]], [change.newValue], [change.index]);
-                    if (!updatedNodes) {
-                        return null;
-                    }
-                    change.newValue = updatedNodes[0];
-                }
-                break;
-            case "splice":
-                {
-                    const { index, removedCount, added } = change;
-                    const addedNodes = reconcileArrayChildren(node, subType, childNodes.slice(index, index + removedCount), added, added.map((_, i) => index + i));
-                    if (!addedNodes) {
-                        return null;
-                    }
-                    change.added = addedNodes;
-                    // update paths of remaining items
-                    for (let i = index + removedCount; i < childNodes.length; i++) {
-                        childNodes[i].setParent(node, "" + (i + added.length - removedCount));
-                    }
-                }
-                break;
-        }
-        return change;
-    }
-    getSnapshot(node) {
-        return node.getChildren().map(childNode => childNode.snapshot);
-    }
-    processInitialSnapshot(childNodes) {
-        const processed = [];
-        Object.keys(childNodes).forEach(key => {
-            processed.push(childNodes[key].getSnapshot());
-        });
-        return processed;
-    }
-    didChange(change) {
-        const node = (0, internal_ts_1.getStateTreeNode)(change.object);
-        switch (change.type) {
-            case "update":
-                return void node.emitPatch({
-                    op: "replace",
-                    path: "" + change.index,
-                    value: change.newValue.snapshot,
-                    oldValue: change.oldValue ? change.oldValue.snapshot : undefined
-                }, node);
-            case "splice":
-                for (let i = change.removedCount - 1; i >= 0; i--) {
-                    node.emitPatch({
-                        op: "remove",
-                        path: "" + (change.index + i),
-                        oldValue: change.removed[i].snapshot
-                    }, node);
-                }
-                for (let i = 0; i < change.addedCount; i++) {
-                    node.emitPatch({
-                        op: "add",
-                        path: "" + (change.index + i),
-                        value: node.getChildNode("" + (change.index + i)).snapshot,
-                        oldValue: undefined
-                    }, node);
-                }
-                return;
-        }
-    }
-    applyPatchLocally(node, subpath, patch) {
-        const target = node.storedValue;
-        const index = subpath === "-" ? target.length : Number(subpath);
-        switch (patch.op) {
-            case "replace":
-                target[index] = patch.value;
-                break;
-            case "add":
-                target.splice(index, 0, patch.value);
-                break;
-            case "remove":
-                target.splice(index, 1);
-                break;
-        }
-    }
-    applySnapshot(node, snapshot) {
-        (0, internal_ts_1.typecheckInternal)(this, snapshot);
-        const target = node.storedValue;
-        target.replace(snapshot);
-    }
-    getChildType() {
-        return this._subType;
-    }
-    isValidSnapshot(value, context) {
-        if (!(0, internal_ts_1.isArray)(value)) {
-            return (0, internal_ts_1.typeCheckFailure)(context, value, "Value is not an array");
-        }
-        for (let i = 0; i < value.length; i++) {
-            (0, internal_ts_1.getContextForPath)(context, "" + i, this._subType);
-            const errors = this._subType.validate(value[i], context);
-            (0, internal_ts_1.popContext)(context);
-            if (errors.length > 0) {
-                return errors;
-            }
-        }
-        return (0, internal_ts_1.typeCheckSuccess)();
-    }
-    getDefaultSnapshot() {
-        return internal_ts_1.EMPTY_ARRAY;
-    }
-    removeChild(node, subpath) {
-        node.storedValue.splice(Number(subpath), 1);
-    }
-}
-exports.ArrayType = ArrayType;
-ArrayType.prototype.applySnapshot = (0, mobx_1.action)(ArrayType.prototype.applySnapshot);
-/**
- * `types.array` - Creates an index based collection type who's children are all of a uniform declared type.
- *
- * This type will always produce [observable arrays](https://mobx.js.org/api.html#observablearray)
- *
- * Example:
- * ```ts
- * const Todo = types.model({
- *   task: types.string
- * })
- *
- * const TodoStore = types.model({
- *   todos: types.array(Todo)
- * })
- *
- * const s = TodoStore.create({ todos: [] })
- * unprotect(s) // needed to allow modifying outside of an action
- * s.todos.push({ task: "Grab coffee" })
- * console.log(s.todos[0]) // prints: "Grab coffee"
- * ```
- *
- * @param subtype
- * @returns
- */
-function array(subtype) {
-    (0, internal_ts_1.assertIsType)(subtype, 1);
-    return new ArrayType(`${subtype.name}[]`, subtype);
-}
-function reconcileArrayChildren(parent, childType, oldNodes, newValues, newPaths) {
-    let nothingChanged = true;
-    for (let i = 0;; i++) {
-        const hasNewNode = i <= newValues.length - 1;
-        const oldNode = oldNodes[i];
-        let newValue = hasNewNode ? newValues[i] : undefined;
-        const newPath = "" + newPaths[i];
-        // for some reason, instead of newValue we got a node, fallback to the storedValue
-        // TODO: https://github.com/mobxjs/mobx-state-tree/issues/340#issuecomment-325581681
-        if ((0, internal_ts_1.isNode)(newValue)) {
-            newValue = newValue.storedValue;
-        }
-        if (!oldNode && !hasNewNode) {
-            // both are empty, end
-            break;
-        }
-        else if (!hasNewNode) {
-            // new one does not exists
-            nothingChanged = false;
-            oldNodes.splice(i, 1);
-            if (oldNode instanceof internal_ts_1.ObjectNode) {
-                // since it is going to be returned by pop/splice/shift better create it before killing it
-                // so it doesn't end up in an undead state
-                oldNode.createObservableInstanceIfNeeded();
-            }
-            oldNode.die();
-            i--;
-        }
-        else if (!oldNode) {
-            // there is no old node, create it
-            // check if already belongs to the same parent. if so, avoid pushing item in. only swapping can occur.
-            if ((0, internal_ts_1.isStateTreeNode)(newValue) &&
-                (0, internal_ts_1.getStateTreeNode)(newValue).parent === parent) {
-                // this node is owned by this parent, but not in the reconcilable set, so it must be double
-                throw (0, internal_ts_1.fail)(`Cannot add an object to a state tree if it is already part of the same or another state tree. Tried to assign an object to '${parent.path}/${newPath}', but it lives already at '${(0, internal_ts_1.getStateTreeNode)(newValue).path}'`);
-            }
-            nothingChanged = false;
-            const newNode = valueAsNode(childType, parent, newPath, newValue);
-            oldNodes.splice(i, 0, newNode);
-        }
-        else if (areSame(oldNode, newValue)) {
-            // both are the same, reconcile
-            oldNodes[i] = valueAsNode(childType, parent, newPath, newValue, oldNode);
-        }
-        else {
-            // nothing to do, try to reorder
-            let oldMatch = undefined;
-            // find a possible candidate to reuse
-            for (let j = i; j < oldNodes.length; j++) {
-                if (areSame(oldNodes[j], newValue)) {
-                    oldMatch = oldNodes.splice(j, 1)[0];
-                    break;
-                }
-            }
-            nothingChanged = false;
-            const newNode = valueAsNode(childType, parent, newPath, newValue, oldMatch);
-            oldNodes.splice(i, 0, newNode);
-        }
-    }
-    return nothingChanged ? null : oldNodes;
-}
-/**
- * Convert a value to a node at given parent and subpath. Attempts to reuse old node if possible and given.
- */
-function valueAsNode(childType, parent, subpath, newValue, oldNode) {
-    // ensure the value is valid-ish
-    (0, internal_ts_1.typecheckInternal)(childType, newValue);
-    function getNewNode() {
-        // the new value has a MST node
-        if ((0, internal_ts_1.isStateTreeNode)(newValue)) {
-            const childNode = (0, internal_ts_1.getStateTreeNode)(newValue);
-            childNode.assertAlive(internal_ts_1.EMPTY_OBJECT);
-            // the node lives here
-            if (childNode.parent !== null && childNode.parent === parent) {
-                childNode.setParent(parent, subpath);
-                return childNode;
-            }
-        }
-        // there is old node and new one is a value/snapshot
-        if (oldNode) {
-            return childType.reconcile(oldNode, newValue, parent, subpath);
-        }
-        // nothing to do, create from scratch
-        return childType.instantiate(parent, subpath, undefined, newValue);
-    }
-    const newNode = getNewNode();
-    if (oldNode && oldNode !== newNode) {
-        if (oldNode instanceof internal_ts_1.ObjectNode) {
-            // since it is going to be returned by pop/splice/shift better create it before killing it
-            // so it doesn't end up in an undead state
-            oldNode.createObservableInstanceIfNeeded();
-        }
-        oldNode.die();
-    }
-    return newNode;
-}
-/**
- * Check if a node holds a value.
- */
-function areSame(oldNode, newValue) {
-    // never consider dead old nodes for reconciliation
-    if (!oldNode.isAlive) {
-        return false;
-    }
-    // the new value has the same node
-    if ((0, internal_ts_1.isStateTreeNode)(newValue)) {
-        const newNode = (0, internal_ts_1.getStateTreeNode)(newValue);
-        return newNode.isAlive && newNode === oldNode;
-    }
-    // the provided value is the snapshot of the old node
-    if (oldNode.snapshot === newValue) {
-        return true;
-    }
-    // Non object nodes don't get reconciled
-    if (!(oldNode instanceof internal_ts_1.ObjectNode)) {
-        return false;
-    }
-    const oldNodeType = oldNode.getReconciliationType();
-    // new value is a snapshot with the correct identifier
-    return (oldNode.identifier !== null &&
-        oldNode.identifierAttribute &&
-        (0, internal_ts_1.isPlainObject)(newValue) &&
-        oldNodeType.is(newValue) &&
-        oldNodeType.isMatchingSnapshotId(oldNode, newValue));
-}
-/**
- * Returns if a given value represents an array type.
- *
- * @param type
- * @returns `true` if the type is an array type.
- */
-function isArrayType(type) {
-    return (0, internal_ts_1.isType)(type) && (type.flags & internal_ts_1.TypeFlags.Array) > 0;
-}
-//# sourceMappingURL=array.js.map