@jbrowse/bandage-core 0.1.1

package/dist/types/alleleProjection/projectAlleles.d.ts

@@ -0,0 +1,13 @@
+import type { Graph } from '../types';
+export interface ProjectedAllele {
+    start: number;
+    refSpan: number;
+    nodeIds: string[];
+    nodeOffsets: number[];
+    pathLength: number;
+}
+export declare function parsePanSN(refName: string): {
+    sample: string;
+    haplotype: number | undefined;
+};
+export declare function projectAlleles(graph: Graph): ProjectedAllele[];

package/dist/types/anchoredNodes.d.ts

@@ -0,0 +1,17 @@
+import type { StableCoordinate } from './gfa-core/index';
+import type { Graph, GraphNode, NodeSegment } from './types';
+export type AnchoredNode = GraphNode & {
+    stable: StableCoordinate;
+};
+export declare const REFERENCE_RANK = 0;
+export declare function isAnchored(node: GraphNode): node is AnchoredNode;
+export declare function isBackbone(node: GraphNode): node is AnchoredNode;
+export declare function isOffReference(node: GraphNode): node is AnchoredNode;
+export declare function backboneNodes(graph: Graph): AnchoredNode[];
+export declare function backbonePositions(backbone: AnchoredNode[]): Record<string, NodeSegment[]>;
+export declare function firstNodeAtOrAfter(nodes: AnchoredNode[], bp: number): number;
+export declare function backboneSpan(backbone: AnchoredNode[]): number;
+export declare function referenceSpan(backbone: AnchoredNode[], region?: {
+    start: number;
+    end: number;
+}): number;

package/dist/types/bandage/bandage-layout.d.ts

@@ -0,0 +1,14 @@
+import type { LayoutNode } from '../layout/referenceSeeds'
+import type { Graph, LayoutResult } from '../types'
+
+export interface BandageModule {
+  computeLayout(
+    graph: { nodes: LayoutNode[]; edges: Graph['edges'] },
+    options: Record<string, unknown>,
+  ): LayoutResult
+}
+
+// The vendored Emscripten bundle's default export is a factory that
+// instantiates the wasm module (layout inlined, -sSINGLE_FILE=1).
+declare const createBandageLayoutModule: () => Promise<BandageModule>
+export default createBandageLayoutModule

package/dist/types/bubbleSpreads.d.ts

@@ -0,0 +1,32 @@
+import type { NodeLengthSpread } from './layout/drawnScale';
+export declare const BUBBLE_SPREADS: readonly [{
+    readonly value: "auto";
+    readonly label: "Proportional";
+    readonly description: "Bandage's own scale: a node draws proportional to its length, so a 1 bp allele is a speck.";
+    readonly law: import("./layout/drawnScale").DrawnLengthLaw;
+    readonly minNodeFactor: 0;
+}, {
+    readonly value: "open";
+    readonly label: "Open bubbles";
+    readonly description: "Give every allele a drawn length, so a bubble reads as two arms rather than a knot.";
+    readonly law: import("./layout/drawnScale").DrawnLengthLaw;
+    readonly minNodeFactor: 2.5;
+}, {
+    readonly value: "wide";
+    readonly label: "Wide bubbles";
+    readonly description: "As open, spread further. Best on a window of a dozen bubbles.";
+    readonly law: import("./layout/drawnScale").DrawnLengthLaw;
+    readonly minNodeFactor: 10;
+}, {
+    readonly value: "compress";
+    readonly label: "Compress lengths";
+    readonly description: "Pull the longest and shortest nodes towards the graph’s mean, so a cut spanning kb and bp fits one pane.";
+    readonly law: {
+        readonly power: 0.5;
+        readonly effect: 0.5;
+    };
+    readonly minNodeFactor: 0;
+}];
+export type BubbleSpread = (typeof BUBBLE_SPREADS)[number]['value'];
+export declare const BUBBLE_SPREAD_VALUES: ("auto" | "open" | "wide" | "compress")[];
+export declare function spreadFor(spread: string): NodeLengthSpread;

package/dist/types/bubbles/bubbleHalos.d.ts

@@ -0,0 +1,20 @@
+import type { BubbleRoute, MinigraphBubble } from './bubbleLine';
+import type { BubbleKind, RepeatSpan } from './classifyBubble';
+import type { Graph, NodeSegment } from '../types';
+export interface BubbleHalo {
+    bubble: MinigraphBubble;
+    kind: BubbleKind;
+    label: string;
+    path: string;
+    labelAt: NodeSegment;
+    members: number;
+    nodeIds: string[];
+    whole: boolean;
+    routes: RouteLabel[];
+}
+export interface RouteLabel {
+    route: BubbleRoute;
+    at: NodeSegment;
+    text: string;
+}
+export declare function bubbleHalos(graph: Graph, bubbles: MinigraphBubble[], positions: Record<string, NodeSegment[]>, walkLabel?: (name: string) => string, repeats?: readonly RepeatSpan[]): BubbleHalo[];

package/dist/types/bubbles/bubbleLine.d.ts

@@ -0,0 +1,24 @@
+export interface MinigraphBubble {
+    refName: string;
+    start: number;
+    end: number;
+    segmentCount: number;
+    pathCount: number;
+    inversion: boolean;
+    shortestAlleleLength: number;
+    longestAlleleLength: number;
+    segments: string;
+    shortestAllele: string | undefined;
+    longestAllele: string | undefined;
+    partial?: boolean;
+    routes?: BubbleRoute[];
+}
+export interface BubbleRoute {
+    steps: string[];
+    bp: number;
+    walks: string[];
+}
+export declare function parseBubbleLine(line: string): MinigraphBubble;
+export declare function bubbleLabel(bubble: MinigraphBubble): string;
+export declare const SATURATED_PATH_COUNT = 2147483647;
+export declare function bubbleDescription(bubble: MinigraphBubble): string;

package/dist/types/bubbles/bubblesFromGraph.d.ts

@@ -0,0 +1,3 @@
+import type { MinigraphBubble } from './bubbleLine';
+import type { Graph } from '../types';
+export declare function bubblesFromGraph(graph: Graph): MinigraphBubble[];

package/dist/types/bubbles/classifyBubble.d.ts

@@ -0,0 +1,16 @@
+import type { MinigraphBubble } from './bubbleLine';
+export type BubbleKind = 'snp' | 'substitution' | 'insertion' | 'deletion' | 'inversion' | 'repeat' | 'superbubble' | 'complex';
+export interface BubbleClass {
+    kind: BubbleKind;
+    label: string;
+}
+export interface RepeatSpan {
+    start: number;
+    end: number;
+    name?: string;
+}
+export declare function formatBp(bp: number): string;
+export declare function classifyBubble(b: MinigraphBubble, repeats?: readonly RepeatSpan[]): BubbleClass;
+export declare const BUBBLE_KIND_COLORS: Record<BubbleKind, string>;
+export declare const BUBBLE_KIND_NAMES: Record<BubbleKind, string>;
+export declare function bubbleSegmentIds(b: MinigraphBubble): string[];

package/dist/types/bubbles/popBubble.d.ts

@@ -0,0 +1,2 @@
+import type { Graph } from '../types';
+export declare function bubbleSubgraph(graph: Graph, segmentIds: string[]): Graph;

package/dist/types/colorSchemes.d.ts

@@ -0,0 +1,33 @@
+import type { Graph } from './types';
+export declare const COLOR_SCHEMES: readonly [{
+    readonly value: "auto";
+    readonly label: "Auto";
+}, {
+    readonly value: "uniform";
+    readonly label: "Uniform";
+}, {
+    readonly value: "random";
+    readonly label: "Random";
+}, {
+    readonly value: "rainbow";
+    readonly label: "Rainbow";
+}, {
+    readonly value: "depth";
+    readonly label: "Depth";
+}, {
+    readonly value: "node-length";
+    readonly label: "Node Length";
+}, {
+    readonly value: "stable-rank";
+    readonly label: "Stable rank";
+}, {
+    readonly value: "reference-position";
+    readonly label: "Reference position";
+}, {
+    readonly value: "grey";
+    readonly label: "Grey";
+}];
+export type ColorScheme = (typeof COLOR_SCHEMES)[number]['value'];
+export type ResolvedColorScheme = Exclude<ColorScheme, 'auto'>;
+export declare const COLOR_SCHEME_VALUES: ("auto" | "uniform" | "random" | "rainbow" | "depth" | "node-length" | "stable-rank" | "reference-position" | "grey")[];
+export declare function resolveColorScheme(scheme: ColorScheme, graph: Graph | undefined): ResolvedColorScheme;

package/dist/types/deletionEdges.d.ts

@@ -0,0 +1,24 @@
+import type { Graph } from './types';
+import type { AxisScale } from './util/geometry';
+export interface DeletionEdge {
+    edgeIndex: number;
+    from: string;
+    to: string;
+    refName: string;
+    start: number;
+    end: number;
+    bp: number;
+    bypassed: string[];
+}
+export declare function bypassedPoints(nodePositions: Record<string, {
+    x: number;
+    y: number;
+}[]>, bypassed: string[]): {
+    x: number;
+    y: number;
+}[];
+export declare function deletionArcCurves(nodePositions: Record<string, {
+    x: number;
+    y: number;
+}[]>, deletion: DeletionEdge, axis: AxisScale): import("./util/geometry").BezierCurve[] | undefined;
+export declare function deletionEdges(graph: Graph): DeletionEdge[];

package/dist/types/gaf/parseGaf.d.ts

@@ -0,0 +1,37 @@
+export interface GafStep {
+    name: string;
+    strand: '+' | '-';
+}
+export interface GafRecord {
+    name: string;
+    queryLength: number;
+    queryStart: number;
+    queryEnd: number;
+    strand: '+' | '-';
+    path: GafStep[];
+    pathLength: number;
+    pathStart: number;
+    pathEnd: number;
+    matches: number;
+    blockLength: number;
+    mappingQuality: number;
+    secondary: boolean;
+    cs?: string;
+}
+export declare function parseGafPath(column: string): GafStep[] | undefined;
+export declare function parseGafLine(line: string): GafRecord | undefined;
+export declare function parseGaf(text: string): GafRecord[];
+export type CsOp = {
+    op: 'match';
+    length: number;
+} | {
+    op: 'substitution';
+    seq: string;
+} | {
+    op: 'insertion';
+    seq: string;
+} | {
+    op: 'deletion';
+    length: number;
+};
+export declare function parseCs(cs: string): CsOp[];

package/dist/types/gbzWindow.d.ts

@@ -0,0 +1,27 @@
+import type { GBZBase, PathName, PathQuery, RangeOptions } from '@gmod/gbz-base';
+export declare class NoReferenceSampleError extends Error {
+    name: string;
+    constructor(anchor: string, referenceSamples: string[]);
+}
+export declare class NodeLimitError extends Error {
+    name: string;
+    constructor(limit: number, windowBp: number, fitsBp: number);
+}
+export declare function haplotypePrefix(name: Pick<PathName, 'sample' | 'haplotype'>): string;
+export declare function haplotypeWanted(name: PathName, wanted: string[] | undefined): boolean;
+export declare function referenceSamplesOf(db: GBZBase): Promise<string[]>;
+export declare function resolveReferenceSample({ configured, anchorPrefix, referenceSamples, }: {
+    configured: string;
+    anchorPrefix: string;
+    referenceSamples: string[];
+}): string;
+export declare function referencePathQuery(db: GBZBase, referenceSample: string, refName: string): Promise<PathQuery | undefined>;
+export declare function nodeLimitError(error: unknown, limit: number, windowBp: number): NodeLimitError | undefined;
+export interface GbzWindowOptions {
+    context: number;
+    snarls: RangeOptions['snarls'];
+    limit: number;
+    keep?: (name: PathName) => boolean;
+    signal?: AbortSignal;
+}
+export declare function cutWindowGFA(db: GBZBase, query: PathQuery | undefined, start: number, end: number, { keep, ...opts }: GbzWindowOptions): Promise<string>;

package/dist/types/genes/genePins.d.ts

@@ -0,0 +1,19 @@
+import type { Graph, NodeSegment } from '../types';
+export interface GeneModel {
+    name: string;
+    refName: string;
+    start: number;
+    end: number;
+    strand: number;
+    exons: {
+        start: number;
+        end: number;
+    }[];
+}
+export interface GenePin {
+    gene: GeneModel;
+    exons: string;
+    at: NodeSegment;
+    covered: number;
+}
+export declare function genePins(graph: Graph, genes: GeneModel[], positions: Record<string, NodeSegment[]>): GenePin[];

package/dist/types/gfa/gfaConverter.d.ts

@@ -0,0 +1,11 @@
+import type { GFAGraph } from '../gfa-core/index';
+import type { GraphEdge, GraphNode, GraphPath } from '../types';
+export declare function convertGFAToGraph(gfaGraph: GFAGraph, name?: string): {
+    name: string;
+    nodes: GraphNode[];
+    edges: GraphEdge[];
+    paths: GraphPath[] | undefined;
+    anchorPaths: import("../types").PathOrigin[] | undefined;
+    pathVisits: Map<string, import("../types").PathVisit[]> | undefined;
+    anchoredBy: "tags" | undefined;
+};

package/dist/types/gfa-core/gfaParser.d.ts

@@ -0,0 +1,48 @@
+export interface GFANode {
+    id: string;
+    length: number;
+    sequence: string;
+    tags: Record<string, string | number>;
+}
+export interface StableCoordinate {
+    refName: string;
+    start: number;
+    rank: number;
+    strand?: '+' | '-';
+}
+export declare function stableCoordinate(node: GFANode): StableCoordinate | undefined;
+export interface GFALink {
+    source: string;
+    target: string;
+    strand1?: string;
+    strand2?: string;
+    cigar: string;
+    tags: Record<string, string | number>;
+}
+export interface GFAPath {
+    name: string;
+    path: string;
+    rest: string[];
+}
+export interface GFAWalkSegment {
+    id: string;
+    strand: string;
+}
+export interface GFAWalk {
+    sample: string;
+    haplotype: number;
+    contig: string;
+    start: number;
+    end: number;
+    segments: GFAWalkSegment[];
+    tags: Record<string, string | number>;
+}
+export interface GFAGraph {
+    nodes: GFANode[];
+    links: GFALink[];
+    paths: GFAPath[];
+    walks: GFAWalk[];
+    header: Record<string, string | number>[];
+    id: string;
+}
+export declare function parseGFA(file: string): GFAGraph;

package/dist/types/gfa-core/index.d.ts

@@ -0,0 +1,2 @@
+export { parseGFA, stableCoordinate } from './gfaParser';
+export type { GFAGraph, GFALink, GFANode, GFAPath, GFAWalk, GFAWalkSegment, StableCoordinate, } from './gfaParser';

package/dist/types/graphLabels.d.ts

@@ -0,0 +1,46 @@
+import type { DeletionEdge } from './deletionEdges';
+import type { Box, TakeBox } from './overlayLabels';
+import type { AlleleDeletion, NodeSegment } from './types';
+import type { AxisScale } from './util/geometry';
+export declare function rowLabelBox(text: string, screenY: number): Box;
+export interface Leader {
+    arcX: number;
+    arcY: number;
+    labelX: number;
+    labelY: number;
+}
+export interface GraphLabel {
+    key: string;
+    text: string;
+    x: number;
+    y: number;
+    kind: 'node' | 'deletion';
+    leader?: Leader;
+}
+export declare function formatBp(bp: number): string;
+interface SizeLabelArgs {
+    nodePositions: Record<string, NodeSegment[]>;
+    nodeLengths: Map<string, number>;
+    deletions: DeletionEdge[];
+    alleleDeletions?: AlleleDeletion[];
+    axis: AxisScale;
+    translateX: number;
+    translateY: number;
+    width: number;
+    height: number;
+    version?: number;
+}
+export interface SizeLabelCandidate {
+    label: GraphLabel;
+    box: Box;
+}
+export declare function sizeLabelCandidates({ nodePositions, nodeLengths, deletions, alleleDeletions, axis, translateX, translateY, width, height, version, }: SizeLabelArgs): {
+    deletions: SizeLabelCandidate[];
+    nodes: SizeLabelCandidate[];
+};
+export declare function nodeLabelBudget(width: number, height: number): number;
+export declare function placeSizeLabels(candidates: SizeLabelCandidate[], take: TakeBox, budget?: number): GraphLabel[];
+export declare function graphLabels({ reserved, ...args }: SizeLabelArgs & {
+    reserved?: Box[];
+}): GraphLabel[];
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,50 @@
+export { FIT_PADDING, clampZoom, drawingBounds, engineRequest, fitTransform, forceLayout, layoutExtent, loadGraph, } from './pipeline';
+export type { Bounds, EngineRequest, EngineSettings, LayoutEngine, } from './pipeline';
+export { FORCE_LAYOUT_LABEL, LAYOUT_MODES, layoutModeByValue, modeUsesLayoutEngine, } from './layoutModes';
+export type { LayoutModeValue } from './layoutModes';
+export { COLOR_SCHEMES, resolveColorScheme } from './colorSchemes';
+export type { ColorScheme, ResolvedColorScheme } from './colorSchemes';
+export { NODE_WIDTHS, maxNodeWidthPx, meanDepth, nodeInk, nodeWidthPx, } from './nodeWidths';
+export type { NodeWidth } from './nodeWidths';
+export { BUBBLE_SPREADS } from './bubbleSpreads';
+export type { BubbleSpread } from './bubbleSpreads';
+export { REFERENCE_RAMP_MAX_HUE, buildGeometry, computeReferenceRamp, } from './renderer/GeometryBuilder';
+export { Canvas2DRenderer } from './renderer/Canvas2DRenderer';
+export { getDpr } from '@jbrowse/render-core/canvas2dUtils';
+export type { Renderer } from './renderer/types';
+export { findHoveredEdge, findHoveredNode } from './util/hitDetection';
+export type { NodeInk } from './util/hitDetection';
+export type { AxisScale } from './util/geometry';
+export { wheelZoomFactor } from './util/wheelZoom';
+export { drawTubeMap, tubeMapPicture } from './tubeMap/draw';
+export type { TubeMapFrame, TubeMapPicture } from './tubeMap/draw';
+export { referenceKnots, warpX } from './tubeMap/warp';
+export { tubeMapFrame, tubeMapNodeAt } from './tubeMap/frame';
+export type { TubeMapTransform, TubeMapView } from './tubeMap/frame';
+export type { TubeMapColumn, TubeMapDrawing } from './layout/tubeMapLayout';
+export { deletionEdges } from './deletionEdges';
+export type { DeletionEdge } from './deletionEdges';
+export { walkHighlight } from './walkHighlight';
+export { pathColorsLegible, pathLegend } from './pathColors';
+export { bubblesFromGraph } from './bubbles/bubblesFromGraph';
+export { bubbleHalos } from './bubbles/bubbleHalos';
+export type { BubbleHalo } from './bubbles/bubbleHalos';
+export { BUBBLE_KIND_COLORS, BUBBLE_KIND_NAMES, bubbleSegmentIds, classifyBubble, } from './bubbles/classifyBubble';
+export { bubbleSubgraph } from './bubbles/popBubble';
+export type { MinigraphBubble } from './bubbles/bubbleLine';
+export { walkRows } from './layout/walkRows';
+export type { WalkRows } from './layout/walkRows';
+export { walkRowsExtent } from './layout/walkRowLayout';
+export { ROW_HEIGHT_PX } from './layout/rowSpacing';
+export { HALO_FACTOR, LEGEND_INSET_PX, layoutLabels } from './labelLayout';
+export type { BubbleGlyph, LabelLayout, LabelLayoutSource } from './labelLayout';
+export { formatBp } from './graphLabels';
+export { LABEL_CHAR_PX, LABEL_PAD, LABEL_PX } from './overlayLabels';
+export type { Graph, GraphEdge, GraphNode, LayoutResult, NodeSegment, } from './types';
+export { cutWindowGFA, haplotypeWanted, referencePathQuery, referenceSamplesOf, resolveReferenceSample, } from './gbzWindow';
+export type { GbzWindowOptions } from './gbzWindow';
+export { engineKey } from './pipeline';
+export { axisScaleOf, contains, padded, screenToLayout, viewportOf, zoomAbout, } from './viewport';
+export type { PaneTransform } from './viewport';
+export { default as loadBandage } from './loadBandage';
+export { panSNContig, panSNHaplotype, panSNSample } from './pansn';

package/dist/types/labelLayout.d.ts

@@ -0,0 +1,59 @@
+import type { BubbleHalo, RouteLabel } from './bubbles/bubbleHalos';
+import type { MinigraphBubble } from './bubbles/bubbleLine';
+import type { BubbleKind } from './bubbles/classifyBubble';
+import type { DeletionEdge } from './deletionEdges';
+import type { GenePin } from './genes/genePins';
+import type { GraphLabel } from './graphLabels';
+import type { PlacedLabel } from './overlayLabels';
+import type { AlleleDeletion, NodeSegment } from './types';
+import type { AxisScale } from './util/geometry';
+export declare const HALO_FACTOR = 3.4;
+export declare const LEGEND_INSET_PX = 6;
+export interface BubbleGlyph {
+    bubble: MinigraphBubble;
+    kind: BubbleKind;
+    label: string;
+}
+export interface LabelLayoutSource {
+    paneWidth: number;
+    canvasHeight: number;
+    axisScale: AxisScale;
+    translateX: number;
+    translateY: number;
+    contigThickness: number;
+    legendSize: {
+        width: number;
+        height: number;
+    };
+    drawnRowLabels: {
+        label: string;
+        y: number;
+    }[];
+    bubbleHalos: BubbleHalo[];
+    bubbleGlyphs: BubbleGlyph[];
+    genePins: GenePin[];
+    poppedFrom?: {
+        label: string;
+    };
+    nodePositions?: Record<string, NodeSegment[]>;
+    labelsNodeSizes: boolean;
+    nodeLengths: Map<string, number>;
+    showDeletionEdges: boolean;
+    deletions: DeletionEdge[];
+    alleleDeletions: AlleleDeletion[];
+    positionsVersion: number;
+}
+export interface LabelLayout {
+    bubbles: PlacedLabel<BubbleHalo>[];
+    glyphs: PlacedLabel<{
+        glyph: BubbleGlyph;
+        glyphX: number;
+    }>[];
+    genes: PlacedLabel<GenePin>[];
+    routes: PlacedLabel<{
+        halo: BubbleHalo;
+        route: RouteLabel;
+    }>[];
+    sizes: GraphLabel[];
+}
+export declare function layoutLabels(m: LabelLayoutSource): LabelLayout;

package/dist/types/layout/anchoredLayout.d.ts

@@ -0,0 +1,5 @@
+import type { Graph, LayoutResult } from '../types';
+export declare function anchoredLayout(graph: Graph, region?: {
+    start: number;
+    end: number;
+}): LayoutResult | undefined;

package/dist/types/layout/drawnScale.d.ts

@@ -0,0 +1,28 @@
+import type { Graph, GraphNode } from '../types';
+export interface BandageScaleOpts {
+    nodeLengthPerMegabase: number;
+    minimumNodeLength: number;
+    nodeSegmentLength: number;
+    edgeLength: number;
+}
+declare const MEAN_NODE_LENGTH = 40;
+export declare function drawnNodeLength(opts: BandageScaleOpts, length: number): number;
+export declare function bandageAutoScale(graph: Graph, minNodeLength?: number): BandageScaleOpts;
+export interface DrawnLengthLaw {
+    power: number;
+    effect: number;
+}
+export declare const PROPORTIONAL_LENGTH: DrawnLengthLaw;
+export declare function isProportional(law: DrawnLengthLaw): boolean;
+export declare function drawnLengthFor(graph: Graph, law: DrawnLengthLaw): (bp: number) => number;
+export interface NodeLengthSpread {
+    law: DrawnLengthLaw;
+    minNodeLength: number;
+}
+export declare const PROPORTIONAL_SPREAD: NodeLengthSpread;
+export interface LayoutScaling {
+    nodes: GraphNode[];
+    opts: BandageScaleOpts;
+}
+export declare function layoutScaling(graph: Graph, spread?: NodeLengthSpread): LayoutScaling;
+export { MEAN_NODE_LENGTH };

package/dist/types/layout/mergeRuns.d.ts

@@ -0,0 +1,9 @@
+import type { Graph, NodeSegment } from '../types';
+export interface MergedRuns {
+    graph: Graph;
+    runs: Map<string, string[]>;
+}
+export declare function mergeRuns(graph: Graph): MergedRuns;
+export declare function splitRuns(positions: Record<string, NodeSegment[]>, runs: Map<string, string[]>, weightOf: (id: string) => number): Record<string, NodeSegment[]>;
+export declare function polylineSlice(line: NodeSegment[], from: number, to: number): NodeSegment[];
+export declare function polylineMidpoint(line: NodeSegment[]): NodeSegment;

package/dist/types/layout/orderedLayout.d.ts

@@ -0,0 +1,9 @@
+import type { Graph, LayoutResult } from '../types';
+export declare function referenceOrder(graph: Graph): string[];
+export interface LayeredGraph {
+    layers: string[][];
+    layerOf: Map<string, number>;
+    preds: Map<string, string[]>;
+}
+export declare function layerGraph(graph: Graph): LayeredGraph;
+export declare function orderedLayout(graph: Graph): LayoutResult | undefined;

package/dist/types/layout/orientToReference.d.ts

@@ -0,0 +1,4 @@
+import type { Graph, NodeSegment } from '../types';
+type Positions = Record<string, NodeSegment[]>;
+export declare function orientToReference(graph: Graph, positions: Positions): Positions;
+export {};

package/dist/types/layout/placeOffReference.d.ts

@@ -0,0 +1,9 @@
+import type { AlleleDeletion, Graph, NodeSegment } from '../types';
+interface PlaceArgs {
+    graph: Graph;
+    span: number;
+    rowY: (node: Graph['nodes'][number]) => number;
+    positions: Record<string, NodeSegment[]>;
+}
+export declare function placeOffReference({ graph, span, rowY, positions, }: PlaceArgs): AlleleDeletion[];
+export {};

package/dist/types/layout/referenceSeeds.d.ts

@@ -0,0 +1,12 @@
+import type { LayoutScaling } from './drawnScale';
+import type { Graph, GraphNode } from '../types';
+export type LayoutNode = GraphNode & {
+    x?: number;
+    y?: number;
+};
+export interface Seed {
+    x: number;
+    y: number;
+}
+export declare function referenceSeeds(graph: Graph, scaling: LayoutScaling): Map<string, Seed>;
+export declare function seededNodes(graph: Graph, scaling: LayoutScaling): LayoutNode[];

package/dist/types/layout/rowSpacing.d.ts

@@ -0,0 +1 @@
+export declare const ROW_HEIGHT_PX = 20;

package/dist/types/layout/sampleRowLayout.d.ts

@@ -0,0 +1,5 @@
+import type { Graph, LayoutResult } from '../types';
+export declare function sampleRowLayout(graph: Graph, region?: {
+    start: number;
+    end: number;
+}, keep?: readonly string[]): LayoutResult | undefined;

package/dist/types/layout/tubeMapLayout.d.ts

@@ -0,0 +1,19 @@
+import type { Graph, LayoutResult } from '../types';
+import type { InputTrack, TubeMapLayout } from '@gmod/tubemap-core';
+export interface TubeMapColumn {
+    order: number;
+    x0: number;
+    x1: number;
+    bp0: number;
+    bp1: number;
+}
+export interface TubeMapDrawing {
+    layout: TubeMapLayout;
+    yOffset: number;
+    columns?: TubeMapColumn[];
+}
+export declare function tubeMapTracks(graph: Graph): InputTrack[];
+export declare function hasTubeMapPaths(graph: Graph): boolean;
+export declare function tubeWidth(trackCount: number): number;
+export declare function tubeMapLayout(graph: Graph): LayoutResult | undefined;
+export declare function tubeMapReferenceLayout(graph: Graph): LayoutResult | undefined;

package/dist/types/layout/variantMapLayout.d.ts

@@ -0,0 +1,2 @@
+import type { Graph, LayoutResult } from '../types';
+export declare function variantMapLayout(graph: Graph): LayoutResult | undefined;

package/dist/types/layout/walkRowLayout.d.ts

@@ -0,0 +1,10 @@
+import type { WalkRows } from './walkRows';
+import type { Graph, LayoutResult } from '../types';
+export declare function walkRowsExtent(walks: WalkRows): {
+    maxX: number;
+    maxY: number;
+};
+export declare function walkRowLayout(graph: Graph, region?: {
+    start: number;
+    end: number;
+}): LayoutResult | undefined;