@jbrowse/mobx-state-tree 5.13.0 → 6.1.0

package/dist/index.d.ts

@@ -945,7 +945,6 @@ declare abstract class BaseType<C, S, T, N extends BaseNode<any, any, any> = Bas
  */
 declare abstract class ComplexType<C, S, T> extends BaseType<C, S, T, ObjectNode<C, S, T>> {
     identifierAttribute?: string;
-    constructor(name: string);
     create(snapshot?: C, environment?: any): any;
     getValue(node: this["N"]): T;
     abstract getDefaultSnapshot(): C;
@@ -953,7 +952,7 @@ declare abstract class ComplexType<C, S, T> extends BaseType<C, S, T, ObjectNode
     abstract finalizeNewInstance(node: this["N"], instance: any): void;
     abstract applySnapshot(node: this["N"], snapshot: C): void;
     abstract applyPatchLocally(node: this["N"], subpath: string, patch: IJsonPatch): void;
-    abstract processInitialSnapshot(childNodes: IChildNodesMap, snapshot: C): S;
+    abstract processInitialSnapshot(childNodes: IChildNodesMap): S;
     abstract getChildren(node: this["N"]): ReadonlyArray<AnyNode>;
     abstract getChildNode(node: this["N"], key: string): AnyNode;
     abstract getChildType(propertyName?: string): IAnyType;
@@ -1245,7 +1244,6 @@ declare class IdentifierCache {
     private cacheId;
     private cache;
     private lastCacheModificationPerId;
-    constructor();
     private updateLastCacheModificationPerId;
     getLastCacheModificationPerId(identifier: string): string;
     addNodeToCache(node: AnyObjectNode, lastCacheUpdate?: boolean): void;

package/dist/mobx-state-tree.cjs

@@ -946,7 +946,6 @@ class BaseNode {
     constructor(type, parent, subpath, environment) {
         this.type = type;
         this.environment = environment;
-        this.environment = environment;
         this.baseSetParent(parent, subpath);
     }
     getReconciliationType() {
@@ -1414,10 +1413,7 @@ class ObjectNode extends BaseNode {
     }
     _getCachedInitialSnapshot() {
         if (!this._cachedInitialSnapshotCreated) {
-            const type = this.type;
-            const childNodes = this._childNodes;
-            const snapshot = this._initialSnapshot;
-            this._cachedInitialSnapshot = type.processInitialSnapshot(childNodes, snapshot);
+            this._cachedInitialSnapshot = this.type.processInitialSnapshot(this._childNodes);
             this._cachedInitialSnapshotCreated = true;
         }
         return this._cachedInitialSnapshot;
@@ -1810,9 +1806,6 @@ BaseType.prototype.create = mobx.action(BaseType.prototype.create);
  */
 class ComplexType extends BaseType {
     identifierAttribute;
-    constructor(name) {
-        super(name);
-    }
     create(snapshot = this.getDefaultSnapshot(), environment) {
         return super.create(snapshot, environment);
     }
@@ -2714,13 +2707,6 @@ function typeCheckFailure(context, value, message) {
     // Clone context since it may be mutated after this error is created
     return [{ context: context.slice(), value, message }];
 }
-/**
- * @internal
- * @hidden
- */
-function flattenTypeErrors(errors) {
-    return errors.flat();
-}
 // TODO; doublecheck: typecheck should only needed to be invoked from: type.create and array / map / value.property will change
 /**
  * @internal
@@ -2782,7 +2768,6 @@ class IdentifierCache {
     // last time the cache (array) for a given time changed
     // n.b. it is not really the time, but just an integer that gets increased after each modification to the array
     lastCacheModificationPerId = mobx.observable.map();
-    constructor() { }
     updateLastCacheModificationPerId(identifier) {
         const lcm = this.lastCacheModificationPerId.get(identifier);
         // we start at 1 since 0 means no update since cache creation
@@ -2823,7 +2808,7 @@ class IdentifierCache {
                 if (!set.length) {
                     this.cache.delete(id);
                 }
-                this.updateLastCacheModificationPerId(node.identifier);
+                this.updateLastCacheModificationPerId(id);
             }
         }
     }
@@ -3055,15 +3040,8 @@ function convertChildNodesToArray(childNodes) {
     if (!childNodes) {
         return EMPTY_ARRAY;
     }
-    const keys = Object.keys(childNodes);
-    if (!keys.length) {
-        return EMPTY_ARRAY;
-    }
-    const result = new Array(keys.length);
-    keys.forEach((key, index) => {
-        result[index] = childNodes[key];
-    });
-    return result;
+    const result = Object.values(childNodes);
+    return result.length ? result : EMPTY_ARRAY;
 }
 
 const plainObjectString = Object.toString();
@@ -3081,9 +3059,7 @@ const EMPTY_OBJECT = Object.freeze({});
  * @internal
  * @hidden
  */
-const mobxShallow = mobx._getGlobalState().useProxies
-    ? { deep: false }
-    : { deep: false, proxy: false };
+const mobxShallow = { deep: false };
 Object.freeze(mobxShallow);
 /**
  * @internal
@@ -3281,10 +3257,19 @@ class EventHandler {
         this.handlers.length = 0;
     }
     emit(...args) {
-        // 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));
+        const handlers = this.handlers;
+        // 0 and 1 handlers are by far the common cases (a patch/snapshot listener, a
+        // disposer) and need no copy: with a single handler, calling the value we
+        // already read is exactly what iterating a copy of it would do.
+        if (handlers.length <= 1) {
+            handlers[0]?.(...args);
+            return;
+        }
+        // otherwise iterate a copy so (un)registrations during emit don't disturb
+        // this pass and reentrant emits stay correct
+        for (const f of handlers.slice()) {
+            f(...args);
+        }
     }
 }
 /**
@@ -3665,6 +3650,11 @@ function escapeJsonPath(path) {
  * Unescape slashes and backslashes.
  */
 function unescapeJsonPath(path) {
+    // every escape sequence starts with `~`, so bail before the two regex passes
+    // for the overwhelmingly common unescaped part (mirrors escapeJsonPath above)
+    if (!path.includes("~")) {
+        return path;
+    }
     return path.replace(/~1/g, "/").replace(/~0/g, "~");
 }
 /**
@@ -3911,7 +3901,11 @@ var MapIdentifierMode;
 })(MapIdentifierMode || (MapIdentifierMode = {}));
 class MSTMap extends mobx.ObservableMap {
     constructor(initialData, name) {
-        super(initialData, mobx.observable.ref.enhancer, name);
+        // mobx's default (deep) enhancer. The old `observable.ref.enhancer` arg
+        // read undefined ever since mobx 6 renamed the field to `options_.enhancer`,
+        // so deep has been the effective behavior all along; mobx 7 dropped
+        // `observable.ref` entirely.
+        super(initialData, undefined, name);
     }
     get(key) {
         // maybe this is over-enthousiastic? normalize numeric keys to strings
@@ -4151,22 +4145,21 @@ class MapType extends ComplexType {
     applySnapshot(node, snapshot) {
         typecheckInternal(this, snapshot);
         const target = node.storedValue;
-        const currentKeys = {};
-        Array.from(target.keys()).forEach(key => {
-            currentKeys[key] = false;
-        });
+        // keys present before the apply, minus the ones the snapshot (re)sets — what
+        // remains has to be deleted. A Set rather than a plain object: it needs no
+        // sentinel values, no second pass to find the survivors, and it can hold keys
+        // like "__proto__", which an object literal silently swallows.
+        const staleKeys = new Set(target.keys());
         if (snapshot) {
             // Don't use target.replace, as it will throw away all existing items first
             for (const key in snapshot) {
                 target.set(key, snapshot[key]);
-                currentKeys[`${key}`] = true;
+                staleKeys.delete(key);
             }
         }
-        Object.keys(currentKeys).forEach(key => {
-            if (currentKeys[key] === false) {
-                target.delete(key);
-            }
-        });
+        for (const key of staleKeys) {
+            target.delete(key);
+        }
     }
     getChildType() {
         return this._subType;
@@ -4306,7 +4299,7 @@ class ArrayType extends ComplexType {
                     if (change.newValue === change.object[change.index]) {
                         return null;
                     }
-                    const updatedNodes = reconcileArrayChildren(node, subType, [childNodes[change.index]], [change.newValue], [change.index]);
+                    const updatedNodes = reconcileArrayChildren(node, subType, [childNodes[change.index]], [change.newValue], change.index);
                     if (!updatedNodes) {
                         return null;
                     }
@@ -4316,7 +4309,7 @@ class ArrayType extends ComplexType {
             case "splice":
                 {
                     const { index, removedCount, added } = change;
-                    const addedNodes = reconcileArrayChildren(node, subType, childNodes.slice(index, index + removedCount), added, added.map((_, i) => index + i));
+                    const addedNodes = reconcileArrayChildren(node, subType, childNodes.slice(index, index + removedCount), added, index);
                     if (!addedNodes) {
                         return null;
                     }
@@ -4442,7 +4435,11 @@ function array(subtype) {
     assertIsType(subtype, 1);
     return new ArrayType(`${subtype.name}[]`, subtype);
 }
-function reconcileArrayChildren(parent, childType, oldNodes, newValues, newPaths) {
+/**
+ * @param firstNewPath index the reconciled slice starts at; both call sites
+ * hand over a contiguous run, so subpath `i` is simply `firstNewPath + i`
+ */
+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
@@ -4465,7 +4462,7 @@ function reconcileArrayChildren(parent, childType, oldNodes, newValues, newPaths
         const hasNewNode = i <= newValues.length - 1;
         const oldNode = oldNodes[i];
         let newValue = hasNewNode ? newValues[i] : undefined;
-        const newPath = `${newPaths[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)) {
@@ -4589,12 +4586,14 @@ function areSame(oldNode, newValue) {
     if (!(oldNode instanceof ObjectNode)) {
         return false;
     }
+    if (oldNode.identifier === null ||
+        !oldNode.identifierAttribute ||
+        !isPlainObject(newValue)) {
+        return false;
+    }
     const oldNodeType = oldNode.getReconciliationType();
     // new value is a snapshot with the correct identifier
-    return (oldNode.identifier !== null &&
-        oldNode.identifierAttribute &&
-        isPlainObject(newValue) &&
-        oldNodeType.is(newValue) &&
+    return (oldNodeType.is(newValue) &&
         oldNodeType.isMatchingSnapshotId(oldNode, newValue));
 }
 /**
@@ -4609,6 +4608,9 @@ function isArrayType(type) {
 
 const PRE_PROCESS_SNAPSHOT = "preProcessSnapshot";
 const POST_PROCESS_SNAPSHOT = "postProcessSnapshot";
+function getPropObservable(storedValue, key) {
+    return mobx.getAtom(storedValue, key);
+}
 function objectTypeToString() {
     return getStateTreeNode(this).toString();
 }
@@ -4618,16 +4620,8 @@ const defaultObjectOptions = {
     initializers: EMPTY_ARRAY
 };
 function toPropertiesObject(declaredProps) {
-    const keysList = Object.keys(declaredProps);
-    const alreadySeenKeys = new Set();
-    keysList.forEach(key => {
-        if (alreadySeenKeys.has(key)) {
-            throw fail(`${key} is declared twice in the model. Model should not contain the same keys`);
-        }
-        alreadySeenKeys.add(key);
-    });
     // loop through properties and ensures that all items are types
-    return keysList.reduce((props, key) => {
+    return Object.keys(declaredProps).reduce((props, key) => {
         // warn if user intended a HOOK
         if (key in Hook) {
             throw fail(`Hook '${key}' was defined as property. Hooks should be defined as part of the actions`);
@@ -4667,7 +4661,10 @@ function toPropertiesObject(declaredProps) {
             throw fail(`Invalid type definition for property '${key}', cannot infer a type from a value like '${value}' (${typeof value})`);
         }
         return props;
-    }, { ...declaredProps });
+    }, 
+    // seeded with the raw declaration; every key is either replaced by its
+    // converted type below, left alone because it already is one, or throws
+    { ...declaredProps });
 }
 /**
  * @internal
@@ -4949,7 +4946,8 @@ class ModelType extends ComplexType {
         // 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)) {
+                if (mobx.isComputedProp(instance, name) ||
+                    !mobx.isObservableProp(instance, name)) {
                     throw fail(`${name} property is declared twice`);
                 }
             });
@@ -4989,33 +4987,52 @@ class ModelType extends ComplexType {
         }
     }
     getChildren(node) {
-        const res = [];
-        this.forAllProps(name => {
-            res.push(this.getChildNode(node, name));
-        });
+        const names = this.propertyNames;
+        const res = new Array(names.length);
+        for (let i = 0; i < names.length; i++) {
+            res[i] = this.getPropertyNode(node, names[i]);
+        }
         return res;
     }
-    getChildNode(node, key) {
-        if (!(key in this.properties)) {
-            throw fail(`Not a value property: ${key}`);
-        }
-        const adm = mobx._getAdministration(node.storedValue, key);
-        const childNode = adm.raw?.();
+    /**
+     * Same as {@link getChildNode} but for a key already known to be a declared
+     * property (callers iterating `propertyNames`), so the membership guard is
+     * skipped.
+     */
+    getPropertyNode(node, key) {
+        const childNode = getPropObservable(node.storedValue, key).raw();
         if (!childNode) {
             throw fail(`Node not available for property ${key}`);
         }
         return childNode;
     }
+    getChildNode(node, key) {
+        if (!(key in this.properties)) {
+            throw fail(`Not a value property: ${key}`);
+        }
+        return this.getPropertyNode(node, key);
+    }
     getSnapshot(node, applyPostProcess = true) {
         const res = {};
-        this.forAllProps((name, type) => {
-            mobx.getAtom(node.storedValue, name).reportObserved();
-            const snapshot = this.getChildNode(node, name).snapshot;
+        const storedValue = node.storedValue;
+        const properties = this.properties;
+        for (const name of this.propertyNames) {
+            // One mobx lookup serves both purposes: reportObserved so the snapshot
+            // computed recomputes when the child is reassigned (raw() below does not
+            // track), and raw() to read the child node. Going through getChildNode
+            // would repeat the same lookup for every property.
+            const observable = getPropObservable(storedValue, name);
+            observable.reportObserved();
+            const childNode = observable.raw();
+            if (!childNode) {
+                throw fail(`Node not available for property ${name}`);
+            }
+            const snapshot = childNode.snapshot;
             // strip-default optionals omit their key when equal to the default
-            if (!shouldStripChildFromSnapshot(type, snapshot)) {
+            if (!shouldStripChildFromSnapshot(properties[name], snapshot)) {
                 res[name] = snapshot;
             }
-        });
+        }
         if (applyPostProcess) {
             return this.applySnapshotPostProcessor(res);
         }
@@ -5079,7 +5096,10 @@ class ModelType extends ComplexType {
         return typeCheckSuccess();
     }
     forAllProps(fn) {
-        this.propertyNames.forEach(key => fn(key, this.properties[key]));
+        const properties = this.properties;
+        for (const key of this.propertyNames) {
+            fn(key, properties[key]);
+        }
     }
     describe() {
         // optimization: cache
@@ -5549,11 +5569,16 @@ class Union extends BaseType {
     _types;
     _dispatcher;
     _eager = true;
+    // Deliberately recomputed rather than memoized: a `types.late` member reports
+    // 0 for its subtype until the definition resolves, so the fold is not stable
+    // over the type's lifetime and a memo would need a carve-out for exactly the
+    // case that motivates it. Measured at ~4% of union creation, which is not
+    // worth another cache.
     get flags() {
         let result = TypeFlags.Union;
-        this._types.forEach(type => {
+        for (const type of this._types) {
             result |= type.flags;
-        });
+        }
         return result;
     }
     constructor(name, _types, options) {
@@ -5695,13 +5720,9 @@ class Union extends BaseType {
             if (reconcileCurrentType.is(value)) {
                 return reconcileCurrentType;
             }
-            return this._types
-                .filter(t => t !== reconcileCurrentType)
-                .find(type => type.is(value));
-        }
-        else {
-            return this._types.find(type => type.is(value));
+            return this._types.find(type => type !== reconcileCurrentType && type.is(value));
         }
+        return this._types.find(type => type.is(value));
     }
     tryQuickMatch(value, reconcileCurrentType) {
         // state tree nodes need full type compatibility checking
@@ -5713,15 +5734,17 @@ class Union extends BaseType {
         if (!isPlainObject(value)) {
             return this.tryMatchPrimitive(value);
         }
-        // for objects, try structural matching against model types
-        const typesToCheck = reconcileCurrentType
-            ? [
-                reconcileCurrentType,
-                ...this._types.filter(t => t !== reconcileCurrentType)
-            ]
-            : this._types;
-        for (const type of typesToCheck) {
-            if (this.snapshotLooksLikeType(value, type)) {
+        // for objects, try structural matching against model types, preferring the
+        // reconciliation type (checked first, then skipped in the main pass) so a
+        // reconcile keeps its current member when it still fits — without building
+        // the reordered candidate list this used to allocate on every call
+        if (reconcileCurrentType &&
+            this.snapshotLooksLikeType(value, reconcileCurrentType)) {
+            return reconcileCurrentType;
+        }
+        for (const type of this._types) {
+            if (type !== reconcileCurrentType &&
+                this.snapshotLooksLikeType(value, type)) {
                 return type;
             }
         }
@@ -5836,7 +5859,7 @@ class Union extends BaseType {
         if (applicableTypes === 1) {
             return typeCheckSuccess();
         }
-        return typeCheckFailure(context, value, "No type is applicable for the union").concat(flattenTypeErrors(allErrors));
+        return typeCheckFailure(context, value, "No type is applicable for the union").concat(allErrors.flat());
     }
     getSubTypes() {
         return this._types;
@@ -5936,15 +5959,15 @@ class OptionalValue extends BaseType {
             : this.getDefaultInstanceOrSnapshot(), parent, subpath);
     }
     getDefaultInstanceOrSnapshot() {
-        const defaultInstanceOrSnapshot = typeof this._defaultValue === "function"
-            ? this._defaultValue()
-            : this._defaultValue;
-        // while static values are already snapshots and checked on types.optional
-        // generator functions must always be rechecked just in case
-        if (typeof this._defaultValue === "function") {
-            typecheckInternal(this, defaultInstanceOrSnapshot);
+        const defaultValue = this._defaultValue;
+        if (typeof defaultValue !== "function") {
+            // static values are already snapshots, checked once by types.optional
+            return defaultValue;
         }
-        return defaultInstanceOrSnapshot;
+        const generated = defaultValue();
+        // generator functions must always be rechecked just in case
+        typecheckInternal(this, generated);
+        return generated;
     }
     isValidSnapshot(value, context) {
         // defaulted values can be skipped
@@ -6036,33 +6059,70 @@ function isOptionalType(type) {
     return isType(type) && (type.flags & TypeFlags.Optional) > 0;
 }
 /**
- * Compare a child snapshot to a stripped-default's reference snapshot. Mirrors
- * the legacy hand-rolled comparison: identity for primitives, structural for
- * objects/arrays.
+ * Compare a child snapshot to a stripped-default's reference snapshot: identity
+ * for primitives, structural for objects/arrays.
+ *
+ * Walks the two snapshots in parallel and bails at the first difference. The
+ * previous implementation compared `JSON.stringify(a) === JSON.stringify(b)`
+ * behind a size guard, which is O(whole snapshot) on both sides — plus two
+ * string allocations — even when the very first key differs. That is the normal
+ * case for an identified sub-model: its snapshot has exactly the same shape as
+ * the default and differs only in the identifier, so the size guard never fires
+ * and every `getSnapshot` of the parent serialized both trees just to answer
+ * "no".
+ *
+ * Snapshots are frozen, acyclic, JSON-ish plain data, so a plain recursive walk
+ * is safe. Key order is compared too, matching what stringify comparison did:
+ * the point is to answer "is this still the default", and the only unsafe answer
+ * is a false positive (a key gets dropped from the snapshot that shouldn't be),
+ * so where this can't reproduce stringify exactly — `{a: undefined}` vs
+ * `{b: undefined}`, or `NaN` nested in a frozen value, both of which stringify
+ * flattened into equal text — it errs toward "not equal" and simply keeps the
+ * key. Neither shape is reachable from a model snapshot, whose key set and order
+ * are fixed by its type.
  */
 function defaultSnapshotEquals(a, b) {
     if (a === b) {
         return true;
     }
-    if (typeof a === "object" &&
-        a !== null &&
-        typeof b === "object" &&
-        b !== null) {
-        // Cheap structural short-circuit before the full stringify compare: a
-        // value of a different size can't equal the default, so the common strip
-        // case (non-empty value vs an empty `[]`/`{}` default) avoids stringifying
-        // a potentially large snapshot on every getSnapshot.
-        if (Array.isArray(a) !== Array.isArray(b)) {
+    if (typeof a !== "object" ||
+        a === null ||
+        typeof b !== "object" ||
+        b === null) {
+        return false;
+    }
+    const aIsArray = Array.isArray(a);
+    if (aIsArray !== Array.isArray(b)) {
+        return false;
+    }
+    if (aIsArray) {
+        const arrayA = a;
+        const arrayB = b;
+        if (arrayA.length !== arrayB.length) {
             return false;
         }
-        const aSize = Array.isArray(a) ? a.length : Object.keys(a).length;
-        const bSize = Array.isArray(b) ? b.length : Object.keys(b).length;
-        if (aSize !== bSize) {
+        for (let i = 0; i < arrayA.length; i++) {
+            if (!defaultSnapshotEquals(arrayA[i], arrayB[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    const objectA = a;
+    const objectB = b;
+    const keysA = Object.keys(objectA);
+    const keysB = Object.keys(objectB);
+    if (keysA.length !== keysB.length) {
+        return false;
+    }
+    for (let i = 0; i < keysA.length; i++) {
+        const key = keysA[i];
+        if (key !== keysB[i] ||
+            !defaultSnapshotEquals(objectA[key], objectB[key])) {
             return false;
         }
-        return JSON.stringify(a) === JSON.stringify(b);
     }
-    return false;
+    return true;
 }
 /**
  * An optional type that additionally omits its key from a parent model's