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

package/esm/LinearGenomeView/index.js

@@ -1,16 +1,26 @@
 import { lazy } from 'react';
 import { ViewType } from '@jbrowse/core/pluggableElementTypes';
-import { stateModelFactory } from "./model.js";
+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),
-            ReactComponent: lazy(() => import("./components/LinearGenomeView.js")),
+            stateModel,
+            launchKeys: lgvLaunchKeys,
+            ReactComponent: lazy(() => import('./components/LinearGenomeView.js')),
         });
     });
 }
-export * from "./model.js";
-export * from "./types.js";
-export { default as HighlightBand } from "./components/HighlightBand.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';
+export { default as OverviewHighlightBand } from './components/OverviewHighlightBand.js';
+export { default as SVGHighlightBand } from './components/SVGHighlightBand.js';

package/esm/LinearGenomeView/initKeys.d.ts

@@ -0,0 +1,12 @@
+export declare function partitionLaunchKeys(spec: object, viewPropKeys: ReadonlySet<string>): {
+    init: Record<string, unknown>;
+    viewProps: Record<string, unknown>;
+    unknown: Record<string, unknown>;
+};
+export declare function linearGenomeViewPropKeys(pluginManager: {
+    getViewType: (name: string) => {
+        stateModel: {
+            properties: object;
+        };
+    };
+}): ReadonlySet<string>;

package/esm/LinearGenomeView/initKeys.js

@@ -0,0 +1,68 @@
+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, `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:
+//
+// - `init`: resolution keys (loc, tracks, highlight, …) with no direct MST
+//   representation, which afterAttach applies on attach and then discards
+// - `viewProps`: plain persisted props MST restores natively, so they belong on
+//   the view snapshot rather than in the blob
+// - `unknown`: neither, i.e. a typo. MST silently drops unknown snapshot keys and
+//   `init` is a frozen blob, so nothing else would notice
+//
+// The two callers differ only in what they do with each bucket: the launcher
+// spreads a flat spec across the new view's snapshot and warns about the typos,
+// while afterAttach — which only ever sees an already-built blob — warns about
+// both a typo and a view prop that ended up inside it.
+export function partitionLaunchKeys(spec, 
+// The view's declared property names. Callers with a live node read it off
+// `getPropertyMembers(self).properties`; callers building a snapshot read it
+// off the registered view type's `stateModel.properties` — see
+// `linearGenomeViewPropKeys`.
+viewPropKeys) {
+    const init = {};
+    const viewProps = {};
+    const unknown = {};
+    for (const [key, value] of Object.entries(spec)) {
+        const bucket = knownInitKeys.has(key)
+            ? init
+            : (viewPropKeys.has(key) || LEGACY_VIEWPORT_PROPS.has(key)) &&
+                !RESERVED.has(key)
+                ? viewProps
+                : unknown;
+        bucket[key] = value;
+    }
+    return { init, viewProps, unknown };
+}
+// The registered LinearGenomeView's declared property names, for a caller that
+// has a PluginManager but no view yet (a launcher, or a synteny row being built).
+// A caller holding a live node reads the same thing off
+// `getPropertyMembers(self).properties` instead.
+//
+// `getViewType` THROWS on an unregistered name, and that is left alone: this is
+// only ever called from code that is about to add a LinearGenomeView, so an
+// absent view type is a broken plugin manager rather than a case to degrade
+// through — and degrading would mean silently dropping every property the
+// caller asked for, which is the failure this whole mechanism exists to end.
+//
+// Cached: the set is fixed for the life of the manager, and a launch that opens
+// a stack of rows would otherwise rebuild it per row.
+const propKeyCache = new WeakMap();
+export function linearGenomeViewPropKeys(pluginManager) {
+    const cached = propKeyCache.get(pluginManager);
+    if (cached) {
+        return cached;
+    }
+    const { stateModel } = pluginManager.getViewType('LinearGenomeView');
+    const keys = new Set(Object.keys(stateModel.properties));
+    propKeyCache.set(pluginManager, keys);
+    return keys;
+}

package/esm/LinearGenomeView/keyboardHandler.d.ts

@@ -1,2 +1,9 @@
 import type { LinearGenomeViewModel } from './model.ts';
+/**
+ * Sets up keyboard shortcuts for the LinearGenomeView
+ * - Ctrl/Cmd + ArrowLeft: slide left
+ * - Ctrl/Cmd + ArrowRight: slide right
+ * - Ctrl/Cmd + ArrowUp: zoom in
+ * - Ctrl/Cmd + ArrowDown: zoom out
+ */
 export declare function setupKeyboardHandler(self: LinearGenomeViewModel): void;

package/esm/LinearGenomeView/keyboardHandler.js

@@ -1,6 +1,16 @@
 import { getSession } from '@jbrowse/core/util';
 import { addDisposer } from '@jbrowse/mobx-state-tree';
+/**
+ * Sets up keyboard shortcuts for the LinearGenomeView
+ * - Ctrl/Cmd + ArrowLeft: slide left
+ * - Ctrl/Cmd + ArrowRight: slide right
+ * - Ctrl/Cmd + ArrowUp: zoom in
+ * - Ctrl/Cmd + ArrowDown: zoom out
+ */
 export function setupKeyboardHandler(self) {
+    if (typeof document === 'undefined') {
+        return;
+    }
     function handler(e) {
         const session = getSession(self);
         if (session.focusedViewId === self.id && (e.ctrlKey || e.metaKey)) {

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

@@ -3,21 +3,17 @@ export declare const ReturnToImportFormDialog: import("react").LazyExoticCompone
         clearView: () => void;
     };
     handleClose: () => void;
-}) => import("react/jsx-runtime").JSX.Element>;
+}) => import("react").JSX.Element>;
 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-runtime").JSX.Element>;
+}) => import("react").JSX.Element>;
 export declare const ExportSvgDialog: import("react").LazyExoticComponent<typeof import("./components/ExportSvgDialog.tsx").default>;
-export declare const GetSequenceDialog: import("react").LazyExoticComponent<({ model, handleClose, }: {
-    model: {
-        leftOffset?: import("./types.ts").BpOffset;
-        rightOffset?: import("./types.ts").BpOffset;
-        getSelectedRegions: (left?: import("./types.ts").BpOffset, right?: import("./types.ts").BpOffset) => import("@jbrowse/core/util").Region[];
-        setOffsets: (left?: import("./types.ts").BpOffset, right?: import("./types.ts").BpOffset) => void;
-    };
+export declare const GetSequenceDialog: import("react").LazyExoticComponent<({ model, regions, handleClose, }: {
+    model: import("@jbrowse/mobx-state-tree").IAnyStateTreeNode;
+    regions: import("@jbrowse/core/util").Region[];
     handleClose: () => void;
-}) => import("react/jsx-runtime").JSX.Element>;
+}) => import("react").JSX.Element>;

package/esm/LinearGenomeView/lazyDialogs.js

@@ -1,5 +1,5 @@
 import { lazy } from 'react';
 export const ReturnToImportFormDialog = lazy(() => import('@jbrowse/core/ui/ReturnToImportFormDialog'));
-export const SequenceSearchDialog = lazy(() => import("./components/SequenceSearchDialog.js"));
-export const ExportSvgDialog = lazy(() => import("./components/ExportSvgDialog.js"));
-export const GetSequenceDialog = lazy(() => import("./components/GetSequenceDialog.js"));
+export const SequenceSearchDialog = lazy(() => import('./components/SequenceSearchDialog.js'));
+export const ExportSvgDialog = lazy(() => import('./components/ExportSvgDialog.js'));
+export const GetSequenceDialog = lazy(() => import('./components/GetSequenceDialog.js'));

package/esm/LinearGenomeView/linkedViewSync.d.ts

@@ -0,0 +1,20 @@
+import type { LinearGenomeViewModel } from './model.ts';
+import type { IStateTreeNode } from '@jbrowse/mobx-state-tree';
+/**
+ * The single source of truth for which LinearGenomeView actions can be
+ * replayed across linked views. Keeping it here (rather than as loose string
+ * 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' | 'launchTrack' | 'launchToggleTrack' | 'hideTrack' | 'setTrackLabels' | 'setShowCenterLine';
+interface LinkableViews {
+    linkViews: boolean;
+    views: LinearGenomeViewModel[];
+}
+/**
+ * Install a middleware that, while `linkViews` is on, replays each listed
+ * action onto every other sub-view so panning/zooming/track-toggling stays in
+ * sync. Used by linear-comparative-view and breakpoint-split-view.
+ */
+export declare function installLinkedViewSync(self: IStateTreeNode & LinkableViews, syncActions: readonly SyncableViewAction[]): void;
+export {};

package/esm/LinearGenomeView/linkedViewSync.js

@@ -0,0 +1,58 @@
+import { addDisposer, addMiddleware, getPath } from '@jbrowse/mobx-state-tree';
+function applyViewAction(view, name, args) {
+    switch (name) {
+        case 'horizontalScroll':
+            view.horizontalScroll(args[0]);
+            break;
+        case 'zoomTo':
+            view.zoomTo(args[0]);
+            break;
+        case 'showTrack':
+            view.showTrack(args[0]);
+            break;
+        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;
+        case 'setTrackLabels':
+            view.setTrackLabels(args[0]);
+            break;
+        case 'setShowCenterLine':
+            view.setShowCenterLine(args[0]);
+            break;
+    }
+}
+/**
+ * Install a middleware that, while `linkViews` is on, replays each listed
+ * action onto every other sub-view so panning/zooming/track-toggling stays in
+ * sync. Used by linear-comparative-view and breakpoint-split-view.
+ */
+export function installLinkedViewSync(self, syncActions) {
+    addDisposer(self, addMiddleware(self, (rawCall, next) => {
+        const handler = rawCall.type === 'action' &&
+            rawCall.id === rawCall.rootId &&
+            self.linkViews
+            ? syncActions.find(action => action === rawCall.name)
+            : undefined;
+        if (handler) {
+            const sourcePath = getPath(rawCall.context);
+            next(rawCall);
+            for (const view of self.views) {
+                if (getPath(view) !== sourcePath) {
+                    applyViewAction(view, handler, rawCall.args);
+                }
+            }
+        }
+        else {
+            next(rawCall);
+        }
+    }));
+}

package/esm/LinearGenomeView/menuItems.d.ts

@@ -1,7 +1,32 @@
 import type { LinearGenomeViewModel } from './model.ts';
 import type { BpOffset } from './types.ts';
 import type { MenuItem } from '@jbrowse/core/ui';
-export declare function rewriteOnClicks(self: LinearGenomeViewModel, trackType: string, viewMenuActions: MenuItem[]): void;
+/**
+ * Zoom all the way out, shared by the view menu and the header's zoom menu —
+ * one definition so the two cannot drift in label, and the view menu is the
+ * only one of the two that survives `hideHeader`.
+ *
+ * The zoom menu earns it on the merits: this is the bottom of the same "Zoom
+ * out 100x" ladder, and it is where someone already zooming looks.
+ *
+ * The label is the import form's button text verbatim (`ImportForm.tsx`), which
+ * is where most people meet the phrase. No icon: the four-arrows glyph it
+ * carried reads as "fullscreen", and nothing else names the same gesture, so a
+ * substitute would be decoration rather than a distinction.
+ */
+export declare function showAllRegionsMenuItem(self: LinearGenomeViewModel): MenuItem;
+/**
+ * Build the main view menu items
+ */
 export declare function buildMenuItems(self: LinearGenomeViewModel): MenuItem[];
-export declare function buildRubberBandMenuItems(self: LinearGenomeViewModel): MenuItem[];
+/**
+ * Build rubberband selection menu items. `launchItems` are the plugin-supplied
+ * things a selection can start (`rubberBandLaunchMenuItems()`); they collect
+ * under one "Launch" submenu so the menu stays three actions plus a group
+ * however many plugins are loaded, and vanish entirely when none apply.
+ */
+export declare function buildRubberBandMenuItems(self: LinearGenomeViewModel, launchItems: MenuItem[]): MenuItem[];
+/**
+ * Build rubberband click menu items (single click on rubberband area)
+ */
 export declare function buildRubberbandClickMenuItems(self: LinearGenomeViewModel, clickOffset: BpOffset): MenuItem[];