8a5c232685
Pure, Three.js-free wall-local geometry that will power directly-visible
proximity guides for doors and windows (rendered in the follow-up phases):
- sill / head height (floor → bottom edge, top edge → wall top)
- edge-to-edge proximity clearance to the nearest neighbour on each side
(or the wall end), with overlap suppression
- along-wall alignment (edge/centre coincidence with a neighbour)
- vertical alignment (shared sill / centre / top — "same sill height")
- Figma-style equal-spacing run detection across a series of 3+ openings
Single `computeOpeningGuides` entry plus exported detectors; 23 unit tests.
Codex-reviewed — equal-spacing uses a longest-equal-window scan (a greedy
first-gap anchor dropped valid runs), edge gaps suppress straddling overlaps,
and the alignment detectors guard against the moving opening appearing in its
own sibling list.
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
242 lines
9.2 KiB
TypeScript
242 lines
9.2 KiB
TypeScript
import { describe, expect, test } from 'bun:test'
|
|
import {
|
|
computeEdgeGaps,
|
|
computeOpeningGuides,
|
|
detectAlongWallAlignment,
|
|
detectEqualSpacing,
|
|
detectVerticalAlignment,
|
|
type OpeningSpan,
|
|
type WallExtent,
|
|
} from './opening-guides'
|
|
|
|
function span(id: string, centerS: number, width: number, centerY = 1, height = 1): OpeningSpan {
|
|
return { id, centerS, width, centerY, height }
|
|
}
|
|
|
|
const WALL: WallExtent = { length: 10, height: 2.5 }
|
|
|
|
describe('detectEqualSpacing', () => {
|
|
test('returns null for fewer than three openings', () => {
|
|
const a = span('a', 0.5, 1)
|
|
const b = span('b', 2.5, 1)
|
|
expect(detectEqualSpacing([a, b], 'b', 0.03, 0.02)).toBeNull()
|
|
})
|
|
|
|
test('detects a run of equal gaps across three openings', () => {
|
|
// width 1 each: a[0,1] b[2,3] c[4,5] → two gaps of 1m.
|
|
const a = span('a', 0.5, 1)
|
|
const b = span('b', 2.5, 1)
|
|
const c = span('c', 4.5, 1)
|
|
const run = detectEqualSpacing([a, b, c], 'b', 0.03, 0.02)
|
|
expect(run).not.toBeNull()
|
|
expect(run?.gap).toBeCloseTo(1)
|
|
expect(run?.segments).toHaveLength(2)
|
|
expect(run?.openingIds).toEqual(['a', 'b', 'c'])
|
|
expect(run?.segments[0]).toEqual({ fromS: 1, toS: 2 })
|
|
expect(run?.segments[1]).toEqual({ fromS: 3, toS: 4 })
|
|
})
|
|
|
|
test('extends a run across four openings (three gaps)', () => {
|
|
const openings = [span('a', 0.5, 1), span('b', 2.5, 1), span('c', 4.5, 1), span('d', 6.5, 1)]
|
|
const run = detectEqualSpacing(openings, 'c', 0.03, 0.02)
|
|
expect(run?.segments).toHaveLength(3)
|
|
expect(run?.openingIds).toEqual(['a', 'b', 'c', 'd'])
|
|
})
|
|
|
|
test('returns null when gaps differ beyond tolerance', () => {
|
|
const a = span('a', 0.5, 1) // [0,1]
|
|
const b = span('b', 2.5, 1) // [2,3] → gap 1
|
|
const c = span('c', 5, 1) // [4.5,5.5] → gap 1.5
|
|
expect(detectEqualSpacing([a, b, c], 'b', 0.03, 0.02)).toBeNull()
|
|
})
|
|
|
|
test('returns null when the moving opening is not part of the equal run', () => {
|
|
const a = span('a', 0.5, 1)
|
|
const b = span('b', 2.5, 1)
|
|
const c = span('c', 4.5, 1) // a,b,c form equal gaps of 1
|
|
const d = span('d', 10, 1) // far right, breaks the run
|
|
expect(detectEqualSpacing([a, b, c, d], 'd', 0.03, 0.02)).toBeNull()
|
|
})
|
|
|
|
test('a near-zero (touching) gap breaks a run', () => {
|
|
const a = span('a', 0.5, 1) // [0,1]
|
|
const b = span('b', 1.505, 1) // [1.005,2.005] → gap 0.005 < minGap
|
|
const c = span('c', 3.005, 1) // [2.505,3.505] → gap 0.5
|
|
expect(detectEqualSpacing([a, b, c], 'b', 0.03, 0.02)).toBeNull()
|
|
})
|
|
|
|
test('honours the equal-spacing tolerance', () => {
|
|
const a = span('a', 0.5, 1) // [0,1]
|
|
const b = span('b', 2.5, 1) // [2,3] → gap 1.0
|
|
const c = span('c', 4.52, 1) // [4.02,5.02] → gap 1.02
|
|
expect(detectEqualSpacing([a, b, c], 'b', 0.03, 0.02)?.segments).toHaveLength(2)
|
|
expect(detectEqualSpacing([a, b, c], 'b', 0.01, 0.02)).toBeNull()
|
|
})
|
|
})
|
|
|
|
describe('computeEdgeGaps', () => {
|
|
test('measures clearance to the nearest neighbour on each side', () => {
|
|
const moving = span('m', 5, 1) // [4.5,5.5]
|
|
const left = span('l', 2, 1) // [1.5,2.5]
|
|
const right = span('r', 8, 1) // [7.5,8.5]
|
|
const gaps = computeEdgeGaps(moving, [left, right], WALL, 0.02)
|
|
const byside = Object.fromEntries(gaps.map((g) => [g.side, g]))
|
|
expect(byside.left?.distance).toBeCloseTo(2)
|
|
expect(byside.left?.target).toBe('opening')
|
|
expect(byside.left?.targetId).toBe('l')
|
|
expect(byside.right?.distance).toBeCloseTo(2)
|
|
expect(byside.right?.targetId).toBe('r')
|
|
})
|
|
|
|
test('falls back to wall ends with no neighbour', () => {
|
|
const moving = span('m', 5, 1) // [4.5,5.5]
|
|
const gaps = computeEdgeGaps(moving, [], WALL, 0.02)
|
|
const byside = Object.fromEntries(gaps.map((g) => [g.side, g]))
|
|
expect(byside.left?.target).toBe('wall-start')
|
|
expect(byside.left?.distance).toBeCloseTo(4.5)
|
|
expect(byside.right?.target).toBe('wall-end')
|
|
expect(byside.right?.distance).toBeCloseTo(4.5)
|
|
})
|
|
|
|
test('omits a side that is flush / overlapping (below minGap)', () => {
|
|
const moving = span('m', 5, 1) // [4.5,5.5]
|
|
const flush = span('l', 4, 1) // [3.5,4.5] right edge touches moving left
|
|
const gaps = computeEdgeGaps(moving, [flush], WALL, 0.02)
|
|
expect(gaps.find((g) => g.side === 'left')).toBeUndefined()
|
|
expect(gaps.find((g) => g.side === 'right')?.target).toBe('wall-end')
|
|
})
|
|
})
|
|
|
|
describe('detectAlongWallAlignment', () => {
|
|
test('detects edge-to-edge alignment within tolerance', () => {
|
|
const moving = span('m', 5, 2) // [4,6]
|
|
const sib = span('s', 7.05, 2) // left edge 6.05
|
|
const a = detectAlongWallAlignment(moving, [sib], 0.08)
|
|
expect(a?.movingFeature).toBe('right')
|
|
expect(a?.targetFeature).toBe('left')
|
|
expect(a?.snap).toBeCloseTo(0.05)
|
|
expect(a?.s).toBeCloseTo(6.05)
|
|
})
|
|
|
|
test('detects centre alignment', () => {
|
|
const moving = span('m', 5, 2)
|
|
const sib = span('s', 5.03, 0.5) // centre 5.03, edges far from moving edges
|
|
const a = detectAlongWallAlignment(moving, [sib], 0.08)
|
|
expect(a?.movingFeature).toBe('center')
|
|
expect(a?.targetFeature).toBe('center')
|
|
expect(a?.snap).toBeCloseTo(0.03)
|
|
})
|
|
|
|
test('returns null when nothing is within tolerance', () => {
|
|
const moving = span('m', 5, 2)
|
|
const sib = span('s', 9, 2)
|
|
expect(detectAlongWallAlignment(moving, [sib], 0.08)).toBeNull()
|
|
})
|
|
})
|
|
|
|
describe('detectVerticalAlignment', () => {
|
|
test('detects a shared sill within tolerance', () => {
|
|
const moving = span('m', 5, 1, 1.5, 1) // sill 1.0
|
|
const sib = span('s', 8, 1, 2.04, 2) // sill 1.04
|
|
const a = detectVerticalAlignment(moving, [sib], 0.08)
|
|
expect(a?.movingFeature).toBe('sill')
|
|
expect(a?.targetFeature).toBe('sill')
|
|
expect(a?.snap).toBeCloseTo(0.04)
|
|
expect(a?.y).toBeCloseTo(1.04)
|
|
})
|
|
|
|
test('returns null when sills/tops differ beyond tolerance', () => {
|
|
const moving = span('m', 5, 1, 1.5, 1) // sill 1, top 2, centre 1.5
|
|
const sib = span('s', 8, 1, 0.4, 0.4) // sill 0.2, top 0.6, centre 0.4
|
|
expect(detectVerticalAlignment(moving, [sib], 0.08)).toBeNull()
|
|
})
|
|
})
|
|
|
|
describe('computeOpeningGuides', () => {
|
|
test('includes sill/head for windows', () => {
|
|
const moving = span('m', 5, 1, 1.5, 1) // bottom 1, top 2
|
|
const guides = computeOpeningGuides({
|
|
moving,
|
|
siblings: [],
|
|
wall: WALL,
|
|
includeVertical: true,
|
|
})
|
|
expect(guides.sillHead?.sill).toBeCloseTo(1)
|
|
expect(guides.sillHead?.head).toBeCloseTo(0.5) // 2.5 - 2
|
|
expect(guides.sillHead?.bottomY).toBeCloseTo(1)
|
|
expect(guides.sillHead?.topY).toBeCloseTo(2)
|
|
})
|
|
|
|
test('omits vertical guides for doors (sit on the floor)', () => {
|
|
const moving = span('m', 5, 1, 1, 2)
|
|
const sib = span('s', 8, 1, 1, 2)
|
|
const guides = computeOpeningGuides({
|
|
moving,
|
|
siblings: [sib],
|
|
wall: WALL,
|
|
includeVertical: false,
|
|
})
|
|
expect(guides.sillHead).toBeNull()
|
|
expect(guides.vertical).toBeNull()
|
|
// along-wall + proximity still computed for doors
|
|
expect(guides.gaps.length).toBeGreaterThan(0)
|
|
})
|
|
|
|
test('combines proximity and equal-spacing in one pass', () => {
|
|
const moving = span('b', 2.5, 1)
|
|
const guides = computeOpeningGuides({
|
|
moving,
|
|
siblings: [span('a', 0.5, 1), span('c', 4.5, 1)],
|
|
wall: WALL,
|
|
includeVertical: true,
|
|
})
|
|
expect(guides.gaps).toHaveLength(2)
|
|
expect(guides.equalSpacing?.gap).toBeCloseTo(1)
|
|
expect(guides.equalSpacing?.openingIds).toEqual(['a', 'b', 'c'])
|
|
})
|
|
})
|
|
|
|
describe('opening-guides — review regressions', () => {
|
|
test('detectEqualSpacing finds a run that starts partway through a drifting sequence', () => {
|
|
// gaps 1.00, 1.02, 1.04 — only [b,c,d] is equal within 0.03 and includes the
|
|
// moving opening; a first-gap-anchored greedy scan used to drop it.
|
|
const openings = [span('a', 0.5, 1), span('b', 2.5, 1), span('c', 4.52, 1), span('d', 6.56, 1)]
|
|
const run = detectEqualSpacing(openings, 'd', 0.03, 0.02)
|
|
expect(run?.openingIds).toEqual(['b', 'c', 'd'])
|
|
expect(run?.gap).toBeCloseTo(1.03)
|
|
expect(run?.segments).toHaveLength(2)
|
|
})
|
|
|
|
test('detectEqualSpacing prefers the leftmost run on a length tie', () => {
|
|
// gaps 1,1,2,2 with the moving opening in the middle — two equal-length runs.
|
|
const openings = [
|
|
span('a', 0.5, 1),
|
|
span('b', 2.5, 1),
|
|
span('c', 4.5, 1),
|
|
span('d', 7.5, 1),
|
|
span('e', 10.5, 1),
|
|
]
|
|
expect(detectEqualSpacing(openings, 'c', 0.03, 0.02)?.openingIds).toEqual(['a', 'b', 'c'])
|
|
})
|
|
|
|
test('computeEdgeGaps suppresses both sides when a sibling overlaps', () => {
|
|
const moving = span('m', 5, 1) // [4.5,5.5]
|
|
const containing = span('s', 5, 2) // [4,6] straddles both edges
|
|
expect(computeEdgeGaps(moving, [containing], WALL, 0.02)).toEqual([])
|
|
})
|
|
|
|
test('alignment detectors ignore the moving opening if present in siblings', () => {
|
|
const moving = span('m', 5, 2, 1.5, 1)
|
|
expect(detectAlongWallAlignment(moving, [moving], 0.08)).toBeNull()
|
|
expect(detectVerticalAlignment(moving, [moving], 0.08)).toBeNull()
|
|
})
|
|
|
|
test('detectAlongWallAlignment reports a negative snap when the feature is past the target', () => {
|
|
const moving = span('m', 5, 2) // centre 5
|
|
const sib = span('s', 4.96, 0.5) // centre 4.96
|
|
const a = detectAlongWallAlignment(moving, [sib], 0.08)
|
|
expect(a?.movingFeature).toBe('center')
|
|
expect(a?.snap).toBeCloseTo(-0.04)
|
|
})
|
|
})
|