@jbrowse/plugin-linear-genome-view 5.0.0-beta.1 → 5.0.0-beta.2

package/esm/LaunchLinearGenomeView/index.js

@@ -1,22 +1,11 @@
-import { linearGenomeViewPropKeys, partitionLaunchKeys, warnUnknownLaunchKeys, } from '../LinearGenomeView/initKeys.js';
 export default function LaunchLinearGenomeViewF(pluginManager) {
     /** #extensionPoint LaunchView-LinearGenomeView | async | Programmatically launch a linear genome view */
     pluginManager.addToExtensionPoint('LaunchView-LinearGenomeView', args => {
-        const { session, id, ...spec } = args;
+        const { session, ...spec } = args;
         if (!spec.assembly) {
             throw new Error('No assembly provided when launching linear genome view');
         }
-        // Resolution keys go into the one-shot `init` blob afterAttach applies and
-        // discards; plain props go straight onto the view snapshot, where MST
-        // restores them natively (and, except for the purely localStorage-backed
-        // showCenterLine, persist on save). Anything in neither set is a typo — MST
-        // drops unknown snapshot keys and `init` is a frozen blob, so nothing
-        // downstream would notice.
-        const { init, viewProps, unknown } = partitionLaunchKeys(spec, linearGenomeViewPropKeys(pluginManager));
-        warnUnknownLaunchKeys('LaunchView-LinearGenomeView', unknown);
-        // A provided id is passed top-level so MST's optional identifier honors it
-        // (undefined falls back to an auto-generated id).
-        session.addView('LinearGenomeView', { id, ...viewProps, init });
+        session.addView('LinearGenomeView', spec);
         return args;
     });
 }

package/esm/LinearGenomeView/afterAttach.js

@@ -2,18 +2,9 @@ import { getSession, isSessionModelWithWidgets, localStorageSetItem, resolveName
 import { coerceHighlight } from '@jbrowse/core/util/highlights';
 import { installInitAutorun } from '@jbrowse/core/util/installInitAutorun';
 import { normalizeTrackInit } from '@jbrowse/core/util/tracks';
-import { addDisposer, getPropertyMembers } from '@jbrowse/mobx-state-tree';
+import { addDisposer } from '@jbrowse/mobx-state-tree';
 import { autorun, when } from 'mobx';
 import { SearchResultsNotFoundError } from '../searchUtils.js';
-import { partitionLaunchKeys, warnUnknownLaunchKeys } from './initKeys.js';
-function warnInitKeyProblems(self, init) {
-    const { viewProps, unknown } = partitionLaunchKeys(init, new Set(Object.keys(getPropertyMembers(self).properties)));
-    const viewPropKeys = Object.keys(viewProps);
-    warnUnknownLaunchKeys('LinearGenomeView init', unknown);
-    if (viewPropKeys.length) {
-        console.warn(`LinearGenomeView init ignored view prop(s): ${viewPropKeys.join(', ')} — set these on the view alongside init, not inside it`);
-    }
-}
 // `init` is a frozen blob that often comes from hand-authored JSON, where a
 // lone entry gets written bare (`tracks: 'genes'`). A string is iterable, so
 // looping over it directly walked its characters — one track opened per letter.
@@ -103,7 +94,11 @@ async function navigateInit(self, session, init) {
             // navToLocString waits for the assembly itself, and this autorun only
             // runs once `initialized` confirms init.assembly has loaded regions, so
             // no explicit waitForAssembly is needed here
-            await self.navToLocString(init.loc, init.assembly, init.grow);
+            // a spec that listed its tracks gets those tracks; one that only named
+            // a gene gets the track the gene was found in, as the search box would
+            await self.navToLocString(init.loc, init.assembly, init.grow, {
+                showHitTrack: asArray(init.tracks).length === 0,
+            });
         }
         else if (init.displayedRegionNames?.length) {
             // an explicit region list is a navigation request just like `loc`, so it
@@ -134,12 +129,13 @@ async function navigateInit(self, session, init) {
         }
     }
 }
-// showTrack funnels through showTrackGeneric, which surfaces any failure
-// (unresolved id, bad config, etc) as its own snackbar
-function showInitTracks(self, init) {
+// launchTrack funnels through showTrackGeneric, which surfaces any failure
+// (unresolved id, bad config, etc) as its own snackbar, and loads the picked
+// display's state model first when it is registered lazily
+async function showInitTracks(self, init) {
     for (const t of asArray(init.tracks)) {
         const { trackId, trackSnapshot, displaySnapshot } = normalizeTrackInit(t);
-        self.showTrack(trackId, trackSnapshot, displaySnapshot);
+        await self.launchTrack(trackId, trackSnapshot, displaySnapshot);
     }
 }
 // backfill assemblyName on any session-authored highlights that omitted it so
@@ -182,14 +178,13 @@ export function applyInitHighlights(self, session, init) {
 }
 async function applyInit(self, init, { superseded }) {
     const session = getSession(self);
-    warnInitKeyProblems(self, init);
     if (init.tracklist) {
         await openTracklist(self, session, superseded);
     }
     // `superseded`, not a bare isAlive: it subsumes the liveness check (the view
     // may have been removed while the drawer or the navigation resolved, and
     // reading or mutating a detached node throws) and also covers the case
-    // isAlive misses — a newer setInit landed mid-apply, so the rest of *this*
+    // isAlive misses — a newer setLaunch landed mid-apply, so the rest of *this*
     // blob is stale. Finishing it anyway appends its tracks and highlights under
     // the one that replaced it, and addToHighlights pushes, so a re-launch of the
     // same spec (a StrictMode remount) doubles the bands. The drain loop applies
@@ -205,7 +200,10 @@ async function applyInit(self, init, { superseded }) {
     if (superseded()) {
         return;
     }
-    showInitTracks(self, init);
+    await showInitTracks(self, init);
+    if (superseded()) {
+        return;
+    }
     if (init.nav !== undefined) {
         self.setHideHeader(!init.nav);
     }

package/esm/LinearGenomeView/components/PaddingBlocks.d.ts

@@ -3,5 +3,5 @@ type LGV = LinearGenomeViewModel;
 declare const PaddingBlocks: ({ model, offset, }: {
     model: LGV;
     offset?: number;
-}) => import("react").JSX.Element;
+}) => import("react").JSX.Element | null;
 export default PaddingBlocks;

package/esm/LinearGenomeView/components/PaddingBlocks.js

@@ -41,11 +41,21 @@ const PaddingBlocks = observer(function PaddingBlocks({ model, offset = 0, }) {
     // the geometry is `model.paddingSpans` -- shared with any host drawing this
     // itself, so a seam here and a seam in an embedder's own chrome can't be
     // computed two different ways. This file owns only what the spans look like.
+    const spans = model.paddingSpans;
+    // Nothing to mask, so no positioned container to hold it — the common case,
+    // since a view sitting inside one contig has no seam, elision or boundary.
+    // The wrapper is not free: `ZoomTransform` reads `staticBlocks`, so an empty
+    // one still re-rendered and rewrote its transform on every gesture frame, per
+    // track. The view returns one shared array here, so this bails without even
+    // re-rendering.
+    if (spans.length === 0) {
+        return null;
+    }
     const kindClass = {
         seam: classes.regionSeparator,
         elided: classes.elided,
         boundary: classes.boundaryBlock,
     };
-    return (_jsx(ZoomTransform, { model: model, offset: offset, children: _jsx("div", { className: classes.absoluteFill, children: model.paddingSpans.map(({ key, x, width, kind }) => (_jsx("div", { className: cx(classes.block, kindClass[kind]), style: { transform: `translateX(${x}px)`, width } }, key))) }) }));
+    return (_jsx(ZoomTransform, { model: model, offset: offset, children: _jsx("div", { className: classes.absoluteFill, children: spans.map(({ x, width, kind }, i) => (_jsx("div", { className: cx(classes.block, kindClass[kind]), style: { transform: `translateX(${x}px)`, width } }, i))) }) }));
 });
 export default PaddingBlocks;

package/esm/LinearGenomeView/components/SequenceSearchDialog.d.ts

@@ -1,7 +1,7 @@
 declare const SequenceSearchDialog: ({ model, handleClose, }: {
     model: {
         assemblyNames: string[];
-        showTrack: (trackId: string) => void;
+        launchTrack: (trackId: string) => Promise<unknown>;
     };
     handleClose: () => void;
 }) => import("react").JSX.Element;

package/esm/LinearGenomeView/components/ZoomButton.js

@@ -15,7 +15,12 @@ const ZoomButton = observer(function ZoomButton({ model, direction, small, }) {
         ? coarseBpPerPx >= maxBpPerPx - EPSILON
         : coarseBpPerPx <= minBpPerPx + EPSILON;
     const fontSize = small ? 'small' : undefined;
-    return (_jsx(Tooltip, { title: out ? 'Zoom out 2x' : 'Zoom in 2x', children: _jsx("span", { children: _jsx(IconButton, { "data-testid": out ? 'zoom_out' : 'zoom_in', size: small ? 'small' : undefined, disabled: disabled, onClick: () => {
+    return (_jsx(Tooltip, { title: out ? 'Zoom out 2x' : 'Zoom in 2x', children: _jsx("span", { children: _jsx(IconButton
+            // on the button, not left to the Tooltip: its title lands on the
+            // <span> the disabled case needs, so the button itself reached the
+            // accessibility tree unnamed and nothing driving by name could aim at
+            // it
+            , { "aria-label": out ? 'Zoom out' : 'Zoom in', "data-testid": out ? 'zoom_out' : 'zoom_in', size: small ? 'small' : undefined, disabled: disabled, onClick: () => {
                     model.zoom(out ? model.bpPerPx * 2 : model.bpPerPx / 2);
                 }, children: out ? (_jsx(ZoomOut, { fontSize: fontSize })) : (_jsx(ZoomIn, { fontSize: fontSize })) }) }) }));
 });

package/esm/LinearGenomeView/components/ZoomTransform.js

@@ -13,6 +13,10 @@ const useStyles = makeStyles()({
         position: 'absolute',
         height: '100%',
         pointerEvents: 'none',
+        // its own compositor layer: a pan then moves the layer instead of
+        // re-rasterizing the root layer's tiles, which paid for the gridline paths
+        // on every frame
+        willChange: 'transform',
     },
 });
 // Shared zoom/scroll-transform wrapper for the gridline ticks and padding-block

package/esm/LinearGenomeView/components/searchModes.d.ts

@@ -1,6 +1,6 @@
 export interface SequenceSearchModel {
     assemblyNames: string[];
-    showTrack: (trackId: string) => void;
+    launchTrack: (trackId: string) => Promise<unknown>;
 }
 export interface SequenceSearchModeProps {
     model: SequenceSearchModel;

package/esm/LinearGenomeView/components/searchModes.js

@@ -14,7 +14,7 @@ export function addReferenceScanTrack(model, args) {
             type: 'FeatureTrack',
             adapter: args.adapter,
         });
-        model.showTrack(args.trackId);
+        void model.launchTrack(args.trackId);
     }
     else {
         session.notify('This session does not support adding tracks', 'warning');

package/esm/LinearGenomeView/index.d.ts

@@ -25,6 +25,7 @@ declare module '@jbrowse/core/PluginManager' {
 }
 export default function LinearGenomeViewF(pluginManager: PluginManager): void;
 export { stateModelFactory } from './model.ts';
+export { lgvLaunchKeys } from './launchKeys.ts';
 export type { LinearGenomeViewModel, LinearGenomeViewStateModel, } from './model.ts';
 export type { BpOffset, ExportSvgOptions, HighlightType, InitState, LinearGenomeViewLaunchProps, NavLocation, TrackLabelMode, VolatileGuide, } from './types.ts';
 export { type SyncableViewAction, installLinkedViewSync, } from './linkedViewSync.ts';

package/esm/LinearGenomeView/index.js

@@ -1,17 +1,24 @@
 import { lazy } from 'react';
 import { ViewType } from '@jbrowse/core/pluggableElementTypes';
+import { lgvLaunchKeys } from './launchKeys.js';
 import { stateModelFactory } from './model.js';
 export default function LinearGenomeViewF(pluginManager) {
     pluginManager.addViewType(() => {
+        // annotated against the registry rather than inferred, which is what
+        // makes a hand-written augmentation earn what `getViewType` promises
+        // its callers — see `ViewTypeRegistry`
+        const stateModel = stateModelFactory(pluginManager);
         return new ViewType({
             name: 'LinearGenomeView',
             displayName: 'Linear genome view',
-            stateModel: stateModelFactory(pluginManager),
+            stateModel,
+            launchKeys: lgvLaunchKeys,
             ReactComponent: lazy(() => import('./components/LinearGenomeView.js')),
         });
     });
 }
 export { stateModelFactory } from './model.js';
+export { lgvLaunchKeys } from './launchKeys.js';
 export { installLinkedViewSync, } from './linkedViewSync.js';
 export { default as HighlightBand } from './components/HighlightBand.js';
 export { default as HighlightChip } from './components/HighlightChip.js';

package/esm/LinearGenomeView/initKeys.d.ts

@@ -10,4 +10,3 @@ export declare function linearGenomeViewPropKeys(pluginManager: {
         };
     };
 }): ReadonlySet<string>;
-export declare function warnUnknownLaunchKeys(surface: string, unknown: object): void;

package/esm/LinearGenomeView/initKeys.js

@@ -1,39 +1,13 @@
-// The init keys are derived from their interface so they can't drift: the
-// Record requires exactly one entry per key, so adding a field without listing
-// it here is a compile error rather than a key that silently warns as "unknown".
-//
-// There is no matching list for the plain view props, and there must not be:
-// they are whatever the state model declares, read off it by the caller and
-// passed in as `viewPropKeys`. A hand-written eight is what left `hideHeader`,
-// `showGridlines`, `showCytobands` and five others declared, menu-settable and
-// silently unreachable from any spec — the same failure LinearSyntenyView's
-// `drawLocationMarkers` had.
-//
-// #launchKeys LinearGenomeView — the URL parameters page renders this list
-// rather than restating it; each of these keys has its own `&param=` section
-// there, which is why no description is attached here.
-const knownInitKeyMap = {
-    loc: true,
-    grow: true,
-    assembly: true,
-    displayedRegionNames: true,
-    tracks: true,
-    tracklist: true,
-    nav: true,
-    highlight: true,
-};
-const knownInitKeys = new Set(Object.keys(knownInitKeyMap));
+import { lgvLaunchKeys } from './launchKeys.js';
+// The remaining v4 partition, still used by the synteny view to build its LGV
+// rows. `lgvLaunchKeys` is the one declaration of what a launch key is, so the
+// two cannot disagree while both exist.
+const knownInitKeys = new Set(Object.keys(lgvLaunchKeys.keys));
 // Never settable from a spec, whatever the model declares: `type` picks the
-// view and `id` is passed top-level so MST's optional identifier honors it.
-const RESERVED = new Set(['id', 'type', 'init']);
-// The viewport keys from before it was stored as a window. They are no longer
-// declared properties, so the model's own property list does not contain them
-// and they would partition as typos — reported as unknown and dropped. They are
-// not typos: `preProcessSnapshot` still converts them, so they belong in the
-// snapshot bucket, and a URL or saved spec that names them goes on working.
-//
-// Deletable with `legacyBpPerPx` in the model, and for the same reason.
-const LEGACY_VIEWPORT_PROPS = new Set(['bpPerPx', 'offsetPx']);
+// view, `id` is passed top-level so MST's optional identifier honors it, and
+// `launch` is the blob the partition fills rather than something anyone writes.
+const RESERVED = new Set(['id', 'type', 'launch']);
+const LEGACY_VIEWPORT_PROPS = new Set(lgvLaunchKeys.passThrough);
 // Partition launch keys three ways, once, for every caller that needs to know
 // which is which:
 //
@@ -92,13 +66,3 @@ export function linearGenomeViewPropKeys(pluginManager) {
     propKeyCache.set(pluginManager, keys);
     return keys;
 }
-// Report the `unknown` bucket. Both callers say the same thing about the same
-// mistake and differ only in which surface they name, so the wording lives next
-// to the partition that produces the bucket rather than in two hand-written
-// copies that drift.
-export function warnUnknownLaunchKeys(surface, unknown) {
-    const keys = Object.keys(unknown);
-    if (keys.length) {
-        console.warn(`${surface} ignored unknown key(s): ${keys.join(', ')}`);
-    }
-}

package/esm/LinearGenomeView/launchKeys.d.ts

@@ -0,0 +1,2 @@
+import type { InitState } from './types.ts';
+export declare const lgvLaunchKeys: import("@jbrowse/core/util/withLaunchInput").LaunchKeyRegistration<InitState, "bpPerPx" | "offsetPx">;

package/esm/LinearGenomeView/launchKeys.js

@@ -0,0 +1,23 @@
+import { defineLaunchKeys } from '@jbrowse/core/util/withLaunchInput';
+// The argument is `Record<keyof InitState, LaunchKeySpec>`, so a command this
+// view interprets and nobody registered here is a compile error rather than a
+// key that partitions as a typo.
+//
+// `bpPerPx`/`offsetPx` are the viewport spelling from before it was stored as a
+// window. They are no longer declared properties, so the partition would read
+// them as typos; the model's own preProcessSnapshot still converts them, so a
+// URL or saved spec naming them goes on working. Deletable with `legacyBpPerPx`.
+//
+// #launchKeys LinearGenomeView — the URL parameters page renders this list
+// rather than restating it; each of these keys has its own `&param=` section
+// there, which is why no description is attached here.
+export const lgvLaunchKeys = defineLaunchKeys()({
+    loc: { kind: 'launch' },
+    grow: { kind: 'launch' },
+    assembly: { kind: 'launch' },
+    displayedRegionNames: { kind: 'launch' },
+    tracklist: { kind: 'launch' },
+    nav: { kind: 'launch' },
+    tracks: { kind: 'trackEntries' },
+    highlight: { kind: 'highlightEntries' },
+}, { passThrough: ['bpPerPx', 'offsetPx'] });

package/esm/LinearGenomeView/lazyDialogs.d.ts

@@ -7,7 +7,7 @@ export declare const ReturnToImportFormDialog: import("react").LazyExoticCompone
 export declare const SequenceSearchDialog: import("react").LazyExoticComponent<({ model, handleClose, }: {
     model: {
         assemblyNames: string[];
-        showTrack: (trackId: string) => void;
+        launchTrack: (trackId: string) => Promise<unknown>;
     };
     handleClose: () => void;
 }) => import("react").JSX.Element>;

package/esm/LinearGenomeView/linkedViewSync.d.ts

@@ -6,7 +6,7 @@ import type { IStateTreeNode } from '@jbrowse/mobx-state-tree';
  * arrays in each parent view) means the dispatch below stays exhaustive and a
  * typo can't silently produce a no-op sync.
  */
-export type SyncableViewAction = 'horizontalScroll' | 'zoomTo' | 'showTrack' | 'toggleTrack' | 'hideTrack' | 'setTrackLabels' | 'setShowCenterLine';
+export type SyncableViewAction = 'horizontalScroll' | 'zoomTo' | 'showTrack' | 'toggleTrack' | 'launchTrack' | 'launchToggleTrack' | 'hideTrack' | 'setTrackLabels' | 'setShowCenterLine';
 interface LinkableViews {
     linkViews: boolean;
     views: LinearGenomeViewModel[];

package/esm/LinearGenomeView/linkedViewSync.js

@@ -13,6 +13,12 @@ function applyViewAction(view, name, args) {
         case 'toggleTrack':
             view.toggleTrack(args[0]);
             break;
+        case 'launchTrack':
+            void view.launchTrack(args[0]);
+            break;
+        case 'launchToggleTrack':
+            void view.launchToggleTrack(args[0]);
+            break;
         case 'hideTrack':
             view.hideTrack(args[0]);
             break;