@jbrowse/mobx-state-tree 6.4.0 → 6.5.0

package/dist/mobx-state-tree.mjs

@@ -5723,7 +5723,7 @@ class Union extends BaseType {
             return cached;
         }
         let result = TypeFlags.Union;
-        for (const type of this._types) {
+        for (const type of this.members()) {
             result |= type.flags;
         }
         if (!(result & TypeFlags.Late)) {
@@ -5732,12 +5732,14 @@ class Union extends BaseType {
         return result;
     }
     computeName() {
-        return `(${this._types.map(type => type.name).join(" | ")})`;
+        return `(${this.members()
+            .map(type => type.name)
+            .join(" | ")})`;
     }
     constructor(_types, options) {
         super();
         this._types = _types;
-        // read the two options directly rather than spreading defaults into a fresh
+        // read the options directly rather than spreading defaults into a fresh
         // object: this constructor runs once per config slot in jbrowse, and the
         // merged object was allocated only to be read twice and dropped
         if (options !== undefined) {
@@ -5747,13 +5749,23 @@ class Union extends BaseType {
             if (options.eager === false) {
                 this._eager = false;
             }
+            if (options.name !== undefined) {
+                this.name = options.name;
+            }
         }
     }
+    // The one point membership is read through, so DynamicUnion can substitute
+    // its thunk without duplicating any of the scanning logic below.
+    members() {
+        return this._types;
+    }
     isAssignableFrom(type) {
-        return this._types.some(subType => subType.isAssignableFrom(type));
+        return this.members().some(subType => subType.isAssignableFrom(type));
     }
     describe() {
-        return `(${this._types.map(factory => factory.describe()).join(" | ")})`;
+        return `(${this.members()
+            .map(factory => factory.describe())
+            .join(" | ")})`;
     }
     instantiate(parent, subpath, environment, initialValue) {
         const type = this.determineType(initialValue, undefined);
@@ -5808,7 +5820,7 @@ class Union extends BaseType {
     }
     _scanForTypeDiscriminator(discriminator) {
         let found;
-        for (const t of this._types) {
+        for (const t of this.members()) {
             const model = resolveModelType(t);
             if (!model) {
                 continue;
@@ -5833,15 +5845,18 @@ class Union extends BaseType {
     }
     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;
-            });
+            this._allMembersDiscriminated = this.computeAllMembersDiscriminated();
         }
         return this._allMembersDiscriminated;
     }
+    computeAllMembersDiscriminated() {
+        return this.members().every(t => {
+            const model = resolveModelType(t);
+            const typeProp = model &&
+                model.properties["type"];
+            return !!typeProp && (typeProp.flags & TypeFlags.Literal) !== 0;
+        });
+    }
     determineType(value, reconcileCurrentType) {
         // try the dispatcher, if defined
         if (this._dispatcher) {
@@ -5862,9 +5877,9 @@ class Union extends BaseType {
             if (reconcileCurrentType.is(value)) {
                 return reconcileCurrentType;
             }
-            return this._types.find(type => type !== reconcileCurrentType && type.is(value));
+            return this.members().find(type => type !== reconcileCurrentType && type.is(value));
         }
-        return this._types.find(type => type.is(value));
+        return this.members().find(type => type.is(value));
     }
     tryQuickMatch(value, reconcileCurrentType) {
         // state tree nodes need full type compatibility checking
@@ -5884,7 +5899,7 @@ class Union extends BaseType {
             this.snapshotLooksLikeType(value, reconcileCurrentType)) {
             return reconcileCurrentType;
         }
-        for (const type of this._types) {
+        for (const type of this.members()) {
             if (type !== reconcileCurrentType &&
                 this.snapshotLooksLikeType(value, type)) {
                 return type;
@@ -5894,7 +5909,7 @@ class Union extends BaseType {
     }
     tryMatchPrimitive(value) {
         const valueType = typeof value;
-        for (const type of this._types) {
+        for (const type of this.members()) {
             const flags = type.flags;
             if ((valueType === "string" && flags & TypeFlags.String) ||
                 (valueType === "number" &&
@@ -5981,10 +5996,11 @@ class Union extends BaseType {
         // 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
+        const members = this.members();
         const candidates = isSnapshotObject
-            ? this._types.filter(t => this.snapshotLooksLikeType(value, t))
+            ? members.filter(t => this.snapshotLooksLikeType(value, t))
             : [];
-        const typesToValidate = candidates.length > 0 ? candidates : this._types;
+        const typesToValidate = candidates.length > 0 ? candidates : members;
         const allErrors = [];
         let applicableTypes = 0;
         for (const type of typesToValidate) {
@@ -6007,7 +6023,7 @@ class Union extends BaseType {
         return typeCheckFailure(context, value, "No type is applicable for the union").concat(allErrors.flat());
     }
     getSubTypes() {
-        return this._types;
+        return this.members();
     }
 }
 // Defaults shared by every union; see the field declarations at the top of the
@@ -6018,6 +6034,56 @@ Object.assign(Union.prototype, {
     _discriminatorCache: undefined,
     _allMembersDiscriminated: undefined
 });
+/**
+ * @internal
+ * @hidden
+ *
+ * A union whose membership is read fresh from a thunk on every operation, so
+ * members that come into existence after the union was built — a registry of
+ * pluggable types whose modules load on demand — still dispatch, validate, and
+ * satisfy references. That last one is the reason this exists: reference
+ * resolution asks the target type `isAssignableFrom(node.type)` through the
+ * identifier cache, and a membership list frozen at construction would reject
+ * every late-loaded member's instances.
+ *
+ * Every membership-derived cache the base class keeps is bypassed here: flags
+ * and the folded name are recomputed per read, and the discriminator scan is
+ * uncached so a miss stays retryable once the missing member registers. A hit
+ * for a given discriminator is assumed stable — registering two members with
+ * the same `type` literal at different times can leave a stale unambiguous
+ * answer where the base class would have reported ambiguity.
+ */
+class DynamicUnion extends Union {
+    _members;
+    constructor(members, options) {
+        super([], options);
+        this._members = members;
+    }
+    members() {
+        return this._members();
+    }
+    get flags() {
+        let result = TypeFlags.Union;
+        for (const type of this.members()) {
+            result |= type.flags;
+        }
+        return result;
+    }
+    get name() {
+        return this._explicitName !== undefined
+            ? this._explicitName
+            : this.computeName();
+    }
+    set name(value) {
+        this._explicitName = value;
+    }
+    _findCandidateByTypeDiscriminator(discriminator) {
+        return this._scanForTypeDiscriminator(discriminator);
+    }
+    allMembersDiscriminated() {
+        return this.computeAllMembersDiscriminated();
+    }
+}
 const unionInternRoot = {};
 function internUnion(types) {
     let node = unionInternRoot;
@@ -6037,6 +6103,13 @@ function internUnion(types) {
 /**
  * `types.union` - Create a union of multiple types. If the correct type cannot be inferred unambiguously from a snapshot, provide a dispatcher function of the form `(snapshot) => Type`.
  *
+ * Passing `members: () => Type[]` in the options (with no positional member
+ * types) creates a union whose membership is re-read from the thunk on every
+ * operation, so types registered after construction — e.g. from a lazily
+ * loaded module — participate in dispatch, validation and reference
+ * resolution. Pair it with a `dispatcher` for snapshot dispatch and a `name`
+ * for stable error messages.
+ *
  * @param optionsOrType
  * @param otherTypes
  * @returns
@@ -6056,12 +6129,18 @@ function union(...args) {
     // check all options
     if (devMode()) {
         if (options) {
-            assertArg(options, o => isPlainObject(o), "object { eager?: boolean, dispatcher?: Function }", 1);
+            assertArg(options, o => isPlainObject(o), "object { eager?: boolean, dispatcher?: Function, members?: Function, name?: string }", 1);
         }
         types.forEach((type, i) => {
             assertIsType(type, options ? i + 2 : i + 1);
         });
     }
+    if (options?.members !== undefined) {
+        if (types.length > 0) {
+            throw fail("union(): the members option cannot be combined with positional member types");
+        }
+        return new DynamicUnion(options.members, options);
+    }
     return options === undefined ? internUnion(types) : new Union(types, options);
 }
 /**
@@ -6646,6 +6725,13 @@ class Lazy extends SimpleType {
     }
     reconcile(current, value, parent, subpath) {
         if (this.loadedType) {
+            // a node created after load carries the loaded type: let it reconcile so
+            // the instance survives applySnapshot instead of dying on every write
+            const loaded = this.loadedType;
+            const currentType = current.type;
+            if (currentType === loaded) {
+                return this.loadedType.reconcile(current, value, parent, subpath);
+            }
             current.die();
             return this.loadedType.instantiate(parent, subpath, parent.environment, value);
         }