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

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

@@ -200,7 +200,7 @@
     /**
      * 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
@@ -245,7 +245,7 @@
     }
     /**
      * 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
@@ -595,7 +595,7 @@
         return getStateTreeNode(target).identifier;
     }
     /**
-     * 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.
@@ -695,9 +695,9 @@
     }
     /**
      * 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.
@@ -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
@@ -898,13 +907,13 @@
      * ```
      *
      * @param snapshotOrInstance Snapshot or instance
-     * @returns The same object casted as an instance
+     * @returns The same object cast as an instance
      */
     function cast(snapshotOrInstance) {
         return snapshotOrInstance;
     }
     /**
-     * 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.
      *
@@ -928,14 +937,14 @@
      * ```
      *
      * @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
      */
     function castToSnapshot(snapshotOrInstance) {
         return snapshotOrInstance;
     }
     /**
-     * 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:
@@ -959,7 +968,7 @@
      * ```
      *
      * @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)
      */
     function castToReferenceSnapshot(instance) {
         return instance;
@@ -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
@@ -4449,6 +4502,7 @@
                 }
             });
         };
+        spawner._isFlowAction = true;
         return spawner;
     }
 
@@ -4862,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,
@@ -5051,7 +5105,7 @@
             configurable: true,
             writable: true,
             value: function (childNodes) {
-                return new MSTMap(childNodes);
+                return new MSTMap(childNodes, this.name);
             }
         });
         Object.defineProperty(MapType.prototype, "finalizeNewInstance", {
@@ -5078,7 +5132,7 @@
             configurable: true,
             writable: true,
             value: function () {
-                return "Map<string, " + this._subType.describe() + ">";
+                return this.name;
             }
         });
         Object.defineProperty(MapType.prototype, "getChildren", {
@@ -5314,7 +5368,7 @@
      * @returns
      */
     function map(subtype) {
-        return new MapType("map<string, " + subtype.name + ">", subtype);
+        return new MapType("Map<string, " + subtype.name + ">", subtype);
     }
     /**
      * Returns if a given value represents a map type.
@@ -5393,7 +5447,8 @@
             configurable: true,
             writable: true,
             value: function (childNodes) {
-                return mobx.observable.array(convertChildNodesToArray(childNodes), mobxShallow);
+                var options = __assign(__assign({}, mobxShallow), { name: this.name });
+                return mobx.observable.array(convertChildNodesToArray(childNodes), options);
             }
         });
         Object.defineProperty(ArrayType.prototype, "finalizeNewInstance", {
@@ -5420,7 +5475,7 @@
             configurable: true,
             writable: true,
             value: function () {
-                return this._subType.describe() + "[]";
+                return this.name;
             }
         });
         Object.defineProperty(ArrayType.prototype, "getChildren", {
@@ -5776,8 +5831,18 @@
         initializers: EMPTY_ARRAY
     };
     function toPropertiesObject(declaredProps) {
+        var keysList = Object.keys(declaredProps);
+        var alreadySeenKeys = {};
+        keysList.forEach(function (key) {
+            if (alreadySeenKeys[key]) {
+                throw fail$1(key + " is declared twice in the model. Model should not contain same keys");
+            }
+            else {
+                alreadySeenKeys[key] = true;
+            }
+        });
         // loop through properties and ensures that all items are types
-        return Object.keys(declaredProps).reduce(function (props, key) {
+        return keysList.reduce(function (props, key) {
             var _a, _b, _c;
             // warn if user intended a HOOK
             if (key in Hook)
@@ -5997,6 +6062,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;
@@ -6122,7 +6188,8 @@
             configurable: true,
             writable: true,
             value: function (childNodes) {
-                return mobx.observable.object(childNodes, EMPTY_OBJECT, mobxShallow);
+                var options = __assign(__assign({}, mobxShallow), { name: this.name });
+                return mobx.observable.object(childNodes, EMPTY_OBJECT, options);
             }
         });
         Object.defineProperty(ModelType.prototype, "finalizeNewInstance", {
@@ -6198,10 +6265,11 @@
             configurable: true,
             writable: true,
             value: function (node, key) {
+                var _a;
                 if (!(key in this.properties))
                     throw fail$1("Not a value property: " + key);
                 var adm = mobx._getAdministration(node.storedValue, key);
-                var childNode = adm.raw();
+                var childNode = (_a = adm.raw) === null || _a === void 0 ? void 0 : _a.call(adm);
                 if (!childNode)
                     throw fail$1("Node not available for property " + key);
                 return childNode;
@@ -6216,7 +6284,14 @@
                 if (applyPostProcess === void 0) { applyPostProcess = true; }
                 var res = {};
                 this.forAllProps(function (name, type) {
-                    mobx.getAtom(node.storedValue, name).reportObserved();
+                    try {
+                        // TODO: FIXME, make sure the observable ref is used!
+                        var atom = mobx.getAtom(node.storedValue, name);
+                        atom.reportObserved();
+                    }
+                    catch (e) {
+                        throw fail$1(name + " property is declared twice");
+                    }
                     res[name] = _this.getChildNode(node, name).snapshot;
                 });
                 if (applyPostProcess) {
@@ -6356,6 +6431,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 });
@@ -6509,7 +6587,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
@@ -6521,6 +6598,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
@@ -7370,6 +7473,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
@@ -8308,6 +8525,8 @@
         boolean: boolean,
         number: number,
         integer: integer,
+        float: float,
+        finite: finite,
         Date: DatePrimitive,
         map: map,
         array: array,
@@ -8315,6 +8534,7 @@
         identifier: identifier,
         identifierNumber: identifierNumber,
         late: late,
+        lazy: lazy,
         undefined: undefinedType,
         null: nullType,
         snapshotProcessor: snapshotProcessor