mobx-state-tree 5.1.7 → 5.2.0-alpha.1

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

@@ -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

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";

package/dist/mobx-state-tree.js

@@ -842,14 +842,21 @@ function getPropertyMembers(typeOrNode) {
     };
 }
 /**
- * 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
  */
 function getMembers(target) {
     var type = getStateTreeNode(target).type;
-    var reflected = __assign(__assign({}, getPropertyMembers(type)), { actions: [], volatile: [], views: [] });
+    var reflected = __assign(__assign({}, getPropertyMembers(type)), { actions: [], volatile: [], views: [], flowActions: [] });
     var props = Object.getOwnPropertyNames(target);
     props.forEach(function (key) {
         if (key in reflected.properties)
@@ -864,6 +871,8 @@ function getMembers(target) {
         }
         if (descriptor.value._isMSTAction === true)
             reflected.actions.push(key);
+        if (descriptor.value._isFlowAction === true)
+            reflected.flowActions.push(key);
         else if (mobx.isObservableProp(target, key))
             reflected.volatile.push(key);
         else
@@ -1590,9 +1599,10 @@ var ObjectNode = /** @class */ (function (_super) {
         enumerable: false,
         configurable: true,
         writable: true,
-        value: function () {
+        value: function (fireHooks) {
+            if (fireHooks === void 0) { fireHooks = true; }
             if (this._observableInstanceState === 0 /* UNINITIALIZED */) {
-                this.createObservableInstance();
+                this.createObservableInstance(fireHooks);
             }
         }
     });
@@ -1600,8 +1610,9 @@ var ObjectNode = /** @class */ (function (_super) {
         enumerable: false,
         configurable: true,
         writable: true,
-        value: function () {
-            var e_1, _a;
+        value: function (fireHooks) {
+            var e_1, _a, e_2, _b;
+            if (fireHooks === void 0) { fireHooks = true; }
             if (devMode()) {
                 if (this.state !== NodeLifeCycle.INITIALIZING) {
                     // istanbul ignore next
@@ -1626,7 +1637,8 @@ var ObjectNode = /** @class */ (function (_super) {
                 // initialize the uninitialized parent chain from parent to child
                 for (var parentChain_1 = __values(parentChain), parentChain_1_1 = parentChain_1.next(); !parentChain_1_1.done; parentChain_1_1 = parentChain_1.next()) {
                     var p = parentChain_1_1.value;
-                    p.createObservableInstanceIfNeeded();
+                    // delay firing hooks until after all parents have been created
+                    p.createObservableInstanceIfNeeded(false);
                 }
             }
             catch (e_1_1) { e_1 = { error: e_1_1 }; }
@@ -1657,8 +1669,28 @@ var ObjectNode = /** @class */ (function (_super) {
                 this._addSnapshotReaction();
             this._childNodes = EMPTY_OBJECT;
             this.state = NodeLifeCycle.CREATED;
-            this.fireHook(Hook.afterCreate);
-            this.finalizeCreation();
+            if (fireHooks) {
+                this.fireHook(Hook.afterCreate);
+                // Note that the parent might not be finalized at this point
+                // so afterAttach won't be called until later in that case
+                this.finalizeCreation();
+                try {
+                    // fire the hooks of the parents that we created
+                    for (var _c = __values(parentChain.reverse()), _d = _c.next(); !_d.done; _d = _c.next()) {
+                        var p = _d.value;
+                        p.fireHook(Hook.afterCreate);
+                        // This will call afterAttach on the child if necessary
+                        p.finalizeCreation();
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+            }
         }
     });
     Object.defineProperty(ObjectNode.prototype, "root", {
@@ -1957,19 +1989,19 @@ var ObjectNode = /** @class */ (function (_super) {
         value: function () {
             var _this = this;
             this.baseFinalizeCreation(function () {
-                var e_2, _a;
+                var e_3, _a;
                 try {
                     for (var _b = __values(_this.getChildren()), _c = _b.next(); !_c.done; _c = _b.next()) {
                         var child = _c.value;
                         child.finalizeCreation();
                     }
                 }
-                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                catch (e_3_1) { e_3 = { error: e_3_1 }; }
                 finally {
                     try {
                         if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                     }
-                    finally { if (e_2) throw e_2.error; }
+                    finally { if (e_3) throw e_3.error; }
                 }
                 _this.fireInternalHook(Hook.afterCreationFinalization);
             });
@@ -2293,6 +2325,9 @@ var TypeFlags;
     TypeFlags[TypeFlags["Integer"] = 131072] = "Integer";
     TypeFlags[TypeFlags["Custom"] = 262144] = "Custom";
     TypeFlags[TypeFlags["SnapshotProcessor"] = 524288] = "SnapshotProcessor";
+    TypeFlags[TypeFlags["Lazy"] = 1048576] = "Lazy";
+    TypeFlags[TypeFlags["Finite"] = 2097152] = "Finite";
+    TypeFlags[TypeFlags["Float"] = 4194304] = "Float";
 })(TypeFlags || (TypeFlags = {}));
 /**
  * @internal
@@ -3141,6 +3176,7 @@ function createActionInvoker(target, name, fn) {
         }, fn);
     };
     res._isMSTAction = true;
+    res._isFlowAction = fn._isFlowAction;
     return res;
 }
 /**
@@ -3556,17 +3592,25 @@ var IdentifierCache = /** @class */ (function () {
         enumerable: false,
         configurable: true,
         writable: true,
-        value: function (node) {
+        value: function (splitNode) {
             var _this = this;
-            var res = new IdentifierCache();
-            var basePath = node.path;
+            var newCache = new IdentifierCache();
+            // The slash is added here so we only match children of the splitNode. In version 5.1.8 and
+            // earlier there was no trailing slash, so non children that started with the same path string
+            // were being matched incorrectly.
+            var basePath = splitNode.path + "/";
             mobx.entries(this.cache).forEach(function (_a) {
                 var _b = __read(_a, 2), id = _b[0], nodes = _b[1];
                 var modified = false;
                 for (var i = nodes.length - 1; i >= 0; i--) {
-                    if (nodes[i].path.indexOf(basePath) === 0) {
-                        res.addNodeToCache(nodes[i], false); // no need to update lastUpdated since it is a whole new cache
+                    var node = nodes[i];
+                    if (node === splitNode || node.path.indexOf(basePath) === 0) {
+                        newCache.addNodeToCache(node, false); // no need to update lastUpdated since it is a whole new cache
                         nodes.splice(i, 1);
+                        // remove empty sets from cache
+                        if (!nodes.length) {
+                            _this.cache.delete(id);
+                        }
                         modified = true;
                     }
                 }
@@ -3574,7 +3618,7 @@ var IdentifierCache = /** @class */ (function () {
                     _this.updateLastCacheModificationPerId(id);
                 }
             });
-            return res;
+            return newCache;
         }
     });
     Object.defineProperty(IdentifierCache.prototype, "has", {
@@ -3858,15 +3902,24 @@ function identity(_) {
     return _;
 }
 /**
- * pollyfill (for IE) suggested in MDN:
- * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger
  * @internal
  * @hidden
  */
-var isInteger = Number.isInteger ||
-    function (value) {
-        return typeof value === "number" && isFinite(value) && Math.floor(value) === value;
-    };
+var isInteger = Number.isInteger;
+/**
+ * @internal
+ * @hidden
+ */
+function isFloat(val) {
+    return Number(val) === val && val % 1 !== 0;
+}
+/**
+ * @internal
+ * @hidden
+ */
+function isFinite(val) {
+    return Number.isFinite(val);
+}
 /**
  * @internal
  * @hidden
@@ -4410,7 +4463,7 @@ function createFlowSpawner(name, generator) {
         var args = arguments;
         function wrap(fn, type, arg) {
             fn.$mst_middleware = spawner.$mst_middleware; // pick up any middleware attached to the flow
-            runWithActionContext(__assign(__assign({}, contextBase), { type: type, args: [arg] }), fn);
+            return runWithActionContext(__assign(__assign({}, contextBase), { type: type, args: [arg] }), fn);
         }
         return new Promise(function (resolve, reject) {
             var gen;
@@ -4424,7 +4477,10 @@ function createFlowSpawner(name, generator) {
                 var ret;
                 try {
                     // prettier-ignore
-                    wrap(function (r) { ret = gen.next(r); }, "flow_resume", res);
+                    var cancelError = wrap(function (r) { ret = gen.next(r); }, "flow_resume", res);
+                    if (cancelError instanceof Error) {
+                        ret = gen.throw(cancelError);
+                    }
                 }
                 catch (e) {
                     // prettier-ignore
@@ -4468,6 +4524,7 @@ function createFlowSpawner(name, generator) {
             }
         });
     };
+    spawner._isFlowAction = true;
     return spawner;
 }
 
@@ -4881,8 +4938,8 @@ var MapIdentifierMode;
 })(MapIdentifierMode || (MapIdentifierMode = {}));
 var MSTMap = /** @class */ (function (_super) {
     __extends(MSTMap, _super);
-    function MSTMap(initialData) {
-        return _super.call(this, initialData, mobx.observable.ref.enhancer) || this;
+    function MSTMap(initialData, name) {
+        return _super.call(this, initialData, mobx.observable.ref.enhancer, name) || this;
     }
     Object.defineProperty(MSTMap.prototype, "get", {
         enumerable: false,
@@ -5070,7 +5127,7 @@ var MapType = /** @class */ (function (_super) {
         configurable: true,
         writable: true,
         value: function (childNodes) {
-            return new MSTMap(childNodes);
+            return new MSTMap(childNodes, this.describe());
         }
     });
     Object.defineProperty(MapType.prototype, "finalizeNewInstance", {
@@ -5412,7 +5469,8 @@ var ArrayType = /** @class */ (function (_super) {
         configurable: true,
         writable: true,
         value: function (childNodes) {
-            return mobx.observable.array(convertChildNodesToArray(childNodes), mobxShallow);
+            var options = __assign(__assign({}, mobxShallow), { name: this.describe() });
+            return mobx.observable.array(convertChildNodesToArray(childNodes), options);
         }
     });
     Object.defineProperty(ArrayType.prototype, "finalizeNewInstance", {
@@ -6016,6 +6074,7 @@ var ModelType = /** @class */ (function (_super) {
                 // while still allowing the middlewares to register them
                 var middlewares = action2.$mst_middleware; // make sure middlewares are not lost
                 var boundAction = action2.bind(actions);
+                boundAction._isFlowAction = action2._isFlowAction || false;
                 boundAction.$mst_middleware = middlewares;
                 var actionInvoker = createActionInvoker(self, name, boundAction);
                 actions[name] = actionInvoker;
@@ -6141,7 +6200,8 @@ var ModelType = /** @class */ (function (_super) {
         configurable: true,
         writable: true,
         value: function (childNodes) {
-            return mobx.observable.object(childNodes, EMPTY_OBJECT, mobxShallow);
+            var options = __assign(__assign({}, mobxShallow), { name: this.describe() });
+            return mobx.observable.object(childNodes, EMPTY_OBJECT, options);
         }
     });
     Object.defineProperty(ModelType.prototype, "finalizeNewInstance", {
@@ -6272,8 +6332,8 @@ var ModelType = /** @class */ (function (_super) {
         configurable: true,
         writable: true,
         value: function (node, snapshot) {
+            typecheckInternal(this, snapshot);
             var preProcessedSnapshot = this.applySnapshotPreProcessor(snapshot);
-            typecheckInternal(this, preProcessedSnapshot);
             this.forAllProps(function (name) {
                 node.storedValue[name] = preProcessedSnapshot[name];
             });
@@ -6375,6 +6435,9 @@ function model() {
     for (var _i = 0; _i < arguments.length; _i++) {
         args[_i] = arguments[_i];
     }
+    if (devMode() && typeof args[0] !== "string" && args[1]) {
+        throw fail$1("Model creation failed. First argument must be a string when two arguments are provided");
+    }
     var name = typeof args[0] === "string" ? args.shift() : "AnonymousModel";
     var properties = args.shift() || {};
     return new ModelType({ name: name, properties: properties });
@@ -6528,7 +6591,6 @@ var string = new CoreType("string", TypeFlags.String, function (v) { return type
 var number = new CoreType("number", TypeFlags.Number, function (v) { return typeof v === "number"; });
 /**
  * `types.integer` - Creates a type that can only contain an integer value.
- * This type is used for integer values by default
  *
  * Example:
  * ```ts
@@ -6540,6 +6602,32 @@ var number = new CoreType("number", TypeFlags.Number, function (v) { return type
  */
 // tslint:disable-next-line:variable-name
 var integer = new CoreType("integer", TypeFlags.Integer, function (v) { return isInteger(v); });
+/**
+ * `types.float` - Creates a type that can only contain an float value.
+ *
+ * Example:
+ * ```ts
+ * const Size = types.model({
+ *   width: types.float,
+ *   height: 10
+ * })
+ * ```
+ */
+// tslint:disable-next-line:variable-name
+var float = new CoreType("float", TypeFlags.Float, function (v) { return isFloat(v); });
+/**
+ * `types.finite` - Creates a type that can only contain an finite value.
+ *
+ * Example:
+ * ```ts
+ * const Size = types.model({
+ *   width: types.finite,
+ *   height: 10
+ * })
+ * ```
+ */
+// tslint:disable-next-line:variable-name
+var finite = new CoreType("finite", TypeFlags.Finite, function (v) { return isFinite(v); });
 /**
  * `types.boolean` - Creates a type that can only contain a boolean value.
  * This type is used for boolean values by default
@@ -7079,7 +7167,7 @@ var OptionalValue = /** @class */ (function (_super) {
         writable: true,
         value: function (parent, subpath, environment, initialValue) {
             if (this.optionalValues.indexOf(initialValue) >= 0) {
-                var defaultInstanceOrSnapshot = this.getDefaultInstanceOrSnapshot();
+                var defaultInstanceOrSnapshot = this.getDefaultInstanceOrSnapshot(parent);
                 return this._subtype.instantiate(parent, subpath, environment, defaultInstanceOrSnapshot);
             }
             return this._subtype.instantiate(parent, subpath, environment, initialValue);
@@ -7092,16 +7180,16 @@ var OptionalValue = /** @class */ (function (_super) {
         value: function (current, newValue, parent, subpath) {
             return this._subtype.reconcile(current, this.optionalValues.indexOf(newValue) < 0 && this._subtype.is(newValue)
                 ? newValue
-                : this.getDefaultInstanceOrSnapshot(), parent, subpath);
+                : this.getDefaultInstanceOrSnapshot(parent), parent, subpath);
         }
     });
     Object.defineProperty(OptionalValue.prototype, "getDefaultInstanceOrSnapshot", {
         enumerable: false,
         configurable: true,
         writable: true,
-        value: function () {
+        value: function (parent) {
             var defaultInstanceOrSnapshot = typeof this._defaultValue === "function"
-                ? this._defaultValue()
+                ? this._defaultValue(parent)
                 : this._defaultValue;
             // while static values are already snapshots and checked on types.optional
             // generator functions must always be rechecked just in case
@@ -7389,6 +7477,120 @@ function isLateType(type) {
     return isType(type) && (type.flags & TypeFlags.Late) > 0;
 }
 
+function lazy(name, options) {
+    // TODO: fix this unknown casting to be stricter
+    return new Lazy(name, options);
+}
+/**
+ * @internal
+ * @hidden
+ */
+var Lazy = /** @class */ (function (_super) {
+    __extends(Lazy, _super);
+    function Lazy(name, options) {
+        var _this = _super.call(this, name) || this;
+        Object.defineProperty(_this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: options
+        });
+        Object.defineProperty(_this, "flags", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: TypeFlags.Lazy
+        });
+        Object.defineProperty(_this, "loadedType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(_this, "pendingNodeList", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: mobx.observable.array()
+        });
+        mobx.when(function () {
+            return _this.pendingNodeList.length > 0 &&
+                _this.pendingNodeList.some(function (node) {
+                    return node.isAlive &&
+                        _this.options.shouldLoadPredicate(node.parent ? node.parent.value : null);
+                });
+        }, function () {
+            _this.options.loadType().then(mobx.action(function (type) {
+                _this.loadedType = type;
+                _this.pendingNodeList.forEach(function (node) {
+                    if (!node.parent)
+                        return;
+                    if (!_this.loadedType)
+                        return;
+                    node.parent.applyPatches([
+                        {
+                            op: "replace",
+                            path: "/" + node.subpath,
+                            value: node.snapshot
+                        }
+                    ]);
+                });
+            }));
+        });
+        return _this;
+    }
+    Object.defineProperty(Lazy.prototype, "describe", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+            return "<lazy " + this.name + ">";
+        }
+    });
+    Object.defineProperty(Lazy.prototype, "instantiate", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (parent, subpath, environment, value) {
+            var _this = this;
+            if (this.loadedType) {
+                return this.loadedType.instantiate(parent, subpath, environment, value);
+            }
+            var node = createScalarNode(this, parent, subpath, environment, deepFreeze(value));
+            this.pendingNodeList.push(node);
+            mobx.when(function () { return !node.isAlive; }, function () { return _this.pendingNodeList.splice(_this.pendingNodeList.indexOf(node), 1); });
+            return node;
+        }
+    });
+    Object.defineProperty(Lazy.prototype, "isValidSnapshot", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (value, context) {
+            if (this.loadedType) {
+                return this.loadedType.validate(value, context);
+            }
+            if (!isSerializable(value)) {
+                return typeCheckFailure(context, value, "Value is not serializable and cannot be lazy");
+            }
+            return typeCheckSuccess();
+        }
+    });
+    Object.defineProperty(Lazy.prototype, "reconcile", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (current, value, parent, subpath) {
+            if (this.loadedType) {
+                current.die();
+                return this.loadedType.instantiate(parent, subpath, parent.environment, value);
+            }
+            return _super.prototype.reconcile.call(this, current, value, parent, subpath);
+        }
+    });
+    return Lazy;
+}(SimpleType));
+
 /**
  * @internal
  * @hidden
@@ -8327,6 +8529,8 @@ var types = {
     boolean: boolean,
     number: number,
     integer: integer,
+    float: float,
+    finite: finite,
     Date: DatePrimitive,
     map: map,
     array: array,
@@ -8334,6 +8538,7 @@ var types = {
     identifier: identifier,
     identifierNumber: identifierNumber,
     late: late,
+    lazy: lazy,
     undefined: undefinedType,
     null: nullType,
     snapshotProcessor: snapshotProcessor