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

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";
 /**
@@ -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
@@ -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.describe());
         }
     });
     Object.defineProperty(MapType.prototype, "finalizeNewInstance", {
@@ -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.describe() });
+            return observable.array(convertChildNodesToArray(childNodes), options);
         }
     });
     Object.defineProperty(ArrayType.prototype, "finalizeNewInstance", {
@@ -6015,6 +6070,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 +6196,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.describe() });
+            return observable.object(childNodes, EMPTY_OBJECT, options);
         }
     });
     Object.defineProperty(ModelType.prototype, "finalizeNewInstance", {
@@ -6374,6 +6431,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 +6587,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 +6598,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
@@ -7078,7 +7163,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);
@@ -7091,16 +7176,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
@@ -7388,6 +7473,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 +8525,8 @@ var types = {
     boolean: boolean,
     number: number,
     integer: integer,
+    float: float,
+    finite: finite,
     Date: DatePrimitive,
     map: map,
     array: array,
@@ -8333,6 +8534,7 @@ var types = {
     identifier: identifier,
     identifierNumber: identifierNumber,
     late: late,
+    lazy: lazy,
     undefined: undefinedType,
     null: nullType,
     snapshotProcessor: snapshotProcessor