@jbrowse/mobx-state-tree 5.7.0 → 5.8.6

package/esm/internal.js

@@ -1,44 +0,0 @@
-/*
- * All imports / exports should be proxied through this file.
- * Why? It gives us full control over the module load order, preventing circular dependency isses
- */
-export * from "./core/node/livelinessChecking.js";
-export * from "./core/node/Hook.js";
-export * from "./core/mst-operations.js";
-export * from "./core/node/BaseNode.js";
-export * from "./core/node/scalar-node.js";
-export * from "./core/node/object-node.js";
-export * from "./core/type/type.js";
-export * from "./middlewares/create-action-tracking-middleware.js";
-export * from "./middlewares/createActionTrackingMiddleware2.js";
-export * from "./middlewares/on-action.js";
-export * from "./core/action.js";
-export * from "./core/actionContext.js";
-export * from "./core/type/type-checker.js";
-export * from "./core/node/identifier-cache.js";
-export * from "./core/node/create-node.js";
-export * from "./core/node/node-utils.js";
-export * from "./core/process.js";
-export * from "./core/flow.js";
-export * from "./core/json-patch.js";
-export * from "./utils.js";
-export * from "./types/utility-types/snapshotProcessor.js";
-export * from "./types/complex-types/map.js";
-export * from "./types/complex-types/array.js";
-export * from "./types/complex-types/model.js";
-export * from "./types/primitives.js";
-export * from "./types/utility-types/literal.js";
-export * from "./types/utility-types/refinement.js";
-export * from "./types/utility-types/enumeration.js";
-export * from "./types/utility-types/union.js";
-export * from "./types/utility-types/optional.js";
-export * from "./types/utility-types/maybe.js";
-export * from "./types/utility-types/late.js";
-export * from "./types/utility-types/lazy.js";
-export * from "./types/utility-types/frozen.js";
-export * from "./types/utility-types/reference.js";
-export * from "./types/utility-types/identifier.js";
-export * from "./types/utility-types/custom.js";
-export * from "./types/utility-types/resilient.js";
-export * from "./types/index.js";
-//# sourceMappingURL=internal.js.map

package/esm/internal.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"internal.js","sourceRoot":"","sources":["../src/internal.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,cAAc,mCAAmC,CAAA;AACjD,cAAc,qBAAqB,CAAA;AACnC,cAAc,0BAA0B,CAAA;AACxC,cAAc,yBAAyB,CAAA;AACvC,cAAc,4BAA4B,CAAA;AAC1C,cAAc,4BAA4B,CAAA;AAC1C,cAAc,qBAAqB,CAAA;AACnC,cAAc,oDAAoD,CAAA;AAClE,cAAc,kDAAkD,CAAA;AAChE,cAAc,4BAA4B,CAAA;AAC1C,cAAc,kBAAkB,CAAA;AAChC,cAAc,yBAAyB,CAAA;AACvC,cAAc,6BAA6B,CAAA;AAC3C,cAAc,iCAAiC,CAAA;AAC/C,cAAc,4BAA4B,CAAA;AAC1C,cAAc,2BAA2B,CAAA;AACzC,cAAc,mBAAmB,CAAA;AACjC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,sBAAsB,CAAA;AACpC,cAAc,YAAY,CAAA;AAC1B,cAAc,4CAA4C,CAAA;AAC1D,cAAc,8BAA8B,CAAA;AAC5C,cAAc,gCAAgC,CAAA;AAC9C,cAAc,gCAAgC,CAAA;AAC9C,cAAc,uBAAuB,CAAA;AACrC,cAAc,kCAAkC,CAAA;AAChD,cAAc,qCAAqC,CAAA;AACnD,cAAc,sCAAsC,CAAA;AACpD,cAAc,gCAAgC,CAAA;AAC9C,cAAc,mCAAmC,CAAA;AACjD,cAAc,gCAAgC,CAAA;AAC9C,cAAc,+BAA+B,CAAA;AAC7C,cAAc,+BAA+B,CAAA;AAC7C,cAAc,iCAAiC,CAAA;AAC/C,cAAc,oCAAoC,CAAA;AAClD,cAAc,qCAAqC,CAAA;AACnD,cAAc,iCAAiC,CAAA;AAC/C,cAAc,oCAAoC,CAAA;AAClD,cAAc,kBAAkB,CAAA","sourcesContent":["/*\n * All imports / exports should be proxied through this file.\n * Why? It gives us full control over the module load order, preventing circular dependency isses\n */\n\nexport * from \"./core/node/livelinessChecking.ts\"\nexport * from \"./core/node/Hook.ts\"\nexport * from \"./core/mst-operations.ts\"\nexport * from \"./core/node/BaseNode.ts\"\nexport * from \"./core/node/scalar-node.ts\"\nexport * from \"./core/node/object-node.ts\"\nexport * from \"./core/type/type.ts\"\nexport * from \"./middlewares/create-action-tracking-middleware.ts\"\nexport * from \"./middlewares/createActionTrackingMiddleware2.ts\"\nexport * from \"./middlewares/on-action.ts\"\nexport * from \"./core/action.ts\"\nexport * from \"./core/actionContext.ts\"\nexport * from \"./core/type/type-checker.ts\"\nexport * from \"./core/node/identifier-cache.ts\"\nexport * from \"./core/node/create-node.ts\"\nexport * from \"./core/node/node-utils.ts\"\nexport * from \"./core/process.ts\"\nexport * from \"./core/flow.ts\"\nexport * from \"./core/json-patch.ts\"\nexport * from \"./utils.ts\"\nexport * from \"./types/utility-types/snapshotProcessor.ts\"\nexport * from \"./types/complex-types/map.ts\"\nexport * from \"./types/complex-types/array.ts\"\nexport * from \"./types/complex-types/model.ts\"\nexport * from \"./types/primitives.ts\"\nexport * from \"./types/utility-types/literal.ts\"\nexport * from \"./types/utility-types/refinement.ts\"\nexport * from \"./types/utility-types/enumeration.ts\"\nexport * from \"./types/utility-types/union.ts\"\nexport * from \"./types/utility-types/optional.ts\"\nexport * from \"./types/utility-types/maybe.ts\"\nexport * from \"./types/utility-types/late.ts\"\nexport * from \"./types/utility-types/lazy.ts\"\nexport * from \"./types/utility-types/frozen.ts\"\nexport * from \"./types/utility-types/reference.ts\"\nexport * from \"./types/utility-types/identifier.ts\"\nexport * from \"./types/utility-types/custom.ts\"\nexport * from \"./types/utility-types/resilient.ts\"\nexport * from \"./types/index.ts\"\n"]}

package/esm/middlewares/create-action-tracking-middleware.d.ts

@@ -1,24 +0,0 @@
-import { type IMiddlewareEvent, type IMiddlewareHandler } from "../internal.ts";
-export interface IActionTrackingMiddlewareHooks<T> {
-    filter?: (call: IMiddlewareEvent) => boolean;
-    onStart: (call: IMiddlewareEvent) => T;
-    onResume: (call: IMiddlewareEvent, context: T) => void;
-    onSuspend: (call: IMiddlewareEvent, context: T) => void;
-    onSuccess: (call: IMiddlewareEvent, context: T, result: any) => void;
-    onFail: (call: IMiddlewareEvent, context: T, error: any) => void;
-}
-/**
- * Note: Consider migrating to `createActionTrackingMiddleware2`, it is easier to use.
- *
- * Convenience utility to create action based middleware that supports async processes more easily.
- * All hooks are called for both synchronous and asynchronous actions. Except that either `onSuccess` or `onFail` is called
- *
- * The create middleware tracks the process of an action (assuming it passes the `filter`).
- * `onResume` can return any value, which will be passed as second argument to any other hook. This makes it possible to keep state during a process.
- *
- * See the `atomic` middleware for an example
- *
- * @param hooks
- * @returns
- */
-export declare function createActionTrackingMiddleware<T = any>(hooks: IActionTrackingMiddlewareHooks<T>): IMiddlewareHandler;

package/esm/middlewares/create-action-tracking-middleware.js

@@ -1,78 +0,0 @@
-const runningActions = new Map();
-/**
- * Note: Consider migrating to `createActionTrackingMiddleware2`, it is easier to use.
- *
- * Convenience utility to create action based middleware that supports async processes more easily.
- * All hooks are called for both synchronous and asynchronous actions. Except that either `onSuccess` or `onFail` is called
- *
- * The create middleware tracks the process of an action (assuming it passes the `filter`).
- * `onResume` can return any value, which will be passed as second argument to any other hook. This makes it possible to keep state during a process.
- *
- * See the `atomic` middleware for an example
- *
- * @param hooks
- * @returns
- */
-export function createActionTrackingMiddleware(hooks) {
-    return function actionTrackingMiddleware(call, next, _abort) {
-        switch (call.type) {
-            case "action": {
-                if (!hooks.filter || hooks.filter(call) === true) {
-                    const context = hooks.onStart(call);
-                    hooks.onResume(call, context);
-                    runningActions.set(call.id, {
-                        call,
-                        context,
-                        async: false
-                    });
-                    try {
-                        const res = next(call);
-                        hooks.onSuspend(call, context);
-                        if (runningActions.get(call.id).async === false) {
-                            runningActions.delete(call.id);
-                            hooks.onSuccess(call, context, res);
-                        }
-                        return res;
-                    }
-                    catch (e) {
-                        runningActions.delete(call.id);
-                        hooks.onFail(call, context, e);
-                        throw e;
-                    }
-                }
-                else {
-                    return next(call);
-                }
-            }
-            case "flow_spawn": {
-                const root = runningActions.get(call.rootId);
-                root.async = true;
-                return next(call);
-            }
-            case "flow_resume":
-            case "flow_resume_error": {
-                const root = runningActions.get(call.rootId);
-                hooks.onResume(call, root.context);
-                try {
-                    return next(call);
-                }
-                finally {
-                    hooks.onSuspend(call, root.context);
-                }
-            }
-            case "flow_throw": {
-                const root = runningActions.get(call.rootId);
-                runningActions.delete(call.rootId);
-                hooks.onFail(call, root.context, call.args[0]);
-                return next(call);
-            }
-            case "flow_return": {
-                const root = runningActions.get(call.rootId);
-                runningActions.delete(call.rootId);
-                hooks.onSuccess(call, root.context, call.args[0]);
-                return next(call);
-            }
-        }
-    };
-}
-//# sourceMappingURL=create-action-tracking-middleware.js.map

package/esm/middlewares/create-action-tracking-middleware.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"create-action-tracking-middleware.js","sourceRoot":"","sources":["../../src/middlewares/create-action-tracking-middleware.ts"],"names":[],"mappings":"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","sourcesContent":["import { type IMiddlewareEvent, type IMiddlewareHandler } from \"../internal.ts\"\n\nconst runningActions = new Map<\n  number,\n  { async: boolean; call: IMiddlewareEvent; context: any }\n>()\n\nexport interface IActionTrackingMiddlewareHooks<T> {\n  filter?: (call: IMiddlewareEvent) => boolean\n  onStart: (call: IMiddlewareEvent) => T\n  onResume: (call: IMiddlewareEvent, context: T) => void\n  onSuspend: (call: IMiddlewareEvent, context: T) => void\n  onSuccess: (call: IMiddlewareEvent, context: T, result: any) => void\n  onFail: (call: IMiddlewareEvent, context: T, error: any) => void\n}\n\n/**\n * Note: Consider migrating to `createActionTrackingMiddleware2`, it is easier to use.\n *\n * Convenience utility to create action based middleware that supports async processes more easily.\n * All hooks are called for both synchronous and asynchronous actions. Except that either `onSuccess` or `onFail` is called\n *\n * The create middleware tracks the process of an action (assuming it passes the `filter`).\n * `onResume` can return any value, which will be passed as second argument to any other hook. This makes it possible to keep state during a process.\n *\n * See the `atomic` middleware for an example\n *\n * @param hooks\n * @returns\n */\nexport function createActionTrackingMiddleware<T = any>(\n  hooks: IActionTrackingMiddlewareHooks<T>\n): IMiddlewareHandler {\n  return function actionTrackingMiddleware(\n    call: IMiddlewareEvent,\n    next: (actionCall: IMiddlewareEvent) => any,\n    _abort: (value: any) => any\n  ) {\n    switch (call.type) {\n      case \"action\": {\n        if (!hooks.filter || hooks.filter(call) === true) {\n          const context = hooks.onStart(call)\n          hooks.onResume(call, context)\n          runningActions.set(call.id, {\n            call,\n            context,\n            async: false\n          })\n          try {\n            const res = next(call)\n            hooks.onSuspend(call, context)\n            if (runningActions.get(call.id)!.async === false) {\n              runningActions.delete(call.id)\n              hooks.onSuccess(call, context, res)\n            }\n            return res\n          } catch (e) {\n            runningActions.delete(call.id)\n            hooks.onFail(call, context, e)\n            throw e\n          }\n        } else {\n          return next(call)\n        }\n      }\n      case \"flow_spawn\": {\n        const root = runningActions.get(call.rootId)!\n        root.async = true\n        return next(call)\n      }\n      case \"flow_resume\":\n      case \"flow_resume_error\": {\n        const root = runningActions.get(call.rootId)!\n        hooks.onResume(call, root.context)\n        try {\n          return next(call)\n        } finally {\n          hooks.onSuspend(call, root.context)\n        }\n      }\n      case \"flow_throw\": {\n        const root = runningActions.get(call.rootId)!\n        runningActions.delete(call.rootId)\n        hooks.onFail(call, root.context, call.args[0])\n        return next(call)\n      }\n      case \"flow_return\": {\n        const root = runningActions.get(call.rootId)!\n        runningActions.delete(call.rootId)\n        hooks.onSuccess(call, root.context, call.args[0])\n        return next(call)\n      }\n    }\n  }\n}\n"]}

package/esm/middlewares/createActionTrackingMiddleware2.d.ts

@@ -1,34 +0,0 @@
-import { type IActionContext, type IMiddlewareHandler } from "../internal.ts";
-export interface IActionTrackingMiddleware2Call<TEnv> extends Readonly<IActionContext> {
-    env: TEnv | undefined;
-    readonly parentCall?: IActionTrackingMiddleware2Call<TEnv>;
-}
-export interface IActionTrackingMiddleware2Hooks<TEnv> {
-    filter?: (call: IActionTrackingMiddleware2Call<TEnv>) => boolean;
-    onStart: (call: IActionTrackingMiddleware2Call<TEnv>) => void;
-    onFinish: (call: IActionTrackingMiddleware2Call<TEnv>, error?: any) => void;
-}
-/**
- * Convenience utility to create action based middleware that supports async processes more easily.
- * The flow is like this:
- * - for each action: if filter passes -> `onStart` -> (inner actions recursively) -> `onFinish`
- *
- * Example: if we had an action `a` that called inside an action `b1`, then `b2` the flow would be:
- * - `filter(a)`
- * - `onStart(a)`
- *   - `filter(b1)`
- *   - `onStart(b1)`
- *   - `onFinish(b1)`
- *   - `filter(b2)`
- *   - `onStart(b2)`
- *   - `onFinish(b2)`
- * - `onFinish(a)`
- *
- * The flow is the same no matter if the actions are sync or async.
- *
- * See the `atomic` middleware for an example
- *
- * @param hooks
- * @returns
- */
-export declare function createActionTrackingMiddleware2<TEnv = any>(middlewareHooks: IActionTrackingMiddleware2Hooks<TEnv>): IMiddlewareHandler;

package/esm/middlewares/createActionTrackingMiddleware2.js

@@ -1,130 +0,0 @@
-class RunningAction {
-    hooks;
-    call;
-    flowsPending = 0;
-    running = true;
-    constructor(hooks, call) {
-        this.hooks = hooks;
-        this.call = call;
-        if (hooks) {
-            hooks.onStart(call);
-        }
-    }
-    finish(error) {
-        if (this.running) {
-            this.running = false;
-            if (this.hooks) {
-                this.hooks.onFinish(this.call, error);
-            }
-        }
-    }
-    incFlowsPending() {
-        this.flowsPending++;
-    }
-    decFlowsPending() {
-        this.flowsPending--;
-    }
-    get hasFlowsPending() {
-        return this.flowsPending > 0;
-    }
-}
-/**
- * Convenience utility to create action based middleware that supports async processes more easily.
- * The flow is like this:
- * - for each action: if filter passes -> `onStart` -> (inner actions recursively) -> `onFinish`
- *
- * Example: if we had an action `a` that called inside an action `b1`, then `b2` the flow would be:
- * - `filter(a)`
- * - `onStart(a)`
- *   - `filter(b1)`
- *   - `onStart(b1)`
- *   - `onFinish(b1)`
- *   - `filter(b2)`
- *   - `onStart(b2)`
- *   - `onFinish(b2)`
- * - `onFinish(a)`
- *
- * The flow is the same no matter if the actions are sync or async.
- *
- * See the `atomic` middleware for an example
- *
- * @param hooks
- * @returns
- */
-export function createActionTrackingMiddleware2(middlewareHooks) {
-    const runningActions = new Map();
-    return function actionTrackingMiddleware(call, next) {
-        // find parentRunningAction
-        const parentRunningAction = call.parentActionEvent
-            ? runningActions.get(call.parentActionEvent.id)
-            : undefined;
-        if (call.type === "action") {
-            const newCall = {
-                ...call,
-                // make a shallow copy of the parent action env
-                env: parentRunningAction && parentRunningAction.call.env,
-                parentCall: parentRunningAction && parentRunningAction.call
-            };
-            const passesFilter = !middlewareHooks.filter || middlewareHooks.filter(newCall);
-            const hooks = passesFilter ? middlewareHooks : undefined;
-            const runningAction = new RunningAction(hooks, newCall);
-            runningActions.set(call.id, runningAction);
-            let res;
-            try {
-                res = next(call);
-            }
-            catch (e) {
-                runningActions.delete(call.id);
-                runningAction.finish(e);
-                throw e;
-            }
-            // sync action finished
-            if (!runningAction.hasFlowsPending) {
-                runningActions.delete(call.id);
-                runningAction.finish();
-            }
-            return res;
-        }
-        else {
-            if (!parentRunningAction) {
-                return next(call);
-            }
-            switch (call.type) {
-                case "flow_spawn": {
-                    parentRunningAction.incFlowsPending();
-                    return next(call);
-                }
-                case "flow_resume":
-                case "flow_resume_error": {
-                    return next(call);
-                }
-                case "flow_throw": {
-                    const error = call.args[0];
-                    try {
-                        return next(call);
-                    }
-                    finally {
-                        parentRunningAction.decFlowsPending();
-                        if (!parentRunningAction.hasFlowsPending) {
-                            runningActions.delete(call.parentActionEvent.id);
-                            parentRunningAction.finish(error);
-                        }
-                    }
-                }
-                case "flow_return": {
-                    try {
-                        return next(call);
-                    }
-                    finally {
-                        parentRunningAction.decFlowsPending();
-                        if (!parentRunningAction.hasFlowsPending) {
-                            runningActions.delete(call.parentActionEvent.id);
-                            parentRunningAction.finish();
-                        }
-                    }
-                }
-            }
-        }
-    };
-}
-//# sourceMappingURL=createActionTrackingMiddleware2.js.map

package/esm/middlewares/createActionTrackingMiddleware2.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"createActionTrackingMiddleware2.js","sourceRoot":"","sources":["../../src/middlewares/createActionTrackingMiddleware2.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  type IActionContext,\n  type IMiddlewareEvent,\n  type IMiddlewareHandler\n} from \"../internal.ts\"\n\nexport interface IActionTrackingMiddleware2Call<\n  TEnv\n> extends Readonly<IActionContext> {\n  env: TEnv | undefined\n  readonly parentCall?: IActionTrackingMiddleware2Call<TEnv>\n}\n\nexport interface IActionTrackingMiddleware2Hooks<TEnv> {\n  filter?: (call: IActionTrackingMiddleware2Call<TEnv>) => boolean\n  onStart: (call: IActionTrackingMiddleware2Call<TEnv>) => void\n  onFinish: (call: IActionTrackingMiddleware2Call<TEnv>, error?: any) => void\n}\n\nclass RunningAction {\n  private flowsPending = 0\n  private running = true\n\n  constructor(\n    public readonly hooks: IActionTrackingMiddleware2Hooks<any> | undefined,\n    readonly call: IActionTrackingMiddleware2Call<any>\n  ) {\n    if (hooks) {\n      hooks.onStart(call)\n    }\n  }\n\n  finish(error?: any) {\n    if (this.running) {\n      this.running = false\n      if (this.hooks) {\n        this.hooks.onFinish(this.call, error)\n      }\n    }\n  }\n\n  incFlowsPending() {\n    this.flowsPending++\n  }\n\n  decFlowsPending() {\n    this.flowsPending--\n  }\n\n  get hasFlowsPending() {\n    return this.flowsPending > 0\n  }\n}\n\n/**\n * Convenience utility to create action based middleware that supports async processes more easily.\n * The flow is like this:\n * - for each action: if filter passes -> `onStart` -> (inner actions recursively) -> `onFinish`\n *\n * Example: if we had an action `a` that called inside an action `b1`, then `b2` the flow would be:\n * - `filter(a)`\n * - `onStart(a)`\n *   - `filter(b1)`\n *   - `onStart(b1)`\n *   - `onFinish(b1)`\n *   - `filter(b2)`\n *   - `onStart(b2)`\n *   - `onFinish(b2)`\n * - `onFinish(a)`\n *\n * The flow is the same no matter if the actions are sync or async.\n *\n * See the `atomic` middleware for an example\n *\n * @param hooks\n * @returns\n */\nexport function createActionTrackingMiddleware2<TEnv = any>(\n  middlewareHooks: IActionTrackingMiddleware2Hooks<TEnv>\n): IMiddlewareHandler {\n  const runningActions = new Map<number, RunningAction>()\n\n  return function actionTrackingMiddleware(\n    call: IMiddlewareEvent,\n    next: (actionCall: IMiddlewareEvent) => any\n  ) {\n    // find parentRunningAction\n    const parentRunningAction = call.parentActionEvent\n      ? runningActions.get(call.parentActionEvent.id)\n      : undefined\n\n    if (call.type === \"action\") {\n      const newCall: IActionTrackingMiddleware2Call<TEnv> = {\n        ...call,\n        // make a shallow copy of the parent action env\n        env: parentRunningAction && parentRunningAction.call.env,\n        parentCall: parentRunningAction && parentRunningAction.call\n      }\n\n      const passesFilter =\n        !middlewareHooks.filter || middlewareHooks.filter(newCall)\n      const hooks = passesFilter ? middlewareHooks : undefined\n\n      const runningAction = new RunningAction(hooks, newCall)\n      runningActions.set(call.id, runningAction)\n\n      let res\n      try {\n        res = next(call)\n      } catch (e) {\n        runningActions.delete(call.id)\n        runningAction.finish(e)\n        throw e\n      }\n      // sync action finished\n      if (!runningAction.hasFlowsPending) {\n        runningActions.delete(call.id)\n        runningAction.finish()\n      }\n      return res\n    } else {\n      if (!parentRunningAction) {\n        return next(call)\n      }\n\n      switch (call.type) {\n        case \"flow_spawn\": {\n          parentRunningAction.incFlowsPending()\n          return next(call)\n        }\n        case \"flow_resume\":\n        case \"flow_resume_error\": {\n          return next(call)\n        }\n        case \"flow_throw\": {\n          const error = call.args[0]\n          try {\n            return next(call)\n          } finally {\n            parentRunningAction.decFlowsPending()\n            if (!parentRunningAction.hasFlowsPending) {\n              runningActions.delete(call.parentActionEvent!.id)\n              parentRunningAction.finish(error)\n            }\n          }\n        }\n        case \"flow_return\": {\n          try {\n            return next(call)\n          } finally {\n            parentRunningAction.decFlowsPending()\n            if (!parentRunningAction.hasFlowsPending) {\n              runningActions.delete(call.parentActionEvent!.id)\n              parentRunningAction.finish()\n            }\n          }\n        }\n      }\n    }\n  }\n}\n"]}

package/esm/middlewares/on-action.d.ts

@@ -1,87 +0,0 @@
-import { type IActionContext, type IAnyStateTreeNode, type IDisposer } from "../internal.ts";
-export interface ISerializedActionCall {
-    name: string;
-    path?: string;
-    args?: any[];
-}
-export interface IActionRecorder {
-    actions: ReadonlyArray<ISerializedActionCall>;
-    readonly recording: boolean;
-    stop(): void;
-    resume(): void;
-    replay(target: IAnyStateTreeNode): void;
-}
-/**
- * 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
- */
-export declare function applyAction(target: IAnyStateTreeNode, actions: ISerializedActionCall | ISerializedActionCall[]): void;
-/**
- * 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
- */
-export declare function recordActions(subject: IAnyStateTreeNode, filter?: (action: ISerializedActionCall, actionContext: IActionContext | undefined) => boolean): IActionRecorder;
-/**
- * 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
- */
-export declare function onAction(target: IAnyStateTreeNode, listener: (call: ISerializedActionCall) => void, attachAfter?: boolean): IDisposer;

package/esm/middlewares/on-action.js

@@ -1,210 +0,0 @@
-import { runInAction } from "mobx";
-import { addMiddleware, applyPatch, applySnapshot, asArray, assertArg, assertIsStateTreeNode, devMode, fail, getRelativePathBetweenNodes, getRunningActionContext, getStateTreeNode, getType, isArray, isPlainObject, isPrimitive, isProtected, isRoot, isStateTreeNode, tryResolve, warnError } from "../internal.js";
-function serializeArgument(node, actionName, index, arg) {
-    if (arg instanceof Date) {
-        return { $MST_DATE: arg.getTime() };
-    }
-    if (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 (isStateTreeNode(arg)) {
-        return serializeTheUnserializable(`[MSTNode: ${getType(arg).name}]`);
-    }
-    if (typeof arg === "function") {
-        return serializeTheUnserializable(`[function]`);
-    }
-    if (typeof arg === "object" && !isPlainObject(arg) && !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
- */
-export function applyAction(target, actions) {
-    // check all arguments
-    assertIsStateTreeNode(target, 1);
-    assertArg(actions, a => typeof a === "object", "object or array", 2);
-    runInAction(() => {
-        asArray(actions).forEach(action => baseApplyAction(target, action));
-    });
-}
-function baseApplyAction(target, action) {
-    const resolvedTarget = tryResolve(target, action.path || "");
-    if (!resolvedTarget) {
-        throw fail(`Invalid action path: ${action.path || ""}`);
-    }
-    const node = getStateTreeNode(resolvedTarget);
-    // Reserved functions
-    if (action.name === "@APPLY_PATCHES") {
-        return applyPatch.call(null, resolvedTarget, action.args[0]);
-    }
-    if (action.name === "@APPLY_SNAPSHOT") {
-        return applySnapshot.call(null, resolvedTarget, action.args[0]);
-    }
-    if (!(typeof resolvedTarget[action.name] === "function")) {
-        throw 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
- */
-export function recordActions(subject, filter) {
-    // check all arguments
-    assertIsStateTreeNode(subject, 1);
-    const actions = [];
-    const listener = (call) => {
-        const recordThis = filter ? filter(call, 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
- */
-export function onAction(target, listener, attachAfter = false) {
-    // check all arguments
-    assertIsStateTreeNode(target, 1);
-    if (devMode()) {
-        if (!isRoot(target)) {
-            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 (!isProtected(target)) {
-            warnError("Warning: Attaching onAction listeners to non protected nodes is dangerous: No events will be emitted for direct modifications without action.");
-        }
-    }
-    return addMiddleware(target, function handler(rawCall, next) {
-        if (rawCall.type === "action" && rawCall.id === rawCall.rootId) {
-            const sourceNode = getStateTreeNode(rawCall.context);
-            const info = {
-                name: rawCall.name,
-                path: getRelativePathBetweenNodes(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