mobx-state-tree 7.3.0 → 7.3.2

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

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

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

@@ -5296,7 +5296,7 @@
     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,
@@ -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;
             }
         }