@chengchenccc/tui 0.1.1-rc.1

package/dist/vendor/mermaid-ascii/ascii/edge-routing.js

@@ -0,0 +1,302 @@
+// ============================================================================
+// ASCII renderer — direction system and edge path determination
+//
+// Ported from AlexanderGrooff/mermaid-ascii cmd/direction.go + cmd/mapping_edge.go.
+// Handles direction constants, edge attachment point selection,
+// and dual-path comparison for optimal edge routing.
+// ============================================================================
+import { Up, Down, Left, Right, UpperRight, UpperLeft, LowerRight, LowerLeft, Middle, gridCoordDirection, } from "./types.js";
+import { getPath, mergePath } from "./pathfinder.js";
+import { getNodeSubgraph } from "./grid.js";
+import { displayWidth } from "../text-metrics.js";
+// ============================================================================
+// Direction utilities
+// ============================================================================
+export function getOpposite(d) {
+    if (d === Up)
+        return Down;
+    if (d === Down)
+        return Up;
+    if (d === Left)
+        return Right;
+    if (d === Right)
+        return Left;
+    if (d === UpperRight)
+        return LowerLeft;
+    if (d === UpperLeft)
+        return LowerRight;
+    if (d === LowerRight)
+        return UpperLeft;
+    if (d === LowerLeft)
+        return UpperRight;
+    return Middle;
+}
+/** Compare directions by value (not reference). */
+export function dirEquals(a, b) {
+    return a.x === b.x && a.y === b.y;
+}
+/**
+ * Determine 8-way direction from one coordinate to another.
+ * Uses the coordinate difference to pick one of 8 cardinal/ordinal directions.
+ */
+export function determineDirection(from, to) {
+    if (from.x === to.x) {
+        return from.y < to.y ? Down : Up;
+    }
+    else if (from.y === to.y) {
+        return from.x < to.x ? Right : Left;
+    }
+    else if (from.x < to.x) {
+        return from.y < to.y ? LowerRight : UpperRight;
+    }
+    else {
+        return from.y < to.y ? LowerLeft : UpperLeft;
+    }
+}
+// ============================================================================
+// Start/end direction selection for edges
+// ============================================================================
+/** Self-reference routing (node points to itself). */
+function selfReferenceDirection(graphDirection) {
+    if (graphDirection === 'LR')
+        return [Right, Down, Down, Right];
+    return [Down, Right, Right, Down];
+}
+/**
+ * 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 function determineStartAndEndDir(edge, graphDirection) {
+    if (edge.from === edge.to)
+        return selfReferenceDirection(graphDirection);
+    const d = determineDirection(edge.from.gridCoord, edge.to.gridCoord);
+    let preferredDir;
+    let preferredOppositeDir;
+    let alternativeDir;
+    let alternativeOppositeDir;
+    const isBackwards = graphDirection === 'LR'
+        ? (dirEquals(d, Left) || dirEquals(d, UpperLeft) || dirEquals(d, LowerLeft))
+        : (dirEquals(d, Up) || dirEquals(d, UpperLeft) || dirEquals(d, UpperRight));
+    if (dirEquals(d, LowerRight)) {
+        if (graphDirection === 'LR') {
+            preferredDir = Down;
+            preferredOppositeDir = Left;
+            alternativeDir = Right;
+            alternativeOppositeDir = Up;
+        }
+        else {
+            preferredDir = Right;
+            preferredOppositeDir = Up;
+            alternativeDir = Down;
+            alternativeOppositeDir = Left;
+        }
+    }
+    else if (dirEquals(d, UpperRight)) {
+        if (graphDirection === 'LR') {
+            preferredDir = Up;
+            preferredOppositeDir = Left;
+            alternativeDir = Right;
+            alternativeOppositeDir = Down;
+        }
+        else {
+            preferredDir = Right;
+            preferredOppositeDir = Down;
+            alternativeDir = Up;
+            alternativeOppositeDir = Left;
+        }
+    }
+    else if (dirEquals(d, LowerLeft)) {
+        if (graphDirection === 'LR') {
+            preferredDir = Down;
+            preferredOppositeDir = Down;
+            alternativeDir = Left;
+            alternativeOppositeDir = Up;
+        }
+        else {
+            preferredDir = Left;
+            preferredOppositeDir = Up;
+            alternativeDir = Down;
+            alternativeOppositeDir = Right;
+        }
+    }
+    else if (dirEquals(d, UpperLeft)) {
+        if (graphDirection === 'LR') {
+            preferredDir = Down;
+            preferredOppositeDir = Down;
+            alternativeDir = Left;
+            alternativeOppositeDir = Down;
+        }
+        else {
+            preferredDir = Right;
+            preferredOppositeDir = Right;
+            alternativeDir = Up;
+            alternativeOppositeDir = Right;
+        }
+    }
+    else if (isBackwards) {
+        if (graphDirection === 'LR' && dirEquals(d, Left)) {
+            preferredDir = Down;
+            preferredOppositeDir = Down;
+            alternativeDir = Left;
+            alternativeOppositeDir = Right;
+        }
+        else if (graphDirection === 'TD' && dirEquals(d, Up)) {
+            preferredDir = Right;
+            preferredOppositeDir = Right;
+            alternativeDir = Up;
+            alternativeOppositeDir = Down;
+        }
+        else {
+            preferredDir = d;
+            preferredOppositeDir = getOpposite(d);
+            alternativeDir = d;
+            alternativeOppositeDir = getOpposite(d);
+        }
+    }
+    else {
+        // Default: go in the natural direction
+        preferredDir = d;
+        preferredOppositeDir = getOpposite(d);
+        alternativeDir = d;
+        alternativeOppositeDir = getOpposite(d);
+    }
+    return [preferredDir, preferredOppositeDir, alternativeDir, alternativeOppositeDir];
+}
+// ============================================================================
+// Edge path determination
+// ============================================================================
+/**
+ * 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 function determinePath(graph, edge) {
+    // Determine effective direction for this edge
+    // If both nodes are in the same subgraph with a direction override, use it
+    // Otherwise, use the graph's direction (not source's effective direction)
+    const sourceSg = getNodeSubgraph(graph, edge.from);
+    const targetSg = getNodeSubgraph(graph, edge.to);
+    const effectiveDir = (sourceSg && sourceSg === targetSg && sourceSg.direction)
+        ? sourceSg.direction
+        : graph.config.graphDirection;
+    const [preferredDir, preferredOppositeDir, alternativeDir, alternativeOppositeDir] = determineStartAndEndDir(edge, effectiveDir);
+    // Try preferred path
+    const prefFrom = gridCoordDirection(edge.from.gridCoord, preferredDir);
+    const prefTo = gridCoordDirection(edge.to.gridCoord, preferredOppositeDir);
+    let preferredPath = getPath(graph.grid, prefFrom, prefTo);
+    // Try alternative path
+    const altFrom = gridCoordDirection(edge.from.gridCoord, alternativeDir);
+    const altTo = gridCoordDirection(edge.to.gridCoord, alternativeOppositeDir);
+    let alternativePath = getPath(graph.grid, altFrom, altTo);
+    // Case 1: Both paths found — pick the shorter one
+    if (preferredPath !== null && alternativePath !== null) {
+        preferredPath = mergePath(preferredPath);
+        alternativePath = mergePath(alternativePath);
+        if (preferredPath.length <= alternativePath.length) {
+            edge.startDir = preferredDir;
+            edge.endDir = preferredOppositeDir;
+            edge.path = preferredPath;
+        }
+        else {
+            edge.startDir = alternativeDir;
+            edge.endDir = alternativeOppositeDir;
+            edge.path = alternativePath;
+        }
+        return;
+    }
+    // Case 2: Only preferred path found
+    if (preferredPath !== null) {
+        edge.startDir = preferredDir;
+        edge.endDir = preferredOppositeDir;
+        edge.path = mergePath(preferredPath);
+        return;
+    }
+    // Case 3: Only alternative path found
+    if (alternativePath !== null) {
+        edge.startDir = alternativeDir;
+        edge.endDir = alternativeOppositeDir;
+        edge.path = mergePath(alternativePath);
+        return;
+    }
+    // Case 4: Both paths failed — create a direct fallback path
+    // This happens for edges crossing subgraph boundaries where A* can't find
+    // a clear route. We create a direct path from source to target exit points
+    // so arrowheads can still be rendered correctly.
+    edge.startDir = preferredDir;
+    edge.endDir = preferredOppositeDir;
+    edge.path = [prefFrom, prefTo];
+}
+/**
+ * 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 function determineLabelLine(graph, edge) {
+    if (edge.text.length === 0)
+        return;
+    const lenLabel = displayWidth(edge.text);
+    const pathLen = edge.path.length;
+    const isVerticalFlow = graph.config.graphDirection === 'TD';
+    // Collect all segments with their widths and orientation
+    const segments = [];
+    for (let i = 1; i < pathLen; i++) {
+        const p1 = edge.path[i - 1];
+        const p2 = edge.path[i];
+        const line = [p1, p2];
+        const width = calculateLineWidth(graph, line);
+        // A segment is vertical if X coords are same, horizontal if Y coords are same
+        const isVertical = p1.x === p2.x;
+        segments.push({ line, width, index: i, isVertical });
+    }
+    // Find segments wide enough for the label, excluding the first segment
+    // The first segment is often shared between edges from the same source node
+    const suitableSegments = segments.filter(s => s.width >= lenLabel && s.index > 1);
+    let largestLine;
+    if (suitableSegments.length > 0) {
+        // Prefer segments near the end of the path (closer to target)
+        // This avoids the shared initial segments from source
+        suitableSegments.sort((a, b) => b.index - a.index);
+        largestLine = suitableSegments[0].line;
+    }
+    else {
+        // Fall back to any suitable segment including the first
+        const fallbackSegments = segments.filter(s => s.width >= lenLabel);
+        if (fallbackSegments.length > 0) {
+            fallbackSegments.sort((a, b) => b.index - a.index);
+            largestLine = fallbackSegments[0].line;
+        }
+        else {
+            // No segment wide enough — use the widest one
+            segments.sort((a, b) => b.width - a.width);
+            largestLine = segments[0]?.line ?? [edge.path[0], edge.path[1]];
+        }
+    }
+    // Ensure column at midpoint is wide enough for the label
+    const minX = Math.min(largestLine[0].x, largestLine[1].x);
+    const maxX = Math.max(largestLine[0].x, largestLine[1].x);
+    const middleX = minX + Math.floor((maxX - minX) / 2);
+    const current = graph.columnWidth.get(middleX) ?? 0;
+    graph.columnWidth.set(middleX, Math.max(current, lenLabel + 2));
+    edge.labelLine = [largestLine[0], largestLine[1]];
+}
+/** Calculate the total character width of a line segment by summing column widths. */
+function calculateLineWidth(graph, line) {
+    let total = 0;
+    const startX = Math.min(line[0].x, line[1].x);
+    const endX = Math.max(line[0].x, line[1].x);
+    for (let x = startX; x <= endX; x++) {
+        total += graph.columnWidth.get(x) ?? 0;
+    }
+    return total;
+}

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

@@ -0,0 +1,8 @@
+import type { AsciiConfig, AsciiTheme, ColorMode } from './types.ts';
+/**
+ * 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;
+//# sourceMappingURL=er-diagram.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"er-diagram.d.ts","sourceRoot":"","sources":["../../../../src/vendor/mermaid-ascii/ascii/er-diagram.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAU,WAAW,EAAwB,UAAU,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AA6IlG;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,SAAS,CAAC,EAAE,SAAS,EAAE,KAAK,CAAC,EAAE,UAAU,GAAG,MAAM,CAyRlH"}