@jbrowse/mobx-state-tree 5.9.2 → 5.10.0

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;
@@ -5391,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
@@ -5440,10 +5470,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
@@ -5532,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];
@@ -5563,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