mobx-state-tree 3.12.2 → 3.15.0

package/README.md

@@ -64,6 +64,12 @@ Supported browsers:
 -   MobX-state-tree runs on any ES5 environment
 -   However, for MobX version 4 or 5 can be used. MobX 4 will run on any environment, MobX 5 only on modern browsers. See for more details the [MobX readme](https://github.com/mobxjs/mobx#browser-support)
 
+Supported devtools:
+
+- [Reactotron](https://github.com/infinitered/reactotron)
+- [MobX DevTools](https://chrome.google.com/webstore/detail/mobx-developer-tools/pfgnfdagidkfgccljigdamigbcnndkod)
+- The Redux can be connected as well as demonstrated [here](https://github.com/mobxjs/mobx-state-tree/blob/1906a394906d2e8f2cc1c778e1e3228307c1b112/packages/mst-example-redux-todomvc/src/index.js#L6)
+
 # Getting started
 
 See the [Getting started](https://github.com/mobxjs/mobx-state-tree/blob/master/docs/getting-started.md#getting-started) tutorial or follow the free [egghead.io course](https://egghead.io/courses/manage-application-state-with-mobx-state-tree) (note however that the course is for MST v2, so it might be a bit outdated).
@@ -153,7 +159,7 @@ Simply subscribing to the patch stream of a tree is another way to sync diffs wi
 
 Since MST uses MobX behind the scenes, it integrates seamlessly with [mobx](https://mobx.js.org) and [mobx-react](https://github.com/mobxjs/mobx-react). See also this [egghead.io lesson: Render mobx-state-tree Models in React](https://egghead.io/lessons/react-render-mobx-state-tree-models-in-react).
 Even cooler, because it supports snapshots, middleware and replayable actions out of the box, it is possible to replace a Redux store and reducer with a MobX state tree.
-This makes it possible to connect the Redux devtools to MST. See the [Redux / MST TodoMVC example](https://github.com/mobxjs/mobx-state-tree/blob/4c2b19ec4a6a8d74064e4b8a87c0f8b46e97e621/examples/redux-todomvc/src/index.js#L6).
+This makes it possible to connect the Redux devtools to MST. See the [Redux / MST TodoMVC example](https://github.com/mobxjs/mobx-state-tree/blob/1906a394906d2e8f2cc1c778e1e3228307c1b112/packages/mst-example-redux-todomvc/src/index.js#L6).
 
 ---
 
@@ -674,7 +680,7 @@ const s = Store.create({
 })
 ```
 
-#### Reference validation: `isValidReference`, `tryReference`, `onInvalidate` hook and `types.safeReference`
+#### Reference validation: `isValidReference`, `tryReference`, `onInvalidated` hook and `types.safeReference`
 
 Accessing an invalid reference (a reference to a dead/detached node) triggers an exception.
 
@@ -722,7 +728,10 @@ A default implementation of such `onInvalidated` hook is provided by the `types.
 -   If its parent is an array: Remove itself from the array
 -   If its parent is a map: Remove itself from the map
 
-Strictly speaking it is implemented as
+In addition to the options possible for a plain reference type, the optional options parameter object also accepts a parameter named `acceptsUndefined`, which is set to true by default, so it is suitable for model properties.
+When used inside collections (arrays/maps) it is recommended to set this option to false so it can't take undefined as value, which is usually the desired in those cases.
+
+Strictly speaking, `safeReference` with `acceptsUndefined` set to true (the default) is implemented as
 
 ```js
 types.maybe(
@@ -735,15 +744,28 @@ types.maybe(
 )
 ```
 
+and with `acceptsUndefined` set to false as
+
+```js
+types.reference(Type, {
+    ...customGetSetIfAvailable,
+    onInvalidated(ev) {
+        ev.removeRef()
+    }
+})
+```
+
 ```js
 const Todo = types.model({ id: types.identifier })
 const Store = types.model({
     todos: types.array(Todo),
-    selectedTodo: types.safeReference(Todo)
+    selectedTodo: types.safeReference(Todo),
+    multipleSelectedTodos: types.array(types.safeReference(Todo, { acceptsUndefined: false }))
 })
 
 // given selectedTodo points to a valid Todo and that Todo is later removed from the todos
-// array, then selectedTodo will automatically become undefined
+// array, then selectedTodo will automatically become undefined, and if it is included in multipleSelectedTodos
+// then it will be removed from the array
 ```
 
 ### Listening to observables, snapshots, patches or actions
@@ -930,7 +952,7 @@ const Todo = types
 
 The object that is returned from the `volatile` initializer function can contain any piece of data and will result in an instance property with the same name. Volatile properties have the following characteristics:
 
-1.  The can be read from outside the model (if you want hidden volatile state, keep the state in your closure as shown in the previous section, and _only_ if it is not used on a view consider not making it observable)
+1.  They can be read from outside the model (if you want hidden volatile state, keep the state in your closure as shown in the previous section, and _only_ if it is not used on a view consider not making it observable)
 2.  The volatile properties will be only observable, see [observable _references_](https://mobx.js.org/refguide/modifiers.html). Values assigned to them will be unmodified and not automatically converted to deep observable structures.
 3.  Like normal properties, they can only be modified through actions
 4.  Volatile props will not show up in snapshots, and cannot be updated by applying snapshots
@@ -1012,7 +1034,7 @@ Note that since MST v3 `types.array` and `types.map` are wrapped in `types.optio
 ## Utility types
 
 -   `types.union(options?: { dispatcher?: (snapshot) => Type, eager?: boolean }, types...)` create a union of multiple types. If the correct type cannot be inferred unambiguously from a snapshot, provide a dispatcher function to determine the type. When `eager` flag is set to `true` (default) - the first matching type will be used, if set to `false` the type check will pass only if exactly 1 type matches.
--   `types.optional(type, defaultValue, optionalValues?)` marks an value as being optional (in e.g. a model). If a value is not provided/`undefined` (or set to any of the primitive values passed as an optional `optionalValues` array) the `defaultValue` will be used instead. If `defaultValue` is a function, it will be evaluated. This can be used to generate, for example, IDs or timestamps upon creation.
+-   `types.optional(type, defaultValue, optionalValues?)` marks a value as being optional (in e.g. a model). If a value is not provided/`undefined` (or set to any of the primitive values passed as an optional `optionalValues` array) the `defaultValue` will be used instead. If `defaultValue` is a function, it will be evaluated. This can be used to generate, for example, IDs or timestamps upon creation.
 -   `types.literal(value)` can be used to create a literal type, where the only possible value is specifically that value. This is very powerful in combination with `union`s. E.g. `temperature: types.union(types.literal("hot"), types.literal("cold"))`.
 -   `types.enumeration(name?, options: string[])` creates an enumeration. This method is a shorthand for a union of string literals. If you are using typescript and want to create a type based on an string enum (e.g. `enum Color { ... }`) then use `types.enumeration<Color>("Color", Object.values(Color))`, where the `"Color"` name argument is optional.
 -   `types.refinement(name?, baseType, (snapshot) => boolean)` creates a type that is more specific than the base type, e.g. `types.refinement(types.string, value => value.length > 5)` to create a type of strings that can only be longer then 5.
@@ -1105,6 +1127,21 @@ Note, except for `preProcessSnapshot` and `postProcessSnapshot`, all hooks shoul
 
 All hooks can be defined multiple times and can be composed automatically.
 
+## LifeCycle hooks for `types.array`/`types.map`
+
+Hooks for `types.array`/`types.map` can be defined by using the `.hooks(self => ({}))` method.
+
+Calling `.hooks(...)` produces new type, same as calling `.actions()` for `types.model`.
+
+Available hooks are:
+
+| Hook                  | Meaning                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| --------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `afterCreate`         | Immediately after an instance is initialized: right after `.create()` for root node or after the first access for the nested one. Children will fire this event before parents. You can't make assumptions about the parent safely, use `afterAttach` if you need to.                                                                                                                                                                                                                                                                                                                                                                         |
+| `afterAttach`         | As soon as the _direct_ parent is assigned (this node is attached to another node). If an element is created as part of a parent, `afterAttach` is also fired. Unlike `afterCreate`, `afterAttach` will fire breadth first. So, in `afterAttach` one can safely make assumptions about the parent, but in `afterCreate` not                                                                                                                                                                                                                                                                                                                   |
+| `beforeDetach`        | As soon as the node is removed from the _direct_ parent, but only if the node is _not_ destroyed. In other words, when `detach(node)` is used                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| `beforeDestroy`       | Called before the node is destroyed, as a result of calling `destroy`, or by removing or replacing the node from the tree. Child destructors will fire before parents                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | 
+
 # Api overview
 
 See the [full API docs](docs/API/README.md) for more details.
@@ -1119,7 +1156,8 @@ See the [full API docs](docs/API/README.md) for more details.
 | [`cast(nodeOrSnapshot)`](docs/API/README.md#cast)                                                                     | Cast a node instance or snapshot to a node instance so it can be used in assignment operations                                                                                                                                                        |
 | [`castToSnapshot(nodeOrSnapshot)`](docs/API/README.md#casttosnapshot)                                                 | Cast a node instance to a snapshot so it can be used inside create operations                                                                                                                                                                         |
 | [`castToReferenceSnapshot(node)`](docs/API/README.md#casttoreferencesnapshot)                                         | Cast a node instance to a reference snapshot so it can be used inside create operations                                                                                                                                                               |
-| [`createActionTrackingMiddleware`](docs/API/README.md#createactiontrackingmiddleware)                                 | Utility to make writing middleware that tracks async actions less cumbersome                                                                                                                                                                          |
+| [`createActionTrackingMiddleware`](docs/API/README.md#createactiontrackingmiddleware)                                 | Utility to make writing middleware that tracks async actions less cumbersome. Consider migrating to `createActionTrackingMiddleware2`                                                                                                                 |
+| [`createActionTrackingMiddleware2`](docs/API/README.md#createactiontrackingmiddleware)                                | Utility to make writing middleware that tracks async actions less cumbersome                                                                                                                                                                          |
 | [`clone(node, keepEnvironment?: true \| false \| newEnvironment)`](docs/API/README.md#clone)                          | Creates a full clone of the given node. By default preserves the same environment                                                                                                                                                                     |
 | [`decorate(handler, function)`](docs/API/README.md#decorate)                                                          | Attaches middleware to a specific action (or flow)                                                                                                                                                                                                    |
 | [`destroy(node)`](docs/API/README.md#destroy)                                                                         | Kills `node`, making it unusable. Removes it from any parent in the process                                                                                                                                                                           |
@@ -1161,9 +1199,9 @@ See the [full API docs](docs/API/README.md) for more details.
 | [`setLivelinessChecking("warn" \| "ignore" \| "error")`](docs/API/README.md#setlivelinesschecking)                    | Defines what MST should do when running into reads / writes to objects that have died. By default it will print a warning. Use te `"error"` option to easy debugging to see where the error was thrown and when the offending read / write took place |
 | [`getLivelinessChecking()`](docs/API/README.md#getlivelinesschecking)                                                 | Returns the current liveliness checking mode.                                                                                                                                                                                                         |
 | [`splitJsonPath(path)`](docs/API/README.md#splitjsonpath)                                                             | Splits and unescapes the given JSON `path` into path parts                                                                                                                                                                                            |
-| [`typecheck(type, value)`](docs/API/README.md#typecheck)                                                              | Typechecks a value against a type. Throws on errors. Use this if you need typechecks even in a production build.                                                                                                                                      |
+| [`typecheck(type, value)`](docs/API/README.md#typecheck)                                                              | Typechecks a value against a type. Throws on errors. Use this if you need typechecks even in a production build. NOTE: set process.env.ENABLE_TYPE_CHECK = "true" if you want to enable type checking in any environment                                                                                                                                      |
 | [`tryResolve(node, path)`](docs/API/README.md#tryresolve)                                                             | Like `resolve`, but just returns `null` if resolving fails at any point in the path                                                                                                                                                                   |
-| [`tryReference(() => node | null | undefined, checkIfAlive = true)`](docs/API/README.md#tryreference)                 | Tests if a reference is valid (pointing to an existing node and optionally if alive) and returns such reference if it the check passes, else it returns undefined.                                                                                    |
+| [`tryReference(() => node \| null \| undefined, checkIfAlive = true)`](docs/API/README.md#tryreference)                 | Tests if a reference is valid (pointing to an existing node and optionally if alive) and returns such reference if it the check passes, else it returns undefined.                                                                                    |
 | [`unprotect(node)`](docs/API/README.md#unprotect)                                                                     | Unprotects `node`, making it possible to directly modify any value in the subtree, without actions                                                                                                                                                    |
 | [`walk(startNode, (node) => void)`](docs/API/README.md#walk)                                                          | Performs a depth-first walk through a tree                                                                                                                                                                                                            |
 | [`escapeJsonPath(path)`](docs/API/README.md#escapejsonpath)                                                           | escape special characters in an identifier, according to http://tools.ietf.org/html/rfc6901                                                                                                                                                           |
@@ -1181,6 +1219,9 @@ See the [full API docs](docs/API/README.md) for more details.
 | [`isReferenceType(value)`](docs/API/README.md#isReferenceType)                                                        | Returns if a given value represents a reference type.                                                                                                                                                                                                 |
 | [`isRefinementType(value)`](docs/API/README.md#isRefinementType)                                                      | Returns if a given value represents a refinement type.                                                                                                                                                                                                |
 | [`isUnionType(value)`](docs/API/README.md#isUnionType)                                                                | Returns if a given value represents a union type.                                                                                                                                                                                                     |
+| [`getRunningActionContext()`](docs/API/README.md#getrunningactioncontext)                                             | Returns the currently executing MST action context, or undefined if none.                                                                                                                                                                             |
+| [`isActionContextChildOf(actionContext, parent)`](docs/API/README.md#isActionContextChildOf)                          | Returns if the given action context is a parent of this action context.                                                                                                                                                                               |
+| [`isActionContextThisOrChildOf(actionContext, parentOrSame)`](docs/API/README.md#isActionContextThisOrChildOf)        | Returns if the given action context is this or a parent of this action context.                                                                                                                                                                       |
 
 A _disposer_ is a function that cancels the effect for which it was created.
 
@@ -1337,7 +1378,7 @@ MST doesn't offer an any type because it can't reason about it. For example, giv
 -   If no identifier is specified, but the type of the snapshot is correct, MST will reconcile objects as well if they are stored in a specific model property or under the same map key.
 -   In arrays, items without an identifier are never reconciled.
 
-If an object is reconciled, the consequence is that localState is preserved and `postCreate` / `attach` life-cycle hooks are not fired because applying a snapshot results just in an existing tree node being updated.
+If an object is reconciled, the consequence is that localState is preserved and `afterCreate` / `attach` life-cycle hooks are not fired because applying a snapshot results just in an existing tree node being updated.
 
 ### Creating async flows
 
@@ -1364,9 +1405,30 @@ Yes, with MST it is pretty straight forward to setup hot reloading for your stor
 ### TypeScript and MST
 
 TypeScript support is best-effort as not all patterns can be expressed in TypeScript. Except for assigning snapshots to properties we get pretty close! As MST uses the latest fancy TypeScript features it is required to use TypeScript 3.0 or later with `noImplicitThis` and `strictNullChecks` enabled.
-Actually, the more strict options that are enabled, the better the type system will behave.
+Actually, the more strict options that are enabled, the better the type system will behave. 
 
-We recommend using TypeScript together with MST, but since the type system of MST is more dynamic than the TypeScript system, there are cases that cannot be expressed neatly and occasionally you will need to fallback to `any` or manually adding type annotations.
+#### Recommend compiler flags
+
+The recommended compiler flags (against which all our tests are written) are:
+
+```json
+{
+    "strictNullChecks": true,
+    "strictFunctionTypes": true,
+    "noImplicitAny": true,
+    "noImplicitReturns": true,
+    "noImplicitThis": true
+}
+```
+
+Or shorter by leveraging `strict`:
+
+```json
+{
+  "strict": true,
+  "noImplicitReturns": true
+}
+```
 
 Flow is not supported.
 
@@ -1404,7 +1466,8 @@ type ITodoSnapshotOut = SnapshotOut<typeof Todo> // => { title: string }
 ```
 
 Due to the way typeof operator works, when working with big and deep models trees, it might make your IDE/ts server takes a lot of CPU time and freeze vscode (or others).
-A partial solution for this is to turn the types into interfaces.
+A solution for this is to turn the types into interfaces. 
+This way of defining types enables TypeScript to better cope with circular type definitions as well.
 
 ```ts
 interface ITodo extends Instance<typeof Todo> {}
@@ -1680,16 +1743,33 @@ So far this might look a lot like an immutable state tree as found for example i
 
 ## Contributing
 
+Extensive pull requests are best discussed in an issue first.
+
+Setting up the environment:
+
 1.  Clone this repository
-2.  Yarn is the package manager of choice. Make sure to run Node 8 or higher.
-3.  Run `yarn install && yarn run bootstrap`.
-4.  Run `yarn build` at least once in `packages/mobx-state-tree`
-5.  For MST changes: go to `packages/mobx-state-tree` and run `yarn watch` (the test runner is Jest)
-6.  Editor settings are optimized for VS Code, so just run `code .` in the root folder. Debugger settings are included in the project.
-7.  After updating jsdocs, best run `yarn build-docs`
-8.  When creating PRs, make sure to check the travis build, it will run some tests which are by default not run locally
-9.  Extensive pull requests are best discussed in an issue first
-10. Have fun!
+2.  `yarn` is the package manager of choice (with workspaces support enabled). Make sure to run Node 8 or higher.
+3.  Run `yarn install` on the root.
+4.  Editor settings are optimized for VS Code, so just run `code .` in the root folder. Debugger settings are included in the project.
+
+For `mobx-state-tree`:
+
+1.  Go to `packages/mobx-state-tree` and run `yarn jest` to ensure all tests pass.
+2.  After updating jsdocs, better run `yarn build-docs` in `packages/mobx-state-tree` to regenerate them.
+
+For `mst-middlewares`:
+
+1.  Go to `packages/mst-middlewares` and run `yarn jest` to ensure all tests pass.
+2.  If your changes depend on a change in `packages/mobx-state-tree` you will need to run `yarn buld` there first!
+
+Once you think your PR is ready:
+
+1.  Run on the root `yarn build` to ensure it all builds.
+2.  Run on the root `yarn test` to ensure all tests pass.
+3.  Create the PR on GitHub.
+4.  Check the CI build passes on the PR thread in GitHub.
+
+Have fun!
 
 ## Thanks!
 

package/dist/core/action.d.ts

@@ -1,48 +1,50 @@
-import { IDisposer, IAnyStateTreeNode } from "../internal";
-export declare type IMiddlewareEventType = "action" | "flow_spawn" | "flow_resume" | "flow_resume_error" | "flow_return" | "flow_throw";
-export declare type IMiddlewareEvent = {
-    type: IMiddlewareEventType;
-    name: string;
-    id: number;
-    parentId: number;
-    rootId: number;
-    allParentIds: number[];
-    context: IAnyStateTreeNode;
-    tree: IAnyStateTreeNode;
-    args: any[];
-};
-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.
- * If a tree is protected (by default), this means that any mutation of the tree will pass through your middleware.
- *
- * For more details, see the [middleware docs](../middleware.md)
- *
- * @param target Node to apply the middleware to.
- * @param middleware Middleware to apply.
- * @returns A callable function to dispose the middleware.
- */
-export declare function addMiddleware(target: IAnyStateTreeNode, handler: IMiddlewareHandler, includeHooks?: boolean): IDisposer;
-/**
- * Binds middleware to a specific action.
- *
- * Example:
- * ```ts
- * type.actions(self => {
- *   function takeA____() {
- *       self.toilet.donate()
- *       self.wipe()
- *       self.wipe()
- *       self.toilet.flush()
- *   }
- *   return {
- *     takeA____: decorate(atomic, takeA____)
- *   }
- * })
- * ```
- *
- * @param handler
- * @param fn
- * @returns The original function
- */
-export declare function decorate<T extends Function>(handler: IMiddlewareHandler, fn: T): T;
+import { IDisposer, IAnyStateTreeNode, IActionContext } from "../internal";
+export declare type IMiddlewareEventType = "action" | "flow_spawn" | "flow_resume" | "flow_resume_error" | "flow_return" | "flow_throw";
+export interface IMiddlewareEvent extends IActionContext {
+    /** Event type */
+    readonly type: IMiddlewareEventType;
+    /** Parent event unique id */
+    readonly parentId: number;
+    /** Parent event object */
+    readonly parentEvent: IMiddlewareEvent | undefined;
+    /** Root event unique id */
+    readonly rootId: number;
+    /** Id of all events, from root until current (excluding current) */
+    readonly allParentIds: number[];
+}
+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.
+ * If a tree is protected (by default), this means that any mutation of the tree will pass through your middleware.
+ *
+ * For more details, see the [middleware docs](../middleware.md)
+ *
+ * @param target Node to apply the middleware to.
+ * @param middleware Middleware to apply.
+ * @returns A callable function to dispose the middleware.
+ */
+export declare function addMiddleware(target: IAnyStateTreeNode, handler: IMiddlewareHandler, includeHooks?: boolean): IDisposer;
+/**
+ * Binds middleware to a specific action.
+ *
+ * Example:
+ * ```ts
+ * type.actions(self => {
+ *   function takeA____() {
+ *       self.toilet.donate()
+ *       self.wipe()
+ *       self.wipe()
+ *       self.toilet.flush()
+ *   }
+ *   return {
+ *     takeA____: decorate(atomic, takeA____)
+ *   }
+ * })
+ * ```
+ *
+ * @param handler
+ * @param fn
+ * @param includeHooks
+ * @returns The original function
+ */
+export declare function decorate<T extends Function>(handler: IMiddlewareHandler, fn: T, includeHooks?: boolean): T;

package/dist/core/actionContext.d.ts

@@ -0,0 +1,27 @@
+import { IAnyStateTreeNode, IMiddlewareEvent } from "../internal";
+export interface IActionContext {
+    /** Event name (action name for actions) */
+    readonly name: string;
+    /** Event unique id */
+    readonly id: number;
+    /** Parent action event object */
+    readonly parentActionEvent: IMiddlewareEvent | undefined;
+    /** Event context (node where the action was invoked) */
+    readonly context: IAnyStateTreeNode;
+    /** Event tree (root node of the node where the action was invoked) */
+    readonly tree: IAnyStateTreeNode;
+    /** Event arguments in an array (action arguments for actions) */
+    readonly args: any[];
+}
+/**
+ * Returns the currently executing MST action context, or undefined if none.
+ */
+export declare function getRunningActionContext(): IActionContext | undefined;
+/**
+ * Returns if the given action context is a parent of this action context.
+ */
+export declare function isActionContextChildOf(actionContext: IActionContext, parent: number | IActionContext | IMiddlewareEvent): boolean;
+/**
+ * Returns if the given action context is this or a parent of this action context.
+ */
+export declare function isActionContextThisOrChildOf(actionContext: IActionContext, parentOrThis: number | IActionContext | IMiddlewareEvent): boolean;

package/dist/core/flow.d.ts

@@ -1,30 +1,14 @@
-/** @hidden */
-declare const $flowYield: unique symbol;
-/** @hidden */
-export interface FlowYield {
-    [$flowYield]: undefined;
-}
-/** @hidden */
-declare const $flowReturn: unique symbol;
-/** @hidden */
-export interface FlowReturn<T> {
-    [$flowReturn]: T;
-}
-/** @hidden */
-export declare type FlowReturnType<R> = IfAllAreFlowYieldThenVoid<R extends FlowReturn<infer FR> ? FR extends Promise<infer FRP> ? FRP : FR : R extends Promise<any> ? FlowYield : R>;
-/** @hidden */
-export declare type IfAllAreFlowYieldThenVoid<R> = Exclude<R, FlowYield> extends never ? void : Exclude<R, FlowYield>;
-/**
- * See [asynchronous actions](https://github.com/mobxjs/mobx-state-tree/blob/master/docs/async-actions.md).
- *
- * @returns The flow as a promise.
- */
-export declare function flow<R, Args extends any[]>(generator: (...args: Args) => IterableIterator<R>): (...args: Args) => Promise<FlowReturnType<R>>;
-/**
- *  Used for TypeScript to make flows that return a promise return the actual promise result.
- *
- * @param val
- * @returns
- */
-export declare function castFlowReturn<T>(val: T): FlowReturn<T>;
-export {};
+/**
+ * See [asynchronous actions](https://github.com/mobxjs/mobx-state-tree/blob/master/docs/async-actions.md).
+ *
+ * @returns The flow as a promise.
+ */
+export declare function flow<R, Args extends any[]>(generator: (...args: Args) => Generator<any, R, any>): (...args: Args) => Promise<R>;
+/**
+ * @deprecated Not needed since TS3.6.
+ * Used for TypeScript to make flows that return a promise return the actual promise result.
+ *
+ * @param val
+ * @returns
+ */
+export declare function castFlowReturn<T>(val: T): T;

package/dist/core/json-patch.d.ts

@@ -1,36 +1,36 @@
-/**
- * https://tools.ietf.org/html/rfc6902
- * http://jsonpatch.com/
- */
-export interface IJsonPatch {
-    op: "replace" | "add" | "remove";
-    path: string;
-    value?: any;
-}
-export interface IReversibleJsonPatch extends IJsonPatch {
-    oldValue: any;
-}
-/**
- * Escape slashes and backslashes.
- *
- * http://tools.ietf.org/html/rfc6901
- */
-export declare function escapeJsonPath(path: string): string;
-/**
- * Unescape slashes and backslashes.
- */
-export declare function unescapeJsonPath(path: string): string;
-/**
- * Generates a json-path compliant json path from path parts.
- *
- * @param path
- * @returns
- */
-export declare function joinJsonPath(path: string[]): string;
-/**
- * Splits and decodes a json path into several parts.
- *
- * @param path
- * @returns
- */
-export declare function splitJsonPath(path: string): string[];
+/**
+ * https://tools.ietf.org/html/rfc6902
+ * http://jsonpatch.com/
+ */
+export interface IJsonPatch {
+    readonly op: "replace" | "add" | "remove";
+    readonly path: string;
+    readonly value?: any;
+}
+export interface IReversibleJsonPatch extends IJsonPatch {
+    readonly oldValue: any;
+}
+/**
+ * Escape slashes and backslashes.
+ *
+ * http://tools.ietf.org/html/rfc6901
+ */
+export declare function escapeJsonPath(path: string): string;
+/**
+ * Unescape slashes and backslashes.
+ */
+export declare function unescapeJsonPath(path: string): string;
+/**
+ * Generates a json-path compliant json path from path parts.
+ *
+ * @param path
+ * @returns
+ */
+export declare function joinJsonPath(path: string[]): string;
+/**
+ * Splits and decodes a json path into several parts.
+ *
+ * @param path
+ * @returns
+ */
+export declare function splitJsonPath(path: string): string[];