mermaid2term 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,301 @@
+/**
+ * Core type definitions for the mermaid2term library
+ */
+/**
+ * Grid coordinate - logical positioning in the layout grid
+ * Each node occupies a 3x3 grid cell (border + content + border)
+ */
+interface GridCoord {
+    x: number;
+    y: number;
+}
+/**
+ * Drawing coordinate - physical character position in the output canvas
+ */
+interface DrawingCoord {
+    x: number;
+    y: number;
+}
+/**
+ * Direction for graph layout and edge routing
+ */
+type Direction = 'up' | 'down' | 'left' | 'right';
+/**
+ * Graph flow direction
+ */
+type GraphDirection = 'LR' | 'RL' | 'TD' | 'BT';
+/**
+ * Shape types for flowchart nodes
+ */
+type NodeShape = 'rect' | 'round' | 'diamond' | 'circle' | 'asymmetric' | 'hexagon' | 'parallelogram' | 'trapezoid' | 'cylinder' | 'subroutine';
+/**
+ * A node in the diagram graph
+ */
+interface Node {
+    /** Unique identifier */
+    id: string;
+    /** Display label (may differ from id) */
+    label: string;
+    /** Visual shape */
+    shape: NodeShape;
+    /** Style class name (from classDef) */
+    styleClass?: string;
+    /** Assigned grid position after layout */
+    gridCoord?: GridCoord;
+    /** Assigned drawing position after coordinate transformation */
+    drawingCoord?: DrawingCoord;
+    /** Width in characters (calculated from label + padding) */
+    width?: number;
+    /** Height in characters */
+    height?: number;
+}
+/**
+ * Arrow/line style for edges
+ */
+type EdgeStyle = 'solid' | 'dotted' | 'thick';
+/**
+ * Arrow head type
+ */
+type ArrowType = 'arrow' | 'open' | 'circle' | 'cross';
+/**
+ * An edge connecting two nodes
+ */
+interface Edge {
+    /** Source node id */
+    from: string;
+    /** Target node id */
+    to: string;
+    /** Optional label on the edge */
+    label?: string;
+    /** Line style */
+    style: EdgeStyle;
+    /** Arrow head type at the target end */
+    arrowType: ArrowType;
+    /** Whether arrow points both ways */
+    bidirectional: boolean;
+    /** Calculated path through grid after layout */
+    path?: GridCoord[];
+    /** Starting direction from source node */
+    startDirection?: Direction;
+    /** Ending direction into target node */
+    endDirection?: Direction;
+}
+/**
+ * Style class definition (from classDef)
+ */
+interface StyleClass {
+    name: string;
+    fill?: string;
+    stroke?: string;
+    color?: string;
+    strokeWidth?: string;
+}
+/**
+ * Character set to use for rendering
+ */
+type Charset = 'unicode' | 'ascii';
+/**
+ * Options for rendering diagrams
+ */
+interface RenderOptions {
+    /** Character set - unicode for nice box drawing, ascii for compatibility */
+    charset: Charset;
+    /** Maximum output width in characters (0 = unlimited) */
+    maxWidth: number;
+    /** Horizontal spacing between nodes (in grid units) */
+    paddingX: number;
+    /** Vertical spacing between nodes (in grid units) */
+    paddingY: number;
+    /** Padding inside node borders */
+    borderPadding: number;
+    /** Show debug coordinates overlay */
+    showCoords: boolean;
+}
+/**
+ * Default render options
+ */
+declare const DEFAULT_RENDER_OPTIONS: RenderOptions;
+/**
+ * Supported diagram types
+ */
+type DiagramType = 'flowchart' | 'sequence' | 'class' | 'state' | 'er' | 'unknown';
+/**
+ * Base interface for all diagram ASTs
+ */
+interface BaseDiagramAST {
+    type: DiagramType;
+}
+/**
+ * Result of layout computation
+ */
+interface LayoutResult {
+    /** Total width needed */
+    width: number;
+    /** Total height needed */
+    height: number;
+    /** Positioned nodes */
+    nodes: Node[];
+    /** Routed edges */
+    edges: Edge[];
+    /** Column widths (grid coord -> char width) */
+    columnWidths: Map<number, number>;
+    /** Row heights (grid coord -> char height) */
+    rowHeights: Map<number, number>;
+}
+/**
+ * Interface that all diagram type renderers must implement
+ */
+interface DiagramRenderer<T extends BaseDiagramAST = BaseDiagramAST> {
+    /** Parse input string into diagram AST */
+    parse(input: string): T;
+    /** Compute layout positions for all elements */
+    layout(ast: T, options: RenderOptions): LayoutResult;
+    /** Render laid-out diagram to ASCII string */
+    render(layout: LayoutResult, options: RenderOptions): string;
+}
+
+declare class Canvas {
+    private width;
+    private height;
+    private grid;
+    private chars;
+    constructor(width: number, height: number, charset?: Charset);
+    getWidth(): number;
+    getHeight(): number;
+    set(x: number, y: number, char: string): void;
+    forceSet(x: number, y: number, char: string): void;
+    get(x: number, y: number): string;
+    drawText(x: number, y: number, text: string): void;
+    drawHorizontalLine(x1: number, x2: number, y: number, char?: string): void;
+    drawVerticalLine(x: number, y1: number, y2: number, char?: string): void;
+    drawBox(x: number, y: number, width: number, height: number): void;
+    drawArrow(x: number, y: number, direction: 'up' | 'down' | 'left' | 'right'): void;
+    expandTo(newWidth: number, newHeight: number): void;
+    merge(other: Canvas, offsetX: number, offsetY: number): void;
+    fixJunctions(): void;
+    toString(): string;
+    static fromCoord(coord: DrawingCoord): {
+        x: number;
+        y: number;
+    };
+}
+
+interface BoxChars {
+    topLeft: string;
+    topRight: string;
+    bottomLeft: string;
+    bottomRight: string;
+    horizontal: string;
+    vertical: string;
+}
+interface LineChars {
+    horizontal: string;
+    vertical: string;
+    dottedHorizontal: string;
+    dottedVertical: string;
+    thickHorizontal: string;
+    thickVertical: string;
+}
+interface ArrowChars {
+    up: string;
+    down: string;
+    left: string;
+    right: string;
+    upOpen: string;
+    downOpen: string;
+    leftOpen: string;
+    rightOpen: string;
+    circle: string;
+    cross: string;
+}
+interface JunctionChars {
+    cross: string;
+    leftT: string;
+    rightT: string;
+    topT: string;
+    bottomT: string;
+}
+interface CharacterSet {
+    box: BoxChars;
+    line: LineChars;
+    arrow: ArrowChars;
+    junction: JunctionChars;
+}
+declare function getCharacterSet(charset: Charset): CharacterSet;
+declare function mergeJunctionChars(existing: string, incoming: string): string;
+declare function isLineOrJunctionChar(char: string): boolean;
+declare function isJunctionChar(char: string): boolean;
+declare function isHorizontalChar(char: string): boolean;
+declare function isVerticalChar(char: string): boolean;
+declare function connectsLeft(char: string): boolean;
+declare function connectsRight(char: string): boolean;
+declare function connectsUp(char: string): boolean;
+declare function connectsDown(char: string): boolean;
+declare function getJunctionChar(up: boolean, down: boolean, left: boolean, right: boolean, charset: Charset): string;
+
+interface FlowchartNode extends Node {
+    index: number;
+}
+interface FlowchartEdge extends Edge {
+    index: number;
+}
+interface Subgraph {
+    id: string;
+    label: string;
+    nodeIds: string[];
+}
+interface FlowchartAST extends BaseDiagramAST {
+    type: 'flowchart';
+    direction: GraphDirection;
+    nodes: Map<string, FlowchartNode>;
+    edges: FlowchartEdge[];
+    subgraphs: Subgraph[];
+    styleClasses: Map<string, StyleClass>;
+}
+
+declare function parseFlowchart(input: string): FlowchartAST;
+
+declare function renderFlowchart(ast: FlowchartAST, options: RenderOptions): string;
+
+interface LayoutedGraph {
+    nodes: Map<string, FlowchartNode>;
+    edges: FlowchartEdge[];
+    backEdges: Set<FlowchartEdge>;
+    width: number;
+    height: number;
+    columnWidths: Map<number, number>;
+    rowHeights: Map<number, number>;
+}
+declare function layoutFlowchart(ast: FlowchartAST, options: RenderOptions): LayoutedGraph;
+
+type MessageStyle = 'solid' | 'dotted';
+type ArrowStyle = 'filled' | 'open';
+interface Participant {
+    id: string;
+    alias: string;
+    index: number;
+}
+interface Message {
+    from: string;
+    to: string;
+    text: string;
+    style: MessageStyle;
+    arrowStyle: ArrowStyle;
+    index: number;
+}
+interface SequenceAST extends BaseDiagramAST {
+    type: 'sequence';
+    participants: Map<string, Participant>;
+    messages: Message[];
+}
+
+declare function parseSequence(input: string): SequenceAST;
+
+declare function renderSequence(ast: SequenceAST, options: RenderOptions): string;
+
+declare function detectDiagramType(input: string): DiagramType;
+declare function render(input: string, options?: Partial<RenderOptions>): string;
+declare function renderToFlowchart(input: string, options?: Partial<RenderOptions>): string;
+declare function renderToSequence(input: string, options?: Partial<RenderOptions>): string;
+
+export { type ArrowChars, type ArrowStyle, type ArrowType, type BaseDiagramAST, type BoxChars, Canvas, type CharacterSet, type Charset, DEFAULT_RENDER_OPTIONS, type DiagramRenderer, type DiagramType, type Direction, type DrawingCoord, type Edge, type EdgeStyle, type FlowchartAST, type FlowchartEdge, type FlowchartNode, type GraphDirection, type GridCoord, type JunctionChars, type LayoutResult, type LineChars, type Message, type MessageStyle, type Node, type NodeShape, type Participant, type RenderOptions, type SequenceAST, type StyleClass, type Subgraph, connectsDown, connectsLeft, connectsRight, connectsUp, detectDiagramType, getCharacterSet, getJunctionChar, isHorizontalChar, isJunctionChar, isLineOrJunctionChar, isVerticalChar, layoutFlowchart, mergeJunctionChars, parseFlowchart, parseSequence, render, renderFlowchart, renderSequence, renderToFlowchart, renderToSequence };