@linxiraos/pi-utils 1.0.0

package/dist/types/vendor/mermaid-ascii/ascii/edge-routing.d.ts

@@ -0,0 +1,43 @@
+import type { Direction, AsciiEdge, AsciiGraph } from './types.js';
+export declare function getOpposite(d: Direction): Direction;
+/** Compare directions by value (not reference). */
+export declare function dirEquals(a: Direction, b: Direction): boolean;
+/**
+ * Determine 8-way direction from one coordinate to another.
+ * Uses the coordinate difference to pick one of 8 cardinal/ordinal directions.
+ */
+export declare function determineDirection(from: {
+    x: number;
+    y: number;
+}, to: {
+    x: number;
+    y: number;
+}): Direction;
+/**
+ * Determine preferred and alternative start/end directions for an edge.
+ * Returns [preferredStart, preferredEnd, alternativeStart, alternativeEnd].
+ *
+ * The edge routing tries both pairs and picks the shorter path.
+ * Direction selection depends on relative node positions and graph direction (LR vs TD).
+ */
+export declare function determineStartAndEndDir(edge: AsciiEdge, graphDirection: string): [Direction, Direction, Direction, Direction];
+/**
+ * Determine the path for an edge by trying two candidate routes (preferred + alternative)
+ * and picking the shorter one. Sets edge.path, edge.startDir, edge.endDir.
+ *
+ * When both A* paths fail (common for edges crossing subgraph boundaries), falls back
+ * to a direct path using the start/end points. This ensures edges always have a path
+ * for arrowhead rendering.
+ *
+ * Uses the effective direction for edge routing, respecting subgraph direction overrides
+ * when both source and target are in the same subgraph.
+ */
+export declare function determinePath(graph: AsciiGraph, edge: AsciiEdge): void;
+/**
+ * Find the best line segment in an edge's path to place a label on.
+ * Prefers vertical segments for TD/BT graphs and horizontal for LR/RL to avoid
+ * label collisions when multiple edges share initial segments.
+ * Falls back to the widest segment if none are suitable.
+ * Also increases the column width at the label position to fit the text.
+ */
+export declare function determineLabelLine(graph: AsciiGraph, edge: AsciiEdge): void;

package/dist/types/vendor/mermaid-ascii/ascii/er-diagram.d.ts

@@ -0,0 +1,7 @@
+import type { AsciiConfig, AsciiTheme, ColorMode } from './types.js';
+/**
+ * Render a Mermaid ER diagram to ASCII/Unicode text.
+ *
+ * Pipeline: parse → build boxes → component-aware layout → draw boxes → draw relationships → string.
+ */
+export declare function renderErAscii(text: string, config: AsciiConfig, colorMode?: ColorMode, theme?: AsciiTheme): string;

package/dist/types/vendor/mermaid-ascii/ascii/grid.d.ts

@@ -0,0 +1,56 @@
+import type { GridCoord, DrawingCoord, Direction, AsciiGraph, AsciiNode, AsciiSubgraph } from './types.js';
+/**
+ * Convert a grid coordinate to a drawing (character) coordinate.
+ * Sums column widths up to the target column, and row heights up to the target row,
+ * then centers within the cell.
+ */
+export declare function gridToDrawingCoord(graph: AsciiGraph, c: GridCoord, dir?: Direction): DrawingCoord;
+/** Convert a path of grid coords to drawing coords. */
+export declare function lineToDrawing(graph: AsciiGraph, line: GridCoord[]): DrawingCoord[];
+/**
+ * Reserve a 3x3 block in the grid for a node.
+ * If the requested position is occupied, recursively shift by 4 grid units
+ * (in the perpendicular direction based on effective direction) until a free spot is found.
+ *
+ * @param effectiveDir - Optional direction override. If not provided, uses the node's
+ *                       effective direction (subgraph direction if in a subgraph with override,
+ *                       otherwise graph direction).
+ */
+export declare function reserveSpotInGrid(graph: AsciiGraph, node: AsciiNode, requested: GridCoord, effectiveDir?: 'LR' | 'TD'): GridCoord;
+/**
+ * Set column widths and row heights for a node's 3x3 grid block.
+ * Each node occupies 3 columns (border, content, border) and 3 rows.
+ * Uses shape-aware dimensions to properly size non-rectangular shapes.
+ */
+export declare function setColumnWidth(graph: AsciiGraph, node: AsciiNode): void;
+/** Ensure grid has width/height entries for all cells along an edge path. */
+export declare function increaseGridSizeForPath(graph: AsciiGraph, path: GridCoord[]): void;
+/**
+ * Get the innermost subgraph that directly contains this node.
+ * Returns null if node is not in any subgraph.
+ */
+export declare function getNodeSubgraph(graph: AsciiGraph, node: AsciiNode): AsciiSubgraph | null;
+/**
+ * Get the effective direction for a node's layout.
+ * Returns the subgraph's direction override if the node is in a subgraph with one,
+ * otherwise returns the graph-level direction.
+ */
+export declare function getEffectiveDirection(graph: AsciiGraph, node: AsciiNode): 'LR' | 'TD';
+export declare function calculateSubgraphBoundingBoxes(graph: AsciiGraph): void;
+/**
+ * Offset all drawing coordinates so subgraph borders don't go negative.
+ * If any subgraph has negative min coordinates, shift everything positive.
+ */
+export declare function offsetDrawingForSubgraphs(graph: AsciiGraph): void;
+/**
+ * createMapping performs the full grid layout:
+ * 1. Place root nodes on the grid
+ * 2. Place child nodes level by level
+ * 3. Compute column widths and row heights
+ * 4. Run A* pathfinding for all edges
+ * 5. Determine label placement
+ * 6. Convert grid coords → drawing coords
+ * 7. Generate node box drawings
+ * 8. Calculate subgraph bounding boxes
+ */
+export declare function createMapping(graph: AsciiGraph): void;

package/dist/types/vendor/mermaid-ascii/ascii/index.d.ts

@@ -0,0 +1,65 @@
+import { detectColorMode, DEFAULT_ASCII_THEME } from './ansi.js';
+import type { AsciiTheme, ColorMode } from './types.js';
+import type { Direction } from '../types.js';
+export type { AsciiTheme, ColorMode };
+export { DEFAULT_ASCII_THEME, detectColorMode };
+export interface AsciiRenderOptions {
+    /** true = ASCII chars (+,-,|,>), false = Unicode box-drawing (┌,─,│,►). Default: false */
+    useAscii?: boolean;
+    /** Horizontal spacing between nodes. Default: 5 */
+    paddingX?: number;
+    /** Vertical spacing between nodes. Default: 5 */
+    paddingY?: number;
+    /** Padding inside node boxes. Default: 1 */
+    boxBorderPadding?: number;
+    /**
+     * Force the layout direction, overriding the direction parsed from the
+     * diagram source. Applies to the flowchart + state-diagram grid pipeline
+     * (sequence/class/ER/xychart renderers ignore it). Useful for re-fitting a
+     * wide `LR` graph into a narrow viewport by laying it out top-down.
+     * Default: undefined (use the source's own direction).
+     */
+    direction?: Direction;
+    /**
+     * Color mode for output.
+     * - 'none': No colors (plain text)
+     * - 'auto': Auto-detect (terminal ANSI capabilities, or HTML in browsers)
+     * - 'ansi16': 16-color ANSI
+     * - 'ansi256': 256-color xterm
+     * - 'truecolor': 24-bit RGB
+     * - 'html': HTML <span> tags with inline color styles (for browser rendering)
+     * Default: 'auto'
+     */
+    colorMode?: ColorMode | 'auto';
+    /** Theme colors for ASCII output. Uses default theme if not provided. */
+    theme?: Partial<AsciiTheme>;
+}
+/**
+ * Render Mermaid diagram text to an ASCII/Unicode string.
+ *
+ * Synchronous — no async layout engine needed (unlike the SVG renderer).
+ * Auto-detects diagram type from the header line and dispatches to
+ * the appropriate renderer.
+ *
+ * @param text - Mermaid source text (any supported diagram type)
+ * @param options - Rendering options
+ * @returns Multi-line ASCII/Unicode string
+ *
+ * @example
+ * ```ts
+ * const result = renderMermaidAscii(`
+ *   graph LR
+ *     A --> B --> C
+ * `, { useAscii: true })
+ *
+ * // Output:
+ * // +---+     +---+     +---+
+ * // |   |     |   |     |   |
+ * // | A |---->| B |---->| C |
+ * // |   |     |   |     |   |
+ * // +---+     +---+     +---+
+ * ```
+ */
+export declare function renderMermaidASCII(text: string, options?: AsciiRenderOptions): string;
+/** Lowercase alias kept as the public name used by the pi-utils wrapper. */
+export declare const renderMermaidAscii: typeof renderMermaidASCII;

package/dist/types/vendor/mermaid-ascii/ascii/multiline-utils.d.ts

@@ -0,0 +1,27 @@
+import type { Canvas } from './types.js';
+/**
+ * Split a label into lines.
+ * Labels are already normalized by parsers (br tags → \n).
+ */
+export declare function splitLines(label: string): string[];
+/**
+ * Get the maximum line width for sizing calculations.
+ * Used to determine column widths for multi-line labels.
+ */
+export declare function maxLineWidth(label: string): number;
+/**
+ * Get the number of lines for height calculations.
+ * Used to determine row heights for multi-line labels.
+ */
+export declare function lineCount(label: string): number;
+/**
+ * Draw multi-line text centered at (cx, cy).
+ * Expands vertically from the center point.
+ * Each line is horizontally centered independently.
+ */
+export declare function drawMultilineTextCentered(canvas: Canvas, label: string, cx: number, cy: number): void;
+/**
+ * Draw multi-line text left-aligned starting at (x, y).
+ * Each subsequent line is placed one row below.
+ */
+export declare function drawMultilineTextLeft(canvas: Canvas, label: string, x: number, y: number): void;

package/dist/types/vendor/mermaid-ascii/ascii/pathfinder.d.ts

@@ -0,0 +1,17 @@
+import type { GridCoord, AsciiNode } from './types.js';
+/**
+ * Manhattan distance with a +1 penalty when both dx and dy are non-zero.
+ * This encourages the pathfinder to prefer straight lines and minimize corners.
+ */
+export declare function heuristic(a: GridCoord, b: GridCoord): number;
+/**
+ * Find a path from `from` to `to` on the grid using A*.
+ * Returns the path as an array of GridCoords, or null if no bounded path exists.
+ */
+export declare function getPath(grid: Map<string, AsciiNode>, from: GridCoord, to: GridCoord): GridCoord[] | null;
+/**
+ * Simplify a path by removing intermediate waypoints on straight segments.
+ * E.g., [(0,0), (1,0), (2,0), (2,1)] becomes [(0,0), (2,0), (2,1)].
+ * This reduces the number of line-drawing operations.
+ */
+export declare function mergePath(path: GridCoord[]): GridCoord[];

package/dist/types/vendor/mermaid-ascii/ascii/sequence.d.ts

@@ -0,0 +1,7 @@
+import type { AsciiConfig, AsciiTheme, ColorMode } from './types.js';
+/**
+ * Render a Mermaid sequence diagram to ASCII/Unicode text.
+ *
+ * Pipeline: parse → layout (columns + rows) → draw onto canvas → string.
+ */
+export declare function renderSequenceAscii(text: string, config: AsciiConfig, colorMode?: ColorMode, theme?: AsciiTheme): string;

package/dist/types/vendor/mermaid-ascii/ascii/shapes/circle.d.ts

@@ -0,0 +1,11 @@
+import type { ShapeRenderer } from './types.js';
+/**
+ * Circle shape renderer.
+ * Uses circle markers (◯) at corners to indicate circular shape semantics.
+ *
+ * Renders as:
+ *   ◯─────────◯
+ *   │  Label  │
+ *   ◯─────────◯
+ */
+export declare const circleRenderer: ShapeRenderer;

package/dist/types/vendor/mermaid-ascii/ascii/shapes/corners.d.ts

@@ -0,0 +1,34 @@
+import type { AsciiNodeShape } from '../types.js';
+/**
+ * Corner characters for a shape in both Unicode and ASCII modes.
+ */
+export interface CornerChars {
+    /** Top-left corner */
+    tl: string;
+    /** Top-right corner */
+    tr: string;
+    /** Bottom-left corner */
+    bl: string;
+    /** Bottom-right corner */
+    br: string;
+}
+/**
+ * Shape corner configuration with both Unicode and ASCII variants.
+ */
+export interface ShapeCorners {
+    unicode: CornerChars;
+    ascii: CornerChars;
+}
+/**
+ * Corner character lookup table for all shape types.
+ *
+ * Design principles:
+ * - All shapes use orthogonal box structure (no diagonals)
+ * - Corner characters indicate shape semantics
+ * - ASCII fallbacks use available punctuation
+ */
+export declare const SHAPE_CORNERS: Record<AsciiNodeShape, ShapeCorners>;
+/**
+ * Get corner characters for a shape type.
+ */
+export declare function getCorners(shape: AsciiNodeShape, useAscii: boolean): CornerChars;

package/dist/types/vendor/mermaid-ascii/ascii/shapes/diamond.d.ts

@@ -0,0 +1,11 @@
+import type { ShapeRenderer } from './types.js';
+/**
+ * Diamond shape renderer.
+ * Uses diamond markers (◇) at corners to indicate decision node semantics.
+ *
+ * Renders as:
+ *   ◇─────────◇
+ *   │  Label  │
+ *   ◇─────────◇
+ */
+export declare const diamondRenderer: ShapeRenderer;

package/dist/types/vendor/mermaid-ascii/ascii/shapes/hexagon.d.ts

@@ -0,0 +1,11 @@
+import type { ShapeRenderer } from './types.js';
+/**
+ * Hexagon shape renderer.
+ * Uses hexagon markers (⬡) at corners to indicate process node semantics.
+ *
+ * Renders as:
+ *   ⬡─────────⬡
+ *   │  Label  │
+ *   ⬡─────────⬡
+ */
+export declare const hexagonRenderer: ShapeRenderer;

package/dist/types/vendor/mermaid-ascii/ascii/shapes/index.d.ts

@@ -0,0 +1,26 @@
+import type { AsciiNodeShape, Canvas, DrawingCoord, Direction } from '../types.js';
+import type { ShapeRenderer, ShapeDimensions, ShapeRenderOptions, ShapeRegistry } from './types.js';
+export type { ShapeRenderer, ShapeDimensions, ShapeRenderOptions, ShapeRegistry };
+/**
+ * Global shape registry — maps shape types to their renderers.
+ * Rectangle is the default fallback for unregistered shapes.
+ */
+export declare const shapeRegistry: ShapeRegistry;
+/**
+ * Get the renderer for a shape type, falling back to rectangle.
+ */
+export declare function getShapeRenderer(shape: AsciiNodeShape): ShapeRenderer;
+/**
+ * Render a node shape to a canvas.
+ * This is the main entry point for shape rendering.
+ */
+export declare function renderShape(shape: AsciiNodeShape, label: string, options: ShapeRenderOptions): Canvas;
+/**
+ * Get dimensions for a shape given a label.
+ * Used during layout to determine node size.
+ */
+export declare function getShapeDimensions(shape: AsciiNodeShape, label: string, options: ShapeRenderOptions): ShapeDimensions;
+/**
+ * Get edge attachment point for a shape.
+ */
+export declare function getShapeAttachmentPoint(shape: AsciiNodeShape, dir: Direction, dimensions: ShapeDimensions, baseCoord: DrawingCoord): DrawingCoord;

package/dist/types/vendor/mermaid-ascii/ascii/shapes/rectangle.d.ts

@@ -0,0 +1,31 @@
+import type { Canvas, DrawingCoord, Direction } from '../types.js';
+import type { ShapeRenderer, ShapeDimensions, ShapeRenderOptions } from './types.js';
+import { type CornerChars } from './corners.js';
+/**
+ * Calculate standard box dimensions for any rectangular shape.
+ * Used by rectangle, circle, diamond, hexagon, etc.
+ */
+export declare function getBoxDimensions(label: string, options: ShapeRenderOptions): ShapeDimensions;
+/**
+ * Render a box with custom corner characters.
+ * This is the core rendering function used by all rectangular shapes.
+ *
+ * @param label - Text to display in the box
+ * @param dimensions - Pre-calculated dimensions
+ * @param corners - Corner characters (tl, tr, bl, br)
+ * @param useAscii - Whether to use ASCII or Unicode for lines
+ */
+export declare function renderBox(label: string, dimensions: ShapeDimensions, corners: CornerChars, useAscii: boolean): Canvas;
+/**
+ * Calculate edge attachment point for rectangular shapes.
+ * All box-based shapes use the same attachment logic.
+ */
+export declare function getBoxAttachmentPoint(dir: Direction, dimensions: ShapeDimensions, baseCoord: DrawingCoord): DrawingCoord;
+/**
+ * Rectangle shape renderer — the default box shape.
+ * Renders as:
+ *   ┌─────────┐
+ *   │  Label  │
+ *   └─────────┘
+ */
+export declare const rectangleRenderer: ShapeRenderer;

package/dist/types/vendor/mermaid-ascii/ascii/shapes/rounded.d.ts

@@ -0,0 +1,11 @@
+import type { ShapeRenderer } from './types.js';
+/**
+ * Rounded rectangle shape renderer.
+ * Uses rounded corner markers (╭╮╰╯) to indicate soft edges.
+ *
+ * Renders as:
+ *   ╭─────────╮
+ *   │  Label  │
+ *   ╰─────────╯
+ */
+export declare const roundedRenderer: ShapeRenderer;

package/dist/types/vendor/mermaid-ascii/ascii/shapes/special.d.ts

@@ -0,0 +1,59 @@
+import type { ShapeRenderer } from './types.js';
+/**
+ * Subroutine shape renderer — double-bordered rectangle.
+ * Renders as:
+ *   ┌┬─────────┬┐
+ *   ││  Label  ││
+ *   └┴─────────┴┘
+ */
+export declare const subroutineRenderer: ShapeRenderer;
+/**
+ * Double circle shape renderer.
+ * Uses double circle markers (◎) at corners.
+ *
+ * Renders as:
+ *   ◎─────────◎
+ *   │  Label  │
+ *   ◎─────────◎
+ */
+export declare const doublecircleRenderer: ShapeRenderer;
+/**
+ * Cylinder shape renderer — database symbol.
+ * Renders as:
+ *   ╭─────╮
+ *   │─────│
+ *   │ DB  │
+ *   │─────│
+ *   ╰─────╯
+ */
+export declare const cylinderRenderer: ShapeRenderer;
+/**
+ * Asymmetric (flag/banner) shape renderer.
+ * Uses arrow markers (▷) on left corners.
+ *
+ * Renders as:
+ *   ▷─────────┐
+ *   │  Label  │
+ *   ▷─────────┘
+ */
+export declare const asymmetricRenderer: ShapeRenderer;
+/**
+ * Trapezoid shape renderer — wider at bottom.
+ * Uses slope markers (◸◹) on top corners.
+ *
+ * Renders as:
+ *   ◸─────────◹
+ *   │  Label  │
+ *   └─────────┘
+ */
+export declare const trapezoidRenderer: ShapeRenderer;
+/**
+ * Trapezoid-alt shape renderer — wider at top.
+ * Uses slope markers (◺◿) on bottom corners.
+ *
+ * Renders as:
+ *   ┌─────────┐
+ *   │  Label  │
+ *   ◺─────────◿
+ */
+export declare const trapezoidAltRenderer: ShapeRenderer;

package/dist/types/vendor/mermaid-ascii/ascii/shapes/stadium.d.ts

@@ -0,0 +1,17 @@
+import type { ShapeRenderer } from './types.js';
+/**
+ * Stadium (pill) shape renderer.
+ *
+ * Single-line:  ( Label )
+ *
+ * Multi-line unicode:
+ *   ╭──────────╮
+ *   │  Label   │
+ *   ╰──────────╯
+ *
+ * Multi-line ASCII:
+ *   (----------)
+ *   (  Label   )
+ *   (----------)
+ */
+export declare const stadiumRenderer: ShapeRenderer;

package/dist/types/vendor/mermaid-ascii/ascii/shapes/state.d.ts

@@ -0,0 +1,30 @@
+import type { ShapeRenderer } from './types.js';
+/**
+ * State start pseudo-state renderer — filled circle in rounded box.
+ * Renders as:
+ *   ╭───╮
+ *   │ ● │   (Unicode)
+ *   ╰───╯
+ *
+ *   .---.
+ *   | * |   (ASCII)
+ *   '---'
+ *
+ * This represents the UML initial pseudo-state.
+ */
+export declare const stateStartRenderer: ShapeRenderer;
+/**
+ * State end pseudo-state renderer — bullseye in double-bordered box.
+ * Renders as:
+ *   ╔═══╗
+ *   ║ ◎ ║   (Unicode)
+ *   ╚═══╝
+ *
+ *   #===#
+ *   # * #   (ASCII)
+ *   #===#
+ *
+ * This represents the UML final state. The double border distinguishes it
+ * from the start state's single rounded border.
+ */
+export declare const stateEndRenderer: ShapeRenderer;

package/dist/types/vendor/mermaid-ascii/ascii/shapes/types.d.ts

@@ -0,0 +1,55 @@
+import type { Canvas, DrawingCoord, Direction, AsciiNodeShape } from '../types.js';
+/**
+ * Dimensions calculated for a shape, used by layout and rendering.
+ */
+export interface ShapeDimensions {
+    /** Total width in characters including borders */
+    width: number;
+    /** Total height in characters including borders */
+    height: number;
+    /** Label area bounds (where text can be placed) */
+    labelArea: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    /** Grid column widths for the 3-column layout [left, center, right] */
+    gridColumns: [number, number, number];
+    /** Grid row heights for the 3-row layout [top, middle, bottom] */
+    gridRows: [number, number, number];
+}
+/**
+ * Options passed to shape renderers.
+ */
+export interface ShapeRenderOptions {
+    /** Use ASCII chars (+,-,|) vs Unicode box-drawing (┌,─,│) */
+    useAscii: boolean;
+    /** Padding inside the shape */
+    padding: number;
+}
+/**
+ * Interface for pluggable shape renderers.
+ * Each shape type implements this interface.
+ */
+export interface ShapeRenderer {
+    /**
+     * Calculate dimensions for this shape given a label.
+     * Used during layout to determine node size.
+     */
+    getDimensions(label: string, options: ShapeRenderOptions): ShapeDimensions;
+    /**
+     * Render the shape to a canvas.
+     * Returns a standalone canvas containing just the shape.
+     */
+    render(label: string, dimensions: ShapeDimensions, options: ShapeRenderOptions): Canvas;
+    /**
+     * Get the edge attachment point for a given direction.
+     * Used by edge routing to determine where edges connect.
+     */
+    getAttachmentPoint(dir: Direction, dimensions: ShapeDimensions, baseCoord: DrawingCoord): DrawingCoord;
+}
+/**
+ * Registry of shape renderers keyed by shape type.
+ */
+export type ShapeRegistry = Map<AsciiNodeShape, ShapeRenderer>;