@zombie-mermaid/ascii-renderer 2.2.1

package/src/__tests__/ascii-pathfinder-route-edge.test.ts

@@ -0,0 +1,184 @@
+/**
+ * Direct coverage for pathfinder.ts's routeEdge (and the tryDirectPath fast
+ * path it wraps) — previously untested (PR #178 review). routeEdge is the
+ * shared seam edge-routing.ts's determinePath and edge-bundling.ts's
+ * routeBundledEdges both route through: try an unobstructed direct L-shaped
+ * path first, falling back to A* search, and require a render-wide
+ * pathBudget rather than silently degrading when one is absent.
+ *
+ * The "try both L orientations" behavior below is the fix for the
+ * arrival-vs-departure direction bug the review found: `dir` picks a
+ * *preferred* corner order, but when that orientation is blocked the other
+ * orientation is tried too, so routeEdge produces a correct direct path
+ * even when a caller's `dir` reflects an arrival anchor rather than the
+ * true departure direction (see edge-bundling.ts's routeBundledEdges).
+ */
+import { describe, it, expect } from 'vitest'
+import { routeEdge, createPathBudget } from '../pathfinder.ts'
+import {
+  Up,
+  Down,
+  Left,
+  Right,
+  Middle,
+  UpperRight,
+  requireCardinalDirection,
+} from '../types.ts'
+import type { AsciiGraph, PathBudget } from '../types.ts'
+import { createGrid, placeBlock, type Grid } from '../grid-occupancy.ts'
+
+function makeGraph(grid: Grid, pathBudget: PathBudget | undefined): AsciiGraph {
+  return {
+    nodes: [],
+    edges: [],
+    canvas: [],
+    roleCanvas: [],
+    grid,
+    columnWidth: new Map(),
+    rowHeight: new Map(),
+    subgraphs: [],
+    config: {
+      useAscii: false,
+      paddingX: 5,
+      paddingY: 5,
+      boxBorderPadding: 1,
+      graphDirection: 'TD',
+    },
+    offsetX: 0,
+    offsetY: 0,
+    bundles: [],
+    pathBudget,
+  }
+}
+
+describe('routeEdge', () => {
+  it('takes the horizontal-first direct L when dir is Right', () => {
+    const graph = makeGraph(createGrid(), createPathBudget())
+    const path = routeEdge(
+      graph,
+      { x: 0, y: 0 },
+      { x: 4, y: 4 },
+      requireCardinalDirection(Right),
+    )
+    expect(path).toEqual([
+      { x: 0, y: 0 },
+      { x: 4, y: 0 },
+      { x: 4, y: 4 },
+    ])
+  })
+
+  it('takes the vertical-first direct L when dir is Down', () => {
+    const graph = makeGraph(createGrid(), createPathBudget())
+    const path = routeEdge(
+      graph,
+      { x: 0, y: 0 },
+      { x: 4, y: 4 },
+      requireCardinalDirection(Down),
+    )
+    expect(path).toEqual([
+      { x: 0, y: 0 },
+      { x: 0, y: 4 },
+      { x: 4, y: 4 },
+    ])
+  })
+
+  it('falls back to the other L orientation when the preferred one is blocked', () => {
+    // dir=Right prefers the {4,0} corner; occupy it so only the {0,4}
+    // corner (vertical-first) is clear. This is exactly the scenario the
+    // arrival-vs-departure bug hit: a caller passes a `dir` that doesn't
+    // match the true departure axis, but the direct path is still found
+    // because both orientations are tried.
+    const grid = createGrid()
+    placeBlock(grid, { x: 4, y: 0 }, 1)
+    const graph = makeGraph(grid, createPathBudget())
+    const path = routeEdge(
+      graph,
+      { x: 0, y: 0 },
+      { x: 4, y: 4 },
+      requireCardinalDirection(Right),
+    )
+    expect(path).toEqual([
+      { x: 0, y: 0 },
+      { x: 0, y: 4 },
+      { x: 4, y: 4 },
+    ])
+  })
+
+  it('falls back to A* when both direct L orientations are blocked', () => {
+    const grid = createGrid()
+    placeBlock(grid, { x: 4, y: 0 }, 1)
+    placeBlock(grid, { x: 0, y: 4 }, 1)
+    const graph = makeGraph(grid, createPathBudget())
+    const path = routeEdge(
+      graph,
+      { x: 0, y: 0 },
+      { x: 4, y: 4 },
+      requireCardinalDirection(Right),
+    )
+    // Not a 3-point direct L — A* found a route around the two blockers.
+    expect(path).not.toBeNull()
+    expect(path!.length).toBeGreaterThan(3)
+    expect(path![0]).toEqual({ x: 0, y: 0 })
+    expect(path![path!.length - 1]).toEqual({ x: 4, y: 4 })
+  })
+
+  it('falls back to A* (trivial straight line) when from/to are already axis-aligned', () => {
+    const graph = makeGraph(createGrid(), createPathBudget())
+    const path = routeEdge(
+      graph,
+      { x: 0, y: 0 },
+      { x: 0, y: 6 },
+      requireCardinalDirection(Down),
+    )
+    expect(path).toEqual([
+      { x: 0, y: 0 },
+      { x: 0, y: 6 },
+    ])
+  })
+
+  it('returns null when the destination is unreachable through free cells', () => {
+    // Occupy all 4 neighbors of the destination — no legal final hop exists
+    // from any direction, so neither the direct path nor A* can reach it.
+    const grid = createGrid()
+    placeBlock(grid, { x: 9, y: 10 }, 1)
+    placeBlock(grid, { x: 11, y: 10 }, 1)
+    placeBlock(grid, { x: 10, y: 9 }, 1)
+    placeBlock(grid, { x: 10, y: 11 }, 1)
+    const graph = makeGraph(grid, createPathBudget())
+    const path = routeEdge(
+      graph,
+      { x: 0, y: 0 },
+      { x: 10, y: 10 },
+      requireCardinalDirection(Right),
+    )
+    expect(path).toBeNull()
+  })
+
+  it('throws when graph.pathBudget is not set, instead of silently searching unbudgeted', () => {
+    const graph = makeGraph(createGrid(), undefined)
+    expect(() =>
+      routeEdge(
+        graph,
+        { x: 0, y: 0 },
+        { x: 4, y: 4 },
+        requireCardinalDirection(Right),
+      ),
+    ).toThrow(/pathBudget/)
+  })
+})
+
+describe('requireCardinalDirection', () => {
+  it('passes through each of the 4 cardinal directions', () => {
+    for (const d of [Up, Down, Left, Right]) {
+      expect(requireCardinalDirection(d)).toBe(d)
+    }
+  })
+
+  it('throws for a diagonal direction', () => {
+    expect(() => requireCardinalDirection(UpperRight)).toThrow(/cardinal/)
+  })
+
+  it('throws for Middle', () => {
+    expect(() => requireCardinalDirection(Middle)).toThrow(/cardinal/)
+  })
+})

package/src/__tests__/ascii-sequence-alt-else-label.test.ts

@@ -0,0 +1,236 @@
+// ============================================================================
+// ASCII sequence diagram — alt/else block label truncation regression tests
+// (issue #352)
+//
+// The alt/loop/opt/par block's wall (bLeft/bRight) was sized purely from the
+// span of the lifelines its messages touch (plus self-arrow extent, fixed
+// for #68). Header ("alt [label]") and divider ("[else label]") text is
+// drawn starting at bLeft + 1 and hard-clipped at bRight — so a label longer
+// than that message-driven span lost its tail with no ellipsis or other
+// marker, and because the cut lands mid-word the truncated text can still
+// read as a complete (but wrong) phrase, e.g. "alt [credentials" instead of
+// "alt [credentials valid]".
+//
+// The fix measures the longest label among the block's header and every
+// divider up front and widens the wall (growing the canvas too, if needed)
+// to fit it, mirroring the self-arrow widening done for #68.
+// ============================================================================
+
+import { describe, it, expect } from 'vitest'
+import { renderMermaidASCII } from '@zombie-mermaid/ascii-renderer'
+
+describe('ASCII sequence diagrams – alt/else block labels (issue #352)', () => {
+  it('does not truncate a long alt/else label mid-word (exact issue repro)', () => {
+    const result = renderMermaidASCII(
+      `
+sequenceDiagram
+    participant A
+    participant B
+    participant C
+    alt credentials valid
+        A->>B: x
+    else credentials rejected
+        A->>B: y
+    end
+`,
+      { useAscii: false },
+    )
+
+    // Full, unclipped labels must appear.
+    expect(result).toContain('alt [credentials valid]')
+    expect(result).toContain('[credentials rejected]')
+
+    // The exact mid-word-truncated strings from the issue must be gone —
+    // checked with a trailing wall/junction character so a match against
+    // the (correct) full label's shared prefix doesn't false-positive.
+    expect(result).not.toContain('┌alt [credentials┐')
+    expect(result).not.toContain('[credentials rej┤')
+  })
+
+  it('does not let the widened wall swallow an uninvolved participant lifeline (#387)', () => {
+    // C has no messages inside the block, so widening the wall to fit the
+    // long label must push C's lifeline clear of it rather than land on
+    // top of/next to it. Before this fix, the wall's right edge landed one
+    // column past C's already-placed lifeline, drawing the block's own
+    // wall and C's lifeline back-to-back on every interior row with no gap
+    // between them — two adjacent "│" characters that read as one thing
+    // enclosing a participant the block has nothing to do with.
+    const result = renderMermaidASCII(
+      `
+sequenceDiagram
+    participant A
+    participant B
+    participant C
+    alt credentials valid
+        A->>B: x
+    else credentials rejected
+        A->>B: y
+    end
+`,
+      { useAscii: false },
+    )
+
+    for (const line of result.split('\n')) {
+      expect(line).not.toMatch(/││/)
+    }
+  })
+
+  it('leaves short labels that already fit unchanged (no regression)', () => {
+    const result = renderMermaidASCII(
+      `
+sequenceDiagram
+    participant A
+    participant B
+    participant C
+    alt yes
+        A->>B: x
+    else no
+        A->>B: y
+    end
+`,
+      { useAscii: false },
+    )
+
+    // Matches the issue's own "short labels, for reference" expected output.
+    expect(result).toContain('alt [yes]───────┐')
+    expect(result).toContain('[no]╌╌╌╌╌╌╌╌╌╌╌╌┤')
+  })
+
+  it('widens the wall for a very long single-condition label', () => {
+    const longLabel =
+      'this condition label is extremely long and needs the canvas to grow to fit it properly'
+    const result = renderMermaidASCII(
+      `
+sequenceDiagram
+    participant A
+    participant B
+    alt ${longLabel}
+        A->>B: x
+    end
+`,
+      { useAscii: false },
+    )
+
+    expect(result).toContain(`alt [${longLabel}]`)
+
+    // The header line's own right wall must close immediately after the
+    // label — proves the wall grew to fit rather than the label being cut.
+    const headerLine = result
+      .split('\n')
+      .find((l) => l.includes(`alt [${longLabel}]`))
+    expect(headerLine).toBeDefined()
+    expect(headerLine!.endsWith('┐')).toBe(true)
+  })
+
+  it('widens the wall to fit the longest of several else branches with varying label lengths', () => {
+    const result = renderMermaidASCII(
+      `
+sequenceDiagram
+    participant A
+    participant B
+    alt short
+        A->>B: w
+    else a moderately long condition
+        A->>B: x
+    else an even longer condition than the previous one
+        A->>B: y
+    else tiny
+        A->>B: z
+    end
+`,
+      { useAscii: false },
+    )
+
+    expect(result).toContain('alt [short]')
+    expect(result).toContain('[a moderately long condition]')
+    expect(result).toContain('[an even longer condition than the previous one]')
+    expect(result).toContain('[tiny]')
+
+    // None of the labels should be cut short — checked with the closing
+    // bracket so a match against the (correct) full label's shared prefix
+    // doesn't false-positive.
+    expect(result).not.toContain('[a moderately long conditio]')
+    expect(result).not.toContain('[an even longer condition than the previous]')
+  })
+
+  it('widens loop/opt block walls too, not just alt', () => {
+    const loopResult = renderMermaidASCII(
+      `
+sequenceDiagram
+    participant A
+    participant B
+    loop a fairly long loop condition label here
+        A->>B: x
+    end
+`,
+      { useAscii: false },
+    )
+    expect(loopResult).toContain(
+      'loop [a fairly long loop condition label here]',
+    )
+
+    const optResult = renderMermaidASCII(
+      `
+sequenceDiagram
+    participant A
+    participant B
+    opt a fairly long optional condition label here
+        A->>B: x
+    end
+`,
+      { useAscii: false },
+    )
+    expect(optResult).toContain(
+      'opt [a fairly long optional condition label here]',
+    )
+  })
+
+  it('handles a block with no header label at all (bare "par")', () => {
+    // `block.label` is '' (falsy) here — exercises the `block.label ? ... :
+    // block.type` branch that a labelled alt/loop never reaches.
+    const result = renderMermaidASCII(
+      `
+sequenceDiagram
+    participant A
+    participant B
+    par
+        A->>B: x
+    and
+        A->>B: y
+    end
+`,
+      { useAscii: false },
+    )
+
+    expect(result).toContain('┌par')
+    expect(result).not.toContain('par [')
+  })
+
+  it('handles a bare else divider with no label text', () => {
+    // `divider.label` is '' (falsy) here — exercises the `if (divider.label)`
+    // false branch that a labelled else never reaches.
+    const result = renderMermaidASCII(
+      `
+sequenceDiagram
+    participant A
+    participant B
+    alt some long condition that needs the wall widened
+        A->>B: x
+    else
+        A->>B: y
+    end
+`,
+      { useAscii: false },
+    )
+
+    expect(result).toContain(
+      'alt [some long condition that needs the wall widened]',
+    )
+    // The bare divider must still render as a plain divider row — checked
+    // positively (a dashed line actually exists) as well as negatively (it
+    // carries no "[...]" label of its own). The negative check alone would
+    // still pass if the renderer silently dropped the divider entirely.
+    expect(result).toMatch(/├╌+┤/)
+    expect(result).not.toMatch(/├\[.*\]/)
+  })
+})

package/src/__tests__/ascii-sequence-block-wall-clearance.test.ts

@@ -0,0 +1,217 @@
+// ============================================================================
+// ASCII sequence diagram — block-wall lifeline clearance (issue #353)
+//
+// `loop`/`alt`/`opt`/etc. share a single wall-extent calculation
+// (src/ascii/sequence.ts's "DRAW: blocks" pass): a fixed BLOCK_WALL_MARGIN
+// padding around the leftmost/rightmost lifeline the block's own messages
+// touch. That calculation only ever looks at lifelines the block's messages
+// reach — so the fixed margin could coincidentally land a wall exactly on a
+// *different*, untouched lifeline's column, subsuming it (wall glyph and
+// lifeline glyph sharing the same cell) for the block's whole vertical span.
+//
+// This bit `alt` in the issue's repro (a diagram combining `loop`, `alt`,
+// and `opt`, where only `alt` doesn't reach the diagram's rightmost
+// lifeline) while `loop`/`opt` happened to clear it, because their own
+// messages already reached that lifeline and so were naturally padded past
+// it by the same margin. It is not a per-block-type bug: all three share
+// identical wall-calculation code.
+//
+// The fix pulls a wall back short of an untouched lifeline rather than
+// pushing it past one — verified against real mermaid.js's own SVG output
+// for this exact diagram (see scripts/lib/real-mermaid.ts): `loop`/`opt`
+// there enclose `Database` because their own messages touch it directly,
+// but `alt` — which never messages `Database` — stops well short of it
+// (124px of real clearance, not a few px of overshoot), even though
+// `loop`/`opt` in the same diagram extend ~11px *past* Database's lifeline
+// to enclose it. Real mermaid never widens a block's wall to enclose a
+// lifeline its own messages don't touch. An earlier version of this test
+// asserted the opposite (`alt` should match `loop`/`opt` by enclosing
+// Database) — that was a reasonable-sounding but unverified guess at the
+// "consistent" fix; it wasn't checked against real mermaid at the time.
+// ============================================================================
+
+import { describe, it, expect } from 'vitest'
+import { renderMermaidASCII } from '@zombie-mermaid/ascii-renderer'
+
+/** Column indices (0-based) of every lifeline, read off the actor header's
+ * bottom border row (the one carrying `┬` junctions). */
+function lifelineColumns(lines: string[]): number[] {
+  const row = lines[2]!
+  const cols: number[] = []
+  for (let i = 0; i < row.length; i++) if (row[i] === '┬') cols.push(i)
+  return cols
+}
+
+/** Right-wall column of a block, read from the row containing `marker`
+ * (its own top-border/header row, e.g. "┌alt [...]" or a divider row like
+ * "├[else label]"). The block's own right corner/junction is the last
+ * box-drawing glyph on that row. */
+function blockWallRightColumn(lines: string[], marker: string): number {
+  const row = lines.find((l) => l.includes(marker))
+  expect(row, `expected a line containing "${marker}"`).toBeDefined()
+  const candidates = ['┐', '┤', '┘']
+  let col = -1
+  for (const ch of candidates) {
+    const idx = row!.lastIndexOf(ch)
+    if (idx > col) col = idx
+  }
+  expect(col, `expected a right-wall glyph on line: ${row}`).toBeGreaterThan(-1)
+  return col
+}
+
+describe('ASCII sequence diagrams – block wall lifeline clearance (issue #353)', () => {
+  it('clears the rightmost lifeline consistently across loop/alt/opt in the same diagram', () => {
+    const src = `
+sequenceDiagram
+    participant U as User
+    participant C as Client
+    participant A as Auth Service
+    participant D as Database
+
+    U->>C: click sign in
+    C->>A: POST /authorize
+
+    loop token refresh
+        A->>A: validate signature<br/>and check expiry
+        A->>D: lookup session
+        D-->>A: session row
+    end
+
+    alt credentials valid
+        A->>A: mint access token<br/>mint refresh token
+        A-->>C: 200 + tokens
+        C-->>U: redirect to app
+    else credentials rejected
+        A->>A: increment<br/>failure counter
+        A-->>C: 401 unauthorized
+        C-->>U: show error
+    end
+
+    opt remember me
+        C->>A: POST /persist
+        A->>D: store long-lived token
+    end
+`
+    const result = renderMermaidASCII(src, { useAscii: false })
+    const lines = result.split('\n')
+
+    const llCols = lifelineColumns(lines)
+    const rightmostLL = Math.max(...llCols) // Database
+    const authServiceLL = llCols[2]! // touched by alt directly
+
+    const loopRight = blockWallRightColumn(lines, 'loop [token refresh]')
+    const altRight = blockWallRightColumn(lines, 'alt [credentials valid]')
+    const optRight = blockWallRightColumn(lines, 'opt [remember me]')
+
+    // None of the three walls may land on any lifeline column — the
+    // original bug manifested as alt's right wall landing exactly on the
+    // Database lifeline's column.
+    for (const wallCol of [loopRight, altRight, optRight]) {
+      expect(llCols).not.toContain(wallCol)
+    }
+
+    // loop/opt both message Database directly, so both enclose it with
+    // clearance — matching real mermaid.
+    expect(loopRight).toBeGreaterThan(rightmostLL)
+    expect(optRight).toBeGreaterThan(rightmostLL)
+
+    // alt never messages Database — real mermaid stops alt's wall well
+    // short of it rather than widening to enclose it, so alt must NOT
+    // match loop/opt's right column here. It still clears the lifeline it
+    // does touch (Auth Service).
+    expect(altRight).toBeGreaterThan(authServiceLL)
+    expect(altRight).toBeLessThan(rightmostLL)
+    expect(altRight).not.toBe(loopRight)
+    expect(altRight).not.toBe(optRight)
+
+    // The Database lifeline must still be drawn as a lifeline (not
+    // subsumed into the alt block's wall) for a row inside the alt block's
+    // span, e.g. its "mint access token" self-arrow row.
+    const selfArrowRow = lines.find((l) => l.includes('mint access token'))
+    expect(selfArrowRow).toBeDefined()
+    expect(selfArrowRow![rightmostLL]).toBe('│')
+    // ...and that lifeline sits outside (to the right of) alt's own right
+    // wall on that row — two distinct glyphs, not one, and not enclosed.
+    expect(altRight).toBeLessThan(rightmostLL)
+  })
+
+  it('keeps a consistent right wall across every else-branch of a multi-branch alt', () => {
+    // Branch labels/content of increasing width so a wall computed only
+    // from the *first* branch (rather than reused consistently across all
+    // of them) would drift from branch to branch.
+    const src = `
+sequenceDiagram
+    participant A
+    participant B
+    participant C
+
+    alt first branch
+        A->>B: short
+    else second branch is quite a bit longer than the first
+        B->>C: also a fairly long message label here
+    else third
+        A->>A: a long self-arrow label in the third branch
+    end
+`
+    const result = renderMermaidASCII(src, { useAscii: false })
+    const lines = result.split('\n')
+    const llCols = lifelineColumns(lines)
+
+    const headerRight = blockWallRightColumn(lines, 'alt [first branch]')
+    const else1Right = blockWallRightColumn(
+      lines,
+      '[second branch is quite a bit longer than the first]',
+    )
+    const else2Right = blockWallRightColumn(lines, '[third]')
+
+    // The wall stays at the same column for the header and every divider —
+    // it must be computed once from the whole block's extent, not
+    // per-branch (which would produce a jagged/misaligned right edge).
+    expect(else1Right).toBe(headerRight)
+    expect(else2Right).toBe(headerRight)
+
+    // And, as above, it must not coincide with any lifeline column.
+    for (const wallCol of [headerRight, else1Right, else2Right]) {
+      expect(llCols).not.toContain(wallCol)
+    }
+  })
+
+  it('does not let the pulled-back wall overwrite a self-message label (CodeRabbit)', () => {
+    // A short self-arrow label on the only touched actor, with an
+    // untouched actor sitting just past the label's own extent: the
+    // pull-back fix above can compute a wall column that lands inside the
+    // self-arrow's own label span rather than after it, and the later
+    // block-border draw then silently overwrites the label's first
+    // character(s). B is untouched by the loop's only message (a self-arrow
+    // on A) and sits close enough (default lifeline spacing) to trigger the
+    // pull-back for a short label.
+    const src = `
+sequenceDiagram
+    participant A
+    participant B
+    loop x
+        A->>A: abc
+    end
+`
+    const result = renderMermaidASCII(src, { useAscii: false })
+    const lines = result.split('\n')
+
+    // The label must survive intact and contiguous — a pull-back that
+    // clips into it would replace its leading character(s) with the
+    // block's own border glyph instead.
+    const labelRow = lines.find((l) => l.includes('abc'))
+    expect(labelRow).toBeDefined()
+
+    // The block's own right wall must sit at or after the label's last
+    // column, never inside its span.
+    const llCols = lifelineColumns(lines)
+    const wallRight = blockWallRightColumn(lines, 'loop [x]')
+    const labelEndCol = labelRow!.lastIndexOf('abc') + 'abc'.length - 1
+    expect(wallRight).toBeGreaterThanOrEqual(labelEndCol)
+    // ...and strictly before B's own column — not just "not exactly on
+    // it," which would also pass if the wall were pushed past B instead
+    // (enclosing the untouched lifeline, the opposite regression this
+    // suite exists to catch).
+    expect(wallRight).toBeLessThan(llCols[1]!)
+  })
+})