mobx-state-tree 7.3.1 → 7.4.0

package/dist/mobx-state-tree.js

@@ -6033,6 +6033,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;
@@ -6061,24 +6062,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", {
@@ -6159,9 +6168,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;
         }
     }
@@ -7446,13 +7463,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])
  * })
  * ```
  *
@@ -7465,10 +7483,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;