@pascal-app/editor 1.0.6 → 1.0.7

package/src/lib/wall-nudge.ts

@@ -0,0 +1,131 @@
+/**
+ * Arrow keys nudge the selected wall square to itself in the floor plan: one
+ * inch a press (a centimetre in metric), or less when a parallel wall it lines
+ * up with comes first (`wall-parallel-snap`), so it stops flush. The arrow's
+ * direction on screen picks the way; an arrow along the wall does nothing.
+ * The nudge is the side arrows' push (`commitRoomPush`), so joined walls
+ * follow, jogs and overlaps come out as when the wall is pushed, and each
+ * press is one undo step.
+ */
+
+import {
+  type AnyNodeId,
+  getPerpendicularWallMoveAxis,
+  useScene,
+  type WallNode,
+  type WallPlanPoint,
+} from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
+import { commitRoomPush } from './room-handle-drag'
+import { levelSeparatorLines, separatorWallLine } from './separator-lines'
+import { nudgeWallPosition, wallParallelTargets } from './wall-parallel-snap'
+
+/** One nudge in feet and inches, in metres. */
+export const WALL_NUDGE_IMPERIAL = 0.0254
+/** One nudge in metric, in metres. */
+export const WALL_NUDGE_METRIC = 0.01
+
+const ARROW_SCREEN_DIRECTIONS: Record<string, [number, number]> = {
+  ArrowUp: [0, -1],
+  ArrowDown: [0, 1],
+  ArrowLeft: [-1, 0],
+  ArrowRight: [1, 0],
+}
+
+// An arrow within about 67° of the wall's own direction runs along it.
+const MIN_ACROSS = 0.4
+
+/** True for the four bare arrow keys. */
+export function isWallNudgeKey(key: string): boolean {
+  return key in ARROW_SCREEN_DIRECTIONS
+}
+
+/**
+ * The plan direction an arrow points on screen: the shown floor plan's scene
+ * transform, turned or not, maps it back. Null when no floor plan is shown.
+ */
+export function floorplanArrowDirection(key: string): WallPlanPoint | null {
+  const screen = ARROW_SCREEN_DIRECTIONS[key]
+  if (!screen || typeof document === 'undefined') return null
+  const scenes = document.querySelectorAll<SVGGraphicsElement>('[data-floorplan-scene]')
+  for (const scene of scenes) {
+    const rect = scene.ownerSVGElement?.getBoundingClientRect()
+    const ctm = scene.getScreenCTM()
+    if (!ctm || !rect || rect.width === 0 || rect.height === 0) continue
+    const inverse = ctm.inverse()
+    const origin = new DOMPoint(0, 0).matrixTransform(inverse)
+    const tip = new DOMPoint(screen[0], screen[1]).matrixTransform(inverse)
+    const dx = tip.x - origin.x
+    const dz = tip.y - origin.y
+    const length = Math.hypot(dx, dz)
+    if (length > 1e-12) return [dx / length, dz / length]
+  }
+  return null
+}
+
+/**
+ * How far (signed, along the wall's move axis) one nudge of `wall` in plan
+ * direction `direction` goes; null when the direction runs along the wall.
+ */
+export function wallNudgeDistance(
+  wall: WallNode,
+  direction: WallPlanPoint,
+  walls: readonly WallNode[],
+  step: number,
+): { axis: WallPlanPoint; distance: number } | null {
+  const axis = getPerpendicularWallMoveAxis(wall.start, wall.end)
+  if (!axis) return null
+  const across = direction[0] * axis[0] + direction[1] * axis[1]
+  if (Math.abs(across) < MIN_ACROSS) return null
+  const position = wall.start[0] * axis[0] + wall.start[1] * axis[1]
+  const end = nudgeWallPosition(
+    wallParallelTargets(wall, axis, walls),
+    position,
+    Math.sign(across) * step,
+  )
+  return { axis, distance: end - position }
+}
+
+/**
+ * Nudge the one selected wall for an arrow key while the floor plan is shown.
+ * An invisible wall nudges the same way, as a line: it stops flush with the
+ * walls and the other invisible walls, and those joined to it follow.
+ * Returns true when the key was used.
+ */
+export function nudgeSelectedWall(key: string): boolean {
+  const { selectedIds } = useViewer.getState().selection
+  if (selectedIds.length !== 1) return false
+  const nodes = useScene.getState().nodes
+  const selected = nodes[selectedIds[0] as AnyNodeId]
+  if (selected?.type !== 'wall' && selected?.type !== 'separator') return false
+  const direction = floorplanArrowDirection(key)
+  if (!direction) return false
+
+  const walls = Object.values(nodes).filter(
+    (entry): entry is WallNode => entry?.type === 'wall' && entry.parentId === selected.parentId,
+  )
+  const step = useViewer.getState().unit === 'imperial' ? WALL_NUDGE_IMPERIAL : WALL_NUDGE_METRIC
+  const nudge =
+    selected.type === 'wall'
+      ? wallNudgeDistance(selected, direction, walls, step)
+      : wallNudgeDistance(
+          separatorWallLine(selected),
+          direction,
+          [...walls, ...levelSeparatorLines(nodes, selected.parentId, new Set([selected.id]))],
+          step,
+        )
+  if (!nudge) return false
+  commitRoomPush(
+    selected.type === 'wall'
+      ? { wallId: selected.id, t0: 0, t1: 1 }
+      : {
+          wallId: selected.id,
+          t0: 0,
+          t1: 1,
+          separators: [{ separatorId: selected.id, t0: 0, t1: 1 }],
+        },
+    nudge.axis,
+    nudge.distance,
+  )
+  return true
+}

package/src/lib/wall-parallel-snap.test.ts

@@ -0,0 +1,83 @@
+import { describe, expect, test } from 'bun:test'
+import { WallNode } from '@pascal-app/core'
+import {
+  nearestWallParallelTarget,
+  nudgeWallPosition,
+  WALL_PARALLEL_SNAP_RADIUS,
+  wallParallelTargets,
+} from './wall-parallel-snap'
+
+const wall = (id: string, start: [number, number], end: [number, number], extra = {}) =>
+  WallNode.parse({ id: `wall_${id}`, start, end, thickness: 0.15, ...extra })
+const outside = { frontSide: 'exterior', backSide: 'interior' } as const
+const DOWN: [number, number] = [0, 1]
+
+describe('wallParallelTargets', () => {
+  test('an outside wall lines up with a parallel outside wall, not a partition', () => {
+    const moving = wall('moving', [5, 0.3], [8, 0.3], outside)
+    const top = wall('top', [0, 0.07], [4, 0.07], outside)
+    const partition = wall('partition', [1, 0.2], [3, 0.2])
+    const side = wall('side', [4, 0.07], [4, 4], outside)
+
+    const targets = wallParallelTargets(moving, DOWN, [moving, top, partition, side])
+
+    expect(targets.map((target) => target.wallId)).toEqual(['wall_top'])
+    expect(targets).toHaveLength(1)
+    expect(targets[0]!.position).toBeCloseTo(0.07)
+    // The guide runs along both walls, on the top wall's outdoor face: frontSide
+    // is the left-normal side, +z for a wall running +x.
+    const [from, to] = [targets[0]!.from, targets[0]!.to]
+    expect([from[0], to[0]]).toEqual([0, 8])
+    expect(from[1]).toBeCloseTo(0.07 + 0.075)
+    expect(to[1]).toBeCloseTo(0.07 + 0.075)
+  })
+
+  test('a partition lines up with every parallel wall', () => {
+    const moving = wall('moving', [1, 2], [3, 2])
+    const top = wall('top', [0, 0], [4, 0], outside)
+    const other = wall('other', [1, 3], [3, 3])
+    const ids = wallParallelTargets(moving, DOWN, [moving, top, other]).map((t) => t.wallId)
+    expect(new Set(ids)).toEqual(new Set(['wall_top', 'wall_other']))
+  })
+
+  test('walls of different thickness line up face to face and centre to centre', () => {
+    const moving = wall('moving', [5, 1], [8, 1], { ...outside, thickness: 0.2 })
+    const top = wall('top', [0, 0], [4, 0], { ...outside, thickness: 0.1 })
+    const positions = wallParallelTargets(moving, DOWN, [top]).map((t) => t.position)
+    // Faces at ±0.05 against ±0.1, and the centres.
+    expect(positions.map((p) => Number(p.toFixed(3))).sort()).toEqual([-0.05, 0, 0.05])
+  })
+
+  test('a reversed or justified wall lines up by its faces', () => {
+    const moving = wall('moving', [8, 1], [5, 1], { ...outside, justification: 'a' })
+    const top = wall('top', [0, 0], [4, 0], outside)
+    const positions = wallParallelTargets(moving, DOWN, [top]).map((t) => t.position)
+    // Justified 'a' on a wall running -x puts its body on the -z side of its
+    // line, so its faces and centre all line up with the top wall's when that
+    // line sits half a thickness below it.
+    expect(positions.map((p) => Number(p.toFixed(3)))).toEqual([0.075])
+  })
+})
+
+describe('nearestWallParallelTarget', () => {
+  test('snaps within the radius and lets go past it', () => {
+    const moving = wall('moving', [5, 0.3], [8, 0.3], outside)
+    const targets = wallParallelTargets(moving, DOWN, [wall('top', [0, 0], [4, 0], outside)])
+    expect(nearestWallParallelTarget(targets, 0.1)?.position).toBeCloseTo(0)
+    expect(nearestWallParallelTarget(targets, WALL_PARALLEL_SNAP_RADIUS + 0.01)).toBeNull()
+  })
+})
+
+describe('nudgeWallPosition', () => {
+  const moving = wall('moving', [5, 0.3], [8, 0.3], outside)
+  const targets = wallParallelTargets(moving, DOWN, [wall('top', [0, 0.29], [4, 0.29], outside)])
+
+  test('stops on a line-up it would pass', () => {
+    expect(nudgeWallPosition(targets, 0.3, -0.0254)).toBeCloseTo(0.29)
+  })
+
+  test('otherwise moves the whole step', () => {
+    expect(nudgeWallPosition(targets, 0.3, 0.0254)).toBeCloseTo(0.3254)
+    expect(nudgeWallPosition(targets, 0.29, -0.0254)).toBeCloseTo(0.2646)
+  })
+})

package/src/lib/wall-parallel-snap.ts

@@ -0,0 +1,176 @@
+/**
+ * Lines a wall that is moving sideways up with the parallel walls around it:
+ * a face onto the face on the same side of another wall, or its body centre
+ * onto theirs. An outside wall broken up by partitions moves one piece at a
+ * time, so each piece can be pulled back flush with the rest of the outside.
+ *
+ * A wall with an outdoor face lines up only with other outside walls; any
+ * other wall lines up with every wall on its level. The 2D and 3D wall moves
+ * snap through here, and the arrow-key nudge stops on these positions.
+ */
+
+import {
+  getWallFaceOffsets,
+  isCurvedWall,
+  type WallNode,
+  type WallPlanPoint,
+} from '@pascal-app/core'
+import useAlignmentGuides from '../store/use-alignment-guides'
+
+/** How near (metres) a moving wall comes to lining up before it snaps there. */
+export const WALL_PARALLEL_SNAP_RADIUS = 0.15
+
+// Walls within about 1° of each other count as parallel.
+const PARALLEL_TOLERANCE = Math.sin(Math.PI / 180)
+const SAME_POSITION = 1e-6
+
+type MovingWall = Pick<
+  WallNode,
+  'id' | 'start' | 'end' | 'thickness' | 'justification' | 'frontSide' | 'backSide'
+> &
+  Partial<Pick<WallNode, 'curveOffset'>>
+
+/**
+ * A position where the moving wall lines up with another: `position` is where
+ * its reference line sits along the move axis, `from` → `to` the shared face
+ * or centre line, drawn along both walls.
+ */
+export type WallParallelTarget = {
+  position: number
+  wallId: string
+  from: WallPlanPoint
+  to: WallPlanPoint
+}
+
+function isOutsideWall(wall: Pick<WallNode, 'frontSide' | 'backSide'>): boolean {
+  return wall.frontSide === 'exterior' || wall.backSide === 'exterior'
+}
+
+function direction(wall: Pick<WallNode, 'start' | 'end'>): WallPlanPoint | null {
+  const dx = wall.end[0] - wall.start[0]
+  const dz = wall.end[1] - wall.start[1]
+  const length = Math.hypot(dx, dz)
+  return length > 1e-9 ? [dx / length, dz / length] : null
+}
+
+const dot = (a: readonly [number, number], b: readonly [number, number]) =>
+  a[0] * b[0] + a[1] * b[1]
+
+// Which way the wall's left normal (-dy, dx) runs along `axis`.
+function normalSign(dir: WallPlanPoint, axis: WallPlanPoint): number {
+  return Math.sign(dot([-dir[1], dir[0]], axis)) || 1
+}
+
+/**
+ * The wall's faces and body centre along `axis`, relative to its reference
+ * line: the face on the axis's positive side, the other face, the centre.
+ */
+function sidePlanes(wall: MovingWall, dir: WallPlanPoint, axis: WallPlanPoint) {
+  const sign = normalSign(dir, axis)
+  const { a, b } = getWallFaceOffsets(wall)
+  const high = Math.max(a * sign, b * sign)
+  const low = Math.min(a * sign, b * sign)
+  return [high, low, (high + low) / 2] as const
+}
+
+/**
+ * The order to try a wall's planes in, so the guide of planes that coincide
+ * is drawn on its outdoor face (frontSide is the left-normal side), else on
+ * its centre.
+ */
+function planeOrder(wall: MovingWall, dir: WallPlanPoint, axis: WallPlanPoint): number[] {
+  const outdoor = wall.frontSide === 'exterior' ? 1 : wall.backSide === 'exterior' ? -1 : 0
+  const outward = outdoor * normalSign(dir, axis)
+  return outward > 0 ? [0, 1, 2] : outward < 0 ? [1, 0, 2] : [2, 0, 1]
+}
+
+/**
+ * Every position along `axis` (a unit vector square to the wall) where `wall`
+ * lines up with a parallel wall in `walls`.
+ */
+export function wallParallelTargets(
+  wall: MovingWall,
+  axis: WallPlanPoint,
+  walls: readonly WallNode[],
+): WallParallelTarget[] {
+  const dir = direction(wall)
+  if (!dir || isCurvedWall(wall)) return []
+  const own = sidePlanes(wall, dir, axis)
+  const outsideOnly = isOutsideWall(wall)
+  const ownSpan = [dot(wall.start, dir), dot(wall.end, dir)]
+  const targets: WallParallelTarget[] = []
+
+  for (const other of walls) {
+    if (other.id === wall.id || isCurvedWall(other)) continue
+    if (outsideOnly && !isOutsideWall(other)) continue
+    const otherDir = direction(other)
+    if (!otherDir || Math.abs(otherDir[0] * dir[1] - otherDir[1] * dir[0]) > PARALLEL_TOLERANCE) {
+      continue
+    }
+    const line = dot(other.start, axis)
+    const planes = sidePlanes(other, otherDir, axis)
+    const along = [...ownSpan, dot(other.start, dir), dot(other.end, dir)]
+    const lo = Math.min(...along)
+    const hi = Math.max(...along)
+    const seen: number[] = []
+    for (const index of planeOrder(other, otherDir, axis)) {
+      const shared = line + planes[index]!
+      const position = shared - own[index]!
+      if (seen.some((value) => Math.abs(value - position) < SAME_POSITION)) continue
+      seen.push(position)
+      targets.push({
+        position,
+        wallId: other.id,
+        from: [dir[0] * lo + axis[0] * shared, dir[1] * lo + axis[1] * shared],
+        to: [dir[0] * hi + axis[0] * shared, dir[1] * hi + axis[1] * shared],
+      })
+    }
+  }
+  return targets
+}
+
+/** The target nearest `position`, if one is within `radius`. */
+export function nearestWallParallelTarget(
+  targets: readonly WallParallelTarget[],
+  position: number,
+  radius = WALL_PARALLEL_SNAP_RADIUS,
+): WallParallelTarget | null {
+  let best: WallParallelTarget | null = null
+  for (const target of targets) {
+    const gap = Math.abs(target.position - position)
+    if (gap > radius) continue
+    if (!best || gap < Math.abs(best.position - position)) best = target
+  }
+  return best
+}
+
+/**
+ * Where a nudge of `step` (signed, along the axis) from `position` ends: the
+ * full step, or the first line-up it passes on the way.
+ */
+export function nudgeWallPosition(
+  targets: readonly WallParallelTarget[],
+  position: number,
+  step: number,
+): number {
+  let end = position + step
+  for (const target of targets) {
+    const travel = (target.position - position) * Math.sign(step)
+    if (travel > SAME_POSITION && travel < Math.abs(step) - SAME_POSITION) {
+      if (Math.abs(target.position - position) < Math.abs(end - position)) end = target.position
+    }
+  }
+  return end
+}
+
+/** Show the line a moving wall has snapped onto (null clears it). */
+export function publishWallParallelGuide(target: WallParallelTarget | null): void {
+  if (!target) {
+    useAlignmentGuides.getState().clear()
+    return
+  }
+  useAlignmentGuides.getState().setDraft({
+    lines: [{ kind: 'alignment', from: target.from, to: target.to }],
+    intersections: [],
+  })
+}

package/src/lib/wall-placement-pointer.test.ts

@@ -4,6 +4,7 @@ import {
   createWallPointerTracker,
   wallPointerInParent,
   wallSideAtPointer,
+  wallSideOfPlanPoint,
 } from './wall-placement-pointer'
 
 test('keeps the grab offset across a pointer gap on the original face', () => {
@@ -40,3 +41,25 @@ test('reads the pointer in the rotated wall parent and identifies its face', ()
   expect(local[1]).toBeCloseTo(3)
   expect(wallSideAtPointer(local)).toBe('back')
 })
+
+test('a plan point reads the wall face it is on, as a 3D hover does', () => {
+  // Along +X the frame's +Z (front) is the plan's +Z side.
+  const wall = {
+    start: [0, 0] as [number, number],
+    end: [4, 0] as [number, number],
+    thickness: 0.2,
+  }
+  expect(wallSideOfPlanPoint(wall, [2, 0.3])).toBe('front')
+  expect(wallSideOfPlanPoint(wall, [2, -0.3])).toBe('back')
+  // Drawn the other way, the same point is on its back.
+  expect(
+    wallSideOfPlanPoint(
+      { ...wall, start: [4, 0] as [number, number], end: [0, 0] as [number, number] },
+      [2, 0.3],
+    ),
+  ).toBe('back')
+  // A justified wall splits at its body's middle, not its reference line.
+  const justified = { ...wall, justification: 'a' as const }
+  expect(wallSideOfPlanPoint(justified, [2, 0.05])).toBe('back')
+  expect(wallSideOfPlanPoint(justified, [2, 0.15])).toBe('front')
+})

package/src/lib/wall-placement-pointer.ts

@@ -1,3 +1,4 @@
+import { getWallBodyCenterOffset, type WallNode } from '@pascal-app/core'
 import { type Object3D, Vector3 } from 'three'
 
 type WallSide = 'front' | 'back'
@@ -55,3 +56,20 @@ export function wallPointerInParent(
 export function wallSideAtPointer(point: readonly number[]): WallSide {
   return point[2]! >= 0 ? 'front' : 'back'
 }
+
+/**
+ * The face of a straight wall a plan point is on, as a 3D hover reports it: `front` is the wall
+ * frame's +Z (the plan side `(-dz, dx)` of start → end), measured from the wall body's centre so a justified
+ * wall splits at its middle. The plan's stand-in for the hovered face's normal.
+ */
+export function wallSideOfPlanPoint(
+  wall: Pick<WallNode, 'start' | 'end' | 'thickness' | 'justification'>,
+  point: readonly [number, number],
+): WallSide {
+  const dx = wall.end[0] - wall.start[0]
+  const dz = wall.end[1] - wall.start[1]
+  const length = Math.hypot(dx, dz)
+  if (length < 1e-9) return 'front'
+  const across = ((point[0] - wall.start[0]) * -dz + (point[1] - wall.start[1]) * dx) / length
+  return across >= getWallBodyCenterOffset(wall) ? 'front' : 'back'
+}