@jbrowse/plugin-linear-genome-view 5.0.0-beta.11 → 5.0.0-beta.15

package/esm/LinearGenomeView/model.js

@@ -1,14 +1,13 @@
-import { lazy } from 'react';
+import { canonicalLocString } from '@jbrowse/core/TextSearch/places';
 import { getConf } from '@jbrowse/core/configuration';
 import { BaseViewModel } from '@jbrowse/core/pluggableElementTypes/models';
 import { exportViewSvg } from '@jbrowse/core/svg/exportViewSvg';
-import { assembleLocString, clamp, getBpDisplayStr, getDialogHost, getSession, getTickDisplayStr, isSessionModelWithWidgets, localStorageGetBoolean, localStorageGetItem, springAnimate, sum, } from '@jbrowse/core/util';
+import { assembleLocString, clamp, getBpDisplayStr, getNotificationSink, getSession, isSessionModelWithWidgets, localStorageGetBoolean, localStorageGetItem, localStorageSetBoolean, localStorageSetItem, springAnimate, sum, } from '@jbrowse/core/util';
 import { bpToLinearBp, bpToPx, computeMoveToLayout, createOverviewLayout, getLayoutHighlightCoords, getOverviewRegionPxSpan, moveTo, pxToBp, } from '@jbrowse/core/util/Base1DUtils';
 import { scaleBandHeights } from '@jbrowse/core/util/bandHeight';
 import { wholeBaseRegions } from '@jbrowse/core/util/blockTypes';
 import calculateDynamicBlocks from '@jbrowse/core/util/calculateDynamicBlocks';
 import calculateStaticBlocks from '@jbrowse/core/util/calculateStaticBlocks';
-import { tickLabelsWorthDrawing } from '@jbrowse/core/util/tickLabels';
 import { hideTrackGeneric, launchToggleTrackGeneric, launchTrackGeneric, showTrackGeneric, toggleTrackGeneric, } from '@jbrowse/core/util/tracks';
 import { ElementId } from '@jbrowse/core/util/types/mst';
 import { highlightsOnAssemblies } from '@jbrowse/core/util/viewHighlights';
@@ -18,7 +17,7 @@ import { MIN_DISPLAY_HEIGHT } from '@jbrowse/display-kit/const';
 import { contentRightEdgePx } from '@jbrowse/display-kit/regionHost';
 import { cast, getParent, hasParent, isAlive, types, } from '@jbrowse/mobx-state-tree';
 import { observable, when } from 'mobx';
-import { handleSelectedRegion, navToOption } from '../searchUtils.js';
+import { handleSelectedRegion, isOpenInView, navToOption, } from '../searchUtils.js';
 import { doAfterAttach } from './afterAttach.js';
 import { getCytobands, shouldSwapTracks } from './components/util.js';
 import { HEADER_BAR_HEIGHT, HEADER_OVERVIEW_HEIGHT, MIN_BP_PER_PX, MINIMIZED_TRACK_HEIGHT, MINIMUM_BLOCK_WIDTH, RESIZE_ALL_HANDLE_HEIGHT, RESIZE_HANDLE_HEIGHT, SCALE_BAR_HEIGHT, SHOW_ALL_REGIONS_FILL, TRACK_OUTLINE_BORDER, TRACK_TOP_GAP, } from './consts.js';
@@ -27,13 +26,7 @@ import { setupKeyboardHandler } from './keyboardHandler.js';
 import { lgvLaunchKeys } from './launchKeys.js';
 import { buildHighlightsSubMenuItems, buildMenuItems, buildRubberBandMenuItems, buildRubberbandClickMenuItems, } from './menuItems.js';
 import { sharedScaleContainerOf } from './sharedScaleContainer.js';
-import { calculateVisibleLocStrings, cytobandLabelGutterWidth, expandRegion, fitAllRegionsWindow, generateLocations, getScalebarRefNameLabels, regionsOrientation, groupContiguousBlocks, labelFitsInBlock, makeBlockTicks, runRefNameLabelPx, setDisplayedRegionsKeepingCenter, tickLabelWidth, } from './util.js';
-// lazies
-const SearchResultsDialog = lazy(() => import('./components/SearchResultsDialog.js'));
-// The one array `paddingSpans` returns when a view has nothing to mask, so that
-// computed's value repeats by identity. Frozen because every consumer maps over
-// it and a caller that sorted in place would do so for the whole session.
-const NO_PADDING_SPANS = Object.freeze([]);
+import { calculateVisibleLocStrings, cytobandLabelGutterWidth, expandRegion, fitAllRegionsWindow, generateLocations, getGridlineTicks, getPaddingSpans, getScalebarLabels, getScalebarRefNameLabels, regionsOrientation, setDisplayedRegionsKeepingCenter, } from './util.js';
 /**
  * Calculate the offsetPx needed to center content within a viewport.
  * Returns a negative offset when content is smaller than viewport (padding on left).
@@ -60,13 +53,18 @@ function canonicalHighlight(self, region) {
 // bpPerPx deltas smaller than this are treated as no zoom change, avoiding
 // pointless offset re-anchoring on micro-steps
 const BP_PER_PX_EPSILON = 0.000001;
-// px of the rightmost content kept on-screen at max scroll-right, so the genome
-// can't be scrolled entirely off the left edge. Shared by maxOffset and
-// getSelectedRegions' clamp so the two bounds can't drift apart.
-const MAX_OFFSET_PADDING_PX = 10;
-// px of the leftmost content kept on-screen at max scroll-left, mirroring
-// MAX_OFFSET_PADDING_PX at the other end
-const MIN_OFFSET_PADDING_PX = 30;
+// px of blank space a view may scroll past either end of its regions, enough to
+// read as an edge and too little to lose the content
+const OVERSCROLL_PX = 100;
+// The offsets a view can scroll to: the content edge to edge plus a little
+// overscroll. Content narrower than the view collapses the range to the
+// centered offset, which is what `showAllRegions` and `fitAllRegions` ask for.
+function offsetBounds(contentPx, viewportPx) {
+    const centered = getCenteredOffsetPx(contentPx, viewportPx);
+    return contentPx > viewportPx
+        ? { min: -OVERSCROLL_PX, max: contentPx - viewportPx + OVERSCROLL_PX }
+        : { min: centered, max: centered };
+}
 // whether two BlockSets cover the same blocks, by key and in order
 function sameBlockKeys(a, b) {
     return (a.blocks.length === b.blocks.length &&
@@ -143,6 +141,8 @@ function isTrackSelectorVisible(self) {
 /**
  * #stateModel LinearGenomeView
  * #category view
+ * Stacks tracks under a horizontal axis of one or more genomic regions laid
+ * end to end, which the user scrolls, zooms and searches.
  *
  * #example
  * A `LinearGenomeView` is what you hand-author under `defaultSession.views`, and
@@ -267,7 +267,10 @@ export function stateModelFactory(pluginManager) {
         trackSelectorType: types.stripDefault(types.enumeration(['hierarchical']), 'hierarchical'),
         /**
          * #property
-         * show the "center line"
+         * show the "center line". A personal preference: never in a session
+         * snapshot. It, showCytobands, trackLabels, colorByCDS, showAminoAcids
+         * and showTrackOutlines start from this browser's last choice, which
+         * their setters record.
          */
         showCenterLine: types.optional(types.boolean, () => localStorageGetBoolean('lgv-showCenterLine', false)),
         /**
@@ -355,6 +358,12 @@ export function stateModelFactory(pluginManager) {
              * #volatile
              */
             draggingTrackId: undefined,
+            /**
+             * #volatile
+             * Set by a search whose hits name more than one place, until the user
+             * picks one or closes it.
+             */
+            searchPicker: undefined,
             /**
              * #volatile
              */
@@ -967,15 +976,13 @@ export function stateModelFactory(pluginManager) {
          * #getter
          */
         get maxOffset() {
-            // objectively determined to keep the linear genome on the main screen
-            return this.displayedRegionsTotalPx - MAX_OFFSET_PADDING_PX;
+            return offsetBounds(this.displayedRegionsTotalPx, self.width).max;
         },
         /**
          * #getter
          */
         get minOffset() {
-            // objectively determined to keep the linear genome on the main screen
-            return -self.width + MIN_OFFSET_PADDING_PX;
+            return offsetBounds(this.displayedRegionsTotalPx, self.width).min;
         },
         /**
          * #getter
@@ -1020,6 +1027,15 @@ export function stateModelFactory(pluginManager) {
         getActiveDisplayId(trackId) {
             return this.getTrack(trackId)?.activeDisplay.configuration.displayId;
         },
+    }))
+        .actions(self => ({
+        /**
+         * #action
+         * Dismiss the search picker without choosing a place.
+         */
+        closeSearchPicker() {
+            self.searchPicker = undefined;
+        },
     }))
         .actions(self => ({
         /**
@@ -1027,6 +1043,7 @@ export function stateModelFactory(pluginManager) {
          */
         setShowTrackOutlines(arg) {
             self.showTrackOutlines = arg;
+            localStorageSetBoolean('lgv-showTrackOutlines', arg);
         },
         /**
          * #action
@@ -1039,18 +1056,21 @@ export function stateModelFactory(pluginManager) {
          */
         setColorByCDS(flag) {
             self.colorByCDS = flag;
+            localStorageSetBoolean('lgv-colorByCDS', flag);
         },
         /**
          * #action
          */
         setShowAminoAcids(flag) {
             self.showAminoAcids = flag;
+            localStorageSetBoolean('lgv-showAminoAcids', flag);
         },
         /**
          * #action
          */
         setShowCytobands(flag) {
             self.showCytobands = flag;
+            localStorageSetBoolean('lgv-showCytobands', flag);
         },
         /**
          * #action
@@ -1236,17 +1256,46 @@ export function stateModelFactory(pluginManager) {
             model: self,
             assemblyName,
         })) {
-            getDialogHost(self).queueDialog(handleClose => [
-                SearchResultsDialog,
-                {
-                    model: self,
-                    searchResults,
-                    searchQuery,
-                    handleClose,
-                    assemblyName,
-                    onPick,
+            const session = getSession(self);
+            const assembly = session.assemblyManager.get(assemblyName);
+            const ordered = [...searchResults].sort((a, b) => Number(isOpenInView(b, self)) -
+                Number(isOpenInView(a, self)));
+            const picker = {
+                query: searchQuery,
+                assemblyName,
+                rows: ordered.map(result => {
+                    const location = result.getLocation() ?? '';
+                    const trackId = result.getTrackId();
+                    return {
+                        id: result.getId(),
+                        label: result.getLabel(),
+                        location: assembly && location
+                            ? canonicalLocString(location, assembly)
+                            : location,
+                        trackName: trackId
+                            ? (session.getTrackById(trackId)?.name ?? '')
+                            : '',
+                    };
+                }),
+                pick: async (id) => {
+                    const picked = ordered.find(result => result.getId() === id);
+                    try {
+                        if (picked) {
+                            await onPick(picked);
+                        }
+                    }
+                    catch (e) {
+                        console.error(e);
+                        if (isAlive(self)) {
+                            getNotificationSink(self).notifyError(`${e}`, e);
+                        }
+                    }
+                    if (isAlive(self) && self.searchPicker === picker) {
+                        self.closeSearchPicker();
+                    }
                 },
-            ]);
+            };
+            self.searchPicker = picker;
         },
         /**
          * #action
@@ -1372,12 +1421,14 @@ export function stateModelFactory(pluginManager) {
          */
         setTrackLabels(setting) {
             self.trackLabels = setting;
+            localStorageSetItem('lgv-trackLabels', setting);
         },
         /**
          * #action
          */
         setShowCenterLine(b) {
             self.showCenterLine = b;
+            localStorageSetBoolean('lgv-showCenterLine', b);
         },
         /**
          * #action
@@ -1426,7 +1477,8 @@ export function stateModelFactory(pluginManager) {
             const { bpPerPx, offsetPx: rawOffsetPx } = computeMoveToLayout(layout, leftOffset, rightOffset);
             // mirror Base1DView.scrollTo clamping: raw offsetPx can be far outside
             // the valid range when both offsets are oob on the same side
-            const offsetPx = clamp(rawOffsetPx, self.minOffset, self.totalBp / bpPerPx - MAX_OFFSET_PADDING_PX);
+            const { min, max } = offsetBounds(self.totalBp / bpPerPx, self.width);
+            const offsetPx = clamp(rawOffsetPx, min, max);
             return wholeBaseRegions(calculateDynamicBlocks({
                 ...layout,
                 bpPerPx,
@@ -1477,16 +1529,6 @@ export function stateModelFactory(pluginManager) {
         setLaunch(launch) {
             self.launch = launch;
         },
-        /**
-         * #method
-         * renders the view to SVG markup, which it returns; saves it through
-         * FileSaver unless `save: false`
-         */
-        // Promise<string> is stated: renderToSvg is typed against this very
-        // model, so an inferred return makes the type reference itself (TS2456)
-        async exportSvg(opts = {}) {
-            return exportViewSvg(self, opts, () => import('./svgcomponents/SVGLinearGenomeView.js'));
-        },
     }))
         .actions(self => {
         let cancelLastSlide = () => { };
@@ -1790,21 +1832,12 @@ export function stateModelFactory(pluginManager) {
              * than recomputing the makeTicks loop per component.
              */
             get gridlineTicks() {
-                const { bpPerPx } = self;
                 const { blocks, offsetPx: firstBlockOffset } = this.staticBlocks;
-                const ticks = [];
-                // iterate merged region runs (like scalebarLabels) so a tick on an
-                // internal ~800px chunk boundary isn't emitted twice (once as a
-                // chunk's right edge, once as the next chunk's left edge)
-                for (const run of groupContiguousBlocks(blocks)) {
-                    const runLeft = run.offsetPx - firstBlockOffset;
-                    for (const { type, x } of makeBlockTicks(run, bpPerPx)) {
-                        if (x >= 0 && x <= run.widthPx) {
-                            ticks.push({ x: runLeft + x, major: type === 'major' });
-                        }
-                    }
-                }
-                return ticks;
+                return getGridlineTicks({
+                    blocks,
+                    firstBlockOffset,
+                    bpPerPx: self.bpPerPx,
+                });
             },
             /**
              * #getter
@@ -1822,33 +1855,13 @@ export function stateModelFactory(pluginManager) {
              * reads as the same number repeated across the row.
              */
             get scalebarLabels() {
-                const { bpPerPx } = self;
                 const { blocks, offsetPx: firstBlockOffset } = this.staticBlocks;
-                const labels = [];
-                const runs = groupContiguousBlocks(blocks);
-                const refNameLabelPx = runRefNameLabelPx(runs, self.displayedRegionsOrientation);
-                for (const [i, run] of runs.entries()) {
-                    const runLeft = run.offsetPx - firstBlockOffset;
-                    const runLabels = [];
-                    for (const { base, x } of makeBlockTicks(run, bpPerPx, false)) {
-                        const label = getTickDisplayStr(base + 1, bpPerPx);
-                        const w = tickLabelWidth(label);
-                        // the bold refName label pinned at the run's left edge takes
-                        // precedence, as it does on the overview scalebar
-                        if (x - w / 2 >= refNameLabelPx[i] &&
-                            labelFitsInBlock(x - w / 2, w, run.widthPx)) {
-                            runLabels.push({
-                                x: runLeft + x,
-                                label,
-                                key: `${run.offsetPx}-${base}`,
-                            });
-                        }
-                    }
-                    if (tickLabelsWorthDrawing(runLabels.length)) {
-                        labels.push(...runLabels);
-                    }
-                }
-                return labels;
+                return getScalebarLabels({
+                    blocks,
+                    firstBlockOffset,
+                    bpPerPx: self.bpPerPx,
+                    orientation: self.displayedRegionsOrientation,
+                });
             },
             /**
              * #getter
@@ -1946,38 +1959,7 @@ export function stateModelFactory(pluginManager) {
             // cannot drift without failing here.
             get paddingSpans() {
                 const { blocks, offsetPx: firstBlockOffset } = this.staticBlocks;
-                const spans = [];
-                for (const block of blocks) {
-                    const x = block.offsetPx - firstBlockOffset;
-                    if (block.type === 'ContentBlock') {
-                        if (block.isRightEndOfDisplayedRegion) {
-                            spans.push({
-                                key: `${block.key}-sep`,
-                                x: x + block.widthPx - 1,
-                                width: 3,
-                                kind: 'seam',
-                            });
-                        }
-                    }
-                    else {
-                        spans.push({
-                            key: block.key,
-                            x,
-                            width: block.widthPx,
-                            kind: block.type === 'ElidedBlock'
-                                ? 'elided'
-                                : 'boundary',
-                        });
-                    }
-                }
-                // One shared array when there is nothing to draw, so the computed's
-                // value repeats and MobX's `===` stops the chain here. This is the
-                // COMMON case, not an edge one: a view sitting inside one contig has
-                // no region seam, no elision and no boundary, and that is where a
-                // reader spends nearly all of a session. A fresh `[]` each frame
-                // instead re-rendered a PaddingBlocks per track plus one for the
-                // container, every frame of every gesture, to draw nothing.
-                return spans.length > 0 ? spans : NO_PADDING_SPANS;
+                return getPaddingSpans(blocks, firstBlockOffset);
             },
             /**
              * #getter
@@ -2050,7 +2032,7 @@ export function stateModelFactory(pluginManager) {
             /**
              * #getter
              * Right edge (px, viewport-relative) of the on-screen content, clamped
-             * to the track — where a right-pinned overlay such as a wiggle's colour
+             * to the track — where a right-pinned overlay such as a wiggle's color
              * or score legend belongs, rather than out in the empty gutter the
              * regions can leave at whole-genome zoom. `@jbrowse/display-kit`'s
              * `contentRightEdgePx` states the rule; an SVG export applies the same
@@ -2219,6 +2201,42 @@ export function stateModelFactory(pluginManager) {
             }
         },
     }))
+        .actions(self => {
+        function layOutAt(width) {
+            self.setWidth(width);
+            self.settleCoarseBlocks();
+        }
+        return {
+            /**
+             * #method
+             * renders the view to SVG markup, which it returns; saves it through
+             * FileSaver unless `save: false`. A `viewWidth` lays the view out at
+             * that many pixels for the export, as a window that wide would, and
+             * puts the on-screen width back after.
+             */
+            // Promise<string> is stated: renderToSvg is typed against this very
+            // model, so an inferred return makes the type reference itself (TS2456)
+            async exportSvg(opts = {}) {
+                const { width } = self;
+                const { viewWidth = width } = opts;
+                // The on-screen tracks redraw at `viewWidth` until the export ends. A
+                // hidden copy of the view would keep them still, but it needs a
+                // session slot that autosave and undo skip, and new ids for the view,
+                // its tracks and displays, since widgets find them by id.
+                if (viewWidth !== width) {
+                    layOutAt(viewWidth);
+                }
+                try {
+                    return await exportViewSvg(self, opts, () => import('./svgcomponents/SVGLinearGenomeView.js'));
+                }
+                finally {
+                    if (viewWidth !== width) {
+                        layOutAt(width);
+                    }
+                }
+            },
+        };
+    })
         .actions(self => ({
         /**
          * #action
@@ -2498,8 +2516,7 @@ export function stateModelFactory(pluginManager) {
         // unrelated files lose their parameter types to it.
         async navToLocString(input, optAssemblyName, grow, opts) {
             const { assemblyNames } = self;
-            const session = getSession(self);
-            const { assemblyManager } = session;
+            const { assemblyManager } = getSession(self);
             const assemblyName = optAssemblyName || assemblyNames[0];
             if (assemblyName) {
                 await assemblyManager.waitForAssembly(assemblyName);
@@ -2911,22 +2928,13 @@ export function stateModelFactory(pluginManager) {
         };
     })
         .postProcessSnapshot(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,
-            ...(!showCytobands ? { showCytobands } : {}),
-            ...(trackLabels ? { trackLabels } : {}),
-            ...(colorByCDS ? { colorByCDS } : {}),
-            ...(!showAminoAcids ? { showAminoAcids } : {}),
-            ...(!showTrackOutlines ? { showTrackOutlines } : {}),
-        };
+        // showCenterLine is a personal preference and stays out of the session.
+        // The other localStorage-seeded settings are always written: the
+        // receiving browser's localStorage fills an absent one, so stripping a
+        // default would show a share link's reader their own setting instead
+        // of the author's.
+        const { showCenterLine, ...rest } = snap;
+        return rest;
     });
 }
 // #endregion

package/esm/LinearGenomeView/rExport/exportLinearView.d.ts

@@ -0,0 +1,13 @@
+import type { LinearGenomeViewModel } from '../model.ts';
+/** The R script that redraws the tracks open in the view, over its visible regions. */
+export declare function exportLinearViewToR(view: LinearGenomeViewModel, out?: string): {
+    drawn: number;
+    script: undefined;
+    notes: string[];
+} | {
+    drawn: number;
+    script: string;
+    notes: string[];
+};
+/** Downloads the view's R script, telling the user what it leaves out. */
+export declare function downloadRScript(view: LinearGenomeViewModel): Promise<void>;

package/esm/LinearGenomeView/rExport/exportLinearView.js

@@ -0,0 +1,98 @@
+import { fullConfSnapshot, readConfObject } from '@jbrowse/core/configuration';
+import { getSession } from '@jbrowse/core/util';
+import { getSnapshot } from '@jbrowse/mobx-state-tree';
+import { exportTracksToR } from './rScript.js';
+function trackConf(track) {
+    return track.configuration;
+}
+/** The regions on screen, each displayed region cut to what the view shows of it. */
+function viewRegions(view) {
+    const blocks = view.dynamicBlocks.contentBlocks;
+    if (blocks.length === 0) {
+        return view.displayedRegions.map(r => ({
+            refName: r.refName,
+            start: Math.floor(r.start),
+            end: Math.ceil(r.end),
+        }));
+    }
+    const byRegion = new Map();
+    for (const block of blocks) {
+        const key = block.displayedRegionIndex ?? -1;
+        const held = byRegion.get(key);
+        if (held?.refName === block.refName) {
+            held.start = Math.min(held.start, Math.floor(block.start));
+            held.end = Math.max(held.end, Math.ceil(block.end));
+        }
+        else {
+            byRegion.set(key, {
+                refName: block.refName,
+                start: Math.floor(block.start),
+                end: Math.ceil(block.end),
+            });
+        }
+    }
+    return [...byRegion.values()];
+}
+/** The view's assembly config as written. */
+function assemblyOf(view) {
+    const name = view.assemblyNames[0];
+    const configuration = name
+        ? getSession(view).assemblyManager.get(name)?.configuration
+        : undefined;
+    return configuration
+        ? getSnapshot(configuration)
+        : undefined;
+}
+function tracksOf(view) {
+    const tracks = [];
+    for (const track of view.tracks) {
+        const display = track.displays[0];
+        if (display) {
+            const { type, displayId, ...written } = getSnapshot(display.configuration);
+            const { heightMode, height } = fullConfSnapshot(display.configuration);
+            tracks.push({
+                trackId: track.configuration.trackId,
+                trackName: readConfObject(trackConf(track), 'name') ||
+                    track.configuration.trackId,
+                displayType: display.type,
+                adapter: readConfObject(trackConf(track), 'adapter'),
+                display: written,
+                heightMode,
+                height,
+            });
+        }
+    }
+    return tracks;
+}
+/** The R script that redraws the tracks open in the view, over its visible regions. */
+export function exportLinearViewToR(view, out) {
+    return exportTracksToR({
+        tracks: tracksOf(view),
+        regions: viewRegions(view),
+        assembly: assemblyOf(view),
+        bpPerPx: view.bpPerPx,
+        out,
+        notes: view.displayedRegions.some(r => r.reversed)
+            ? ['view: shown right to left, where the figure runs left to right']
+            : [],
+    });
+}
+/** Downloads the view's R script, telling the user what it leaves out. */
+export async function downloadRScript(view) {
+    const session = getSession(view);
+    try {
+        const { saveAs } = await import('@jbrowse/core/util/FileSaver');
+        const { script, notes } = exportLinearViewToR(view);
+        if (!script) {
+            session.notify(`No open track has an R export. ${notes.join('; ')}`, 'warning');
+            return;
+        }
+        saveAs(new Blob([script], { type: 'text/plain;charset=utf-8' }), 'jbrowse_view.R');
+        if (notes.length) {
+            session.notify(`Exported with ${notes.length} note${notes.length === 1 ? '' : 's'} in the script header`, 'info');
+        }
+    }
+    catch (e) {
+        session.notifyError(`${e}`, e);
+    }
+}

package/esm/LinearGenomeView/rExport/rScript.d.ts

@@ -0,0 +1,75 @@
+/** A view's region, 0-based half-open, on the assembly's canonical contig. */
+export interface Region {
+    refName: string;
+    start: number;
+    end: number;
+}
+export interface RExportTrack {
+    trackId: string;
+    trackName: string;
+    displayType: string;
+    adapter: Record<string, unknown>;
+    /** The display's config as written, its defaults left out, which the engine fills from the same schema. */
+    display: Record<string, unknown>;
+    /** The display's resolved sizing, which a feature track exports so the figure drops what the view drops. */
+    heightMode?: unknown;
+    height?: unknown;
+}
+/** The ggjbrowse release whose readers and `jbrowse_stack` the script calls. */
+export declare const GGJBROWSE_VERSION = "0.10.0";
+/**
+ * A resolved config writes an unset slot as `''`, `[]` or `{}`, which a reader
+ * would take for a setting. Keeps `false` and `0`, which are values.
+ */
+export declare function withoutUnset(value: unknown): unknown;
+export declare function rStr(s: string): string;
+/**
+ * A config value as the R literal ggjbrowse hands the engine: a `list` per
+ * object, `c()` per vector of scalars, `list()` per vector of objects and per
+ * empty vector, which jsonlite would otherwise write as `{}`.
+ */
+export declare function rValue(value: unknown): string;
+/**
+ * The path or URL a JBrowse file location points at, as R opens it: a `uri`
+ * resolved against its `baseUri` as the browser's fetch resolved it, a
+ * `file://` URL as its path, or a `localPath`.
+ */
+export declare function locationPath(location: unknown): string | undefined;
+/**
+ * The view's assembly as the R value every reader takes: `jbrowse_assembly()`
+ * of its sequence and alias files where ggjbrowse builds the same config from
+ * their paths, and otherwise the config itself, its locations paths R opens.
+ */
+export declare function assemblyArgument(snapshot: Record<string, unknown>): {
+    value: string;
+} | {
+    skipped: string;
+};
+/** A region as JBrowse's location box writes it, 1-based and inclusive. */
+export declare function locusOf(refName: string, start: number, end: number): string;
+/**
+ * One R script for a view's tracks over its regions: a ggjbrowse reader per
+ * track, reading each as its display does, then `jbrowse_stack()` drawing
+ * them as the view stacks them. A track ggjbrowse cannot read lands in the
+ * header instead of stopping the figure: a script that quietly differs from
+ * its view says so.
+ */
+export declare function exportTracksToR({ tracks, regions, assembly: assemblySnapshot, bpPerPx, out, notes: viewNotes, }: {
+    tracks: readonly RExportTrack[];
+    regions: readonly Region[];
+    /** The view's assembly config as written, which names its sequence and its contigs' aliases. */
+    assembly?: Record<string, unknown>;
+    /** The view's zoom, which decides what a feature or quantitative display shows. */
+    bpPerPx?: number;
+    out?: string;
+    /** What the caller knows of the view that the figure does not show. */
+    notes?: readonly string[];
+}): {
+    drawn: number;
+    script: undefined;
+    notes: string[];
+} | {
+    drawn: number;
+    script: string;
+    notes: string[];
+};