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

package/dist/mobx-state-tree.umd.js

@@ -842,14 +842,21 @@
         };
     }
     /**
-     * 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 @@
             }
             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 @@
             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 @@
             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 (this.state !== NodeLifeCycle.INITIALIZING) {
                         // istanbul ignore next
@@ -1626,7 +1637,8 @@
                     // 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 @@
                     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 @@
             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 @@
         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 @@
             }, fn);
         };
         res._isMSTAction = true;
+        res._isFlowAction = fn._isFlowAction;
         return res;
     }
     /**
@@ -3556,17 +3592,25 @@
             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 @@
                         _this.updateLastCacheModificationPerId(id);
                     }
                 });
-                return res;
+                return newCache;
             }
         });
         Object.defineProperty(IdentifierCache.prototype, "has", {
@@ -3858,15 +3902,24 @@
         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
@@ -4388,7 +4441,7 @@
             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;
@@ -4402,7 +4455,10 @@
                     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
@@ -4446,6 +4502,7 @@
                 }
             });
         };
+        spawner._isFlowAction = true;
         return spawner;
     }
 
@@ -4859,8 +4916,8 @@
     })(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,
@@ -5048,7 +5105,7 @@
             configurable: true,
             writable: true,
             value: function (childNodes) {
-                return new MSTMap(childNodes);
+                return new MSTMap(childNodes, this.describe());
             }
         });
         Object.defineProperty(MapType.prototype, "finalizeNewInstance", {
@@ -5390,7 +5447,8 @@
             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", {
@@ -5994,6 +6052,7 @@
                     // 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;
@@ -6119,7 +6178,8 @@
             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", {
@@ -6250,8 +6310,8 @@
             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];
                 });
@@ -6353,6 +6413,9 @@
         for (var _i = 0; _i < arguments.length; _i++) {
             args[_i] = arguments[_i];
         }
+        if (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 });
@@ -6506,7 +6569,6 @@
     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
@@ -6518,6 +6580,32 @@
      */
     // 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
@@ -7057,7 +7145,7 @@
             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);
@@ -7070,16 +7158,16 @@
             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
@@ -7367,6 +7455,120 @@
         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
@@ -8305,6 +8507,8 @@
         boolean: boolean,
         number: number,
         integer: integer,
+        float: float,
+        finite: finite,
         Date: DatePrimitive,
         map: map,
         array: array,
@@ -8312,6 +8516,7 @@
         identifier: identifier,
         identifierNumber: identifierNumber,
         late: late,
+        lazy: lazy,
         undefined: undefinedType,
         null: nullType,
         snapshotProcessor: snapshotProcessor