@jbrowse/mobx-state-tree 5.9.2 → 5.10.0

package/dist/mobx-state-tree.mjs

@@ -2699,16 +2699,27 @@ function typecheck(type, value) {
     }
 }
 const MAX_ERRORS_REPORTED = 10;
-function validationErrorsToString(type, value, errors) {
-    if (errors.length === 0) {
-        return undefined;
-    }
+/**
+ * @internal
+ * @hidden
+ * Format a list of validation errors as bullet-style lines, capped at
+ * MAX_ERRORS_REPORTED entries with an overflow suffix. Shared by typecheck()
+ * and union's `noMatchMessage` so prod-build union failures can include
+ * candidate validation errors using the same formatting.
+ */
+function formatValidationErrorLines(errors) {
     const shown = errors.slice(0, MAX_ERRORS_REPORTED).map(toErrorString);
     const overflow = errors.length - shown.length;
     if (overflow > 0) {
         shown.push(`(… and ${overflow} more error${overflow === 1 ? "" : "s"})`);
     }
-    return (`Error while converting ${shortenPrintValue(prettyPrintValue(value))} to \`${type.name}\`:\n\n    ` + shown.join("\n    "));
+    return shown;
+}
+function validationErrorsToString(type, value, errors) {
+    if (errors.length === 0) {
+        return undefined;
+    }
+    return (`Error while converting ${shortenPrintValue(prettyPrintValue(value))} to \`${type.name}\`:\n\n    ` + formatValidationErrorLines(errors).join("\n    "));
 }
 
 let identifierCacheId = 0;
@@ -5389,6 +5400,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
@@ -5438,10 +5468,74 @@ class Union extends BaseType {
         return type.reconcile(current, newValue, parent, subpath);
     }
     noMatchMessage(value) {
-        const discriminator = isPlainObject(value) && typeof value.type === "string"
-            ? ` for snapshot with type "${value.type}"`
-            : "";
-        return `No matching type for union ${this.name}${discriminator}`;
+        const base = `No matching type for union ${this.name}`;
+        if (!isPlainObject(value)) {
+            return base;
+        }
+        const discriminator = value.type;
+        if (typeof discriminator !== "string") {
+            return base;
+        }
+        const baseWithDiscriminator = `${base} for snapshot with type "${discriminator}"`;
+        // If exactly one union member has a literal `type` property matching the
+        // snapshot's discriminator, run its validate() so we can append the
+        // property-level reasons it didn't match. This converts the bare prod-build
+        // "no matching type" into something diagnosable (e.g. which field was the
+        // wrong type, which required field was missing) without re-bloating the
+        // message back to every-member's full describe() output.
+        const candidate = this._findCandidateByTypeDiscriminator(discriminator);
+        if (!candidate) {
+            return baseWithDiscriminator;
+        }
+        const errors = candidate.validate(value, [
+            { path: "", type: candidate }
+        ]);
+        if (errors.length === 0) {
+            return baseWithDiscriminator;
+        }
+        return (`${baseWithDiscriminator}:\n    ` +
+            formatValidationErrorLines(errors).join("\n    "));
+    }
+    _findCandidateByTypeDiscriminator(discriminator) {
+        let found;
+        for (const t of this._types) {
+            const model = resolveModelType(t);
+            if (!model) {
+                continue;
+            }
+            const typeProp = model.properties.type;
+            if (!typeProp ||
+                !(typeProp.flags & TypeFlags.Literal) ||
+                !typeProp.is(discriminator)) {
+                continue;
+            }
+            if (found) {
+                // Ambiguous (two members declare the same `type` literal). Fall back
+                // 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
@@ -5530,11 +5624,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];
@@ -5561,6 +5658,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