@linxiraos/pi-utils 1.0.0

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

@@ -0,0 +1,206 @@
+import type { NodeShape } from '../types.js';
+export type { NodeShape };
+/**
+ * Shape type for ASCII rendering — maps parser shapes to ASCII renderers.
+ * Most shapes from the parser are supported, with fallback to 'rectangle'.
+ */
+export type AsciiNodeShape = NodeShape;
+/** Logical grid coordinate — nodes occupy 3x3 blocks on this grid. */
+export interface GridCoord {
+    x: number;
+    y: number;
+}
+/** Character-level coordinate on the 2D text canvas. */
+export interface DrawingCoord {
+    x: number;
+    y: number;
+}
+/**
+ * Direction constants model positions on a node's 3x3 grid block.
+ * Each node occupies grid cells [x..x+2, y..y+2].
+ * Directions are offsets into that block, used for edge attachment points.
+ *
+ *   (0,0) UL   (1,0) Up   (2,0) UR
+ *   (0,1) Left (1,1) Mid  (2,1) Right
+ *   (0,2) LL   (1,2) Down (2,2) LR
+ */
+export interface Direction {
+    readonly x: number;
+    readonly y: number;
+}
+export declare const Up: Direction;
+export declare const Down: Direction;
+export declare const Left: Direction;
+export declare const Right: Direction;
+export declare const UpperRight: Direction;
+export declare const UpperLeft: Direction;
+export declare const LowerRight: Direction;
+export declare const LowerLeft: Direction;
+export declare const Middle: Direction;
+/** All named directions for iteration. */
+export declare const ALL_DIRECTIONS: readonly Direction[];
+/**
+ * 2D text canvas — column-major (canvas[x][y]).
+ * Each cell holds a single character (or space).
+ */
+export type Canvas = string[][];
+/** A node in the ASCII graph, positioned on the grid. */
+export interface AsciiNode {
+    /** Unique identity key — the original node ID from the parser (e.g. "A", "B"). */
+    name: string;
+    /** Human-readable label for rendering inside the box (e.g. "Web Server"). */
+    displayLabel: string;
+    /** Node shape from the parser (e.g. "rectangle", "diamond", "circle"). */
+    shape: AsciiNodeShape;
+    index: number;
+    gridCoord: GridCoord | null;
+    drawingCoord: DrawingCoord | null;
+    drawing: Canvas | null;
+    drawn: boolean;
+    styleClassName: string;
+    styleClass: AsciiStyleClass;
+}
+/** Style class for colored node text (ported from Go's classDef). */
+export interface AsciiStyleClass {
+    name: string;
+    styles: Record<string, string>;
+}
+/** Edge line style for ASCII rendering. */
+export type AsciiEdgeStyle = 'solid' | 'dotted' | 'thick';
+/** An edge in the ASCII graph, with a routed path. */
+export interface AsciiEdge {
+    from: AsciiNode;
+    to: AsciiNode;
+    text: string;
+    path: GridCoord[];
+    labelLine: GridCoord[];
+    startDir: Direction;
+    endDir: Direction;
+    /** Line style: solid (default), dotted (-.->) or thick (==>) */
+    style: AsciiEdgeStyle;
+    /** Whether to render an arrowhead at the start (source end) of the edge */
+    hasArrowStart: boolean;
+    /** Whether to render an arrowhead at the end (target end) of the edge */
+    hasArrowEnd: boolean;
+    /** Bundle this edge belongs to (if any). Set during bundling analysis. */
+    bundle?: EdgeBundle;
+    /**
+     * For bundled edges: path from source/target to the junction point.
+     * The full visual path is: pathToJunction + bundle.sharedPath (for fan-in)
+     * or bundle.sharedPath + pathToJunction (for fan-out).
+     */
+    pathToJunction?: GridCoord[];
+}
+/** A subgraph container with bounding box for rendering. */
+export interface AsciiSubgraph {
+    name: string;
+    nodes: AsciiNode[];
+    parent: AsciiSubgraph | null;
+    children: AsciiSubgraph[];
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+    /** Optional direction override for layout within this subgraph (LR or TD). */
+    direction?: 'LR' | 'TD';
+}
+/** Configuration for ASCII rendering. */
+export interface AsciiConfig {
+    /** 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;
+    /** Graph direction: "LR" or "TD". */
+    graphDirection: 'LR' | 'TD';
+}
+/** Full ASCII graph state used during layout and rendering. */
+export interface AsciiGraph {
+    nodes: AsciiNode[];
+    edges: AsciiEdge[];
+    canvas: Canvas;
+    /** Role canvas — tracks the role of each character for colored output. */
+    roleCanvas: RoleCanvas;
+    /** Grid occupancy map — maps "x,y" keys to node references. */
+    grid: Map<string, AsciiNode>;
+    columnWidth: Map<number, number>;
+    rowHeight: Map<number, number>;
+    subgraphs: AsciiSubgraph[];
+    config: AsciiConfig;
+    /** Offset applied to all drawing coords to accommodate subgraph borders. */
+    offsetX: number;
+    offsetY: number;
+    /** Edge bundles for parallel link visualization. Set during bundling analysis. */
+    bundles: EdgeBundle[];
+}
+export declare function gridCoordEquals(a: GridCoord, b: GridCoord): boolean;
+export declare function drawingCoordEquals(a: DrawingCoord, b: DrawingCoord): boolean;
+/** Apply a direction offset to a grid coordinate (move into the 3x3 block). */
+export declare function gridCoordDirection(c: GridCoord, dir: Direction): GridCoord;
+/** Key for storing GridCoord in a Map. */
+export declare function gridKey(c: GridCoord): string;
+/** Default empty style class. */
+export declare const EMPTY_STYLE: AsciiStyleClass;
+/**
+ * Role of a character in the ASCII diagram, used for theming.
+ * Each role maps to a different color when colors are enabled.
+ */
+export type CharRole = 'text' | 'border' | 'line' | 'arrow' | 'corner' | 'junction';
+/**
+ * Role canvas — parallel to Canvas, tracks the role of each character.
+ * Same column-major structure: roleCanvas[x][y] gives the role at (x, y).
+ * null means the character has no role (whitespace).
+ */
+export type RoleCanvas = (CharRole | null)[][];
+/**
+ * Theme colors for ASCII output — hex color strings.
+ * Derived from the SVG theme system for visual consistency.
+ */
+export interface AsciiTheme {
+    /** Text color (node labels, edge labels) */
+    fg: string;
+    /** Box border color (node borders, subgraph borders) */
+    border: string;
+    /** Edge line color (paths between nodes) */
+    line: string;
+    /** Arrowhead color (▲▼◄► or ^v<>) */
+    arrow: string;
+    /** Theme accent color (optional, used by xycharts for series 0) */
+    accent?: string;
+    /** Background color (optional, used by xycharts for dark-mode-aware shading) */
+    bg?: string;
+    /** Corner character color (optional, defaults to line) */
+    corner?: string;
+    /** Junction character color (optional, defaults to border) */
+    junction?: string;
+}
+/** Color mode for output. */
+export type ColorMode = 'none' | 'ansi16' | 'ansi256' | 'truecolor' | 'html';
+/**
+ * Edge bundle — groups edges that share a common source or target.
+ * Used to visually merge parallel links before they reach the shared node.
+ *
+ * For fan-in (A & B --> C): multiple sources converge to one target.
+ * For fan-out (A --> B & C): one source diverges to multiple targets.
+ */
+export interface EdgeBundle {
+    /** Bundle type: fan-in = many→one, fan-out = one→many */
+    type: 'fan-in' | 'fan-out';
+    /** Edges in this bundle */
+    edges: AsciiEdge[];
+    /** The common node (target for fan-in, source for fan-out) */
+    sharedNode: AsciiNode;
+    /** The non-shared nodes (sources for fan-in, targets for fan-out) */
+    otherNodes: AsciiNode[];
+    /** Junction point where edges merge/split — set during routing */
+    junctionPoint: GridCoord | null;
+    /** Path from junction to shared node (drawn once for all edges) */
+    sharedPath: GridCoord[];
+    /** Direction when entering/exiting the junction */
+    junctionDir: Direction;
+    /** Direction when entering/exiting the shared node */
+    sharedNodeDir: Direction;
+}

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

@@ -0,0 +1,51 @@
+/**
+ * ASCII Rendering Validation Utilities
+ *
+ * Provides validation functions for ASCII diagram output,
+ * including diagonal line detection to ensure orthogonal-only routing.
+ */
+/**
+ * Characters that represent diagonal lines in ASCII and Unicode modes.
+ * These should never appear in properly rendered diagrams.
+ */
+export declare const DIAGONAL_CHARS: {
+    readonly ascii: readonly ['/', '\\'];
+    readonly unicode: readonly ['╱', '╲'];
+    readonly all: readonly ['/', '\\', '╱', '╲'];
+};
+/**
+ * Position of a diagonal character in ASCII output.
+ */
+export interface DiagonalPosition {
+    line: number;
+    col: number;
+    char: string;
+}
+/**
+ * Check if ASCII output contains any diagonal line characters.
+ * Returns true if diagonals are found (which is an error condition).
+ *
+ * @param asciiOutput - The rendered ASCII diagram string
+ * @returns true if diagonal characters are present, false otherwise
+ */
+export declare function hasDiagonalLines(asciiOutput: string): boolean;
+/**
+ * Find all diagonal line character positions in ASCII output.
+ * Useful for debugging when diagonals are detected.
+ *
+ * Skips diagonal characters that appear inside node labels (between box borders).
+ * This prevents false positives from labels like "feature/auth" or "release/1.0".
+ *
+ * @param asciiOutput - The rendered ASCII diagram string
+ * @returns Array of positions where diagonal characters were found
+ */
+export declare function findDiagonalLines(asciiOutput: string): DiagonalPosition[];
+/**
+ * Assert that ASCII output contains no diagonal lines.
+ * Throws an error with detailed position information if diagonals are found.
+ *
+ * @param asciiOutput - The rendered ASCII diagram string
+ * @param context - Optional context string for error message (e.g., diagram name)
+ * @throws Error if diagonal characters are present
+ */
+export declare function assertNoDiagonals(asciiOutput: string, context?: string): void;

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

@@ -0,0 +1,2 @@
+import type { AsciiConfig, AsciiTheme, ColorMode } from './types.js';
+export declare function renderXYChartAscii(text: string, config: AsciiConfig, colorMode: ColorMode, theme: AsciiTheme): string;

package/dist/types/vendor/mermaid-ascii/class/parser.d.ts

@@ -0,0 +1,6 @@
+import type { ClassDiagram } from './types.js';
+/**
+ * Parse a Mermaid class diagram.
+ * Expects the first line to be "classDiagram".
+ */
+export declare function parseClassDiagram(lines: string[]): ClassDiagram;

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

@@ -0,0 +1,102 @@
+/** Parsed class diagram — logical structure from mermaid text */
+export interface ClassDiagram {
+    /** All class definitions */
+    classes: ClassNode[];
+    /** Relationships between classes */
+    relationships: ClassRelationship[];
+    /** Optional namespace groupings */
+    namespaces: ClassNamespace[];
+}
+export interface ClassNode {
+    id: string;
+    label: string;
+    /** Annotation like <<interface>>, <<abstract>>, <<service>>, <<enumeration>> */
+    annotation?: string;
+    /** Class attributes (fields/properties) */
+    attributes: ClassMember[];
+    /** Class methods (functions) */
+    methods: ClassMember[];
+}
+export interface ClassMember {
+    /** Visibility: + public, - private, # protected, ~ package */
+    visibility: '+' | '-' | '#' | '~' | '';
+    /** Member name */
+    name: string;
+    /** Type annotation (e.g., "String", "int", "void") */
+    type?: string;
+    /** Whether the member is static (underlined in UML) */
+    isStatic?: boolean;
+    /** Whether the member is abstract (italic in UML) */
+    isAbstract?: boolean;
+    /** Whether the member is a method (renders with parentheses) */
+    isMethod?: boolean;
+    /** Method parameters (e.g., "data", "key, val") — only for methods */
+    params?: string;
+}
+/** Relationship types following UML conventions */
+export type RelationshipType = 'inheritance' | 'composition' | 'aggregation' | 'association' | 'dependency' | 'realization';
+export interface ClassRelationship {
+    from: string;
+    to: string;
+    type: RelationshipType;
+    /**
+     * Which end of the relationship line has the UML marker (triangle, diamond, arrow).
+     * Determined by the arrow syntax direction:
+     *   - Prefix markers like `<|--`, `*--`, `o--` → 'from' (marker on left/from side)
+     *   - Suffix markers like `..|>`, `-->`, `..>`, `--*`, `--o` → 'to' (marker on right/to side)
+     */
+    markerAt: 'from' | 'to';
+    /** Label on the relationship line */
+    label?: string;
+    /** Cardinality at the "from" end (e.g., "1", "*", "0..1") */
+    fromCardinality?: string;
+    /** Cardinality at the "to" end */
+    toCardinality?: string;
+}
+export interface ClassNamespace {
+    name: string;
+    classIds: string[];
+}
+export interface PositionedClassDiagram {
+    width: number;
+    height: number;
+    classes: PositionedClassNode[];
+    relationships: PositionedClassRelationship[];
+}
+export interface PositionedClassNode {
+    id: string;
+    label: string;
+    annotation?: string;
+    attributes: ClassMember[];
+    methods: ClassMember[];
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** Height of the header section (name + annotation) */
+    headerHeight: number;
+    /** Height of the attributes section */
+    attrHeight: number;
+    /** Height of the methods section */
+    methodHeight: number;
+}
+export interface PositionedClassRelationship {
+    from: string;
+    to: string;
+    type: RelationshipType;
+    /** Which end of the line has the UML marker — propagated from ClassRelationship */
+    markerAt: 'from' | 'to';
+    label?: string;
+    fromCardinality?: string;
+    toCardinality?: string;
+    /** Path points from source to target */
+    points: Array<{
+        x: number;
+        y: number;
+    }>;
+    /** Dagre-computed label center position (avoids overlaps between nearby edges) */
+    labelPosition?: {
+        x: number;
+        y: number;
+    };
+}

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

@@ -0,0 +1,6 @@
+import type { ErDiagram } from './types.js';
+/**
+ * Parse a Mermaid ER diagram.
+ * Expects the first line to be "erDiagram".
+ */
+export declare function parseErDiagram(lines: string[]): ErDiagram;

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

@@ -0,0 +1,76 @@
+/** Parsed ER diagram — logical structure from mermaid text */
+export interface ErDiagram {
+    /** All entity definitions */
+    entities: ErEntity[];
+    /** Relationships between entities */
+    relationships: ErRelationship[];
+}
+export interface ErEntity {
+    id: string;
+    /** Display name (same as id unless aliased) */
+    label: string;
+    /** Entity attributes (columns) */
+    attributes: ErAttribute[];
+}
+export interface ErAttribute {
+    /** Data type (string, int, varchar, etc.) */
+    type: string;
+    /** Attribute name */
+    name: string;
+    /** Key constraints: PK, FK, UK */
+    keys: Array<'PK' | 'FK' | 'UK'>;
+    /** Optional comment */
+    comment?: string;
+}
+/**
+ * Cardinality notation (crow's foot):
+ *   'one'       ||  exactly one
+ *   'zero-one'  |o  zero or one
+ *   'many'      }|  one or more
+ *   'zero-many' o{  zero or more
+ */
+export type Cardinality = 'one' | 'zero-one' | 'many' | 'zero-many';
+export interface ErRelationship {
+    entity1: string;
+    entity2: string;
+    /** Cardinality at entity1's end */
+    cardinality1: Cardinality;
+    /** Cardinality at entity2's end */
+    cardinality2: Cardinality;
+    /** Relationship verb/label (e.g., "places", "contains") */
+    label: string;
+    /** Whether the relationship is identifying (solid line) or non-identifying (dashed) */
+    identifying: boolean;
+}
+export interface PositionedErDiagram {
+    width: number;
+    height: number;
+    entities: PositionedErEntity[];
+    relationships: PositionedErRelationship[];
+}
+export interface PositionedErEntity {
+    id: string;
+    label: string;
+    attributes: ErAttribute[];
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** Height of the header row */
+    headerHeight: number;
+    /** Height per attribute row */
+    rowHeight: number;
+}
+export interface PositionedErRelationship {
+    entity1: string;
+    entity2: string;
+    cardinality1: Cardinality;
+    cardinality2: Cardinality;
+    label: string;
+    identifying: boolean;
+    /** Path points from entity1 to entity2 */
+    points: Array<{
+        x: number;
+        y: number;
+    }>;
+}

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

@@ -0,0 +1 @@
+export * from './ascii/index.js';

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

@@ -0,0 +1,9 @@
+/**
+ * Normalize label text for terminal ASCII output: strip surrounding quotes,
+ * convert <br> tags and literal newline escapes to newlines, and reduce
+ * inline formatting (HTML bold/italic/underline/strike tags and the markdown
+ * bold, italic, and strikethrough markers) to plain text. The ASCII renderer
+ * has no styled spans, so preserving the markup would print raw tags and
+ * markers inside node boxes.
+ */
+export declare function normalizeBrTags(label: string): string;

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

@@ -0,0 +1,7 @@
+import type { MermaidGraph } from './types.js';
+/**
+ * Parse Mermaid text into a logical graph structure.
+ * Auto-detects diagram type (flowchart or state diagram).
+ * Throws on invalid/unsupported input.
+ */
+export declare function parseMermaid(text: string): MermaidGraph;

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

@@ -0,0 +1,6 @@
+import type { SequenceDiagram } from './types.js';
+/**
+ * Parse a Mermaid sequence diagram.
+ * Expects the first line to be "sequenceDiagram".
+ */
+export declare function parseSequenceDiagram(lines: string[]): SequenceDiagram;

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

@@ -0,0 +1,130 @@
+/** Parsed sequence diagram — logical structure from mermaid text */
+export interface SequenceDiagram {
+    /** Ordered list of actors/participants */
+    actors: Actor[];
+    /** Messages between actors in chronological order */
+    messages: Message[];
+    /** Structural blocks (loop, alt, opt, par, critical) */
+    blocks: Block[];
+    /** Notes attached to actors */
+    notes: Note[];
+}
+export interface Actor {
+    id: string;
+    label: string;
+    /** 'participant' renders as a box, 'actor' renders as a stick figure */
+    type: 'participant' | 'actor';
+}
+export interface Message {
+    from: string;
+    to: string;
+    label: string;
+    /** Arrow style: solid line or dashed line */
+    lineStyle: 'solid' | 'dashed';
+    /** Arrow head: filled (closed) or open */
+    arrowHead: 'filled' | 'open';
+    /** Activate the target lifeline (+) */
+    activate?: boolean;
+    /** Deactivate the source lifeline (-) */
+    deactivate?: boolean;
+}
+export interface Block {
+    /** Block type keyword */
+    type: 'loop' | 'alt' | 'opt' | 'par' | 'critical' | 'break' | 'rect';
+    /** Label for the block header */
+    label: string;
+    /** Index of the first message inside this block */
+    startIndex: number;
+    /** Index of the last message inside this block (inclusive) */
+    endIndex: number;
+    /** For alt/par blocks: indices where "else"/"and" dividers appear (message indices) */
+    dividers: Array<{
+        index: number;
+        label: string;
+    }>;
+}
+export interface Note {
+    /** Which actor(s) the note is attached to */
+    actorIds: string[];
+    /** Note text content */
+    text: string;
+    /** Position relative to the actor(s) */
+    position: 'left' | 'right' | 'over';
+    /** Message index after which this note appears */
+    afterIndex: number;
+}
+export interface PositionedSequenceDiagram {
+    width: number;
+    height: number;
+    actors: PositionedActor[];
+    lifelines: Lifeline[];
+    messages: PositionedMessage[];
+    activations: Activation[];
+    blocks: PositionedBlock[];
+    notes: PositionedNote[];
+}
+export interface PositionedActor {
+    id: string;
+    label: string;
+    type: 'participant' | 'actor';
+    /** Center x of the actor box */
+    x: number;
+    /** Top y of the actor box */
+    y: number;
+    width: number;
+    height: number;
+}
+/** Vertical dashed line from actor to bottom of diagram */
+export interface Lifeline {
+    actorId: string;
+    x: number;
+    topY: number;
+    bottomY: number;
+}
+export interface PositionedMessage {
+    from: string;
+    to: string;
+    label: string;
+    lineStyle: 'solid' | 'dashed';
+    arrowHead: 'filled' | 'open';
+    /** Start point (from actor's lifeline) */
+    x1: number;
+    /** End point (to actor's lifeline) */
+    x2: number;
+    /** Vertical position */
+    y: number;
+    /** Whether this is a self-message (same actor) */
+    isSelf: boolean;
+}
+/** Narrow rectangle on a lifeline showing active processing */
+export interface Activation {
+    actorId: string;
+    x: number;
+    topY: number;
+    bottomY: number;
+    width: number;
+}
+export interface PositionedBlock {
+    type: Block['type'];
+    label: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** Divider lines within the block (for alt/par) */
+    dividers: Array<{
+        y: number;
+        label: string;
+    }>;
+}
+export interface PositionedNote {
+    text: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** Actor IDs this note is attached to (for SVG attribution) */
+    actors?: string[];
+    /** Note position relative to actors (for SVG attribution) */
+    position?: 'left' | 'right' | 'over';
+}

package/dist/types/vendor/mermaid-ascii/text-metrics.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Placeholder occupying the second cell of a fullwidth glyph on the ASCII
+ * canvas. U+0000 cannot appear in parsed Mermaid labels, is treated as
+ * occupied label content by canvas merging, and is stripped at
+ * serialization time. Invariant: a WIDE_PAD cell always sits immediately
+ * right of its lead cell; canvas writes keep the pair atomic.
+ */
+export declare const WIDE_PAD = "\0";
+/**
+ * Display width of a string in terminal columns, summed over grapheme
+ * clusters so it always equals `toCells(text).length`. ASCII-only strings
+ * take a fast path.
+ */
+export declare function displayWidth(text: string): number;
+/**
+ * Expand a string into ASCII-canvas cells: each 2-column grapheme cluster
+ * is stored whole in one cell and followed by WIDE_PAD, so that
+ * `cells.length === displayWidth(text)`. Per-character placement loops can
+ * iterate the result with plain cell offsets.
+ */
+export declare function toCells(text: string): string[];