mobx-state-tree 5.0.0 → 5.0.4

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

@@ -1,4 +1,4 @@
-import { isComputedProp, isObservableProp, createAtom, makeObservable, action, _allowStateChangesInsideComputed, reaction, computed, runInAction, observable, values, entries, _getGlobalState, isObservableArray, getAtom, ObservableMap, _interceptReads, intercept, observe, _getAdministration, set } 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 } from 'mobx';
 
 var livelinessChecking = "warn";
 /**
@@ -64,11 +64,13 @@ PERFORMANCE OF THIS SOFTWARE.
 var extendStatics = function(d, b) {
     extendStatics = Object.setPrototypeOf ||
         ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
     return extendStatics(d, b);
 };
 
 function __extends(d, b) {
+    if (typeof b !== "function" && b !== null)
+        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
     extendStatics(d, b);
     function __() { this.constructor = d; }
     d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
@@ -97,13 +99,6 @@ function __rest(s, e) {
     return t;
 }
 
-function __decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-
 function __generator(thisArg, body) {
     var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
     return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
@@ -161,6 +156,7 @@ function __read(o, n) {
     return ar;
 }
 
+/** @deprecated */
 function __spread() {
     for (var ar = [], i = 0; i < arguments.length; i++)
         ar = ar.concat(__read(arguments[i]));
@@ -1130,6 +1126,14 @@ var BaseNode = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
+    Object.defineProperty(BaseNode.prototype, "getReconciliationType", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+            return this.type;
+        }
+    });
     Object.defineProperty(BaseNode.prototype, "baseSetParent", {
         enumerable: false,
         configurable: true,
@@ -1265,7 +1269,6 @@ var ScalarNode = /** @class */ (function (_super) {
     __extends(ScalarNode, _super);
     function ScalarNode(simpleType, parent, subpath, environment, initialSnapshot) {
         var _this = _super.call(this, simpleType, parent, subpath, environment) || this;
-        makeObservable(_this);
         try {
             _this.storedValue = simpleType.createNewInstance(initialSnapshot);
         }
@@ -1386,11 +1389,9 @@ var ScalarNode = /** @class */ (function (_super) {
             this.fireInternalHook(name);
         }
     });
-    __decorate([
-        action
-    ], ScalarNode.prototype, "die", null);
     return ScalarNode;
 }(BaseNode));
+ScalarNode.prototype.die = action(ScalarNode.prototype.die);
 
 var nextNodeId = 1;
 var snapshotReactionOptions = {
@@ -1508,6 +1509,12 @@ var ObjectNode = /** @class */ (function (_super) {
             writable: true,
             value: false
         });
+        Object.defineProperty(_this, "_snapshotComputed", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(_this, "_snapshotUponDeath", {
             enumerable: true,
             configurable: true,
@@ -1521,7 +1528,7 @@ var ObjectNode = /** @class */ (function (_super) {
             writable: true,
             value: void 0
         });
-        makeObservable(_this);
+        _this._snapshotComputed = computed(function () { return freeze(_this.getSnapshot()); });
         _this.unbox = _this.unbox.bind(_this);
         _this._initialSnapshot = freeze(initialValue);
         _this.identifierAttribute = complexType.identifierAttribute;
@@ -1641,9 +1648,7 @@ var ObjectNode = /** @class */ (function (_super) {
                 this._isRunningAction = false;
             }
             this._observableInstanceState = 2 /* CREATED */;
-            // NOTE: we need to touch snapshot, because non-observable
-            // "_observableInstanceState" field was touched
-            invalidateComputed(this, "snapshot");
+            this._snapshotComputed.trackAndCompute();
             if (this.isRoot)
                 this._addSnapshotReaction();
             this._childNodes = EMPTY_OBJECT;
@@ -1755,7 +1760,7 @@ var ObjectNode = /** @class */ (function (_super) {
     Object.defineProperty(ObjectNode.prototype, "snapshot", {
         // advantage of using computed for a snapshot is that nicely respects transactions etc.
         get: function () {
-            return freeze(this.getSnapshot());
+            return this._snapshotComputed.get();
         },
         enumerable: false,
         configurable: true
@@ -2251,21 +2256,13 @@ var ObjectNode = /** @class */ (function (_super) {
             }
         }
     });
-    __decorate([
-        action
-    ], ObjectNode.prototype, "createObservableInstance", null);
-    __decorate([
-        computed
-    ], ObjectNode.prototype, "snapshot", null);
-    __decorate([
-        action
-    ], ObjectNode.prototype, "detach", null);
-    __decorate([
-        action
-    ], ObjectNode.prototype, "die", null);
     return ObjectNode;
 }(BaseNode));
+ObjectNode.prototype.createObservableInstance = action(ObjectNode.prototype.createObservableInstance);
+ObjectNode.prototype.detach = action(ObjectNode.prototype.detach);
+ObjectNode.prototype.die = action(ObjectNode.prototype.die);
 
+var _a;
 /**
  * @internal
  * @hidden
@@ -2351,7 +2348,6 @@ var BaseType = /** @class */ (function () {
             writable: true,
             value: void 0
         });
-        makeObservable(this);
         this.name = name;
     }
     Object.defineProperty(BaseType.prototype, "create", {
@@ -2436,13 +2432,10 @@ var BaseType = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
-    var _a;
-    _a = $type;
-    __decorate([
-        action
-    ], BaseType.prototype, "create", null);
     return BaseType;
 }());
+_a = $type;
+BaseType.prototype.create = action(BaseType.prototype.create);
 /**
  * A complex type produces a MST node (Node in the state tree)
  *
@@ -2479,6 +2472,16 @@ var ComplexType = /** @class */ (function (_super) {
             return node.storedValue;
         }
     });
+    Object.defineProperty(ComplexType.prototype, "isMatchingSnapshotId", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (current, snapshot) {
+            return (!current.identifierAttribute ||
+                current.identifier ===
+                    normalizeIdentifier(snapshot[current.identifierAttribute]));
+        }
+    });
     Object.defineProperty(ComplexType.prototype, "tryToReconcileNode", {
         enumerable: false,
         configurable: true,
@@ -2497,9 +2500,7 @@ var ComplexType = /** @class */ (function (_super) {
             if (current.type === this &&
                 isMutable(newValue) &&
                 !isStateTreeNode(newValue) &&
-                (!current.identifierAttribute ||
-                    current.identifier ===
-                        normalizeIdentifier(newValue[current.identifierAttribute]))) {
+                this.isMatchingSnapshotId(current, newValue)) {
                 // the newValue has no node, so can be treated like a snapshot
                 // we can reconcile
                 current.applySnapshot(newValue);
@@ -2539,11 +2540,9 @@ var ComplexType = /** @class */ (function (_super) {
             return null;
         }
     });
-    __decorate([
-        action
-    ], ComplexType.prototype, "create", null);
     return ComplexType;
 }(BaseType));
+ComplexType.prototype.create = action(ComplexType.prototype.create);
 /**
  * @internal
  * @hidden
@@ -3972,12 +3971,21 @@ function deepFreeze(value) {
 function isSerializable(value) {
     return typeof value !== "function";
 }
+/**
+ * @internal
+ * @hidden
+ */
+function defineProperty(object, key, descriptor) {
+    isObservableObject(object)
+        ? defineProperty$1(object, key, descriptor)
+        : Object.defineProperty(object, key, descriptor);
+}
 /**
  * @internal
  * @hidden
  */
 function addHiddenFinalProp(object, propName, value) {
-    Object.defineProperty(object, propName, {
+    defineProperty(object, propName, {
         enumerable: false,
         writable: false,
         configurable: true,
@@ -3989,7 +3997,7 @@ function addHiddenFinalProp(object, propName, value) {
  * @hidden
  */
 function addHiddenWritableProp(object, propName, value) {
-    Object.defineProperty(object, propName, {
+    defineProperty(object, propName, {
         enumerable: false,
         writable: true,
         configurable: true,
@@ -4181,14 +4189,6 @@ function argsToArray(args) {
         res[i] = args[i];
     return res;
 }
-/**
- * @internal
- * @hidden
- */
-function invalidateComputed(target, propName) {
-    var atom = getAtom(target, propName);
-    atom.trackAndCompute();
-}
 /**
  * @internal
  * @hidden
@@ -4590,6 +4590,8 @@ function splitJsonPath(path) {
     return parts;
 }
 
+/** @hidden */
+var $preProcessorFailed = Symbol("$preProcessorFailed");
 var SnapshotProcessor = /** @class */ (function (_super) {
     __extends(SnapshotProcessor, _super);
     function SnapshotProcessor(_subtype, _processors, name) {
@@ -4634,6 +4636,19 @@ var SnapshotProcessor = /** @class */ (function (_super) {
             return sn;
         }
     });
+    Object.defineProperty(SnapshotProcessor.prototype, "preProcessSnapshotSafe", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (sn) {
+            try {
+                return this.preProcessSnapshot(sn);
+            }
+            catch (e) {
+                return $preProcessorFailed;
+            }
+        }
+    });
     Object.defineProperty(SnapshotProcessor.prototype, "postProcessSnapshot", {
         enumerable: false,
         configurable: true,
@@ -4652,11 +4667,14 @@ var SnapshotProcessor = /** @class */ (function (_super) {
         value: function (node) {
             var _this = this;
             // the node has to use these methods rather than the original type ones
-            proxyNodeTypeMethods(node.type, this, "create");
+            proxyNodeTypeMethods(node.type, this, "create", "is", "isMatchingSnapshotId");
             var oldGetSnapshot = node.getSnapshot;
             node.getSnapshot = function () {
                 return _this.postProcessSnapshot(oldGetSnapshot.call(node));
             };
+            node.getReconciliationType = function () {
+                return _this;
+            };
         }
     });
     Object.defineProperty(SnapshotProcessor.prototype, "instantiate", {
@@ -4699,7 +4717,10 @@ var SnapshotProcessor = /** @class */ (function (_super) {
         configurable: true,
         writable: true,
         value: function (value, context) {
-            var processedSn = this.preProcessSnapshot(value);
+            var processedSn = this.preProcessSnapshotSafe(value);
+            if (processedSn === $preProcessorFailed) {
+                return typeCheckFailure(context, value, "Failed to preprocess value");
+            }
             return this._subtype.validate(processedSn, context);
         }
     });
@@ -4720,7 +4741,10 @@ var SnapshotProcessor = /** @class */ (function (_super) {
                 ? this._subtype
                 : isStateTreeNode(thing)
                     ? getSnapshot(thing, false)
-                    : this.preProcessSnapshot(thing);
+                    : this.preProcessSnapshotSafe(thing);
+            if (value === $preProcessorFailed) {
+                return false;
+            }
             return this._subtype.validate(value, [{ path: "", type: this._subtype }]).length === 0;
         }
     });
@@ -4732,6 +4756,18 @@ var SnapshotProcessor = /** @class */ (function (_super) {
             return this._subtype.isAssignableFrom(type);
         }
     });
+    Object.defineProperty(SnapshotProcessor.prototype, "isMatchingSnapshotId", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (current, snapshot) {
+            if (!(this._subtype instanceof ComplexType)) {
+                return false;
+            }
+            var processedSn = this.preProcessSnapshot(snapshot);
+            return ComplexType.prototype.isMatchingSnapshotId.call(this._subtype, current, processedSn);
+        }
+    });
     return SnapshotProcessor;
 }(BaseType));
 function proxyNodeTypeMethods(nodeType, snapshotProcessorType) {
@@ -4963,7 +4999,6 @@ var MapType = /** @class */ (function (_super) {
         });
         _this._determineIdentifierMode();
         _this.hookInitializers = hookInitializers;
-        makeObservable(_this);
         return _this;
     }
     Object.defineProperty(MapType.prototype, "hooks", {
@@ -5264,16 +5299,14 @@ var MapType = /** @class */ (function (_super) {
             node.storedValue.delete(subpath);
         }
     });
-    __decorate([
-        action
-    ], MapType.prototype, "applySnapshot", null);
     return MapType;
 }(ComplexType));
+MapType.prototype.applySnapshot = action(MapType.prototype.applySnapshot);
 /**
  * `types.map` - Creates a key based collection type who's children are all of a uniform declared type.
  * If the type stored in a map has an identifier, it is mandatory to store the child under that identifier in the map.
  *
- * This type will always produce [observable maps](https://mobx.js.org/refguide/map.html)
+ * This type will always produce [observable maps](https://mobx.js.org/api.html#observablemap)
  *
  * Example:
  * ```ts
@@ -5336,7 +5369,6 @@ var ArrayType = /** @class */ (function (_super) {
             writable: true,
             value: []
         });
-        makeObservable(_this);
         _this.hookInitializers = hookInitializers;
         return _this;
     }
@@ -5585,15 +5617,13 @@ var ArrayType = /** @class */ (function (_super) {
             node.storedValue.splice(Number(subpath), 1);
         }
     });
-    __decorate([
-        action
-    ], ArrayType.prototype, "applySnapshot", null);
     return ArrayType;
 }(ComplexType));
+ArrayType.prototype.applySnapshot = action(ArrayType.prototype.applySnapshot);
 /**
  * `types.array` - Creates an index based collection type who's children are all of a uniform declared type.
  *
- * This type will always produce [observable arrays](https://mobx.js.org/refguide/array.html)
+ * This type will always produce [observable arrays](https://mobx.js.org/api.html#observablearray)
  *
  * Example:
  * ```ts
@@ -5734,8 +5764,8 @@ function areSame(oldNode, newValue) {
         oldNode.identifier !== null &&
         oldNode.identifierAttribute &&
         isPlainObject(newValue) &&
-        oldNode.identifier === normalizeIdentifier(newValue[oldNode.identifierAttribute]) &&
-        oldNode.type.is(newValue));
+        oldNode.type.is(newValue) &&
+        oldNode.type.isMatchingSnapshotId(oldNode, newValue));
 }
 /**
  * Returns if a given value represents an array type.
@@ -5898,7 +5928,6 @@ var ModelType = /** @class */ (function (_super) {
                     });
             }
         });
-        makeObservable(_this);
         Object.assign(_this, defaultObjectOptions, opts);
         // ensures that any default value gets converted to its related type
         _this.properties = toPropertiesObject(_this.properties);
@@ -6061,19 +6090,8 @@ var ModelType = /** @class */ (function (_super) {
                 // is this a computed property?
                 var descriptor = Object.getOwnPropertyDescriptor(views, key);
                 if ("get" in descriptor) {
-                    if (isComputedProp(self, key)) {
-                        var computedValue = _getAdministration(self, key);
-                        // TODO: mobx currently does not allow redefining computes yet, pending #1121
-                        // FIXME: this binds to the internals of mobx!
-                        computedValue.derivation = descriptor.get;
-                        computedValue.scope = self;
-                        if (descriptor.set)
-                            computedValue.setter = action(computedValue.name + "-setter", descriptor.set);
-                    }
-                    else {
-                        Object.defineProperty(self, key, descriptor);
-                        makeObservable(self, (_a = {}, _a[key] = computed, _a));
-                    }
+                    defineProperty$1(self, key, descriptor);
+                    makeObservable(self, (_a = {}, _a[key] = computed, _a));
                 }
                 else if (typeof descriptor.value === "function") {
                     (!devMode() ? addHiddenFinalProp : addHiddenWritableProp)(self, key, descriptor.value);
@@ -6337,11 +6355,9 @@ var ModelType = /** @class */ (function (_super) {
             node.storedValue[subpath] = undefined;
         }
     });
-    __decorate([
-        action
-    ], ModelType.prototype, "applySnapshot", null);
     return ModelType;
 }(ComplexType));
+ModelType.prototype.applySnapshot = action(ModelType.prototype.applySnapshot);
 /**
  * `types.model` - Creates a new model type by providing a name, properties, volatile state and actions.
  *
@@ -6903,7 +6919,7 @@ var Union = /** @class */ (function (_super) {
         configurable: true,
         writable: true,
         value: function (current, newValue, parent, subpath) {
-            var type = this.determineType(newValue, current.type);
+            var type = this.determineType(newValue, current.getReconciliationType());
             if (!type)
                 throw fail$1("No matching type for union " + this.describe()); // can happen in prod builds
             return type.reconcile(current, newValue, parent, subpath);