@zombie-mermaid/ascii-renderer 2.2.1

package/src/__tests__/ascii-class-cross-level-jog-corruption.test.ts

@@ -0,0 +1,187 @@
+// ============================================================================
+// ASCII class diagram — cross-level connector jog corrupting an intervening
+// box's text
+//
+// Discovered incidentally while writing ascii-class-box-occupancy.test.ts's
+// coverage for issue #953/PR #957 (the *same-level* relationship cycle's
+// detour line lacking an occupancy guard). This is a distinct bug in a
+// different branch of src/ascii/class-diagram.ts's relationship-drawing
+// pass — the "target is below source" (and, by the same missing guard,
+// "target is above source") branch, used whenever a relationship's two
+// classes land on different levels.
+//
+// That branch's "no collision" routing draws a straight horizontal jog
+// connecting the source's lane column to the target's lane column at some
+// row between them. The *only* check that decided this was safe to draw
+// without a detour (`findClearColumn`) tests whether the source's own lane
+// column is itself clear of boxes across the full row range — it says
+// nothing about whether the horizontal jog's row is clear all the way over
+// to the target's column. When a class ends up positioned far from its
+// actual parent's column — e.g. a level's only child is always placed at
+// the leftmost slot regardless of which sibling at the level above is its
+// parent — and a *different*, taller same-level sibling's box sits between
+// those two columns, the jog cuts straight through that sibling's box,
+// silently replacing whichever attribute/method row it crosses.
+//
+// Fixed by giving src/ascii/class-diagram.ts the same kind of box-occupancy
+// guard (`boxCells`/`setCGuarded`) src/ascii/er-diagram.ts already has for
+// issue #350, scoped to the cross-level branches only — the same-level
+// branch's own detour (PR #957's scope) is untouched here.
+// ============================================================================
+
+import { describe, it, expect } from 'vitest'
+import { renderMermaidASCII } from '@zombie-mermaid/ascii-renderer'
+import { findBoxRect, rectsOverlap } from './helpers/ascii-form.ts'
+
+function expectNoBoxOverlap(ascii: string, names: string[]): void {
+  const rects = names.map((n) => ({ n, r: findBoxRect(ascii, n) }))
+  for (let i = 0; i < rects.length; i++) {
+    for (let j = i + 1; j < rects.length; j++) {
+      expect(
+        rectsOverlap(rects[i]!.r, rects[j]!.r),
+        `${rects[i]!.n} and ${rects[j]!.n} boxes overlap`,
+      ).toBe(false)
+    }
+  }
+}
+
+function manyAttrs(prefix: string, count: number): string {
+  return Array.from(
+    { length: count },
+    (_, i) => `    +String ${prefix}${i}`,
+  ).join('\n')
+}
+
+/** Assert every one of `needles` appears verbatim, exactly once, in `text`. */
+function expectAllPresentOnce(text: string, needles: string[]): void {
+  for (const needle of needles) {
+    const count = text.split(needle).length - 1
+    expect(count, `expected "${needle}" to appear exactly once`).toBe(1)
+  }
+}
+
+describe('ASCII class diagrams — cross-level connector jog never corrupts a box', () => {
+  it('root-level sibling sits between a source and its far-off, sole child (minimal repro)', () => {
+    // Left/TallMid/RightSrc are three unrelated level-0 roots (no cycle
+    // involved, unlike the original report — isolates this bug from the
+    // separately-tracked same-level detour issue). Kid is RightSrc's only
+    // child, so it lands at the leftmost slot of level 1 regardless of
+    // RightSrc's own (rightmost) column — the "no collision" routing then
+    // has to jog the whole width of the canvas, straight through TallMid.
+    const src = `classDiagram
+  class Left
+  class TallMid {
+${manyAttrs('b', 6)}
+  }
+  class RightSrc
+  class Kid
+  RightSrc --> Kid`
+    const ascii = renderMermaidASCII(src, { useAscii: true })
+    expectAllPresentOnce(ascii, [
+      '+ b0: String',
+      '+ b1: String',
+      '+ b2: String',
+      '+ b3: String',
+      '+ b4: String',
+      '+ b5: String',
+    ])
+    expectNoBoxOverlap(ascii, ['Left', 'TallMid', 'RightSrc', 'Kid'])
+  })
+
+  it('originally-reported repro: same-level cycle plus an unrelated root/child pair', () => {
+    // The exact topology this bug was first reported against. Alpha/Mid/
+    // Charlie form a same-level relationship cycle (falls to level 0 via
+    // the level-BFS's "no root" fallback); Root is a genuine level-0 root
+    // (declared after the cycle) with its own child Kid at level 1. Only
+    // "+ b4: String" is asserted here — the cross-level bug this file
+    // covers. "+ b1: String" is a *separate*, already-tracked corruption
+    // (the same-level cycle's own detour, issue #953/PR #957) and is
+    // deliberately not asserted on so this suite stays independent of
+    // that fix landing.
+    const src = `classDiagram
+  class Alpha
+  class Mid {
+${manyAttrs('b', 6)}
+  }
+  class Charlie
+  class Root
+  class Kid
+  Alpha --> Mid
+  Mid --> Charlie
+  Charlie --> Alpha
+  Root --> Kid`
+    const ascii = renderMermaidASCII(src, { useAscii: true })
+    expect(
+      ascii,
+      '"+ b4: String" was overwritten by Root->Kid\'s jog',
+    ).toContain('+ b4: String')
+  })
+
+  it('deeper tree: a tall level-0 sibling between a level-1 source and its level-2 grandchild', () => {
+    const src = `classDiagram
+  class A
+  class TallMid {
+${manyAttrs('b', 6)}
+  }
+  class B
+  class Kid1
+  class GrandKid
+  B --> Kid1
+  Kid1 --> GrandKid`
+    const ascii = renderMermaidASCII(src, { useAscii: true })
+    expectAllPresentOnce(ascii, [
+      '+ b0: String',
+      '+ b1: String',
+      '+ b2: String',
+      '+ b3: String',
+      '+ b4: String',
+      '+ b5: String',
+    ])
+    expectNoBoxOverlap(ascii, ['A', 'TallMid', 'B', 'Kid1', 'GrandKid'])
+  })
+
+  it('more siblings: several unrelated roots plus a separate parent/child pair, inheritance marker', () => {
+    const src = `classDiagram
+  class Left
+  class TallMid {
+${manyAttrs('d', 6)}
+  }
+  class RightSrc
+  class Kid
+  RightSrc <|-- Kid`
+    const ascii = renderMermaidASCII(src, { useAscii: true })
+    expectAllPresentOnce(ascii, [
+      '+ d0: String',
+      '+ d1: String',
+      '+ d2: String',
+      '+ d3: String',
+      '+ d4: String',
+      '+ d5: String',
+    ])
+    expectNoBoxOverlap(ascii, ['Left', 'TallMid', 'RightSrc', 'Kid'])
+  })
+
+  it('"target above source" branch with a from-side marker renders without corrupting a box', () => {
+    // The "above" branch (this file's second `else if`) has no
+    // findClearColumn collision-avoidance at all — it always draws the
+    // straight jog/vertical/horizontal/vertical/jog path, so it's just as
+    // exposed to this bug as the "below" branch, and is guarded the same
+    // way here. A `Root --> A` / `A <|-- B` / `B --> A` back-edge forces
+    // A's level above B's (the level-assignment BFS keeps the *longest*
+    // path to a node, so B->A's back edge pushes A past B) — the
+    // `A <|-- B` edge then runs from the now-deeper A up to the
+    // shallower B, taking the "above" branch with its hollow-triangle
+    // marker at the 'from' end (A), a combination no other test in this
+    // file exercises.
+    const src = `classDiagram
+  class Root
+  class A
+  class B
+  class Extra
+  Root --> A
+  A <|-- B
+  B --> A`
+    const ascii = renderMermaidASCII(src, { useAscii: true })
+    expectNoBoxOverlap(ascii, ['Root', 'A', 'B', 'Extra'])
+  })
+})

package/src/__tests__/ascii-class-detour-label-routing-487.test.ts

@@ -0,0 +1,114 @@
+/**
+ * Regression test for #487 — "ASCII class diagram: relationship labels
+ * ignore detour routing, appear attached to wrong box."
+ *
+ * Root cause: `renderClassAscii` anchored every relationship's label at the
+ * *idealized straight-line* midpoint between its source and target
+ * connection columns (`idealMidX = Math.floor((fromCX + toCX) / 2)`), even
+ * when the relationship's line actually detours around an intermediate box
+ * (the `needsDetour` / `findClearColumn` branch). On the "Class: MVC
+ * Architecture" sample, `Controller --> View : refreshes` detours around
+ * `Model` to reach `View`, but its label still anchored on the straight
+ * Controller/View midpoint — which happened to coincide with
+ * `Controller --> Model : updates`'s own (non-detoured, correct) label one
+ * row below it, making both labels read as though they terminated at
+ * `Model`.
+ *
+ * The fix (`computeLabelAnchor` in `class-diagram.ts`) anchors a detoured
+ * relationship's label on its *actual routed path* instead: the midpoint of
+ * the detour's vertical trunk (falling back to the longer horizontal jog
+ * when the trunk has no vertical room), flush against the trunk's clear
+ * side rather than centered on it — centering a label on the trunk's single
+ * clear column would re-overlap the very box the trunk was routed around,
+ * since `findClearColumn` only guarantees that one column is clear, not a
+ * whole label-width window.
+ */
+
+import { describe, it, expect } from 'vitest'
+import { renderMermaidASCII } from '@zombie-mermaid/ascii-renderer'
+import { findBoxRect } from './helpers/ascii-form.ts'
+
+const MVC_SOURCE = `classDiagram
+  class Model {
+    -data Map
+    +getData() Map
+    +setData(key, val) void
+    +notify() void
+  }
+  class View {
+    -model Model
+    +render() void
+    +update() void
+  }
+  class Controller {
+    -model Model
+    -view View
+    +handleInput(event) void
+    +updateModel(data) void
+  }
+  Controller --> Model : updates
+  Controller --> View : refreshes
+  View --> Model : reads
+  Model ..> View : notifies`
+
+describe('ASCII class diagram — detour-aware relationship label placement (issue #487)', () => {
+  it("places `refreshes` on its own row, off `updates`'s arrowhead column", () => {
+    const ascii = renderMermaidASCII(MVC_SOURCE, { colorMode: 'none' })
+    const lines = ascii.split('\n')
+
+    const updatesRow = lines.findIndex((l) => l.includes('updates'))
+    const refreshesRow = lines.findIndex((l) => l.includes('refreshes'))
+    expect(updatesRow).toBeGreaterThanOrEqual(0)
+    expect(refreshesRow).toBeGreaterThanOrEqual(0)
+
+    // Before the fix, both labels sat on adjacent rows directly above the
+    // single arrowhead entering Model, reading as though both relationships
+    // terminated there. `refreshes` must not share `updates`'s column range
+    // (the sole visual cue, pre-fix, that made them look like the same
+    // termination) on any row, and in particular not on `updates`'s own row.
+    expect(refreshesRow).not.toBe(updatesRow)
+
+    const updatesLine = lines[updatesRow]!
+    const updatesStart = updatesLine.indexOf('updates')
+    const updatesEnd = updatesStart + 'updates'.length - 1
+
+    const refreshesLine = lines[refreshesRow]!
+    const refreshesStart = refreshesLine.indexOf('refreshes')
+    const refreshesEnd = refreshesStart + 'refreshes'.length - 1
+
+    // No column overlap between the two labels anywhere they might appear.
+    const overlapsColumns =
+      refreshesStart <= updatesEnd && updatesStart <= refreshesEnd
+    expect(overlapsColumns).toBe(false)
+  })
+
+  it("anchors `refreshes` past Model's right border, not centered inside its footprint", () => {
+    const ascii = renderMermaidASCII(MVC_SOURCE, { colorMode: 'none' })
+    const lines = ascii.split('\n')
+
+    // Model's box right edge (column-based, not a literal-column-0
+    // assumption — issue #971 can legitimately shift Model's own column
+    // when it has a real single qualifying parent to align under, same as
+    // it does here against Controller). `refreshes` — the label for the
+    // relationship that detours around Model to reach View — must land
+    // strictly to the right of that edge on every row it occupies, never
+    // overlapping Model's own footprint the way the straight-line midpoint
+    // used to (issue #487).
+    const modelRect = findBoxRect(ascii, 'Model')
+    const modelRightBorder = modelRect.x1
+    expect(modelRightBorder).toBeGreaterThan(0)
+
+    const refreshesRow = lines.findIndex((l) => l.includes('refreshes'))
+    expect(refreshesRow).toBeGreaterThanOrEqual(0)
+    const refreshesStart = lines[refreshesRow]!.indexOf('refreshes')
+    expect(refreshesStart).toBeGreaterThan(modelRightBorder)
+  })
+
+  it('does not move any non-detoured relationship label (reads, notifies, updates stay put)', () => {
+    const ascii = renderMermaidASCII(MVC_SOURCE, { colorMode: 'none' })
+    for (const label of ['updates', 'reads', 'notifies', 'refreshes']) {
+      expect(ascii).toContain(label)
+    }
+    expect(ascii).not.toContain('…')
+  })
+})

package/src/__tests__/ascii-class-diagram-compartments.test.ts

@@ -0,0 +1,70 @@
+// ============================================================================
+// ASCII class diagram compartment tests (issue #87)
+// ============================================================================
+
+import { describe, it, expect } from 'vitest'
+import { renderMermaidASCII } from '@zombie-mermaid/ascii-renderer'
+
+describe('ASCII class diagram box compartments', () => {
+  it('omits the attrs compartment for a class with methods but no attributes (regression)', () => {
+    // Before the fix, buildClassSections() always returned a 3-section box
+    // once methods were non-empty, even with zero attrs — drawMultiBox then
+    // rendered that empty section as a visible blank compartment.
+    const ascii = renderMermaidASCII(
+      `classDiagram
+        class Animal {
+          +makeSound()
+        }`,
+      { useAscii: true },
+    )
+    const lines = ascii.split('\n').filter((l) => l.trim().length > 0)
+    // A box with N sections has N+1 horizontal border lines (top, N-1
+    // internal dividers, bottom). 2 sections (header + methods) -> 3.
+    const dividerCount = lines.filter((l) => /^\+-+\+$/.test(l.trim())).length
+    expect(dividerCount).toBe(3)
+    expect(ascii).toContain('makeSound')
+    expect(ascii).not.toMatch(/\|\s*\|\n\+-+\+\n\|\s*\+makeSound/)
+  })
+
+  it('omits the methods compartment for a class with attrs but no methods (no regression)', () => {
+    const ascii = renderMermaidASCII(
+      `classDiagram
+        class Point {
+          +int x
+        }`,
+      { useAscii: true },
+    )
+    expect(ascii).toContain('x')
+    const lines = ascii.split('\n').filter((l) => l.trim().length > 0)
+    const dividerCount = lines.filter((l) => /^\+-+\+$/.test(l.trim())).length
+    expect(dividerCount).toBe(3)
+  })
+
+  it('renders both compartments for a class with attrs and methods', () => {
+    const ascii = renderMermaidASCII(
+      `classDiagram
+        class Circle {
+          +radius int
+          +draw() void
+        }`,
+      { useAscii: true },
+    )
+    expect(ascii).toContain('radius')
+    expect(ascii).toContain('draw')
+    const lines = ascii.split('\n').filter((l) => l.trim().length > 0)
+    const dividerCount = lines.filter((l) => /^\+-+\+$/.test(l.trim())).length
+    expect(dividerCount).toBe(4)
+  })
+
+  it('renders header only for a class with neither attrs nor methods', () => {
+    const ascii = renderMermaidASCII(
+      `classDiagram
+        class Empty`,
+      { useAscii: true },
+    )
+    expect(ascii).toContain('Empty')
+    const lines = ascii.split('\n').filter((l) => l.trim().length > 0)
+    const dividerCount = lines.filter((l) => /^\+-+\+$/.test(l.trim())).length
+    expect(dividerCount).toBe(2)
+  })
+})

package/src/__tests__/ascii-class-label-box-collision.test.ts

@@ -0,0 +1,60 @@
+/**
+ * Regression test for a pre-existing, previously-untested branch in
+ * `renderClassAscii`'s label placement: when a relationship's label would
+ * land inside another class's box (e.g. a "skip" edge whose two endpoints
+ * straddle a third class positioned between them), the renderer must find
+ * a clear gap instead of overwriting that box's content.
+ *
+ * `A --> C : skips`, with `B` (from the unrelated `A --> B --> C` chain)
+ * positioned directly between them, puts `skips`'s ideal label position
+ * inside B's box — this covers `renderClassAscii`'s `labelInBox` /
+ * gap-search fallback.
+ *
+ * Since #487's detour-aware label placement, `skips` (which detours around
+ * B) anchors on its own detour trunk — a column past B's right border —
+ * rather than searching for an entirely box-free *row*. That can legitimately
+ * put the label on the same terminal row as one of B's content lines (the
+ * same pattern the MVC sample's `refreshes` label uses, sharing a row with
+ * Model's compartment separator), as long as it never overlaps B's own
+ * *columns* — this test now checks that non-overlap directly instead of
+ * requiring a different row entirely.
+ */
+
+import { describe, it, expect } from 'vitest'
+import { renderMermaidASCII } from '@zombie-mermaid/ascii-renderer'
+
+describe('ASCII class diagram — label collision with an intermediate box', () => {
+  it('moves a skip-edge label out of an intermediate class box instead of overwriting it', () => {
+    const ascii = renderMermaidASCII(
+      `classDiagram
+  class A
+  class B
+  class C
+  A --> B
+  B --> C
+  A --> C : skips`,
+      { colorMode: 'none' },
+    )
+
+    const lines = ascii.split('\n')
+    const labelRow = lines.findIndex((l) => l.includes('skips'))
+    expect(labelRow).toBeGreaterThanOrEqual(0)
+
+    // B's box must still render intact — "B" itself, and both of its box
+    // borders — nowhere overwritten by the "skips" label text: wherever the
+    // label lands (even on the same row as one of B's own lines), its
+    // columns must fall entirely outside B's box columns.
+    const bRow = lines.findIndex((l) => l.includes('│ B │'))
+    expect(bRow).toBeGreaterThanOrEqual(0)
+    const bLine = lines[bRow]!
+    const bBoxStart = bLine.indexOf('│ B │')
+    const bBoxEnd = bBoxStart + '│ B │'.length - 1
+
+    const labelLine = lines[labelRow]!
+    const labelStart = labelLine.indexOf('skips')
+    const labelEnd = labelStart + 'skips'.length - 1
+    const overlapsOnSharedRow =
+      labelRow === bRow && labelStart <= bBoxEnd && bBoxStart <= labelEnd
+    expect(overlapsOnSharedRow).toBe(false)
+  })
+})

package/src/__tests__/ascii-class-label-row-collision-531.test.ts

@@ -0,0 +1,135 @@
+/**
+ * Regression test for issue #531: at a small enough `paddingY`, a
+ * relationship label could vanish from ASCII class-diagram output with no
+ * error, no ellipsis, and no trace.
+ *
+ * Root cause: `renderClassAscii` resolves each relationship label's row in
+ * two independent places. `computeLabelAnchor` gives a label a "raw" ideal
+ * row (`baseMidY`). If that row lands inside a box, a runtime fallback (the
+ * "box-gap scan") searches the from/to gap for the nearest row that is at
+ * least clear of boxes, and the draw pass uses whatever row the fallback
+ * picked. Separately, a horizontal-territory precompute (added for issue
+ * #447, to stop two same-row labels from overwriting each other) decides
+ * which labels need X-territory splitting by comparing each pair's row
+ * bands — but it computed those bands from the *raw* `baseMidY`, before the
+ * box-gap-scan fallback could move a label to a completely different row.
+ * Two relationships whose *ideal* rows never overlapped could still both
+ * resolve, via the fallback, to the *same actual* row — invisibly to the
+ * territory precompute, which never split their columns because it never
+ * saw them as colliding. The later relationship's unconditional `setC`
+ * write then silently overwrote the earlier one's already-drawn label.
+ *
+ * A second, related gap: even once territory rowStart/rowEnd values reflect
+ * the real (post-fallback) row, the split algorithm only ever compared a
+ * label against its immediate neighbor by `idealMidX` order. When a third
+ * label — on a different, non-colliding row — happened to sit between two
+ * same-row colliding labels in `idealMidX` order, the pair that actually
+ * needed splitting was never adjacent in that order and so was never
+ * compared at all.
+ *
+ * The fix (`resolveLabelFinalY` in class-diagram.ts) resolves each label's
+ * final row once, up front, and both the territory precompute and the draw
+ * pass reuse that single resolved value — so they can never disagree.
+ * Territory splitting also now scans outward for the nearest row-*actually*-
+ * overlapping neighbor instead of stopping at the immediate one. Neither
+ * fix is specific to detour routing (issue #487/#489's "route around an
+ * intermediate box" mechanism): the second test below reproduces the same
+ * silent-drop failure with a diagram where no relationship detours at all,
+ * confirming the bug (and the fix) live in the general label-placement
+ * mechanism, not the detour-trunk logic.
+ */
+
+import { describe, it, expect } from 'vitest'
+import { renderMermaidASCII } from '@zombie-mermaid/ascii-renderer'
+
+/** paddingY values below the default (5) that the issue found all reproduce
+ * the same corruption — the vertical gap floors at 1 row, so nothing about
+ * it changes at more extreme negative values. */
+const tightPaddingYValues = [4, 3, 2, 1, 0, -1, -5, -10]
+
+describe('ASCII class diagram — relationship label row collision (issue #531)', () => {
+  describe("detour-involving repro (the issue's own minimal repro)", () => {
+    const src = `classDiagram
+  class Model
+  class View
+  class Controller
+  Controller --> Model : updates
+  Controller --> View : refreshes
+  View --> Model : reads
+  Model ..> View : notifies`
+
+    it('renders every label in full at the default paddingY', () => {
+      const out = renderMermaidASCII(src, { colorMode: 'none' })
+      expect(out).toContain('updates')
+      expect(out).toContain('refreshes')
+      expect(out).toContain('reads')
+      expect(out).toContain('notifies')
+    })
+
+    it.each(tightPaddingYValues)(
+      'never silently drops a label at paddingY=%d',
+      (paddingY) => {
+        const out = renderMermaidASCII(src, { colorMode: 'none', paddingY })
+
+        // Three of the four labels have room to render in full regardless.
+        expect(out).toContain('updates')
+        expect(out).toContain('reads')
+        expect(out).toContain('notifies')
+
+        // `refreshes` shares a row with `updates` at this tight spacing and
+        // must yield some of its width via territory-splitting/truncation
+        // (issue #447's established, accepted behavior for genuinely
+        // insufficient space) — but it must never disappear *entirely* the
+        // way it (or `updates`, depending on exact geometry) did before the
+        // fix. Assert the real invariant rather than pinning the exact
+        // truncated glyphs: the row that carries `updates` must carry some
+        // non-blank content besides it, where the old bug left nothing.
+        const line = out.split('\n').find((l) => l.includes('updates'))
+        expect(line).toBeDefined()
+        const withoutUpdates = line!.replace('updates', '').trim()
+        expect(withoutUpdates.length).toBeGreaterThan(0)
+      },
+    )
+  })
+
+  describe('non-detour repro (general mechanism, no detour routing involved)', () => {
+    // A -> B, B -> C (adjacent, direct) plus A -> C (a "skip" relationship
+    // whose direct straight-line midpoint lands inside B's box, triggering
+    // the same box-gap-scan fallback purely from vertical box geometry —
+    // no relationship here ever detours horizontally). Confirms the bug (and
+    // the fix) are independent of the #487/#489 detour-trunk logic, per the
+    // issue's own "Scope note".
+    const src = `classDiagram
+  class A
+  class B
+  class C
+  A --> B : sib1
+  B --> C : sib2
+  A --> C : longlabelhere`
+
+    it('renders every label in full at the default paddingY', () => {
+      const out = renderMermaidASCII(src, { colorMode: 'none' })
+      expect(out).toContain('sib1')
+      expect(out).toContain('sib2')
+      expect(out).toContain('longlabelhere')
+    })
+
+    it.each(tightPaddingYValues)(
+      'never silently drops a label at paddingY=%d',
+      (paddingY) => {
+        const out = renderMermaidASCII(src, { colorMode: 'none', paddingY })
+
+        expect(out).toContain('sib1')
+        expect(out).toContain('sib2')
+
+        // `longlabelhere` shares a row with `sib1` at this tight spacing and
+        // gets truncated rather than disappearing outright — see the note
+        // in the sibling describe block above.
+        const line = out.split('\n').find((l) => l.includes('sib1'))
+        expect(line).toBeDefined()
+        const withoutSib1 = line!.replace('sib1', '').trim()
+        expect(withoutSib1.length).toBeGreaterThan(0)
+      },
+    )
+  })
+})

package/src/__tests__/ascii-class-label-territory-row-awareness.test.ts

@@ -0,0 +1,57 @@
+/**
+ * Regression test for a bug discovered while integrating issue #447 with
+ * issue #448: `renderClassAscii`'s label-territory precomputation
+ * (added for #447) split/truncated two labels whenever their *horizontal*
+ * positions were close, even when the two relationships render on
+ * completely different rows and never actually visually collide — e.g.
+ * one class's two separate outgoing edges to two different targets at
+ * different heights (`Controller --> Model : updates` and
+ * `Controller --> View : refreshes` in the "Class: MVC Architecture"
+ * sample, which — before this fix — rendered as `refre…`/`…ates` even
+ * though nothing else was drawn anywhere near those cells).
+ *
+ * The fix tracks each label's row span (rowStart/rowEnd, mirroring the
+ * draw pass's own baseMidY calculation) and only treats two labels as
+ * needing territory-splitting when their row spans actually overlap.
+ */
+
+import { describe, it, expect } from 'vitest'
+import { renderMermaidASCII } from '@zombie-mermaid/ascii-renderer'
+
+describe('ASCII class diagram — label territory is row-aware (issue #447 follow-up)', () => {
+  it('does not truncate two labels whose relationships share a source but target different, differently-positioned classes', () => {
+    // Uses the full "Class: MVC Architecture" sample source (samples-data.ts)
+    // — reproducing this needs its exact box layout; a hand-trimmed subset
+    // (e.g. dropping the `reads`/`notifies` pair) shifts row positions
+    // enough that `updates`/`refreshes` no longer collide, defeating the
+    // regression check.
+    const ascii = renderMermaidASCII(
+      `classDiagram
+  class Model {
+    -data Map
+    +getData() Map
+    +setData(key, val) void
+    +notify() void
+  }
+  class View {
+    -model Model
+    +render() void
+    +update() void
+  }
+  class Controller {
+    -model Model
+    -view View
+    +handleInput(event) void
+    +updateModel(data) void
+  }
+  Controller --> Model : updates
+  Controller --> View : refreshes
+  View --> Model : reads
+  Model ..> View : notifies`,
+      { colorMode: 'none' },
+    )
+
+    expect(ascii).toContain('updates')
+    expect(ascii).toContain('refreshes')
+  })
+})