mobx-state-tree 7.3.1 → 7.4.0

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

@@ -6029,6 +6029,7 @@ var ArrayType = /** @class */ (function (_super) {
         configurable: true,
         writable: true,
         value: function (node, snapshot) {
+            var e_1, _a;
             if (!isArray(snapshot)) {
                 typecheckInternal(this, snapshot);
                 return;
@@ -6057,24 +6058,32 @@ var ArrayType = /** @class */ (function (_super) {
                 applyDirectSnapshotsInRange(childNodes, snapshot, firstChangedIndex);
                 return;
             }
-            var oldEnd = oldLength - 1;
-            var newEnd = newLength - 1;
-            while (oldEnd >= firstChangedIndex &&
-                newEnd >= firstChangedIndex &&
-                childNodes[oldEnd].snapshot === snapshot[newEnd]) {
-                oldEnd--;
-                newEnd--;
-            }
-            // Trim the unchanged suffix too, so we only replace the minimal changed window.
-            var replacedCount = oldEnd >= firstChangedIndex ? oldEnd - firstChangedIndex + 1 : 0;
-            var replacementSnapshots = newEnd >= firstChangedIndex
-                ? snapshot.slice(firstChangedIndex, newEnd + 1)
-                : EMPTY_ARRAY;
-            if (replacedCount === 1 && replacementSnapshots.length === 1) {
-                target[firstChangedIndex] = replacementSnapshots[0];
-                return;
+            // The lengths match, so only the differing entries have to change. Collect them
+            // before touching the array, because assigning to one entry invalidates the
+            // snapshots of the others and their identity can no longer be compared.
+            var changedIndexes = [];
+            for (var i = firstChangedIndex; i < oldLength; i++) {
+                if (childNodes[i].snapshot !== snapshot[i]) {
+                    changedIndexes.push(i);
+                }
+            }
+            try {
+                // Assign the changed entries individually rather than splicing across the
+                // untouched entries between them: a single assignment reconciles exactly one
+                // child, which keeps the cost proportional to the number of changes instead of
+                // the distance between the first and the last of them.
+                for (var changedIndexes_1 = __values(changedIndexes), changedIndexes_1_1 = changedIndexes_1.next(); !changedIndexes_1_1.done; changedIndexes_1_1 = changedIndexes_1.next()) {
+                    var index = changedIndexes_1_1.value;
+                    target[index] = snapshot[index];
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (changedIndexes_1_1 && !changedIndexes_1_1.done && (_a = changedIndexes_1.return)) _a.call(changedIndexes_1);
+                }
+                finally { if (e_1) throw e_1.error; }
             }
-            target.splice.apply(target, __spreadArray([firstChangedIndex, replacedCount], __read(replacementSnapshots), false));
         }
     });
     Object.defineProperty(ArrayType.prototype, "getChildType", {
@@ -6155,9 +6164,17 @@ function findFirstChangedIndex(childNodes, snapshot, length) {
 }
 function canApplyDirectSnapshotsInRange(childType, childNodes, snapshot, startIndex) {
     for (var i = startIndex; i < childNodes.length; i++) {
-        if (childNodes[i].snapshot === snapshot[i])
+        var childNode = childNodes[i];
+        if (childNode.snapshot === snapshot[i])
             continue;
-        if (!canApplyDirectSnapshot(childType, childNodes[i], snapshot[i])) {
+        if (!canApplyDirectSnapshot(childType, childNode, snapshot[i])) {
+            return false;
+        }
+        // Array reconciliation only treats two snapshots as the same child when they carry
+        // a matching identifier (see `areSame`). Identifier-less children are replaced
+        // rather than updated in place, so they must not take the direct-apply path or
+        // lifecycle hooks such as afterCreate would never run for the new child.
+        if (!childNode.identifierAttribute || childNode.identifier === null) {
             return false;
         }
     }
@@ -7442,13 +7459,14 @@ function isRefinementType(type) {
 }
 
 /**
- * `types.enumeration` - Can be used to create an string based enumeration.
- * (note: this methods is just sugar for a union of string literals)
+ * `types.enumeration` - Can be used to create a string or number based enumeration.
+ * (note: this methods is just sugar for a union of string or number literals)
  *
  * Example:
  * ```ts
  * const TrafficLight = types.model({
- *   color: types.enumeration("Color", ["Red", "Orange", "Green"])
+ *   color: types.enumeration("Color", ["Red", "Orange", "Green"]),
+ *   speedLimit: types.enumeration("SpeedLimit", [30, 50])
  * })
  * ```
  *
@@ -7461,10 +7479,10 @@ function enumeration(name, options) {
     // check all options
     if (devMode()) {
         realOptions.forEach(function (option, i) {
-            assertIsString(option, i + 1);
+            assertArg(option, function (o) { return typeof o === "string" || typeof o === "number"; }, "string or number", i + 1);
         });
     }
-    var type = union.apply(void 0, __spreadArray([], __read(realOptions.map(function (option) { return literal("" + option); })), false));
+    var type = union.apply(void 0, __spreadArray([], __read(realOptions.map(function (option) { return literal(option); })), false));
     if (typeof name === "string")
         type.name = name;
     return type;

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

@@ -6011,6 +6011,7 @@
             configurable: true,
             writable: true,
             value: function (node, snapshot) {
+                var e_1, _a;
                 if (!isArray(snapshot)) {
                     typecheckInternal(this, snapshot);
                     return;
@@ -6039,24 +6040,32 @@
                     applyDirectSnapshotsInRange(childNodes, snapshot, firstChangedIndex);
                     return;
                 }
-                var oldEnd = oldLength - 1;
-                var newEnd = newLength - 1;
-                while (oldEnd >= firstChangedIndex &&
-                    newEnd >= firstChangedIndex &&
-                    childNodes[oldEnd].snapshot === snapshot[newEnd]) {
-                    oldEnd--;
-                    newEnd--;
-                }
-                // Trim the unchanged suffix too, so we only replace the minimal changed window.
-                var replacedCount = oldEnd >= firstChangedIndex ? oldEnd - firstChangedIndex + 1 : 0;
-                var replacementSnapshots = newEnd >= firstChangedIndex
-                    ? snapshot.slice(firstChangedIndex, newEnd + 1)
-                    : EMPTY_ARRAY;
-                if (replacedCount === 1 && replacementSnapshots.length === 1) {
-                    target[firstChangedIndex] = replacementSnapshots[0];
-                    return;
+                // The lengths match, so only the differing entries have to change. Collect them
+                // before touching the array, because assigning to one entry invalidates the
+                // snapshots of the others and their identity can no longer be compared.
+                var changedIndexes = [];
+                for (var i = firstChangedIndex; i < oldLength; i++) {
+                    if (childNodes[i].snapshot !== snapshot[i]) {
+                        changedIndexes.push(i);
+                    }
+                }
+                try {
+                    // Assign the changed entries individually rather than splicing across the
+                    // untouched entries between them: a single assignment reconciles exactly one
+                    // child, which keeps the cost proportional to the number of changes instead of
+                    // the distance between the first and the last of them.
+                    for (var changedIndexes_1 = __values(changedIndexes), changedIndexes_1_1 = changedIndexes_1.next(); !changedIndexes_1_1.done; changedIndexes_1_1 = changedIndexes_1.next()) {
+                        var index = changedIndexes_1_1.value;
+                        target[index] = snapshot[index];
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (changedIndexes_1_1 && !changedIndexes_1_1.done && (_a = changedIndexes_1.return)) _a.call(changedIndexes_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
                 }
-                target.splice.apply(target, __spreadArray([firstChangedIndex, replacedCount], __read(replacementSnapshots), false));
             }
         });
         Object.defineProperty(ArrayType.prototype, "getChildType", {
@@ -6137,9 +6146,17 @@
     }
     function canApplyDirectSnapshotsInRange(childType, childNodes, snapshot, startIndex) {
         for (var i = startIndex; i < childNodes.length; i++) {
-            if (childNodes[i].snapshot === snapshot[i])
+            var childNode = childNodes[i];
+            if (childNode.snapshot === snapshot[i])
                 continue;
-            if (!canApplyDirectSnapshot(childType, childNodes[i], snapshot[i])) {
+            if (!canApplyDirectSnapshot(childType, childNode, snapshot[i])) {
+                return false;
+            }
+            // Array reconciliation only treats two snapshots as the same child when they carry
+            // a matching identifier (see `areSame`). Identifier-less children are replaced
+            // rather than updated in place, so they must not take the direct-apply path or
+            // lifecycle hooks such as afterCreate would never run for the new child.
+            if (!childNode.identifierAttribute || childNode.identifier === null) {
                 return false;
             }
         }
@@ -7424,13 +7441,14 @@
     }
 
     /**
-     * `types.enumeration` - Can be used to create an string based enumeration.
-     * (note: this methods is just sugar for a union of string literals)
+     * `types.enumeration` - Can be used to create a string or number based enumeration.
+     * (note: this methods is just sugar for a union of string or number literals)
      *
      * Example:
      * ```ts
      * const TrafficLight = types.model({
-     *   color: types.enumeration("Color", ["Red", "Orange", "Green"])
+     *   color: types.enumeration("Color", ["Red", "Orange", "Green"]),
+     *   speedLimit: types.enumeration("SpeedLimit", [30, 50])
      * })
      * ```
      *
@@ -7443,10 +7461,10 @@
         // check all options
         {
             realOptions.forEach(function (option, i) {
-                assertIsString(option, i + 1);
+                assertArg(option, function (o) { return typeof o === "string" || typeof o === "number"; }, "string or number", i + 1);
             });
         }
-        var type = union.apply(void 0, __spreadArray([], __read(realOptions.map(function (option) { return literal("" + option); })), false));
+        var type = union.apply(void 0, __spreadArray([], __read(realOptions.map(function (option) { return literal(option); })), false));
         if (typeof name === "string")
             type.name = name;
         return type;