@chengchenccc/tui 0.1.1-rc.1

package/dist/vendor/mermaid-ascii/ascii/edge-bundling.d.ts

@@ -0,0 +1,49 @@
+import type { AsciiGraph, EdgeBundle, GridCoord } from './types.ts';
+/**
+ * Analyze graph edges and create bundles for parallel links.
+ *
+ * Groups edges by:
+ * - Fan-in: Multiple edges sharing the same target (A & B --> C)
+ * - Fan-out: Multiple edges sharing the same source (A --> B & C)
+ *
+ * Only creates bundles when:
+ * - Graph direction is TD (top-down) - LR routing handles merging naturally
+ * - 2+ edges share the endpoint
+ * - All edges have the same style (solid/dotted/thick)
+ * - None of the edges have labels (labels would overlap at junction)
+ * - Edges are not self-loops
+ *
+ * @returns Array of bundles. Each edge can belong to at most one bundle.
+ */
+export declare function analyzeEdgeBundles(graph: AsciiGraph): EdgeBundle[];
+/**
+ * Calculate the optimal junction point for a bundle.
+ *
+ * For fan-in (A & B --> C):
+ *   - Junction is placed between the sources and the target
+ *   - In TD: above the target, horizontally centered between sources
+ *   - In LR: left of the target, vertically centered between sources
+ *
+ * For fan-out (A --> B & C):
+ *   - Junction is placed between the source and the targets
+ *   - In TD: below the source, horizontally centered between targets
+ *   - In LR: right of the source, vertically centered between targets
+ */
+export declare function calculateJunctionPoint(graph: AsciiGraph, bundle: EdgeBundle): GridCoord;
+/**
+ * Route all edges in a bundle through the junction point.
+ *
+ * For fan-in bundles:
+ *   1. Route each source → junction (stored in edge.pathToJunction)
+ *   2. Route junction → target (stored in bundle.sharedPath)
+ *
+ * For fan-out bundles:
+ *   1. Route source → junction (stored in bundle.sharedPath)
+ *   2. Route junction → each target (stored in edge.pathToJunction)
+ */
+export declare function routeBundledEdges(graph: AsciiGraph, bundle: EdgeBundle): void;
+/**
+ * Process all bundles in a graph: calculate junction points and route edges.
+ */
+export declare function processBundles(graph: AsciiGraph): void;
+//# sourceMappingURL=edge-bundling.d.ts.map

package/dist/vendor/mermaid-ascii/ascii/edge-bundling.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edge-bundling.d.ts","sourceRoot":"","sources":["../../../../src/vendor/mermaid-ascii/ascii/edge-bundling.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EACV,UAAU,EAAwB,UAAU,EAAE,SAAS,EACxD,MAAM,YAAY,CAAA;AASnB;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,UAAU,GAAG,UAAU,EAAE,CAqFlE;AAuCD;;;;;;;;;;;;GAYG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,UAAU,EACjB,MAAM,EAAE,UAAU,GACjB,SAAS,CAkDX;AAMD;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,GAAG,IAAI,CAuE7E;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI,CAItD"}

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

@@ -0,0 +1,289 @@
+// ============================================================================
+// ASCII renderer — edge bundling for parallel links
+//
+// Analyzes edges to find parallel links (A & B --> C or A --> B & C) and
+// groups them into bundles. Bundled edges share a visual junction point
+// where they merge/split, creating cleaner diagrams.
+//
+// This module provides:
+//   - analyzeEdgeBundles(): Finds and creates bundles from graph edges
+//   - calculateJunctionPoint(): Computes optimal merge/split locations
+//   - routeBundledEdges(): Routes edges through junction points
+// ============================================================================
+import { Up, Down, Left, Right, Middle } from "./types.js";
+import { getPath, mergePath } from "./pathfinder.js";
+import { getNodeSubgraph } from "./grid.js";
+// ============================================================================
+// Bundle analysis
+// ============================================================================
+/**
+ * Analyze graph edges and create bundles for parallel links.
+ *
+ * Groups edges by:
+ * - Fan-in: Multiple edges sharing the same target (A & B --> C)
+ * - Fan-out: Multiple edges sharing the same source (A --> B & C)
+ *
+ * Only creates bundles when:
+ * - Graph direction is TD (top-down) - LR routing handles merging naturally
+ * - 2+ edges share the endpoint
+ * - All edges have the same style (solid/dotted/thick)
+ * - None of the edges have labels (labels would overlap at junction)
+ * - Edges are not self-loops
+ *
+ * @returns Array of bundles. Each edge can belong to at most one bundle.
+ */
+export function analyzeEdgeBundles(graph) {
+    // Only bundle in TD direction - LR routing handles merging naturally at corners
+    if (graph.config.graphDirection !== 'TD') {
+        return [];
+    }
+    const bundles = [];
+    const bundledEdges = new Set();
+    // Group edges by target (fan-in candidates)
+    const edgesByTarget = new Map();
+    for (const edge of graph.edges) {
+        // Skip self-loops
+        if (edge.from === edge.to)
+            continue;
+        const existing = edgesByTarget.get(edge.to) ?? [];
+        existing.push(edge);
+        edgesByTarget.set(edge.to, existing);
+    }
+    // Create fan-in bundles
+    for (const [target, edges] of edgesByTarget) {
+        if (edges.length < 2)
+            continue;
+        if (!canBundle(edges, graph))
+            continue;
+        // Check if all edges are already bundled
+        if (edges.some(e => bundledEdges.has(e)))
+            continue;
+        const bundle = {
+            type: 'fan-in',
+            edges: [...edges],
+            sharedNode: target,
+            otherNodes: edges.map(e => e.from),
+            junctionPoint: null,
+            sharedPath: [],
+            junctionDir: Middle,
+            sharedNodeDir: Middle,
+        };
+        // Mark edges as bundled
+        for (const edge of edges) {
+            edge.bundle = bundle;
+            bundledEdges.add(edge);
+        }
+        bundles.push(bundle);
+    }
+    // Group edges by source (fan-out candidates)
+    const edgesBySource = new Map();
+    for (const edge of graph.edges) {
+        // Skip self-loops and already bundled edges
+        if (edge.from === edge.to)
+            continue;
+        if (bundledEdges.has(edge))
+            continue;
+        const existing = edgesBySource.get(edge.from) ?? [];
+        existing.push(edge);
+        edgesBySource.set(edge.from, existing);
+    }
+    // Create fan-out bundles
+    for (const [source, edges] of edgesBySource) {
+        if (edges.length < 2)
+            continue;
+        if (!canBundle(edges, graph))
+            continue;
+        const bundle = {
+            type: 'fan-out',
+            edges: [...edges],
+            sharedNode: source,
+            otherNodes: edges.map(e => e.to),
+            junctionPoint: null,
+            sharedPath: [],
+            junctionDir: Middle,
+            sharedNodeDir: Middle,
+        };
+        // Mark edges as bundled
+        for (const edge of edges) {
+            edge.bundle = bundle;
+            bundledEdges.add(edge);
+        }
+        bundles.push(bundle);
+    }
+    return bundles;
+}
+/**
+ * Check if a group of edges can be bundled together.
+ * Returns false if edges have different styles, any have labels,
+ * or if the edges span subgraph boundaries (which creates complex routing).
+ */
+function canBundle(edges, graph) {
+    if (edges.length < 2)
+        return false;
+    const firstStyle = edges[0].style;
+    const firstFromSg = getNodeSubgraph(graph, edges[0].from);
+    const firstToSg = getNodeSubgraph(graph, edges[0].to);
+    for (const edge of edges) {
+        // Different styles can't be bundled (would look confusing)
+        if (edge.style !== firstStyle)
+            return false;
+        // Edges with labels can't be bundled (labels would overlap at junction)
+        if (edge.text.length > 0)
+            return false;
+        // Don't bundle if edges span different subgraph boundaries
+        // (creates complex routing that doesn't look good)
+        const fromSg = getNodeSubgraph(graph, edge.from);
+        const toSg = getNodeSubgraph(graph, edge.to);
+        if (fromSg !== firstFromSg || toSg !== firstToSg)
+            return false;
+        // Don't bundle if source and target are in different subgraphs
+        // (cross-boundary edges have special routing needs)
+        if (fromSg !== toSg)
+            return false;
+    }
+    return true;
+}
+// ============================================================================
+// Junction point calculation
+// ============================================================================
+/**
+ * Calculate the optimal junction point for a bundle.
+ *
+ * For fan-in (A & B --> C):
+ *   - Junction is placed between the sources and the target
+ *   - In TD: above the target, horizontally centered between sources
+ *   - In LR: left of the target, vertically centered between sources
+ *
+ * For fan-out (A --> B & C):
+ *   - Junction is placed between the source and the targets
+ *   - In TD: below the source, horizontally centered between targets
+ *   - In LR: right of the source, vertically centered between targets
+ */
+export function calculateJunctionPoint(graph, bundle) {
+    const dir = graph.config.graphDirection;
+    const sharedCoord = bundle.sharedNode.gridCoord;
+    const otherCoords = bundle.otherNodes.map(n => n.gridCoord);
+    if (bundle.type === 'fan-in') {
+        // Junction is BEFORE the shared target
+        // Calculate center of sources
+        const minX = Math.min(...otherCoords.map(c => c.x));
+        const maxX = Math.max(...otherCoords.map(c => c.x));
+        const minY = Math.min(...otherCoords.map(c => c.y));
+        const maxY = Math.max(...otherCoords.map(c => c.y));
+        if (dir === 'TD') {
+            // Junction above target, centered between sources
+            // Place it one row above the target's entry point
+            const junctionY = sharedCoord.y - 1;
+            // X is centered between sources, but clamped to shared node's X for alignment
+            const centerX = Math.floor((minX + maxX) / 2) + 1; // +1 for center of 3x3 block
+            const junctionX = sharedCoord.x + 1; // Align with target's center
+            return { x: junctionX, y: junctionY };
+        }
+        else {
+            // LR: Junction left of target, centered between sources
+            const junctionX = sharedCoord.x - 1;
+            const junctionY = sharedCoord.y + 1; // Align with target's center
+            return { x: junctionX, y: junctionY };
+        }
+    }
+    else {
+        // fan-out: Junction is AFTER the shared source
+        const minX = Math.min(...otherCoords.map(c => c.x));
+        const maxX = Math.max(...otherCoords.map(c => c.x));
+        const minY = Math.min(...otherCoords.map(c => c.y));
+        const maxY = Math.max(...otherCoords.map(c => c.y));
+        if (dir === 'TD') {
+            // Junction below source, will then split to targets
+            const junctionY = sharedCoord.y + 3; // Just below source's 3x3 block
+            const junctionX = sharedCoord.x + 1; // Align with source's center
+            return { x: junctionX, y: junctionY };
+        }
+        else {
+            // LR: Junction right of source
+            const junctionX = sharedCoord.x + 3;
+            const junctionY = sharedCoord.y + 1;
+            return { x: junctionX, y: junctionY };
+        }
+    }
+}
+// ============================================================================
+// Bundled edge routing
+// ============================================================================
+/**
+ * Route all edges in a bundle through the junction point.
+ *
+ * For fan-in bundles:
+ *   1. Route each source → junction (stored in edge.pathToJunction)
+ *   2. Route junction → target (stored in bundle.sharedPath)
+ *
+ * For fan-out bundles:
+ *   1. Route source → junction (stored in bundle.sharedPath)
+ *   2. Route junction → each target (stored in edge.pathToJunction)
+ */
+export function routeBundledEdges(graph, bundle) {
+    const dir = graph.config.graphDirection;
+    // Calculate and store junction point
+    bundle.junctionPoint = calculateJunctionPoint(graph, bundle);
+    const junction = bundle.junctionPoint;
+    // Determine directions based on graph direction and bundle type
+    if (bundle.type === 'fan-in') {
+        // Sources converge to junction, then junction to target
+        bundle.junctionDir = dir === 'TD' ? Up : Left;
+        bundle.sharedNodeDir = dir === 'TD' ? Down : Right;
+        // Route junction → target (shared path)
+        const targetCoord = bundle.sharedNode.gridCoord;
+        const targetEntry = dir === 'TD'
+            ? { x: targetCoord.x + 1, y: targetCoord.y } // Top center of target
+            : { x: targetCoord.x, y: targetCoord.y + 1 }; // Left center of target
+        const sharedPath = getPath(graph.grid, junction, targetEntry);
+        bundle.sharedPath = sharedPath ? mergePath(sharedPath) : [junction, targetEntry];
+        // Route each source → junction
+        for (const edge of bundle.edges) {
+            const sourceCoord = edge.from.gridCoord;
+            const sourceExit = dir === 'TD'
+                ? { x: sourceCoord.x + 1, y: sourceCoord.y + 2 } // Bottom center of source
+                : { x: sourceCoord.x + 2, y: sourceCoord.y + 1 }; // Right center of source
+            const pathToJunction = getPath(graph.grid, sourceExit, junction);
+            edge.pathToJunction = pathToJunction ? mergePath(pathToJunction) : [sourceExit, junction];
+            // Set edge directions for proper drawing
+            edge.startDir = dir === 'TD' ? Down : Right;
+            edge.endDir = dir === 'TD' ? Up : Left;
+            // Build full path for grid size calculation: source → junction → target
+            edge.path = [...edge.pathToJunction, ...bundle.sharedPath.slice(1)];
+        }
+    }
+    else {
+        // fan-out: Source to junction, then junction splits to targets
+        bundle.junctionDir = dir === 'TD' ? Down : Right;
+        bundle.sharedNodeDir = dir === 'TD' ? Up : Left;
+        // Route source → junction (shared path)
+        const sourceCoord = bundle.sharedNode.gridCoord;
+        const sourceExit = dir === 'TD'
+            ? { x: sourceCoord.x + 1, y: sourceCoord.y + 2 } // Bottom center of source
+            : { x: sourceCoord.x + 2, y: sourceCoord.y + 1 }; // Right center of source
+        const sharedPath = getPath(graph.grid, sourceExit, junction);
+        bundle.sharedPath = sharedPath ? mergePath(sharedPath) : [sourceExit, junction];
+        // Route junction → each target
+        for (const edge of bundle.edges) {
+            const targetCoord = edge.to.gridCoord;
+            const targetEntry = dir === 'TD'
+                ? { x: targetCoord.x + 1, y: targetCoord.y } // Top center of target
+                : { x: targetCoord.x, y: targetCoord.y + 1 }; // Left center of target
+            const pathToJunction = getPath(graph.grid, junction, targetEntry);
+            edge.pathToJunction = pathToJunction ? mergePath(pathToJunction) : [junction, targetEntry];
+            // Set edge directions
+            edge.startDir = dir === 'TD' ? Down : Right;
+            edge.endDir = dir === 'TD' ? Up : Left;
+            // Build full path for grid size calculation: source → junction → target
+            edge.path = [...bundle.sharedPath, ...edge.pathToJunction.slice(1)];
+        }
+    }
+}
+/**
+ * Process all bundles in a graph: calculate junction points and route edges.
+ */
+export function processBundles(graph) {
+    for (const bundle of graph.bundles) {
+        routeBundledEdges(graph, bundle);
+    }
+}

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

@@ -0,0 +1,44 @@
+import type { Direction, AsciiEdge, AsciiGraph } from './types.ts';
+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;
+//# sourceMappingURL=edge-routing.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"edge-routing.d.ts","sourceRoot":"","sources":["../../../../src/vendor/mermaid-ascii/ascii/edge-routing.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAa,SAAS,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAa7E,wBAAgB,WAAW,CAAC,CAAC,EAAE,SAAS,GAAG,SAAS,CAUnD;AAED,mDAAmD;AACnD,wBAAgB,SAAS,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,GAAG,OAAO,CAE7D;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,EAAE,EAAE,EAAE;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAU1G;AAYD;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,SAAS,EACf,cAAc,EAAE,MAAM,GACrB,CAAC,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,CAAC,CAgE9C;AAMD;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,SAAS,GAAG,IAAI,CA+DtE;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,SAAS,GAAG,IAAI,CA0D3E"}