loom-browser 0.0.1 → 0.0.3

package/dist/types/src/themes/renderTheme.d.ts

@@ -1,86 +0,0 @@
-/**
- * Unified RenderTheme system — shadcn-style palette-driven theming.
- *
- * Users define a global palette (primary, secondary, background, foreground, etc.)
- * and each track type knows how to derive its specific config defaults from that
- * palette. Everything is overridable at three levels:
- *
- *   1. Palette-derived defaults   (annotation.color = palette.primary)
- *   2. Per-track-type overrides   (theme.annotation.borderRadius = 3)
- *   3. Per-track instance overrides (options.config.color = 'red')
- *
- * Renderers never see RenderTheme directly — they still consume AnnotationRenderConfig,
- * WigRenderConfig, etc. The theme system produces those configs.
- */
-import type { AnnotationRenderConfig, WigRenderConfig, RulerRenderConfig, SequenceRenderConfig, InteractionRenderConfig } from '../types';
-/** Global color palette — the primary customization surface. */
-export interface ThemePalette {
-    /** Main track color (CDS exons, wig bars, signal fill). */
-    primary: string;
-    /** Alternate strand, negative values. */
-    secondary: string;
-    /** Highlights, selections, active states. */
-    accent: string;
-    /** Track canvas background. */
-    background: string;
-    /** Text, labels, tick marks. */
-    foreground: string;
-    /** Subtle elements: baselines, introns, borders. */
-    muted: string;
-}
-/**
- * Unified render theme. Defines a global palette, typography, and nucleotide
- * colors. Each track type derives its config defaults from the palette, with
- * optional per-track-type overrides.
- */
-export interface RenderTheme {
-    palette: ThemePalette;
-    /** CSS font-family string. Default: 'sans-serif'. */
-    fontFamily: string;
-    /** Base font size in pixels. Default: 10. */
-    fontSize: number;
-    /** Nucleotide color mapping (A, C, G, T, N). */
-    nucleotideColors: Record<string, string>;
-    annotation?: Partial<AnnotationRenderConfig>;
-    wig?: Partial<WigRenderConfig>;
-    ruler?: Partial<RulerRenderConfig>;
-    sequence?: Partial<SequenceRenderConfig>;
-    interaction?: Partial<InteractionRenderConfig>;
-}
-/** Returns the default render theme matching classic igv.js appearance. */
-export declare function defaultRenderTheme(): RenderTheme;
-/**
- * Deep-merge a partial theme into the defaults.
- * If no overrides provided, returns the default theme.
- */
-export declare function resolveTheme(overrides?: Partial<RenderTheme>): RenderTheme;
-/**
- * Resolve a full AnnotationRenderConfig from a theme + optional per-track overrides.
- *
- * Resolution: palette-derived defaults → theme.annotation overrides → per-track overrides.
- */
-export declare function resolveAnnotationConfig(theme: RenderTheme, overrides?: Partial<AnnotationRenderConfig>): AnnotationRenderConfig;
-/**
- * Resolve a full WigRenderConfig from a theme + optional per-track overrides.
- *
- * Resolution: palette-derived defaults → theme.wig overrides → per-track overrides.
- */
-export declare function resolveWigConfig(theme: RenderTheme, overrides?: Partial<WigRenderConfig>): WigRenderConfig;
-/**
- * Resolve a full RulerRenderConfig from a theme + optional per-track overrides.
- *
- * Resolution: palette-derived defaults → theme.ruler overrides → per-track overrides.
- */
-export declare function resolveRulerConfig(theme: RenderTheme, overrides?: Partial<RulerRenderConfig>): RulerRenderConfig;
-/**
- * Resolve a full SequenceRenderConfig from a theme + optional per-track overrides.
- *
- * Resolution: palette-derived defaults → theme.sequence overrides → per-track overrides.
- */
-export declare function resolveSequenceConfig(theme: RenderTheme, overrides?: Partial<SequenceRenderConfig>): SequenceRenderConfig;
-/**
- * Resolve a full InteractionRenderConfig from a theme + optional per-track overrides.
- *
- * Resolution: palette-derived defaults → theme.interaction overrides → per-track overrides.
- */
-export declare function resolveInteractionConfig(theme: RenderTheme, overrides?: Partial<InteractionRenderConfig>): InteractionRenderConfig;

package/dist/types/src/themes/renderThemePresets.d.ts

@@ -1,16 +0,0 @@
-/**
- * Built-in RenderTheme presets.
- *
- * These are Partial<RenderTheme> objects — pass them to resolveTheme() to get
- * a fully resolved theme with defaults filled in.
- *
- * Usage:
- *   import {resolveTheme} from './renderTheme'
- *   import {modernRenderTheme} from './renderThemePresets'
- *   const theme = resolveTheme(modernRenderTheme)
- */
-import type { RenderTheme } from './renderTheme';
-/** Modern theme — blue/pink palette, rounded exons, system font. */
-export declare const modernRenderTheme: Partial<RenderTheme>;
-/** Dark theme — adapted for dark backgrounds, high contrast. */
-export declare const darkRenderTheme: Partial<RenderTheme>;

package/dist/types/src/trackRegistry.d.ts

@@ -1,81 +0,0 @@
-/**
- * Track registry — extensible factory for creating tracks from session configs.
- *
- * Mirrors igv.js `trackFactory.ts` (`js/trackFactory.ts`), which uses a
- * `Map<string, TrackCreator>` with type alias resolution and runtime
- * registration via `registerTrackClass()` / `registerTrackCreatorFunction()`.
- *
- * Our implementation follows the same pattern: a central `Map` of creators,
- * type aliases, and public registration functions. The key difference is that
- * igv.js creators take `(config, browser)` and return a Track, whereas ours
- * take `(trackConfig, context)` and return a `CreatedTrack` (track + data
- * source + metadata) since data sources are first-class in our architecture.
- */
-import type { Locus, Track, DataSource, DataSourceConfig, TrackSessionConfig, SequenceProvider } from './types';
-import type { CanvasProvider } from './canvasProvider';
-import type { WorkerProvider } from './workerProvider';
-import type { RenderTheme } from './themes/renderTheme';
-/** Context passed to every track creator function. */
-export interface TrackCreatorContext {
-    locus: Locus;
-    canvasProvider: CanvasProvider;
-    workerProvider?: WorkerProvider;
-    theme?: Partial<RenderTheme>;
-    /** Sequence provider from the genome, used by sequence tracks. */
-    sequenceProvider?: SequenceProvider;
-}
-/** Result of creating a track — the track itself plus optional data source. */
-export interface CreatedTrack {
-    track: Track;
-    dataSource: DataSource | null;
-    dataSourceConfig: DataSourceConfig | null;
-    name?: string;
-    order?: number;
-}
-/**
- * Factory function that creates a track + data source from a session config.
- *
- * Mirrors igv.js `TrackCreator = (config, browser) => Track` but returns
- * a richer result since we separate track rendering from data sourcing.
- */
-export type TrackCreator = (trackConfig: TrackSessionConfig, context: TrackCreatorContext) => CreatedTrack;
-/**
- * Register a track creator for a given type string.
- *
- * Mirrors igv.js `registerTrackCreatorFunction()` (js/trackFactory.ts).
- */
-export declare function registerTrackCreator(type: string, creator: TrackCreator): void;
-/**
- * Register a type alias so that e.g. "gene" resolves to "annotation".
- *
- * Mirrors igv.js alias resolution in `getTrack()` (js/trackFactory.ts lines 78-96)
- * where switch/case maps "annotation"→"feature", "genes"→"feature", etc.
- */
-export declare function registerTypeAlias(alias: string, canonicalType: string): void;
-/**
- * Look up a track creator by type (resolving aliases first).
- *
- * Mirrors igv.js `getTrack()` (js/trackFactory.ts) which resolves aliases
- * then looks up in the `trackFunctions` Map.
- */
-export declare function getTrackCreator(type: string): TrackCreator | undefined;
-/**
- * Return all known track type strings (canonical + aliases).
- *
- * Mirrors igv.js `knownTrackTypes()` (js/trackFactory.ts).
- */
-export declare function knownTrackTypes(): Set<string>;
-export declare function createDataSource(config: DataSourceConfig, workerProvider?: WorkerProvider): DataSource;
-/**
- * Create a track from a session config using the registry.
- *
- * This replaces the switch/case in the old `createTrackFromSession()`.
- * Unknown types throw an error (mirrors igv.js behavior where `getTrack()`
- * returns undefined and the browser logs a warning).
- */
-export declare function createTrackFromConfig(trackConfig: TrackSessionConfig, locus: Locus, options?: {
-    canvasProvider?: CanvasProvider;
-    workerProvider?: WorkerProvider;
-    theme?: Partial<RenderTheme>;
-    sequenceProvider?: SequenceProvider;
-}): CreatedTrack;

package/dist/types/src/trackSelector.d.ts

@@ -1,31 +0,0 @@
-/**
- * TrackSelector — SQL-ish WHERE clause for matching tracks by metadata.
- *
- * Selectors support matching on track ID, name (string or RegExp), type,
- * and arbitrary metadata key-value pairs. All provided fields use AND semantics:
- * a track must match every specified criterion.
- *
- * ```ts
- * // Remove all ATAC-seq tracks
- * browser.removeTracks({ where: { assay: 'ATAC-seq' } })
- *
- * // Find wig tracks from K562
- * browser.findTracks({ type: 'wig', where: { biosample: 'K562' } })
- * ```
- */
-import type { ManagedTrack } from './headlessGenomeBrowser';
-/** Selector for matching tracks by ID, name, type, and/or metadata. */
-export interface TrackSelector {
-    /** Exact match against track ID. */
-    id?: string;
-    /** String: case-insensitive substring match. RegExp: test against track name. */
-    name?: string | RegExp;
-    /** Exact match against track type (e.g. 'wig', 'annotation', 'interact'). */
-    type?: string;
-    /** Metadata key-value matching. Every entry must match (AND semantics). */
-    where?: Record<string, string>;
-}
-/** Test whether a single managed track matches all criteria in a selector. */
-export declare function matchesSelector(mt: ManagedTrack, selector: TrackSelector): boolean;
-/** Select all managed tracks matching a selector. */
-export declare function selectTracks(tracks: readonly ManagedTrack[], selector: TrackSelector): ManagedTrack[];

package/dist/types/src/tracks/annotation/annotationRenderer.d.ts

@@ -1,17 +0,0 @@
-/**
- * Standalone annotation feature renderer.
- *
- * Adapted from js/feature/render/renderFeature.ts but with no `this` context —
- * all configuration is passed as explicit parameters.
- *
- * Renders gene, BED, GFF, and peak features with exon/UTR/CDS structure,
- * intron lines, strand arrows, labels, and per-feature colors.
- */
-import type { AnnotationFeature, AnnotationRenderConfig, RenderContext } from '../../types';
-/**
- * Render a set of annotation features onto a canvas context.
- *
- * Features should already have `.row` assigned (via `pack()`).
- * The canvas should be sized and cleared before calling this.
- */
-export declare function renderAnnotationTrack(ctx: CanvasRenderingContext2D, features: AnnotationFeature[], config: AnnotationRenderConfig, rc: RenderContext): void;

package/dist/types/src/tracks/annotation/annotationThemes.d.ts

@@ -1,11 +0,0 @@
-/**
- * Preset render themes for annotation tracks.
- *
- * Each theme is a Partial<AnnotationRenderConfig> that can be spread over defaults.
- * Usage: { ...defaultAnnotationRenderConfig(), ...modernTheme }
- */
-import type { AnnotationRenderConfig } from '../../types';
-/** Modern theme — softer colors, rounded exons, strand-based coloring. */
-export declare const modernTheme: Partial<AnnotationRenderConfig>;
-/** Dark theme — modern theme adapted for dark backgrounds. */
-export declare const darkTheme: Partial<AnnotationRenderConfig>;

package/dist/types/src/tracks/annotation/annotationTrackCanvas.d.ts

@@ -1,58 +0,0 @@
-/**
- * Canvas manager for rendering annotation features (gene, BED, GFF, peaks).
- *
- * Extends BaseTrackCanvas — canvas lifecycle (DPR, resize, attach/detach,
- * background) is handled by the base class. This class only implements
- * annotation-specific logic: feature packing, height computation, and rendering.
- *
- * Usage:
- *   const canvas = document.createElement('canvas')
- *   const track = new AnnotationTrackCanvas(canvas, { locus, features })
- *   track.attachTo(containerDiv)
- */
-import type { AnnotationFeature, AnnotationRenderConfig, Locus, RenderContext, AnnotationTrackSessionConfig, HitTestResult, AxisInfo, ContextMenuItem } from '../../types';
-import type { CanvasProvider } from '../../canvasProvider';
-import type { WorkerProvider } from '../../workerProvider';
-import type { RenderTheme } from '../../themes/renderTheme';
-import { BaseTrackCanvas } from '../baseTrackCanvas';
-export type { Locus } from '../../types';
-export interface AnnotationTrackCanvasOptions {
-    locus: Locus;
-    features: AnnotationFeature[];
-    /** Per-track config overrides. Applied after theme-derived defaults. */
-    config?: Partial<AnnotationRenderConfig>;
-    /** Unified render theme. Palette drives default colors/fonts. */
-    theme?: Partial<RenderTheme>;
-    /** Fixed pixel height. If not set, computed from row count. */
-    height?: number;
-    /** Background color. Default: palette.background. */
-    background?: string;
-    /** Canvas provider for environment abstraction. Default: DOMCanvasProvider. */
-    canvasProvider?: CanvasProvider;
-    /** Worker provider for offloading CPU-intensive tasks (packing). */
-    workerProvider?: WorkerProvider;
-    /** Track name for axis label. */
-    name?: string;
-}
-export declare class AnnotationTrackCanvas extends BaseTrackCanvas<AnnotationRenderConfig> {
-    private features;
-    private fixedHeight;
-    private background;
-    private _name;
-    private workerProvider?;
-    /** Most recently packed features, available after render(). */
-    private packedFeatures;
-    /** Whether packedFeatures was pre-computed by async worker (skip sync pack in computeHeight). */
-    private packedReady;
-    readonly type = "annotation";
-    constructor(canvas: HTMLCanvasElement, options: AnnotationTrackCanvasOptions);
-    /** Update features and re-render. Dispatches async pack when workerProvider is set. */
-    setFeatures(features: AnnotationFeature[]): void;
-    protected computeHeight(_width: number): number;
-    protected getBackground(): string;
-    protected doRender(ctx: CanvasRenderingContext2D, _width: number, _height: number, rc: RenderContext): void;
-    getAxisInfo(): AxisInfo | undefined;
-    getContextMenuItems(_x: number, _y: number): ContextMenuItem[];
-    hitTest(x: number, y: number): HitTestResult<AnnotationFeature>[];
-    serializeConfig(theme: RenderTheme): AnnotationTrackSessionConfig;
-}

package/dist/types/src/tracks/annotation/index.d.ts

@@ -1,4 +0,0 @@
-export { renderAnnotationTrack } from './annotationRenderer';
-export { AnnotationTrackCanvas } from './annotationTrackCanvas';
-export type { AnnotationTrackCanvasOptions } from './annotationTrackCanvas';
-export { modernTheme, darkTheme } from './annotationThemes';

package/dist/types/src/tracks/axis/axisRenderer.d.ts

@@ -1,19 +0,0 @@
-/**
- * Stateless axis renderers for the left-hand axis column.
- *
- * These are pure canvas renderers — they take a 2D context, axis info, and
- * dimensions, and paint the axis. No DOM, no state, no side effects.
- *
- * Two variants:
- * - renderQuantitativeAxis: tick marks + data range labels for numeric tracks (wig)
- * - renderLabelAxis: centered rotated text label for annotation tracks (gene)
- */
-import type { AxisInfo } from '../../types';
-/** Format a number for axis labels (ported from igv.js paintAxis.ts). */
-export declare function prettyPrintNumber(n: number): string;
-export declare function renderQuantitativeAxis(ctx: CanvasRenderingContext2D, info: AxisInfo, width: number, height: number): void;
-/**
- * Paint a label-only axis (e.g., gene track name).
- * Renders a vertically-rotated centered text label.
- */
-export declare function renderLabelAxis(ctx: CanvasRenderingContext2D, info: AxisInfo, width: number, height: number): void;

package/dist/types/src/tracks/axis/index.d.ts

@@ -1 +0,0 @@
-export { renderQuantitativeAxis, renderLabelAxis, prettyPrintNumber } from './axisRenderer';

package/dist/types/src/tracks/baseTrackCanvas.d.ts

@@ -1,113 +0,0 @@
-/**
- * Base class for canvas-based genomic track renderers.
- *
- * Handles all shared canvas lifecycle: DPR scaling, sizing, resize observation,
- * attach/detach, background fill, and RenderContext construction.
- *
- * Subclasses implement:
- *   - type (track type identifier)
- *   - computeHeight(width) — return CSS pixel height for current state
- *   - getBackground() — return background fill color
- *   - doRender(ctx, width, height, rc) — the actual drawing logic
- *
- * This eliminates ~80 lines of identical boilerplate per track type.
- */
-import type { Locus, RenderContext, Track, TrackSessionConfig, HitTestResult, ContextMenuItem } from '../types';
-import type { RenderTheme } from '../themes/renderTheme';
-import type { CanvasProvider } from '../canvasProvider';
-export declare abstract class BaseTrackCanvas<TConfig> implements Track {
-    protected _canvas: HTMLCanvasElement;
-    protected _locus: Locus;
-    protected _config: TConfig;
-    protected _height: number;
-    protected canvasProvider: CanvasProvider;
-    private resizeObserver;
-    private container;
-    private _renderSuspended;
-    private _renderPending;
-    private _error;
-    private _zoomedOut;
-    /**
-     * Visibility window in base pairs. When the viewport spans more than this
-     * many bp, data is not fetched and "Zoom in to see features" is shown.
-     * Mirrors igv.js TrackBase.visibilityWindow (js/trackViewport.ts checkZoomIn).
-     *
-     * Set to undefined or 0 to disable (always fetch). Set > 0 to enable.
-     */
-    visibilityWindow?: number;
-    abstract readonly type: string;
-    get canvas(): HTMLCanvasElement;
-    get locus(): Locus;
-    get height(): number;
-    /** Current track config (read-only). Use setConfig() to update. */
-    get config(): TConfig;
-    constructor(canvas: HTMLCanvasElement, locus: Locus, config: TConfig, canvasProvider?: CanvasProvider);
-    /** Update locus and re-render. */
-    setLocus(locus: Locus): void;
-    /** Merge partial config and re-render. */
-    setConfig(config: Partial<TConfig>): void;
-    /** Suspend rendering — calls to render() will be deferred until resumeRendering(). */
-    suspendRendering(): void;
-    /** Resume rendering. If render() was called while suspended, flushes now. */
-    resumeRendering(): void;
-    /** Set an error state to render on the track canvas. Pass null to clear. */
-    setError(error: Error | null): void;
-    /**
-     * Mark this track as zoomed out beyond its visibility window.
-     * When true, render() shows "Zoom in to see features" instead of track content.
-     * Called by HeadlessGenomeBrowser during data lifecycle.
-     */
-    setZoomedOut(zoomedOut: boolean): void;
-    /**
-     * Hit-test at canvas-relative pixel coordinates.
-     * Returns features at that point with pre-formatted popup data.
-     * Default: empty (no interactive features). Subclasses override.
-     */
-    hitTest(_x: number, _y: number): HitTestResult[];
-    /**
-     * Return context menu items for a right-click at canvas-relative coordinates.
-     * Default: undefined (no track-specific items). Subclasses override.
-     */
-    getContextMenuItems(_x: number, _y: number): ContextMenuItem[] | undefined;
-    /**
-     * Attach the canvas to a container element.
-     * Appends the canvas and sets up a ResizeObserver for automatic re-renders.
-     */
-    attachTo(container: HTMLElement): void;
-    /** Detach from container and stop observing resizes. */
-    detach(): void;
-    /** Render the track. Handles DPR, sizing, background, then delegates to doRender(). */
-    render(): void;
-    /** Draw a centered error message on the canvas. */
-    protected renderError(ctx: CanvasRenderingContext2D, width: number, height: number): void;
-    /**
-     * Draw a centered "Zoom in to see features" notice.
-     * Mirrors igv.js TrackViewport.createZoomInNotice (js/trackViewport.ts).
-     */
-    protected renderZoomInNotice(ctx: CanvasRenderingContext2D, width: number, height: number): void;
-    /**
-     * Render this track onto an arbitrary context (e.g. Canvas2SVG for SVG export).
-     * Skips DPR scaling and canvas-element lifecycle — draws directly at the given
-     * dimensions using the track's current locus and state.
-     *
-     * Mirrors igv.js TrackViewport.renderSVGContext() which calls track.draw()
-     * with a C2S context (js/trackViewport.ts lines 525-579).
-     */
-    renderToContext(ctx: CanvasRenderingContext2D, width: number, height: number): void;
-    /**
-     * Compute the track height in CSS pixels for the current state.
-     * Called at the start of each render(). The width parameter is provided
-     * in case height depends on layout (e.g., gene packing).
-     */
-    protected abstract computeHeight(width: number): number;
-    /** Return the background fill color for the canvas. */
-    protected abstract getBackground(): string;
-    /** Perform the actual track-specific rendering onto the prepared canvas. */
-    protected abstract doRender(ctx: CanvasRenderingContext2D, width: number, height: number, rc: RenderContext): void;
-    /**
-     * Serialize this track's config for session save/restore.
-     * Each subclass diffs its config against theme defaults and returns
-     * a typed TrackSessionConfig with only overridden fields.
-     */
-    abstract serializeConfig(theme: RenderTheme): TrackSessionConfig;
-}

package/dist/types/src/tracks/dynseq/dynseqRenderer.d.ts

@@ -1,38 +0,0 @@
-/**
- * Dynamic sequence (dynseq) renderer for wig tracks.
- *
- * Renders DNA base letters (A, C, G, T, N) as filled glyphs whose height
- * is proportional to the wig signal value. Only activates at high zoom
- * (bpPerPixel < 2) where individual bases are resolvable.
- *
- * Ported from js/feature/wigTrack.ts renderDynSeq/drawLetterGlyph/drawSVGPath.
- */
-/** Default nucleotide color scheme matching igv.js. */
-export declare const defaultNucleotideColors: Readonly<Record<string, string>>;
-/**
- * Draw a single DNA base letter as a filled glyph.
- *
- * @param ctx - Canvas context
- * @param base - The base character (A, C, G, T, N)
- * @param x - Left edge pixel position
- * @param y - Top edge pixel position
- * @param width - Glyph width in pixels
- * @param height - Glyph height in pixels
- * @param color - Fill color
- * @param flipVertical - Flip the glyph vertically (for negative values)
- */
-export declare function drawLetterGlyph(ctx: CanvasRenderingContext2D, base: string, x: number, y: number, width: number, height: number, color: string, flipVertical?: boolean, backgroundColor?: string): void;
-/**
- * Render a single wig feature as dynseq (DNA base glyphs scaled by value).
- *
- * @param ctx - Canvas context
- * @param sequence - DNA sequence string for this feature's region
- * @param x - Left edge pixel position of the feature
- * @param width - Pixel width of the feature
- * @param y - Y pixel of the data value
- * @param y0 - Y pixel of the zero line
- * @param value - The wig data value (for determining negative/flip)
- * @param colors - Nucleotide color map
- * @param backgroundColor - Background color for glyph cutouts (e.g. hole in 'A')
- */
-export declare function renderDynSeqFeature(ctx: CanvasRenderingContext2D, sequence: string, x: number, width: number, y: number, y0: number, value: number, colors?: Readonly<Record<string, string>>, backgroundColor?: string): void;

package/dist/types/src/tracks/dynseq/index.d.ts

@@ -1 +0,0 @@
-export { renderDynSeqFeature, drawLetterGlyph, defaultNucleotideColors } from './dynseqRenderer';

package/dist/types/src/tracks/index.d.ts

@@ -1,7 +0,0 @@
-export { BaseTrackCanvas } from './baseTrackCanvas';
-export * from './axis';
-export * from './annotation';
-export * from './wig';
-export * from './ruler';
-export * from './dynseq';
-export * from './interaction';

package/dist/types/src/tracks/interaction/index.d.ts

@@ -1,4 +0,0 @@
-export { renderInteractionTrack, positionString } from './interactionRenderer';
-export type { DrawnInteractionFeature, InteractionDrawState } from './interactionRenderer';
-export { InteractionTrackCanvas } from './interactionTrackCanvas';
-export type { InteractionTrackCanvasOptions } from './interactionTrackCanvas';

package/dist/types/src/tracks/interaction/interactionRenderer.d.ts

@@ -1,52 +0,0 @@
-/**
- * Stateless renderer for interaction (arc/BEDPE) tracks.
- *
- * Draws pairwise genomic contacts as arcs connecting two regions.
- * Two display modes:
- * - "nested": arc height proportional to genomic distance (ctx.arc)
- * - "proportional": arc height proportional to score/value (ctx.ellipse)
- *
- * Inter-chromosome interactions are drawn as colored rectangles.
- *
- * Port of js/feature/interactionTrack.ts draw methods.
- * Layer 2 (Track Canvas): uses CanvasRenderingContext2D, no DOM.
- */
-import type { InteractionFeature, InteractionRenderConfig, RenderContext } from '../../types';
-/** Draw state stored on features during rendering for hit-testing. */
-export type InteractionDrawState = NestedDrawState | ProportionalDrawState | RectDrawState;
-interface NestedDrawState {
-    type: 'nested';
-    xc: number;
-    yc: number;
-    r: number;
-}
-interface ProportionalDrawState {
-    type: 'proportional';
-    xc: number;
-    yc: number;
-    radiusX: number;
-    radiusY: number;
-}
-interface RectDrawState {
-    type: 'rect';
-    x: number;
-    y: number;
-    w: number;
-    h: number;
-}
-/** Feature with transient draw state attached during rendering. */
-export interface DrawnInteractionFeature extends InteractionFeature {
-    drawState?: InteractionDrawState;
-}
-/**
- * Render interaction features onto a canvas context.
- *
- * Stateless: all state is passed in, no side effects beyond canvas drawing
- * and attaching drawState to features for hit-testing.
- */
-export declare function renderInteractionTrack(ctx: CanvasRenderingContext2D, features: DrawnInteractionFeature[], config: InteractionRenderConfig, rc: RenderContext): void;
-/**
- * Format a genomic position for popup display.
- */
-export declare function positionString(chr: string, start: number, end: number, strand?: string): string;
-export {};

package/dist/types/src/tracks/interaction/interactionTrackCanvas.d.ts

@@ -1,54 +0,0 @@
-/**
- * Canvas manager for rendering interaction (arc/BEDPE) tracks.
- *
- * Extends BaseTrackCanvas — canvas lifecycle is handled by the base class.
- * This class implements interaction-specific logic: arc rendering, hit-testing,
- * and popup data.
- *
- * Usage:
- *   const canvas = document.createElement('canvas')
- *   const track = new InteractionTrackCanvas(canvas, { locus, features: [] })
- *   track.attachTo(containerDiv)
- */
-import type { InteractionFeature, InteractionRenderConfig, Locus, RenderContext, InteractionTrackSessionConfig, HitTestResult, AxisInfo, ContextMenuItem, NumericState } from '../../types';
-import type { CanvasProvider } from '../../canvasProvider';
-import type { RenderTheme } from '../../themes/renderTheme';
-import { BaseTrackCanvas } from '../baseTrackCanvas';
-export interface InteractionTrackCanvasOptions {
-    locus: Locus;
-    features: InteractionFeature[];
-    /** Per-track config overrides. Applied after theme-derived defaults. */
-    config?: Partial<InteractionRenderConfig>;
-    /** Unified render theme. Palette drives default colors/fonts. */
-    theme?: Partial<RenderTheme>;
-    /** Background color. Overrides config.background if set. */
-    background?: string;
-    /** Canvas provider for environment abstraction. Default: DOMCanvasProvider. */
-    canvasProvider?: CanvasProvider;
-    /** Track name for axis label. */
-    name?: string;
-}
-export declare class InteractionTrackCanvas extends BaseTrackCanvas<InteractionRenderConfig> {
-    private features;
-    private _name;
-    readonly type = "interact";
-    constructor(canvas: HTMLCanvasElement, options: InteractionTrackCanvasOptions);
-    /** Update features and re-render. */
-    setFeatures(features: InteractionFeature[]): void;
-    protected computeHeight(_width: number): number;
-    protected getBackground(): string;
-    protected doRender(ctx: CanvasRenderingContext2D, _width: number, _height: number, rc: RenderContext): void;
-    /** Hit-test: find features at canvas-relative pixel coordinates. */
-    hitTest(x: number, y: number): HitTestResult<InteractionFeature>[];
-    private buildPopupData;
-    /** Serialize config for session save/restore, diffed against theme defaults. */
-    serializeConfig(theme: RenderTheme): InteractionTrackSessionConfig;
-    /** Return axis info for proportional display mode. */
-    getAxisInfo(): AxisInfo | undefined;
-    /** Context menu items for arc display settings. */
-    getContextMenuItems(_x: number, _y: number): ContextMenuItem[];
-    /** Return numeric state for proportional mode (data range, log scale). */
-    getNumericState(): NumericState | undefined;
-    /** Render onto an arbitrary context (e.g. SVG export). */
-    renderToContext(ctx: CanvasRenderingContext2D, width: number, height: number): void;
-}

package/dist/types/src/tracks/ruler/index.d.ts

@@ -1,3 +0,0 @@
-export { renderRulerTrack } from './rulerRenderer';
-export { RulerTrackCanvas } from './rulerTrackCanvas';
-export type { RulerTrackCanvasOptions } from './rulerTrackCanvas';

package/dist/types/src/tracks/ruler/rulerRenderer.d.ts

@@ -1,25 +0,0 @@
-/**
- * Stateless ruler track renderer.
- *
- * Draws genomic coordinate tick marks and labels onto a canvas context.
- * Ported from js/rulerTrack.ts but with no igv.js dependencies.
- */
-import type { RulerRenderConfig, RenderContext } from '../../types';
-import type { CumulativeOffsets } from '../../genome/chromSizes';
-/**
- * Render a genomic coordinate ruler onto a canvas context.
- *
- * Stateless — all state is passed as parameters.
- * Draws tick marks, labels with SI-prefix units, and a baseline.
- */
-export declare function renderRulerTrack(ctx: CanvasRenderingContext2D, config: RulerRenderConfig, rc: RenderContext): void;
-/** Whole genome context needed by the WG ruler renderer. */
-export interface WholeGenomeRulerContext {
-    cumulativeOffsets: CumulativeOffsets;
-    chromSizes: Record<string, number>;
-}
-/**
- * Render a whole genome ruler showing chromosome rectangles with labels and dividers.
- * Port of js/rulerTrack.ts drawWholeGenome() + renderChromosomeRect().
- */
-export declare function renderWholeGenomeRuler(ctx: CanvasRenderingContext2D, config: RulerRenderConfig, rc: RenderContext, wg: WholeGenomeRulerContext): void;