@jbrowse/plugin-linear-genome-view 5.0.0-beta.16 → 5.0.0-beta.18

package/esm/LinearGenomeView/rExport/rScript.js

@@ -5,7 +5,7 @@ import { resolveUri } from '@jbrowse/core/util';
  * it opens (the slot holding the file and the extension the reader knows it
  * by).
  */
-const READERS = {
+export const READERS = {
     LinearBasicDisplay: {
         call: 'jbrowse_features',
         adapters: {
@@ -216,7 +216,7 @@ function fileArgument(adapters, adapter) {
  * Each sequence adapter `jbrowse_assembly()` builds from a path, by the
  * extension ggjbrowse reads it off, and the index each takes beside it.
  */
-const SEQUENCE_ADAPTERS = {
+export const SEQUENCE_ADAPTERS = {
     TwoBitAdapter: { slot: 'twoBitLocation', ext: /\.2bit$/, beside: {} },
     BgzipFastaAdapter: {
         slot: 'fastaLocation',
@@ -330,7 +330,7 @@ function trackNames(tracks) {
 }
 /** What the figure cannot show of a track whose settings ggjbrowse reads. */
 function settingNotes(track) {
-    const color = track.display.color;
+    const { color } = track.display.encoding ?? {};
     return [
         ...(color?.field === 'mateRefName'
             ? [

package/esm/LinearGenomeView/sharedScaleContainer.js

@@ -1,17 +1,7 @@
-import { getParent, hasParent, isAlive } from '@jbrowse/mobx-state-tree';
+import { findParent } from '@jbrowse/mobx-state-tree';
 export function isSharedScaleContainer(thing) {
     return typeof thing === 'object' && thing !== null && 'sharedFit' in thing;
 }
-// Walks rather than using findParentThatIs because having no such container is
-// the ordinary standalone case here, not the error that helper reports.
 export function sharedScaleContainerOf(node) {
-    let current = node;
-    let found;
-    while (!found && hasParent(current) && isAlive(current)) {
-        current = getParent(current);
-        if (isSharedScaleContainer(current)) {
-            found = current;
-        }
-    }
-    return found;
+    return findParent(node, isSharedScaleContainer);
 }

package/esm/LinearGenomeView/showFiles.d.ts

@@ -0,0 +1,2 @@
+import type { LinearGenomeViewModel } from './model.ts';
+export declare function showFiles(view: LinearGenomeViewModel, files: readonly File[]): Promise<string[]>;

package/esm/LinearGenomeView/showFiles.js

@@ -0,0 +1,19 @@
+import { fileToLocation, getEnv, getSession, isSessionWithAddSessionTrack, } from '@jbrowse/core/util';
+import { pairIndexFiles } from '@jbrowse/core/util/indexCandidates';
+import { guessTrackConfForLocation } from '@jbrowse/core/util/tracks';
+// Every type is guessed before any track is added, so a selection holding one
+// file of no known type adds nothing rather than half of itself.
+export async function showFiles(view, files) {
+    const session = getSession(view);
+    if (!isSessionWithAddSessionTrack(session)) {
+        throw new Error('this session does not take new tracks');
+    }
+    const { pluginManager } = getEnv(view);
+    const assemblyName = view.assemblyNames[0] ?? view.launchAssemblyName;
+    const confs = pairIndexFiles(files).map(({ data, index }) => guessTrackConfForLocation(fileToLocation(data), index && fileToLocation(index), pluginManager, assemblyName));
+    for (const conf of confs) {
+        session.addSessionTrackConf(conf);
+    }
+    await Promise.all(confs.map(conf => view.launchTrack(conf.trackId)));
+    return confs.map(conf => conf.trackId);
+}

package/esm/LinearGenomeView/svgcomponents/useViewSvgFigure.js

@@ -126,7 +126,7 @@ const FrozenSvgFigure = memo(function FrozenSvgFigure({ view, snapshot, }) {
  * (hidden sections, collapses, height overrides: `groupStateKey`), which are
  * volatile and in no snapshot; **the reload counter**, since a Retry or a Force
  * load leaves every snapshot as it was while the figure has an error or a
- * too-large note to replace; **the view's coloring toggles** (`colorByCDS`,
+ * too-large note to replace; **the view's coloring toggles** (`colorByFrame`,
  * `showAminoAcids`), named one by one because the view's own snapshot moves
  * every pan frame; **the width**, since a resize can widen the canvas without
  * moving the locus; **the theme**, since each display bakes colors into its own
@@ -172,7 +172,7 @@ function figureKey(view, themeName) {
                 display?.reloadCounter,
             ];
         }),
-        view.colorByCDS,
+        view.colorByFrame,
         view.showAminoAcids,
         session.getActiveThemeOptions?.(themeName),
         session.highlightsVisible ? view.highlights : false,

package/esm/TrackModifiers/index.d.ts

@@ -0,0 +1,80 @@
+import type { FieldPredicate } from '@jbrowse/core/util/fieldPredicate';
+import type { TrackInit } from '@jbrowse/core/util/tracks';
+import type { DisplaySettings } from '@jbrowse/launch-args/displaySettings';
+import type { IAnyStateTreeNode } from '@jbrowse/mobx-state-tree';
+/** The linear view a command line's tracks open in, as these helpers read it. */
+export interface ModifierView {
+    centerLineInfo?: {
+        refName?: string;
+        offset: number;
+        start: number;
+        end: number;
+        reversed?: boolean;
+        oob?: boolean;
+    };
+    launchTrack: (trackId: string, trackSnapshot?: object, displaySnapshot?: object) => Promise<{
+        displays: unknown[];
+    } | undefined>;
+    showTrack: (trackId: string, trackSnapshot?: object, displaySnapshot?: object) => unknown;
+    tracks: {
+        configuration: {
+            trackId: string;
+        };
+        displays: unknown[];
+        activeDisplay: {
+            configuration: Record<string, unknown>;
+        };
+    }[];
+}
+/**
+ * `displayTypeOf` for a track the session holds, undefined for one it does
+ * not; `displayType` is the display the caller opens it as when no
+ * `display:` modifier names one.
+ */
+export declare function openedDisplayType(session: {
+    getTrackById: (trackId: string) => unknown;
+}, trackId: string, modifiers: string[], displayType?: string): string | undefined;
+/**
+ * Write the `filter` of `trackId`'s `settings` onto its display open in
+ * `view`, by field over the configured filter, as the track menu would.
+ * Returns the display's filter as written, which reopens the track as drawn,
+ * or undefined when the settings write no filter.
+ */
+export declare function writeFilter(view: Pick<ModifierView, 'tracks' | 'showTrack'>, trackId: string, settings: DisplaySettings): FieldPredicate[] | undefined;
+/**
+ * @deprecated `writeFilter`, which every display category takes. This one
+ * writes an alignments `display`'s filter only.
+ */
+export declare function writeReadFilter(display: unknown, displayType: string | undefined, settings: DisplaySettings): FieldPredicate[] | undefined;
+interface LaunchOptions {
+    /** the track entry's own display settings, which the modifiers write over */
+    displaySnapshot?: Record<string, unknown>;
+    trackSnapshot?: Record<string, unknown>;
+    /** changes the settings after the center-line sort resolves, before the open */
+    adjust?: (settings: DisplaySettings) => void;
+    warn?: (message: string) => void;
+}
+/**
+ * Open `trackId` in `view` with its command-line modifiers applied, and return
+ * the session-spec track entry that reopens it as drawn, or undefined when the
+ * open fails, which `launchTrack` reports to the session.
+ */
+export declare function launchTrackWithModifiers(view: ModifierView, trackId: string, displayType: string | undefined, modifiers: string[], { displaySnapshot, trackSnapshot, adjust, warn, }?: LaunchOptions): Promise<{
+    trackId: string;
+    filter?: FieldPredicate[] | undefined;
+} | undefined>;
+/**
+ * Open a session spec's track entry in a navigated `view`, its `modifiers`
+ * written over its display settings. When a modifier or the open fails, the
+ * session's snackbar says why and the track opens with its own settings.
+ */
+export declare function launchTrackInit(view: ModifierView & IAnyStateTreeNode, t: TrackInit): Promise<void>;
+/**
+ * Write a track's `memberWrites` onto what its display in `view` already has,
+ * after every other modifier, so a member write keeps the rest of the setting
+ * whatever order the command line gives them in. A display replaces a color
+ * or facet object whole, which is why these cannot ride in on the launch
+ * snapshot.
+ */
+export declare function writeMembers(view: Pick<ModifierView, 'tracks' | 'showTrack'>, trackId: string, members: string[]): Record<string, unknown>;
+export {};

package/esm/TrackModifiers/index.js

@@ -0,0 +1,212 @@
+import { mergeConfSettings } from '@jbrowse/core/configuration';
+import { getEnv, getSession } from '@jbrowse/core/util';
+import { basePaintedAt } from '@jbrowse/core/util/Base1DUtils';
+import { predicatesOf, testsSomething, withFields, } from '@jbrowse/core/util/fieldPredicate';
+import { normalizeTrackInit, trackDisplayType } from '@jbrowse/core/util/tracks';
+import { buildDisplaySnapshot, displayCategory, memberPatch, memberWrites, mergeSettings, requestedDisplayType, } from '@jbrowse/launch-args/displaySettings';
+import { getSnapshot, getType, isArrayType, isStateTreeNode, } from '@jbrowse/mobx-state-tree';
+/**
+ * The display a linear view opens `conf` as, read off the display picker so it
+ * follows `display:` and the adapter rather than a list of track types.
+ */
+function displayTypeOf(pluginManager, conf, modifiers, displayType) {
+    return trackDisplayType(pluginManager, conf, 'LinearGenomeView', requestedDisplayType(modifiers) ?? displayType);
+}
+/**
+ * `displayTypeOf` for a track the session holds, undefined for one it does
+ * not; `displayType` is the display the caller opens it as when no
+ * `display:` modifier names one.
+ */
+export function openedDisplayType(session, trackId, modifiers, displayType) {
+    const conf = session.getTrackById(trackId);
+    return conf
+        ? displayTypeOf(getEnv(session).pluginManager, (isStateTreeNode(conf) ? getSnapshot(conf) : conf), modifiers, displayType)
+        : undefined;
+}
+const consoleWarn = (message) => {
+    console.warn(`Warning: ${message}`);
+};
+function modifierLaunch(displayType, modifiers, warn = consoleWarn) {
+    return {
+        displayType,
+        settings: buildDisplaySnapshot(displayType, modifiers, warn),
+        members: memberWrites(displayType, modifiers),
+    };
+}
+// the entries grouped by field, as `setFilterFields` takes them: a field whose
+// entries are all bare is `[]`, which clears it, defaults included
+function filterPatch(entries) {
+    const patch = {};
+    for (const p of entries) {
+        patch[p.field] = [
+            ...(patch[p.field] ?? []),
+            ...(testsSomething(p) ? [p] : []),
+        ];
+    }
+    return patch;
+}
+// the display snapshot a track opens with. `filter` stays out of it:
+// `writeFilter` writes it once the track is open, since the list in a
+// snapshot would replace the configured one
+function launchSnapshot({ settings }) {
+    const { snap, displayType } = settings;
+    const { filter: _filter, ...unfiltered } = snap;
+    return {
+        ...unfiltered,
+        ...(displayType ? { type: displayType } : {}),
+    };
+}
+/**
+ * Write the `filter` of `trackId`'s `settings` onto its display open in
+ * `view`, by field over the configured filter, as the track menu would.
+ * Returns the display's filter as written, which reopens the track as drawn,
+ * or undefined when the settings write no filter.
+ */
+export function writeFilter(view, trackId, settings) {
+    const { filter } = settings.snap;
+    const track = view.tracks.find(t => t.configuration.trackId === trackId);
+    if (!filter || !track) {
+        return undefined;
+    }
+    const patch = filterPatch(filter);
+    const display = track.displays[0];
+    if (display?.setFilterFields) {
+        display.setFilterFields(patch);
+        return display.writtenFilter;
+    }
+    const written = withFields(predicatesOf(track.activeDisplay.configuration.filter), patch);
+    view.showTrack(trackId, {}, { filter: written });
+    return written;
+}
+/**
+ * @deprecated `writeFilter`, which every display category takes. This one
+ * writes an alignments `display`'s filter only.
+ */
+export function writeReadFilter(display, displayType, settings) {
+    const { filter } = settings.snap;
+    if (displayCategory(displayType) !== 'alignments' || !filter) {
+        return undefined;
+    }
+    const filterDisplay = display;
+    filterDisplay?.setFilterFields?.(filterPatch(filter));
+    return filterDisplay?.writtenFilter;
+}
+// the pivot is the base under the view's center, which a view has only once
+// it shows a region
+function centerSort(view, trackId, field, warn) {
+    const center = view.centerLineInfo;
+    if (center && !center.oob) {
+        return {
+            field,
+            pos: basePaintedAt(center, center.offset),
+            refName: center.refName ?? '',
+        };
+    }
+    else {
+        warn(`sort:${field} on "${trackId}" ignored — the view has no center position to sort at (pass --loc)`);
+        return undefined;
+    }
+}
+// The modifiers' settings written over the entry's own as a settings bag
+// writes them (`mergeConfSettings`): a namespace such as `pileup` member by
+// member, a bare value lifted first, and a channel such as `encoding.color`
+// whole, so a `color:` modifier is not mixed into the entry's color by field.
+// Plain JSON where no registered display type says which is which.
+function overEntry(view, displayType, entry, over) {
+    const pluginManager = isStateTreeNode(view)
+        ? getEnv(view).pluginManager
+        : undefined;
+    return displayType && pluginManager?.displayTypes.has(displayType)
+        ? mergeConfSettings(pluginManager.getDisplayType(displayType).configSchema, entry, over)
+        : mergeSettings(structuredClone(entry), over);
+}
+/**
+ * Open `trackId` in `view` with its command-line modifiers applied, and return
+ * the session-spec track entry that reopens it as drawn, or undefined when the
+ * open fails, which `launchTrack` reports to the session.
+ */
+export async function launchTrackWithModifiers(view, trackId, displayType, modifiers, { displaySnapshot = {}, trackSnapshot = {}, adjust, warn = consoleWarn, } = {}) {
+    const launch = modifierLaunch(displayType, modifiers, warn);
+    const { snap, sort } = launch.settings;
+    const at = sort && centerSort(view, trackId, sort.field, warn);
+    if (at) {
+        snap.sort = at;
+    }
+    adjust?.(launch.settings);
+    const launched = overEntry(view, displayType, displaySnapshot, launchSnapshot(launch));
+    const opened = await view.launchTrack(trackId, trackSnapshot, launched);
+    if (!opened) {
+        return undefined;
+    }
+    const drawnFilter = writeFilter(view, trackId, launch.settings);
+    const members = writeMembers(view, trackId, launch.members);
+    return {
+        trackId,
+        ...launched,
+        ...(drawnFilter ? { filter: drawnFilter } : {}),
+        ...members,
+    };
+}
+/**
+ * Open a session spec's track entry in a navigated `view`, its `modifiers`
+ * written over its display settings. When a modifier or the open fails, the
+ * session's snackbar says why and the track opens with its own settings.
+ */
+export async function launchTrackInit(view, t) {
+    const { trackId, trackSnapshot, displaySnapshot, modifiers } = normalizeTrackInit(t);
+    if (modifiers.length === 0) {
+        await view.launchTrack(trackId, trackSnapshot, displaySnapshot);
+        return;
+    }
+    const session = getSession(view);
+    const { type } = displaySnapshot;
+    const notes = [];
+    try {
+        await launchTrackWithModifiers(view, trackId, openedDisplayType(session, trackId, modifiers, typeof type === 'string' ? type : undefined), modifiers, {
+            trackSnapshot,
+            displaySnapshot,
+            warn: message => notes.push(message),
+        });
+    }
+    catch (e) {
+        console.error(e);
+        session.notifyError(`"${trackId}" ${modifiers.join(' ')}: ${e}`, e);
+    }
+    // launchTrack reports its own failure, such as a display:
+    // the track cannot open as
+    if (!view.tracks.some(t => t.configuration.trackId === trackId)) {
+        await view.launchTrack(trackId, trackSnapshot, displaySnapshot);
+    }
+    if (notes.length) {
+        session.notify(notes.join('; '), 'warning');
+    }
+}
+/**
+ * Write a track's `memberWrites` onto what its display in `view` already has,
+ * after every other modifier, so a member write keeps the rest of the setting
+ * whatever order the command line gives them in. A display replaces a color
+ * or facet object whole, which is why these cannot ride in on the launch
+ * snapshot.
+ */
+export function writeMembers(view, trackId, members) {
+    if (members.length === 0) {
+        return {};
+    }
+    const track = view.tracks.find(t => t.configuration.trackId === trackId);
+    if (!track) {
+        throw new Error(`"${trackId}" is not open, so ${members.join(' ')} has nothing to write to`);
+    }
+    const { configuration } = track.activeDisplay;
+    const configured = getSnapshot(configuration);
+    const patch = memberPatch(members, root => {
+        // a list at a default the snapshot strips, Manhattan's marks, still seeds
+        // the write, so `marks.0.mark=bar` edits the mark drawn
+        const member = configuration[root];
+        return (configured[root] ??
+            (isStateTreeNode(member) && isArrayType(getType(member))
+                ? getSnapshot(member)
+                : undefined));
+    });
+    view.showTrack(trackId, {}, patch);
+    return patch;
+}

package/esm/index.d.ts

@@ -29,12 +29,14 @@ export { searchBoxMenuItems, useSearchBoxPrefs, } from './LinearGenomeView/compo
 export type { SearchBoxPrefs } from './LinearGenomeView/components/useSearchBoxPrefs.ts';
 export { normalizeTrackInit } from '@jbrowse/core/util/tracks';
 export { applyInitHighlights } from './LinearGenomeView/afterAttach.ts';
+export { launchTrackInit, launchTrackWithModifiers, openedDisplayType, writeFilter, writeMembers, writeReadFilter, } from './TrackModifiers/index.ts';
+export type { ModifierView } from './TrackModifiers/index.ts';
 export { MultiLevelRubberband, multiLevelRowClickMenuItems, multiLevelRowMenuItems, rowLabels, } from './MultiLevelRubberband/index.ts';
 export { fetchResults, SearchResultsNotFoundError } from './searchUtils.ts';
 export type { LaunchLinearGenomeViewArgs } from './LaunchLinearGenomeView/index.ts';
 export type { BpOffset, ExportSvgOptions, HighlightInput, HighlightType, InitState, LinearGenomeViewLaunchProps, NavLocation, TrackLabelMode, ViewTrackLabelMode, VolatileGuide, } from './LinearGenomeView/types.ts';
 export type { ScalebarRefNameLabel } from './LinearGenomeView/util.ts';
-export type { HighlightRegion, SearchPickerRow, SearchPickerState, } from './LinearGenomeView/model.ts';
+export type { HighlightRegion, SearchHits, SearchPickerRow, SearchPickerState, } from './LinearGenomeView/model.ts';
 export type { RegionsOrientation } from './LinearGenomeView/util.ts';
 export type { RegionEdit } from './LinearGenomeView/util.ts';
 export { makeTicks } from './LinearGenomeView/util.ts';

package/esm/index.js

@@ -71,6 +71,7 @@ export { default as HeaderSearchBoxRow } from './LinearGenomeView/components/Hea
 export { searchBoxMenuItems, useSearchBoxPrefs, } from './LinearGenomeView/components/useSearchBoxPrefs.js';
 export { normalizeTrackInit } from '@jbrowse/core/util/tracks';
 export { applyInitHighlights } from './LinearGenomeView/afterAttach.js';
+export { launchTrackInit, launchTrackWithModifiers, openedDisplayType, writeFilter, writeMembers, writeReadFilter, } from './TrackModifiers/index.js';
 export { MultiLevelRubberband, multiLevelRowClickMenuItems, multiLevelRowMenuItems, rowLabels, } from './MultiLevelRubberband/index.js';
 export { fetchResults, SearchResultsNotFoundError } from './searchUtils.js';
 // The scalebar's grid, published because it is a contract other views draw

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jbrowse/plugin-linear-genome-view",
-  "version": "5.0.0-beta.16",
+  "version": "5.0.0-beta.18",
   "type": "module",
   "description": "JBrowse 2 linear genome view",
   "keywords": [
@@ -21,15 +21,16 @@
     "esm"
   ],
   "dependencies": {
-    "@jbrowse/mobx-state-tree": "^6.9.0",
+    "@jbrowse/mobx-state-tree": "^6.10.0",
     "@mui/icons-material": "^9.5.0",
     "@mui/material": "^9.5.0",
-    "mobx": "^7.0.6",
+    "mobx": "^7.1.1",
     "mobx-react": "^10.0.2",
-    "@jbrowse/core": "^5.0.0-beta.16",
-    "@jbrowse/display-kit": "^5.0.0-beta.16",
-    "@jbrowse/display-ui": "^5.0.0-beta.16",
-    "@jbrowse/render-core": "^5.0.0-beta.16"
+    "@jbrowse/display-ui": "^5.0.0-beta.18",
+    "@jbrowse/display-kit": "^5.0.0-beta.18",
+    "@jbrowse/launch-args": "^5.0.0-beta.18",
+    "@jbrowse/render-core": "^5.0.0-beta.18",
+    "@jbrowse/core": "^5.0.0-beta.18"
   },
   "peerDependencies": {
     "react": ">=19.0.0",
@@ -40,7 +41,7 @@
   },
   "sideEffects": false,
   "devDependencies": {
-    "@jbrowse/display-test-utils": "^5.0.0-beta.16"
+    "@jbrowse/display-test-utils": "^5.0.0-beta.18"
   },
   "scripts": {
     "prebuild": "pnpm clean",