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

package/esm/LinearGenomeView/model.js

@@ -14,7 +14,7 @@ import { assemblyErrorMessage, computeViewStatus, } from '@jbrowse/core/util/vie
 import { pendingLaunch, withLaunchInput, } from '@jbrowse/core/util/withLaunchInput';
 import { contentRightEdgePx } from '@jbrowse/display-kit/regionHost';
 import { cast, getParent, hasParent, isAlive, types, } from '@jbrowse/mobx-state-tree';
-import { when } from 'mobx';
+import { observable, when } from 'mobx';
 import { handleSelectedRegion } from '../searchUtils.js';
 import { doAfterAttach } from './afterAttach.js';
 import { shouldSwapTracks } from './components/util.js';
@@ -335,12 +335,20 @@ export function stateModelFactory(pluginManager) {
          */
         launch: types.frozen(),
     }))
-        .volatile(self => {
+        .volatile(() => {
         // typed locals so `unknown`/`Record` aren't narrowed to `undefined`/`{}`; inline
         // type assertions here get stripped by no-unnecessary-type-assertion
         const volatileError = undefined;
-        const trackRefs = {};
         return {
+            /**
+             * #volatile
+             * Height of each track's in-flow label band, measured by
+             * TrackContainer as the rendering container's offset inside its Paper.
+             * Absent (0) while the label is hidden, overlapping, or not yet
+             * measured. Observable, so the offset and height getters re-derive
+             * when a band changes.
+             */
+            trackLabelBands: observable.map(),
             /**
              * #volatile
              */
@@ -361,10 +369,6 @@ export function stateModelFactory(pluginManager) {
              * #volatile
              */
             volatileError,
-            /**
-             * #volatile
-             */
-            trackRefs,
             /**
              * #volatile
              */
@@ -376,14 +380,10 @@ export function stateModelFactory(pluginManager) {
             /**
              * #volatile
              */
-            // What `bpPerPx` used to hold at creation — the snapshot's value, or
-            // the default of 1 — which cannot be read here now that it is derived
-            // and declared after volatile. It has to be a real scale rather than
-            // the not-yet-measured 0: the canvas displays lay out against
-            // `coarseBpPerPx` rather than the live one, and a zero there is a
-            // degenerate layout for the frame or two before the debounced autorun
-            // first writes it.
-            coarseBpPerPx: self.legacyBpPerPx || 1,
+            // A real scale rather than the not-yet-measured 0, for the canvas
+            // displays that lay out against it; `setWidth` seeds the true one at
+            // the first measure.
+            coarseBpPerPx: 1,
             /**
              * #volatile
              */
@@ -529,6 +529,14 @@ export function stateModelFactory(pluginManager) {
         },
     }))
         .views(self => ({
+        /**
+         * #getter
+         * The census entry for this view: the tracks it holds itself. Declared
+         * rather than derived — see `BaseViewModel.ownTracks`.
+         */
+        get ownTracks() {
+            return [...self.tracks];
+        },
         /**
          * #getter
          * Assembly-name prefix for the scalebar refName labels, or undefined for
@@ -758,14 +766,10 @@ export function stateModelFactory(pluginManager) {
          * #getter
          * A track's full cost beyond its display height.
          *
-         * The track *label* is not counted, and cannot be: an offset label is an
-         * in-flow box whose height is whatever the theme renders a Paper of icon
-         * buttons at — 31.140625px on the stock theme, and not a number this file
-         * can derive. So these getters are exact while labels are hidden or
-         * overlapping, and short by one label box per labelled track otherwise.
-         * Anything needing the offset to the pixel with labels showing measures
-         * the DOM; `BreakpointSplitViewOverlay` does, and falls back to this
-         * arithmetic only for a track with no mounted div.
+         * The track *label* is not counted here: an offset label is an in-flow
+         * box whose height is whatever the theme renders a Paper of icon buttons
+         * at, so it is measured into `trackLabelBands` per track and added by
+         * `trackLabelBand` rather than derived.
          */
         get trackChromeHeight() {
             return this.trackLeadingChrome + this.trackTrailingChrome;
@@ -816,6 +820,14 @@ export function stateModelFactory(pluginManager) {
                 ? MINIMIZED_TRACK_HEIGHT
                 : track.activeDisplay.height;
         },
+        /**
+         * #method
+         * the measured in-flow label band above a track's rendering container,
+         * 0 until TrackContainer has measured one or when no label is in flow
+         */
+        trackLabelBand(track) {
+            return self.trackLabelBands.get(track.configuration.trackId) ?? 0;
+        },
         /**
          * #getter
          */
@@ -826,7 +838,9 @@ export function stateModelFactory(pluginManager) {
          * #getter
          */
         get trackHeightsWithChrome() {
-            return this.trackHeights + self.tracks.length * this.trackChromeHeight;
+            return (this.trackHeights +
+                self.tracks.length * this.trackChromeHeight +
+                sum(self.tracks.map(t => this.trackLabelBand(t))));
         },
         /**
          * #getter
@@ -844,14 +858,15 @@ export function stateModelFactory(pluginManager) {
          * first, then unpinned), from the same constants TrackContainer lays its
          * Paper out with. Returns `undefined` if the track is not present.
          *
-         * Exact while track labels are hidden or overlapping. With an offset
-         * label the answer is short by one label box per labelled track above
-         * this one — see `trackChromeHeight` for why that box is not derivable
-         * here.
+         * Includes each track's measured label band, this track's own included,
+         * since an in-flow label sits above the rendering container inside the
+         * same Paper. Exact once TrackContainer has measured; before that it is
+         * short by the unmeasured bands.
          */
         getTrackYOffset(trackId) {
             let y = this.headerHeight + this.scalebarHeight + this.trackLeadingChrome;
             for (const t of [...self.pinnedTracks, ...self.unpinnedTracks]) {
+                y += this.trackLabelBand(t);
                 if (t.configuration.trackId === trackId) {
                     return y;
                 }
@@ -1062,7 +1077,16 @@ export function stateModelFactory(pluginManager) {
         // the gesture into one refetch, its in-flight guard caps concurrent
         // batches at one, and rpcDataMap is overwritten in place rather than
         // cleared, so nothing blanks (ADR-008, ADR-006).
+        setTrackLabelBand(trackId, band) {
+            if (band === 0) {
+                self.trackLabelBands.delete(trackId);
+            }
+            else {
+                self.trackLabelBands.set(trackId, band);
+            }
+        },
         setWidth(newWidth) {
+            const unmeasured = self.bpPerPx <= 0;
             self.volatileWidth = newWidth;
             if (newWidth > 0 && self.windowWidthBp <= 0) {
                 // First measure, and nothing has established a window yet: a migrated
@@ -1073,6 +1097,11 @@ export function stateModelFactory(pluginManager) {
                 self.windowWidthBp = (self.legacyBpPerPx || 1) * newWidth;
                 self.legacyBpPerPx = 0;
             }
+            if (unmeasured && self.bpPerPx > 0) {
+                // The debounced coarse autorun is 500ms out; a restored snapshot's
+                // consumers would lay out and fetch at 1 bp/px until then.
+                self.coarseBpPerPx = self.bpPerPx;
+            }
         },
         /**
          * #action
@@ -1428,13 +1457,20 @@ export function stateModelFactory(pluginManager) {
         },
         /**
          * #method
-         * creates an svg export and save using FileSaver
+         * renders the view to SVG markup, which it returns; saves it through
+         * FileSaver unless `save: false`
          */
+        // Promise<string> is stated, against the house preference for inferred
+        // return types: renderToSvg is typed against this very model, so an
+        // inferred return makes the model type reference itself (TS2456).
         async exportSvg(opts = {}) {
             const { renderToSvg } = await import('./svgcomponents/SVGLinearGenomeView.js');
             const html = await renderToSvg(self, opts);
-            const { saveSvgAsImage } = await import('@jbrowse/core/svg/saveSvgAsImage');
-            await saveSvgAsImage(html, opts);
+            if (opts.save !== false) {
+                const { saveSvgAsImage } = await import('@jbrowse/core/svg/saveSvgAsImage');
+                await saveSvgAsImage(html, opts);
+            }
+            return html;
         },
     }))
         .actions(self => {
@@ -2737,7 +2773,7 @@ export function stateModelFactory(pluginManager) {
              * `centerAt`'s animated twin: the same destination, reached along the
              * arc instead of jumped to, at the zoom the view is already on.
              */
-            flyToCenter(coord, refName) {
+            flyToCenter(coord, refName, displayedRegionIndex) {
                 // `bpToLinearBp` rather than `bpToPx`, which rounds to a whole pixel
                 // at the current zoom: mid-flight that zoom is a point on somebody
                 // else's arc, and a destination quantized against it moves with it.
@@ -2745,6 +2781,7 @@ export function stateModelFactory(pluginManager) {
                     refName,
                     coord,
                     displayedRegions: self.displayedRegions,
+                    displayedRegionIndex,
                 });
                 if (centerBp !== undefined) {
                     flyTo(centerBp, heading ? heading.windowWidthBp : self.windowWidthBp);
@@ -2760,7 +2797,10 @@ export function stateModelFactory(pluginManager) {
             doAfterAttach(self);
         },
     }));
-    return withLaunchInput(model, lgvLaunchKeys)
+    return withLaunchInput(model, lgvLaunchKeys, {
+        registry: pluginManager,
+        materialized: snap => !!snap.displayedRegions?.length,
+    })
         .preProcessSnapshot((snap) => {
         if (!snap) {
             return snap;
@@ -2802,24 +2842,16 @@ export function stateModelFactory(pluginManager) {
         };
     })
         .postProcessSnapshot(snap => {
-        // launch is transient, never persisted. showCenterLine is
-        // purely a localStorage-backed preference (see setupLocalStorageAutorun
-        // in afterAttach.ts) and is never persisted into session snapshots. The
-        // remaining fields are also localStorage-backed, but still persist when
-        // non-default: their strip baseline is the universal default (hardcoded
-        // here), not the localStorage-derived creation default, so a
-        // localStorage-set value stays portable across browsers.
-        const { launch, showCenterLine, showCytobands, trackLabels, colorByCDS, showAminoAcids, showTrackOutlines, ...rest } = snap;
+        // showCenterLine is purely a localStorage-backed preference (see
+        // setupLocalStorageAutorun in afterAttach.ts) and is never persisted
+        // into session snapshots. The remaining fields are also
+        // localStorage-backed, but still persist when non-default: their strip
+        // baseline is the universal default (hardcoded here), not the
+        // localStorage-derived creation default, so a localStorage-set value
+        // stays portable across browsers.
+        const { showCenterLine, showCytobands, trackLabels, colorByCDS, showAminoAcids, showTrackOutlines, ...rest } = snap;
         return {
             ...rest,
-            // keep the launch state until displayedRegions exist, so a snapshot
-            // taken before the launch autorun navigates (e.g. autosave firing
-            // mid-load) can still rebuild the view instead of dropping to the
-            // import form. displayedRegions is stripDefault, so it's absent (not
-            // []) when empty — the optional chain is runtime-necessary despite the
-            // non-nullish type.
-            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-            ...(launch && !snap.displayedRegions?.length ? { launch } : {}),
             ...(!showCytobands ? { showCytobands } : {}),
             ...(trackLabels ? { trackLabels } : {}),
             ...(colorByCDS ? { colorByCDS } : {}),

package/esm/LinearGenomeView/util.d.ts

@@ -1,6 +1,14 @@
 import type { AssemblyManager, ParsedLocString } from '@jbrowse/core/util';
+import type { PxToBpResult } from '@jbrowse/core/util/Base1DUtils';
 import type { BaseBlock, ContentBlock } from '@jbrowse/core/util/blockTypes';
 import type { Region } from '@jbrowse/core/util/types';
+interface CenterKeepingView {
+    width: number;
+    displayedRegions: Region[];
+    pxToBp: (px: number) => PxToBpResult;
+    setDisplayedRegions: (regions: Region[]) => void;
+    centerAt: (coord: number, refName: string, index?: number) => void;
+}
 /**
  * The stored viewport of a view showing `totalBp` of displayed regions fitted to
  * `width` — the regions filling it edge to edge, and centered in it only where
@@ -197,7 +205,29 @@ export declare function regionMoveActions(idx: number, numRegions: number): {
  * the new region set).
  */
 export declare function withRegionMoved(regions: Region[], from: number, to: number): Region[];
+/**
+ * Replace the region list and keep looking at whatever was under the middle of
+ * the viewport, when that region is in the new list.
+ *
+ * `setDisplayedRegions` carries `offsetPx` across and clamps it, which is a
+ * linear position in a coordinate space the write just redefined: dropping the
+ * regions to the left of the one on screen strands the view at the end of what
+ * remains, on blank space. Where the centred region is gone the clamp is still
+ * the only answer, so this falls back to it.
+ */
+export declare function setDisplayedRegionsKeepingCenter(model: CenterKeepingView, regions: Region[]): void;
 export declare function withRegionRemoved(regions: Region[], index: number): Region[];
+/**
+ * The full run of same-orientation regions on one refName that a scalebar
+ * label's `firstRegionIndex`..`lastRegionIndex` sits inside. Those come off the
+ * static blocks, which are clipped to the viewport and broken by an elided
+ * block, so a zoomed-in collapsed-introns view brackets only the exons on
+ * screen — which is the wrong answer for anything acting on the whole run.
+ */
+export declare function regionRunBounds(regions: Region[], firstIndex: number, lastIndex: number): {
+    first: number;
+    last: number;
+};
 export declare function withRegionReversed(regions: Region[], index: number): Region[];
 /**
  * Whether a label occupying [leftPx, leftPx + labelWidth] fits within a block
@@ -348,3 +378,4 @@ export declare function generateLocations({ regions, assemblyManager, assemblyNa
  */
 export declare function parseLocStrings(input: string, assemblyName: string, isValidRefName: (str: string, assemblyName: string) => boolean): ParsedLocString[];
 export declare function calculateVisibleLocStrings(contentBlocks: ContentBlock[]): string;
+export {};

package/esm/LinearGenomeView/util.js

@@ -415,9 +415,57 @@ export function withRegionMoved(regions, from, to) {
     out.splice(to, 0, moved);
     return out;
 }
+/**
+ * Replace the region list and keep looking at whatever was under the middle of
+ * the viewport, when that region is in the new list.
+ *
+ * `setDisplayedRegions` carries `offsetPx` across and clamps it, which is a
+ * linear position in a coordinate space the write just redefined: dropping the
+ * regions to the left of the one on screen strands the view at the end of what
+ * remains, on blank space. Where the centred region is gone the clamp is still
+ * the only answer, so this falls back to it.
+ */
+export function setDisplayedRegionsKeepingCenter(model, regions) {
+    const center = model.displayedRegions.length
+        ? model.pxToBp(model.width / 2)
+        : undefined;
+    model.setDisplayedRegions(regions);
+    const index = center
+        ? regions.findIndex(r => r.refName === center.refName &&
+            r.start === center.start &&
+            r.end === center.end)
+        : -1;
+    if (center && index !== -1) {
+        model.centerAt(center.coord0, center.refName, index);
+    }
+}
 export function withRegionRemoved(regions, index) {
     return regions.filter((_, i) => i !== index);
 }
+/**
+ * The full run of same-orientation regions on one refName that a scalebar
+ * label's `firstRegionIndex`..`lastRegionIndex` sits inside. Those come off the
+ * static blocks, which are clipped to the viewport and broken by an elided
+ * block, so a zoomed-in collapsed-introns view brackets only the exons on
+ * screen — which is the wrong answer for anything acting on the whole run.
+ */
+export function regionRunBounds(regions, firstIndex, lastIndex) {
+    const anchor = regions[firstIndex];
+    const inRun = (r) => r !== undefined &&
+        anchor !== undefined &&
+        r.refName === anchor.refName &&
+        r.assemblyName === anchor.assemblyName &&
+        !!r.reversed === !!anchor.reversed;
+    let first = firstIndex;
+    let last = lastIndex;
+    while (inRun(regions[first - 1])) {
+        first--;
+    }
+    while (inRun(regions[last + 1])) {
+        last++;
+    }
+    return { first, last };
+}
 export function withRegionReversed(regions, index) {
     return regions.map((region, i) => i === index ? { ...region, reversed: !region.reversed } : region);
 }