mobx-state-tree 5.1.8 → 5.2.0-alpha.2

package/dist/core/action.d.ts

@@ -12,6 +12,10 @@ export interface IMiddlewareEvent extends IActionContext {
     /** Id of all events, from root until current (excluding current) */
     readonly allParentIds: number[];
 }
+export interface FunctionWithFlag extends Function {
+    _isMSTAction?: boolean;
+    _isFlowAction?: boolean;
+}
 export declare type IMiddlewareHandler = (actionCall: IMiddlewareEvent, next: (actionCall: IMiddlewareEvent, callback?: (value: any) => any) => void, abort: (value: any) => void) => any;
 /**
  * Middleware can be used to intercept any action is invoked on the subtree where it is attached.

package/dist/core/mst-operations.d.ts

@@ -28,7 +28,7 @@ export declare function getChildType(object: IAnyStateTreeNode, propertyName?: s
 /**
  * Registers a function that will be invoked for each mutation that is applied to the provided model instance, or to any of its children.
  * See [patches](https://github.com/mobxjs/mobx-state-tree#patches) for more details. onPatch events are emitted immediately and will not await the end of a transaction.
- * Patches can be used to deep observe a model tree.
+ * Patches can be used to deeply observe a model tree.
  *
  * @param target the model instance from which to receive patches
  * @param callback the callback that is invoked for each patch. The reversePatch is a patch that would actually undo the emitted patch
@@ -68,7 +68,7 @@ export interface IPatchRecorder {
 }
 /**
  * Small abstraction around `onPatch` and `applyPatch`, attaches a patch listener to a tree and records all the patches.
- * Returns an recorder object with the following signature:
+ * Returns a recorder object with the following signature:
  *
  * Example:
  * ```ts
@@ -247,7 +247,7 @@ export declare function resolveIdentifier<IT extends IAnyModelType>(type: IT, ta
  */
 export declare function getIdentifier(target: IAnyStateTreeNode): string | null;
 /**
- * Tests if a reference is valid (pointing to an existing node and optionally if alive) and returns such reference if it the check passes,
+ * Tests if a reference is valid (pointing to an existing node and optionally if alive) and returns such reference if the check passes,
  * else it returns undefined.
  *
  * @param getter Function to access the reference.
@@ -282,9 +282,9 @@ export declare function tryResolve(target: IAnyStateTreeNode, path: string): any
 export declare function getRelativePath(base: IAnyStateTreeNode, target: IAnyStateTreeNode): string;
 /**
  * Returns a deep copy of the given state tree node as new tree.
- * Short hand for `snapshot(x) = getType(x).create(getSnapshot(x))`
+ * Shorthand for `snapshot(x) = getType(x).create(getSnapshot(x))`
  *
- * _Tip: clone will create a literal copy, including the same identifiers. To modify identifiers etc during cloning, don't use clone but take a snapshot of the tree, modify it, and create new instance_
+ * _Tip: clone will create a literal copy, including the same identifiers. To modify identifiers etc. during cloning, don't use clone but take a snapshot of the tree, modify it, and create new instance_
  *
  * @param source
  * @param keepEnvironment indicates whether the clone should inherit the same environment (`true`, the default), or not have an environment (`false`). If an object is passed in as second argument, that will act as the environment for the cloned tree.
@@ -372,9 +372,17 @@ export interface IModelReflectionData extends IModelReflectionPropertiesData {
     actions: string[];
     views: string[];
     volatile: string[];
+    flowActions: string[];
 }
 /**
- * Returns a reflection of the model node, including name, properties, views, volatile and actions.
+ * Returns a reflection of the model node, including name, properties, views, volatile state,
+ * and actions. `flowActions` is also provided as a separate array of names for any action that
+ * came from a flow generator as well.
+ *
+ * In the case where a model has two actions: `doSomething` and `doSomethingWithFlow`, where
+ * `doSomethingWithFlow` is a flow generator, the `actions` array will contain both actions,
+ * i.e. ["doSomething", "doSomethingWithFlow"], and the `flowActions` array will contain only
+ * the flow action, i.e. ["doSomethingWithFlow"].
  *
  * @param target
  * @returns
@@ -383,7 +391,7 @@ export declare function getMembers(target: IAnyStateTreeNode): IModelReflectionD
 export declare function cast<O extends string | number | boolean | null | undefined = never>(snapshotOrInstance: O): O;
 export declare function cast<O = never>(snapshotOrInstance: TypeOfValue<O>["CreationType"] | TypeOfValue<O>["SnapshotType"] | TypeOfValue<O>["Type"]): O;
 /**
- * Casts a node instance type to an snapshot type so it can be assigned to a type snapshot (e.g. to be used inside a create call).
+ * Casts a node instance type to a snapshot type so it can be assigned to a type snapshot (e.g. to be used inside a create call).
  * Note that this is just a cast for the type system, this is, it won't actually convert an instance to a snapshot,
  * but just fool typescript into thinking so.
  *
@@ -407,12 +415,12 @@ export declare function cast<O = never>(snapshotOrInstance: TypeOfValue<O>["Crea
  * ```
  *
  * @param snapshotOrInstance Snapshot or instance
- * @returns The same object casted as an input (creation) snapshot
+ * @returns The same object cast as an input (creation) snapshot
  */
 export declare function castToSnapshot<I>(snapshotOrInstance: I): Extract<I, IAnyStateTreeNode> extends never ? I : TypeOfValue<I>["CreationType"];
 /**
- * Casts a node instance type to a reference snapshot type so it can be assigned to a refernence snapshot (e.g. to be used inside a create call).
- * Note that this is just a cast for the type system, this is, it won't actually convert an instance to a refererence snapshot,
+ * Casts a node instance type to a reference snapshot type so it can be assigned to a reference snapshot (e.g. to be used inside a create call).
+ * Note that this is just a cast for the type system, this is, it won't actually convert an instance to a reference snapshot,
  * but just fool typescript into thinking so.
  *
  * Example:
@@ -436,7 +444,7 @@ export declare function castToSnapshot<I>(snapshotOrInstance: I): Extract<I, IAn
  * ```
  *
  * @param instance Instance
- * @returns The same object casted as an reference snapshot (string or number)
+ * @returns The same object cast as a reference snapshot (string or number)
  */
 export declare function castToReferenceSnapshot<I>(instance: I): Extract<I, IAnyStateTreeNode> extends never ? I : ReferenceIdentifier;
 /**

package/dist/internal.d.ts

@@ -30,6 +30,7 @@ export * from "./types/utility-types/union";
 export * from "./types/utility-types/optional";
 export * from "./types/utility-types/maybe";
 export * from "./types/utility-types/late";
+export * from "./types/utility-types/lazy";
 export * from "./types/utility-types/frozen";
 export * from "./types/utility-types/reference";
 export * from "./types/utility-types/identifier";