@jbrowse/mobx-state-tree 5.9.1 → 5.9.3

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;
@@ -5438,10 +5449,55 @@ 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) {
+            if (!(t instanceof ModelType)) {
+                continue;
+            }
+            const typeProp = t.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;
+            }
+            found = t;
+        }
+        return found;
     }
     determineType(value, reconcileCurrentType) {
         // try the dispatcher, if defined