@jbrowse/core 5.0.0-beta.11 → 5.0.0-beta.13

package/esm/ReExports/list.js

@@ -248,6 +248,7 @@ export default [
     '@jbrowse/core/ui/SnackbarModel',
     '@jbrowse/core/ui/StackTraceButton',
     '@jbrowse/core/ui/styleTheme',
+    '@jbrowse/core/ui/SubmitDialog',
     '@jbrowse/core/ui/SvgColorLegend',
     '@jbrowse/core/ui/theme',
     '@jbrowse/core/ui/useCoalescedPointer',
@@ -259,6 +260,7 @@ export default [
     '@jbrowse/core/util/adapterMetadata',
     '@jbrowse/core/util/addRelativeUris',
     '@jbrowse/core/util/aggregateFieldName',
+    '@jbrowse/core/util/alignedBytes',
     '@jbrowse/core/util/analytics',
     '@jbrowse/core/util/animationAllowed',
     '@jbrowse/core/util/assemblyConfigUtils',
@@ -317,6 +319,7 @@ export default [
     '@jbrowse/core/util/io',
     '@jbrowse/core/util/io/RemoteFileWithRangeCache',
     '@jbrowse/core/util/isDataCurrent',
+    '@jbrowse/core/util/isoformRank',
     '@jbrowse/core/util/isTextEntryFocused',
     '@jbrowse/core/util/jexl',
     '@jbrowse/core/util/jexlFilters',
@@ -397,6 +400,7 @@ export default [
     '@jbrowse/display-kit/coarseTier',
     '@jbrowse/display-kit/CoarseTierMixin',
     '@jbrowse/display-kit/coarseTierPhase',
+    '@jbrowse/display-kit/colorByMenu',
     '@jbrowse/display-kit/colorConfigSchema',
     '@jbrowse/display-kit/ConfigProblemsIndicator',
     '@jbrowse/display-kit/configSchema',
@@ -434,6 +438,7 @@ export default [
     '@jbrowse/display-kit/heightModeConfigSchemaFields',
     '@jbrowse/display-kit/heightModeMenu',
     '@jbrowse/display-kit/HeightModeMixin',
+    '@jbrowse/display-kit/heldColorSlots',
     '@jbrowse/display-kit/HiddenGroupsMixin',
     '@jbrowse/display-kit/highlightHost',
     '@jbrowse/display-kit/installClearHoverOnViewportChange',
@@ -443,6 +448,7 @@ export default [
     '@jbrowse/display-kit/KeyedFetchMixin',
     '@jbrowse/display-kit/legendHost',
     '@jbrowse/display-kit/LegendMixin',
+    '@jbrowse/display-kit/MarkSvgLayer',
     '@jbrowse/display-kit/MultiRegionDisplayMixin',
     '@jbrowse/display-kit/planRegionFetch',
     '@jbrowse/display-kit/PlotDialog',
@@ -459,6 +465,7 @@ export default [
     '@jbrowse/display-kit/rowsConfigSchema',
     '@jbrowse/display-kit/rpcArgs',
     '@jbrowse/display-kit/SkippedFeaturesIndicator',
+    '@jbrowse/display-kit/SolidColorDialog',
     '@jbrowse/display-kit/stableIdentityComputed',
     '@jbrowse/display-kit/StoredHoverMixin',
     '@jbrowse/display-kit/subPixelBinBp',

package/esm/TextSearch/TextSearchManager.d.ts

@@ -1,6 +1,6 @@
 import QuickLRU from '../util/QuickLRU/index.ts';
 import type PluginManager from '../PluginManager.ts';
-import type { AnyConfigurationModel } from '../configuration/index.ts';
+import type { AnyConfigurationModel, AnyTrackConfig } from '../configuration/index.ts';
 import type { BaseTextSearchAdapter, BaseTextSearchArgs } from '../data_adapters/BaseAdapter/index.ts';
 import type BaseResult from './BaseResults.ts';
 export interface SearchIndex {
@@ -30,9 +30,9 @@ export default class TextSearchManager {
     relevantAdapters(assemblyName: string): AnyConfigurationModel[];
     relevantIndexes(assemblyName: string): SearchIndex[];
     getAdaptersWithAssembly(matches: (names: string[] | undefined) => boolean, confs: AnyConfigurationModel[]): AnyConfigurationModel[];
-    getTrackAdaptersWithAssembly(matches: (names: string[] | undefined) => boolean, confs: AnyConfigurationModel[]): {
+    getTrackAdaptersWithAssembly(matches: (names: string[] | undefined) => boolean, confs: AnyTrackConfig[]): {
         conf: AnyConfigurationModel;
-        trackId: string;
+        trackId: any;
     }[];
     search(args: BaseTextSearchArgs, assemblyName: string): Promise<BaseResult[]>;
     searchIndexes(args: BaseTextSearchArgs, assemblyName: string): Promise<TextSearchReport>;

package/esm/TextSearch/TextSearchManager.js

@@ -3,7 +3,7 @@ import { hydrateTrackConfig, readConfObject } from '../configuration/index.js';
 import { adapterConfigCacheKey } from '../data_adapters/dataAdapterCache.js';
 import QuickLRU from '../util/QuickLRU/index.js';
 import { checkAbortSignal, isAbortException } from '../util/aborting.js';
-import { allSessionTracks, canonicalAssemblyNames } from '../util/tracks.js';
+import { allSessionTracks, canonicalAssemblyNames, getConfAssemblyNamesOrNone, } from '../util/tracks.js';
 // A misconfigured or unreachable index (a 404 .ix, a config missing
 // ixFilePath) must not take down search as a whole: the remaining indexes, and
 // the refName results the caller merges in afterwards, are still useful. The
@@ -84,24 +84,17 @@ export default class TextSearchManager {
     getTrackAdaptersWithAssembly(matches, confs) {
         return confs
             .filter(conf => {
-            const indexNames = readConfObject(conf, [
-                'textSearching',
-                'textSearchAdapter',
-                'assemblyNames',
-            ]);
-            return (!!readConfObject(conf, ['textSearching', 'textSearchAdapter']) &&
-                matches(indexNames?.length
-                    ? indexNames
-                    : readConfObject(conf, 'assemblyNames')));
+            const adapter = conf.textSearching?.textSearchAdapter;
+            const indexNames = adapter?.assemblyNames;
+            return (!!adapter &&
+                matches(indexNames?.length ? indexNames : getConfAssemblyNamesOrNone(conf)));
         })
             .flatMap(track => {
             const live = isStateTreeNode(track)
                 ? track
                 : hydrateTrackConfig(this.pluginManager, track);
             const conf = live?.textSearching.textSearchAdapter;
-            return conf
-                ? [{ conf, trackId: readConfObject(track, 'trackId') }]
-                : [];
+            return conf ? [{ conf, trackId: track.trackId }] : [];
         });
     }
     async search(args, assemblyName) {

package/esm/configuration/configurationSchema.d.ts

@@ -6,17 +6,8 @@ import type { AnyConfigurationModel, AnyConfigurationSchemaType, ConfigNodeActio
 import type { IAnyType, ISimpleType, IType, ReferenceIdentifier, SnapshotIn, SnapshotOut } from '@jbrowse/mobx-state-tree';
 export type { AnyConfigurationModel, AnyConfigurationSchemaType, } from './types.ts';
 /**
- * The three entry kinds `makeConfigurationSchemaModel` classifies: a slot
- * definition, a constant (bare string/number), or a nested sub-schema — which
- * is the **MST type** `ConfigurationSchema()` returned, hence `IAnyType`.
- *
- * A raw nested `ConfigurationSchemaDefinition` used to be a fourth member here,
- * and it was both dead and load-bearing in the wrong direction: nothing
- * constructs a sub-schema from one (the loop has no branch for it, so it throws
- * "no type set for config slot"), while a plain object of strings and numbers is
- * exactly what a *slot definition* is — so every slot in the repo matched that
- * member instead and was never checked against `ConfigSlotDefinition` at all.
- * `type: 'enum'`, a name this system has never had, compiled for years that way.
+ * Each entry is a slot definition, a constant (bare string/number), or a
+ * sub-schema: the MST type `ConfigurationSchema()` returned.
  */
 export interface ConfigurationSchemaDefinition {
     [n: string]: ConfigSlotDefinition | string | number | IAnyType;
@@ -73,23 +64,13 @@ export interface ConfigurationSchemaOptions<BASE_SCHEMA extends AnyConfiguration
 }
 type SchemaHook = (self: any) => any;
 /**
- * Options as **stored**: what a caller passes, except that the three
- * MST-chained hooks may have accumulated a chain by merging in a
- * `baseConfiguration`. A caller's single function is a valid chain of one, so
- * `ConfigurationSchemaOptions` is assignable to this and no call site changes.
- *
- * They stay a chain rather than being folded into one function because MST is
- * what does the chaining: `.actions()` is called once per entry, which is what
- * puts the base's members on `self` by the time the subclass's function runs,
- * and what lets the subclass override one by redeclaring its name. Folding to
- * `self => ({...base(self), ...child(self)})` would give neither, and would
- * corrupt `extend` outright (it returns `{actions, views, state}`, so a spread
- * merge drops whichever side declared fewer of the three).
- *
- * `preProcessSnapshot` is the exception and composes into a single function,
- * `child(base(snapshot))`: the base normalizes and migrates first, the subclass
- * refines. It has to stay one function because `preProcessSnapshotWith` runs it
- * straight off the registry, over a partial settings bag as well as a snapshot.
+ * Options as stored, with a `baseConfiguration`'s hooks merged in. `actions`,
+ * `views` and `extend` stay a chain that MST applies one call per entry, which
+ * puts the base's members on `self` before the subclass's function runs and
+ * lets the subclass override one by name; a spread merge would give neither,
+ * and would drop half of `extend`'s `{actions, views, state}`.
+ * `preProcessSnapshot` composes into one function, `child(base(snapshot))`,
+ * since `preProcessSnapshotWith` runs it off the registry.
  */
 export interface MergedConfigurationSchemaOptions<BASE_SCHEMA extends AnyConfigurationSchemaType | undefined, EXPLICIT_IDENTIFIER extends string | undefined> extends Omit<ConfigurationSchemaOptions<BASE_SCHEMA, EXPLICIT_IDENTIFIER>, 'actions' | 'views' | 'extend'> {
     actions?: SchemaHook | SchemaHook[];
@@ -98,21 +79,16 @@ export interface MergedConfigurationSchemaOptions<BASE_SCHEMA extends AnyConfigu
 }
 declare function makeConfigurationSchemaModel<DEFINITION extends ConfigurationSchemaDefinition, OPTIONS extends MergedConfigurationSchemaOptions<any, any>>(modelName: string, schemaDefinition: DEFINITION, options: OPTIONS): import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").IModelType<Record<string, any>, ConfigNodeActions, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>, [undefined]>;
 /**
- * DEFINITION is unconstrained on purpose. It carries the *merged* definition —
- * `MergeConfigDef`, an unresolved conditional that cannot be checked against a
- * constraint — and intersecting it with `ConfigurationSchemaDefinition` to
- * satisfy one would put an index signature straight back into
- * `keyof DEFINITION`. The authoring check lives on `ConfigurationSchema`'s own
- * parameter, where the literal arrives, and on the `extends` clause below.
+ * DEFINITION is unconstrained: a constraint would put an index signature back
+ * into `keyof DEFINITION`. `ConfigurationSchema`'s own parameter checks the
+ * literal where it arrives. ADR-145.
  */
 export interface ConfigurationSchemaType<out DEFINITION, OPTIONS extends ConfigurationSchemaOptions<any, any>> extends ReturnType<typeof makeConfigurationSchemaModel<DEFINITION & ConfigurationSchemaDefinition, OPTIONS>> {
     /**
-     * Overrides the factory's, whose props come off a `Record<string, any>` and
-     * so admit every name. Slots come from the definition — the identifier and
-     * an `explicitlyTyped` schema's `type` ride in as two of them — and the brand
-     * names this schema, which is what `ConfigurationSchemaForModel` infers back
-     * out. `TypeWithoutSTN` too, since a wrapper — `types.optional`,
-     * `types.stripDefault` — builds its instance from that one.
+     * Replaces the factory's `Record<string, any>` props with the definition's,
+     * and brands the node with this schema for `ConfigurationSchemaForModel`.
+     * `TypeWithoutSTN` is what a `types.optional` or `stripDefault` wrapper builds
+     * its instance from.
      */
     readonly Type: ConfigNodeProps<DEFINITION> & ConfigNodeActions & ConfigNodeBrand<this>;
     readonly TypeWithoutSTN: ConfigNodeProps<DEFINITION> & ConfigNodeActions;
@@ -133,70 +109,32 @@ export declare function ConfigurationSchema<const DEFINITION extends Configurati
 } : unknown), BASE_SCHEMA>, ConfigurationSchemaOptions<BASE_SCHEMA, EXPLICIT_IDENTIFIER, EXPLICITLY_TYPED>>;
 /**
  * #api core/configuration
- * Hydrate a plain track config into a live config node, dispatching on its
- * `type` to find the schema. `session.tracks` holds `types.frozen` plain
- * objects until something references a track (ADR-031). One of those holds only
- * what was literally authored: a slot at its schema default is absent,
- * `preProcessSnapshot` has not run, and nothing that walks a live node applies
- * to it.
- *
- * Use it where a caller needs the resolved config and may be handed either
- * form. The About dialog's "Copy config" is reached from two menus, and one of
- * them passes a `session.tracks` entry.
+ * Hydrate a plain track config, such as a `session.tracks` entry, into a live
+ * config node, dispatching on its `type` to find the schema. A plain entry
+ * holds only what was authored: a slot at its default is absent and
+ * `preProcessSnapshot` has not run.
  *
- * Returns **undefined** when the config names a track type no plugin
- * registered, or when `create` rejects it as invalid. An un-hydrated config has
- * never been validated, so the dialog opening over it should not throw. Callers
- * fall back to using the plain object.
- *
- * Shares `TrackConfigurationReference`'s per-PluginManager cache, so hydrating
- * the same entry twice returns the same node, and in an admin session a track
- * opened later resolves to that same node. A non-admin's open track
- * resolves to the session's private working copy (ADR-032), and this function
- * returns the pristine mirror beside it. The two have the same content;
- * `CopyConfigEntryPoints.test.ts` tests both cases.
+ * Returns **undefined** when no plugin registered the type or `create` rejects
+ * the config, which has never been validated; callers fall back to the plain
+ * object. Hydrating one entry twice returns one node. A shown track resolves to
+ * the session's working copy instead (ADR-032), which has the same content.
  */
 export declare function hydrateTrackConfig(pluginManager: PluginManager, config: Record<string, unknown>): AnyConfigurationModel | undefined;
 type ConfigReferenceInstance<SCHEMA extends AnyConfigurationSchemaType> = SCHEMA extends ConfigurationSchemaType<infer D, any> ? IsAny<D> extends true ? any : SCHEMA['Type'] : SCHEMA['Type'];
 /**
- * Static type of the value `ConfigurationReference` produces, and therefore of a
- * track/display state model's `configuration` prop. Its **instance** type is a
- * clean, single-branded schema instance (see `ConfigReferenceInstance`), so
- * `ConfigurationSchemaForModel` — and thus `getConf(self, slot)` /
- * `readConfObject(self.configuration, slot)` — recovers the concrete schema and
- * its precise slot value types instead of `any`. The snapshot types stay
- * `id-string | schema-snapshot`, matching the runtime union (`idOrSnapshotUnion`):
- * a saved config serializes to its id string, and both an id string and a full
- * inline snapshot are accepted as input — so views that push string ids or
- * synthesized configs (`CircularView`, `SvInspectorView`) keep type-checking.
- *
- * Built by `Omit`-ing `Type` off `IType` and re-adding it, rather than reusing
- * the runtime `ITypeUnion`: `IType`'s own `Type` is `STNValue<T, this>`, which
- * re-brands `T` with `IStateTreeNode<this>`. Layering that over an already-branded
- * `SCHEMA['Type']` (which carries `IStateTreeNode<SCHEMA>`) double-brands the
- * node, and the two competing `IStateTreeNode<…>` brands defeat the single
- * `infer SCHEMA` in `ConfigurationSchemaForModel` (leaving it `any`). Re-adding a
- * plain `Type` keeps the single brand. See the "Config read type narrowing"
- * section of `packages/core/src/configuration/CLAUDE.md`.
+ * The type of a track or display model's `configuration` prop: snapshots are
+ * `id | config`, as the runtime union takes, and the instance carries the
+ * concrete schema so `getConf(self, slot)` narrows. `Type` is re-added rather
+ * than taken from `IType`, whose `STNValue` would brand the node a second time
+ * and leave `ConfigurationSchemaForModel` inferring `any`.
  */
 export type IConfigurationReference<SCHEMA extends AnyConfigurationSchemaType> = Omit<IType<ReferenceIdentifier | SnapshotIn<SCHEMA>, ReferenceIdentifier | SnapshotOut<SCHEMA>, ConfigReferenceInstance<SCHEMA>>, 'Type'> & {
     readonly Type: ConfigReferenceInstance<SCHEMA>;
 };
 /**
- * Dispatch by the schema's identifier: `trackId` → track-ref (resolves through
- * `session.getTrackById`), `displayId` → display-ref (resolves through the
- * parent track's displays array), anything else → plain reference.
- *
- * Display schemas must declare `explicitIdentifier: 'displayId'` (directly or
- * via `baseConfiguration: baseLinearDisplayConfigSchema`, which merges its
- * options through `preprocessConfigurationSchemaArguments`).
- *
- * The return is annotated `IConfigurationReference<SCHEMATYPE>` (see its doc)
- * so `self.configuration` carries the concrete schema. The three runtime
- * branches produce MST reference/union types over `schemaType` that are
- * assignable to that annotation, so `return ref` needs no cast — and must not
- * get one: a prior `as SCHEMATYPE` was dropped because it narrowed `SnapshotIn`
- * to just the object branch and forced callers pushing string ids to
- * `@ts-expect-error` (see `TrackConfigurationReference`'s note).
+ * A reference resolved by the schema's identifier: a `trackId` through the
+ * session, a `displayId` through the containing track's `displays`, anything
+ * else by MST's own identifier lookup. No `as SCHEMATYPE` on the return: it
+ * would narrow `SnapshotIn` to the object branch and refuse a string id.
  */
 export declare function ConfigurationReference<SCHEMATYPE extends AnyConfigurationSchemaType>(schemaType: SCHEMATYPE): IConfigurationReference<SCHEMATYPE>;