@jbrowse/core 4.3.0 → 5.0.0-beta.10

package/esm/rpc/methods/CoreGetFeatures.js

@@ -1,29 +1,25 @@
 import { firstValueFrom } from 'rxjs';
 import { toArray } from 'rxjs/operators';
-import { getAdapter } from "../../data_adapters/dataAdapterCache.js";
-import RpcMethodType from "../../pluggableElementTypes/RpcMethodType.js";
-import { renameRegionsIfNeeded } from "../../util/index.js";
-import SimpleFeature from "../../util/simpleFeature.js";
-export default class CoreGetFeatures extends RpcMethodType {
+import { getFeatureAdapterOrThrow } from '../../data_adapters/getFeatureAdapter.js';
+import RpcMethodTypeWithRenameRegions from '../../pluggableElementTypes/RpcMethodTypeWithRenameRegions.js';
+import { unwrapRpcResult } from '../../util/rpc.js';
+import SimpleFeature from '../../util/simpleFeature.js';
+export default class CoreGetFeatures extends RpcMethodTypeWithRenameRegions {
     name = 'CoreGetFeatures';
-    async deserializeReturn(feats, args, rpcDriver) {
-        const superDeserialized = (await super.deserializeReturn(feats, args, rpcDriver));
-        return superDeserialized.map(feat => new SimpleFeature(feat));
+    async deserializeReturn(feats, _args) {
+        return unwrapRpcResult(feats).map(feat => new SimpleFeature(feat));
     }
-    async serializeArguments(args, rpcDriver) {
-        const { rootModel } = this.pluginManager;
-        const assemblyManager = rootModel.session.assemblyManager;
-        const renamedArgs = await renameRegionsIfNeeded(assemblyManager, args);
-        return super.serializeArguments(renamedArgs, rpcDriver);
-    }
-    async execute(args, rpcDriver) {
-        const { stopToken, statusCallback, sessionId, adapterConfig, regions, opts, } = await this.deserializeArguments(args, rpcDriver);
-        const dataAdapter = (await getAdapter(this.pluginManager, sessionId, adapterConfig)).dataAdapter;
+    async execute(args) {
+        const { signal, statusCallback, regions, opts } = args;
+        const dataAdapter = await getFeatureAdapterOrThrow({
+            ...args,
+            pluginManager: this.pluginManager,
+        });
         const r = await firstValueFrom(dataAdapter
             .getFeaturesInMultipleRegions(regions, {
             ...opts,
             statusCallback,
-            stopToken,
+            signal,
         })
             .pipe(toArray()));
         return r.map(f => f.toJSON());

package/esm/rpc/methods/CoreGetInfo.d.ts

@@ -0,0 +1,6 @@
+import RpcMethodType from '../../pluggableElementTypes/RpcMethodType.ts';
+import type { RpcExecuteArgs } from '../RpcRegistry.ts';
+export default class CoreGetInfo extends RpcMethodType<'CoreGetInfo'> {
+    name: 'CoreGetInfo';
+    execute(args: RpcExecuteArgs<'CoreGetInfo'>): Promise<unknown>;
+}

package/esm/rpc/methods/CoreGetInfo.js

@@ -0,0 +1,12 @@
+import { isFeatureAdapter } from '../../data_adapters/BaseAdapter/index.js';
+import { getAdapter } from '../../data_adapters/dataAdapterCache.js';
+import RpcMethodType from '../../pluggableElementTypes/RpcMethodType.js';
+export default class CoreGetInfo extends RpcMethodType {
+    name = 'CoreGetInfo';
+    async execute(args) {
+        const pm = this.pluginManager;
+        const { sessionId, adapterConfig } = args;
+        const { dataAdapter } = await getAdapter(pm, sessionId, adapterConfig);
+        return isFeatureAdapter(dataAdapter) ? dataAdapter.getHeader(args) : null;
+    }
+}

package/esm/rpc/methods/CoreGetMetadata.d.ts

@@ -1,9 +1,6 @@
 import RpcMethodType from '../../pluggableElementTypes/RpcMethodType.ts';
-export default class CoreGetMetadata extends RpcMethodType {
-    name: string;
-    execute(args: {
-        sessionId: string;
-        stopToken?: string;
-        adapterConfig: Record<string, unknown>;
-    }, rpcDriver: string): Promise<unknown>;
+import type { RpcExecuteArgs } from '../RpcRegistry.ts';
+export default class CoreGetMetadata extends RpcMethodType<'CoreGetMetadata'> {
+    name: 'CoreGetMetadata';
+    execute(args: RpcExecuteArgs<'CoreGetMetadata'>): Promise<unknown>;
 }

package/esm/rpc/methods/CoreGetMetadata.js

@@ -1,15 +1,12 @@
-import { isFeatureAdapter } from "../../data_adapters/BaseAdapter/index.js";
-import { getAdapter } from "../../data_adapters/dataAdapterCache.js";
-import RpcMethodType from "../../pluggableElementTypes/RpcMethodType.js";
+import { isFeatureAdapter } from '../../data_adapters/BaseAdapter/index.js';
+import { getAdapter } from '../../data_adapters/dataAdapterCache.js';
+import RpcMethodType from '../../pluggableElementTypes/RpcMethodType.js';
 export default class CoreGetMetadata extends RpcMethodType {
     name = 'CoreGetMetadata';
-    async execute(args, rpcDriver) {
+    async execute(args) {
         const pm = this.pluginManager;
-        const deserializedArgs = await this.deserializeArguments(args, rpcDriver);
-        const { sessionId, adapterConfig } = deserializedArgs;
+        const { sessionId, adapterConfig } = args;
         const { dataAdapter } = await getAdapter(pm, sessionId, adapterConfig);
-        return isFeatureAdapter(dataAdapter)
-            ? dataAdapter.getMetadata(deserializedArgs)
-            : null;
+        return isFeatureAdapter(dataAdapter) ? dataAdapter.getMetadata(args) : null;
     }
 }

package/esm/rpc/methods/CoreGetRefNames.d.ts

@@ -1,10 +1,6 @@
 import RpcMethodType from '../../pluggableElementTypes/RpcMethodType.ts';
-export default class CoreGetRefNames extends RpcMethodType {
-    name: string;
-    execute(args: {
-        sessionId: string;
-        stopToken?: string;
-        adapterConfig: Record<string, unknown>;
-        sequenceAdapter?: Record<string, unknown>;
-    }, rpcDriver: string): Promise<string[]>;
+import type { RpcExecuteArgs } from '../RpcRegistry.ts';
+export default class CoreGetRefNames extends RpcMethodType<'CoreGetRefNames'> {
+    name: 'CoreGetRefNames';
+    execute(args: RpcExecuteArgs<'CoreGetRefNames'>): Promise<string[] | never[]>;
 }

package/esm/rpc/methods/CoreGetRefNames.js

@@ -1,19 +1,20 @@
-import { isFeatureAdapter } from "../../data_adapters/BaseAdapter/index.js";
-import { getAdapter } from "../../data_adapters/dataAdapterCache.js";
-import RpcMethodType from "../../pluggableElementTypes/RpcMethodType.js";
+import { isRefNameSource } from '../../data_adapters/BaseAdapter/util.js';
+import { getAdapter } from '../../data_adapters/dataAdapterCache.js';
+import RpcMethodType from '../../pluggableElementTypes/RpcMethodType.js';
 export default class CoreGetRefNames extends RpcMethodType {
     name = 'CoreGetRefNames';
-    async execute(args, rpcDriver) {
-        const pm = this.pluginManager;
-        const deserializedArgs = await this.deserializeArguments(args, rpcDriver);
-        const { sessionId, adapterConfig, sequenceAdapter } = deserializedArgs;
-        const { dataAdapter } = await getAdapter(pm, sessionId, adapterConfig);
-        if (!isFeatureAdapter(dataAdapter)) {
-            return [];
-        }
-        if (sequenceAdapter && !dataAdapter.sequenceAdapterConfig) {
-            dataAdapter.setSequenceAdapterConfig(sequenceAdapter);
-        }
-        return dataAdapter.getRefNames(deserializedArgs);
+    async execute(args) {
+        const { sessionId, adapterConfig, sequenceAdapter } = args;
+        const { dataAdapter } = await getAdapter(this.pluginManager, sessionId, adapterConfig, sequenceAdapter);
+        // Gated on isRefNameSource rather than isFeatureAdapter: any adapter that
+        // can name its own contigs needs them reconciled with the assembly's,
+        // whether or not it serves features. PlinkLDTabixAdapter serves precomputed
+        // LD pairs, so it failed a feature-adapter check and reported *zero*
+        // refNames; that made the refName map empty, which made renaming a silent
+        // no-op, which left every record dropped by a later exact-match refName
+        // test. The symptom was a blank LD track with no error whenever the file's
+        // contig names differed from the assembly's canonical ones (an Ensembl-named
+        // .ld file against a UCSC-named hub, say).
+        return isRefNameSource(dataAdapter) ? dataAdapter.getRefNames(args) : [];
     }
 }

package/esm/rpc/methods/CoreGetRegionByteEstimate.d.ts

@@ -0,0 +1,6 @@
+import RpcMethodTypeWithRenameRegions from '../../pluggableElementTypes/RpcMethodTypeWithRenameRegions.ts';
+import type { RpcExecuteArgs } from '../RpcRegistry.ts';
+export default class CoreGetRegionByteEstimate extends RpcMethodTypeWithRenameRegions<'CoreGetRegionByteEstimate'> {
+    name: 'CoreGetRegionByteEstimate';
+    execute(args: RpcExecuteArgs<'CoreGetRegionByteEstimate'>): Promise<number | undefined>;
+}

package/esm/rpc/methods/CoreGetRegionByteEstimate.js

@@ -0,0 +1,19 @@
+import { isFeatureAdapter } from '../../data_adapters/BaseAdapter/index.js';
+import { getAdapter } from '../../data_adapters/dataAdapterCache.js';
+import RpcMethodTypeWithRenameRegions from '../../pluggableElementTypes/RpcMethodTypeWithRenameRegions.js';
+import { largestRegionBytes } from '../byteBudget.js';
+export default class CoreGetRegionByteEstimate extends RpcMethodTypeWithRenameRegions {
+    name = 'CoreGetRegionByteEstimate';
+    async execute(args) {
+        const { adapterConfig, sessionId, regions, scope } = args;
+        const { dataAdapter } = await getAdapter(this.pluginManager, sessionId, adapterConfig, args.sequenceAdapter);
+        // "Unmeasurable", not an error: the gate reads undefined as "no byte axis".
+        if (!isFeatureAdapter(dataAdapter)) {
+            return undefined;
+        }
+        if (scope === 'wholeRequest') {
+            return dataAdapter.getRegionByteSize(regions, args);
+        }
+        return largestRegionBytes(await Promise.all(regions.map(region => dataAdapter.getRegionByteSize([region], args))));
+    }
+}

package/esm/rpc/methods/CoreGetRegions.d.ts

@@ -1,8 +1,6 @@
 import RpcMethodType from '../../pluggableElementTypes/RpcMethodType.ts';
-export default class CoreGetRegions extends RpcMethodType {
-    name: string;
-    execute(args: {
-        sessionId: string;
-        adapterConfig: Record<string, unknown>;
-    }, rpcDriver: string): Promise<never[] | import("../../util/index.ts").NoAssemblyRegion[]>;
+import type { RpcExecuteArgs } from '../RpcRegistry.ts';
+export default class CoreGetRegions extends RpcMethodType<'CoreGetRegions'> {
+    name: 'CoreGetRegions';
+    execute(args: RpcExecuteArgs<'CoreGetRegions'>): Promise<never[] | import("../../util/index.ts").NoAssemblyRegion[]>;
 }

package/esm/rpc/methods/CoreGetRegions.js

@@ -1,15 +1,12 @@
-import { isRegionsAdapter } from "../../data_adapters/BaseAdapter/index.js";
-import { getAdapter } from "../../data_adapters/dataAdapterCache.js";
-import RpcMethodType from "../../pluggableElementTypes/RpcMethodType.js";
+import { isRegionsAdapter } from '../../data_adapters/BaseAdapter/index.js';
+import { getAdapter } from '../../data_adapters/dataAdapterCache.js';
+import RpcMethodType from '../../pluggableElementTypes/RpcMethodType.js';
 export default class CoreGetRegions extends RpcMethodType {
     name = 'CoreGetRegions';
-    async execute(args, rpcDriver) {
+    async execute(args) {
         const pm = this.pluginManager;
-        const deserializedArgs = await this.deserializeArguments(args, rpcDriver);
-        const { sessionId, adapterConfig } = deserializedArgs;
+        const { sessionId, adapterConfig } = args;
         const { dataAdapter } = await getAdapter(pm, sessionId, adapterConfig);
-        return isRegionsAdapter(dataAdapter)
-            ? dataAdapter.getRegions(deserializedArgs)
-            : [];
+        return isRegionsAdapter(dataAdapter) ? dataAdapter.getRegions(args) : [];
     }
 }

package/esm/rpc/methods/CoreGetSequence.d.ts

@@ -1,13 +1,6 @@
 import RpcMethodType from '../../pluggableElementTypes/RpcMethodType.ts';
-import type { RenderArgs } from './util.ts';
-import type { Region } from '../../util/index.ts';
-export default class CoreGetSequence extends RpcMethodType {
-    name: string;
-    serializeArguments(args: RenderArgs, rpcDriver: string): Promise<RenderArgs>;
-    execute(args: {
-        sessionId: string;
-        region: Region;
-        adapterConfig: Record<string, unknown>;
-        stopToken?: string;
-    }, rpcDriver: string): Promise<string | undefined>;
+import type { RpcExecuteArgs } from '../RpcRegistry.ts';
+export default class CoreGetSequence extends RpcMethodType<'CoreGetSequence'> {
+    name: 'CoreGetSequence';
+    execute(args: RpcExecuteArgs<'CoreGetSequence'>): Promise<string | undefined>;
 }

package/esm/rpc/methods/CoreGetSequence.js

@@ -1,17 +1,16 @@
-import { getAdapter } from "../../data_adapters/dataAdapterCache.js";
-import RpcMethodType from "../../pluggableElementTypes/RpcMethodType.js";
-import { renameRegionsIfNeeded } from "../../util/index.js";
+import { isSequenceAdapter } from '../../data_adapters/BaseAdapter/index.js';
+import { getAdapter } from '../../data_adapters/dataAdapterCache.js';
+import RpcMethodType from '../../pluggableElementTypes/RpcMethodType.js';
+// CoreGetSequence takes a single region whose refName fetchSeq() has already
+// resolved to the sequence adapter's name, so no region renaming is needed here
 export default class CoreGetSequence extends RpcMethodType {
     name = 'CoreGetSequence';
-    async serializeArguments(args, rpcDriver) {
-        const { rootModel } = this.pluginManager;
-        const assemblyManager = rootModel.session.assemblyManager;
-        const renamedArgs = await renameRegionsIfNeeded(assemblyManager, args);
-        return super.serializeArguments(renamedArgs, rpcDriver);
-    }
-    async execute(args, rpcDriver) {
-        const { stopToken, sessionId, adapterConfig, region } = await this.deserializeArguments(args, rpcDriver);
-        const dataAdapter = (await getAdapter(this.pluginManager, sessionId, adapterConfig)).dataAdapter;
-        return dataAdapter.getSequence(region, { stopToken });
+    async execute(args) {
+        const { signal, statusCallback, sessionId, adapterConfig, region } = args;
+        const { dataAdapter } = await getAdapter(this.pluginManager, sessionId, adapterConfig);
+        if (!isSequenceAdapter(dataAdapter)) {
+            throw new Error('Adapter does not support retrieving sequences');
+        }
+        return dataAdapter.getSequence(region, { signal, statusCallback });
     }
 }

package/esm/rpc/methods/CoreLoadAdapterCode.d.ts

@@ -0,0 +1,13 @@
+import RpcMethodType from '../../pluggableElementTypes/RpcMethodType.ts';
+import type { RpcExecuteArgs } from '../RpcRegistry.ts';
+/**
+ * Load these adapter types' code in the worker a track is about to use. An
+ * adapter's class arrives by dynamic import on the track's first request
+ * otherwise, and that download waits for the view to lay out and the assembly
+ * to load.
+ */
+export default class CoreLoadAdapterCode extends RpcMethodType<'CoreLoadAdapterCode'> {
+    name: 'CoreLoadAdapterCode';
+    execute({ adapterTypes }: RpcExecuteArgs<'CoreLoadAdapterCode'>): Promise<void>;
+    serializeArguments(args: Record<string, unknown>): Promise<Record<string, unknown>>;
+}

package/esm/rpc/methods/CoreLoadAdapterCode.js

@@ -0,0 +1,16 @@
+import RpcMethodType from '../../pluggableElementTypes/RpcMethodType.js';
+/**
+ * Load these adapter types' code in the worker a track is about to use. An
+ * adapter's class arrives by dynamic import on the track's first request
+ * otherwise, and that download waits for the view to lay out and the assembly
+ * to load.
+ */
+export default class CoreLoadAdapterCode extends RpcMethodType {
+    name = 'CoreLoadAdapterCode';
+    async execute({ adapterTypes }) {
+        await Promise.all(adapterTypes.map(type => this.pluginManager.getAdapterType(type).getAdapterClass()));
+    }
+    async serializeArguments(args) {
+        return args;
+    }
+}

package/esm/rpc/methods/layerFeatures.d.ts

@@ -0,0 +1,33 @@
+import type { BaseFeatureDataAdapter } from '../../data_adapters/BaseAdapter/index.ts';
+import type { FeatureTable } from '../../util/featureTable.ts';
+import type { JexlInstance } from '../../util/jexlStrings.ts';
+import type { CoreGetEncodedLayersArgs, FieldRef } from '../../util/markEncodingTypes.ts';
+import type { StatusCallback } from '../../util/progress.ts';
+/**
+ * One layer of a request as the encoder takes it: its rows, and the row of the
+ * plot each stands in — the field the layer reads, or under a facet each
+ * row's stacked row.
+ */
+export interface LayerFeatures {
+    table: FeatureTable;
+    row: FieldRef | ArrayLike<number> | undefined;
+}
+/**
+ * The table each layer of a `CoreGetEncodedLayers` request encodes: the
+ * region's features through the shared steps, split by the facet where the
+ * request names one, then through each layer's own steps, with each faceted
+ * layer's stacked rows beside it. An instance's `featureIndex` indexes its
+ * layer's table, so the same request answers which row an instance is.
+ */
+export declare function layerFeatures(dataAdapter: BaseFeatureDataAdapter, args: Pick<CoreGetEncodedLayersArgs, 'region' | 'layers' | 'transform' | 'facet' | 'bpPerPx' | 'opts'> & {
+    signal?: AbortSignal;
+    statusCallback?: StatusCallback;
+}, jexl: JexlInstance): Promise<{
+    layers: {
+        table: FeatureTable;
+        row: FieldRef | Uint32Array | undefined;
+    }[];
+    sections: import("../../util/markEncodingTypes.ts").FacetSection[] | undefined;
+    zoomRange: import("../../data_adapters/BaseAdapter/zoomRange.ts").ZoomRange | undefined;
+    notices: string[];
+}>;

package/esm/rpc/methods/layerFeatures.js

@@ -0,0 +1,29 @@
+import { checkAbortSignal } from '../../util/aborting.js';
+import { layerTables } from '../../util/featureTransforms.js';
+import { updateStatus } from '../../util/progress.js';
+/**
+ * The table each layer of a `CoreGetEncodedLayers` request encodes: the
+ * region's features through the shared steps, split by the facet where the
+ * request names one, then through each layer's own steps, with each faceted
+ * layer's stacked rows beside it. An instance's `featureIndex` indexes its
+ * layer's table, so the same request answers which row an instance is.
+ */
+export async function layerFeatures(dataAdapter, args, jexl) {
+    const { region, layers: requested, transform = [], facet, bpPerPx, opts, signal, statusCallback, } = args;
+    const notices = [];
+    const fetchOpts = { ...opts, bpPerPx, statusCallback, signal, notices };
+    const [fetched, zoomRange] = await updateStatus('Downloading features', statusCallback, () => Promise.all([
+        dataAdapter.getFeatureTable(region, fetchOpts),
+        dataAdapter.getZoomRange(fetchOpts),
+    ]));
+    checkAbortSignal(signal);
+    const { layers, sections } = layerTables(fetched, {
+        transform,
+        facet,
+        layers: requested.map(r => ({
+            transform: r.transform,
+            row: r.encoding.row,
+        })),
+    }, jexl);
+    return { layers, sections, zoomRange, notices };
+}

package/esm/rpc/serializeError/index.d.ts

@@ -0,0 +1,9 @@
+export interface ErrorObject {
+    name?: string;
+    message: string;
+    stack?: string;
+    cause?: unknown;
+    [key: string]: unknown;
+}
+export declare function serializeError(value: unknown): ErrorObject;
+export declare function deserializeError(value: unknown): Error;

package/esm/rpc/serializeError/index.js

@@ -0,0 +1,86 @@
+// Error's core fields (name/message/stack) are non-enumerable, so they're
+// copied explicitly; `cause` is non-enumerable too and recursed separately. Any
+// other own-enumerable props (AuthNeededError.url, a Node-style .code, etc.) are
+// copied generically so custom error data survives the worker boundary.
+const coreProperties = new Set(['name', 'message', 'stack', 'cause']);
+function stringify(value) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    // JSON.stringify returns undefined (not a string) for undefined, functions,
+    // and symbols, despite its type signature claiming otherwise
+    if (value === undefined ||
+        typeof value === 'function' ||
+        typeof value === 'symbol') {
+        return String(value);
+    }
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+function isSerializedError(value) {
+    return (!!value &&
+        typeof value === 'object' &&
+        !Array.isArray(value) &&
+        typeof value.message === 'string');
+}
+function errorToObject(error, seen) {
+    const obj = {
+        name: error.name,
+        message: error.message,
+        stack: error.stack,
+    };
+    // copy custom own-enumerable data (url, code, ...); skip functions since they
+    // aren't structured-cloneable and postMessage would throw on them
+    for (const [key, value] of Object.entries(error)) {
+        if (!coreProperties.has(key) && typeof value !== 'function') {
+            obj[key] = value;
+        }
+    }
+    const { cause } = error;
+    if (cause !== undefined && !seen.has(cause)) {
+        seen.add(cause);
+        obj.cause = cause instanceof Error ? errorToObject(cause, seen) : cause;
+    }
+    return obj;
+}
+export function serializeError(value) {
+    if (value instanceof Error) {
+        return errorToObject(value, new Set([value]));
+    }
+    // a thrown non-Error value (string, object, ...) still travels as an Error so
+    // the other side can reject with something error-shaped
+    return { name: 'NonError', message: stringify(value) };
+}
+export function deserializeError(value) {
+    if (value instanceof Error) {
+        return value;
+    }
+    if (typeof value === 'string') {
+        return new Error(value);
+    }
+    if (isSerializedError(value)) {
+        // reconstructed as a plain Error carrying the original name (nothing in the
+        // app branches on `instanceof TypeError` etc. across the worker boundary)
+        const error = new Error(value.message);
+        error.name = value.name ?? 'Error';
+        if (value.stack) {
+            error.stack = value.stack;
+        }
+        for (const [key, val] of Object.entries(value)) {
+            if (!coreProperties.has(key)) {
+                error[key] = val;
+            }
+        }
+        if (value.cause !== undefined) {
+            error.cause = isSerializedError(value.cause)
+                ? deserializeError(value.cause)
+                : value.cause;
+        }
+        return error;
+    }
+    return new Error(stringify(value));
+}

package/esm/svg/SvgExport.d.ts

@@ -0,0 +1,30 @@
+export declare function SVGBackground({ width, height, }: {
+    width: number;
+    height: number;
+}): import("react").JSX.Element;
+export declare function SVGExportRoot({ width, height, margin, fontFamily, children, }: {
+    width: number;
+    height: number;
+    margin?: number;
+    fontFamily?: string;
+    children: React.ReactNode;
+}): import("react").JSX.Element;
+export declare function SVGMessageBox({ message, width, height, }: {
+    message: string;
+    width: number;
+    height: number;
+}): import("react").JSX.Element;
+export declare function SvgChrome({ regionTooLarge, width, height, children, }: {
+    regionTooLarge?: boolean;
+    width: number;
+    height: number;
+    children: React.ReactNode;
+}): import("react").JSX.Element;
+export declare function SvgClipRect({ id, x, y, width, height, children, }: {
+    id: string;
+    x?: number;
+    y?: number;
+    width: number;
+    height: number;
+    children: React.ReactNode;
+}): import("react").JSX.Element;

package/esm/svg/SvgExport.js

@@ -0,0 +1,52 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// Reusable SVG-export building blocks, usable by any plugin without pulling in
+// the linear-genome-view plugin. Non-component members live in sibling files
+// (`constants.ts`, `svgReady.ts`) so this stays component-only for
+// react-refresh.
+import { usePalette } from '../ui/PaletteContext.js';
+import { stripAlpha } from '../util/svgColorProps.js';
+import { exportMargin } from './constants.js';
+import { svgSafeId } from './svgId.js';
+// Full-bleed background rect. `width`/`height` are the *total* SVG dimensions.
+export function SVGBackground({ width, height, }) {
+    const palette = usePalette();
+    return (_jsx("rect", { width: width, height: height, fill: stripAlpha(palette.background.default) }));
+}
+// Root <svg> for an image export. Owns the xmlns/viewBox boilerplate, widens
+// the canvas by `margin` on each side, and paints the themed background.
+// `width`/`height` are the content dimensions (the rendered canvas is
+// `width + margin * 2` wide); views translate their content by `margin` to sit
+// inside the gutter.
+export function SVGExportRoot({ width, height, margin = exportMargin, fontFamily, children, }) {
+    const totalWidth = width + margin * 2;
+    return (_jsxs("svg", { width: totalWidth, height: height, xmlns: "http://www.w3.org/2000/svg", xmlnsXlink: "http://www.w3.org/1999/xlink", viewBox: `0 0 ${totalWidth} ${height}`, fontFamily: fontFamily ? fontFamily : undefined, children: [_jsx(SVGBackground, { width: totalWidth, height: height }), children] }));
+}
+// Informational box for a soft terminal state (region too large). Keeps the
+// track's reserved height and labels a state that would otherwise export as a
+// silent blank.
+//
+// There is deliberately no error counterpart. A failed track fails the export
+// (`throwOnExportErrors`) rather than painting its error into the figure, so the
+// only terminal an export draws is one the user asked for by zooming out.
+export function SVGMessageBox({ message, width, height, }) {
+    return (_jsxs(_Fragment, { children: [_jsx("rect", { x: 0, y: 0, width: width, height: height, fill: "#f2f2f2" }), _jsx("text", { x: 10, y: height / 2, fill: "#555555", fontSize: 14, children: message })] }));
+}
+// SVG-export counterpart of DisplayChrome (BaseLinearDisplay/components): the
+// terminal-state gate every display's `renderSvg` ends in. It renders the
+// terminal state itself — a "region too large" message — and only paints the
+// children when the display has renderable data. The body is an ordinary child
+// component, so it never runs in a terminal state and no `renderSvg` re-detects
+// one from empty/absent data. The readiness wait happens before it, in
+// `renderDisplaySvg` (the one genuinely async step), so this component is sync.
+//
+// One terminal, not two, and the asymmetry is the point: over-budget is a state
+// the user navigated to on purpose, and a figure saying so is the honest export
+// of it. A fetch that failed is not — it is the export being unable to answer,
+// which `throwOnExportErrors` reports by failing rather than by drawing.
+export function SvgChrome({ regionTooLarge, width, height, children, }) {
+    return regionTooLarge ? (_jsx(SVGMessageBox, { message: "Region too large to render", width: width, height: height })) : (_jsx(_Fragment, { children: children }));
+}
+export function SvgClipRect({ id, x = 0, y = 0, width, height, children, }) {
+    const safeId = svgSafeId(id);
+    return (_jsxs(_Fragment, { children: [_jsx("defs", { children: _jsx("clipPath", { id: safeId, children: _jsx("rect", { x: x, y: y, width: width, height: height }) }) }), _jsx("g", { clipPath: `url(#${safeId})`, children: children })] }));
+}

package/esm/svg/SvgThemeProviders.d.ts

@@ -0,0 +1,12 @@
+import type { ThemeOptions } from '@mui/material';
+/**
+ * Both theme providers, from the export's theme options. An export renders
+ * outside every React tree the app mounted, so without them a `useTheme` body
+ * gets MUI's default theme and a `usePalette` or `makeStyles` one JBrowse's
+ * default light style theme — whatever theme the user picked. Every place an
+ * export tree is rendered mounts this: the file, a live figure, a ring strip.
+ */
+export declare function SvgThemeProviders({ theme, children, }: {
+    theme: ThemeOptions | undefined;
+    children: React.ReactNode;
+}): import("react").JSX.Element;

package/esm/svg/SvgThemeProviders.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { ThemeProvider } from '@mui/material';
+import { StyleThemeProvider } from '../ui/PaletteContext.js';
+import { resolveStyleTheme } from '../ui/styleTheme.js';
+import { createJBrowseTheme } from '../ui/theme.js';
+/**
+ * Both theme providers, from the export's theme options. An export renders
+ * outside every React tree the app mounted, so without them a `useTheme` body
+ * gets MUI's default theme and a `usePalette` or `makeStyles` one JBrowse's
+ * default light style theme — whatever theme the user picked. Every place an
+ * export tree is rendered mounts this: the file, a live figure, a ring strip.
+ */
+export function SvgThemeProviders({ theme, children, }) {
+    return (_jsx(ThemeProvider, { theme: createJBrowseTheme(theme), children: _jsx(StyleThemeProvider, { theme: resolveStyleTheme({ configTheme: theme }), children: children }) }));
+}

package/esm/svg/constants.d.ts

@@ -0,0 +1 @@
+export declare const exportMargin = 50;

package/esm/svg/constants.js

@@ -0,0 +1,5 @@
+// Fixed horizontal gutter (CSS px) added to the left and right of every image
+// export, giving ruler ticks and track-label backgrounds room to bleed past
+// the genome content area. Lives apart from `SvgExport.tsx` so that file stays
+// component-only for react-refresh.
+export const exportMargin = 50;

package/esm/svg/exportViewSvg.d.ts

@@ -0,0 +1,28 @@
+import type { SvgRasterCanvasOpts } from '../util/createSvgRasterCanvas.ts';
+import type React from 'react';
+/** What every view's `exportSvg` accepts. A view with more extends it. */
+export interface ViewExportSvgOptions extends SvgRasterCanvasOpts {
+    rasterizeLayers?: boolean;
+    format?: 'svg' | 'png';
+    filename?: string;
+    /**
+     * Whether to hand the result to the browser's download path. Default true,
+     * which is the dialog. False returns the markup and writes nothing — the
+     * caller has somewhere of its own to put it, and a download it did not ask
+     * for would land beside that under a name it did not choose.
+     */
+    save?: boolean;
+    Wrapper?: React.FC<{
+        children: React.ReactNode;
+    }>;
+    /** a named theme; the session's active one when absent */
+    themeName?: string;
+    fontFamily?: string;
+}
+/**
+ * The body of every view's `exportSvg` action: load the view's lazy
+ * `renderToSvg`, render, save unless `save: false`, and return the markup.
+ */
+export declare function exportViewSvg<V, O extends ViewExportSvgOptions>(view: V, opts: O, load: () => Promise<{
+    renderToSvg: (view: V, opts: O) => Promise<string>;
+}>): Promise<string>;