@chengchenccc/tui 0.1.1-rc.1

package/dist/vendor/mermaid-ascii/ascii/converter.js

@@ -0,0 +1,233 @@
+// ============================================================================
+// ASCII renderer — MermaidGraph → AsciiGraph converter
+//
+// Bridges the existing TypeScript parser output to the ASCII renderer's
+// internal graph structure. This avoids maintaining a separate parser
+// for ASCII rendering — we reuse parseMermaid() and convert its output.
+// ============================================================================
+import { EMPTY_STYLE } from "./types.js";
+import { mkCanvas, mkRoleCanvas } from "./canvas.js";
+/**
+ * Convert a parsed MermaidGraph into an AsciiGraph ready for grid layout.
+ *
+ * Key mappings:
+ * - MermaidGraph.nodes (Map) → ordered AsciiNode[] preserving insertion order
+ * - MermaidGraph.edges → AsciiEdge[] with resolved node references
+ * - MermaidGraph.subgraphs → AsciiSubgraph[] with parent/child tree
+ * - Node labels are used as display names (not raw IDs)
+ */
+export function convertToAsciiGraph(parsed, config) {
+    // Build node list preserving Map insertion order
+    const nodeMap = new Map();
+    let index = 0;
+    for (const [id, mNode] of parsed.nodes) {
+        const asciiNode = {
+            // Use the parser ID as the unique identity key to avoid collisions
+            // when multiple nodes share the same label (e.g. A[Web Server], C[Web Server]).
+            name: id,
+            // The label is used for rendering inside the box.
+            displayLabel: mNode.label,
+            // Preserve shape from parser for shape-aware rendering
+            shape: mNode.shape,
+            index,
+            gridCoord: null,
+            drawingCoord: null,
+            drawing: null,
+            drawn: false,
+            styleClassName: '',
+            styleClass: EMPTY_STYLE,
+        };
+        nodeMap.set(id, asciiNode);
+        index++;
+    }
+    const nodes = [...nodeMap.values()];
+    // Build edges with resolved node references
+    const edges = [];
+    for (const mEdge of parsed.edges) {
+        const from = nodeMap.get(mEdge.source);
+        const to = nodeMap.get(mEdge.target);
+        if (!from || !to)
+            continue;
+        edges.push({
+            from,
+            to,
+            text: mEdge.label ?? '',
+            path: [],
+            labelLine: [],
+            startDir: { x: 0, y: 0 },
+            endDir: { x: 0, y: 0 },
+            style: mEdge.style,
+            hasArrowStart: mEdge.hasArrowStart,
+            hasArrowEnd: mEdge.hasArrowEnd,
+        });
+    }
+    // Convert subgraphs recursively
+    const subgraphs = [];
+    for (const mSg of parsed.subgraphs) {
+        convertSubgraph(mSg, null, nodeMap, subgraphs);
+    }
+    // Deduplicate subgraph node membership to match Go parser behavior.
+    // In Go, a node belongs only to the subgraph where it was FIRST DEFINED.
+    // The TS parser adds referenced nodes to all subgraphs they appear in,
+    // which causes incorrect bounding boxes when nodes span subgraph boundaries.
+    deduplicateSubgraphNodes(parsed.subgraphs, subgraphs, nodeMap, parsed);
+    // Apply class definitions
+    for (const [nodeId, className] of parsed.classAssignments) {
+        const node = nodeMap.get(nodeId);
+        const classDef = parsed.classDefs.get(className);
+        if (node && classDef) {
+            node.styleClassName = className;
+            node.styleClass = { name: className, styles: classDef };
+        }
+    }
+    return {
+        nodes,
+        edges,
+        canvas: mkCanvas(0, 0),
+        roleCanvas: mkRoleCanvas(0, 0),
+        grid: new Map(),
+        columnWidth: new Map(),
+        rowHeight: new Map(),
+        subgraphs,
+        config,
+        offsetX: 0,
+        offsetY: 0,
+        bundles: [], // Populated by analyzeEdgeBundles() during layout
+    };
+}
+/**
+ * Recursively convert a MermaidSubgraph to AsciiSubgraph.
+ * Flattens the tree into the subgraphs array while maintaining parent/child references.
+ * This matches the Go implementation where all subgraphs are in a flat list
+ * but linked via parent/children pointers.
+ */
+function convertSubgraph(mSg, parent, nodeMap, allSubgraphs) {
+    // Normalize subgraph direction: BT→TD, RL→LR (same as root graph normalization)
+    let normalizedDirection;
+    if (mSg.direction) {
+        normalizedDirection = (mSg.direction === 'LR' || mSg.direction === 'RL') ? 'LR' : 'TD';
+    }
+    const sg = {
+        name: mSg.label,
+        nodes: [],
+        parent,
+        children: [],
+        minX: 0, minY: 0, maxX: 0, maxY: 0,
+        direction: normalizedDirection,
+    };
+    // Resolve node references
+    for (const nodeId of mSg.nodeIds) {
+        const node = nodeMap.get(nodeId);
+        if (node)
+            sg.nodes.push(node);
+    }
+    allSubgraphs.push(sg);
+    // Recurse into children
+    for (const childMSg of mSg.children) {
+        const child = convertSubgraph(childMSg, sg, nodeMap, allSubgraphs);
+        sg.children.push(child);
+        // Child nodes are also part of parent subgraphs (Go behavior).
+        // The Go parser adds nodes to ALL subgraphs in the stack, so a nested
+        // node belongs to both the inner and outer subgraph.
+        for (const childNode of child.nodes) {
+            if (!sg.nodes.includes(childNode)) {
+                sg.nodes.push(childNode);
+            }
+        }
+    }
+    return sg;
+}
+/**
+ * Deduplicate subgraph node membership to match Go parser behavior.
+ *
+ * The Go parser only adds a node to the subgraph that was active when the node
+ * was FIRST CREATED. If a node is later referenced inside a different subgraph,
+ * it is NOT added to that subgraph. The TS parser is more permissive — it adds
+ * referenced nodes to whichever subgraph they appear in.
+ *
+ * This function fixes the discrepancy by:
+ * 1. Walking the edges to determine which nodes were first created inside each subgraph
+ * 2. Removing nodes from subgraphs where they weren't first created
+ */
+function deduplicateSubgraphNodes(mermaidSubgraphs, asciiSubgraphs, nodeMap, parsed) {
+    // Build a map from MermaidSubgraph to its corresponding AsciiSubgraph.
+    // The ordering matches since we convert them in the same order.
+    const sgMap = new Map();
+    buildSgMap(mermaidSubgraphs, asciiSubgraphs, sgMap);
+    // Determine which subgraph each node was "first defined" in.
+    // A node is first defined in the subgraph where it first appears as a NEW node
+    // in the ordered edge/node list. We approximate this by checking the global
+    // node insertion order against subgraph membership.
+    const nodeOwner = new Map(); // nodeId → owning subgraph
+    // Walk all mermaid subgraphs in document order. For each subgraph,
+    // claim nodes that haven't been claimed yet by any previous subgraph.
+    function claimNodes(mSg) {
+        const asciiSg = sgMap.get(mSg);
+        if (!asciiSg)
+            return;
+        // Recurse into children first (they appear before parent in the Go parser stack,
+        // but nodes defined in children are added to parent too — this is handled by
+        // the convertSubgraph function which propagates child nodes to parents).
+        // For dedup, we process children first so their claims propagate up correctly.
+        for (const child of mSg.children) {
+            claimNodes(child);
+        }
+        // Claim unclaimed nodes in this subgraph
+        for (const nodeId of mSg.nodeIds) {
+            if (!nodeOwner.has(nodeId)) {
+                nodeOwner.set(nodeId, asciiSg);
+            }
+        }
+    }
+    for (const mSg of mermaidSubgraphs) {
+        claimNodes(mSg);
+    }
+    // Now remove nodes from subgraphs that don't own them.
+    // A node should remain in: its owner subgraph + all ancestors of the owner.
+    for (const asciiSg of asciiSubgraphs) {
+        asciiSg.nodes = asciiSg.nodes.filter(node => {
+            // Find this node's ID in the nodeMap
+            let nodeId;
+            for (const [id, n] of nodeMap) {
+                if (n === node) {
+                    nodeId = id;
+                    break;
+                }
+            }
+            if (!nodeId)
+                return false;
+            const owner = nodeOwner.get(nodeId);
+            if (!owner)
+                return true; // not in any subgraph claim — keep as-is
+            // Keep the node if this subgraph is the owner or an ancestor of the owner
+            return isAncestorOrSelf(asciiSg, owner);
+        });
+    }
+}
+/** Check if `candidate` is the same as or an ancestor of `target`. */
+function isAncestorOrSelf(candidate, target) {
+    let current = target;
+    while (current !== null) {
+        if (current === candidate)
+            return true;
+        current = current.parent;
+    }
+    return false;
+}
+/** Build a mapping from MermaidSubgraph → AsciiSubgraph (matching by position). */
+function buildSgMap(mSgs, aSgs, result) {
+    // The asciiSubgraphs array is flat (all subgraphs including nested ones),
+    // while mermaidSubgraphs is hierarchical. We need to flatten the mermaid tree
+    // in the same order the converter processes them (pre-order DFS).
+    const flatMermaid = [];
+    function flatten(sgs) {
+        for (const sg of sgs) {
+            flatMermaid.push(sg);
+            flatten(sg.children);
+        }
+    }
+    flatten(mSgs);
+    for (let i = 0; i < flatMermaid.length && i < aSgs.length; i++) {
+        result.set(flatMermaid[i], aSgs[i]);
+    }
+}

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

@@ -0,0 +1,67 @@
+import type { Canvas, DrawingCoord, AsciiGraph, AsciiNode, AsciiEdge, AsciiSubgraph, AsciiEdgeStyle } from './types.ts';
+/**
+ * Draw a node using its shape type.
+ * Returns a standalone canvas containing the rendered shape.
+ *
+ * For basic shapes (rectangle, rounded), uses grid-determined dimensions
+ * to ensure consistent sizing across nodes in the same column.
+ * For special shapes (diamond, circle, state pseudo-states, etc.),
+ * uses shape-specific dimension calculation but centers the content
+ * within the grid cell dimensions to ensure proper vertical alignment.
+ */
+export declare function drawNode(node: AsciiNode, graph: AsciiGraph): Canvas;
+/**
+ * Draw a node box with centered label text.
+ * Returns a standalone canvas containing just the box.
+ * Box size is determined by the grid column/row sizes for the node's position.
+ */
+export declare function drawBox(node: AsciiNode, graph: AsciiGraph): Canvas;
+/**
+ * Draw a multi-section box with horizontal dividers between sections.
+ * Used by class diagrams (header | attributes | methods) and ER diagrams (header | attributes).
+ * Each section is an array of text lines to render left-aligned with padding.
+ *
+ * @param sections - Array of sections, each section is an array of text lines
+ * @param useAscii - true for ASCII chars, false for Unicode box-drawing
+ * @param padding - horizontal padding inside the box (default 1)
+ * @returns A standalone Canvas containing the multi-section box
+ */
+export declare function drawMultiBox(sections: string[][], useAscii: boolean, padding?: number): Canvas;
+/**
+ * Draw a line between two drawing coordinates using orthogonal Manhattan routing.
+ * Returns the list of coordinates that were drawn on.
+ * offsetFrom/offsetTo control how many cells to skip at the start/end.
+ *
+ * All lines use 90° bends only - no diagonal lines are produced.
+ * For diagonal directions, uses horizontal-first routing (draws horizontal
+ * segment, then vertical segment).
+ */
+export declare function drawLine(canvas: Canvas, from: DrawingCoord, to: DrawingCoord, offsetFrom: number, offsetTo: number, useAscii: boolean, style?: AsciiEdgeStyle): DrawingCoord[];
+/**
+ * Draw a complete arrow (edge) between two nodes.
+ * Returns 6 separate canvases for layered compositing:
+ * [path, boxStart, arrowHeadEnd, arrowHeadStart, corners, label]
+ *
+ * Supports bidirectional arrows via edge.hasArrowStart and edge.hasArrowEnd.
+ */
+export declare function drawArrow(graph: AsciiGraph, edge: AsciiEdge): [Canvas, Canvas, Canvas, Canvas, Canvas, Canvas];
+/** Draw a subgraph border rectangle. */
+export declare function drawSubgraphBox(sg: AsciiSubgraph, graph: AsciiGraph): Canvas;
+/** Draw a subgraph label centered in its header area. Supports multi-line labels. */
+export declare function drawSubgraphLabel(sg: AsciiSubgraph, graph: AsciiGraph): [Canvas, DrawingCoord];
+/**
+ * Main draw function — renders the entire graph onto the canvas.
+ * Drawing order matters for correct layering:
+ * 1. Subgraph borders (bottom layer)
+ * 2. Node boxes
+ * 3. Edge paths (lines)
+ * 4. Edge corners
+ * 5. Arrowheads
+ * 6. Box-start junctions
+ * 7. Edge labels
+ * 8. Subgraph labels (top layer)
+ *
+ * Also fills the roleCanvas with character roles for colored output.
+ */
+export declare function drawGraph(graph: AsciiGraph): Canvas;
+//# sourceMappingURL=draw.d.ts.map

package/dist/vendor/mermaid-ascii/ascii/draw.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"draw.d.ts","sourceRoot":"","sources":["../../../../src/vendor/mermaid-ascii/ascii/draw.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EACV,MAAM,EAAE,YAAY,EACpB,UAAU,EAAE,SAAS,EAAE,SAAS,EAAE,aAAa,EAAE,cAAc,EAChE,MAAM,YAAY,CAAA;AAkBnB;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,UAAU,GAAG,MAAM,CAMnE;AA4ED;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,UAAU,GAAG,MAAM,CAElE;AAMD;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAC1B,QAAQ,EAAE,MAAM,EAAE,EAAE,EACpB,QAAQ,EAAE,OAAO,EACjB,OAAO,GAAE,MAAU,GAClB,MAAM,CAyER;AAkCD;;;;;;;;GAQG;AACH,wBAAgB,QAAQ,CACtB,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,YAAY,EAClB,EAAE,EAAE,YAAY,EAChB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,OAAO,EACjB,KAAK,GAAE,cAAwB,GAC9B,YAAY,EAAE,CAmGhB;AAMD;;;;;;GAMG;AACH,wBAAgB,SAAS,CACvB,KAAK,EAAE,UAAU,EACjB,IAAI,EAAE,SAAS,GACd,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAgDlD;AA0pBD,wCAAwC;AACxC,wBAAgB,eAAe,CAAC,EAAE,EAAE,aAAa,EAAE,KAAK,EAAE,UAAU,GAAG,MAAM,CA8B5E;AAED,qFAAqF;AACrF,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,aAAa,EAAE,KAAK,EAAE,UAAU,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CA+B9F;AA0FD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAsHnD"}