@jbrowse/core 5.0.0-beta.7 → 5.0.0-beta.9

package/esm/pluggableElementTypes/models/baseConnectionConfig.d.ts

@@ -1,30 +1,34 @@
 import type { Instance } from '@jbrowse/mobx-state-tree';
 /**
  * #config BaseConnection
- * #gotcha A connection config is only a pointer: the hub's track list is
- * fetched when the connection loads and held in memory, and is **not** written
- * into a saved or shared session. Only a track you actually open is stored
- * (under `connectionTrackConfigs`, keyed by `trackId`), which is what keeps a
- * shared session small even against a very large hub.
+ * #gotcha JBrowse fetches the hub's track list when the connection loads and
+ * holds it in memory, and does **not** write it into a saved or shared session.
+ * The session stores only the tracks you open (under `connectionTrackConfigs`,
+ * keyed by `trackId`), so a shared session stays small even for a very large
+ * hub.
  */
 declare const BaseConnectionConfig: import("../../configuration/configurationSchema.ts").ConfigurationSchemaType<{
-    /**
-     * #slot
-     */
     readonly name: {
-        readonly type: "string";
-        readonly defaultValue: "nameOfConnection";
-        readonly description: "a unique name for this connection";
+        type: "string";
+    } & {
+        defaultValue: string;
     };
-    /**
-     * #slot
-     */
     readonly assemblyNames: {
-        readonly type: "stringArray";
-        readonly defaultValue: readonly [];
-        readonly description: "optional list of names of assemblies in this connection";
+        type: "stringArray";
+    } & {
+        defaultValue: unknown;
     };
-}, import("../../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, "connectionId">>;
+    type: {
+        type: "string";
+    } & {
+        defaultValue: string;
+    };
+    connectionId: {
+        type: "string";
+    } & {
+        defaultValue: string;
+    };
+}, import("../../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, "connectionId", true, import("../../configuration/requirements.ts").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>>>;
 export default BaseConnectionConfig;
 export type BaseConnectionConfigSchema = typeof BaseConnectionConfig;
 export type BaseConnectionConfigModel = Instance<BaseConnectionConfigSchema>;

package/esm/pluggableElementTypes/models/baseConnectionConfig.js

@@ -1,11 +1,11 @@
 import { ConfigurationSchema } from '../../configuration/index.js';
 /**
  * #config BaseConnection
- * #gotcha A connection config is only a pointer: the hub's track list is
- * fetched when the connection loads and held in memory, and is **not** written
- * into a saved or shared session. Only a track you actually open is stored
- * (under `connectionTrackConfigs`, keyed by `trackId`), which is what keeps a
- * shared session small even against a very large hub.
+ * #gotcha JBrowse fetches the hub's track list when the connection loads and
+ * holds it in memory, and does **not** write it into a saved or shared session.
+ * The session stores only the tracks you open (under `connectionTrackConfigs`,
+ * keyed by `trackId`), so a shared session stays small even for a very large
+ * hub.
  */
 const BaseConnectionConfig = ConfigurationSchema('BaseConnection', {
     /**

package/esm/pluggableElementTypes/models/baseInternetAccountConfig.d.ts

@@ -3,44 +3,39 @@
  * the "base" internet account type
  */
 export declare const BaseInternetAccountConfig: import("../../configuration/configurationSchema.ts").ConfigurationSchemaType<{
-    /**
-     * #slot
-     */
     readonly name: {
-        readonly description: "descriptive name of the internet account";
-        readonly type: "string";
-        readonly defaultValue: "";
+        type: "string";
+    } & {
+        defaultValue: string;
     };
-    /**
-     * #slot
-     */
     readonly description: {
-        readonly description: "a description of the internet account";
-        readonly type: "string";
-        readonly defaultValue: "";
+        type: "string";
+    } & {
+        defaultValue: string;
     };
-    /**
-     * #slot
-     */
     readonly authHeader: {
-        readonly description: "request header for credentials";
-        readonly type: "string";
-        readonly defaultValue: "Authorization";
+        type: "string";
+    } & {
+        defaultValue: string;
     };
-    /**
-     * #slot
-     */
     readonly tokenType: {
-        readonly description: "a custom name for a token to include in the header";
-        readonly type: "string";
-        readonly defaultValue: "";
+        type: "string";
+    } & {
+        defaultValue: string;
     };
-    /**
-     * #slot
-     */
     readonly domains: {
-        readonly description: "array of valid domains the url can contain to use this account";
-        readonly type: "stringArray";
-        readonly defaultValue: readonly [];
+        type: "stringArray";
+    } & {
+        defaultValue: unknown;
     };
-}, import("../../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, "internetAccountId">>;
+    type: {
+        type: "string";
+    } & {
+        defaultValue: string;
+    };
+    internetAccountId: {
+        type: "string";
+    } & {
+        defaultValue: string;
+    };
+}, import("../../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, "internetAccountId", true, import("../../configuration/requirements.ts").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>>>;

package/esm/pluggableElementTypes/models/baseTrackConfig.d.ts

@@ -12,23 +12,16 @@ export declare function preprocessTrackConfigSnapshot(pluginManager: PluginManag
     trackId: string;
     name: string;
     type: string;
+    assemblyNames?: unknown;
+    textSearching?: {
+        textSearchAdapter?: unknown;
+    };
     displays: {
         type: string;
         featureHeight?: {} | null | undefined;
         displayId: string;
     }[];
 };
-/**
- * The `addDisplayConf` action shared by every track config schema — appends a
- * display config unless one with the same displayId already exists.
- */
-interface DisplayConf {
-    type: string;
-    displayId: string;
-}
-export declare function trackConfigActions(self: unknown): {
-    addDisplayConf(conf: DisplayConf): DisplayConf | undefined;
-};
 /**
  * #config BaseTrack
  * Configuration shared by all track types. Concrete tracks (FeatureTrack,
@@ -36,168 +29,91 @@ export declare function trackConfigActions(self: unknown): {
  * fields in addition to its own.
  */
 export declare function createBaseTrackConfig(pluginManager: PluginManager): import("../../configuration/configurationSchema.ts").ConfigurationSchemaType<{
-    /**
-     * #slot
-     */
     readonly name: {
-        readonly description: "descriptive name of the track, falls back to the trackId when unset";
-        readonly type: "string";
-        readonly defaultValue: "";
+        type: "string";
+    } & {
+        defaultValue: string;
     };
-    /**
-     * #slot
-     */
     readonly assemblyNames: {
-        readonly description: "name of the assembly (or assemblies) track belongs to";
-        readonly type: "stringArray";
-        readonly defaultValue: readonly ["assemblyName"];
+        type: "stringArray";
+    } & {
+        defaultValue: unknown;
     };
-    /**
-     * #slot
-     */
     readonly description: {
-        readonly description: "a description of the track";
-        readonly type: "string";
-        readonly defaultValue: "";
+        type: "string";
+    } & {
+        defaultValue: string;
     };
-    /**
-     * #slot
-     */
     readonly category: {
-        readonly description: "the category and sub-categories of a track";
-        readonly type: "stringArray";
-        readonly defaultValue: readonly [];
+        type: "stringArray";
+    } & {
+        defaultValue: unknown;
     };
-    /**
-     * #slot
-     */
     readonly metadata: {
-        readonly type: "frozen";
-        readonly description: "anything to add about this track";
-        readonly defaultValue: {};
+        type: "frozen";
+    } & {
+        defaultValue: unknown;
     };
-    /**
-     * #slot
-     * where this track's data comes from. Its `type` names the adapter for
-     * the file format (`BamAdapter`, `Gff3TabixAdapter`, ...) and the rest of
-     * the object is that adapter's own slots — see the adapter pages for
-     * each. Most adapters also accept a `uri` shorthand in place of writing
-     * their location slots out.
-     */
     readonly adapter: import("@jbrowse/mobx-state-tree").IAnyType;
     readonly textSearching: import("../../configuration/configurationSchema.ts").ConfigurationSchemaType<{
-        /**
-         * #slot textSearching.indexingAttributes
-         */
         readonly indexingAttributes: {
-            readonly type: "stringArray";
-            readonly description: "list of which feature attributes to index for text searching";
-            readonly defaultValue: readonly ["Name", "ID", "symbol"];
+            type: "stringArray";
+        } & {
+            defaultValue: unknown;
         };
-        /**
-         * #slot textSearching.indexingFeatureTypesToExclude
-         */
         readonly indexingFeatureTypesToExclude: {
-            readonly type: "stringArray";
-            readonly description: "list of feature types to exclude in text search index";
-            readonly defaultValue: readonly ["CDS", "exon"];
+            type: "stringArray";
+        } & {
+            defaultValue: unknown;
         };
-        /**
-         * #slot textSearching.indexingFeatureTypesToInclude
-         * The only feature types to index, dropping every other type the file
-         * carries. Empty (the default) means no allow list, i.e. index
-         * everything `indexingFeatureTypesToExclude` does not name.
-         *
-         * Use this instead of the exclude list when the file draws from a
-         * vocabulary you do not control. An NCBI RefSeq GFF3 uses 115 feature
-         * types, 80 of them leaf records with nothing to search for — a `match`
-         * is labelled with a bare UUID, a `cDNA_match` with an MD5, every
-         * `biological_region` with the literal string "biological region" — so
-         * a deny list leaks whichever type is added next, while the allow list
-         * (gene, pseudogene, and the transcript types) does not grow. Both may
-         * be set: this one admits, the exclude list then narrows.
-         *
-         * GFF3 only; the GTF and VCF indexers do not filter by type.
-         */
         readonly indexingFeatureTypesToInclude: {
-            readonly type: "stringArray";
-            readonly description: "the only feature types to index; empty means index every type not excluded";
-            readonly defaultValue: readonly [];
+            type: "stringArray";
+        } & {
+            defaultValue: unknown;
         };
-        /**
-         * #slot textSearching.textSearchAdapter
-         * a per-track name search index, normally a `TrixTextSearchAdapter`
-         * over what `jbrowse text-index --tracks` built. Without one, this
-         * track's features are only findable through an assembly-wide search
-         * adapter.
-         */
-        readonly textSearchAdapter: import("@jbrowse/mobx-state-tree").IAnyType;
-    }, import("../../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, undefined>>;
-    /**
-     * #slot
-     * An **array** of full display configs, e.g.
-     * `displays: [{ type: 'LinearBasicDisplay', color: 'green' }]`. Each entry
-     * names a display `type`; use this when you need exact control — your own
-     * `displayId`, different settings for two displays, or choosing which
-     * display is the default.
-     *
-     * For the common case, prefer the `displayDefaults` shorthand instead — an
-     * object of appearance settings (e.g. `displayDefaults: { color: 'green' }`)
-     * that JBrowse routes to whichever display uses each setting, so you don't
-     * have to name the display or write the array.
-     *
-     * See the [track config guide](/docs/config_guides/tracks/#configuring-displays).
-     */
+        readonly textSearchAdapter: import("@jbrowse/mobx-state-tree").ITypeUnion<any, any, any>;
+    }, import("../../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, undefined, undefined, import("../../configuration/requirements.ts").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>>>;
     readonly displays: import("@jbrowse/mobx-state-tree").IArrayType<import("@jbrowse/mobx-state-tree").IAnyType>;
-    /**
-     * #slot
-     * jexl callbacks that add, rewrite or hide fields in this track's
-     * feature-details panel. Four slots, listed at
-     * [FormatDetails](/docs/config/formatdetails), and the same schema exists
-     * session-wide as `configuration.formatDetails`.
-     */
     readonly formatDetails: import("../../configuration/configurationSchema.ts").ConfigurationSchemaType<{
         readonly feature: {
-            readonly type: "frozen";
-            readonly description: "adds extra fields to the feature details";
-            readonly defaultValue: {};
-            readonly contextVariable: ["feature"];
+            type: "frozen";
+        } & {
+            defaultValue: unknown;
         };
         readonly subfeatures: {
-            readonly type: "frozen";
-            readonly description: "adds extra fields to the subfeatures of a feature";
-            readonly defaultValue: {};
-            readonly contextVariable: ["feature"];
+            type: "frozen";
+        } & {
+            defaultValue: unknown;
         };
         readonly depth: {
-            readonly type: "maybeNumber";
-            readonly description: "levels of subfeature the formatDetails.subfeatures callback runs on, default 2";
+            type: "maybeNumber";
         };
         readonly maxDepth: {
-            readonly type: "maybeNumber";
-            readonly description: "hide subfeatures nested deeper than this, default no limit";
+            type: "maybeNumber";
         };
-    }, import("../../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, undefined>>;
-    /**
-     * #slot
-     * jexl callbacks that add, rewrite or hide fields in this track's About
-     * dialog. Two slots, listed at
-     * [FormatAbout](/docs/config/formatabout), and the same schema exists
-     * session-wide as `configuration.formatAbout`.
-     */
+    }, import("../../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, undefined, undefined, import("../../configuration/requirements.ts").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>>>;
     readonly formatAbout: import("../../configuration/configurationSchema.ts").ConfigurationSchemaType<{
         readonly config: {
-            readonly type: "frozen";
-            readonly description: "formats configuration object in about dialog";
-            readonly defaultValue: {};
-            readonly contextVariable: ["config"];
+            type: "frozen";
+        } & {
+            defaultValue: unknown;
         };
         readonly hideUris: {
-            readonly type: "boolean";
-            readonly defaultValue: false;
+            type: "boolean";
+        } & {
+            defaultValue: boolean;
         };
-    }, import("../../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, undefined>>;
-}, import("../../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, "trackId">>;
+    }, import("../../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, undefined, undefined, import("../../configuration/requirements.ts").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>>>;
+    type: {
+        type: "string";
+    } & {
+        defaultValue: string;
+    };
+    trackId: {
+        type: "string";
+    } & {
+        defaultValue: string;
+    };
+}, import("../../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, "trackId", true, import("../../configuration/requirements.ts").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>>>;
 export type BaseTrackConfigSchema = ReturnType<typeof createBaseTrackConfig>;
 export type BaseTrackConfig = Instance<BaseTrackConfigSchema>;
-export {};

package/esm/pluggableElementTypes/models/baseTrackConfig.js

@@ -1,5 +1,6 @@
 import { types } from '@jbrowse/mobx-state-tree';
 import { ConfigurationSchema, FormatAboutConfigSchemaFactory, FormatDetailsConfigSchemaFactory, } from '../../configuration/index.js';
+import { expandLooseSearchIndex } from '../../util/expandLooseSearchIndex.js';
 import { expandTrackConfigShorthand } from './expandTrackConfigShorthand.js';
 import { liftLegacyRendererConfig } from './migrateTrackConfig.js';
 /**
@@ -54,8 +55,17 @@ export function preprocessTrackConfigSnapshot(pluginManager, snapshot) {
     // are all aliases of one canonical type). First occurrence wins to preserve
     // the default (displays[0]).
     const seenTypes = new Set();
+    const { textSearching } = snap;
     return {
         ...snap,
+        ...(textSearching?.textSearchAdapter
+            ? {
+                textSearching: {
+                    ...textSearching,
+                    textSearchAdapter: expandLooseSearchIndex(textSearching.textSearchAdapter, snap.assemblyNames),
+                },
+            }
+            : {}),
         displays: displays
             .map(d => {
             const canonical = displayAliasMap.get(d.type);
@@ -76,23 +86,6 @@ export function preprocessTrackConfigSnapshot(pluginManager, snapshot) {
             .map(d => liftLegacyRendererConfig(d, snap.trackId)),
     };
 }
-export function trackConfigActions(self) {
-    const { displays } = self;
-    return {
-        addDisplayConf(conf) {
-            const { type } = conf;
-            if (!type) {
-                throw new Error('display type not specified');
-            }
-            const display = displays.find(d => d.displayId === conf.displayId);
-            if (display) {
-                return display;
-            }
-            const length = displays.push(conf);
-            return displays[length - 1];
-        },
-    };
-}
 /**
  * #config BaseTrack
  * Configuration shared by all track types. Concrete tracks (FeatureTrack,
@@ -192,11 +185,17 @@ export function createBaseTrackConfig(pluginManager) {
             /**
              * #slot textSearching.textSearchAdapter
              * a per-track name search index, normally a `TrixTextSearchAdapter`
-             * over what `jbrowse text-index --tracks` built. Without one, this
+             * over what `jbrowse text-index --tracks` built; `{ uri: 'genes.ix' }`
+             * is enough, searching this track's assemblies. Without one, this
              * track's features are only findable through an assembly-wide search
              * adapter.
              */
-            textSearchAdapter: pluginManager.pluggableConfigSchemaType('text search adapter'),
+            // Not `types.maybe(union)`: that unions the real type *before*
+            // `optional(undefined)`, and every member here is all-default, so an
+            // omitted key still resolved to the first registered one rather than
+            // to nothing (see textSearchAdapterSlotOmission.test.ts). Listing the
+            // undefined branch first is what actually wins the omitted-key default.
+            textSearchAdapter: types.union(types.optional(types.undefined, undefined), pluginManager.pluggableConfigSchemaType('text search adapter')),
         }),
         /**
          * #slot
@@ -217,17 +216,15 @@ export function createBaseTrackConfig(pluginManager) {
         /**
          * #slot
          * jexl callbacks that add, rewrite or hide fields in this track's
-         * feature-details panel. Four slots, listed at
-         * [FormatDetails](/docs/config/formatdetails), and the same schema exists
-         * session-wide as `configuration.formatDetails`.
+         * feature-details panel. The same schema exists session-wide as
+         * `configuration.formatDetails`.
          */
         formatDetails: FormatDetailsConfigSchemaFactory(),
         /**
          * #slot
          * jexl callbacks that add, rewrite or hide fields in this track's About
-         * dialog. Two slots, listed at
-         * [FormatAbout](/docs/config/formatabout), and the same schema exists
-         * session-wide as `configuration.formatAbout`.
+         * dialog. The same schema exists session-wide as
+         * `configuration.formatAbout`.
          */
         formatAbout: FormatAboutConfigSchemaFactory(),
     }, {
@@ -237,6 +234,5 @@ export function createBaseTrackConfig(pluginManager) {
          */
         explicitIdentifier: 'trackId',
         explicitlyTyped: true,
-        actions: trackConfigActions,
     });
 }

package/esm/pluggableElementTypes/models/components/SaveTrackData.js

@@ -43,13 +43,13 @@ function useTrackDataExport({ model, regions, regionStr, type, options, }) {
             // array key as "don't fetch", so the gated state would fetch nothing
             force ? 'forced' : 'gated',
         ]
-        : null, async (_name, _trackId, _regions, fileType, mode, stopToken, statusCallback) => fetchTrackData({
+        : null, async (_name, _trackId, _regions, fileType, mode, signal, statusCallback) => fetchTrackData({
         model,
         regions,
         type: fileType,
         options,
         force: mode === 'forced',
-        stopToken,
+        signal,
         statusCallback,
     }));
     return { result: data, error, loading: isLoading, status, setForce };

package/esm/pluggableElementTypes/models/components/fetchTrackData.d.ts

@@ -1,7 +1,6 @@
 import type { AnyConfigurationModel } from '../../../configuration/index.ts';
 import type { Region } from '../../../util/index.ts';
 import type { StatusCallback } from '../../../util/progress.ts';
-import type { StopToken } from '../../../util/stopToken.ts';
 import type { FileTypeExporter } from '../saveTrackFileTypes/types.ts';
 import type { IStateTreeNode } from '@jbrowse/mobx-state-tree';
 /**
@@ -41,15 +40,15 @@ export interface TrackDataResult {
  *
  * This reads every feature in the visible region, which on a deep track is the
  * same work the display itself does — worth cancelling when the dialog closes,
- * and worth naming while it runs, hence the stop token and status callback.
+ * and worth naming while it runs, hence the signal and status callback.
  */
-export declare function fetchTrackData({ model, regions, type, options, force, stopToken, statusCallback, }: {
+export declare function fetchTrackData({ model, regions, type, options, force, signal, statusCallback, }: {
     model: ExportableTrack;
     regions: Region[];
     type: string;
     options: Record<string, FileTypeExporter>;
     /** skip the size pre-flight — the user has seen the estimate and said yes */
     force?: boolean;
-    stopToken?: StopToken;
+    signal?: AbortSignal;
     statusCallback?: StatusCallback;
 }): Promise<TrackDataResult>;

package/esm/pluggableElementTypes/models/components/fetchTrackData.js

@@ -30,13 +30,13 @@ function endWithNewline(str) {
  *
  * This reads every feature in the visible region, which on a deep track is the
  * same work the display itself does — worth cancelling when the dialog closes,
- * and worth naming while it runs, hence the stop token and status callback.
+ * and worth naming while it runs, hence the signal and status callback.
  */
-export async function fetchTrackData({ model, regions, type, options, force, stopToken, statusCallback, }) {
+export async function fetchTrackData({ model, regions, type, options, force, signal, statusCallback, }) {
     const session = getSession(model);
     const sessionId = getRpcSessionId(model);
     const adapterConfig = getConf(model, ['adapter']);
-    const opts = { stopToken, statusCallback };
+    const opts = { signal, statusCallback };
     const { exportsDataViaAdapter } = model;
     // The same index lookup the display's gate takes before it fetches, for the
     // same reason: this menu item pulls the region the display just refused to

package/esm/pluggableElementTypes/models/expandTrackConfigShorthand.d.ts

@@ -1,19 +1,27 @@
 import type PluginManager from '../../PluginManager.ts';
+import type { AnyConfigurationSchemaType } from '../../configuration/index.ts';
 export interface DisplaySnapshot {
     type: string;
     displayId?: string;
     [key: string]: unknown;
 }
 /**
- * Pure: route each shorthand `displayDefaults: {...}` setting to the display
- * types that define it. A setting goes to every display type whose config schema
- * has that slot, so slot names disambiguate across displays on their own (e.g.
- * `color` → LinearVariantDisplay, `strokeColor` → ChordVariantDisplay). Keys no
- * display defines are returned as `unknownKeys` for the caller to surface.
+ * Route each shorthand `displayDefaults: {...}` setting to the display types
+ * whose slot of that name takes its value, so slot names disambiguate across
+ * displays (`color` → LinearVariantDisplay, `strokeColor` →
+ * ChordVariantDisplay) and so do the values: `displayMode: 'compact'` on a
+ * FeatureTrack reaches the feature display and not the arc display, whose
+ * `displayMode` is `arcs | semicircles`. A key no display declares is an `unknownKeys`
+ * entry, and one every declaring display refuses a `refused` entry carrying
+ * each display's reason.
  */
-export declare function collectDisplayOverrides(displaySettings: Record<string, unknown>, displaySlots: Map<string, Set<string>>): {
+export declare function collectDisplayOverrides(displaySettings: Record<string, unknown>, displaySchemas: ReadonlyMap<string, AnyConfigurationSchemaType>): {
     overrides: Map<string, Record<string, unknown>>;
     unknownKeys: string[];
+    refused: {
+        key: string;
+        reasons: string[];
+    }[];
 };
 /**
  * Pure: fold per-display override props into a `displays` array, creating an
@@ -25,7 +33,7 @@ export declare function mergeOverridesIntoDisplays(displays: DisplaySnapshot[],
  * Expands the shorthand `displayDefaults` **object** into the explicit `displays`
  * **array**, so users can set display settings without naming the display type
  * or nesting in `displays:[{type,...}]`. `displayDefaults:{color:'green'}` routes
- * each setting to the display type(s) that define that slot, folding them into
+ * each setting to the display type(s) whose slot takes it, folding them into
  * whatever `displays` array the track already has (explicit entries win).
  *
  * `displayDefaults` is kept separate from `displays` (rather than overloading