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

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

@@ -1,4 +1,4 @@
-import { isComputedProp, isObservableProp, createAtom, action, computed, _allowStateChangesInsideComputed, reaction, runInAction, observable, values, entries, _getGlobalState, isObservableArray, isObservableObject, defineProperty as defineProperty$1, ObservableMap, _interceptReads, intercept, observe, _getAdministration, set, makeObservable, getAtom } from 'mobx';
+import { isComputedProp, isObservableProp, createAtom, action, computed, _allowStateChangesInsideComputed, reaction, runInAction, observable, values, entries, _getGlobalState, isObservableArray, isObservableObject, defineProperty as defineProperty$1, ObservableMap, _interceptReads, intercept, observe, _getAdministration, set, makeObservable, getAtom, when } from 'mobx';
 
 var livelinessChecking = "warn";
 /**
@@ -196,7 +196,7 @@ function getChildType(object, propertyName) {
 /**
  * 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
@@ -241,7 +241,7 @@ function applyPatch(target, patch) {
 }
 /**
  * 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
@@ -591,7 +591,7 @@ function getIdentifier(target) {
     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.
@@ -691,9 +691,9 @@ function getRelativePath(base, target) {
 }
 /**
  * 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.
@@ -838,14 +838,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)
@@ -860,6 +867,8 @@ function getMembers(target) {
         }
         if (descriptor.value._isMSTAction === true)
             reflected.actions.push(key);
+        if (descriptor.value._isFlowAction === true)
+            reflected.flowActions.push(key);
         else if (isObservableProp(target, key))
             reflected.volatile.push(key);
         else
@@ -894,13 +903,13 @@ function getMembers(target) {
  * ```
  *
  * @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.
  *
@@ -924,14 +933,14 @@ function cast(snapshotOrInstance) {
  * ```
  *
  * @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:
@@ -955,7 +964,7 @@ function castToSnapshot(snapshotOrInstance) {
  * ```
  *
  * @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;
@@ -1586,9 +1595,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);
             }
         }
     });
@@ -1596,8 +1606,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
@@ -1622,7 +1633,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 }; }
@@ -1653,8 +1665,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", {
@@ -1953,19 +1985,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);
             });
@@ -2289,6 +2321,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
@@ -3137,6 +3172,7 @@ function createActionInvoker(target, name, fn) {
         }, fn);
     };
     res._isMSTAction = true;
+    res._isFlowAction = fn._isFlowAction;
     return res;
 }
 /**
@@ -3552,17 +3588,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 + "/";
             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;
                     }
                 }
@@ -3570,7 +3614,7 @@ var IdentifierCache = /** @class */ (function () {
                     _this.updateLastCacheModificationPerId(id);
                 }
             });
-            return res;
+            return newCache;
         }
     });
     Object.defineProperty(IdentifierCache.prototype, "has", {
@@ -3854,15 +3898,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
@@ -4467,6 +4520,7 @@ function createFlowSpawner(name, generator) {
             }
         });
     };
+    spawner._isFlowAction = true;
     return spawner;
 }
 
@@ -4880,8 +4934,8 @@ var MapIdentifierMode;
 })(MapIdentifierMode || (MapIdentifierMode = {}));
 var MSTMap = /** @class */ (function (_super) {
     __extends(MSTMap, _super);
-    function MSTMap(initialData) {
-        return _super.call(this, initialData, observable.ref.enhancer) || this;
+    function MSTMap(initialData, name) {
+        return _super.call(this, initialData, observable.ref.enhancer, name) || this;
     }
     Object.defineProperty(MSTMap.prototype, "get", {
         enumerable: false,
@@ -5069,7 +5123,7 @@ var MapType = /** @class */ (function (_super) {
         configurable: true,
         writable: true,
         value: function (childNodes) {
-            return new MSTMap(childNodes);
+            return new MSTMap(childNodes, this.name);
         }
     });
     Object.defineProperty(MapType.prototype, "finalizeNewInstance", {
@@ -5096,7 +5150,7 @@ var MapType = /** @class */ (function (_super) {
         configurable: true,
         writable: true,
         value: function () {
-            return "Map<string, " + this._subType.describe() + ">";
+            return this.name;
         }
     });
     Object.defineProperty(MapType.prototype, "getChildren", {
@@ -5332,7 +5386,7 @@ MapType.prototype.applySnapshot = action(MapType.prototype.applySnapshot);
  * @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.
@@ -5411,7 +5465,8 @@ var ArrayType = /** @class */ (function (_super) {
         configurable: true,
         writable: true,
         value: function (childNodes) {
-            return observable.array(convertChildNodesToArray(childNodes), mobxShallow);
+            var options = __assign(__assign({}, mobxShallow), { name: this.name });
+            return observable.array(convertChildNodesToArray(childNodes), options);
         }
     });
     Object.defineProperty(ArrayType.prototype, "finalizeNewInstance", {
@@ -5438,7 +5493,7 @@ var ArrayType = /** @class */ (function (_super) {
         configurable: true,
         writable: true,
         value: function () {
-            return this._subType.describe() + "[]";
+            return this.name;
         }
     });
     Object.defineProperty(ArrayType.prototype, "getChildren", {
@@ -5794,8 +5849,18 @@ var defaultObjectOptions = {
     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)
@@ -6015,6 +6080,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;
@@ -6140,7 +6206,8 @@ var ModelType = /** @class */ (function (_super) {
         configurable: true,
         writable: true,
         value: function (childNodes) {
-            return observable.object(childNodes, EMPTY_OBJECT, mobxShallow);
+            var options = __assign(__assign({}, mobxShallow), { name: this.name });
+            return observable.object(childNodes, EMPTY_OBJECT, options);
         }
     });
     Object.defineProperty(ModelType.prototype, "finalizeNewInstance", {
@@ -6216,10 +6283,11 @@ var ModelType = /** @class */ (function (_super) {
         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 = _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;
@@ -6234,7 +6302,14 @@ var ModelType = /** @class */ (function (_super) {
             if (applyPostProcess === void 0) { applyPostProcess = true; }
             var res = {};
             this.forAllProps(function (name, type) {
-                getAtom(node.storedValue, name).reportObserved();
+                try {
+                    // TODO: FIXME, make sure the observable ref is used!
+                    var atom = 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) {
@@ -6374,6 +6449,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 });
@@ -6527,7 +6605,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
@@ -6539,6 +6616,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
@@ -7388,6 +7491,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: observable.array()
+        });
+        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(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);
+            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
@@ -8326,6 +8543,8 @@ var types = {
     boolean: boolean,
     number: number,
     integer: integer,
+    float: float,
+    finite: finite,
     Date: DatePrimitive,
     map: map,
     array: array,
@@ -8333,6 +8552,7 @@ var types = {
     identifier: identifier,
     identifierNumber: identifierNumber,
     late: late,
+    lazy: lazy,
     undefined: undefinedType,
     null: nullType,
     snapshotProcessor: snapshotProcessor