zombie-mermaid 4.2.2 → 4.2.3

package/src/__tests__/ascii-edge-bundling-routing.test.ts

@@ -1,214 +0,0 @@
-/**
- * Direct coverage for edge-bundling.ts's routeBundledEdges /
- * calculateJunctionPoint — previously untested (PR #178 review): no test
- * imported either function, so the fan-in/fan-out routing math (junction
- * placement, per-edge pathToJunction, shared trunk path) was only ever
- * exercised indirectly through draw-bundles.ts's rendering tests.
- *
- * Also covers the LR branches directly. analyzeEdgeBundles only ever
- * creates bundles for TD graphs (LR routing merges naturally at corners),
- * so routeBundledEdges' LR ternaries are unreachable through any real
- * Mermaid diagram today — but the function itself handles both directions,
- * and after the PR #178 fix (routeEdge/tryDirectPath try both L
- * orientations instead of trusting a possibly-wrong `dir`), the LR path is
- * exercised here directly and pinned, rather than left as untested dead
- * code with the same direction-confusion risk the TD side had.
- */
-import { describe, it, expect } from 'vitest'
-import { parseMermaid } from '@zombie-mermaid/mermaid-parser'
-import { convertToAsciiGraph } from '../../packages/ascii-renderer/src/converter.ts'
-import { createMapping } from '../../packages/ascii-renderer/src/grid.ts'
-import {
-  calculateJunctionPoint,
-  routeBundledEdges,
-} from '../../packages/ascii-renderer/src/edge-bundling.ts'
-import { Middle } from '../../packages/ascii-renderer/src/types.ts'
-import type {
-  AsciiConfig,
-  AsciiGraph,
-  EdgeBundle,
-} from '../../packages/ascii-renderer/src/types.ts'
-
-function buildGraph(src: string, graphDirection: 'TD' | 'LR'): AsciiGraph {
-  const config: AsciiConfig = {
-    useAscii: false,
-    paddingX: 5,
-    paddingY: 5,
-    boxBorderPadding: 1,
-    graphDirection,
-  }
-  const graph = convertToAsciiGraph(parseMermaid(src), config)
-  createMapping(graph)
-  return graph
-}
-
-const FAN_OUT_TD = `flowchart TD
-  C[Source] --> A[One]
-  C --> B[Two]`
-
-const FAN_IN_TD = `flowchart TD
-  A[One] --> C[Target]
-  B[Two] --> C`
-
-describe('routeBundledEdges (TD, via the real layout pipeline)', () => {
-  it('pins the fan-out junction and per-target paths', () => {
-    const graph = buildGraph(FAN_OUT_TD, 'TD')
-    expect(graph.bundles).toHaveLength(1)
-    const bundle = graph.bundles[0]!
-    expect(bundle.type).toBe('fan-out')
-
-    const C = graph.nodes.find((n) => n.name === 'C')!
-    expect(bundle.junctionPoint).toEqual({
-      x: C.gridCoord!.x + 1,
-      y: C.gridCoord!.y + 3,
-    })
-
-    // Every edge in the bundle shares the same trunk directions.
-    for (const edge of bundle.edges) {
-      expect(edge.startDir).toEqual({ x: 1, y: 2 }) // Down
-      expect(edge.endDir).toEqual({ x: 1, y: 0 }) // Up
-      expect(edge.pathToJunction).toBeDefined()
-      expect(edge.pathToJunction!.at(0)).toEqual(bundle.junctionPoint)
-    }
-  })
-
-  it('pins the fan-in junction and per-source paths', () => {
-    const graph = buildGraph(FAN_IN_TD, 'TD')
-    expect(graph.bundles).toHaveLength(1)
-    const bundle = graph.bundles[0]!
-    expect(bundle.type).toBe('fan-in')
-
-    const C = graph.nodes.find((n) => n.name === 'C')!
-    expect(bundle.junctionPoint).toEqual({
-      x: C.gridCoord!.x + 1,
-      y: C.gridCoord!.y - 1,
-    })
-    expect(bundle.sharedPath.at(-1)).toEqual({
-      x: C.gridCoord!.x + 1,
-      y: C.gridCoord!.y,
-    })
-
-    for (const edge of bundle.edges) {
-      expect(edge.startDir).toEqual({ x: 1, y: 2 }) // Down
-      expect(edge.endDir).toEqual({ x: 1, y: 0 }) // Up
-      expect(edge.pathToJunction!.at(-1)).toEqual(bundle.junctionPoint)
-    }
-  })
-
-  it('routes a 3-way fan-out with an unobstructed direct path to each target (no zigzag)', () => {
-    // Regression check for the PR #178 arrival-vs-departure direction bug:
-    // before the fix, the junction->target segment's fast path was dead
-    // for every fan-out edge except the (degenerate, always-aligned) first
-    // one, so off-center targets could get an A*-search path instead of
-    // the direct 2-segment L. Each pathToJunction here must be exactly 2
-    // segments (junction, corner, target) or, when already axis-aligned, 1.
-    const graph = buildGraph(
-      `flowchart TD
-        C[Source] --> A[One]
-        C --> B[A much longer target]
-        C --> D[Three]`,
-      'TD',
-    )
-    const bundle = graph.bundles[0]!
-    for (const edge of bundle.edges) {
-      const path = edge.pathToJunction!
-      // A direct L is at most 3 points (or 2 if already axis-aligned) —
-      // never a longer A*-search detour.
-      expect(path.length).toBeLessThanOrEqual(3)
-    }
-  })
-})
-
-describe('routeBundledEdges (LR, called directly)', () => {
-  // analyzeEdgeBundles never creates a bundle for an LR graph, so these
-  // build one by hand from a real LR-laid-out graph's nodes/edges and call
-  // routeBundledEdges directly — exercising the function's LR branches with
-  // pinned coordinates instead of leaving them untested.
-  function makeBundle(
-    type: 'fan-in' | 'fan-out',
-    graph: AsciiGraph,
-    sharedName: string,
-  ): EdgeBundle {
-    const shared = graph.nodes.find((n) => n.name === sharedName)!
-    const edges = graph.edges.filter((e) =>
-      type === 'fan-out' ? e.from === shared : e.to === shared,
-    )
-    return {
-      type,
-      edges,
-      sharedNode: shared,
-      otherNodes: edges.map((e) => (type === 'fan-out' ? e.to : e.from)),
-      junctionPoint: null,
-      sharedPath: [],
-      junctionDir: Middle,
-      sharedNodeDir: Middle,
-    }
-  }
-
-  it('pins fan-out junction/target coordinates for an LR graph', () => {
-    const graph = buildGraph(
-      `flowchart LR
-        C[Source] --> A[One]
-        C --> B[Two]`,
-      'LR',
-    )
-    const bundle = makeBundle('fan-out', graph, 'C')
-    const C = graph.nodes.find((n) => n.name === 'C')!
-
-    const junction = calculateJunctionPoint(graph, bundle)
-    expect(junction).toEqual({ x: C.gridCoord!.x + 3, y: C.gridCoord!.y + 1 })
-
-    routeBundledEdges(graph, bundle)
-    expect(bundle.junctionPoint).toEqual(junction)
-    expect(bundle.sharedPath.at(-1)).toEqual(junction)
-
-    for (const edge of bundle.edges) {
-      const target = edge.to
-      expect(edge.startDir).toEqual({ x: 2, y: 1 }) // Right
-      expect(edge.endDir).toEqual({ x: 0, y: 1 }) // Left
-      const path = edge.pathToJunction!
-      expect(path.at(0)).toEqual(junction)
-      expect(path.at(-1)).toEqual({
-        x: target.gridCoord!.x,
-        y: target.gridCoord!.y + 1,
-      })
-      // Direct L (or already-aligned straight line) — never an A* detour.
-      expect(path.length).toBeLessThanOrEqual(3)
-    }
-  })
-
-  it('pins fan-in junction/source coordinates for an LR graph', () => {
-    const graph = buildGraph(
-      `flowchart LR
-        A[One] --> C[Target]
-        B[Two] --> C`,
-      'LR',
-    )
-    const bundle = makeBundle('fan-in', graph, 'C')
-    const C = graph.nodes.find((n) => n.name === 'C')!
-
-    const junction = calculateJunctionPoint(graph, bundle)
-    expect(junction).toEqual({ x: C.gridCoord!.x - 1, y: C.gridCoord!.y + 1 })
-
-    routeBundledEdges(graph, bundle)
-    expect(bundle.junctionPoint).toEqual(junction)
-    expect(bundle.sharedPath.at(0)).toEqual(junction)
-    expect(bundle.sharedPath.at(-1)).toEqual({
-      x: C.gridCoord!.x,
-      y: C.gridCoord!.y + 1,
-    })
-
-    for (const edge of bundle.edges) {
-      const source = edge.from
-      expect(edge.startDir).toEqual({ x: 2, y: 1 }) // Right
-      expect(edge.endDir).toEqual({ x: 0, y: 1 }) // Left
-      const path = edge.pathToJunction!
-      expect(path.at(-1)).toEqual(junction)
-      expect(path.at(0)).toEqual({
-        x: source.gridCoord!.x + 2,
-        y: source.gridCoord!.y + 1,
-      })
-      expect(path.length).toBeLessThanOrEqual(3)
-    }
-  })
-})

package/src/__tests__/ascii-edge-cross-style-overlap.test.ts

@@ -1,216 +0,0 @@
-/**
- * Regression tests for a real-world bug: `graph.grid` (grid-occupancy.ts)
- * only tracks *node* occupancy, so two edges with neither a shared source
- * nor a shared target — the only cases `analyzeEdgeBundles` groups, and the
- * only relationship A*'s own occupancy check knows about — could
- * independently route through the same empty cell. When the two edges have
- * different line styles (e.g. a solid branch and a dotted retry/back-edge,
- * a very ordinary shape for any diagram with a retry loop), one silently
- * overwrote the other's glyph in the final canvas: the rendered line looked
- * like a single corrupted half-solid, half-dotted run, with no visual
- * indication that two distinct connections were even there.
- *
- * Repro: a decision node with a "No" branch to a retry node, which then
- * dotted-links back to the start — reported against the CI/CD Pipeline
- * sample on the project's own samples page (a subgraph made it more likely,
- * by leaving less free routing space, but the underlying bug has nothing to
- * do with subgraphs — this repro has none).
- */
-import { describe, it, expect } from 'vitest'
-import { parseMermaid } from '@zombie-mermaid/mermaid-parser'
-import { convertToAsciiGraph } from '../../packages/ascii-renderer/src/converter.ts'
-import { createMapping } from '../../packages/ascii-renderer/src/grid.ts'
-import {
-  isOccupied,
-  pathCells,
-  createGrid,
-  cloneGrid,
-  placeBlock,
-} from '../../packages/ascii-renderer/src/grid-occupancy.ts'
-import {
-  createEdgeCellStyles,
-  findStyleConflict,
-  claimPathCells,
-} from '../../packages/ascii-renderer/src/edge-cell-styles.ts'
-import { renderMermaidASCII } from '@zombie-mermaid/ascii-renderer'
-import type {
-  AsciiConfig,
-  AsciiEdge,
-  AsciiGraph,
-} from '../../packages/ascii-renderer/src/types.ts'
-
-const RETRY_LOOP_SOURCE = `graph TD
-    A[Push Code] --> B{Tests Pass?}
-    B -->|Yes| C[Build Image]
-    B -->|No| D[Fix & Retry]
-    D -.-> A`
-
-function findEdge(
-  edges: AsciiEdge[],
-  fromName: string,
-  toName: string,
-): AsciiEdge {
-  const edge = edges.find(
-    (e) => e.from.name === fromName && e.to.name === toName,
-  )
-  if (!edge) {
-    throw new Error(`Expected an edge ${fromName} -> ${toName}`)
-  }
-  return edge
-}
-
-/**
- * Cells owned by a node's own reserved block are excluded: both edges
- * necessarily touch D's border where they connect to it (one incoming, one
- * outgoing), and that shared port cell is drawn by D's own box-drawing
- * code, not either edge's line style — see edge-cell-styles.ts's module
- * doc. Only *open, non-node* cells are where a real cross-style collision
- * would silently overwrite a glyph.
- */
-function openPathCells(graph: AsciiGraph, path: AsciiEdge['path']): string[] {
-  return pathCells(path)
-    .filter((c) => !isOccupied(graph.grid, c))
-    .map((c) => `${c.x},${c.y}`)
-}
-
-describe('cross-style edge overlap', () => {
-  it('routes a solid branch edge and an unrelated dotted back-edge through disjoint open-space cells', () => {
-    const parsed = parseMermaid(RETRY_LOOP_SOURCE)
-    const config: AsciiConfig = {
-      useAscii: false,
-      paddingX: 5,
-      paddingY: 5,
-      boxBorderPadding: 1,
-      graphDirection: 'TD',
-    }
-    const graph = convertToAsciiGraph(parsed, config)
-    createMapping(graph)
-
-    const noBranch = findEdge(graph.edges, 'B', 'D')
-    const backEdge = findEdge(graph.edges, 'D', 'A')
-
-    expect(noBranch.style).toBe('solid')
-    expect(backEdge.style).toBe('dotted')
-
-    const noBranchCells = new Set(openPathCells(graph, noBranch.path))
-    const backEdgeCells = openPathCells(graph, backEdge.path)
-
-    // Neither edge shares a source or target with the other (B->D vs
-    // D->A), so the *only* thing that can legitimately keep them apart in
-    // open routing space is this disjointness check — same-style edges are
-    // allowed (and often expected) to share cells, but these two must not.
-    const overlap = backEdgeCells.filter((key) => noBranchCells.has(key))
-    expect(overlap).toEqual([])
-  })
-
-  it('renders the retry-loop repro without throwing', () => {
-    // The original report was against a subgraph-wrapped version of this
-    // same shape; asserting on the plain render (not just internal path
-    // data, above) guards the full pipeline end to end.
-    const out = renderMermaidASCII(RETRY_LOOP_SOURCE)
-    for (const label of ['Push Code', 'Tests Pass?', 'Build Image', 'Fix']) {
-      expect(out).toContain(label)
-    }
-  })
-
-  /**
-   * Regression for the crash discovered while fixing the overlap above: an
-   * early version reserved edge-path cells with a naive
-   * "x += sign(dx); y += sign(dy)" walk, which only reaches a segment's
-   * endpoint when |dx| === |dy|. `determinePath`'s Case-4 direct fallback
-   * can produce a segment with any dx/dy ratio, and this plain 4-edge
-   * fan-out is enough to trigger it — the walk never terminated and ran
-   * until the `Set` backing the occupancy grid threw "maximum size
-   * exceeded". See grid-occupancy.test.ts's `pathCells` tests for the
-   * unit-level version of this.
-   */
-  it('does not hang or crash on a plain fan-out that exercises the direct-fallback path', () => {
-    const start = Date.now()
-    const out = renderMermaidASCII(
-      'flowchart LR\n  A --> B\n  A --> C\n  A --> D\n  A --> E',
-      { colorMode: 'none' },
-    )
-    expect(Date.now() - start).toBeLessThan(5000)
-    for (const label of ['A', 'B', 'C', 'D', 'E']) {
-      expect(out).toContain(label)
-    }
-  })
-
-  /**
-   * Regression for a CodeRabbit finding on this PR: `rerouteAroundStyleConflicts`
-   * (grid.ts) temporarily adds a conflicting cell to `graph.grid` so A*
-   * avoids it on retry, then removes the reservation once the edge is
-   * done. An earlier version passed that *same live, mutating* grid to
-   * `findStyleConflict`'s "is this cell node-owned, and therefore not a
-   * real conflict" check — so on a second re-route attempt, the cell
-   * blocked on attempt 1 looked node-occupied and got silently skipped. If
-   * A*'s direct fallback (which ignores occupancy entirely) still crossed
-   * that exact cell, the loop wrongly concluded "no conflict" and stopped,
-   * leaving the two differently-styled edges still overlapping there.
-   *
-   * The fix: pass a `nodeOnlyGrid` snapshot — cloned via `cloneGrid` right
-   * after node placement, before any edge is routed — to the conflict
-   * check instead. This test reproduces the exact mechanism directly:
-   * checking against the live (temp-mutated) grid misses the conflict;
-   * checking against a frozen snapshot correctly still reports it.
-   */
-  it('a temporary reroute reservation on the live grid must not hide a conflict from the frozen node-only snapshot', () => {
-    const grid = createGrid()
-    placeBlock(grid, { x: 4, y: 8 }) // node D's reserved 3x3 block
-    const nodeOnlyGrid = cloneGrid(grid) // taken before any temporary reservation
-
-    const cellStyles = createEdgeCellStyles()
-    const solidPath = [
-      { x: 2, y: 5 },
-      { x: 5, y: 5 },
-      { x: 5, y: 8 },
-    ]
-    claimPathCells(nodeOnlyGrid, cellStyles, solidPath, 'solid')
-
-    const dottedPathThatStillCrossesTheConflict = [
-      { x: 5, y: 1 },
-      { x: 5, y: 8 },
-    ]
-
-    // Simulate what `rerouteAroundStyleConflicts`'s retry loop does when
-    // A*'s direct fallback keeps returning the *same* unchanged path each
-    // time (occupancy-blind, by definition): each iteration finds the
-    // next not-yet-blocked conflicting cell and adds it to the live grid.
-    // With three open-space conflict cells in the path — (5,5), (5,6),
-    // (5,7) — three iterations exhaust every real conflict this way
-    // without the edge's route ever actually changing.
-    for (let i = 0; i < 3; i++) {
-      const conflict = findStyleConflict(
-        grid,
-        cellStyles,
-        dottedPathThatStillCrossesTheConflict,
-        'dotted',
-      )
-      expect(conflict).not.toBeNull()
-      grid.add(`${conflict!.x},${conflict!.y}`)
-    }
-
-    // The bug: after those three iterations, every real conflict cell now
-    // looks node-occupied on the live grid — checking against it reports
-    // "no conflict" even though the edge's path (unchanged this whole
-    // time) still overlaps the solid path in open space.
-    const missedByLiveGrid = findStyleConflict(
-      grid,
-      cellStyles,
-      dottedPathThatStillCrossesTheConflict,
-      'dotted',
-    )
-    expect(missedByLiveGrid).toBeNull()
-
-    // The fix: checking against the untouched snapshot is unaffected by
-    // any of those temporary reservations, so the real conflict is still
-    // caught (reported at the first crossing cell in path order).
-    const caughtByFrozenSnapshot = findStyleConflict(
-      nodeOnlyGrid,
-      cellStyles,
-      dottedPathThatStillCrossesTheConflict,
-      'dotted',
-    )
-    expect(caughtByFrozenSnapshot).toEqual({ x: 5, y: 5 })
-  })
-})

package/src/__tests__/ascii-grid-deep-chain.test.ts

@@ -1,64 +0,0 @@
-/**
- * Regression test for #153 — `createMapping`'s `highestPositionPerLevel`
- * level tracker was a fixed-size-100 array (`new Array(100).fill(0)`), but
- * each level down a chain adds 4 to the tracked coordinate. A chain deeper
- * than ~25 nodes (100 / 4) pushed the index past the preallocated bound,
- * silently reading `undefined` (asserted as `number`) and producing `NaN`
- * grid coordinates instead of throwing or laying out correctly.
- *
- * Fixed by making the tracker a sparse array with `?? 0` defaults on read,
- * so it grows with the chain instead of capping at a fixed depth.
- */
-import { describe, it, expect } from 'vitest'
-import { parseMermaid } from '@zombie-mermaid/mermaid-parser'
-import { convertToAsciiGraph } from '../../packages/ascii-renderer/src/converter.ts'
-import { createMapping } from '../../packages/ascii-renderer/src/grid.ts'
-import { renderMermaidASCII } from '@zombie-mermaid/ascii-renderer'
-import type { AsciiConfig } from '../../packages/ascii-renderer/src/types.ts'
-
-function longChainSource(depth: number): string {
-  const lines = ['flowchart TD']
-  for (let i = 1; i < depth; i++) {
-    lines.push(`  n${i} --> n${i + 1}`)
-  }
-  return lines.join('\n')
-}
-
-describe('ASCII grid layout handles chains deeper than the old fixed-size level tracker (#153)', () => {
-  it('lays out a 40-node chain with no NaN grid coordinates', () => {
-    const source = longChainSource(40)
-    const parsed = parseMermaid(source)
-    const config: AsciiConfig = {
-      useAscii: false,
-      paddingX: 5,
-      paddingY: 5,
-      boxBorderPadding: 1,
-      graphDirection: 'TD',
-    }
-    const graph = convertToAsciiGraph(parsed, config)
-    createMapping(graph)
-
-    expect(graph.nodes).toHaveLength(40)
-    for (const node of graph.nodes) {
-      expect(node.gridCoord).not.toBeNull()
-      expect(Number.isFinite(node.gridCoord!.x)).toBe(true)
-      expect(Number.isFinite(node.gridCoord!.y)).toBe(true)
-    }
-
-    // Each node in the chain should sit strictly deeper (larger y) than the
-    // previous one — NaN corruption would break this monotonic ordering.
-    const yById = new Map(graph.nodes.map((n) => [n.name, n.gridCoord!.y]))
-    for (let i = 1; i < 40; i++) {
-      const y = yById.get(`n${i}`)!
-      const yNext = yById.get(`n${i + 1}`)!
-      expect(yNext).toBeGreaterThan(y)
-    }
-  })
-
-  it('renders a 40-node chain to ASCII without throwing or producing NaN in output', () => {
-    const output = renderMermaidASCII(longChainSource(40))
-    expect(output).not.toContain('NaN')
-    expect(output).toContain('n1')
-    expect(output).toContain('n40')
-  })
-})