mobx-state-tree 7.3.0 → 7.3.2

package/dist/mobx-state-tree.js

@@ -5318,7 +5318,7 @@ var MapIdentifierMode;
 var MSTMap = /** @class */ (function (_super) {
     __extends(MSTMap, _super);
     function MSTMap(initialData, name) {
-        return _super.call(this, initialData, mobx.observable.ref.enhancer, name) || this;
+        return _super.call(this, initialData, function (v) { return v; }, name) || this;
     }
     Object.defineProperty(MSTMap.prototype, "get", {
         enumerable: false,
@@ -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;
         }
     }