@jbrowse/mobx-state-tree 5.4.7 → 5.6.0

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

@@ -1654,6 +1654,9 @@ ObjectNode.prototype.createObservableInstance = action(ObjectNode.prototype.crea
 ObjectNode.prototype.detach = action(ObjectNode.prototype.detach);
 ObjectNode.prototype.die = 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
@@ -1729,7 +1732,27 @@ class BaseType {
                 : typeCheckFailure(context, value);
             // it is tempting to compare snapshots, but in that case we should always clone on assignments...
         }
-        return this.isValidSnapshot(value, context);
+        // 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;
     }
     is(thing) {
         return this.validate(thing, [{ path: "", type: this }]).length === 0;
@@ -2594,9 +2617,21 @@ function toErrorString(error) {
 /**
  * @internal
  * @hidden
+ * Pushes a new entry onto the context array (mutates in place for performance).
+ * Returns the same context array for chaining.
  */
 function getContextForPath(context, path, type) {
-    return context.concat([{ path, type }]);
+    context.push({ path, type });
+    return context;
+}
+/**
+ * @internal
+ * @hidden
+ * Pops the last entry from the context array (mutates in place).
+ * Must be called after validation to restore context state.
+ */
+function popContext(context) {
+    context.pop();
 }
 /**
  * @internal
@@ -2610,14 +2645,15 @@ function typeCheckSuccess() {
  * @hidden
  */
 function typeCheckFailure(context, value, message) {
-    return [{ 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.reduce((a, i) => a.concat(i), []);
+    return errors.flat();
 }
 // TODO; doublecheck: typecheck should only needed to be invoked from: type.create and array / map / value.property will change
 /**
@@ -3172,6 +3208,8 @@ function addHiddenWritableProp(object, propName, value) {
  */
 class EventHandler {
     handlers = [];
+    emitting = false;
+    pendingUnregisters = null;
     get hasSubscribers() {
         return this.handlers.length > 0;
     }
@@ -3190,6 +3228,14 @@ class EventHandler {
         return this.handlers.indexOf(fn) >= 0;
     }
     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);
@@ -3199,9 +3245,26 @@ class EventHandler {
         this.handlers.length = 0;
     }
     emit(...args) {
-        // make a copy just in case it changes
-        const handlers = this.handlers.slice();
-        handlers.forEach(f => f(...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;
+            }
+        }
     }
 }
 /**
@@ -4121,7 +4184,15 @@ class MapType extends ComplexType {
         if (!isPlainObject(value)) {
             return typeCheckFailure(context, value, "Value is not a plain object");
         }
-        return flattenTypeErrors(Object.keys(value).map(path => this._subType.validate(value[path], getContextForPath(context, path, this._subType))));
+        for (const key of Object.keys(value)) {
+            getContextForPath(context, key, this._subType);
+            const errors = this._subType.validate(value[key], context);
+            popContext(context);
+            if (errors.length > 0) {
+                return errors;
+            }
+        }
+        return typeCheckSuccess();
     }
     getDefaultSnapshot() {
         return EMPTY_OBJECT;
@@ -4334,7 +4405,15 @@ class ArrayType extends ComplexType {
         if (!isArray(value)) {
             return typeCheckFailure(context, value, "Value is not an array");
         }
-        return flattenTypeErrors(value.map((item, index) => this._subType.validate(item, getContextForPath(context, "" + index, this._subType))));
+        for (let i = 0; i < value.length; i++) {
+            getContextForPath(context, "" + i, this._subType);
+            const errors = this._subType.validate(value[i], context);
+            popContext(context);
+            if (errors.length > 0) {
+                return errors;
+            }
+        }
+        return typeCheckSuccess();
     }
     getDefaultSnapshot() {
         return EMPTY_ARRAY;
@@ -4884,7 +4963,16 @@ class ModelType extends ComplexType {
         if (!isPlainObject(snapshot)) {
             return typeCheckFailure(context, snapshot, "Value is not a plain object");
         }
-        return flattenTypeErrors(this.propertyNames.map(key => this.properties[key].validate(snapshot[key], getContextForPath(context, key, this.properties[key]))));
+        for (const key of this.propertyNames) {
+            const propType = this.properties[key];
+            getContextForPath(context, key, propType);
+            const errors = propType.validate(snapshot[key], context);
+            popContext(context);
+            if (errors.length > 0) {
+                return errors;
+            }
+        }
+        return typeCheckSuccess();
     }
     forAllProps(fn) {
         this.propertyNames.forEach(key => fn(key, this.properties[key]));
@@ -5350,6 +5438,23 @@ class Union extends BaseType {
         if (this._dispatcher) {
             return this._dispatcher(value);
         }
+        // fast path: when type checking is disabled, try quick structural matching first
+        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)
         if (reconcileCurrentType) {
@@ -5364,6 +5469,84 @@ class Union extends BaseType {
             return this._types.find(type => type.is(value));
         }
     }
+    tryQuickMatch(value, reconcileCurrentType) {
+        // state tree nodes need full type compatibility checking
+        // (e.g., A.is(B.create()) must return false even if snapshots are compatible)
+        if (isStateTreeNode(value)) {
+            return undefined;
+        }
+        // for non-object values, try primitive matching
+        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)) {
+                return type;
+            }
+        }
+        return undefined;
+    }
+    tryMatchPrimitive(value) {
+        const valueType = typeof value;
+        for (const type of this._types) {
+            const flags = type.flags;
+            if ((valueType === "string" && flags & TypeFlags.String) ||
+                (valueType === "number" &&
+                    flags &
+                        (TypeFlags.Number |
+                            TypeFlags.Integer |
+                            TypeFlags.Float |
+                            TypeFlags.Finite)) ||
+                (valueType === "boolean" && flags & TypeFlags.Boolean) ||
+                (value === null && flags & TypeFlags.Null) ||
+                (value === undefined && flags & TypeFlags.Undefined)) {
+                return type;
+            }
+            // for literals, check exact value match
+            if (flags & TypeFlags.Literal) {
+                if (type.is(value)) {
+                    return type;
+                }
+            }
+        }
+        return undefined;
+    }
+    snapshotLooksLikeType(value, type) {
+        // for model types, check if snapshot has all the required property keys
+        // and that any literal-typed properties match exactly
+        if (type instanceof ModelType) {
+            const props = type.properties;
+            // use cached propertyNames from ModelType instead of Object.keys()
+            for (const key of type.propertyNames) {
+                const propType = props[key];
+                const isOptional = propType.flags & TypeFlags.Optional;
+                const propValue = value[key];
+                // check required properties exist and are not undefined
+                // (unless the type accepts undefined, which Optional types do)
+                if (!isOptional) {
+                    if (!(key in value) || propValue === undefined) {
+                        return false;
+                    }
+                }
+                // for literal types, verify the value matches exactly
+                // this is critical for discriminated unions
+                if (propType.flags & TypeFlags.Literal) {
+                    if (!propType.is(propValue)) {
+                        return false;
+                    }
+                }
+            }
+            return true;
+        }
+        return false;
+    }
     isValidSnapshot(value, context) {
         if (this._dispatcher) {
             return this._dispatcher(value).validate(value, context);
@@ -6453,6 +6636,122 @@ class CustomType extends SimpleType {
     }
 }
 
+class Resilient extends BaseType {
+    _subtype;
+    _fallbackType;
+    _createFallbackSnapshot;
+    get flags() {
+        return this._subtype.flags;
+    }
+    constructor(_subtype, _fallbackType, _createFallbackSnapshot) {
+        super(`resilient(${_subtype.name})`);
+        this._subtype = _subtype;
+        this._fallbackType = _fallbackType;
+        this._createFallbackSnapshot = _createFallbackSnapshot;
+    }
+    describe() {
+        return `resilient(${this._subtype.describe()})`;
+    }
+    _instantiateFallback(parent, subpath, environment, originalSnapshot, originalError) {
+        let fallbackSnapshot;
+        try {
+            fallbackSnapshot = this._createFallbackSnapshot(originalError, originalSnapshot);
+        }
+        catch (e) {
+            throw fail(`resilient: createFallbackSnapshot threw while handling error for '${this._subtype.name}': ${originalError}. createFallbackSnapshot error: ${e}`);
+        }
+        try {
+            return this._fallbackType.instantiate(parent, subpath, environment, fallbackSnapshot);
+        }
+        catch (e) {
+            throw fail(`resilient: fallback type '${this._fallbackType.name}' failed to instantiate while handling error for '${this._subtype.name}': ${originalError}. Fallback error: ${e}`);
+        }
+    }
+    instantiate(parent, subpath, environment, initialValue) {
+        if (isStateTreeNode(initialValue)) {
+            return this._subtype.instantiate(parent, subpath, environment, initialValue);
+        }
+        try {
+            return this._subtype.instantiate(parent, subpath, environment, initialValue);
+        }
+        catch (e) {
+            return this._instantiateFallback(parent, subpath, environment, initialValue, e);
+        }
+    }
+    reconcile(current, newValue, parent, subpath) {
+        if (isStateTreeNode(newValue)) {
+            return this._subtype.reconcile(current, newValue, parent, subpath);
+        }
+        if (this._fallbackType.isAssignableFrom(current.type)) {
+            try {
+                return this._subtype.instantiate(parent, subpath, undefined, newValue);
+            }
+            catch (e) {
+                return this._fallbackType.reconcile(current, this._createFallbackSnapshot(e, newValue), parent, subpath);
+            }
+        }
+        try {
+            return this._subtype.reconcile(current, newValue, parent, subpath);
+        }
+        catch (e) {
+            current.die();
+            return this._instantiateFallback(parent, subpath, undefined, newValue, e);
+        }
+    }
+    isValidSnapshot(_value, _context) {
+        return typeCheckSuccess();
+    }
+    is(thing) {
+        if (isType(thing)) {
+            return (this._subtype.isAssignableFrom(thing) ||
+                this._fallbackType.isAssignableFrom(thing));
+        }
+        try {
+            if (this._subtype.is(thing)) {
+                return true;
+            }
+        }
+        catch (_e) {
+            // subtype.is() may throw (e.g. union dispatcher)
+        }
+        try {
+            return this._fallbackType.is(thing);
+        }
+        catch (_e) {
+            return false;
+        }
+    }
+    isAssignableFrom(type) {
+        return (this._subtype.isAssignableFrom(type) ||
+            this._fallbackType.isAssignableFrom(type));
+    }
+    getSubTypes() {
+        return [this._subtype, this._fallbackType];
+    }
+    getSnapshot(node) {
+        return node.snapshot;
+    }
+}
+/**
+ * `types.resilient` - Wraps a type so that instantiation errors are caught
+ * and a fallback type is used instead. This is useful for loading data that
+ * may contain unknown or invalid subtrees (e.g., plugin types that are not
+ * installed) without crashing the entire state tree.
+ *
+ * The `createFallbackSnapshot` callback receives the caught error and the
+ * original snapshot, and must return a valid snapshot for the fallback type.
+ *
+ * @param type The type to wrap.
+ * @param fallbackType The fallback type to use when instantiation fails.
+ * @param createFallbackSnapshot Callback that produces a fallback snapshot from the error and original snapshot.
+ * @returns A resilient type.
+ */
+function resilient(type, fallbackType, createFallbackSnapshot) {
+    assertIsType(type, 1);
+    assertIsType(fallbackType, 2);
+    return new Resilient(type, fallbackType, createFallbackSnapshot);
+}
+
 // we import the types to re-export them inside types.
 const types = {
     enumeration,
@@ -6483,7 +6782,8 @@ const types = {
     lazy,
     undefined: undefinedType,
     null: nullType,
-    snapshotProcessor
+    snapshotProcessor,
+    resilient
 };
 
 export { addDisposer, addMiddleware, applyAction, applyPatch, applySnapshot, cast, castFlowReturn, castToReferenceSnapshot, castToSnapshot, clone, createActionTrackingMiddleware, createActionTrackingMiddleware2, decorate, destroy, detach, escapeJsonPath, flow, getChildType, getEnv, getIdentifier, getLivelinessChecking, getMembers, getNodeId, getParent, getParentOfType, getPath, getPathParts, getPropertyMembers, getRelativePath, getRoot, getRunningActionContext, getSnapshot, getType, hasParent, hasParentOfType, isActionContextChildOf, isActionContextThisOrChildOf, isAlive, isArrayType, isFrozenType, isIdentifierType, isLateType, isLiteralType, isMapType, isModelType, isOptionalType, isPrimitiveType, isProtected, isReferenceType, isRefinementType, isRoot, isStateTreeNode, isType, isUnionType, isValidReference, joinJsonPath, onAction, onPatch, onSnapshot, process$1 as process, protect, recordActions, recordPatches, resolveIdentifier, resolvePath, setDevMode, setLivelinessChecking, setLivelynessChecking, splitJsonPath, types as t, toGenerator, toGeneratorFunction, tryReference, tryResolve, typecheck, types, unescapeJsonPath, unprotect, walk };