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

package/esm/LinearGenomeView/flyTo.js

@@ -0,0 +1,135 @@
+import { clamp } from '@jbrowse/core/util';
+// The paper's rho: how much the path is willing to zoom out to cover distance.
+// Their section 6 user experiment measured 1.42 (sd 0.47), and they note that
+// it "suggests that rho = sqrt(2) is possibly an optimal value" without being
+// able to say why; d3-interpolateZoom takes the same sqrt(2). Lower flattens
+// the arc into a pan, higher pulls further back and travels faster, and it is
+// the one knob to reach for if the zoomed-out apex ever proves too expensive to
+// fetch through.
+//
+// IT DOES NOT TODAY, and the arithmetic that says it should is worth
+// contradicting explicitly. A cross-chromosome flight over stacked whole
+// assemblies traces ~15 octaves of zoom out and ~15 back, and synteny's fetch
+// key buckets on `floor(log2(bpPerPx))` — so a flight crosses ~30 fetch buckets
+// where a pan at constant zoom crosses none. Measured against
+// `demos/grape_peach_cacao` it costs exactly ONE extra RPC over the instant
+// jump (2 against 1), because the 500ms leading-edge debounce absorbs the whole
+// excursion: one fetch leaving, one on landing.
+// `agent-docs/measurements/synteny-mate-flight.json`.
+const RHO = Math.sqrt(2);
+// WHERE WE PART COMPANY WITH THE PAPER, and the one number in here that is not
+// theirs. `S` is a path length in their dimensionless units of perceived
+// motion, growing with the LOG of the distance: half a screen scores 0.7, one
+// screen 1.2, a hundred screens 7.5, a whole genome 12. Their section 6
+// measured an animation speed V of 0.90 of those units per second, which would
+// put that whole-genome flight at THIRTEEN SECONDS — a wait, not a transition,
+// and their own scenario (a map of the US) never asks for a path that long.
+//
+// So the duration is clamped instead: a floor for the hops too short to need
+// time, a ceiling for the cross-genome one, and a rate between. At the ceiling
+// that is an effective V around 11, an order of magnitude above what they
+// measured, and it is the deliberate cost of not making the reader wait.
+// Perceived velocity is still constant WITHIN a flight — that is equation (9)'s
+// doing, not this — and this only picks the total.
+const MS_PER_UNIT = 90;
+const MIN_MS = 250;
+const MAX_MS = 1100;
+// Below this much motion, relative to the window it happens in, the pan is
+// treated as none at all. RELATIVE, not absolute: the general solution divides
+// by the distance, so a sub-bp move between two different zooms sends `b`
+// through infinity and `at` returns NaN — and an absolute epsilon that is small
+// against a 250Mb chromosome is not small against a 500bp window.
+const STATIONARY = 1e-6;
+/**
+ * The viewport path from `from` to `to`, and how long to spend on it.
+ *
+ * The path is equation (9) of the paper cited at the top of this file: it zooms
+ * out as it travels and back in as it arrives, along the geodesic that holds
+ * the *perceived* velocity constant, so the reader can follow the whole journey
+ * rather than watching one blurred smear.
+ *
+ * A STRAIGHT PAN IS NOT THE ALTERNATIVE, it is the thing this exists to avoid.
+ * The jump that wants animating here is a synteny row showing a whole assembly
+ * being sent to a mate on another chromosome: tens of megabases at a window of
+ * tens of kilobases, which is a thousand screens of travel. Panned at constant
+ * scale that is a thousand screens of unreadable streaking and no frame in
+ * which the reader is anywhere identifiable. Pulled back to where both ends fit
+ * and then dropped in, it is a picture of where they came from and where they
+ * landed.
+ *
+ * The zoomed-out apex is `w0 * cosh(r0)` — for a same-zoom hop, about the
+ * distance travelled — so the arc naturally tops out at "both endpoints on
+ * screen". A view whose `maxBpPerPx` is tighter than that simply clamps there
+ * and flies the middle of the path flat; nothing here has to know the limit,
+ * because the caller writes through `zoomTo` and reads back what it got.
+ */
+export function planFlight(from, to) {
+    const w0 = from.windowWidthBp;
+    const w1 = to.windowWidthBp;
+    const delta = to.centerBp - from.centerBp;
+    const dist = Math.abs(delta);
+    const at = dist > Math.max(w0, w1) * STATIONARY
+        ? zoomAndPan(from, to, dist, Math.sign(delta))
+        : zoomInPlace(from, to);
+    return {
+        durationMs: at ? clamp(at.S * MS_PER_UNIT, MIN_MS, MAX_MS) : 0,
+        // Snapped at the end rather than left to the closed form, whose `u(S)`
+        // reaches the destination only to within the rounding of two hyperbolics.
+        at: t => (at && t < 1 ? at.at(t) : to),
+    };
+}
+// Equation (9), term for term. `u` runs along the path in world units from the
+// start, and the two `r` are where the start and end sit on the ellipse the
+// path traces. The paper's `u1 - u0` is signed; here the caller's sign is
+// carried separately in `direction` and `dist` is its magnitude, so that u0 = 0
+// and the two forms agree.
+function zoomAndPan(from, to, dist, direction) {
+    const w0 = from.windowWidthBp;
+    const w1 = to.windowWidthBp;
+    const rho2 = RHO * RHO;
+    const rho4 = rho2 * rho2;
+    const b0 = (w1 * w1 - w0 * w0 + rho4 * dist * dist) / (2 * w0 * rho2 * dist);
+    const b1 = (w1 * w1 - w0 * w0 - rho4 * dist * dist) / (2 * w1 * rho2 * dist);
+    // asinh(-b), which is exactly the ln(-b + sqrt(b*b + 1)) equation (9) writes
+    // (and d3 implements literally) — but evaluated without the catastrophic
+    // cancellation those two terms suffer at the far end of a cross-genome jump,
+    // where b runs to a thousand and they agree to seven digits before
+    // subtracting. Same value, better conditioned.
+    const r0 = Math.asinh(-b0);
+    const r1 = Math.asinh(-b1);
+    const S = (r1 - r0) / RHO;
+    const coshR0 = Math.cosh(r0);
+    const sinhR0 = Math.sinh(r0);
+    return S > 0
+        ? {
+            S,
+            at: (t) => {
+                const s = t * S * RHO + r0;
+                return {
+                    centerBp: from.centerBp +
+                        direction *
+                            ((w0 / rho2) * coshR0 * Math.tanh(s) - (w0 / rho2) * sinhR0),
+                    windowWidthBp: (w0 * coshR0) / Math.cosh(s),
+                };
+            },
+        }
+        : undefined;
+}
+// The paper's u0 = u1 case, given unnumbered just after equation (9): the
+// endpoints are the same place at different scales, so there is no path to
+// trace and the zoom is exponential in `s` on its own. Their `w0 exp(k*rho*s)`
+// over `S = |ln(w1/w0)|/rho` is `w0 * ratio**t` here, which is the same curve
+// with `t = s/S` and their sign `k` folded into the ratio.
+function zoomInPlace(from, to) {
+    const ratio = to.windowWidthBp / from.windowWidthBp;
+    const S = Math.abs(Math.log(ratio)) / RHO;
+    return S > 0
+        ? {
+            S,
+            at: (t) => ({
+                centerBp: from.centerBp + (to.centerBp - from.centerBp) * t,
+                windowWidthBp: from.windowWidthBp * ratio ** t,
+            }),
+        }
+        : undefined;
+}

package/esm/LinearGenomeView/headerFit.d.ts

@@ -0,0 +1,27 @@
+declare const SHEDDABLE: readonly [readonly ['trackSelectorIndent', 16], readonly ['panButtonSpacing', 100], readonly ['scrollZoomLabel', 83], readonly ['zoomSlider', 100], readonly ['regionWidth', 54]];
+export type HeaderFit = Record<(typeof SHEDDABLE)[number][0], boolean>;
+/**
+ * Which of the header bar's optional pieces a header `width` px wide still has
+ * room for, given what the search box is asking for — `searchBoxWidth`, margins
+ * included — and whether the clear-highlights button is currently in the row.
+ * An unmeasured width — the first render, before the ResizeObserver has
+ * reported — keeps all of them, so the common wide case paints its final form
+ * immediately rather than flashing the compact one.
+ *
+ * `searchBoxPx` is the box's ask and not its floor, because the two differ by
+ * the locstring — 189px empty, 194 at `ctgA:1..20,000`, 284 at
+ * `chr22:10,510,000..10,610,000`. Shedding against the floor is what left
+ * flexbox squeezing the box this whole table exists to protect: against the
+ * floor the probe read 184px of an asked 210 at an 800px window and 186 at 600.
+ *
+ * The fully shed row costs 238px, so under `238 + searchBoxPx` the row overflows
+ * whatever it gives up and the box shrinks like any flex item. That is a floor,
+ * not a cliff: it shrinks from what it asked for rather than from the 101px the
+ * unshed row used to leave it.
+ */
+export declare function headerFit({ width, searchBoxPx, clearHighlight, }: {
+    width: number | undefined;
+    searchBoxPx: number;
+    clearHighlight?: boolean;
+}): HeaderFit;
+export {};

package/esm/LinearGenomeView/headerFit.js

@@ -0,0 +1,59 @@
+// Widths measured against a built jbrowse-web at the default theme and root
+// font size — `products/jbrowse-web/browser-tests/probe-lgv-header-fit.ts`
+// prints the row piece by piece. It spends 591px on everything that is not the
+// search box (47 track selector, 114 scroll-zoom toggle, 156 pan buttons, 50 bp
+// readout, 192 zoom controls, 32 of flex gap). What the box itself asks for is
+// the caller's, because it follows the locstring rather than being a constant.
+const ROW_WITHOUT_SEARCH_PX = 591;
+// The one piece of the row that comes and goes on its own. A text search that
+// lands on a feature raises it — the same flow that was just using the search
+// box this whole table exists to protect — so its width is taken off the top
+// rather than left for the search box to absorb.
+const CLEAR_HIGHLIGHT_PX = 35;
+// What the header gives up as its window narrows, cheapest first, with the
+// pixels each one frees. Whitespace goes before words, words before a redundant
+// control, and that before a readout. The search box is not on the list: it is
+// the one control in the row with no equivalent anywhere else in the view, so
+// everything else exists to keep it on screen.
+const SHEDDABLE = [
+    ['trackSelectorIndent', 16],
+    ['panButtonSpacing', 100],
+    ['scrollZoomLabel', 83],
+    ['zoomSlider', 100],
+    ['regionWidth', 54],
+];
+/**
+ * Which of the header bar's optional pieces a header `width` px wide still has
+ * room for, given what the search box is asking for — `searchBoxWidth`, margins
+ * included — and whether the clear-highlights button is currently in the row.
+ * An unmeasured width — the first render, before the ResizeObserver has
+ * reported — keeps all of them, so the common wide case paints its final form
+ * immediately rather than flashing the compact one.
+ *
+ * `searchBoxPx` is the box's ask and not its floor, because the two differ by
+ * the locstring — 189px empty, 194 at `ctgA:1..20,000`, 284 at
+ * `chr22:10,510,000..10,610,000`. Shedding against the floor is what left
+ * flexbox squeezing the box this whole table exists to protect: against the
+ * floor the probe read 184px of an asked 210 at an 800px window and 186 at 600.
+ *
+ * The fully shed row costs 238px, so under `238 + searchBoxPx` the row overflows
+ * whatever it gives up and the box shrinks like any flex item. That is a floor,
+ * not a cliff: it shrinks from what it asked for rather than from the 101px the
+ * unshed row used to leave it.
+ */
+export function headerFit({ width, searchBoxPx, clearHighlight = false, }) {
+    const fit = Object.fromEntries(SHEDDABLE.map(([k]) => [k, true]));
+    if (width === undefined) {
+        return fit;
+    }
+    const room = width - (clearHighlight ? CLEAR_HIGHLIGHT_PX : 0);
+    let need = ROW_WITHOUT_SEARCH_PX + searchBoxPx;
+    for (const [key, saves] of SHEDDABLE) {
+        if (need <= room) {
+            break;
+        }
+        fit[key] = false;
+        need -= saves;
+    }
+    return fit;
+}

package/esm/LinearGenomeView/index.d.ts

@@ -1,4 +1,34 @@
+import type { LinearGenomeViewModel } from './model.ts';
 import type PluginManager from '@jbrowse/core/PluginManager';
+import type { ViewLayout } from '@jbrowse/core/util/Base1DUtils';
+declare module '@jbrowse/core/PluginManager' {
+    interface ExtensionPointRegistry {
+        /** #extensionPoint LinearGenomeView-TracksContainerComponent | sync | Add a component into the LGV tracks container */
+        'LinearGenomeView-TracksContainerComponent': ElementList<{
+            model: LinearGenomeViewModel;
+        }>;
+        /** #extensionPoint LinearGenomeView-ScalebarHighlightComponent | sync | Add a highlight component to the scalebar */
+        'LinearGenomeView-ScalebarHighlightComponent': ElementList<{
+            model: LinearGenomeViewModel;
+        }>;
+        /** #extensionPoint LinearGenomeView-HighlightSVGComponent | sync | Add an SVG highlight overlay in the LGV SVG export */
+        'LinearGenomeView-HighlightSVGComponent': ElementList<{
+            model: LinearGenomeViewModel;
+            height: number;
+        }>;
+        /** #extensionPoint LinearGenomeView-OverviewScalebarComponent | sync | Add a component to the overview scalebar */
+        'LinearGenomeView-OverviewScalebarComponent': ElementList<{
+            model: LinearGenomeViewModel;
+            overview: ViewLayout;
+        }>;
+    }
+}
 export default function LinearGenomeViewF(pluginManager: PluginManager): void;
-export * from './model.ts';
-export * from './types.ts';
+export { stateModelFactory } from './model.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';
+export { default as HighlightBand } from './components/HighlightBand.tsx';
+export { default as HighlightChip } from './components/HighlightChip.tsx';
+export { default as OverviewHighlightBand } from './components/OverviewHighlightBand.tsx';
+export { default as SVGHighlightBand } from './components/SVGHighlightBand.tsx';

package/esm/LinearGenomeView/index.js

@@ -1,15 +1,19 @@
 import { lazy } from 'react';
 import { ViewType } from '@jbrowse/core/pluggableElementTypes';
-import { stateModelFactory } from "./model.js";
+import { stateModelFactory } from './model.js';
 export default function LinearGenomeViewF(pluginManager) {
     pluginManager.addViewType(() => {
         return new ViewType({
             name: 'LinearGenomeView',
             displayName: 'Linear genome view',
             stateModel: stateModelFactory(pluginManager),
-            ReactComponent: lazy(() => import("./components/LinearGenomeView.js")),
+            ReactComponent: lazy(() => import('./components/LinearGenomeView.js')),
         });
     });
 }
-export * from "./model.js";
-export * from "./types.js";
+export { stateModelFactory } from './model.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,13 @@
+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>;
+export declare function warnUnknownLaunchKeys(surface: string, unknown: object): void;

package/esm/LinearGenomeView/initKeys.js

@@ -0,0 +1,104 @@
+// 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));
+// 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']);
+// 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;
+}
+// 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/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/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;
     };
     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' | '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,52 @@
+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 '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[];