@jbrowse/mobx-state-tree 5.9.3 → 5.10.1

package/dist/index.d.ts

@@ -1501,6 +1501,8 @@ declare function snapshotProcessor<IT extends IAnyType, CustomC = _NotCustomized
 /** @hidden */
 interface IMapType<IT extends IAnyType> extends IType<IKeyValueMap<IT["CreationType"]> | undefined, IKeyValueMap<IT["SnapshotType"]>, IMSTMap<IT>> {
     hooks(hooks: IHooksGetter<IMSTMap<IT>>): IMapType<IT>;
+    /** the value type of the map */
+    getChildType(): IAnyType;
 }
 /** @hidden */
 interface IMSTMap<IT extends IAnyType> {
@@ -1583,6 +1585,8 @@ interface IMSTArray<IT extends IAnyType> extends IObservableArray<IT["Type"]> {
 /** @hidden */
 interface IArrayType<IT extends IAnyType> extends IType<readonly IT["CreationType"][] | undefined, IT["SnapshotType"][], IMSTArray<IT>> {
     hooks(hooks: IHooksGetter<IMSTArray<IAnyType>>): IArrayType<IT>;
+    /** the element type of the array */
+    getChildType(): IAnyType;
 }
 /**
  * `types.array` - Creates an index based collection type who's children are all of a uniform declared type.

package/dist/mobx-state-tree.cjs

@@ -5402,6 +5402,25 @@ function enumeration(name, options) {
     return type;
 }
 
+// Drill through single-subtype wrappers — optional(), refinement(),
+// snapshotProcessor(), late() — to the underlying ModelType. Discriminated-
+// union scoping keys on a member's literal `type` property, but real-world
+// members are rarely bare models (jbrowse config schemas, for instance, are
+// always optional(model) or optional(snapshotProcessor(model))). Without this
+// the scoping never engages and every failure prints every member's full
+// structure. Wrappers expose their child as `_subtype` (optional/refinement/
+// snapshotProcessor) or via `getSubType()` (late); bounded to avoid cycles.
+function resolveModelType(type) {
+    let current = type;
+    for (let depth = 0; current && depth < 20; depth++) {
+        if (current instanceof ModelType) {
+            return current;
+        }
+        const wrapper = current;
+        current = wrapper._subtype ?? wrapper.getSubType?.(false);
+    }
+    return undefined;
+}
 /**
  * @internal
  * @hidden
@@ -5482,11 +5501,11 @@ class Union extends BaseType {
     _findCandidateByTypeDiscriminator(discriminator) {
         let found;
         for (const t of this._types) {
-            if (!(t instanceof ModelType)) {
+            const model = resolveModelType(t);
+            if (!model) {
                 continue;
             }
-            const typeProp = t.properties
-                .type;
+            const typeProp = model.properties.type;
             if (!typeProp ||
                 !(typeProp.flags & TypeFlags.Literal) ||
                 !typeProp.is(discriminator)) {
@@ -5497,10 +5516,29 @@ class Union extends BaseType {
                 // to the short message rather than picking arbitrarily.
                 return undefined;
             }
+            // Return the original (possibly wrapped) member, not the unwrapped
+            // model, so validate()/is() still apply optional defaults and any
+            // snapshotProcessor pre-processing.
             found = t;
         }
         return found;
     }
+    // True when every member resolves to a model carrying a literal `type`
+    // discriminator — i.e. a fully discriminated union, where a snapshot's `type`
+    // uniquely identifies the intended member and no untagged catch-all member
+    // could also accept it. Cached: membership is fixed at construction.
+    _allMembersDiscriminated;
+    allMembersDiscriminated() {
+        if (this._allMembersDiscriminated === undefined) {
+            this._allMembersDiscriminated = this._types.every(t => {
+                const model = resolveModelType(t);
+                const typeProp = model &&
+                    model.properties.type;
+                return !!typeProp && (typeProp.flags & TypeFlags.Literal) !== 0;
+            });
+        }
+        return this._allMembersDiscriminated;
+    }
     determineType(value, reconcileCurrentType) {
         // try the dispatcher, if defined
         if (this._dispatcher) {
@@ -5588,11 +5626,14 @@ class Union extends BaseType {
     }
     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;
+        // and that any literal-typed properties match exactly. Unwrap optional() /
+        // snapshotProcessor() / refinement() / late() so wrapped members (e.g.
+        // jbrowse config schemas, which are always optional(model)) still match.
+        const model = resolveModelType(type);
+        if (model) {
+            const props = model.properties;
             // use cached propertyNames from ModelType instead of Object.keys()
-            for (const key of type.propertyNames) {
+            for (const key of model.propertyNames) {
                 const propType = props[key];
                 const isOptional = propType.flags & TypeFlags.Optional;
                 const propValue = value[key];
@@ -5619,6 +5660,28 @@ class Union extends BaseType {
         if (this._dispatcher) {
             return this._dispatcher(value).validate(value, context);
         }
+        // For plain-object snapshots carrying a `type` discriminator, validate only
+        // the single member whose literal `type` matches.
+        // - Clean validation short-circuits to success only when it is sound to skip
+        //   the other members: an eager union (first match wins) or a fully
+        //   discriminated one (no untagged catch-all could also match). A non-eager
+        //   union with a catch-all must still fall through so ambiguity is counted.
+        // - A failure is the definitive, scoped error only when every member is
+        //   discriminated; otherwise a catch-all could still accept the value, so
+        //   fall through to full validation.
+        if (isPlainObject(value) && !isStateTreeNode(value)) {
+            const discriminator = value.type;
+            if (typeof discriminator === "string") {
+                const candidate = this._findCandidateByTypeDiscriminator(discriminator);
+                if (candidate) {
+                    const errors = candidate.validate(value, context);
+                    const cleanAndUnique = errors.length === 0 && this._eager;
+                    if (cleanAndUnique || this.allMembersDiscriminated()) {
+                        return errors;
+                    }
+                }
+            }
+        }
         // for plain-object snapshots, prefer union members whose literal-typed
         // discriminator properties match the value (e.g. {type: "MsaView"})
         // so error output is scoped to the intended branch instead of every member