loom-browser 0.0.1

package/dist/types/src/tracks/sequence/sequenceThemes.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Preset render themes for sequence tracks.
+ *
+ * Each theme is a Partial<SequenceRenderConfig> that can be spread over defaults.
+ * Usage: resolveSequenceConfig(theme, modernSequenceTheme)
+ */
+import type { SequenceRenderConfig } from '../../types';
+/** Modern theme — softer frame colors, solid text, rounded start/stop badges. */
+export declare const modernSequenceTheme: Partial<SequenceRenderConfig>;
+/** Dark theme — muted backgrounds, bright labels, high contrast on dark canvas. */
+export declare const darkSequenceTheme: Partial<SequenceRenderConfig>;

package/dist/types/src/tracks/sequence/sequenceTrackCanvas.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Sequence track canvas — extends BaseTrackCanvas for DNA/RNA sequence display.
+ *
+ * Layer 2 (Track Canvas): Manages canvas lifecycle, DPR scaling, config state,
+ * and delegates rendering to the pure sequenceRenderer.
+ *
+ * Port of js/sequenceTrack.ts with full feature parity:
+ * - DNA/RNA/protein sequence rendering
+ * - Reverse complement toggle
+ * - Three-frame amino acid translation toggle
+ * - Dynamic height (25px default, 115px with translation)
+ * - Context menu items (strand toggle, translation toggle)
+ * - Visibility window enforcement (bpPerPixel threshold of 10)
+ * - Session serialization
+ *
+ * Data is provided via the standard DataSource lifecycle — the browser fetches
+ * sequence through a SequenceDataSource and pushes it via setFeatures().
+ * Also supports direct setSequence() for standalone usage.
+ */
+import { BaseTrackCanvas } from '../baseTrackCanvas';
+import type { Locus, RenderContext, SequenceRenderConfig, TrackSessionConfig, ContextMenuItem } from '../../types';
+import type { RenderTheme } from '../../themes/renderTheme';
+import type { SequenceFeature } from './sequenceRenderer';
+import type { CanvasProvider } from '../../canvasProvider';
+/** Options for constructing a SequenceTrackCanvas. */
+export interface SequenceTrackCanvasOptions {
+    locus: Locus;
+    config?: Partial<SequenceRenderConfig>;
+    theme?: Partial<RenderTheme>;
+    canvasProvider?: CanvasProvider;
+}
+export declare class SequenceTrackCanvas extends BaseTrackCanvas<SequenceRenderConfig> {
+    readonly type = "sequence";
+    private _sequence;
+    private _theme;
+    constructor(canvas: HTMLCanvasElement, options: SequenceTrackCanvasOptions);
+    /**
+     * Whether the current viewport is zoomed in enough to fetch/render sequence.
+     * Matches igv.js bppSequenceThreshold check in getFeatures().
+     */
+    shouldFetchSequence(bpPerPixel: number): boolean;
+    /**
+     * Standard DataSource lifecycle: browser pushes SequenceFeature[] from SequenceDataSource.
+     * Takes the first element (single sequence region) or clears if empty (zoomed out).
+     */
+    setFeatures(features: SequenceFeature[]): void;
+    /** Set the sequence data directly. For standalone usage without a DataSource. */
+    setSequence(feature: SequenceFeature | null): void;
+    /** Get the current sequence data (for context menu operations). */
+    getSequence(): SequenceFeature | null;
+    /** Toggle reverse complement display. */
+    toggleReversed(): void;
+    /** Toggle three-frame translation display. */
+    toggleFrameTranslate(): void;
+    /**
+     * Return context menu items for the sequence track.
+     *
+     * Matches igv.js SequenceTrack.menuItemList() + contextMenuItemList():
+     * - Strand toggle (Forward/Reverse)
+     * - Translation toggle (Three-frame Translate / Close Translation)
+     */
+    getContextMenuItems(_x: number, _y: number): ContextMenuItem[] | undefined;
+    protected computeHeight(_width: number): number;
+    protected getBackground(): string;
+    protected doRender(ctx: CanvasRenderingContext2D, _width: number, _height: number, rc: RenderContext): void;
+    serializeConfig(theme: RenderTheme): TrackSessionConfig;
+}

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

@@ -0,0 +1,5 @@
+export { renderWigTrack } from './wigRenderer';
+export { WigTrackCanvas } from './wigTrackCanvas';
+export type { WigTrackCanvasOptions } from './wigTrackCanvas';
+export { summarizeWigData, computeWigDataRange } from './wigSummary';
+export { modernWigTheme, darkWigTheme, warmWigTheme, lineWigTheme } from './wigThemes';

package/dist/types/src/tracks/wig/wigRenderer.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Standalone wig track renderer.
+ *
+ * Adapted from js/feature/wigTrack.ts draw() method with no `this` context —
+ * all configuration is passed as explicit parameters.
+ *
+ * Supports four graph types: bar, line, points, and dynseq.
+ */
+import type { WigFeature, WigRenderConfig, RenderContext } from '../../types';
+/**
+ * Render wig features onto a canvas context.
+ *
+ * The canvas should be sized and cleared before calling this.
+ */
+export declare function renderWigTrack(ctx: CanvasRenderingContext2D, features: WigFeature[], config: WigRenderConfig, rc: RenderContext): void;

package/dist/types/src/tracks/wig/wigSummary.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Resolution-aware data summarization for wig tracks.
+ *
+ * When zoomed out, many data points map to the same pixel. This module bins
+ * features and applies a window function (mean, min, max) to produce one
+ * summary value per pixel-width bin.
+ *
+ * Ported from js/feature/wigSummary.ts with strict types, no `any`.
+ */
+import type { WigFeature, WindowFunction } from '../../types';
+/**
+ * Summarize wig features by binning into pixel-width windows and applying
+ * a window function.
+ *
+ * Features must be sorted by position. Wig features cannot overlap.
+ *
+ * @param features - sorted array of wig features
+ * @param startBP - start position in base pairs (left edge of viewport)
+ * @param bpPerPixel - base pairs per pixel (bin size)
+ * @param windowFunction - aggregation function: mean, min, max, or none
+ * @returns summarized features (one per pixel-bin)
+ */
+export declare function summarizeWigData(features: WigFeature[], startBP: number, bpPerPixel: number, windowFunction?: WindowFunction): WigFeature[];
+/**
+ * Compute the min/max data range from a set of wig features.
+ * Useful for autoscaling.
+ */
+export declare function computeWigDataRange(features: WigFeature[]): {
+    min: number;
+    max: number;
+};

package/dist/types/src/tracks/wig/wigThemes.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Preset render themes for wig tracks.
+ *
+ * Each theme is a Partial<WigRenderConfig> that can be spread over defaults.
+ * Usage: { ...defaultWigRenderConfig(), ...modernWigTheme }
+ */
+import type { WigRenderConfig } from '../../types';
+/** Modern theme — blue bars with subtle styling. */
+export declare const modernWigTheme: Partial<WigRenderConfig>;
+/** Dark theme — bright teal on dark background. */
+export declare const darkWigTheme: Partial<WigRenderConfig>;
+/** Warm red theme — for coverage or signal intensity. */
+export declare const warmWigTheme: Partial<WigRenderConfig>;
+/** Line graph variant — modern blue line. */
+export declare const lineWigTheme: Partial<WigRenderConfig>;

package/dist/types/src/tracks/wig/wigTrackCanvas.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Canvas manager for rendering wig (wiggle) tracks.
+ *
+ * Extends BaseTrackCanvas — canvas lifecycle is handled by the base class.
+ * This class implements wig-specific logic: value scaling, autoscale,
+ * and rendering delegation.
+ *
+ * Data summarization (pixel-width binning) is handled at the data source
+ * layer by BigWigDataSource, not here. This keeps the render layer
+ * focused on rendering and lets headless consumers benefit from
+ * pre-summarized data.
+ *
+ * For dynseq mode, an optional `sequenceProvider` can be passed at construction.
+ * When in dynseq mode, the track automatically fetches and attaches DNA sequence
+ * to features at high zoom (bpPerPixel < 2). This matches the igv.js pattern
+ * where sequence is fetched during getFeatures(), not during rendering.
+ *
+ * Usage:
+ *   const canvas = document.createElement('canvas')
+ *   const track = new WigTrackCanvas(canvas, { locus, features })
+ *   track.attachTo(containerDiv)
+ */
+import type { WigFeature, WigRenderConfig, WindowFunction, Locus, RenderContext, WigTrackSessionConfig, HitTestResult, AxisInfo, ContextMenuItem, NumericState, SequenceProvider } from '../../types';
+import type { CanvasProvider } from '../../canvasProvider';
+import type { RenderTheme } from '../../themes/renderTheme';
+import { BaseTrackCanvas } from '../baseTrackCanvas';
+export interface WigTrackCanvasOptions {
+    locus: Locus;
+    features: WigFeature[];
+    /** Per-track config overrides. Applied after theme-derived defaults. */
+    config?: Partial<WigRenderConfig>;
+    /** Unified render theme. Palette drives default colors/fonts. */
+    theme?: Partial<RenderTheme>;
+    /** Fixed pixel height. If not set, uses config.height (default 50). */
+    height?: number;
+    /** Background color. Overrides palette.background if set. */
+    background?: string;
+    /** Canvas provider for environment abstraction. Default: DOMCanvasProvider. */
+    canvasProvider?: CanvasProvider;
+    /** Track name for axis label. */
+    name?: string;
+    /** Sequence provider for dynseq rendering. When set, dynseq appears in the graph type menu. */
+    sequenceProvider?: SequenceProvider;
+}
+export declare class WigTrackCanvas extends BaseTrackCanvas<WigRenderConfig> {
+    private features;
+    private fixedHeight;
+    private _name;
+    private _lastDataRange;
+    private _sequenceProvider;
+    /** Abort controller for in-flight sequence fetch. */
+    private _seqAbort;
+    /** Callback invoked when the user changes the windowing function via context menu. */
+    private _onWindowFunctionChange?;
+    readonly type = "wig";
+    constructor(canvas: HTMLCanvasElement, options: WigTrackCanvasOptions);
+    /** Set a callback invoked when the user changes the windowing function via context menu. */
+    set onWindowFunctionChange(cb: ((wf: WindowFunction) => void) | undefined);
+    /** Update features and re-render. Recomputes autoscale if enabled. */
+    setFeatures(features: WigFeature[]): void;
+    /** Update locus and re-render. Re-fetches sequence in dynseq mode. */
+    setLocus(locus: Locus): void;
+    /** Merge partial config and re-render. Triggers sequence fetch when switching to dynseq. */
+    setConfig(config: Partial<WigRenderConfig>): void;
+    /**
+     * Fetch DNA sequence for current features and re-render.
+     * At low zoom (bpPerPixel >= 2), skips fetch — the renderer falls back to bars.
+     */
+    private augmentWithSequence;
+    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[];
+    /**
+     * Return numeric state for shared menu items (autoscale, log scale, set data range).
+     * The browser calls numericDataMenuItems() with this state when assembling context menus.
+     */
+    getNumericState(): NumericState;
+    hitTest(x: number, _y: number): HitTestResult<WigFeature>[];
+    serializeConfig(theme: RenderTheme): WigTrackSessionConfig;
+}