zombie-mermaid 2.2.3 → 2.2.6

package/src/__tests__/color-utils.test.ts

@@ -1,186 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import {
-  parseCssColor,
-  parseHexColor,
-  mixSrgb,
-  mixHexColors,
-  formatCssColor,
-} from '@zombie-mermaid/core'
-
-describe('parseCssColor', () => {
-  it('parses 3/4/6/8-digit hex, expanding shorthand and reading alpha', () => {
-    expect(parseCssColor('#fff')).toEqual({ r: 255, g: 255, b: 255, a: 1 })
-    expect(parseCssColor('#f008')).toEqual({
-      r: 255,
-      g: 0,
-      b: 0,
-      a: 0x88 / 255,
-    })
-    expect(parseCssColor('#27272A')).toEqual({ r: 39, g: 39, b: 42, a: 1 })
-    expect(parseCssColor('#00000080')).toEqual({
-      r: 0,
-      g: 0,
-      b: 0,
-      a: 0x80 / 255,
-    })
-  })
-
-  it('parses rgb()/rgba() in legacy comma and modern space syntax', () => {
-    expect(parseCssColor('rgb(1, 2, 3)')).toEqual({ r: 1, g: 2, b: 3, a: 1 })
-    expect(parseCssColor('rgba(1, 2, 3, 0.5)')).toEqual({
-      r: 1,
-      g: 2,
-      b: 3,
-      a: 0.5,
-    })
-    expect(parseCssColor('rgb(10 20 30 / 50%)')).toEqual({
-      r: 10,
-      g: 20,
-      b: 30,
-      a: 0.5,
-    })
-    expect(parseCssColor('rgb(100%, 0%, 50%)')).toEqual({
-      r: 255,
-      g: 0,
-      b: 127.5,
-      a: 1,
-    })
-  })
-
-  it('parses the transparent keyword', () => {
-    expect(parseCssColor('transparent')).toEqual({ r: 0, g: 0, b: 0, a: 0 })
-    expect(parseCssColor('  Transparent ')).toEqual({ r: 0, g: 0, b: 0, a: 0 })
-  })
-
-  it('returns null for anything it cannot evaluate rather than guessing', () => {
-    expect(parseCssColor('var(--fg)')).toBeNull()
-    expect(parseCssColor('red')).toBeNull()
-    expect(parseCssColor('hsl(0 100% 50%)')).toBeNull()
-    expect(parseCssColor('#ggg')).toBeNull()
-    expect(parseCssColor('color-mix(in srgb, #000, #fff)')).toBeNull()
-    expect(parseCssColor('')).toBeNull()
-  })
-
-  it('returns null when a channel matches the token pattern but is not a valid number', () => {
-    // RGB_FUNC_RE's channel class (`[\d.]+%?`) accepts any run of digits
-    // and dots, including a malformed one like "1.2.3" — it isn't trying
-    // to fully validate number syntax, just to find the token boundaries.
-    // Number("1.2.3") is NaN, so this must be rejected downstream rather
-    // than producing a color with a NaN channel.
-    expect(parseCssColor('rgb(1.2.3, 0, 0)')).toBeNull()
-    expect(parseCssColor('rgba(0, 0, 0, 1.2.3)')).toBeNull()
-  })
-})
-
-describe('parseHexColor', () => {
-  it('returns RGB tuple for hex literals and null otherwise', () => {
-    expect(parseHexColor('#abc')).toEqual([170, 187, 204])
-    expect(parseHexColor('#aabbccdd')).toEqual([170, 187, 204])
-    expect(parseHexColor('rgb(1,2,3)')).toBeNull()
-  })
-})
-
-describe('mixSrgb', () => {
-  const black = { r: 0, g: 0, b: 0, a: 1 }
-  const white = { r: 255, g: 255, b: 255, a: 1 }
-  const transparent = { r: 0, g: 0, b: 0, a: 0 }
-
-  it('defaults to 50/50 when both percentages are omitted', () => {
-    expect(mixSrgb(black, white)).toEqual({
-      r: 127.5,
-      g: 127.5,
-      b: 127.5,
-      a: 1,
-    })
-  })
-
-  it('infers the omitted percentage as 100 minus the given one', () => {
-    expect(mixSrgb(black, white, 25)).toEqual({
-      r: 191.25,
-      g: 191.25,
-      b: 191.25,
-      a: 1,
-    })
-    expect(mixSrgb(black, white, undefined, 25)).toEqual({
-      r: 63.75,
-      g: 63.75,
-      b: 63.75,
-      a: 1,
-    })
-  })
-
-  it('normalizes percentages that sum to more than 100', () => {
-    // 150 + 50 → 75% / 25%
-    expect(mixSrgb(black, white, 150, 50)).toEqual({
-      r: 63.75,
-      g: 63.75,
-      b: 63.75,
-      a: 1,
-    })
-  })
-
-  it('scales alpha by the sum when percentages sum to less than 100', () => {
-    // 25 + 25 → 50/50 blend at alpha 0.5
-    expect(mixSrgb(black, white, 25, 25)).toEqual({
-      r: 127.5,
-      g: 127.5,
-      b: 127.5,
-      a: 0.5,
-    })
-  })
-
-  it('interpolates in premultiplied alpha, so fading toward transparent keeps the hue', () => {
-    const red = { r: 255, g: 0, b: 0, a: 1 }
-    const mixed = mixSrgb(red, transparent, 20)
-    expect(mixed).toEqual({ r: 255, g: 0, b: 0, a: 0.2 })
-  })
-
-  it('returns null when both percentages are zero (invalid per spec)', () => {
-    expect(mixSrgb(black, white, 0, 0)).toBeNull()
-  })
-
-  it('mixes two fully-transparent colors without dividing by zero alpha', () => {
-    // Both inputs have alpha 0, so the result's premultiplied alpha is also
-    // 0 — premul's `alpha === 0 ? 0 : …` guard must short-circuit rather
-    // than compute `0/0` (NaN) for each channel.
-    const transparentRed = { r: 255, g: 0, b: 0, a: 0 }
-    const transparentBlue = { r: 0, g: 0, b: 255, a: 0 }
-    expect(mixSrgb(transparentRed, transparentBlue, 50, 50)).toEqual({
-      r: 0,
-      g: 0,
-      b: 0,
-      a: 0,
-    })
-  })
-})
-
-describe('mixHexColors', () => {
-  it('mixes fg into bg at the given percentage, matching the ASCII bridge’s historical math', () => {
-    // 0*.5 + 255*.5 = 127.5 → rounds to 128 = 0x80
-    expect(mixHexColors('#000000', '#ffffff', 50)).toBe('#808080')
-    // 0*.85 + 255*.15 = 38.25 → 38 = 0x26
-    expect(mixHexColors('#000000', '#ffffff', 85)).toBe('#262626')
-  })
-
-  it('returns fg unchanged when either side is not a concrete color', () => {
-    expect(mixHexColors('var(--fg)', '#fff', 50)).toBe('var(--fg)')
-    expect(mixHexColors('#000', 'var(--bg)', 50)).toBe('#000')
-  })
-})
-
-describe('formatCssColor', () => {
-  it('emits #rrggbb for opaque colors and rgba() otherwise', () => {
-    expect(formatCssColor({ r: 255, g: 0, b: 128, a: 1 })).toBe('#ff0080')
-    expect(formatCssColor({ r: 39, g: 39, b: 42, a: 0.2 })).toBe(
-      'rgba(39, 39, 42, 0.2)',
-    )
-  })
-
-  it('rounds channels and clamps out-of-range values', () => {
-    expect(formatCssColor({ r: 127.5, g: -3, b: 300, a: 1 })).toBe('#8000ff')
-    expect(formatCssColor({ r: 0, g: 0, b: 0, a: 1.5 })).toBe('#000000')
-    expect(formatCssColor({ r: 0, g: 0, b: 0, a: 0.33333 })).toBe(
-      'rgba(0, 0, 0, 0.333)',
-    )
-  })
-})

package/src/__tests__/diagram-type.test.ts

@@ -1,28 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { detectDiagramType } from '@zombie-mermaid/core'
-
-describe('detectDiagramType', () => {
-  it('detects each diagram type from its header keyword', () => {
-    expect(detectDiagramType('flowchart TD\nA-->B')).toBe('flowchart')
-    expect(detectDiagramType('sequenceDiagram\nA->>B: Hi')).toBe('sequence')
-    expect(detectDiagramType('classDiagram\nclass Foo')).toBe('class')
-    expect(detectDiagramType('erDiagram\nFOO ||--o{ BAR : has')).toBe('er')
-    expect(detectDiagramType('xychart-beta\nx-axis [a, b]')).toBe('xychart')
-  })
-
-  it('isolates the header on a semicolon-separated single line', () => {
-    expect(detectDiagramType('sequenceDiagram;A->>B: Hi')).toBe('sequence')
-    expect(detectDiagramType('classDiagram;class Foo')).toBe('class')
-    expect(detectDiagramType('erDiagram;FOO ||--o{ BAR : has')).toBe('er')
-    expect(detectDiagramType('flowchart TD;A-->B')).toBe('flowchart')
-  })
-
-  it('does not match an xychart header with an unsupported suffix', () => {
-    expect(detectDiagramType('xychart-foo\nx-axis [a, b]')).toBe('flowchart')
-  })
-
-  it('falls back to flowchart for unrecognized input', () => {
-    expect(detectDiagramType('')).toBe('flowchart')
-    expect(detectDiagramType('not a real header')).toBe('flowchart')
-  })
-})

package/src/__tests__/draw-lines.test.ts

@@ -1,93 +0,0 @@
-/**
- * Direct unit tests for drawLine's diagonal routing branches
- * (UpperLeft/UpperRight/LowerLeft/LowerRight in src/ascii/draw-lines.ts).
- *
- * These branches only fire when `from` and `to` differ on both axes.
- * Every real call site (draw-arrows.ts's drawPath, draw-bundles.ts) feeds
- * drawLine coordinates derived from an A* grid path — and the pathfinder
- * only ever moves 4-directionally (see pathfinder.ts's MOVE_DIRS) — so no
- * Mermaid diagram through the renderer can actually produce a diagonal
- * `from`/`to` pair here; the pure-vertical/horizontal branches are already
- * covered that way. Testing this diagonal routing therefore has to call
- * drawLine directly, the same way pathfinder.test.ts unit-tests getPath
- * directly with hand-built inputs rather than through a full render.
- */
-import { describe, it, expect } from 'vitest'
-import { drawLine } from '../../packages/ascii-renderer/src/draw-lines.ts'
-import { mkCanvas } from '../../packages/ascii-renderer/src/canvas.ts'
-
-describe('drawLine diagonal routing', () => {
-  it('routes UpperLeft as a horizontal-then-vertical bend', () => {
-    const canvas = mkCanvas(10, 10)
-    const drawn = drawLine(canvas, { x: 8, y: 8 }, { x: 2, y: 2 }, 1, -1, false)
-    expect(canvas[7]![8]).toBe('─')
-    expect(canvas[2]![8]).toBe('─')
-    expect(canvas[2]![7]).toBe('│')
-    expect(canvas[2]![3]).toBe('│')
-    expect(drawn.length).toBe(6 + 5)
-  })
-
-  it('routes UpperRight as a horizontal-then-vertical bend', () => {
-    const canvas = mkCanvas(10, 10)
-    const drawn = drawLine(canvas, { x: 2, y: 8 }, { x: 8, y: 2 }, 1, -1, false)
-    expect(canvas[3]![8]).toBe('─')
-    expect(canvas[8]![8]).toBe('─')
-    expect(canvas[8]![7]).toBe('│')
-    expect(canvas[8]![3]).toBe('│')
-    expect(drawn.length).toBe(6 + 5)
-  })
-
-  it('routes LowerLeft as a horizontal-then-vertical bend', () => {
-    const canvas = mkCanvas(10, 10)
-    const drawn = drawLine(canvas, { x: 8, y: 2 }, { x: 2, y: 8 }, 1, -1, false)
-    expect(canvas[7]![2]).toBe('─')
-    expect(canvas[2]![2]).toBe('─')
-    expect(canvas[2]![3]).toBe('│')
-    expect(canvas[2]![7]).toBe('│')
-    expect(drawn.length).toBe(6 + 5)
-  })
-
-  describe('LowerRight', () => {
-    it('draws a straight vertical line when x delta is 1 (source-aligned)', () => {
-      const canvas = mkCanvas(10, 10)
-      const drawn = drawLine(
-        canvas,
-        { x: 5, y: 2 },
-        { x: 6, y: 8 },
-        1,
-        -1,
-        false,
-      )
-      for (let y = 3; y <= 7; y++) {
-        expect(canvas[5]![y]).toBe('│')
-      }
-      expect(canvas[6]![8]).toBe(' ')
-      expect(drawn.every((c) => c.x === 5)).toBe(true)
-      expect(drawn.length).toBe(5)
-    })
-
-    it('routes as a horizontal-then-vertical bend when x delta is greater than 1', () => {
-      const canvas = mkCanvas(10, 10)
-      const drawn = drawLine(
-        canvas,
-        { x: 2, y: 2 },
-        { x: 8, y: 8 },
-        1,
-        -1,
-        false,
-      )
-      expect(canvas[3]![2]).toBe('─')
-      expect(canvas[8]![2]).toBe('─')
-      expect(canvas[8]![3]).toBe('│')
-      expect(canvas[8]![7]).toBe('│')
-      expect(drawn.length).toBe(6 + 5)
-    })
-
-    it('uses ASCII characters in ASCII mode', () => {
-      const canvas = mkCanvas(10, 10)
-      drawLine(canvas, { x: 2, y: 2 }, { x: 8, y: 8 }, 1, -1, true)
-      expect(canvas[3]![2]).toBe('-')
-      expect(canvas[8]![3]).toBe('|')
-    })
-  })
-})

package/src/__tests__/edge-cell-styles.test.ts

@@ -1,180 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import {
-  createEdgeCellStyles,
-  findStyleConflict,
-  claimPathCells,
-} from '../../packages/ascii-renderer/src/edge-cell-styles.ts'
-import {
-  createGrid,
-  placeBlock,
-} from '../../packages/ascii-renderer/src/grid-occupancy.ts'
-
-describe('edge-cell-styles', () => {
-  it('reports no conflict against an empty map', () => {
-    const grid = createGrid()
-    const cellStyles = createEdgeCellStyles()
-    const path = [
-      { x: 0, y: 0 },
-      { x: 3, y: 0 },
-    ]
-    expect(findStyleConflict(grid, cellStyles, path, 'solid')).toBeNull()
-  })
-
-  it('does not flag a second same-style edge through claimed cells', () => {
-    const grid = createGrid()
-    const cellStyles = createEdgeCellStyles()
-    const path = [
-      { x: 0, y: 0 },
-      { x: 3, y: 0 },
-    ]
-    claimPathCells(grid, cellStyles, path, 'solid')
-    // A second solid edge reusing the same cells is exactly the "sibling
-    // edges share a trunk" / "LR routing merges naturally at corners"
-    // behavior other tests rely on — must stay unflagged.
-    expect(findStyleConflict(grid, cellStyles, path, 'solid')).toBeNull()
-  })
-
-  it('flags a different-style edge crossing already-claimed cells', () => {
-    const grid = createGrid()
-    const cellStyles = createEdgeCellStyles()
-    const path = [
-      { x: 0, y: 0 },
-      { x: 3, y: 0 },
-    ]
-    claimPathCells(grid, cellStyles, path, 'solid')
-    expect(findStyleConflict(grid, cellStyles, path, 'dotted')).toEqual({
-      x: 0,
-      y: 0,
-    })
-  })
-
-  it('reports the first conflicting cell in path order', () => {
-    const grid = createGrid()
-    const cellStyles = createEdgeCellStyles()
-    claimPathCells(
-      grid,
-      cellStyles,
-      [
-        { x: 5, y: 0 },
-        { x: 8, y: 0 },
-      ],
-      'thick',
-    )
-    const crossing = [
-      { x: 0, y: 0 },
-      { x: 10, y: 0 },
-    ]
-    expect(findStyleConflict(grid, cellStyles, crossing, 'solid')).toEqual({
-      x: 5,
-      y: 0,
-    })
-  })
-
-  it('first claim wins — claiming a cell twice with different styles keeps the original', () => {
-    const grid = createGrid()
-    const cellStyles = createEdgeCellStyles()
-    const cell = [{ x: 1, y: 1 }]
-    claimPathCells(grid, cellStyles, cell, 'solid')
-    claimPathCells(grid, cellStyles, cell, 'dotted')
-    // Still solid from the first claim, so a *third* dotted edge is still
-    // reported as a conflict rather than silently "winning" the cell.
-    expect(findStyleConflict(grid, cellStyles, cell, 'dotted')).toEqual({
-      x: 1,
-      y: 1,
-    })
-  })
-
-  it('does not flag cells the path never touches', () => {
-    const grid = createGrid()
-    const cellStyles = createEdgeCellStyles()
-    claimPathCells(
-      grid,
-      cellStyles,
-      [
-        { x: 0, y: 0 },
-        { x: 0, y: 5 },
-      ],
-      'solid',
-    )
-    const unrelated = [
-      { x: 10, y: 10 },
-      { x: 12, y: 10 },
-    ]
-    expect(findStyleConflict(grid, cellStyles, unrelated, 'dotted')).toBeNull()
-  })
-
-  /**
-   * Regression: an edge's path always includes its own source/target
-   * node's border cell — that's how it connects to the box at all — so
-   * two edges sharing a node (one incoming, one outgoing, as in a retry
-   * loop's `B -->|No| D; D -.-> A`) legitimately share that exact port
-   * cell. An earlier version tracked *every* path cell including
-   * node-owned ones, which flagged this as a conflict — and since an edge
-   * always returns to its own node's fixed attachment point regardless of
-   * grid occupancy, "blocking" a node cell and re-routing found the
-   * identical cell again every time, so the fix never actually converged.
-   */
-  it('does not flag a shared node-border cell as a conflict', () => {
-    const grid = createGrid()
-    placeBlock(grid, { x: 4, y: 8 }) // node D's reserved 3x3 block
-    const cellStyles = createEdgeCellStyles()
-
-    // Incoming solid edge terminating at D's top-center port, (5, 8).
-    claimPathCells(
-      grid,
-      cellStyles,
-      [
-        { x: 2, y: 5 },
-        { x: 5, y: 5 },
-        { x: 5, y: 8 },
-      ],
-      'solid',
-    )
-
-    // Outgoing dotted edge leaving from D's right-side port, (6, 9) —
-    // inside the same reserved block, so still node-owned — then diverging
-    // into its own open column (7) rather than reusing (5, *).
-    const conflict = findStyleConflict(
-      grid,
-      cellStyles,
-      [
-        { x: 6, y: 9 },
-        { x: 7, y: 9 },
-        { x: 7, y: 1 },
-      ],
-      'dotted',
-    )
-    expect(conflict).toBeNull()
-  })
-
-  it('still flags a genuine open-space conflict alongside a shared node border', () => {
-    const grid = createGrid()
-    placeBlock(grid, { x: 4, y: 8 }) // node D's reserved 3x3 block
-    const cellStyles = createEdgeCellStyles()
-
-    claimPathCells(
-      grid,
-      cellStyles,
-      [
-        { x: 2, y: 5 },
-        { x: 5, y: 5 },
-        { x: 5, y: 8 },
-      ],
-      'solid',
-    )
-
-    // A different-style edge that reaches D via the *same open-space*
-    // column (5, 5)-(5, 8), not just the shared port cell, is still a
-    // real conflict — reported at the first open cell it crosses.
-    const conflict = findStyleConflict(
-      grid,
-      cellStyles,
-      [
-        { x: 5, y: 1 },
-        { x: 5, y: 8 },
-      ],
-      'dotted',
-    )
-    expect(conflict).toEqual({ x: 5, y: 5 })
-  })
-})

package/src/__tests__/elk-adapter-utils.test.ts

@@ -1,166 +0,0 @@
-/**
- * Unit tests for the shared ELK edge-geometry extraction helpers
- * (`extractEdgePoints` / `extractEdgeLabelPosition`).
- *
- * `from-elk.ts`, `class/layout.ts`, and `er/layout.ts` all exercise this
- * module indirectly through full-diagram integration tests, but those
- * only ever hit the "happy path" (an edge with sections and, sometimes,
- * a placed label). These tests cover the defensive branches directly —
- * missing/empty sections, missing/empty labels, an unplaced label, and
- * missing bend points/label dimensions — so every branch has direct
- * coverage rather than relying on an integration test to happen to hit it.
- */
-import { describe, it, expect } from 'vitest'
-import type { ElkExtendedEdge } from 'elkjs'
-import {
-  extractEdgePoints,
-  extractEdgeLabelPosition,
-} from '@zombie-mermaid/svg-renderer'
-
-function edge(partial: Partial<ElkExtendedEdge>): ElkExtendedEdge {
-  return { id: 'e0', sources: ['a'], targets: ['b'], ...partial }
-}
-
-describe('extractEdgePoints', () => {
-  it('returns an empty array when the edge has no sections property', () => {
-    expect(extractEdgePoints(edge({}))).toEqual([])
-  })
-
-  it('returns an empty array when sections is an empty array', () => {
-    expect(extractEdgePoints(edge({ sections: [] }))).toEqual([])
-  })
-
-  it('walks start -> end with no bend points', () => {
-    const e = edge({
-      sections: [
-        {
-          id: 's0',
-          startPoint: { x: 10, y: 20 },
-          endPoint: { x: 30, y: 40 },
-        },
-      ],
-    })
-    expect(extractEdgePoints(e)).toEqual([
-      { x: 10, y: 20 },
-      { x: 30, y: 40 },
-    ])
-  })
-
-  it('walks start -> bendPoints -> end when bend points are present', () => {
-    const e = edge({
-      sections: [
-        {
-          id: 's0',
-          startPoint: { x: 0, y: 0 },
-          endPoint: { x: 100, y: 0 },
-          bendPoints: [
-            { x: 25, y: 50 },
-            { x: 75, y: 50 },
-          ],
-        },
-      ],
-    })
-    expect(extractEdgePoints(e)).toEqual([
-      { x: 0, y: 0 },
-      { x: 25, y: 50 },
-      { x: 75, y: 50 },
-      { x: 100, y: 0 },
-    ])
-  })
-
-  it('translates every point by offsetX/offsetY when provided', () => {
-    const e = edge({
-      sections: [
-        {
-          id: 's0',
-          startPoint: { x: 0, y: 0 },
-          endPoint: { x: 10, y: 10 },
-          bendPoints: [{ x: 5, y: 5 }],
-        },
-      ],
-    })
-    expect(extractEdgePoints(e, 100, 200)).toEqual([
-      { x: 100, y: 200 },
-      { x: 105, y: 205 },
-      { x: 110, y: 210 },
-    ])
-  })
-
-  it('only reads the first section when multiple are present', () => {
-    const e = edge({
-      sections: [
-        { id: 's0', startPoint: { x: 0, y: 0 }, endPoint: { x: 1, y: 1 } },
-        { id: 's1', startPoint: { x: 9, y: 9 }, endPoint: { x: 8, y: 8 } },
-      ],
-    })
-    expect(extractEdgePoints(e)).toEqual([
-      { x: 0, y: 0 },
-      { x: 1, y: 1 },
-    ])
-  })
-})
-
-describe('extractEdgeLabelPosition', () => {
-  it('returns undefined when the edge has no labels property', () => {
-    expect(extractEdgeLabelPosition(edge({}))).toBeUndefined()
-  })
-
-  it('returns undefined when labels is an empty array', () => {
-    expect(extractEdgeLabelPosition(edge({ labels: [] }))).toBeUndefined()
-  })
-
-  it('returns undefined when the label has no x/y (ELK left it unplaced)', () => {
-    expect(
-      extractEdgeLabelPosition(edge({ labels: [{ text: 'foo' }] })),
-    ).toBeUndefined()
-  })
-
-  it('returns undefined when only x is set (y still unplaced)', () => {
-    expect(
-      extractEdgeLabelPosition(edge({ labels: [{ text: 'foo', x: 5 }] })),
-    ).toBeUndefined()
-  })
-
-  it('computes the label center, defaulting missing width/height to 0', () => {
-    expect(
-      extractEdgeLabelPosition(
-        edge({ labels: [{ text: 'foo', x: 10, y: 20 }] }),
-      ),
-    ).toEqual({ x: 10, y: 20 })
-  })
-
-  it('computes the label center from x/y/width/height', () => {
-    expect(
-      extractEdgeLabelPosition(
-        edge({
-          labels: [{ text: 'foo', x: 10, y: 20, width: 40, height: 10 }],
-        }),
-      ),
-    ).toEqual({ x: 30, y: 25 })
-  })
-
-  it('translates the computed center by offsetX/offsetY when provided', () => {
-    expect(
-      extractEdgeLabelPosition(
-        edge({
-          labels: [{ text: 'foo', x: 10, y: 20, width: 40, height: 10 }],
-        }),
-        100,
-        200,
-      ),
-    ).toEqual({ x: 130, y: 225 })
-  })
-
-  it('only reads the first label when multiple are present', () => {
-    expect(
-      extractEdgeLabelPosition(
-        edge({
-          labels: [
-            { text: 'first', x: 0, y: 0 },
-            { text: 'second', x: 100, y: 100 },
-          ],
-        }),
-      ),
-    ).toEqual({ x: 0, y: 0 })
-  })
-})