@jbrowse/mobx-state-tree 5.11.1 → 5.12.0

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)) {
@@ -1118,6 +1119,21 @@ class ScalarNode extends BaseNode {
 ScalarNode.prototype.die = mobx.action(ScalarNode.prototype.die);
 
 let nextNodeId = 1;
+var ObservableInstanceLifecycle;
+(function (ObservableInstanceLifecycle) {
+    // the actual observable instance has not been created yet
+    ObservableInstanceLifecycle[ObservableInstanceLifecycle["UNINITIALIZED"] = 0] = "UNINITIALIZED";
+    // the actual observable instance is being created
+    ObservableInstanceLifecycle[ObservableInstanceLifecycle["CREATING"] = 1] = "CREATING";
+    // the actual observable instance has been created
+    ObservableInstanceLifecycle[ObservableInstanceLifecycle["CREATED"] = 2] = "CREATED";
+})(ObservableInstanceLifecycle || (ObservableInstanceLifecycle = {}));
+var InternalEvents;
+(function (InternalEvents) {
+    InternalEvents["Dispose"] = "dispose";
+    InternalEvents["Patch"] = "patch";
+    InternalEvents["Snapshot"] = "snapshot";
+})(InternalEvents || (InternalEvents = {}));
 const snapshotReactionOptions = {
     onError(e) {
         throw e;
@@ -1149,7 +1165,7 @@ class ObjectNode extends BaseNode {
     _autoUnbox = true; // unboxing is disabled when reading child nodes
     _isRunningAction = false; // only relevant for root
     _hasSnapshotReaction = false;
-    _observableInstanceState = 0 /* ObservableInstanceLifecycle.UNINITIALIZED */;
+    _observableInstanceState = ObservableInstanceLifecycle.UNINITIALIZED;
     _childNodes;
     _initialSnapshot;
     _cachedInitialSnapshot;
@@ -1194,7 +1210,7 @@ class ObjectNode extends BaseNode {
     }
     createObservableInstanceIfNeeded(fireHooks = true) {
         if (this._observableInstanceState ===
-            0 /* ObservableInstanceLifecycle.UNINITIALIZED */) {
+            ObservableInstanceLifecycle.UNINITIALIZED) {
             this.createObservableInstance(fireHooks);
         }
     }
@@ -1205,7 +1221,7 @@ class ObjectNode extends BaseNode {
                 throw fail("assertion failed: the creation of the observable instance must be done on the initializing phase");
             }
         }
-        this._observableInstanceState = 1 /* ObservableInstanceLifecycle.CREATING */;
+        this._observableInstanceState = ObservableInstanceLifecycle.CREATING;
         // make sure the parent chain is created as well
         // array with parent chain from parent to child
         const parentChain = [];
@@ -1215,7 +1231,7 @@ class ObjectNode extends BaseNode {
         // this is done to avoid traversing the whole tree to the root when using
         // the same reference again
         while (parent?._observableInstanceState ===
-            0 /* ObservableInstanceLifecycle.UNINITIALIZED */) {
+            ObservableInstanceLifecycle.UNINITIALIZED) {
             parentChain.unshift(parent);
             parent = parent.parent;
         }
@@ -1240,7 +1256,7 @@ class ObjectNode extends BaseNode {
         finally {
             this._isRunningAction = false;
         }
-        this._observableInstanceState = 2 /* ObservableInstanceLifecycle.CREATED */;
+        this._observableInstanceState = ObservableInstanceLifecycle.CREATED;
         this._snapshotComputed.trackAndCompute();
         if (this.isRoot) {
             this._addSnapshotReaction();
@@ -1354,7 +1370,7 @@ class ObjectNode extends BaseNode {
         if (!this.isAlive) {
             return this._snapshotUponDeath;
         }
-        return this._observableInstanceState === 2 /* ObservableInstanceLifecycle.CREATED */
+        return this._observableInstanceState === ObservableInstanceLifecycle.CREATED
             ? this._getActualSnapshot()
             : this._getCachedInitialSnapshot();
     }
@@ -1417,7 +1433,7 @@ class ObjectNode extends BaseNode {
         this._autoUnbox = false;
         try {
             return this._observableInstanceState ===
-                2 /* ObservableInstanceLifecycle.CREATED */
+                ObservableInstanceLifecycle.CREATED
                 ? this.type.getChildNode(this, subpath)
                 : this._childNodes[subpath];
         }
@@ -1430,7 +1446,7 @@ class ObjectNode extends BaseNode {
         this._autoUnbox = false;
         try {
             return this._observableInstanceState ===
-                2 /* ObservableInstanceLifecycle.CREATED */
+                ObservableInstanceLifecycle.CREATED
                 ? this.type.getChildren(this)
                 : convertChildNodesToArray(this._childNodes);
         }
@@ -1516,7 +1532,7 @@ class ObjectNode extends BaseNode {
     }
     aboutToDie() {
         if (this._observableInstanceState ===
-            0 /* ObservableInstanceLifecycle.UNINITIALIZED */) {
+            ObservableInstanceLifecycle.UNINITIALIZED) {
             return;
         }
         this.getChildren().forEach(node => {
@@ -1525,8 +1541,8 @@ class ObjectNode extends BaseNode {
         // beforeDestroy should run before the disposers since else we could end up in a situation where
         // a disposer added with addDisposer at this stage (beforeDestroy) is actually never released
         this.baseAboutToDie();
-        this._internalEventsEmit("dispose" /* InternalEvents.Dispose */);
-        this._internalEventsClear("dispose" /* InternalEvents.Dispose */);
+        this._internalEventsEmit(InternalEvents.Dispose);
+        this._internalEventsClear(InternalEvents.Dispose);
     }
     finalizeDeath() {
         // invariant: not called directly but from "die"
@@ -1542,42 +1558,42 @@ class ObjectNode extends BaseNode {
     }
     onSnapshot(onChange) {
         this._addSnapshotReaction();
-        return this._internalEventsRegister("snapshot" /* InternalEvents.Snapshot */, onChange);
+        return this._internalEventsRegister(InternalEvents.Snapshot, onChange);
     }
     emitSnapshot(snapshot) {
-        this._internalEventsEmit("snapshot" /* InternalEvents.Snapshot */, snapshot);
+        this._internalEventsEmit(InternalEvents.Snapshot, snapshot);
     }
     onPatch(handler) {
-        return this._internalEventsRegister("patch" /* InternalEvents.Patch */, handler);
+        return this._internalEventsRegister(InternalEvents.Patch, handler);
     }
     emitPatch(basePatch, source) {
-        if (this._internalEventsHasSubscribers("patch" /* InternalEvents.Patch */)) {
+        if (this._internalEventsHasSubscribers(InternalEvents.Patch)) {
             const localizedPatch = {
                 ...basePatch,
-                path: `${source.path.substr(this.path.length)}/${basePatch.path}` // calculate the relative path of the patch
+                path: `${source.path.slice(this.path.length)}/${basePatch.path}` // calculate the relative path of the patch
             };
             const [patch, reversePatch] = splitPatch(localizedPatch);
-            this._internalEventsEmit("patch" /* InternalEvents.Patch */, patch, reversePatch);
+            this._internalEventsEmit(InternalEvents.Patch, patch, reversePatch);
         }
         if (this.parent) {
             this.parent.emitPatch(basePatch, source);
         }
     }
     hasDisposer(disposer) {
-        return this._internalEventsHas("dispose" /* InternalEvents.Dispose */, disposer);
+        return this._internalEventsHas(InternalEvents.Dispose, disposer);
     }
     addDisposer(disposer) {
         if (!this.hasDisposer(disposer)) {
-            this._internalEventsRegister("dispose" /* InternalEvents.Dispose */, disposer, true);
+            this._internalEventsRegister(InternalEvents.Dispose, disposer, true);
             return;
         }
         throw fail("cannot add a disposer when it is already registered for execution");
     }
     removeDisposer(disposer) {
-        if (!this._internalEventsHas("dispose" /* InternalEvents.Dispose */, disposer)) {
+        if (!this._internalEventsHas(InternalEvents.Dispose, disposer)) {
             throw fail("cannot remove a disposer which was never registered for execution");
         }
-        this._internalEventsUnregister("dispose" /* InternalEvents.Dispose */, disposer);
+        this._internalEventsUnregister(InternalEvents.Dispose, disposer);
     }
     removeMiddleware(middleware) {
         if (this.middlewares) {
@@ -1653,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
@@ -1731,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;
@@ -2567,22 +2560,47 @@ function isActionContextThisOrChildOf(actionContext, parentOrThis) {
 }
 
 const MAX_STRINGIFY_DEPTH = 3;
+const MAX_STRINGIFY_ARRAY_ITEMS = 10;
+const MAX_STRINGIFY_OBJECT_KEYS = 20;
+const MAX_STRINGIFY_STRING_LENGTH = 100;
+// Recursively cap depth, array length, object key count, and string length so a
+// huge offending snapshot degrades into readable, bounded context instead of a
+// wall of text that then gets sliced mid-structure. The depth cap also bounds
+// recursion on circular structures.
+function truncateForStringify(value, depth) {
+    if (typeof value === "string") {
+        return value.length > MAX_STRINGIFY_STRING_LENGTH
+            ? `${value.substring(0, MAX_STRINGIFY_STRING_LENGTH)}… (${value.length - MAX_STRINGIFY_STRING_LENGTH} more characters)`
+            : value;
+    }
+    if (value === null || typeof value !== "object") {
+        return value;
+    }
+    if (depth >= MAX_STRINGIFY_DEPTH) {
+        return Array.isArray(value) ? "[…]" : "{…}";
+    }
+    if (Array.isArray(value)) {
+        const items = value
+            .slice(0, MAX_STRINGIFY_ARRAY_ITEMS)
+            .map(item => truncateForStringify(item, depth + 1));
+        if (value.length > MAX_STRINGIFY_ARRAY_ITEMS) {
+            items.push(`… ${value.length - MAX_STRINGIFY_ARRAY_ITEMS} more items`);
+        }
+        return items;
+    }
+    const keys = Object.keys(value);
+    const result = {};
+    for (const key of keys.slice(0, MAX_STRINGIFY_OBJECT_KEYS)) {
+        result[key] = truncateForStringify(value[key], depth + 1);
+    }
+    if (keys.length > MAX_STRINGIFY_OBJECT_KEYS) {
+        result["…"] = `${keys.length - MAX_STRINGIFY_OBJECT_KEYS} more keys`;
+    }
+    return result;
+}
 function safeStringify(value) {
     try {
-        const ancestors = [];
-        return JSON.stringify(value, function (_key, val) {
-            if (val !== null && typeof val === "object") {
-                while (ancestors.length > 0 &&
-                    ancestors[ancestors.length - 1] !== this) {
-                    ancestors.pop();
-                }
-                if (ancestors.length >= MAX_STRINGIFY_DEPTH) {
-                    return Array.isArray(val) ? "[…]" : "{…}";
-                }
-                ancestors.push(val);
-            }
-            return val;
-        });
+        return JSON.stringify(truncateForStringify(value, 0));
     }
     catch (e) {
         // istanbul ignore next
@@ -3013,31 +3031,6 @@ function convertChildNodesToArray(childNodes) {
     return result;
 }
 
-// based on: https://github.com/mobxjs/mobx-utils/blob/master/src/async-action.ts
-/*
-    All contents of this file are deprecated.
-
-    The term `process` has been replaced with `flow` to avoid conflicts with the
-    global `process` object.
-
-    Refer to `flow.ts` for any further changes to this implementation.
-*/
-const DEPRECATION_MESSAGE = "See https://github.com/mobxjs/mobx-state-tree/issues/399 for more information. " +
-    "Note that the middleware event types starting with `process` now start with `flow`.";
-/**
- * @hidden
- *
- * @deprecated has been renamed to `flow()`.
- * See https://github.com/mobxjs/mobx-state-tree/issues/399 for more information.
- * Note that the middleware event types starting with `process` now start with `flow`.
- *
- * @returns {Promise}
- */
-function process$1(asyncAction) {
-    deprecated("process", `\`process()\` has been renamed to \`flow()\`. ${DEPRECATION_MESSAGE}`);
-    return flow(asyncAction);
-}
-
 const plainObjectString = Object.toString();
 /**
  * @internal
@@ -3226,8 +3219,6 @@ function addHiddenWritableProp(object, propName, value) {
  */
 class EventHandler {
     handlers = [];
-    emitting = false;
-    pendingUnregisters = null;
     get hasSubscribers() {
         return this.handlers.length > 0;
     }
@@ -3246,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);
@@ -3263,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));
     }
 }
 /**
@@ -3328,25 +3295,6 @@ class EventHandlers {
         }
     }
 }
-/**
- * @internal
- * @hidden
- */
-const deprecated = function (id, message) {
-    // skip if running production
-    if (!devMode()) {
-        return;
-    }
-    // warn if hasn't been warned before
-    if (deprecated.ids && !deprecated.ids.hasOwnProperty(id)) {
-        warnError(`Deprecation warning: ${message}`);
-    }
-    // mark as warned to avoid duplicate warn message
-    if (deprecated.ids) {
-        deprecated.ids[id] = true;
-    }
-};
-deprecated.ids = {};
 /**
  * @internal
  * @hidden
@@ -4299,9 +4247,9 @@ class ArrayType extends ComplexType {
         return node.storedValue.slice();
     }
     getChildNode(node, key) {
-        const index = Number(key);
-        if (index < node.storedValue.length) {
-            return node.storedValue[index];
+        const child = node.storedValue[Number(key)];
+        if (child) {
+            return child;
         }
         throw fail(`Not a child: ${key}`);
     }
@@ -4454,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];
@@ -4468,7 +4433,7 @@ function reconcileArrayChildren(parent, childType, oldNodes, newValues, newPaths
             // both are empty, end
             break;
         }
-        else if (!hasNewNode) {
+        else if (oldNode && !hasNewNode) {
             // new one does not exists
             nothingChanged = false;
             oldNodes.splice(i, 1);
@@ -4497,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;
@@ -4663,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);
@@ -4852,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);
     }
@@ -4906,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)) {
@@ -5525,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)
@@ -7068,7 +7049,6 @@ exports.joinJsonPath = joinJsonPath;
 exports.onAction = onAction;
 exports.onPatch = onPatch;
 exports.onSnapshot = onSnapshot;
-exports.process = process$1;
 exports.protect = protect;
 exports.recordActions = recordActions;
 exports.recordPatches = recordPatches;