@jbrowse/mobx-state-tree 5.11.2 → 5.12.0

package/dist/index.d.ts

@@ -347,7 +347,7 @@ declare function getRelativePath(base: IAnyStateTreeNode, target: IAnyStateTreeN
  * @param keepEnvironment indicates whether the clone should inherit the same environment (`true`, the default), or not have an environment (`false`). If an object is passed in as second argument, that will act as the environment for the cloned tree.
  * @returns
  */
-declare function clone<T extends IAnyStateTreeNode>(source: T, keepEnvironment?: boolean | any): T;
+declare function clone<T extends IAnyStateTreeNode>(source: T, keepEnvironment?: boolean | object): T;
 /**
  * Removes a model element from the state tree, and let it live on as a new state tree
  */

package/dist/mobx-state-tree.cjs

@@ -766,10 +766,11 @@ function getMembers(target) {
             }
             return;
         }
-        if (descriptor.value._isFlowAction === true) {
+        const value = descriptor.value;
+        if (value?._isFlowAction === true) {
             reflected.flowActions.push(key);
         }
-        if (descriptor.value._isMSTAction === true) {
+        if (value?._isMSTAction === true) {
             reflected.actions.push(key);
         }
         else if (mobx.isObservableProp(target, key)) {
@@ -1668,9 +1669,6 @@ ObjectNode.prototype.createObservableInstance = mobx.action(ObjectNode.prototype
 ObjectNode.prototype.detach = mobx.action(ObjectNode.prototype.detach);
 ObjectNode.prototype.die = mobx.action(ObjectNode.prototype.die);
 
-// Cache for validation results to avoid re-validating the same object against the same type
-// Uses WeakMap so cached objects can be garbage collected
-const validationCache = new WeakMap();
 /**
  * @internal
  * @hidden
@@ -1746,27 +1744,7 @@ class BaseType {
                 : typeCheckFailure(context, value);
             // it is tempting to compare snapshots, but in that case we should always clone on assignments...
         }
-        // check cache for object values (only at root level to avoid context mismatches)
-        if (typeof value === "object" && value !== null && context.length === 1) {
-            const typeCache = validationCache.get(value);
-            if (typeCache) {
-                const cached = typeCache.get(this);
-                if (cached !== undefined) {
-                    return cached;
-                }
-            }
-        }
-        const result = this.isValidSnapshot(value, context);
-        // cache result for object values (only at root level)
-        if (typeof value === "object" && value !== null && context.length === 1) {
-            let typeCache = validationCache.get(value);
-            if (!typeCache) {
-                typeCache = new WeakMap();
-                validationCache.set(value, typeCache);
-            }
-            typeCache.set(this, result);
-        }
-        return result;
+        return this.isValidSnapshot(value, context);
     }
     is(thing) {
         return this.validate(thing, [{ path: "", type: this }]).length === 0;
@@ -3241,8 +3219,6 @@ function addHiddenWritableProp(object, propName, value) {
  */
 class EventHandler {
     handlers = [];
-    emitting = false;
-    pendingUnregisters = null;
     get hasSubscribers() {
         return this.handlers.length > 0;
     }
@@ -3261,14 +3237,6 @@ class EventHandler {
         return this.handlers.includes(fn);
     }
     unregister(fn) {
-        if (this.emitting) {
-            // defer unregistration until emit is done
-            if (!this.pendingUnregisters) {
-                this.pendingUnregisters = [];
-            }
-            this.pendingUnregisters.push(fn);
-            return;
-        }
         const index = this.handlers.indexOf(fn);
         if (index >= 0) {
             this.handlers.splice(index, 1);
@@ -3278,26 +3246,10 @@ class EventHandler {
         this.handlers.length = 0;
     }
     emit(...args) {
-        // use emitting flag to defer unregistrations instead of copying array
-        this.emitting = true;
-        try {
-            for (const f of this.handlers) {
-                f(...args);
-            }
-        }
-        finally {
-            this.emitting = false;
-            // process any deferred unregistrations
-            if (this.pendingUnregisters) {
-                for (const fn of this.pendingUnregisters) {
-                    const index = this.handlers.indexOf(fn);
-                    if (index >= 0) {
-                        this.handlers.splice(index, 1);
-                    }
-                }
-                this.pendingUnregisters = null;
-            }
-        }
+        // iterate a copy so (un)registrations during emit don't disturb this pass
+        // and reentrant emits stay correct
+        const handlers = this.handlers.slice();
+        handlers.forEach(f => f(...args));
     }
 }
 /**
@@ -4450,6 +4402,23 @@ function array(subtype) {
 }
 function reconcileArrayChildren(parent, childType, oldNodes, newValues, newPaths) {
     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.
+    let idIndex;
+    if (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];
@@ -4493,13 +4462,26 @@ function reconcileArrayChildren(parent, childType, oldNodes, newValues, newPaths
             oldNodes[i] = valueAsNode(childType, parent, newPath, newValue, oldNode);
         }
         else {
-            // nothing to do, try to reorder
+            // nothing to do, try to reorder: find a candidate old node to reuse
             let oldMatch = undefined;
-            // find a possible candidate to reuse
-            for (let j = i; j < oldNodes.length; j++) {
-                if (areSame(oldNodes[j], newValue)) {
+            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];
-                    break;
+                }
+            }
+            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;
+                    }
                 }
             }
             nothingChanged = false;
@@ -4659,6 +4641,9 @@ class ModelType extends ComplexType {
     preProcessor;
     postProcessor;
     propertyNames;
+    // member/property name collisions are a property of the type, so we only need
+    // to check the first instance we finalize (see finalizeNewInstance)
+    duplicateKeysChecked = false;
     constructor(opts) {
         super(opts.name || defaultObjectOptions.name);
         Object.assign(this, defaultObjectOptions, opts);
@@ -4848,6 +4833,21 @@ class ModelType extends ComplexType {
             mobx._interceptReads(instance, name, node.unbox);
         });
         this.initializers.reduce((self, fn) => fn(self), instance);
+        // views, actions and volatile share the instance namespace with properties,
+        // so a view/action reusing a property name silently clobbers that property's
+        // observable value. It's a type-level mistake (identical for every instance),
+        // so we check just the first one we finalize: a healthy property stays a
+        // plain observable, a shadowing getter becomes a computed, and a shadowing
+        // function/value stops being observable at all. The flag is only set on
+        // success so a broken type keeps throwing on every create.
+        if (!this.duplicateKeysChecked) {
+            this.forAllProps(name => {
+                if (mobx.isComputedProp(instance, name) || !mobx.isObservableProp(instance, name)) {
+                    throw fail(`${name} property is declared twice`);
+                }
+            });
+            this.duplicateKeysChecked = true;
+        }
         mobx.intercept(instance, this.willChange);
         mobx.observe(instance, this.didChange);
     }
@@ -4902,14 +4902,7 @@ class ModelType extends ComplexType {
     getSnapshot(node, applyPostProcess = true) {
         const res = {};
         this.forAllProps((name, type) => {
-            try {
-                // TODO: FIXME, make sure the observable ref is used!
-                const atom = mobx.getAtom(node.storedValue, name);
-                atom.reportObserved();
-            }
-            catch (_e) {
-                throw fail(`${name} property is declared twice`);
-            }
+            mobx.getAtom(node.storedValue, name).reportObserved();
             const snapshot = this.getChildNode(node, name).snapshot;
             // strip-default optionals omit their key when equal to the default
             if (!shouldStripChildFromSnapshot(type, snapshot)) {
@@ -5521,22 +5514,14 @@ class Union extends BaseType {
         if (this._dispatcher) {
             return this._dispatcher(value);
         }
-        // fast path: when type checking is disabled, try quick structural matching first
+        // fast path: when type checking is disabled, try quick structural matching
+        // first. This skips full recursive validation of every property value, a
+        // meaningful win for wide model members (e.g. jbrowse config schemas).
         if (!isTypeCheckingEnabled()) {
             const quickMatch = this.tryQuickMatch(value, reconcileCurrentType);
             if (quickMatch) {
                 return quickMatch;
             }
-            // for plain object snapshots that didn't match via quick path, try all types
-            // with quick matching before falling back to full validation
-            // (state tree nodes must go through full validation for type identity checks)
-            if (isPlainObject(value) && !isStateTreeNode(value)) {
-                for (const type of this._types) {
-                    if (this.snapshotLooksLikeType(value, type)) {
-                        return type;
-                    }
-                }
-            }
         }
         // find the most accomodating type
         // if we are using reconciliation try the current node type first (fix for #1045)