@jbrowse/mobx-state-tree 6.6.0 → 6.6.1

package/dist/mobx-state-tree.mjs

@@ -4467,98 +4467,174 @@ function array(subtype) {
  */
 function reconcileArrayChildren(parent, childType, oldNodes, newValues, firstNewPath) {
     let nothingChanged = true;
-    // When the element type is a plain model with an identifier, index the old
-    // nodes by id so a moved / replaced child is matched in O(1) instead of the
-    // linear scan in the reorder branch below. This turns a full array
-    // replacement (the common "load new data" case) from O(n^2) into O(n). Types
-    // whose id extraction needs type-specific preprocessing (union,
-    // snapshotProcessor, late, ...) are intentionally excluded: areSame must run
-    // `is()` before their id check, so they stay on the scan path.
-    // With at most one old node the scan below is already O(1), so building the
-    // index would only add a Map allocation to every single-element write.
-    let idIndex;
-    if (oldNodes.length > 1 &&
-        childType instanceof ModelType &&
-        childType.identifierAttribute) {
-        const byId = new Map();
-        for (const n of oldNodes) {
-            if (n instanceof ObjectNode && n.identifier !== null) {
-                byId.set(n.identifier, n);
-            }
-        }
-        idIndex = { attr: childType.identifierAttribute, byId };
-    }
-    for (let i = 0;; i++) {
-        const hasNewNode = i <= newValues.length - 1;
-        const oldNode = oldNodes[i];
-        let newValue = hasNewNode ? newValues[i] : undefined;
+    const result = [];
+    // every old node before `next` is claimed
+    const claimed = new Uint8Array(oldNodes.length);
+    let next = 0;
+    let finder;
+    for (let i = 0; i < newValues.length; i++) {
+        while (claimed[next]) {
+            next++;
+        }
+        const oldNode = oldNodes[next];
+        let newValue = newValues[i];
         const newPath = `${firstNewPath + i}`;
         // for some reason, instead of newValue we got a node, fallback to the storedValue
         // TODO: https://github.com/mobxjs/mobx-state-tree/issues/340#issuecomment-325581681
         if (isNode(newValue)) {
             newValue = newValue.storedValue;
         }
-        if (!oldNode && !hasNewNode) {
-            // both are empty, end
-            break;
+        if (!oldNode) {
+            if (isStateTreeNode(newValue) &&
+                getStateTreeNode(newValue).parent === parent) {
+                // this node is owned by this parent, but not in the reconcilable set, so it must be double
+                throw fail(`Cannot add an object to a state tree if it is already part of the same or another state tree. Tried to assign an object to '${parent.path}/${newPath}', but it lives already at '${getStateTreeNode(newValue).path}'`);
+            }
+            nothingChanged = false;
+            result.push(valueAsNode(childType, parent, newPath, newValue));
+        }
+        else if (areSame(oldNode, newValue)) {
+            claimed[next] = 1;
+            result.push(valueAsNode(childType, parent, newPath, newValue, oldNode));
+        }
+        else {
+            nothingChanged = false;
+            // a single-element write scans one node, cheaper than building an index
+            const j = oldNodes.length > 1
+                ? (finder ??= new ReuseFinder(childType, oldNodes, claimed)).find(newValue, next)
+                : scanForSame(oldNodes, claimed, next, newValue);
+            let oldMatch;
+            if (j >= 0) {
+                claimed[j] = 1;
+                oldMatch = oldNodes[j];
+            }
+            result.push(valueAsNode(childType, parent, newPath, newValue, oldMatch));
         }
-        else if (oldNode && !hasNewNode) {
-            // new one does not exists
+    }
+    for (let j = next; j < oldNodes.length; j++) {
+        if (!claimed[j]) {
             nothingChanged = false;
-            oldNodes.splice(i, 1);
+            const oldNode = oldNodes[j];
             if (oldNode instanceof ObjectNode) {
                 // since it is going to be returned by pop/splice/shift better create it before killing it
                 // so it doesn't end up in an undead state
                 oldNode.createObservableInstanceIfNeeded();
             }
             oldNode.die();
-            i--;
         }
-        else if (!oldNode) {
-            // there is no old node, create it
-            // check if already belongs to the same parent. if so, avoid pushing item in. only swapping can occur.
-            if (isStateTreeNode(newValue) &&
-                getStateTreeNode(newValue).parent === parent) {
-                // this node is owned by this parent, but not in the reconcilable set, so it must be double
-                throw fail(`Cannot add an object to a state tree if it is already part of the same or another state tree. Tried to assign an object to '${parent.path}/${newPath}', but it lives already at '${getStateTreeNode(newValue).path}'`);
-            }
-            nothingChanged = false;
-            const newNode = valueAsNode(childType, parent, newPath, newValue);
-            oldNodes.splice(i, 0, newNode);
+    }
+    return nothingChanged ? null : result;
+}
+function scanForSame(oldNodes, claimed, from, value) {
+    for (let j = from; j < oldNodes.length; j++) {
+        if (!claimed[j] && areSame(oldNodes[j], value)) {
+            return j;
         }
-        else if (areSame(oldNode, newValue)) {
-            // both are the same, reconcile
-            oldNodes[i] = valueAsNode(childType, parent, newPath, newValue, oldNode);
+    }
+    return -1;
+}
+/**
+ * Picks the old node the reorder branch reuses: the first unclaimed one
+ * `areSame` holds for. `areSame` reduces to an equality — node identity for a
+ * live node, the old node's snapshot for anything else — except where the
+ * value is a plain object and the old node carries an identifier, where it
+ * runs `is()` before matching ids. So only that case scans, and an identified
+ * plain model looks its id up instead, as ADR 0001 records.
+ */
+class ReuseFinder {
+    oldNodes;
+    claimed;
+    idAttribute;
+    byId;
+    byNode;
+    bySnapshot;
+    anyIdentified;
+    constructor(childType, oldNodes, claimed) {
+        this.oldNodes = oldNodes;
+        this.claimed = claimed;
+        this.idAttribute =
+            childType instanceof ModelType ? childType.identifierAttribute : undefined;
+    }
+    find(value, next) {
+        let j;
+        if (this.idAttribute && isPlainObject(value)) {
+            j =
+                this.idIndex(next).get(normalizeIdentifier(value[this.idAttribute])) ??
+                    -1;
+        }
+        else if (isStateTreeNode(value)) {
+            j = this.nodeIndex(next).get(getStateTreeNode(value)) ?? -1;
+        }
+        else if (!isPlainObject(value) || !this.hasIdentifiedNode(next)) {
+            j = this.firstWithSnapshot(value, next);
         }
         else {
-            // nothing to do, try to reorder: find a candidate old node to reuse
-            let oldMatch = undefined;
-            if (idIndex && isPlainObject(newValue)) {
-                // for an identified element type a plain-object snapshot can only match
-                // by id (it is never a live node, and snapshot-reference equality still
-                // implies the same id), so a miss means "nothing to reuse" without
-                // scanning. areSame still verifies the single candidate.
-                const candidate = idIndex.byId.get(normalizeIdentifier(newValue[idIndex.attr]));
-                const j = candidate ? oldNodes.indexOf(candidate, i) : -1;
-                if (j >= i && areSame(oldNodes[j], newValue)) {
-                    oldMatch = oldNodes.splice(j, 1)[0];
+            return scanForSame(this.oldNodes, this.claimed, next, value);
+        }
+        return j >= 0 && !this.claimed[j] && areSame(this.oldNodes[j], value)
+            ? j
+            : -1;
+    }
+    // last one wins on a duplicate id, even when it is already claimed
+    idIndex(next) {
+        if (!this.byId) {
+            this.byId = new Map();
+            for (let j = next; j < this.oldNodes.length; j++) {
+                const node = this.oldNodes[j];
+                if (node instanceof ObjectNode && node.identifier !== null) {
+                    this.byId.set(node.identifier, j);
                 }
             }
-            else {
-                // find a possible candidate to reuse
-                for (let j = i; j < oldNodes.length; j++) {
-                    if (areSame(oldNodes[j], newValue)) {
-                        oldMatch = oldNodes.splice(j, 1)[0];
-                        break;
-                    }
+        }
+        return this.byId;
+    }
+    nodeIndex(next) {
+        if (!this.byNode) {
+            this.byNode = new Map();
+            for (let j = next; j < this.oldNodes.length; j++) {
+                this.byNode.set(this.oldNodes[j], j);
+            }
+        }
+        return this.byNode;
+    }
+    hasIdentifiedNode(next) {
+        if (this.anyIdentified === undefined) {
+            this.anyIdentified = this.oldNodes
+                .slice(next)
+                .some(node => node instanceof ObjectNode &&
+                node.identifier !== null &&
+                !!node.identifierAttribute);
+        }
+        return this.anyIdentified;
+    }
+    firstWithSnapshot(value, next) {
+        if (!this.bySnapshot) {
+            const first = new Map();
+            const nextSame = new Int32Array(this.oldNodes.length);
+            for (let j = this.oldNodes.length - 1; j >= next; j--) {
+                const node = this.oldNodes[j];
+                if (!this.claimed[j] && node.isAlive) {
+                    const snapshot = node.snapshot;
+                    nextSame[j] = first.get(snapshot) ?? -1;
+                    first.set(snapshot, j);
                 }
             }
-            nothingChanged = false;
-            const newNode = valueAsNode(childType, parent, newPath, newValue, oldMatch);
-            oldNodes.splice(i, 0, newNode);
+            this.bySnapshot = { first, nextSame };
+        }
+        const { first, nextSame } = this.bySnapshot;
+        const head = first.get(value);
+        if (head === undefined) {
+            return -1;
+        }
+        let j = head;
+        while (j >= 0 && (this.claimed[j] || !this.oldNodes[j].isAlive)) {
+            j = nextSame[j];
+        }
+        if (j !== head) {
+            first.set(value, j);
         }
+        return j;
     }
-    return nothingChanged ? null : oldNodes;
 }
 /**
  * Convert a value to a node at given parent and subpath. Attempts to reuse old node if possible and given.