mobx-state-tree 5.2.0 → 5.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016 Michel Weststrate
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/mobx-state-tree.js

@@ -279,7 +279,7 @@ function recordPatches(subject, filter) {
     assertIsStateTreeNode(subject, 1);
     var data = {
         patches: [],
-        reversedInversePatches: []
+        inversePatches: []
     };
     // we will generate the immutable copy of patches on demand for public consumption
     var publicData = {};
@@ -296,13 +296,13 @@ function recordPatches(subject, filter) {
         },
         get reversedInversePatches() {
             if (!publicData.reversedInversePatches) {
-                publicData.reversedInversePatches = data.reversedInversePatches.slice();
+                publicData.reversedInversePatches = data.inversePatches.slice().reverse();
             }
             return publicData.reversedInversePatches;
         },
         get inversePatches() {
             if (!publicData.inversePatches) {
-                publicData.inversePatches = data.reversedInversePatches.slice().reverse();
+                publicData.inversePatches = data.inversePatches.slice();
             }
             return publicData.inversePatches;
         },
@@ -321,7 +321,7 @@ function recordPatches(subject, filter) {
                     return;
                 }
                 data.patches.push(patch);
-                data.reversedInversePatches.unshift(inversePatch);
+                data.inversePatches.push(inversePatch);
                 // mark immutable public patches as dirty
                 publicData.patches = undefined;
                 publicData.inversePatches = undefined;
@@ -332,7 +332,7 @@ function recordPatches(subject, filter) {
             applyPatch(target || subject, data.patches);
         },
         undo: function (target) {
-            applyPatch(target || subject, data.reversedInversePatches);
+            applyPatch(target || subject, data.inversePatches.slice().reverse());
         }
     };
     recorder.resume();
@@ -1751,9 +1751,7 @@ var ObjectNode = /** @class */ (function (_super) {
                 if (!this.parent && newParent.root === this) {
                     throw fail$1("A state tree is not allowed to contain itself. Cannot assign " + this + " to path '" + newParent.path + "/" + subpath + "'");
                 }
-                if (!this.parent &&
-                    !!this.environment &&
-                    this.environment !== newParent.root.environment) {
+                if (!this.parent && !!this.environment && this.environment !== newParent.root.environment) {
                     throw fail$1("A state tree cannot be made part of another state tree as long as their environments are different.");
                 }
             }
@@ -1777,9 +1775,7 @@ var ObjectNode = /** @class */ (function (_super) {
         value: function (name) {
             var _this = this;
             this.fireInternalHook(name);
-            var fn = this.storedValue &&
-                typeof this.storedValue === "object" &&
-                this.storedValue[name];
+            var fn = this.storedValue && typeof this.storedValue === "object" && this.storedValue[name];
             if (typeof fn === "function") {
                 // we check for it to allow old mobx peer dependencies that don't have the method to work (even when still bugged)
                 if (mobx._allowStateChangesInsideComputed) {
@@ -1881,8 +1877,7 @@ var ObjectNode = /** @class */ (function (_super) {
             var actionFullPath = "";
             if (actionContext && actionContext.name != null) {
                 // try to use the context, and if it not available use the node one
-                var actionPath = (actionContext && actionContext.context && getPath(actionContext.context)) ||
-                    escapedPath;
+                var actionPath = (actionContext && actionContext.context && getPath(actionContext.context)) || escapedPath;
                 actionFullPath = actionPath + "." + actionContext.name + "()";
             }
             return "You are trying to read or write to an object that is no longer part of a state tree. (Object type: '" + this.type.name + "', Path upon death: '" + escapedPath + "', Subpath: '" + subpath + "', Action: '" + actionFullPath + "'). Either detach nodes first, or don't use objects after removing / replacing them in the tree.";
@@ -2517,8 +2512,7 @@ var ComplexType = /** @class */ (function (_super) {
         writable: true,
         value: function (current, snapshot) {
             return (!current.identifierAttribute ||
-                current.identifier ===
-                    normalizeIdentifier(snapshot[current.identifierAttribute]));
+                current.identifier === normalizeIdentifier(snapshot[current.identifierAttribute]));
         }
     });
     Object.defineProperty(ComplexType.prototype, "tryToReconcileNode", {
@@ -2831,11 +2825,11 @@ var RunningAction = /** @class */ (function () {
  * @returns
  */
 function createActionTrackingMiddleware2(middlewareHooks) {
-    var runningActions = new WeakMap();
+    var runningActions = new Map();
     return function actionTrackingMiddleware(call, next) {
         // find parentRunningAction
         var parentRunningAction = call.parentActionEvent
-            ? runningActions.get(call.parentActionEvent)
+            ? runningActions.get(call.parentActionEvent.id)
             : undefined;
         if (call.type === "action") {
             var newCall = __assign(__assign({}, call), { 
@@ -2844,17 +2838,19 @@ function createActionTrackingMiddleware2(middlewareHooks) {
             var passesFilter = !middlewareHooks.filter || middlewareHooks.filter(newCall);
             var hooks = passesFilter ? middlewareHooks : undefined;
             var runningAction = new RunningAction(hooks, newCall);
-            runningActions.set(call, runningAction);
+            runningActions.set(call.id, runningAction);
             var res = void 0;
             try {
                 res = next(call);
             }
             catch (e) {
+                runningActions.delete(call.id);
                 runningAction.finish(e);
                 throw e;
             }
+            // sync action finished
             if (!runningAction.hasFlowsPending) {
-                // sync action finished
+                runningActions.delete(call.id);
                 runningAction.finish();
             }
             return res;
@@ -2880,6 +2876,7 @@ function createActionTrackingMiddleware2(middlewareHooks) {
                     finally {
                         parentRunningAction.decFlowsPending();
                         if (!parentRunningAction.hasFlowsPending) {
+                            runningActions.delete(call.parentActionEvent.id);
                             parentRunningAction.finish(error);
                         }
                     }
@@ -2891,6 +2888,7 @@ function createActionTrackingMiddleware2(middlewareHooks) {
                     finally {
                         parentRunningAction.decFlowsPending();
                         if (!parentRunningAction.hasFlowsPending) {
+                            runningActions.delete(call.parentActionEvent.id);
                             parentRunningAction.finish();
                         }
                     }
@@ -2912,8 +2910,7 @@ function serializeArgument(node, actionName, index, arg) {
     if (typeof arg === "function")
         return serializeTheUnserializable("[function]");
     if (typeof arg === "object" && !isPlainObject(arg) && !isArray(arg))
-        return serializeTheUnserializable("[object " + ((arg && arg.constructor && arg.constructor.name) ||
-            "Complex Object") + "]");
+        return serializeTheUnserializable("[object " + ((arg && arg.constructor && arg.constructor.name) || "Complex Object") + "]");
     try {
         // Check if serializable, cycle free etc...
         // MWE: there must be a better way....
@@ -3169,8 +3166,7 @@ function createActionInvoker(target, name, fn) {
             tree: getRoot(target),
             rootId: parentContext ? parentContext.rootId : id,
             parentId: parentContext ? parentContext.id : 0,
-            allParentIds: parentContext
-                ? __spread(parentContext.allParentIds, [parentContext.id]) : [],
+            allParentIds: parentContext ? __spread(parentContext.allParentIds, [parentContext.id]) : [],
             parentEvent: parentContext,
             parentActionEvent: parentActionContext
         }, fn);
@@ -3764,7 +3760,7 @@ function getRelativePathBetweenNodes(base, target) {
             break;
     }
     // TODO: assert that no targetParts paths are "..", "." or ""!
-    return (baseParts.slice(common).map(doubleDot).join("/") + joinJsonPath(targetParts.slice(common)));
+    return baseParts.slice(common).map(doubleDot).join("/") + joinJsonPath(targetParts.slice(common));
 }
 /**
  * @internal
@@ -3781,47 +3777,44 @@ function resolveNodeByPath(base, path, failIfResolveFails) {
 function resolveNodeByPathParts(base, pathParts, failIfResolveFails) {
     if (failIfResolveFails === void 0) { failIfResolveFails = true; }
     var current = base;
-    for (var i = 0; i < pathParts.length; i++) {
-        var part = pathParts[i];
-        if (part === "..") {
-            current = current.parent;
-            if (current)
-                continue; // not everything has a parent
-        }
-        else if (part === ".") {
-            continue;
-        }
-        else if (current) {
-            if (current instanceof ScalarNode) {
-                // check if the value of a scalar resolves to a state tree node (e.g. references)
-                // then we can continue resolving...
-                try {
+    try {
+        for (var i = 0; i < pathParts.length; i++) {
+            var part = pathParts[i];
+            if (part === "..") {
+                current = current.parent;
+                if (current)
+                    continue; // not everything has a parent
+            }
+            else if (part === ".") {
+                continue;
+            }
+            else if (current) {
+                if (current instanceof ScalarNode) {
+                    // check if the value of a scalar resolves to a state tree node (e.g. references)
+                    // then we can continue resolving...
                     var value = current.value;
                     if (isStateTreeNode(value)) {
                         current = getStateTreeNode(value);
                         // fall through
                     }
                 }
-                catch (e) {
-                    if (!failIfResolveFails) {
-                        return undefined;
+                if (current instanceof ObjectNode) {
+                    var subType = current.getChildType(part);
+                    if (subType) {
+                        current = current.getChildNode(part);
+                        if (current)
+                            continue;
                     }
-                    throw e;
                 }
             }
-            if (current instanceof ObjectNode) {
-                var subType = current.getChildType(part);
-                if (subType) {
-                    current = current.getChildNode(part);
-                    if (current)
-                        continue;
-                }
-            }
-        }
-        if (failIfResolveFails)
             throw fail$1("Could not resolve '" + part + "' in path '" + (joinJsonPath(pathParts.slice(0, i)) || "/") + "' while resolving '" + joinJsonPath(pathParts) + "'");
-        else
+        }
+    }
+    catch (e) {
+        if (!failIfResolveFails) {
             return undefined;
+        }
+        throw e;
     }
     return current;
 }
@@ -4011,8 +4004,7 @@ function deepFreeze(value) {
     freeze(value);
     if (isPlainObject(value)) {
         Object.keys(value).forEach(function (propKey) {
-            if (!isPrimitive(value[propKey]) &&
-                !Object.isFrozen(value[propKey])) {
+            if (!isPrimitive(value[propKey]) && !Object.isFrozen(value[propKey])) {
                 deepFreeze(value[propKey]);
             }
         });
@@ -6418,9 +6410,7 @@ var ModelType = /** @class */ (function (_super) {
             var _this = this;
             // optimization: cache
             return ("{ " +
-                this.propertyNames
-                    .map(function (key) { return key + ": " + _this.properties[key].describe(); })
-                    .join("; ") +
+                this.propertyNames.map(function (key) { return key + ": " + _this.properties[key].describe(); }).join("; ") +
                 " }");
         }
     });
@@ -6908,9 +6898,7 @@ function refinement() {
     var name = typeof args[0] === "string" ? args.shift() : isType(args[0]) ? args[0].name : null;
     var type = args[0];
     var predicate = args[1];
-    var message = args[2]
-        ? args[2]
-        : function (v) { return "Value does not respect the refinement predicate"; };
+    var message = args[2] ? args[2] : function (v) { return "Value does not respect the refinement predicate"; };
     // ensures all parameters are correct
     assertIsType(type, [1, 2]);
     assertIsString(name, 1);
@@ -7053,9 +7041,7 @@ var Union = /** @class */ (function (_super) {
                 if (reconcileCurrentType.is(value)) {
                     return reconcileCurrentType;
                 }
-                return this._types
-                    .filter(function (t) { return t !== reconcileCurrentType; })
-                    .find(function (type) { return type.is(value); });
+                return this._types.filter(function (t) { return t !== reconcileCurrentType; }).find(function (type) { return type.is(value); });
             }
             else {
                 return this._types.find(function (type) { return type.is(value); });
@@ -7534,8 +7520,7 @@ var Lazy = /** @class */ (function (_super) {
         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);
+                    return node.isAlive && _this.options.shouldLoadPredicate(node.parent ? node.parent.value : null);
                 });
         }, function () {
             _this.options.loadType().then(mobx.action(function (type) {
@@ -8049,9 +8034,7 @@ var IdentifierReferenceType = /** @class */ (function (_super) {
         configurable: true,
         writable: true,
         value: function (parent, subpath, environment, initialValue) {
-            var identifier = isStateTreeNode(initialValue)
-                ? getIdentifier(initialValue)
-                : initialValue;
+            var identifier = isStateTreeNode(initialValue) ? getIdentifier(initialValue) : initialValue;
             var storedRef = new StoredReference(initialValue, this.targetType);
             var storedRefNode = createScalarNode(this, parent, subpath, environment, storedRef);
             storedRef.node = storedRefNode;
@@ -8136,9 +8119,7 @@ var CustomReferenceType = /** @class */ (function (_super) {
             var newIdentifier = isStateTreeNode(newValue)
                 ? this.options.set(newValue, current ? current.storedValue : null)
                 : newValue;
-            if (!current.isDetaching &&
-                current.type === this &&
-                current.storedValue === newIdentifier) {
+            if (!current.isDetaching && current.type === this && current.storedValue === newIdentifier) {
                 current.setParent(parent, subpath);
                 return current;
             }