bridges-cli 0.0.1 → 0.2.0

package/src/utils/__tests__/bridges.test.tsx

@@ -0,0 +1,137 @@
+import { describe, expect, it } from 'vitest'
+import type { HashiNodeData } from '../../types.ts'
+import { constructNode, getDisplayMode } from '../bridges.ts'
+
+// biome-ignore lint/security/noSecrets: false positive
+describe('getDisplayMode()', () => {
+    it('returns normal when highlightedNode is undefined', () => {
+        const node: HashiNodeData = { value: 1 }
+        expect(getDisplayMode(node, undefined)).toBe('normal')
+    })
+
+    it('returns highlight when node value matches highlightedNode', () => {
+        const node: HashiNodeData = { value: 2 }
+        expect(getDisplayMode(node, 2)).toBe('highlight')
+    })
+
+    it('returns dim when node value does not match highlightedNode', () => {
+        const node: HashiNodeData = { value: 1 }
+        expect(getDisplayMode(node, 2)).toBe('dim')
+    })
+
+    it('returns dim for bridge nodes when highlightedNode is set', () => {
+        expect(getDisplayMode({ value: '-' }, 2)).toBe('dim')
+        expect(getDisplayMode({ value: '|' }, 2)).toBe('dim')
+        expect(getDisplayMode({ value: '#' }, 2)).toBe('dim')
+    })
+
+    it('returns highlight for bridge nodes that are the highlighted value', () => {
+        expect(getDisplayMode({ value: '-' }, 2)).toBe('dim')
+    })
+})
+
+describe('constructNode()', () => {
+    describe('empty node', () => {
+        it('renders space value with no lines', () => {
+            const node: HashiNodeData = { value: ' ' }
+            expect(constructNode(node, 0)).toEqual('     ')
+            expect(constructNode(node, 1)).toEqual('     ')
+            expect(constructNode(node, 2)).toEqual('     ')
+        })
+    })
+
+    describe('horizontal line node', () => {
+        it('renders a horizontal line in the middle', () => {
+            const node: HashiNodeData = { value: '-' }
+            expect(constructNode(node, 0)).toEqual('     ')
+            expect(constructNode(node, 1)).toEqual('─────')
+            expect(constructNode(node, 2)).toEqual('     ')
+        })
+
+        it('renders a double horizontal line in the middle', () => {
+            const node: HashiNodeData = { value: '=' }
+            expect(constructNode(node, 0)).toEqual('     ')
+            expect(constructNode(node, 1)).toEqual('═════')
+            expect(constructNode(node, 2)).toEqual('     ')
+        })
+    })
+
+    describe('vertical line node', () => {
+        it('renders a vertical line in the center', () => {
+            const node: HashiNodeData = { value: '|' }
+            expect(constructNode(node, 0)).toEqual('  │  ')
+            expect(constructNode(node, 1)).toEqual('  │  ')
+            expect(constructNode(node, 2)).toEqual('  │  ')
+        })
+
+        it('renders a double vertical line in the center', () => {
+            const node: HashiNodeData = { value: '#' }
+            expect(constructNode(node, 0)).toEqual('  ║  ')
+            expect(constructNode(node, 1)).toEqual('  ║  ')
+            expect(constructNode(node, 2)).toEqual('  ║  ')
+        })
+    })
+
+    describe('node with value', () => {
+        describe('TOP_ROW', () => {
+            it('renders top border', () => {
+                const node: HashiNodeData = { value: 5 }
+                expect(constructNode(node, 0)).toEqual('╭───╮')
+            })
+
+            it('renders border with vertical line up', () => {
+                const node: HashiNodeData = { value: 5, lineUp: 1 }
+                expect(constructNode(node, 0)).toEqual('╭─┴─╮')
+            })
+
+            it('renders border with double vertical line up', () => {
+                const node: HashiNodeData = { value: 5, lineUp: 2 }
+                expect(constructNode(node, 0)).toEqual('╭─╨─╮')
+            })
+        })
+
+        describe('MIDDLE_ROW', () => {
+            it('renders middle row - value with vertical borders', () => {
+                const node: HashiNodeData = { value: 5 }
+                expect(constructNode(node, 1)).toEqual('│ 5 │')
+            })
+
+            it('renders value with horizontal line on left', () => {
+                const node: HashiNodeData = { value: 5, lineLeft: 1 }
+                expect(constructNode(node, 1)).toEqual('┤ 5 │')
+            })
+
+            it('renders value with horizontal line on right', () => {
+                const node: HashiNodeData = { value: 5, lineRight: 1 }
+                expect(constructNode(node, 1)).toEqual('│ 5 ├')
+            })
+
+            it('renders value with horizontal lines on both sides', () => {
+                const node: HashiNodeData = { value: 5, lineLeft: 1, lineRight: 1 }
+                expect(constructNode(node, 1)).toEqual('┤ 5 ├')
+            })
+
+            it('renders value with double horizontal lines on both sides', () => {
+                const node: HashiNodeData = { value: 5, lineLeft: 2, lineRight: 2 }
+                expect(constructNode(node, 1)).toEqual('╡ 5 ╞')
+            })
+        })
+
+        describe('BOTTOM_ROW', () => {
+            it('renders bottom border without lines', () => {
+                const node: HashiNodeData = { value: 5 }
+                expect(constructNode(node, 2)).toEqual('╰───╯')
+            })
+
+            it('renders border with vertical line down', () => {
+                const node: HashiNodeData = { value: 5, lineDown: 1 }
+                expect(constructNode(node, 2)).toEqual('╰─┬─╯')
+            })
+
+            it('renders border with double vertical line down', () => {
+                const node: HashiNodeData = { value: 5, lineDown: 2 }
+                expect(constructNode(node, 2)).toEqual('╰─╥─╯')
+            })
+        })
+    })
+})

package/src/utils/__tests__/findNodeInDirection.test.ts

@@ -0,0 +1,75 @@
+import { describe, expect, it } from 'vitest'
+
+import { findNodeInDirection } from '../usePuzzleInput.ts'
+
+describe('findNodeInDirection', () => {
+    describe('1x2 grid (horizontal)', () => {
+        const grid = [[{ value: 1 }, { value: 2 }]]
+
+        it('finds node to the right', () => {
+            expect(findNodeInDirection(grid, 0, 0, 'l')).toEqual({ row: 0, col: 1 })
+        })
+
+        it('finds node to the left', () => {
+            expect(findNodeInDirection(grid, 0, 1, 'h')).toEqual({ row: 0, col: 0 })
+        })
+
+        it('returns null when no node to the right', () => {
+            expect(findNodeInDirection(grid, 0, 1, 'l')).toBe(null)
+        })
+
+        it('returns null when no node to the left', () => {
+            expect(findNodeInDirection(grid, 0, 0, 'h')).toBe(null)
+        })
+
+        it('returns null for vertical directions (no rows above/below)', () => {
+            expect(findNodeInDirection(grid, 0, 0, 'j')).toBe(null)
+            expect(findNodeInDirection(grid, 0, 0, 'k')).toBe(null)
+        })
+    })
+
+    describe('2x1 grid (vertical)', () => {
+        const grid = [[{ value: 1 }], [{ value: 2 }]]
+
+        it('finds node below', () => {
+            expect(findNodeInDirection(grid, 0, 0, 'j')).toEqual({ row: 1, col: 0 })
+        })
+
+        it('finds node above', () => {
+            expect(findNodeInDirection(grid, 1, 0, 'k')).toEqual({ row: 0, col: 0 })
+        })
+
+        it('returns null when no node below', () => {
+            expect(findNodeInDirection(grid, 1, 0, 'j')).toBe(null)
+        })
+
+        it('returns null when no node above', () => {
+            expect(findNodeInDirection(grid, 0, 0, 'k')).toBe(null)
+        })
+
+        it('returns null for horizontal directions (no cols left/right)', () => {
+            expect(findNodeInDirection(grid, 0, 0, 'h')).toBe(null)
+            expect(findNodeInDirection(grid, 0, 0, 'l')).toBe(null)
+        })
+    })
+
+    describe('3x3 grid with empty cells', () => {
+        const grid: { value: number | '-' | '=' | '#' | ' ' | '|' }[][] = [
+            [{ value: 1 }, { value: ' ' }, { value: 2 }],
+            [{ value: ' ' }, { value: '#' }, { value: ' ' }],
+            [{ value: 3 }, { value: ' ' }, { value: 4 }],
+        ]
+
+        it('finds node across empty cells', () => {
+            expect(findNodeInDirection(grid, 0, 0, 'l')).toEqual({ row: 0, col: 2 })
+        })
+
+        it('finds node across empty cells (down)', () => {
+            expect(findNodeInDirection(grid, 0, 0, 'j')).toEqual({ row: 2, col: 0 })
+        })
+
+        it('returns node when blocked by wall (#) but path around exists', () => {
+            expect(findNodeInDirection(grid, 0, 0, 'j')).toEqual({ row: 2, col: 0 })
+        })
+    })
+})

package/src/utils/__tests__/{parsePuzzle.test.ts → puzzle-encoding.test.ts}

@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest'
 
-import { parsePuzzle } from '../parsePuzzle.ts'
+import { parsePuzzle } from '../puzzle-encoding.ts'
 
 describe('parsePuzzle', () => {
     describe('encodings without the solution (bridges)', () => {

package/src/utils/bridges.ts

@@ -0,0 +1,395 @@
+import type { HashiNodeData, HashiNodeDisplayMode } from '../types.ts'
+
+export type NodeFilledState = 'valid' | 'invalid' | 'incomplete'
+
+export const ROW_HEIGHT = 3
+export const NODE_WIDTH = 5
+export const SPACE_BETWEEN = 0
+export const OUTER_PADDING = 1
+
+export const TOP_ROW = 0
+export const MIDDLE_ROW = 1
+export const BOTTOM_ROW = 2
+
+export type HashiGridValidationProps = {
+    rows: HashiNodeData[][]
+    numNodes: number
+}
+
+/**
+ * Ensure the grid data is consistent with a valid Bridges puzzle.
+ */
+export function validateGrid({ rows, numNodes }: HashiGridValidationProps): void {
+    if (!rows || rows.length === 0) {
+        throw new Error('HashiGrid: empty data supplied')
+    }
+
+    let rowCount = 0
+    for (const nodes of rows) {
+        const prefix = `HashiGrid row ${rowCount}: `
+
+        if (nodes.length !== numNodes) {
+            throw new Error(`${prefix}expected ${numNodes} nodes, got ${nodes.length}`)
+        }
+
+        for (let i = 0; i < nodes.length; i++) {
+            const node = nodes[i]
+            if (!node) {
+                throw new Error(`${prefix}node at position ${i} is undefined`)
+            }
+            if (
+                typeof node.value !== 'number' &&
+                node.value !== '-' &&
+                node.value !== '=' &&
+                node.value !== ' ' &&
+                node.value !== '#' &&
+                node.value !== '|'
+            ) {
+                throw new Error(`${prefix}node at position ${i} has invalid value: ${node.value}`)
+            }
+        }
+        rowCount++
+    }
+}
+
+/**
+ * Check if the puzzle is solved - all numbered nodes have the correct number of bridges
+ * and all nodes form a connected graph.
+ */
+export function checkSolution(rows: HashiNodeData[][]): boolean {
+    for (const row of rows) {
+        for (const node of row) {
+            const state = getNodeFilledState(node)
+            if (state !== null && state !== 'valid') {
+                return false
+            }
+        }
+    }
+
+    if (!isGraphConnected(rows)) {
+        return false
+    }
+
+    return true
+}
+
+/**
+ * Check if all numbered nodes have the correct number of bridges (regardless of connectivity).
+ */
+export function areAllNodesFilled(rows: HashiNodeData[][]): boolean {
+    for (const row of rows) {
+        for (const node of row) {
+            const state = getNodeFilledState(node)
+            if (state !== null && state !== 'valid') {
+                return false
+            }
+        }
+    }
+    return true
+}
+
+/**
+ * Check if the graph is connected (regardless of whether nodes have correct bridge counts).
+ */
+export function isConnected(rows: HashiNodeData[][]): boolean {
+    return isGraphConnected(rows)
+}
+
+/**
+ * Check if all numbered nodes form a connected graph using BFS.
+ */
+function isGraphConnected(rows: HashiNodeData[][]): boolean {
+    const numRows = rows.length
+    if (numRows === 0) return true
+    const numCols = rows[0].length
+
+    const numberedNodes: [number, number][] = []
+    for (let r = 0; r < numRows; r++) {
+        for (let c = 0; c < numCols; c++) {
+            if (typeof rows[r][c].value === 'number') {
+                numberedNodes.push([r, c])
+            }
+        }
+    }
+
+    if (numberedNodes.length === 0) return true
+
+    const visited = new Set<string>()
+    const queue: [number, number][] = [[numberedNodes[0][0], numberedNodes[0][1]]]
+    visited.add(`${numberedNodes[0][0]},${numberedNodes[0][1]}`)
+
+    while (queue.length > 0) {
+        const next = queue.shift()
+        if (!next) continue
+        const [r, c] = next
+        const node = rows[r]?.[c]
+        if (!node) continue
+
+        if (node.lineRight === 1 || node.lineRight === 2) {
+            const dest = findNodeInDirection(rows, r, c, 0, 1)
+            if (dest) {
+                const key = `${dest[0]},${dest[1]}`
+                if (!visited.has(key)) {
+                    visited.add(key)
+                    queue.push(dest)
+                }
+            }
+        }
+
+        if (node.lineLeft === 1 || node.lineLeft === 2) {
+            const dest = findNodeInDirection(rows, r, c, 0, -1)
+            if (dest) {
+                const key = `${dest[0]},${dest[1]}`
+                if (!visited.has(key)) {
+                    visited.add(key)
+                    queue.push(dest)
+                }
+            }
+        }
+
+        if (node.lineDown === 1 || node.lineDown === 2) {
+            const dest = findNodeInDirection(rows, r, c, 1, 0)
+            if (dest) {
+                const key = `${dest[0]},${dest[1]}`
+                if (!visited.has(key)) {
+                    visited.add(key)
+                    queue.push(dest)
+                }
+            }
+        }
+
+        if (node.lineUp === 1 || node.lineUp === 2) {
+            const dest = findNodeInDirection(rows, r, c, -1, 0)
+            if (dest) {
+                const key = `${dest[0]},${dest[1]}`
+                if (!visited.has(key)) {
+                    visited.add(key)
+                    queue.push(dest)
+                }
+            }
+        }
+    }
+
+    return visited.size === numberedNodes.length
+}
+
+function findNodeInDirection(
+    rows: HashiNodeData[][],
+    startR: number,
+    startC: number,
+    dRow: number,
+    dCol: number
+): [number, number] | null {
+    const numRows = rows.length
+    const numCols = rows[0].length
+    let r = startR + dRow
+    let c = startC + dCol
+
+    while (r >= 0 && r < numRows && c >= 0 && c < numCols) {
+        if (typeof rows[r][c].value === 'number') {
+            return [r, c]
+        }
+        r += dRow
+        c += dCol
+    }
+
+    return null
+}
+
+/**
+ * Determines if a node has the correct number of bridges, too many, or too few.
+ */
+export function getNodeFilledState(node: HashiNodeData): NodeFilledState | null {
+    if (typeof node.value !== 'number') {
+        return null
+    }
+
+    const bridges =
+        (node.lineUp ?? 0) + (node.lineDown ?? 0) + (node.lineLeft ?? 0) + (node.lineRight ?? 0)
+
+    if (bridges === node.value) {
+        return 'valid'
+    }
+    if (bridges > node.value) {
+        return 'invalid'
+    }
+    return 'incomplete'
+}
+
+/**
+ * Determines the display mode for a node based on the highlighted node value.
+ */
+export function getDisplayMode(
+    node: HashiNodeData,
+    highlightedNode?: number,
+    row?: number,
+    col?: number,
+    selectedNode?: { row: number; col: number } | null,
+    mode?: string
+): HashiNodeDisplayMode {
+    // In selecting-node, selected, or invalid mode, highlight only the specific selected node
+    if (
+        (mode === 'selecting-node' || mode === 'selected' || mode === 'invalid') &&
+        selectedNode &&
+        row !== undefined &&
+        col !== undefined
+    ) {
+        if (row === selectedNode.row && col === selectedNode.col) {
+            return 'highlight'
+        }
+        return 'dim'
+    }
+
+    if (highlightedNode === undefined) {
+        return 'normal'
+    }
+    if (typeof node.value === 'number' && node.value === highlightedNode) {
+        return 'highlight'
+    }
+
+    // Bridge values are strings, so they can never match a number highlightedNode
+    return 'dim'
+}
+
+/**
+ * Build the HashiGrid node with its value and borders. Options:
+ *   - node with a value (always 1 digit)
+ *   - empty node - render just spaces
+ *   - horizontal line - single and double
+ *   - vertical line - single and double
+ */
+export function constructNode(
+    node: HashiNodeData,
+    line: 0 | 1 | 2,
+    displayMode: HashiNodeDisplayMode = 'normal',
+    disambiguationLabel?: string,
+    validationState?: NodeFilledState | null,
+    showSolution?: boolean
+): string {
+    // Determine color prefix based on validation state
+    const getColorPrefix = (): string => {
+        if (validationState === 'valid') {
+            return '\x1b[32m' // green
+        }
+        if (validationState === 'invalid') {
+            return '\x1b[31m' // red
+        }
+        return ''
+    }
+
+    const colorReset = '\x1b[39m'
+    const colorPrefix = displayMode === 'dim' ? '' : getColorPrefix()
+    const useColor = colorPrefix !== ''
+
+    // Horizontal line
+    if (node.value === '-') {
+        if (displayMode === 'dim') {
+            return line === MIDDLE_ROW ? `\x1b[2m─────\x1b[22m` : ' '.repeat(NODE_WIDTH)
+        }
+        const content = line === MIDDLE_ROW ? '─────' : ' '.repeat(NODE_WIDTH)
+        if (showSolution) {
+            return `\x1b[32m${content}\x1b[39m`
+        }
+        return useColor ? `${getColorPrefix()}${content}${colorReset}` : content
+    }
+
+    // Double horizontal line
+    if (node.value === '=') {
+        if (displayMode === 'dim') {
+            return line === MIDDLE_ROW ? `\x1b[2m═════\x1b[22m` : ' '.repeat(NODE_WIDTH)
+        }
+        const content = line === MIDDLE_ROW ? '═════' : ' '.repeat(NODE_WIDTH)
+        if (showSolution) {
+            return `\x1b[32m${content}\x1b[39m`
+        }
+        return useColor ? `${getColorPrefix()}${content}${colorReset}` : content
+    }
+
+    // Vertical line
+    if (node.value === '|') {
+        if (displayMode === 'dim') {
+            return `\x1b[2m  │  \x1b[22m`
+        }
+        const content = '  │  '
+        if (showSolution) {
+            return `\x1b[32m${content}\x1b[39m`
+        }
+        return useColor ? `${getColorPrefix()}${content}${colorReset}` : content
+    }
+
+    // Double vertical line
+    if (node.value === '#') {
+        if (displayMode === 'dim') {
+            return `\x1b[2m  ║  \x1b[22m`
+        }
+        const content = '  ║  '
+        if (showSolution) {
+            return `\x1b[32m${content}\x1b[39m`
+        }
+        return useColor ? `${getColorPrefix()}${content}${colorReset}` : content
+    }
+
+    // Node with value to render
+    if (node.value !== ' ') {
+        if (line === TOP_ROW) {
+            const up = node.lineUp === 2 ? '╨' : node.lineUp === 1 ? '┴' : '─'
+            const label = disambiguationLabel ? disambiguationLabel : '─'
+            const border = `╭${label}${up}─╮`
+            if (displayMode === 'highlight') {
+                const highlighted = `\x1b[1m${border}\x1b[22m`
+                if (validationState === 'valid' || validationState === 'invalid') {
+                    return `${getColorPrefix()}${highlighted}${colorReset}`
+                }
+                return highlighted
+            }
+            if (displayMode === 'dim') {
+                const dimmedBorder = `\x1b[2m${border}\x1b[22m`
+                if (validationState === 'valid' || validationState === 'invalid') {
+                    return `${getColorPrefix()}${dimmedBorder}${colorReset}`
+                }
+                return dimmedBorder
+            }
+            return useColor ? `${getColorPrefix()}${border}${colorReset}` : border
+        } else if (line === MIDDLE_ROW) {
+            const left = node.lineLeft === 2 ? '╡' : node.lineLeft === 1 ? '┤' : '│'
+            const right = node.lineRight === 2 ? '╞' : node.lineRight === 1 ? '├' : '│'
+            const content = `${left} ${node.value} ${right}`
+            if (displayMode === 'highlight') {
+                const highlighted = `\x1b[1m${content}\x1b[22m`
+                if (validationState === 'valid' || validationState === 'invalid') {
+                    return `${getColorPrefix()}${highlighted}${colorReset}`
+                }
+                return highlighted
+            }
+            if (displayMode === 'dim') {
+                const dimmedContent = `\x1b[2m${content}\x1b[22m`
+                if (validationState === 'valid' || validationState === 'invalid') {
+                    return `${getColorPrefix()}${dimmedContent}${colorReset}`
+                }
+                return dimmedContent
+            }
+            return useColor ? `${getColorPrefix()}${content}${colorReset}` : content
+        } else if (line === BOTTOM_ROW) {
+            const down = node.lineDown === 2 ? '╥' : node.lineDown === 1 ? '┬' : '─'
+            const border = `╰─${down}─╯`
+            if (displayMode === 'highlight') {
+                const highlighted = `\x1b[1m${border}\x1b[22m`
+                if (validationState === 'valid' || validationState === 'invalid') {
+                    return `${getColorPrefix()}${highlighted}${colorReset}`
+                }
+                return highlighted
+            }
+            if (displayMode === 'dim') {
+                const dimmedBorder = `\x1b[2m${border}\x1b[22m`
+                if (validationState === 'valid' || validationState === 'invalid') {
+                    return `${getColorPrefix()}${dimmedBorder}${colorReset}`
+                }
+                return dimmedBorder
+            }
+            return useColor ? `${getColorPrefix()}${border}${colorReset}` : border
+        }
+    }
+
+    // Empty node
+    return ' '.repeat(NODE_WIDTH)
+}