@jbrowse/mobx-state-tree 5.9.1 → 5.9.3

package/README.md

@@ -7,12 +7,11 @@ Fork of mobx-state-tree v5.4.2 for use in jbrowse
 - updated typescript
 - updated to import actual filepaths instead of node module resolution
 - reduced rollup config
-- tried tsdown but builds were very slow for some reason
 - removed process.env.NODE_ENV from code, instead exporting a setDevMode function
 - converted tests to vitest
 - remove unused dependencies
 - updated tslint to eslint and typescript-eslint
-- attempted to make it a dual CJS/'pure ESM' package but did not work quite yet, using main (CJS) and module (ESM-ish) fields for now since dual build causes trouble with both being imported in vite
+- dual CJS/ESM build using main and module fields (pure ESM causes trouble when both are imported in vite)
 - added `types.resilient` - wraps a type so that instantiation errors are caught
   and a fallback type is used instead of crashing the entire state tree. This is
   useful for arrays or maps that may contain unknown or invalid entries (e.g.
@@ -22,3 +21,6 @@ Fork of mobx-state-tree v5.4.2 for use in jbrowse
   meaning any value is considered a valid snapshot. Validation is deferred to
   instantiation time, where failures are caught and routed to the fallback
 - removed NonEmptyObject annotation (also at upstream in post v5 versions)
+- replaced `unique symbol` phantom properties (`$emptyObject`, `$stateTreeNodeType`) with
+  exported string-keyed brand interfaces (`$EmptyObjectBrand`, `$__mstStateTreeNodeType__`),
+  fixing tsgo TS4058/TS4023 errors when MST types propagate into exported function return types

package/dist/mobx-state-tree.cjs

@@ -2701,16 +2701,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;
@@ -5440,10 +5451,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