@jbrowse/core 5.0.0-beta.2 → 5.0.0-beta.4

package/esm/configuration/promotablePin.d.ts

@@ -1,55 +1,65 @@
 /**
- * #api core/configuration
- * The "apply this to every open track of this type" affordance on a menu row —
- * the trailing `PushPin`, bundled so the row consumes it as one prop. Built by
- * {@link makePin}.
+ * Shared by both pin kinds: which promotable slot the pin writes, whether it
+ * draws filled, and the one click it takes.
  *
- * `active` = this value is currently the session default (a filled pin), which
- * is the state, not the click. `toggle` **applies the value to every open track
- * of the display type** and raises a snackbar whose one action promotes it to
- * the display type's default; on an already-promoted value it clears that
- * default instead, touching no track (see `applyPinClick`).
+ * `slot` is here so a *built menu* can be asked which promotable slots it offers
+ * a pin for, which is the only way that question has an answer: declaring
+ * `promotedBase` is a schema fact and the pin is a menu fact, and a display that
+ * inherits the slot but never builds a row has a slot nothing can ever promote,
+ * silently (`promotableSlotsWithoutPin`, guarded by
+ * `products/jbrowse-web/src/tests/PromotablePinCoverage.test.ts`).
  *
  * **`toggle` rather than an `apply`/`clear` pair**, which was tried and dropped:
  * the sole renderer is a MUI `ToggleButton` whose `onChange` means exactly
  * "flip", so splitting it adds a member *and* a branch at the one call site that
- * never needed one. `active` is already public for a caller that wants to state a
- * direction. (The house preference for explicit setters over toggles is about MST
- * actions, where a toggle destroys the ability to set a known state; nothing here
- * stores a value.)
+ * never needed one. `active` is already public for a caller that wants to state
+ * a direction.
  *
  * Lives here, alone and with no imports, rather than beside `makePin` in
  * `promotableDefaults.ts`: the menu types describe a pin without building one,
- * and `MenuTypes.ts` taking this one interface from that module gave a
- * React-free type file a type closure of 374 files. See
- * `agent-docs/ideas/barrels-block-extraction.md` and `scripts/moduleClosure.ts`.
+ * and `MenuTypes.ts` taking this from that module gave a React-free type file a
+ * type closure of 374 files. See `agent-docs/ideas/barrels-block-extraction.md`
+ * and `scripts/moduleClosure.ts`.
  */
-export interface Pin {
-    /**
-     * The promotable slot this pin promotes a value of. Nothing in the UI reads
-     * it — a pin renders from `active`, `onValue` and the toggle. It is here so a
-     * *built menu* can be asked which promotable slots it offers a pin for, which
-     * is the only way that question has an answer: declaring `promotedBase` is a
-     * schema fact and the pin is a menu fact, and a display that inherits the slot
-     * but never builds a row has a slot nothing can ever promote, silently
-     * (`promotableSlotsWithoutPin`, guarded by
-     * `products/jbrowse-web/src/tests/PromotablePinCoverage.test.ts`).
-     */
+interface PinBase {
     slot: string;
-    /**
-     * The value `toggle` promotes — the on-value {@link makePin} was given, or the
-     * track's current resolved value for the value-omitted form.
-     *
-     * `PinAdornment` words itself from this, and has to: a **boolean** on-value
-     * promotes a *state*, so a row whose label names the setting rather than a
-     * value ("Show legend") gets a pin that promotes hiding the legend as often as
-     * showing it. Every other on-value IS what the row's label says — a radio
-     * option, a slider's current size — so those keep the value-shaped copy.
-     *
-     * Required, like `slot`: a pin that cannot say what it promotes is what let
-     * that copy state the opposite of what the click does.
-     */
+    /** what `toggle` writes into every open track of the display type */
     onValue: unknown;
     active: boolean;
     toggle: () => void;
 }
+/**
+ * #api core/configuration
+ * The pin on a radio or slider row, built by {@link makePin}: `onValue` is the
+ * row's own value, `active` means that value is the display type's promoted
+ * default, and `toggle` on an outline pin applies the value to every open track
+ * and offers it as the default, while on a filled pin it clears that default
+ * and touches no track (`applyAndOfferDefault` / `clearDefault`).
+ */
+export interface ValuePin extends PinBase {
+    kind: 'value';
+}
+/**
+ * #api core/configuration
+ * The pin on a checkbox row, built by {@link makeTogglePin}: the row's own
+ * checkbox over every open track of the display type. `active` mirrors the row,
+ * `onValue` is the state a click applies (the row's opposite), and `toggle`
+ * applies it everywhere and offers it as the default. It never clears a default
+ * on its own — promoting the slot's base value is what clears one.
+ */
+export interface TogglePin extends PinBase {
+    kind: 'toggle';
+}
+/**
+ * #api core/configuration
+ * The "apply this to every open track of this type" affordance on a menu row —
+ * the trailing `PushPin`, bundled so the row consumes it as one prop.
+ *
+ * `kind` is what the adornment words itself from and what the row builders
+ * check: a checkbox row takes a {@link TogglePin}, a radio or slider row a
+ * {@link ValuePin}. The two used to be told apart by `typeof onValue ===
+ * 'boolean'`, which let a value pin over a boolean slot compile and read as a
+ * toggle while clearing on its second click.
+ */
+export type Pin = ValuePin | TogglePin;
+export {};

package/esm/configuration/promotableResolve.d.ts

@@ -69,7 +69,7 @@ export declare function storedSlotValue(config: AnyConfigurationModel, slot: str
  * about a value a caller is about to offer as a pin's on-value.
  *
  * Exists because a pin built over a value the gate refuses is inert in a way
- * nothing reports: `applyPinClick` writes it to the session store happily,
+ * nothing reports: `applyAndOfferDefault` writes it to the session store happily,
  * `resolveSlotIn` then drops it and every track keeps resolving to the tier
  * below, and `isPromotableDefault` compares the *raw* stored value, so the pin
  * draws outline forever while a dead key sits in the user's localStorage. See

package/esm/configuration/promotableResolve.js

@@ -51,7 +51,7 @@ export function storedSlotValue(config, slot) {
  * about a value a caller is about to offer as a pin's on-value.
  *
  * Exists because a pin built over a value the gate refuses is inert in a way
- * nothing reports: `applyPinClick` writes it to the session store happily,
+ * nothing reports: `applyAndOfferDefault` writes it to the session store happily,
  * `resolveSlotIn` then drops it and every track keeps resolving to the tier
  * below, and `isPromotableDefault` compares the *raw* stored value, so the pin
  * draws outline forever while a dead key sits in the user's localStorage. See

package/esm/configuration/tabixIndexFields.d.ts

@@ -14,7 +14,7 @@
  *   two slots in the opposite order
  * - `PairwiseIndexedPAFAdapter`'s prose said `<file>.pif.gz.tbi` while its
  *   default said `my.paf.gz.tbi`
- * - `PlinkLDTabixAdapter` dropped the `(or .csi)` clause
+ * - `PlinkLDTabixAdapter`'s description dropped a clause the other eight carried
  * - the placeholder extensions disagreed with each other for no reason
  *
  * The description is written for every tabix adapter rather than naming one
@@ -39,6 +39,6 @@ export declare const tabixIndexFields: {
             readonly uri: '/path/to/my.gz.tbi';
             readonly locationType: 'UriLocation';
         };
-        readonly description: 'location of the tabix index. Only needed when it is not named `<file>.tbi` (or `.csi`), which is what the `uri` shorthand assumes.';
+        readonly description: 'location of the tabix index. Only needed when it is not named `<file>.tbi`, which is what the `uri` shorthand assumes — a `.csi` beside the file is reached with `csi: true` rather than by spelling this out.';
     };
 };

package/esm/configuration/tabixIndexFields.js

@@ -15,7 +15,7 @@ import { types } from '@jbrowse/mobx-state-tree';
  *   two slots in the opposite order
  * - `PairwiseIndexedPAFAdapter`'s prose said `<file>.pif.gz.tbi` while its
  *   default said `my.paf.gz.tbi`
- * - `PlinkLDTabixAdapter` dropped the `(or .csi)` clause
+ * - `PlinkLDTabixAdapter`'s description dropped a clause the other eight carried
  * - the placeholder extensions disagreed with each other for no reason
  *
  * The description is written for every tabix adapter rather than naming one
@@ -40,6 +40,6 @@ export const tabixIndexFields = {
             uri: '/path/to/my.gz.tbi',
             locationType: 'UriLocation',
         },
-        description: 'location of the tabix index. Only needed when it is not named `<file>.tbi` (or `.csi`), which is what the `uri` shorthand assumes.',
+        description: 'location of the tabix index. Only needed when it is not named `<file>.tbi`, which is what the `uri` shorthand assumes — a `.csi` beside the file is reached with `csi: true` rather than by spelling this out.',
     },
 };

package/esm/data_adapters/BaseAdapter/BaseFeatureDataAdapter.js

@@ -3,14 +3,9 @@ import { toArray } from 'rxjs/operators';
 import { createStatusFanOut } from '../../util/progress.js';
 import { blankStats, scoresToStats } from '../../util/stats.js';
 import { BaseAdapter } from './BaseAdapter.js';
+import { isSubAdapterConfig } from './featureDensity.js';
 import { aggregateQuantitativeStats } from './stats.js';
 import { isFeatureAdapter } from './util.js';
-function isAdapterConfigSnapshot(value) {
-    return (typeof value === 'object' &&
-        value !== null &&
-        'type' in value &&
-        typeof value.type === 'string');
-}
 /**
  * Base class for feature adapters to extend. Defines some methods that
  * subclasses must implement.
@@ -83,10 +78,7 @@ export class BaseFeatureDataAdapter extends BaseAdapter {
      * features over a region, primarily used for quantitative tracks
      */
     async getRegionQuantitativeStats(region, opts) {
-        const feats = this.getFeatures(region, {
-            ...opts,
-            statsEstimationMode: true,
-        });
+        const feats = this.getFeatures(region, opts);
         return scoresToStats(region, feats);
     }
     /**
@@ -127,11 +119,11 @@ export class BaseFeatureDataAdapter extends BaseAdapter {
      */
     async getFeatureDensity(regions, opts) {
         const sidecar = this.getConf(['densityAdapter']);
-        const resolved = isAdapterConfigSnapshot(sidecar) && this.getSubAdapter
+        const resolved = isSubAdapterConfig(sidecar) && this.getSubAdapter
             ? (await this.getSubAdapter(sidecar)).dataAdapter
             : undefined;
         if (resolved && !isFeatureAdapter(resolved)) {
-            throw new Error(`densityAdapter ${isAdapterConfigSnapshot(sidecar) ? sidecar.type : ''} is not a feature adapter`);
+            throw new Error(`densityAdapter ${isSubAdapterConfig(sidecar) ? sidecar.type : ''} is not a feature adapter`);
         }
         return resolved
             ? Promise.all(regions.map(async (region) => {

package/esm/data_adapters/BaseAdapter/featureDensity.d.ts

@@ -27,3 +27,15 @@ export declare const densityAdapterConfigSchemaFields: {
         readonly description: 'optional quantitative sub-adapter (e.g. a BigWigAdapter over a features-per-bin bigWig) drawn as a density band where the region is too large to fetch features; null disables it';
     };
 };
+/**
+ * Whether the `densityAdapter` slot holds something a sub-adapter can be built
+ * from. Beside the slot because both ends of the tier ask it and they have to
+ * agree: the display, deciding the band stands in, and `getFeatureDensity`,
+ * resolving the sidecar. They disagreed — the display took any object, the
+ * adapter wanted a type — so the shorthand every location slot accepts
+ * (`{ uri }`) turned the band on for a read that answered `undefined`, which
+ * commits nothing, and the phase then waited on bins no read would ever bring.
+ */
+export declare function isSubAdapterConfig(value: unknown): value is Record<string, unknown> & {
+    type: string;
+};

package/esm/data_adapters/BaseAdapter/featureDensity.js

@@ -15,3 +15,18 @@ export const densityAdapterConfigSchemaFields = {
         description: 'optional quantitative sub-adapter (e.g. a BigWigAdapter over a features-per-bin bigWig) drawn as a density band where the region is too large to fetch features; null disables it',
     },
 };
+/**
+ * Whether the `densityAdapter` slot holds something a sub-adapter can be built
+ * from. Beside the slot because both ends of the tier ask it and they have to
+ * agree: the display, deciding the band stands in, and `getFeatureDensity`,
+ * resolving the sidecar. They disagreed — the display took any object, the
+ * adapter wanted a type — so the shorthand every location slot accepts
+ * (`{ uri }`) turned the band on for a read that answered `undefined`, which
+ * commits nothing, and the phase then waited on bins no read would ever bring.
+ */
+export function isSubAdapterConfig(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'type' in value &&
+        typeof value.type === 'string');
+}

package/esm/data_adapters/BaseAdapter/index.d.ts

@@ -3,11 +3,11 @@ import type { AnyConfigurationModel } from '../../configuration/index.ts';
 import type { getSubAdapterType } from '../dataAdapterCache.ts';
 import type { AnyDataAdapter } from './util.ts';
 export { type AnyDataAdapter, isFeatureAdapter, isRefNameAliasAdapter, isRegionsAdapter, isSequenceAdapter, isTextSearchAdapter, } from './util.ts';
-export type { BaseOptions, BaseOptionsWithRegions, BaseTextSearchArgs, SearchType, } from './types.ts';
+export type { BaseOptions, BaseTextSearchArgs, LodTier, SearchType, } from './types.ts';
 export { BaseAdapter } from './BaseAdapter.ts';
 export { cachedSetup } from '../../util/cachedSetup.ts';
 export { BaseFeatureDataAdapter } from './BaseFeatureDataAdapter.ts';
-export { type FeatureDensity, densityAdapterConfigSchemaFields, } from './featureDensity.ts';
+export { type FeatureDensity, densityAdapterConfigSchemaFields, isSubAdapterConfig, } from './featureDensity.ts';
 export { BaseSequenceAdapter } from './BaseSequenceAdapter.ts';
 export type { BaseTextSearchAdapter } from './BaseTextSearchAdapter.ts';
 export type { Alias, BaseRefNameAliasAdapter, } from './BaseRefNameAliasAdapter.ts';

package/esm/data_adapters/BaseAdapter/index.js

@@ -2,5 +2,5 @@ export { isFeatureAdapter, isRefNameAliasAdapter, isRegionsAdapter, isSequenceAd
 export { BaseAdapter } from './BaseAdapter.js';
 export { cachedSetup } from '../../util/cachedSetup.js';
 export { BaseFeatureDataAdapter } from './BaseFeatureDataAdapter.js';
-export { densityAdapterConfigSchemaFields, } from './featureDensity.js';
+export { densityAdapterConfigSchemaFields, isSubAdapterConfig, } from './featureDensity.js';
 export { BaseSequenceAdapter } from './BaseSequenceAdapter.js';

package/esm/data_adapters/BaseAdapter/types.d.ts

@@ -1,23 +1,17 @@
 import type { StatusCallback } from '../../util/progress.ts';
 import type { StopToken } from '../../util/stopToken.ts';
-import type { Region } from '../../util/types/index.ts';
+export type LodTier = 'fine' | 'coarse';
 export interface BaseOptions {
     stopToken?: StopToken;
     bpPerPx?: number;
     sessionId?: string;
-    trackInstanceId?: string;
     signal?: AbortSignal;
     statusCallback?: StatusCallback;
     headers?: Record<string, string>;
-    statsEstimationMode?: boolean;
     assemblyName?: string;
-    targetAssemblyName?: string;
-    lodMode?: 'fine' | 'coarse';
+    lodMode?: LodTier;
     topLevelOnly?: boolean;
 }
-export interface BaseOptionsWithRegions extends BaseOptions {
-    regions?: Region[];
-}
 export type SearchType = 'full' | 'prefix' | 'exact';
 export interface BaseTextSearchArgs {
     queryString: string;

package/esm/pluggableElementTypes/AdapterType.d.ts

@@ -42,7 +42,7 @@ export default class AdapterType extends PluggableElementBase {
      * declaring the shorthand once gets both. It used to be a second, separate
      * registration, and five in-tree adapters had only the schema half
      * (`MafTabixAdapter`, `BgzipMafAdapter`, `BgzipTaffyAdapter`,
-     * `AllVsAllPAFAdapter`, `MCScanBlocksAdapter`) — which reads as working,
+     * `MultiGenomePAFAdapter`, `MCScanBlocksAdapter`) — which reads as working,
      * because loading such a config from a URL goes through the schema. Only
      * `normalizeAdapterSnapshots` consults *this*, so what broke was `localFiles`
      * in the embedded products: the shorthand stayed unexpanded, `uri` never
@@ -63,6 +63,7 @@ export default class AdapterType extends PluggableElementBase {
         name: string;
         configSchema: AnyConfigurationSchemaType;
         displayName?: string;
+        aliases?: string[];
         adapterCapabilities?: string[];
         adapterMetadata?: AdapterMetadata;
         normalizeSnapshot?: NormalizeSnapshot;

package/esm/pluggableElementTypes/AdapterType.js

@@ -17,7 +17,7 @@ export default class AdapterType extends PluggableElementBase {
      * declaring the shorthand once gets both. It used to be a second, separate
      * registration, and five in-tree adapters had only the schema half
      * (`MafTabixAdapter`, `BgzipMafAdapter`, `BgzipTaffyAdapter`,
-     * `AllVsAllPAFAdapter`, `MCScanBlocksAdapter`) — which reads as working,
+     * `MultiGenomePAFAdapter`, `MCScanBlocksAdapter`) — which reads as working,
      * because loading such a config from a URL goes through the schema. Only
      * `normalizeAdapterSnapshots` consults *this*, so what broke was `localFiles`
      * in the embedded products: the shorthand stayed unexpanded, `uri` never

package/esm/pluggableElementTypes/DisplayType.d.ts

@@ -1,13 +1,9 @@
-import PluggableElementBase from './PluggableElementBase.ts';
+import LazyStateModelElement from './LazyStateModelElement.ts';
 import type { AnyConfigurationSchemaType } from '../configuration/index.ts';
 import type { AnyReactComponentType } from '../util/index.ts';
 import type { IAnyModelType } from '@jbrowse/mobx-state-tree';
-export default class DisplayType extends PluggableElementBase {
-    private loadedStateModel?;
-    get stateModel(): IAnyModelType;
-    stateModelLoader?: () => Promise<IAnyModelType>;
-    private stateModelPromise?;
-    private pendingStateModelExtensions;
+export default class DisplayType extends LazyStateModelElement {
+    protected readonly group = "display";
     configSchema: AnyConfigurationSchemaType;
     ReactComponent: AnyReactComponentType;
     /**
@@ -33,7 +29,4 @@ export default class DisplayType extends PluggableElementBase {
         helpText?: string;
         aliases?: string[];
     });
-    get isStateModelLoaded(): boolean;
-    loadStateModel(): Promise<IAnyModelType>;
-    extendStateModel(extend: (stateModel: IAnyModelType) => IAnyModelType): void;
 }

package/esm/pluggableElementTypes/DisplayType.js

@@ -1,13 +1,6 @@
-import PluggableElementBase from './PluggableElementBase.js';
-export default class DisplayType extends PluggableElementBase {
-    loadedStateModel;
-    // same contract as ViewType.stateModel
-    get stateModel() {
-        return this.loadedStateModel;
-    }
-    stateModelLoader;
-    stateModelPromise;
-    pendingStateModelExtensions = [];
+import LazyStateModelElement from './LazyStateModelElement.js';
+export default class DisplayType extends LazyStateModelElement {
+    group = 'display';
     configSchema;
     ReactComponent;
     /**
@@ -24,45 +17,10 @@ export default class DisplayType extends PluggableElementBase {
     helpText;
     constructor(stuff) {
         super(stuff);
-        if (typeof stuff.stateModel === 'function') {
-            this.stateModelLoader = stuff.stateModel;
-        }
-        else {
-            this.loadedStateModel = stuff.stateModel;
-        }
         this.configSchema = stuff.configSchema;
         this.ReactComponent = stuff.ReactComponent;
         this.trackType = stuff.trackType;
         this.viewType = stuff.viewType;
         this.helpText = stuff.helpText;
     }
-    get isStateModelLoaded() {
-        return this.loadedStateModel !== undefined;
-    }
-    loadStateModel() {
-        if (this.loadedStateModel !== undefined) {
-            return Promise.resolve(this.loadedStateModel);
-        }
-        if (!this.stateModelLoader) {
-            throw new Error(`display type ${this.name} has neither a state model nor a loader`);
-        }
-        this.stateModelPromise ??= this.stateModelLoader().then(loaded => {
-            let stateModel = loaded;
-            for (const extend of this.pendingStateModelExtensions) {
-                stateModel = extend(stateModel);
-            }
-            this.pendingStateModelExtensions = [];
-            this.loadedStateModel = stateModel;
-            return stateModel;
-        });
-        return this.stateModelPromise;
-    }
-    extendStateModel(extend) {
-        if (this.loadedStateModel !== undefined) {
-            this.loadedStateModel = extend(this.loadedStateModel);
-        }
-        else {
-            this.pendingStateModelExtensions.push(extend);
-        }
-    }
 }

package/esm/pluggableElementTypes/LazyStateModelElement.d.ts

@@ -0,0 +1,27 @@
+import PluggableElementBase from './PluggableElementBase.ts';
+import type { IAnyModelType } from '@jbrowse/mobx-state-tree';
+/**
+ * A pluggable element whose state model may arrive through a dynamic import.
+ * Code that can run before any instance exists — session preloading, pruning,
+ * union membership — checks `isStateModelLoaded` before reading `stateModel`.
+ */
+export default abstract class LazyStateModelElement extends PluggableElementBase {
+    protected abstract readonly group: 'view' | 'display';
+    private loadedStateModel?;
+    private stateModelPromise?;
+    private pendingStateModelExtensions;
+    stateModelLoader?: () => Promise<IAnyModelType>;
+    onStateModelLoaded?: () => void;
+    constructor(stuff: {
+        name: string;
+        displayName?: string;
+        aliases?: string[];
+        stateModel: IAnyModelType | (() => Promise<IAnyModelType>);
+    });
+    get stateModel(): IAnyModelType;
+    set stateModel(stateModel: IAnyModelType);
+    get isStateModelLoaded(): boolean;
+    assertStateModelLoaded(): void;
+    loadStateModel(): Promise<IAnyModelType>;
+    extendStateModel(extend: (stateModel: IAnyModelType) => IAnyModelType): void;
+}

package/esm/pluggableElementTypes/LazyStateModelElement.js

@@ -0,0 +1,71 @@
+import PluggableElementBase from './PluggableElementBase.js';
+/**
+ * A pluggable element whose state model may arrive through a dynamic import.
+ * Code that can run before any instance exists — session preloading, pruning,
+ * union membership — checks `isStateModelLoaded` before reading `stateModel`.
+ */
+export default class LazyStateModelElement extends PluggableElementBase {
+    loadedStateModel;
+    stateModelPromise;
+    pendingStateModelExtensions = [];
+    // named `stateModel` + `Loader` because pluggableMstType probes
+    // `${fieldName}Loader` generically
+    stateModelLoader;
+    // set by PluginManager.addElementType: runs Core-extendPluggableElement once
+    // the loader resolves, so a callback reading `stateModel` sees a model
+    onStateModelLoaded;
+    constructor(stuff) {
+        super(stuff);
+        if (typeof stuff.stateModel === 'function') {
+            this.stateModelLoader = stuff.stateModel;
+        }
+        else {
+            this.loadedStateModel = stuff.stateModel;
+        }
+    }
+    // Throws before the loader resolves, so a plugin composing an unloaded
+    // model fails here rather than as an opaque MST error.
+    get stateModel() {
+        this.assertStateModelLoaded();
+        return this.loadedStateModel;
+    }
+    set stateModel(stateModel) {
+        this.loadedStateModel = stateModel;
+    }
+    get isStateModelLoaded() {
+        return this.loadedStateModel !== undefined;
+    }
+    assertStateModelLoaded() {
+        if (this.loadedStateModel === undefined) {
+            const getter = this.group === 'view' ? 'getViewType' : 'getDisplayType';
+            throw new Error(`state model for ${this.group} type ${this.name} is not loaded yet — await ${getter}('${this.name}').loadStateModel() first`);
+        }
+    }
+    loadStateModel() {
+        if (this.loadedStateModel !== undefined) {
+            return Promise.resolve(this.loadedStateModel);
+        }
+        if (!this.stateModelLoader) {
+            throw new Error(`${this.group} type ${this.name} has neither a state model nor a loader`);
+        }
+        this.stateModelPromise ??= this.stateModelLoader().then(loaded => {
+            let stateModel = loaded;
+            for (const extend of this.pendingStateModelExtensions) {
+                stateModel = extend(stateModel);
+            }
+            this.pendingStateModelExtensions = [];
+            this.loadedStateModel = stateModel;
+            this.onStateModelLoaded?.();
+            return this.stateModel;
+        });
+        return this.stateModelPromise;
+    }
+    extendStateModel(extend) {
+        if (this.loadedStateModel !== undefined) {
+            this.loadedStateModel = extend(this.loadedStateModel);
+        }
+        else {
+            this.pendingStateModelExtensions.push(extend);
+        }
+    }
+}

package/esm/pluggableElementTypes/ViewType.d.ts

@@ -1,4 +1,4 @@
-import PluggableElementBase from './PluggableElementBase.ts';
+import LazyStateModelElement from './LazyStateModelElement.ts';
 import type { LaunchKeyRegistration } from '../util/withLaunchInput.ts';
 import type DisplayType from './DisplayType.ts';
 import type { IAnyModelType, IAnyStateTreeNode } from '@jbrowse/mobx-state-tree';
@@ -11,13 +11,9 @@ type ViewComponentType = React.LazyExoticComponent<BasicView> | BasicView;
 interface ViewMetadata {
     hiddenFromGUI?: boolean;
 }
-export default class ViewType extends PluggableElementBase {
+export default class ViewType extends LazyStateModelElement {
+    protected readonly group = "view";
     ReactComponent: ViewComponentType;
-    private loadedStateModel?;
-    get stateModel(): IAnyModelType;
-    stateModelLoader?: () => Promise<IAnyModelType>;
-    private stateModelPromise?;
-    private pendingStateModelExtensions;
     launchKeys?: LaunchKeyRegistration<unknown, string>;
     displayTypes: DisplayType[];
     viewMetadata: ViewMetadata;
@@ -45,9 +41,6 @@ export default class ViewType extends PluggableElementBase {
      * a session spec launches straight through `LaunchView-<type>`.
      */
     get acceptedKeys(): string[] | undefined;
-    get isStateModelLoaded(): boolean;
-    loadStateModel(): Promise<IAnyModelType>;
-    extendStateModel(extend: (stateModel: IAnyModelType) => IAnyModelType): void;
     addDisplayType(display: DisplayType): void;
 }
 export {};

package/esm/pluggableElementTypes/ViewType.js

@@ -1,19 +1,7 @@
-import PluggableElementBase from './PluggableElementBase.js';
-export default class ViewType extends PluggableElementBase {
+import LazyStateModelElement from './LazyStateModelElement.js';
+export default class ViewType extends LazyStateModelElement {
+    group = 'view';
     ReactComponent;
-    loadedStateModel;
-    // Non-optional because nearly every reader holds a view instance, which
-    // implies the model is loaded; code that can run before any instance exists
-    // (session preloading, pruning, union membership) must check
-    // isStateModelLoaded first.
-    get stateModel() {
-        return this.loadedStateModel;
-    }
-    // named `stateModel` + `Loader` because pluggableMstType and
-    // pruneUnbuildableNodes probe `${fieldName}Loader` generically
-    stateModelLoader;
-    stateModelPromise;
-    pendingStateModelExtensions = [];
     // What `withLaunchInput` partitioned out of this view's snapshots, published
     // beside the model so an out-of-tree plugin, the doc generator and the
     // validator read one declaration rather than each keeping a list.
@@ -32,12 +20,6 @@ export default class ViewType extends PluggableElementBase {
         super(stuff);
         this.ReactComponent = stuff.ReactComponent;
         this.viewMetadata = stuff.viewMetadata ?? {};
-        if (typeof stuff.stateModel === 'function') {
-            this.stateModelLoader = stuff.stateModel;
-        }
-        else {
-            this.loadedStateModel = stuff.stateModel;
-        }
         this.launchKeys = stuff.launchKeys;
         this.extendedName = stuff.extendedName;
     }
@@ -54,7 +36,9 @@ export default class ViewType extends PluggableElementBase {
      * a session spec launches straight through `LaunchView-<type>`.
      */
     get acceptedKeys() {
-        const properties = this.loadedStateModel?.properties;
+        const properties = this.isStateModelLoaded
+            ? this.stateModel.properties
+            : undefined;
         return this.launchKeys && properties
             ? [
                 ...Object.keys(properties),
@@ -63,35 +47,6 @@ export default class ViewType extends PluggableElementBase {
             ]
             : undefined;
     }
-    get isStateModelLoaded() {
-        return this.loadedStateModel !== undefined;
-    }
-    loadStateModel() {
-        if (this.loadedStateModel !== undefined) {
-            return Promise.resolve(this.loadedStateModel);
-        }
-        if (!this.stateModelLoader) {
-            throw new Error(`view type ${this.name} has neither a state model nor a loader`);
-        }
-        this.stateModelPromise ??= this.stateModelLoader().then(loaded => {
-            let stateModel = loaded;
-            for (const extend of this.pendingStateModelExtensions) {
-                stateModel = extend(stateModel);
-            }
-            this.pendingStateModelExtensions = [];
-            this.loadedStateModel = stateModel;
-            return stateModel;
-        });
-        return this.stateModelPromise;
-    }
-    extendStateModel(extend) {
-        if (this.loadedStateModel !== undefined) {
-            this.loadedStateModel = extend(this.loadedStateModel);
-        }
-        else {
-            this.pendingStateModelExtensions.push(extend);
-        }
-    }
     addDisplayType(display) {
         this.displayTypes.push(display);
     }

package/esm/pluggableElementTypes/extendElementType.d.ts

@@ -5,8 +5,7 @@ import type { IAnyModelType } from '@jbrowse/mobx-state-tree';
  * Replace a view type's state model with an extended one, e.g. to add a menu
  * item to `LinearGenomeView`. Pass an array to extend several at once, which is
  * how a contribution reaches a family: the tree spells a display family as a
- * shared mixin set rather than a chain, so there is no parent to name — see
- * `reference/REJECTED_IDEAS.md`, "Give a pluggable element an `extendsType`".
+ * shared mixin set rather than a chain, so there is no parent to name, which is why an `extendsType` was declined.
  *
  * `Core-extendPluggableElement` fires for every pluggable element there is —
  * adapters, widgets, RPC methods, all of them — so a callback written against

package/esm/pluggableElementTypes/extendElementType.js

@@ -14,8 +14,7 @@ function namesOf(name) {
  * Replace a view type's state model with an extended one, e.g. to add a menu
  * item to `LinearGenomeView`. Pass an array to extend several at once, which is
  * how a contribution reaches a family: the tree spells a display family as a
- * shared mixin set rather than a chain, so there is no parent to name — see
- * `reference/REJECTED_IDEAS.md`, "Give a pluggable element an `extendsType`".
+ * shared mixin set rather than a chain, so there is no parent to name, which is why an `extendsType` was declined.
  *
  * `Core-extendPluggableElement` fires for every pluggable element there is —
  * adapters, widgets, RPC methods, all of them — so a callback written against