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

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

@@ -0,0 +1,17 @@
+import type { LinearGenomeViewModel } from '../model.ts';
+export declare function recordsDrawnAlone(display: object): {
+    height: number;
+    fits: boolean;
+} | undefined;
+/** 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,117 @@
+import { fullConfSnapshot, readConfObject } from '@jbrowse/core/configuration';
+import { svgTrackName } from '@jbrowse/core/svg/trackNames';
+import { getSession } from '@jbrowse/core/util';
+import { getSnapshot } from '@jbrowse/mobx-state-tree';
+import { exportTracksToR } from './rScript.js';
+/** 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;
+}
+// The variant display drawing no genotype rows (none in the file, or hidden)
+// states, as `recordsAlone`, its records as the feature track R reads them
+// as: the height they draw at, and whether they fit into it whatever the
+// track's `heightMode`.
+export function recordsDrawnAlone(display) {
+    const alone = 'recordsAlone' in display ? display.recordsAlone : undefined;
+    return typeof alone === 'object' &&
+        alone !== null &&
+        'height' in alone &&
+        typeof alone.height === 'number' &&
+        'fits' in alone &&
+        typeof alone.fits === 'boolean'
+        ? { height: alone.height, fits: alone.fits }
+        : undefined;
+}
+// The tracks the screen draws, in the order it draws them, named as the SVG
+// export names them: pinned first, minimized ones left out.
+function tracksOf(view) {
+    const session = getSession(view);
+    const tracks = [];
+    for (const track of [...view.pinnedTracks, ...view.unpinnedTracks]) {
+        const display = track.displays[0];
+        if (display && !track.minimized) {
+            const { type, displayId, ...written } = getSnapshot(display.configuration);
+            const { heightMode, height } = fullConfSnapshot(display.configuration);
+            const records = recordsDrawnAlone(display);
+            tracks.push({
+                trackId: track.configuration.trackId,
+                trackName: svgTrackName(track, session),
+                displayType: display.type,
+                adapter: readConfObject(track.configuration, 'adapter'),
+                display: written,
+                heightMode: records?.fits ? 'fit' : heightMode,
+                height: records ? records.height : height,
+                recordsOnly: records !== undefined,
+            });
+        }
+    }
+    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,
+        colorByFrame: view.colorByFrame,
+        showAminoAcids: view.showAminoAcids,
+        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,110 @@
+/** 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;
+    /** A variant display drawing its records alone, its genotype rows absent or hidden, which reads as a feature track. */
+    recordsOnly?: boolean;
+}
+interface ReaderAdapter {
+    slot?: string;
+    ext?: RegExp;
+    index?: string;
+}
+/**
+ * Each display ggjbrowse reads, by the reader that reads it, and the adapters
+ * it opens: the slot holding the file, the extension the reader knows it by,
+ * and the suffix of the index the reader looks for beside it.
+ */
+export declare const READERS: Record<string, {
+    call: string;
+    /** The reader for the display drawing no sample rows, its records alone. */
+    recordsOnlyCall?: string;
+    adapters: Record<string, ReaderAdapter>;
+}>;
+/**
+ * The ggjbrowse release the script is tested against: its floor, and the tag
+ * its install line pins. The R export workflow installs this tag on a push.
+ */
+export declare const GGJBROWSE_VERSION = "0.11.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;
+/**
+ * Each sequence adapter `jbrowse_assembly()` builds from a path, by the
+ * extension ggjbrowse reads it off, and the index each takes beside it.
+ */
+export declare const SEQUENCE_ADAPTERS: Record<string, {
+    slot: string;
+    ext: RegExp;
+    beside: Record<string, string>;
+}>;
+/**
+ * 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, colorByFrame, showAminoAcids, 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;
+    /** The view's "CDS reading frame colors", which a feature track takes. */
+    colorByFrame?: boolean;
+    /** The view's "Amino acids when zoomed in", which a feature track takes. */
+    showAminoAcids?: boolean;
+    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[];
+};
+export {};