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

package/esm/LinearGenomeView/keyboardHandler.js

@@ -1,34 +1,72 @@
 import { getSession } from '@jbrowse/core/util';
+import { isTextEntryFocused } from '@jbrowse/core/util/isTextEntryFocused';
 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
- */
+// every entry also needs Ctrl or Cmd; an arrow fires with or without Shift
+export const lgvKeyboardShortcuts = [
+    {
+        keys: 'Ctrl/Cmd + ←',
+        description: 'Pan left',
+        code: 'ArrowLeft',
+        run: self => {
+            self.slide(-0.9);
+        },
+    },
+    {
+        keys: 'Ctrl/Cmd + →',
+        description: 'Pan right',
+        code: 'ArrowRight',
+        run: self => {
+            self.slide(0.9);
+        },
+    },
+    {
+        keys: 'Ctrl/Cmd + ↑',
+        description: 'Zoom in',
+        code: 'ArrowUp',
+        run: self => {
+            self.zoom(self.bpPerPx / 2);
+        },
+    },
+    {
+        keys: 'Ctrl/Cmd + ↓',
+        description: 'Zoom out',
+        code: 'ArrowDown',
+        run: self => {
+            self.zoom(self.bpPerPx * 2);
+        },
+    },
+    {
+        keys: 'Ctrl/Cmd + Shift + D',
+        description: 'Highlight the region in view',
+        code: 'KeyD',
+        shift: true,
+        run: self => {
+            self.highlightCurrentRegion();
+            getSession(self).notify('Region highlighted.', 'success');
+        },
+    },
+    {
+        keys: 'Ctrl/Cmd + Shift + M',
+        description: 'Go to the newest highlight',
+        code: 'KeyM',
+        shift: true,
+        run: self => {
+            void self.navigateNewestHighlight();
+        },
+    },
+];
 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)) {
-            if (e.code === 'ArrowLeft') {
+        if (getSession(self).focusedViewId === self.id &&
+            (e.ctrlKey || e.metaKey) &&
+            !isTextEntryFocused()) {
+            const shortcut = lgvKeyboardShortcuts.find(s => s.code === e.code && (!s.shift || e.shiftKey));
+            if (shortcut) {
                 e.preventDefault();
-                self.slide(-0.9);
-            }
-            else if (e.code === 'ArrowRight') {
-                e.preventDefault();
-                self.slide(0.9);
-            }
-            else if (e.code === 'ArrowUp') {
-                e.preventDefault();
-                self.zoom(self.bpPerPx / 2);
-            }
-            else if (e.code === 'ArrowDown') {
-                e.preventDefault();
-                self.zoom(self.bpPerPx * 2);
+                shortcut.run(self);
             }
         }
     }

package/esm/LinearGenomeView/launchKeys.d.ts

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

package/esm/LinearGenomeView/launchKeys.js

@@ -3,10 +3,12 @@ import { defineLaunchKeys } from '@jbrowse/core/util/withLaunchInput';
 // 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`.
+// `bpPerPx`/`offsetPx` are v4's viewport spelling from before it was stored as
+// a window, `showCytobandsSetting` its cytoband toggle and `colorByCDS` its
+// frame coloring. None is a declared property, 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. Share links carry all four, so they
+// stay.
 //
 // #launchKeys LinearGenomeView — the URL parameters page renders this list
 // rather than restating it; each of these keys has its own `&param=` section
@@ -14,10 +16,13 @@ import { defineLaunchKeys } from '@jbrowse/core/util/withLaunchInput';
 export const lgvLaunchKeys = defineLaunchKeys()({
     loc: { kind: 'launch' },
     grow: { kind: 'launch' },
+    showHitTrack: { kind: 'launch' },
     assembly: { kind: 'launch' },
     displayedRegionNames: { kind: 'launch' },
     tracklist: { kind: 'launch' },
     nav: { kind: 'launch' },
     tracks: { kind: 'trackEntries' },
-    highlight: { kind: 'highlightEntries' },
-}, { passThrough: ['bpPerPx', 'offsetPx'] });
+    highlight: { kind: 'launch' },
+}, {
+    passThrough: ['bpPerPx', 'offsetPx', 'showCytobandsSetting', 'colorByCDS'],
+});

package/esm/LinearGenomeView/lazyDialogs.d.ts

@@ -5,15 +5,28 @@ export declare const ReturnToImportFormDialog: import("react").LazyExoticCompone
     handleClose: () => void;
 }) => import("react").JSX.Element>;
 export declare const SequenceSearchDialog: import("react").LazyExoticComponent<({ model, handleClose, }: {
+    model: import("./components/searchModes.ts").SequenceSearchModel;
+    handleClose: () => void;
+}) => import("react").JSX.Element>;
+export declare const ExportSvgDialog: import("react").LazyExoticComponent<({ model, handleClose, chooseWidth, }: {
     model: {
-        assemblyNames: string[];
-        launchTrack: (trackId: string) => Promise<unknown>;
+        width?: number;
+        effectiveTrackLabels?: import("@jbrowse/display-kit/types").ViewTrackLabelMode;
+        exportSvg(opts: import("@jbrowse/core/ui").BaseExportSvgOptions & {
+            trackLabels: import("@jbrowse/display-kit/types").TrackLabelMode;
+            showGridlines: boolean;
+            viewWidth?: number;
+        }): Promise<unknown>;
     };
     handleClose: () => void;
+    chooseWidth?: boolean;
 }) => 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, regions, handleClose, }: {
     model: import("@jbrowse/mobx-state-tree").IAnyStateTreeNode;
     regions: import("@jbrowse/core/util").Region[];
     handleClose: () => void;
 }) => import("react").JSX.Element>;
+export declare const RegionWidthEditorDialog: import("react").LazyExoticComponent<({ model, handleClose, }: {
+    model: import("./model.ts").LinearGenomeViewModel;
+    handleClose: () => void;
+}) => import("react").JSX.Element>;

package/esm/LinearGenomeView/lazyDialogs.js

@@ -3,3 +3,4 @@ export const ReturnToImportFormDialog = lazy(() => import('@jbrowse/core/ui/Retu
 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 RegionWidthEditorDialog = lazy(() => import('./components/RegionWidthEditorDialog.js'));

package/esm/LinearGenomeView/linkedViewSync.d.ts

@@ -1,20 +1,12 @@
 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.
+ * While `linkViews` is on, replay each pan, zoom and track toggle made on one
+ * sub-view onto every other, with the same arguments.
  */
-export declare function installLinkedViewSync(self: IStateTreeNode & LinkableViews, syncActions: readonly SyncableViewAction[]): void;
+export declare function installLinkedViewSync(self: IStateTreeNode & LinkableViews): void;
 export {};

package/esm/LinearGenomeView/linkedViewSync.js

@@ -1,58 +1,36 @@
-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;
-    }
+import { addDisposer, addMiddleware } from '@jbrowse/mobx-state-tree';
+const LINKED_ACTIONS = [
+    'horizontalScroll',
+    'zoomTo',
+    'showTrack',
+    'toggleTrack',
+    'launchTrack',
+    'launchToggleTrack',
+    'hideTrack',
+    'setTrackLabels',
+    'setShowCenterLine',
+];
+function isLinkedAction(name) {
+    return LINKED_ACTIONS.includes(name);
 }
 /**
- * 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.
+ * While `linkViews` is on, replay each pan, zoom and track toggle made on one
+ * sub-view onto every other, with the same arguments.
  */
-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);
+export function installLinkedViewSync(self) {
+    addDisposer(self, addMiddleware(self, (call, next) => {
+        next(call);
+        const { name, args, context } = call;
+        if (call.type === 'action' &&
+            call.id === call.rootId &&
+            self.linkViews &&
+            isLinkedAction(name)) {
             for (const view of self.views) {
-                if (getPath(view) !== sourcePath) {
-                    applyViewAction(view, handler, rawCall.args);
+                if (view !== context) {
+                    const action = view[name];
+                    void action(...args);
                 }
             }
         }
-        else {
-            next(rawCall);
-        }
     }));
 }

package/esm/LinearGenomeView/menuItems.d.ts

@@ -1,29 +1,27 @@
 import type { LinearGenomeViewModel } from './model.ts';
 import type { BpOffset } from './types.ts';
 import type { MenuItem } from '@jbrowse/core/ui';
+export declare function zoomMenuItems(self: LinearGenomeViewModel): MenuItem[];
+export declare function buildHighlightsSubMenuItems(self: LinearGenomeViewModel): MenuItem[];
 /**
- * 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.
+ * Build the main view menu items. A row stacked in another view has no import
+ * form of its own, so only a top-level view offers the way back to one.
  */
-export declare function showAllRegionsMenuItem(self: LinearGenomeViewModel): MenuItem;
+export declare function buildMenuItems(self: LinearGenomeViewModel): MenuItem[];
 /**
- * Build the main view menu items
+ * Open a copy of the view, tracks and their settings included, framed on the
+ * span between two offsets. The same copy as the view menu's "Copy view", and
+ * nothing links it back to the original.
  */
-export declare function buildMenuItems(self: LinearGenomeViewModel): MenuItem[];
+export declare function openSpanInNewView(view: LinearGenomeViewModel, start?: BpOffset, end?: BpOffset): import("@jbrowse/core/util").AbstractViewModel | undefined;
 /**
- * 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.
+ * Build rubberband selection menu items. What a selection can open collects
+ * under one "Launch" submenu, which sorts last, below any row a plugin appends
+ * to the menu itself: a new linear genome view of the span first, then
+ * `launchItems`, the plugin-supplied ones (`rubberBandLaunchMenuItems()`).
+ *
+ * The new view is a copy of this one, so only a top-level view offers it: a row
+ * of a comparative view carries that view's framing, such as a hidden header.
  */
 export declare function buildRubberBandMenuItems(self: LinearGenomeViewModel, launchItems: MenuItem[]): MenuItem[];
 /**