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

package/esm/LinearGenomeView/rExport/rScript.js

@@ -0,0 +1,464 @@
+import { expandAssemblySequence, expandSidecarShorthand, refNameAliasAdapterType, } from '@jbrowse/core/assemblyManager/expandAssemblyConfigShorthand';
+import { resolveUri } from '@jbrowse/core/util';
+/**
+ * Each display ggjbrowse reads, by the reader that reads it, and the adapters
+ * it opens (the slot holding the file and the extension the reader knows it
+ * by).
+ */
+const READERS = {
+    LinearBasicDisplay: {
+        call: 'jbrowse_features',
+        adapters: {
+            Gff3TabixAdapter: { slot: 'gffGzLocation', ext: /\.gff3?\.gz$/ },
+            Gff3Adapter: { slot: 'gffLocation', ext: /\.gff3?$/ },
+            GtfAdapter: { slot: 'gtfLocation', ext: /\.gtf$/ },
+            BedTabixAdapter: { slot: 'bedGzLocation', ext: /\.bed\.gz$/ },
+            BedAdapter: { slot: 'bedLocation', ext: /\.bed$/ },
+            BigBedAdapter: { slot: 'bigBedLocation', ext: /\.(bb|bigbed)$/ },
+        },
+    },
+    LinearVariantDisplay: {
+        call: 'jbrowse_features',
+        adapters: {
+            VcfTabixAdapter: { slot: 'vcfGzLocation', ext: /\.vcf\.gz$/ },
+            VcfAdapter: { slot: 'vcfLocation', ext: /\.vcf$/ },
+        },
+    },
+    LinearMultiSampleVariantDisplay: {
+        call: 'jbrowse_variants',
+        adapters: {
+            VcfTabixAdapter: { slot: 'vcfGzLocation', ext: /\.vcf\.gz$/ },
+            VcfAdapter: { slot: 'vcfLocation', ext: /\.vcf$/ },
+        },
+    },
+    LinearWiggleDisplay: {
+        call: 'jbrowse_wiggle',
+        adapters: {
+            BigWigAdapter: { slot: 'bigWigLocation', ext: /$/ },
+            MultiWiggleAdapter: {},
+        },
+    },
+    LinearAlignmentsDisplay: {
+        call: 'jbrowse_alignments',
+        adapters: {
+            BamAdapter: { slot: 'bamLocation', ext: /(?<!\.cram)$/ },
+            CramAdapter: { slot: 'cramLocation', ext: /\.cram$/ },
+        },
+    },
+};
+/** The ggjbrowse release whose readers and `jbrowse_stack` the script calls. */
+export const GGJBROWSE_VERSION = '0.10.0';
+const INSTALL = 'remotes::install_github("GMOD/ggjbrowse")';
+function isSet(value) {
+    return !(value === undefined ||
+        value === null ||
+        value === '' ||
+        (Array.isArray(value) && value.length === 0) ||
+        (typeof value === 'object' &&
+            !Array.isArray(value) &&
+            Object.keys(value).length === 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 function withoutUnset(value) {
+    if (Array.isArray(value)) {
+        return value.map(withoutUnset);
+    }
+    if (value && typeof value === 'object') {
+        return Object.fromEntries(Object.entries(value)
+            .map(([k, v]) => [k, withoutUnset(v)])
+            .filter(([, v]) => isSet(v)));
+    }
+    return value;
+}
+export function rStr(s) {
+    return JSON.stringify(s);
+}
+const RESERVED = new Set([
+    'if',
+    'else',
+    'repeat',
+    'while',
+    'function',
+    'for',
+    'next',
+    'break',
+    'in',
+    'TRUE',
+    'FALSE',
+    'NULL',
+    'Inf',
+    'NaN',
+    'NA',
+]);
+function isIdentifier(s) {
+    return /^[A-Za-z.][A-Za-z0-9._]*$/.test(s) && !RESERVED.has(s);
+}
+/**
+ * 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 function rValue(value) {
+    if (value === null || value === undefined) {
+        return 'NULL';
+    }
+    if (typeof value === 'string') {
+        return rStr(value);
+    }
+    if (typeof value === 'number' || typeof value === 'boolean') {
+        return typeof value === 'number' ? String(value) : value ? 'TRUE' : 'FALSE';
+    }
+    if (Array.isArray(value)) {
+        const items = value.map(rValue).join(', ');
+        return value.length && value.every(v => typeof v !== 'object')
+            ? `c(${items})`
+            : `list(${items})`;
+    }
+    return `list(${Object.entries(value)
+        .map(([k, v]) => `${isIdentifier(k) ? k : rStr(k)} = ${rValue(v)}`)
+        .join(', ')})`;
+}
+/**
+ * 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 function locationPath(location) {
+    const loc = location;
+    if (!loc?.uri) {
+        return loc?.localPath;
+    }
+    const resolved = resolveUri({ uri: loc.uri, baseUri: loc.baseUri });
+    return resolved.startsWith('file://')
+        ? decodeURIComponent(new URL(resolved).pathname)
+        : resolved;
+}
+function isLocation(v) {
+    return (typeof v === 'object' &&
+        v !== null &&
+        !Array.isArray(v) &&
+        (typeof v.uri === 'string' ||
+            typeof v.localPath === 'string'));
+}
+/** An adapter config with each location a path or URL R opens, each path also pushed onto `uris`. */
+function openable(value, uris) {
+    if (isLocation(value)) {
+        const uri = locationPath(value);
+        if (uri) {
+            uris.push(uri);
+        }
+        return { uri };
+    }
+    if (Array.isArray(value)) {
+        return value.map(v => openable(v, uris));
+    }
+    if (value && typeof value === 'object') {
+        return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, openable(v, uris)]));
+    }
+    return value;
+}
+/**
+ * The file argument of a track's reader: its path where ggjbrowse would choose
+ * the track's adapter for it from the extension, and the adapter config itself
+ * where the adapter carries a setting or the name hides its format, so every
+ * setting reaches the engine as the browser has it.
+ */
+function fileArgument(adapters, adapter) {
+    const type = String(adapter.type);
+    const known = adapters[type];
+    if (!known) {
+        return { skipped: `${type} has no R reader for this display` };
+    }
+    const uris = [];
+    const located = withoutUnset(openable(adapter, uris));
+    if (uris.length === 0) {
+        return { skipped: `${type} names no file` };
+    }
+    if (uris.some(u => u.startsWith('blob:'))) {
+        return {
+            skipped: 'it reads a file opened in the browser, which R cannot reach',
+        };
+    }
+    const file = known.slot
+        ? (locationPath(adapter[known.slot]) ??
+            (typeof adapter.uri === 'string' ? adapter.uri : undefined))
+        : undefined;
+    const index = adapter.index;
+    const indexPath = locationPath(index?.location) ?? locationPath(adapter.craiLocation);
+    const besideSuffix = type === 'CramAdapter' ? '.crai' : type === 'BamAdapter' ? '.bai' : '.tbi';
+    const plainSlots = new Set([
+        'type',
+        'uri',
+        'index',
+        'craiLocation',
+        known.slot,
+    ]);
+    const plain = file !== undefined &&
+        known.ext?.test(file.replace(/\?.*$/, '').toLowerCase()) &&
+        Object.keys(located).every(k => plainSlots.has(k)) &&
+        Object.keys(index ?? {}).every(k => k === 'location' || k === 'indexType') &&
+        (index?.indexType === 'CSI') === !!indexPath?.endsWith('.csi');
+    return plain
+        ? {
+            file: rStr(file),
+            index: indexPath && indexPath !== `${file}${besideSuffix}`
+                ? indexPath
+                : undefined,
+            uris,
+        }
+        : { file: rValue(located), uris };
+}
+/**
+ * Each sequence adapter `jbrowse_assembly()` builds from a path, by the
+ * extension ggjbrowse reads it off, and the index each takes beside it.
+ */
+const SEQUENCE_ADAPTERS = {
+    TwoBitAdapter: { slot: 'twoBitLocation', ext: /\.2bit$/, beside: {} },
+    BgzipFastaAdapter: {
+        slot: 'fastaLocation',
+        ext: /\.gz$/,
+        beside: { faiLocation: '.fai', gziLocation: '.gzi' },
+    },
+    IndexedFastaAdapter: {
+        slot: 'fastaLocation',
+        ext: /^(?!.*\.(2bit|gz)$)/,
+        beside: { faiLocation: '.fai' },
+    },
+};
+/** The path of a sequence adapter `jbrowse_assembly()` rebuilds from that path alone. */
+function plainSequence(adapter) {
+    const { type, uri, baseUri, ...slots } = adapter;
+    if (type === undefined && typeof uri === 'string') {
+        return Object.keys(slots).length
+            ? undefined
+            : locationPath({ uri, baseUri });
+    }
+    const known = SEQUENCE_ADAPTERS[String(type)];
+    const file = known && uri === undefined && locationPath(slots[known.slot]);
+    return file &&
+        known.ext.test(file.replace(/\?.*$/, '').toLowerCase()) &&
+        Object.entries(slots).every(([k, v]) => k === known.slot ||
+            (known.beside[k] !== undefined &&
+                locationPath(v) === `${file}${known.beside[k]}`))
+        ? file
+        : undefined;
+}
+/** The path of an alias adapter ggjbrowse reads as that path alone. */
+function plainAliases(adapter) {
+    const { type, uri, baseUri, location, ...rest } = adapter;
+    const file = typeof uri === 'string'
+        ? locationPath({ uri, baseUri })
+        : locationPath(location);
+    return file &&
+        Object.keys(rest).length === 0 &&
+        type === refNameAliasAdapterType(file)
+        ? file
+        : 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 function assemblyArgument(snapshot) {
+    const config = expandAssemblySequence(snapshot);
+    const name = String(config.name);
+    const sequence = withoutUnset(config.sequence?.adapter);
+    if (!sequence) {
+        return { skipped: 'the assembly names no sequence' };
+    }
+    const aliasConfig = config.refNameAliases;
+    const aliases = aliasConfig
+        ? withoutUnset(expandSidecarShorthand(aliasConfig, refNameAliasAdapterType).adapter)
+        : undefined;
+    const uris = [];
+    const located = {
+        name,
+        sequence: { adapter: openable(sequence, uris) },
+        ...(aliases
+            ? { refNameAliases: { adapter: openable(aliases, uris) } }
+            : {}),
+    };
+    if (uris.some(u => u.startsWith('blob:'))) {
+        return {
+            skipped: 'the assembly reads a file opened in the browser, which R cannot reach',
+        };
+    }
+    const sequenceFile = plainSequence(sequence);
+    const aliasFile = aliases && plainAliases(aliases);
+    return sequenceFile && (!aliases || aliasFile)
+        ? {
+            value: `jbrowse_assembly(${[
+                rStr(sequenceFile),
+                ...(aliasFile ? [rStr(aliasFile)] : []),
+                `name = ${rStr(name)}`,
+            ].join(', ')})`,
+        }
+        : { value: rValue(located) };
+}
+/** A region as JBrowse's location box writes it, 1-based and inclusive. */
+export function locusOf(refName, start, end) {
+    const n = (x) => Math.round(x).toLocaleString('en-US');
+    return `${refName}:${n(start + 1)}-${n(end)}`;
+}
+function lociLiteral(loci) {
+    return loci.length === 1
+        ? rStr(loci[0])
+        : `c(${loci.map(l => rStr(l)).join(', ')})`;
+}
+/** An R-safe name per track id, unique within the script. */
+function trackNames(tracks) {
+    const taken = new Set(['locus', 'width', 'assembly', 'fig']);
+    return tracks.map(track => {
+        let base = track.trackId
+            .replaceAll(/[^a-zA-Z0-9]/g, '_')
+            .replace(/^(?=[\d_])/, 'x');
+        if (!isIdentifier(base)) {
+            base = `${base}_track`;
+        }
+        let name = base;
+        for (let n = 2; taken.has(name); n++) {
+            name = `${base}_${n}`;
+        }
+        taken.add(name);
+        return name;
+    });
+}
+/** What the figure cannot show of a track whose settings ggjbrowse reads. */
+function settingNotes(track) {
+    const color = track.display.color;
+    return [
+        ...(color?.field === 'mateRefName'
+            ? [
+                'color: mateRefName colors each contig by its hash, where the browser orders them by the assembly',
+            ]
+            : []),
+    ];
+}
+/**
+ * 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 function exportTracksToR({ tracks, regions, assembly: assemblySnapshot, bpPerPx, out = 'figure.png', notes: viewNotes = [], }) {
+    const notes = [...viewNotes];
+    const assembly = assemblySnapshot && assemblyArgument(assemblySnapshot);
+    if (assembly && 'skipped' in assembly) {
+        notes.push(`assembly: ${assembly.skipped}`);
+    }
+    const assemblyValue = assembly && 'value' in assembly ? assembly.value : undefined;
+    const loci = regions.map(r => locusOf(r.refName, r.start, r.end));
+    const totalBp = regions.reduce((sum, r) => sum + r.end - r.start, 0);
+    const viewPx = bpPerPx ? Math.round(totalBp / bpPerPx) : undefined;
+    const widthReaders = [];
+    const names = trackNames(tracks);
+    const reads = [];
+    const drawn = [];
+    let alignments;
+    tracks.forEach((track, i) => {
+        const reader = READERS[track.displayType];
+        if (!reader) {
+            notes.push(`${track.trackName}: ${track.displayType} has no R reader in ggjbrowse yet`);
+            return;
+        }
+        const source = fileArgument(reader.adapters, track.adapter);
+        if ('skipped' in source) {
+            notes.push(`${track.trackName}: ${source.skipped}`);
+            return;
+        }
+        const { heightMode, height } = track;
+        const display = reader.call === 'jbrowse_features'
+            ? {
+                ...track.display,
+                ...(heightMode === undefined ? {} : { heightMode }),
+                ...(height === undefined ? {} : { height }),
+            }
+            : track.display;
+        const width = viewPx !== undefined;
+        const args = [
+            ...(Object.keys(display).length ? [`display = ${rValue(display)}`] : []),
+            ...(width ? ['width = width'] : []),
+            ...(assemblyValue ? ['assembly = assembly'] : []),
+            ...(source.index ? [`index = ${rStr(source.index)}`] : []),
+        ];
+        const name = names[i];
+        if (width) {
+            widthReaders.push(name);
+        }
+        reads.push([
+            `# ${track.trackName}`,
+            `${name} <- ${reader.call}(${source.file},`,
+            `  ${['locus', ...args].join(',\n  ')})`,
+        ].join('\n'));
+        drawn.push(name);
+        if (reader.call === 'jbrowse_alignments') {
+            alignments ??= name;
+        }
+        notes.push(...[
+            ...(source.uris.some(u => u.includes('://') && u.includes('?'))
+                ? [
+                    'source: a URL carries its query string, credential included, so the script is not one to share',
+                ]
+                : []),
+            ...settingNotes(track),
+        ].map(n => `${track.trackName}: ${n}`));
+    });
+    if (drawn.length === 0) {
+        return { drawn: 0, script: undefined, notes };
+    }
+    const script = [
+        "# Generated by JBrowse 2: the view's tracks, read by ggjbrowse, JBrowse's",
+        '# own engine in R, and drawn as the view stacks them.',
+        `# Install ggjbrowse with ${INSTALL}`,
+        '#',
+        '# Each reader returns the tables its track draws; jbrowse_stack() draws',
+        '# them. Restyle every band with &, or draw one alone and add to it:',
+        '#   fig & ggplot2::theme_classic()',
+        `#   ${alignments ? `autoplot(${alignments}, "pileup")` : `autoplot(${drawn[0]})`} + ggplot2::theme_classic()`,
+        ...(notes.length
+            ? [
+                '#',
+                '# What this figure does not show:',
+                ...notes.map(n => `#   - ${n}`),
+            ]
+            : []),
+        '',
+        'if (',
+        '  !requireNamespace("ggjbrowse", quietly = TRUE) ||',
+        `    packageVersion("ggjbrowse") < ${rStr(GGJBROWSE_VERSION)}`,
+        ') {',
+        `  stop("this script needs ggjbrowse ${GGJBROWSE_VERSION} or later: ${INSTALL.replaceAll('"', '\\"')}")`,
+        '}',
+        'library(ggjbrowse)',
+        '',
+        `locus <- ${lociLiteral(loci)}`,
+        ...(assemblyValue
+            ? [
+                "# The view's assembly: the reference every reader reads against, and",
+                '# the aliases that name each contig as each file spells it.',
+                `assembly <- ${assemblyValue}`,
+            ]
+            : []),
+        ...(widthReaders.length
+            ? [
+                "# The view's pixels across its regions. A smaller number lays the tracks",
+                '# out as a narrower browser window would, for a narrower figure with',
+                '# fewer labels at the same size.',
+                `width <- ${viewPx}`,
+            ]
+            : []),
+        '',
+        reads.join('\n\n'),
+        '',
+        `fig <- jbrowse_stack(${drawn.join(', ')})`,
+        'print(fig)',
+        `ggplot2::ggsave(${rStr(out)}, fig, width = jbrowse_width(fig), height = jbrowse_height(fig))`,
+        '',
+    ].join('\n');
+    return { drawn: drawn.length, script, notes };
+}

package/esm/LinearGenomeView/svgcomponents/SVGLinearGenomeView.js

@@ -27,20 +27,17 @@ export async function renderToSvg(model, opts) {
     textHeight = defaultTextHeight(fontSize), rulerHeight = 34, trackLabels = 'offset', themeName, fontFamily, showGridlines = false, Wrapper, } = opts;
     const session = getSession(model);
     const theme = session.getActiveThemeOptions?.(themeName);
-    // owns the two orderings this used to spell out by hand: legendWidth before
-    // the awaits, tracksHeight after them. Every display's `renderSvg` owns its
+    // owns the ordering this used to spell out by hand: the stack's height and
+    // legend gutter measured after the awaits. Every display's `renderSvg` owns its
     // own readiness wait — an LGV display through `renderDisplaySvg`'s
     // `awaitSvgReady`, a non-LGV one (dotplot, synteny, circular) by calling that
     // itself.
     const { tracks, displayResults, tracksHeight, legendWidth, skippedTracks } = await renderViewTracks({
         view: model,
-        opts,
+        opts: { ...opts, fontSize },
         theme,
         textHeight,
         trackLabels,
-        // the standalone export is the one with room to give: it widens its
-        // canvas below so a legend sits beside the plot rather than over it
-        reserveLegendWidth: true,
     });
     notifySkippedSvgTracks(session, skippedTracks);
     // read after the displays' waits, and handed to SVGHeader rather than read
@@ -72,6 +69,6 @@ export async function renderToSvg(model, opts) {
                 // header is the full one: cytoband overview and total-bp scalebar as
                 // well as the assembly name and ruler. `tracksTop` is the height
                 // getHeaderLayout gave it.
-                header: _jsx(SVGHeader, { model: model, fontSize: fontSize, rulerHeight: rulerHeight, layout: headerLayout, showCytobands: effectiveShowCytobands }), fontSize: fontSize, textHeight: textHeight, trackLabels: trackLabels, trackLabelOffset: trackLabelOffset, contentTop: tracksTop, tracksHeight: tracksHeight, showGridlines: showGridlines, leftBuffer: exportMargin, legendWidth: legendWidth }) })),
+                header: _jsx(SVGHeader, { model: model, fontSize: fontSize, rulerHeight: rulerHeight, layout: headerLayout, showCytobands: effectiveShowCytobands }), fontSize: fontSize, textHeight: textHeight, trackLabels: trackLabels, trackLabelOffset: trackLabelOffset, contentTop: tracksTop, tracksHeight: tracksHeight, showGridlines: showGridlines, leftBuffer: exportMargin }) })),
     });
 }

package/esm/LinearGenomeView/svgcomponents/SVGStackedRow.d.ts

@@ -7,7 +7,7 @@ import type { TrackLabelMode } from '@jbrowse/display-kit/types';
  * reserves `getRowHeaderLayout().bandHeight` above it for the header to draw
  * into, and the row is `rulerHeight + rendered.tracksHeight` tall below it.
  */
-export default function SVGStackedRow({ view, rendered, top, margin, fontSize, textHeight, rulerHeight, trackLabels, trackLabelOffset, showGridlines, legendWidth, showAssemblyName, showScalebar, }: {
+export default function SVGStackedRow({ view, rendered, top, margin, fontSize, textHeight, rulerHeight, trackLabels, trackLabelOffset, showGridlines, showAssemblyName, showScalebar, }: {
     view: LinearGenomeViewModel;
     rendered: {
         displayResults: SvgDisplayResult[];
@@ -21,7 +21,6 @@ export default function SVGStackedRow({ view, rendered, top, margin, fontSize, t
     trackLabels: TrackLabelMode;
     trackLabelOffset: number;
     showGridlines: boolean;
-    legendWidth?: number;
     showAssemblyName?: boolean;
     showScalebar?: boolean;
 }): import("react").JSX.Element;

package/esm/LinearGenomeView/svgcomponents/SVGStackedRow.js

@@ -7,6 +7,6 @@ import SVGView from './SVGView.js';
  * reserves `getRowHeaderLayout().bandHeight` above it for the header to draw
  * into, and the row is `rulerHeight + rendered.tracksHeight` tall below it.
  */
-export default function SVGStackedRow({ view, rendered, top, margin, fontSize, textHeight, rulerHeight, trackLabels, trackLabelOffset, showGridlines, legendWidth, showAssemblyName, showScalebar, }) {
-    return (_jsx("g", { transform: `translate(${margin} ${top})`, children: _jsx(SVGView, { view: view, displayResults: rendered.displayResults, header: _jsx(SVGRowHeader, { view: view, fontSize: fontSize, rulerHeight: rulerHeight, showAssemblyName: showAssemblyName, showScalebar: showScalebar }), fontSize: fontSize, textHeight: textHeight, trackLabels: trackLabels, trackLabelOffset: trackLabelOffset, contentTop: rulerHeight, tracksHeight: rendered.tracksHeight, showGridlines: showGridlines, leftBuffer: margin, legendWidth: legendWidth }) }));
+export default function SVGStackedRow({ view, rendered, top, margin, fontSize, textHeight, rulerHeight, trackLabels, trackLabelOffset, showGridlines, showAssemblyName, showScalebar, }) {
+    return (_jsx("g", { transform: `translate(${margin} ${top})`, children: _jsx(SVGView, { view: view, displayResults: rendered.displayResults, header: _jsx(SVGRowHeader, { view: view, fontSize: fontSize, rulerHeight: rulerHeight, showAssemblyName: showAssemblyName, showScalebar: showScalebar }), fontSize: fontSize, textHeight: textHeight, trackLabels: trackLabels, trackLabelOffset: trackLabelOffset, contentTop: rulerHeight, tracksHeight: rendered.tracksHeight, showGridlines: showGridlines, leftBuffer: margin }) }));
 }

package/esm/LinearGenomeView/svgcomponents/SVGTrackLabel.d.ts

@@ -1,10 +1,9 @@
 import type { TrackLabelMode } from '../types.ts';
-export default function SVGTrackLabel({ trackLabels, trackName, fontSize, textHeight, trackLabelOffset, x, raised, }: {
+export default function SVGTrackLabel({ trackLabels, trackName, fontSize, textHeight, trackLabelOffset, x, }: {
     trackName: string;
     trackLabels: TrackLabelMode;
     fontSize: number;
     textHeight: number;
     trackLabelOffset: number;
     x: number;
-    raised?: boolean;
 }): import("react").JSX.Element | null;

package/esm/LinearGenomeView/svgcomponents/SVGTrackLabel.js

@@ -4,24 +4,20 @@ import { stripAlpha } from '@jbrowse/core/util';
 import { TRACK_LABEL_GAP, insetLabelBaselineY, offsetLabelBaselineY, } from './util.js';
 // Where the label sits, per mode. 'left' right-aligns in the gutter
 // trackLabelLeftOffset reserved (hence the shared TRACK_LABEL_GAP), beside the
-// first row or, `raised`, in the band above a track whose sidebar holds the
-// gutter beside its rows. The other modes hang off the leftmost visible content
+// first row. The other modes hang off the leftmost visible content
 // at `x`, either just above the track body ('offset') or inset over it
 // ('overlapping').
 //
 // Every mode is placed on its alphabetic baseline (the SVG default, so no
-// dominantBaseline is emitted at all): 'offset' and a raised 'left' so their
-// descenders land a known distance above the track body — the band is
+// dominantBaseline is emitted at all): 'offset' so its descenders land a known distance above the track body — the band is
 // `textHeight` tall, and offsetLabelBaselineY owns that arithmetic — and
 // 'left'/'overlapping' so their ascenders stay inside the track box they align
 // with.
-function labelPosition({ trackLabels, trackLabelOffset, textHeight, fontSize, x, raised, }) {
+function labelPosition({ trackLabels, trackLabelOffset, textHeight, fontSize, x, }) {
     if (trackLabels === 'left') {
         return {
             x: trackLabelOffset - TRACK_LABEL_GAP,
-            y: raised
-                ? offsetLabelBaselineY(textHeight, fontSize)
-                : insetLabelBaselineY(fontSize),
+            y: insetLabelBaselineY(fontSize),
             textAnchor: 'end',
         };
     }
@@ -34,7 +30,7 @@ function labelPosition({ trackLabels, trackLabelOffset, textHeight, fontSize, x,
     // stay inside it (at y=0 they rose into the track above)
     return { x: x + 5, y: insetLabelBaselineY(fontSize) };
 }
-export default function SVGTrackLabel({ trackLabels, trackName, fontSize, textHeight, trackLabelOffset, x, raised = false, }) {
+export default function SVGTrackLabel({ trackLabels, trackName, fontSize, textHeight, trackLabelOffset, x, }) {
     const palette = usePalette();
     if (trackLabels === 'hidden') {
         return null;
@@ -45,7 +41,6 @@ export default function SVGTrackLabel({ trackLabels, trackName, fontSize, textHe
         textHeight,
         fontSize,
         x,
-        raised,
     });
     // 'overlapping' prints over the track's own data, which the on-screen label
     // clears with a paper box, so it carries the halo text over a plot needs

package/esm/LinearGenomeView/svgcomponents/SVGTracks.d.ts

@@ -2,7 +2,7 @@ import type { LinearGenomeViewModel } from '../index.ts';
 import type { TrackLabelMode } from '../types.ts';
 import type { SvgDisplayResult } from './util.ts';
 type LGV = LinearGenomeViewModel;
-export default function SVGTracks({ displayResults, model, textHeight, fontSize, trackLabels, trackLabelOffset, leftBuffer, legendWidth, }: {
+export default function SVGTracks({ displayResults, model, textHeight, fontSize, trackLabels, trackLabelOffset, leftBuffer, }: {
     displayResults: SvgDisplayResult[];
     model: LGV;
     textHeight: number;
@@ -10,6 +10,5 @@ export default function SVGTracks({ displayResults, model, textHeight, fontSize,
     trackLabels: TrackLabelMode;
     trackLabelOffset: number;
     leftBuffer: number;
-    legendWidth: number;
 }): import("react").JSX.Element;
 export {};

package/esm/LinearGenomeView/svgcomponents/SVGTracks.js

@@ -3,20 +3,20 @@ import { SvgClipRect } from '@jbrowse/core/svg/SvgExport';
 import { svgNodeId } from '@jbrowse/core/svg/svgId';
 import { svgTrackName } from '@jbrowse/core/svg/trackNames';
 import { getSession } from '@jbrowse/core/util';
-import { exportsTooLargeNote } from '@jbrowse/display-kit/renderDisplaySvg';
+import { SvgLegend } from '@jbrowse/display-kit/renderDisplaySvg';
 import SVGRegionSeparators from './SVGRegionSeparators.js';
 import SVGTrackLabel from './SVGTrackLabel.js';
-import { labelOffset, leftLabelRaised, trackBoxOffsets, trackLabelMode, } from './util.js';
-export default function SVGTracks({ displayResults, model, textHeight, fontSize, trackLabels, trackLabelOffset, leftBuffer, legendWidth, }) {
+import { labelOffset, trackBoxOffsets, trackLabelMode } from './util.js';
+export default function SVGTracks({ displayResults, model, textHeight, fontSize, trackLabels, trackLabelOffset, leftBuffer, }) {
     const session = getSession(model);
     const x = Math.max(-model.offsetPx, 0);
     const offsets = trackBoxOffsets(displayResults.map(r => r.track), trackLabels, textHeight);
-    return (_jsx(_Fragment, { children: displayResults.map(({ track, result }, i) => {
+    return (_jsx(_Fragment, { children: displayResults.map(({ track, result, legendHeight }, i) => {
             const conf = track.configuration;
             const trackName = svgTrackName(track, session);
             const display = track.displays[0];
             const currentOffset = offsets[i];
             const textOffset = labelOffset(track, trackLabels, textHeight);
-            return (_jsxs("g", { transform: `translate(0 ${currentOffset})`, children: [_jsx(SvgClipRect, { id: `track-clip-${svgNodeId(model)}-${conf.trackId}`, x: -leftBuffer, y: textOffset, width: model.width + trackLabelOffset + leftBuffer + legendWidth, height: display.height, children: _jsxs("g", { transform: `translate(${trackLabelOffset} ${textOffset})`, children: [result, exportsTooLargeNote(display) ? null : (_jsx(SVGRegionSeparators, { model: model, height: display.height }))] }) }), _jsx(SVGTrackLabel, { trackName: trackName, fontSize: fontSize, textHeight: textHeight, trackLabels: trackLabelMode(track, trackLabels), trackLabelOffset: trackLabelOffset, raised: leftLabelRaised(track, trackLabels), x: x + trackLabelOffset })] }, conf.trackId));
+            return (_jsxs("g", { transform: `translate(0 ${currentOffset})`, children: [_jsx(SvgClipRect, { id: `track-clip-${svgNodeId(model)}-${conf.trackId}`, x: -leftBuffer, y: textOffset, width: model.width + trackLabelOffset + leftBuffer, height: display.height, children: _jsxs("g", { transform: `translate(${trackLabelOffset} ${textOffset})`, children: [result, display.regionTooLarge ? null : (_jsx(SVGRegionSeparators, { model: model, height: display.height }))] }) }), legendHeight === undefined ? null : (_jsx("g", { transform: `translate(${trackLabelOffset} ${textOffset})`, children: _jsx(SvgLegend, { model: display, width: model.width, height: legendHeight }) })), _jsx(SVGTrackLabel, { trackName: trackName, fontSize: fontSize, textHeight: textHeight, trackLabels: trackLabelMode(track, trackLabels), trackLabelOffset: trackLabelOffset, x: x + trackLabelOffset })] }, conf.trackId));
         }) }));
 }

package/esm/LinearGenomeView/svgcomponents/SVGView.d.ts

@@ -2,7 +2,7 @@ import type { LinearGenomeViewModel } from '../index.ts';
 import type { TrackLabelMode } from '../types.ts';
 import type { SvgDisplayResult } from './util.ts';
 import type { ReactNode } from 'react';
-export default function SVGView({ view, displayResults, header, fontSize, textHeight, trackLabels, trackLabelOffset, contentTop, tracksHeight, showGridlines, leftBuffer, legendWidth, }: {
+export default function SVGView({ view, displayResults, header, fontSize, textHeight, trackLabels, trackLabelOffset, contentTop, tracksHeight, showGridlines, leftBuffer, }: {
     view: LinearGenomeViewModel;
     displayResults: SvgDisplayResult[];
     header: ReactNode;
@@ -14,5 +14,4 @@ export default function SVGView({ view, displayResults, header, fontSize, textHe
     tracksHeight: number;
     showGridlines: boolean;
     leftBuffer: number;
-    legendWidth?: number;
 }): import("react").JSX.Element;

package/esm/LinearGenomeView/svgcomponents/SVGView.js

@@ -7,7 +7,7 @@ import SVGTracks from './SVGTracks.js';
 // Shared by all three exports that stack an LGV — the standalone one, and the
 // linear-synteny and breakpoint-split rows — so their per-view layout can't
 // drift. It did drift while the standalone export kept its own copy of these
-// four groups: only that copy widened the per-track clip by `legendWidth`.
-export default function SVGView({ view, displayResults, header, fontSize, textHeight, trackLabels, trackLabelOffset, contentTop, tracksHeight, showGridlines, leftBuffer, legendWidth = 0, }) {
-    return (_jsxs(_Fragment, { children: [_jsx("g", { transform: `translate(${trackLabelOffset})`, children: header }), showGridlines ? (_jsx("g", { transform: `translate(${trackLabelOffset} ${contentTop})`, children: _jsx(SVGGridlines, { model: view, height: tracksHeight }) })) : null, _jsx("g", { transform: `translate(0 ${contentTop})`, children: _jsx(SVGTracks, { textHeight: textHeight, trackLabels: trackLabels, fontSize: fontSize, model: view, displayResults: displayResults, trackLabelOffset: trackLabelOffset, leftBuffer: leftBuffer, legendWidth: legendWidth }) }), _jsx("g", { transform: `translate(${trackLabelOffset} ${contentTop})`, children: _jsx(SVGHighlightsOverlay, { model: view, tracksHeight: tracksHeight }) })] }));
+// four groups.
+export default function SVGView({ view, displayResults, header, fontSize, textHeight, trackLabels, trackLabelOffset, contentTop, tracksHeight, showGridlines, leftBuffer, }) {
+    return (_jsxs(_Fragment, { children: [_jsx("g", { transform: `translate(${trackLabelOffset})`, children: header }), showGridlines ? (_jsx("g", { transform: `translate(${trackLabelOffset} ${contentTop})`, children: _jsx(SVGGridlines, { model: view, height: tracksHeight }) })) : null, _jsx("g", { transform: `translate(0 ${contentTop})`, children: _jsx(SVGTracks, { textHeight: textHeight, trackLabels: trackLabels, fontSize: fontSize, model: view, displayResults: displayResults, trackLabelOffset: trackLabelOffset, leftBuffer: leftBuffer }) }), _jsx("g", { transform: `translate(${trackLabelOffset} ${contentTop})`, children: _jsx(SVGHighlightsOverlay, { model: view, tracksHeight: tracksHeight }) })] }));
 }