@pascal-app/editor 0.8.0 → 0.9.1

package/src/components/tools/tool-manager.tsx

@@ -2,55 +2,52 @@ import {
   type AnyNodeId,
   type BuildingNode,
   type CeilingNode,
+  nodeRegistry,
   type SlabNode,
   useScene,
 } from '@pascal-app/core'
 import { useViewer } from '@pascal-app/viewer'
+import { type ComponentType, lazy, Suspense } from 'react'
 import useEditor, { type Phase, type Tool } from '../../store/use-editor'
-import { CeilingBoundaryEditor } from './ceiling/ceiling-boundary-editor'
-import { CeilingHoleEditor } from './ceiling/ceiling-hole-editor'
-import { CeilingTool } from './ceiling/ceiling-tool'
-import { ColumnTool } from './column/column-tool'
-import { DoorTool } from './door/door-tool'
-import { CurveFenceTool } from './fence/curve-fence-tool'
-import { FenceTool } from './fence/fence-tool'
-import { MoveFenceEndpointTool } from './fence/move-fence-endpoint-tool'
-import { ItemTool } from './item/item-tool'
+import { Alignment3DGuideLayer } from '../editor/alignment-3d-guide-layer'
+import { WallSnapBeaconLayer } from '../editor/wall-snap-beacon-layer'
+import { ElevatorTool } from './elevator/elevator-tool'
 import { MoveTool } from './item/move-tool'
 import { RoofTool } from './roof/roof-tool'
+import { getRegistryAffordanceTool } from './shared/affordance-dispatch'
 import { SiteBoundaryEditor } from './site/site-boundary-editor'
-import { SlabBoundaryEditor } from './slab/slab-boundary-editor'
-import { SlabHoleEditor } from './slab/slab-hole-editor'
-import { SlabTool } from './slab/slab-tool'
-import { SpawnTool } from './spawn/spawn-tool'
 import { StairTool } from './stair/stair-tool'
-import { CurveWallTool } from './wall/curve-wall-tool'
-import { MoveWallEndpointTool } from './wall/move-wall-endpoint-tool'
-import { WallTool } from './wall/wall-tool'
-import { WindowTool } from './window/window-tool'
 import { ZoneBoundaryEditor } from './zone/zone-boundary-editor'
 import { ZoneTool } from './zone/zone-tool'
 
+// Cache lazy tool components keyed by their loader so React.lazy isn't
+// re-invoked across renders.
+const lazyToolCache = new WeakMap<() => Promise<unknown>, ComponentType>()
+
+function getRegistryTool(tool: Tool | null): ComponentType | null {
+  if (!tool) return null
+  const def = nodeRegistry.get(tool)
+  if (!def?.tool) return null
+  const cached = lazyToolCache.get(def.tool)
+  if (cached) return cached
+  const Comp = lazy(def.tool as () => Promise<{ default: ComponentType }>)
+  lazyToolCache.set(def.tool, Comp)
+  return Comp
+}
+
+// Legacy tool fallbacks — kinds whose placement tools haven't migrated
+// to `def.tool` yet. Wall / fence / slab / ceiling / door / window /
+// item / shelf / spawn now go through the registry path above.
 const tools: Record<Phase, Partial<Record<Tool, React.FC>>> = {
   site: {
     'property-line': SiteBoundaryEditor,
   },
   structure: {
-    wall: WallTool,
-    fence: FenceTool,
-    slab: SlabTool,
-    ceiling: CeilingTool,
     roof: RoofTool,
     stair: StairTool,
-    door: DoorTool,
-    item: ItemTool,
     zone: ZoneTool,
-    spawn: SpawnTool,
-    window: WindowTool,
-  },
-  furnish: {
-    item: ItemTool,
   },
+  furnish: {},
 }
 
 export const ToolManager: React.FC = () => {
@@ -67,6 +64,7 @@ export const ToolManager: React.FC = () => {
   const selectedIds = useViewer((state) => state.selection.selectedIds)
   const buildingId = useViewer((state) => state.selection.buildingId)
   const activeLevelId = useViewer((state) => state.selection.levelId)
+  const setSelection = useViewer((state) => state.setSelection)
   const nodes = useScene((state) => state.nodes)
 
   // Building transform for the local group — all building-relative tools live inside this group
@@ -81,25 +79,34 @@ export const ToolManager: React.FC = () => {
   const selectedSlabId = selectedIds.find((id) => nodes[id as AnyNodeId]?.type === 'slab') as
     | SlabNode['id']
     | undefined
+  const selectedSlab = selectedSlabId ? (nodes[selectedSlabId as AnyNodeId] as SlabNode) : null
+  const editingSlabHoleIsManual =
+    selectedSlabId !== undefined &&
+    editingHole?.nodeId === selectedSlabId &&
+    selectedSlab?.holeMetadata?.[editingHole.holeIndex]?.source === 'manual'
 
   // Check if a ceiling is selected
   const selectedCeilingId = selectedIds.find((id) => nodes[id as AnyNodeId]?.type === 'ceiling') as
     | CeilingNode['id']
     | undefined
 
-  // Show site boundary editor when in site phase (toggle controls entry/exit)
-  const showSiteBoundaryEditor = phase === 'site'
+  // Keep the site vertex flags available in select mode; the editor component
+  // switches to full polygon editing only after a flag activates site mode.
+  const showSiteBoundaryEditor = phase === 'site' || mode === 'select'
 
   // Show slab boundary editor when in structure/select mode with a slab selected (but not editing a hole)
   const showSlabBoundaryEditor =
     phase === 'structure' &&
     mode === 'select' &&
     selectedSlabId !== undefined &&
-    (!editingHole || editingHole.nodeId !== selectedSlabId)
+    !editingSlabHoleIsManual
 
   // Show slab hole editor when editing a hole on the selected slab
   const showSlabHoleEditor =
-    selectedSlabId !== undefined && editingHole !== null && editingHole.nodeId === selectedSlabId
+    selectedSlabId !== undefined &&
+    editingHole !== null &&
+    editingHole.nodeId === selectedSlabId &&
+    editingSlabHoleIsManual
 
   // Show ceiling boundary editor when in structure/select mode with a ceiling selected (but not editing a hole)
   const showCeilingBoundaryEditor =
@@ -126,16 +133,38 @@ export const ToolManager: React.FC = () => {
   // Show build tools when in build mode
   const showBuildTool = mode === 'build' && tool !== null
 
-  const BuildToolComponent = showBuildTool ? tools[phase]?.[tool] : null
+  // Registry-first: if the active tool's kind has a NodeDefinition with a
+  // tool contribution, the registry-driven tool takes over.
+  const RegistryToolComponent = showBuildTool ? getRegistryTool(tool) : null
+  const useRegistryTool = RegistryToolComponent != null
+
+  const BuildToolComponent = showBuildTool && !useRegistryTool ? tools[phase]?.[tool] : null
   const handlePlacedNodeSelected = (nodeId: AnyNodeId) => {
-    useViewer.getState().setSelection({ selectedIds: [nodeId] })
+    setSelection({ selectedIds: [nodeId] })
+  }
+  const handlePlacedElevatorSelected = (
+    nodeId: AnyNodeId,
+    elevatorBuildingId: BuildingNode['id'],
+  ) => {
+    // Preserve the active level. `setSelection`'s hierarchy guard nulls
+    // `levelId` whenever `buildingId` is passed without an explicit
+    // `levelId` — which deselected the current floor plan the moment an
+    // elevator was placed. Pass the current level through so the floor
+    // plan stays selected.
+    setSelection({
+      buildingId: elevatorBuildingId,
+      levelId: activeLevelId ?? null,
+      selectedIds: [nodeId],
+    })
   }
 
   return (
     <>
       {/* World-space tools: site boundary and building movement operate in world coordinates */}
       {showSiteBoundaryEditor && <SiteBoundaryEditor />}
-      {movingNode?.type === 'building' && <MoveTool onSpawnMoved={handlePlacedNodeSelected} />}
+      {movingNode?.type === 'building' && (
+        <MoveTool onNodeMoved={handlePlacedNodeSelected} onSpawnMoved={handlePlacedNodeSelected} />
+      )}
 
       {/* Building-local group: all other tools are relative to the selected building.
           Cursor visuals set positions in building-local space; this group applies the
@@ -145,30 +174,117 @@ export const ToolManager: React.FC = () => {
         rotation={buildingRotation as [number, number, number]}
       >
         {showZoneBoundaryEditor && selectedZoneId && <ZoneBoundaryEditor zoneId={selectedZoneId} />}
-        {showSlabBoundaryEditor && selectedSlabId && <SlabBoundaryEditor slabId={selectedSlabId} />}
-        {showSlabHoleEditor && selectedSlabId && editingHole && (
-          <SlabHoleEditor holeIndex={editingHole.holeIndex} slabId={selectedSlabId} />
-        )}
-        {showCeilingBoundaryEditor && selectedCeilingId && (
-          <CeilingBoundaryEditor ceilingId={selectedCeilingId} />
+        {showSlabBoundaryEditor &&
+          selectedSlabId &&
+          (() => {
+            const Registry = getRegistryAffordanceTool('slab', 'boundary-edit')
+            return Registry ? (
+              <Suspense fallback={null}>
+                <Registry slabId={selectedSlabId} />
+              </Suspense>
+            ) : null
+          })()}
+        {showSlabHoleEditor &&
+          selectedSlabId &&
+          editingHole &&
+          (() => {
+            const Registry = getRegistryAffordanceTool('slab', 'hole-edit')
+            return Registry ? (
+              <Suspense fallback={null}>
+                <Registry holeIndex={editingHole.holeIndex} slabId={selectedSlabId} />
+              </Suspense>
+            ) : null
+          })()}
+        {showCeilingBoundaryEditor &&
+          selectedCeilingId &&
+          (() => {
+            const Registry = getRegistryAffordanceTool('ceiling', 'boundary-edit')
+            return Registry ? (
+              <Suspense fallback={null}>
+                <Registry ceilingId={selectedCeilingId} />
+              </Suspense>
+            ) : null
+          })()}
+        {showCeilingHoleEditor &&
+          selectedCeilingId &&
+          editingHole &&
+          (() => {
+            const Registry = getRegistryAffordanceTool('ceiling', 'hole-edit')
+            return Registry ? (
+              <Suspense fallback={null}>
+                <Registry ceilingId={selectedCeilingId} holeIndex={editingHole.holeIndex} />
+              </Suspense>
+            ) : null
+          })()}
+        {movingWallEndpoint &&
+          (() => {
+            const RegistryAffordance = getRegistryAffordanceTool(
+              movingWallEndpoint.wall.type,
+              'move-endpoint',
+            )
+            return RegistryAffordance ? (
+              <Suspense fallback={null}>
+                <RegistryAffordance target={movingWallEndpoint} />
+              </Suspense>
+            ) : null
+          })()}
+        {movingFenceEndpoint &&
+          (() => {
+            const RegistryAffordance = getRegistryAffordanceTool(
+              movingFenceEndpoint.fence.type,
+              'move-endpoint',
+            )
+            return RegistryAffordance ? (
+              <Suspense fallback={null}>
+                <RegistryAffordance target={movingFenceEndpoint} />
+              </Suspense>
+            ) : null
+          })()}
+        {curvingWall &&
+          (() => {
+            const Registry = getRegistryAffordanceTool(curvingWall.type, 'curve')
+            return Registry ? (
+              <Suspense fallback={null}>
+                <Registry node={curvingWall} />
+              </Suspense>
+            ) : null
+          })()}
+        {curvingFence &&
+          (() => {
+            const RegistryAffordance = getRegistryAffordanceTool(curvingFence.type, 'curve')
+            return RegistryAffordance ? (
+              <Suspense fallback={null}>
+                <RegistryAffordance node={curvingFence} />
+              </Suspense>
+            ) : null
+          })()}
+        {movingNode && movingNode.type !== 'building' && (
+          <MoveTool
+            onNodeMoved={handlePlacedNodeSelected}
+            onSpawnMoved={handlePlacedNodeSelected}
+          />
         )}
-        {showCeilingHoleEditor && selectedCeilingId && editingHole && (
-          <CeilingHoleEditor ceilingId={selectedCeilingId} holeIndex={editingHole.holeIndex} />
+        {/* Registry-first: when the active tool's kind has a registered
+            NodeDefinition with a tool contribution, mount it here. */}
+        {!movingNode && useRegistryTool && RegistryToolComponent && (
+          <Suspense fallback={null}>
+            <RegistryToolComponent />
+          </Suspense>
         )}
-        {movingWallEndpoint && <MoveWallEndpointTool target={movingWallEndpoint} />}
-        {movingFenceEndpoint && <MoveFenceEndpointTool target={movingFenceEndpoint} />}
-        {curvingWall && <CurveWallTool node={curvingWall} />}
-        {curvingFence && <CurveFenceTool node={curvingFence} />}
-        {movingNode && movingNode.type !== 'building' && (
-          <MoveTool onSpawnMoved={handlePlacedNodeSelected} />
+        {!movingNode && !useRegistryTool && showBuildTool && tool === 'elevator' && (
+          <ElevatorTool
+            buildingId={buildingId as BuildingNode['id'] | null}
+            levelId={activeLevelId ?? null}
+            onPlaced={handlePlacedElevatorSelected}
+          />
         )}
-        {!movingNode && BuildToolComponent && tool === 'spawn' ? (
-          <SpawnTool currentLevelId={activeLevelId ?? null} onPlaced={handlePlacedNodeSelected} />
-        ) : !movingNode && showBuildTool && tool === 'column' ? (
-          <ColumnTool currentLevelId={activeLevelId ?? null} onPlaced={handlePlacedNodeSelected} />
-        ) : !movingNode && BuildToolComponent && tool !== 'column' ? (
-          <BuildToolComponent />
-        ) : null}
+        {!movingNode && BuildToolComponent && tool !== 'elevator' ? <BuildToolComponent /> : null}
+        {/* Figma-style alignment guides published by the move / placement
+            tools above. Lives inside the building-local group so the
+            building-local guide coords render at the right world position. */}
+        <Alignment3DGuideLayer />
+        {/* "Magnetic" beacon at the active wall-draft snap point. */}
+        <WallSnapBeaconLayer />
       </group>
     </>
   )

package/src/components/tools/wall/wall-drafting.ts

@@ -3,10 +3,7 @@ import {
   type AnyNodeId,
   type DoorNode,
   getScaledDimensions,
-  getWallCurveFrameAt,
-  getWallCurveLength,
   type ItemNode,
-  isCurvedWall,
   useScene,
   type WallNode,
   WallNode as WallSchema,
@@ -15,11 +12,30 @@ import {
 import { useViewer } from '@pascal-app/viewer'
 import { sfxEmitter } from '../../../lib/sfx-bus'
 import useEditor from '../../../store/use-editor'
-
-export type WallPlanPoint = [number, number]
+import {
+  distanceSquared,
+  findWallSnapTarget,
+  findWallSpecialPointSnap,
+  projectPointOntoWall,
+  WALL_JOIN_SNAP_RADIUS,
+  type WallDraftSnapResult,
+  type WallPlanPoint,
+} from './wall-snap-geometry'
+
+// The pure snap geometry lives in `./wall-snap-geometry`; re-exported here so
+// existing importers (fence drafting, the editor barrel) keep their paths.
+export {
+  findWallSnapTarget,
+  WALL_JOIN_SNAP_RADIUS,
+  type WallDraftSnapKind,
+  type WallDraftSnapResult,
+  type WallPlanPoint,
+} from './wall-snap-geometry'
 
 export const WALL_GRID_STEP = 0.5
-export const WALL_JOIN_SNAP_RADIUS = 0.35
+// Smallest available grid snap. Used as a precision-mode step (Shift +
+// drag) so a drag can land on values the regular grid skips.
+export const WALL_FINE_GRID_STEP = 0.05
 export const WALL_MIN_LENGTH = 0.01
 const DEFAULT_WALL_ANGLE_SNAP_STEP = Math.PI / 4
 
@@ -35,13 +51,7 @@ type WallSplitIntersection = {
   point: WallPlanPoint
 }
 
-function distanceSquared(a: WallPlanPoint, b: WallPlanPoint): number {
-  const dx = a[0] - b[0]
-  const dz = a[1] - b[1]
-  return dx * dx + dz * dz
-}
-
-export function getWallGridStep(): number {
+export function getSegmentGridStep(): number {
   return useEditor.getState().gridSnapStep
 }
 
@@ -58,41 +68,30 @@ export function snapPointTo45Degrees(
   cursor: WallPlanPoint,
   step = WALL_GRID_STEP,
   angleStep = DEFAULT_WALL_ANGLE_SNAP_STEP,
+  /**
+   * Optional grid-snap callback. Lets the caller route the final
+   * snap through a world-XZ grid (or any other axis system) instead
+   * of the local-axis grid `snapPointToGrid` uses. When omitted,
+   * falls back to the local-axis snap at `step`.
+   */
+  gridSnap?: (point: WallPlanPoint) => WallPlanPoint,
 ): WallPlanPoint {
   const dx = cursor[0] - start[0]
   const dz = cursor[1] - start[1]
   const angle = Math.atan2(dz, dx)
   const snappedAngle = Math.round(angle / angleStep) * angleStep
   const distance = Math.sqrt(dx * dx + dz * dz)
-
-  return snapPointToGrid(
-    [start[0] + Math.cos(snappedAngle) * distance, start[1] + Math.sin(snappedAngle) * distance],
-    step,
-  )
+  const point: WallPlanPoint = [
+    start[0] + Math.cos(snappedAngle) * distance,
+    start[1] + Math.sin(snappedAngle) * distance,
+  ]
+  return gridSnap ? gridSnap(point) : snapPointToGrid(point, step)
 }
 
-export function getWallAngleSnapStep(step = getWallGridStep()): number {
+export function getWallAngleSnapStep(step = getSegmentGridStep()): number {
   return WALL_ANGLE_SNAP_BY_GRID_STEP[step] ?? DEFAULT_WALL_ANGLE_SNAP_STEP
 }
 
-function projectPointOntoWall(point: WallPlanPoint, wall: WallNode): WallPlanPoint | null {
-  const [x1, z1] = wall.start
-  const [x2, z2] = wall.end
-  const dx = x2 - x1
-  const dz = z2 - z1
-  const lengthSquared = dx * dx + dz * dz
-  if (lengthSquared < 1e-9) {
-    return null
-  }
-
-  const t = ((point[0] - x1) * dx + (point[1] - z1) * dz) / lengthSquared
-  if (t <= 0 || t >= 1) {
-    return null
-  }
-
-  return [x1 + dx * t, z1 + dz * t]
-}
-
 function splitWallAtPoint(wall: WallNode, splitPoint: WallPlanPoint): [WallNode, WallNode] {
   const { id: _id, parentId: _parentId, children, ...rest } = wall
 
@@ -324,76 +323,72 @@ function splitWallIfNeeded(
   }
 }
 
-export function findWallSnapTarget(
-  point: WallPlanPoint,
-  walls: WallNode[],
-  options?: { ignoreWallIds?: string[]; radius?: number },
-): WallPlanPoint | null {
-  const ignoreWallIds = new Set(options?.ignoreWallIds ?? [])
-  const radiusSquared = (options?.radius ?? WALL_JOIN_SNAP_RADIUS) ** 2
-  let bestTarget: WallPlanPoint | null = null
-  let bestDistanceSquared = Number.POSITIVE_INFINITY
-
-  for (const wall of walls) {
-    if (ignoreWallIds.has(wall.id)) {
-      continue
-    }
-
-    const candidates: Array<WallPlanPoint | null> = [wall.start, wall.end]
-
-    if (isCurvedWall(wall)) {
-      const sampleCount = Math.max(8, Math.ceil(getWallCurveLength(wall) / 0.3))
-      for (let index = 0; index <= sampleCount; index += 1) {
-        const frame = getWallCurveFrameAt(wall, index / sampleCount)
-        candidates.push([frame.point.x, frame.point.y])
-      }
-    } else {
-      candidates.push(projectPointOntoWall(point, wall))
-    }
-    for (const candidate of candidates) {
-      if (!candidate) {
-        continue
-      }
-
-      const candidateDistanceSquared = distanceSquared(point, candidate)
-      if (
-        candidateDistanceSquared > radiusSquared ||
-        candidateDistanceSquared >= bestDistanceSquared
-      ) {
-        continue
-      }
-
-      bestTarget = candidate
-      bestDistanceSquared = candidateDistanceSquared
-    }
-  }
-
-  return bestTarget
-}
-
-export function snapWallDraftPoint(args: {
+type SnapWallDraftArgs = {
   point: WallPlanPoint
   walls: WallNode[]
   start?: WallPlanPoint
   angleSnap?: boolean
   ignoreWallIds?: string[]
-}): WallPlanPoint {
-  const { point, walls, start, angleSnap = false, ignoreWallIds } = args
-  const step = getWallGridStep()
+  /** Override the grid step (e.g. `WALL_FINE_GRID_STEP` for precision mode). */
+  step?: number
+  /**
+   * Magnetic snapping to existing wall geometry (corners, midpoints,
+   * crossings, wall bodies). When `false`, only grid/angle snap applies and
+   * `snap` is always `null`. Defaults to `true` so callers that don't care
+   * keep the prior behaviour.
+   */
+  magnetic?: boolean
+  /**
+   * Optional grid-snap override. Lets the caller route grid snapping
+   * through a world-XZ aligned snap (so a rotated building's draft
+   * lands on the visible grid). When omitted, falls back to the
+   * local-axis grid at `step`.
+   */
+  gridSnap?: (point: WallPlanPoint) => WallPlanPoint
+}
+
+export function snapWallDraftPointDetailed(args: SnapWallDraftArgs): WallDraftSnapResult {
+  const {
+    point,
+    walls,
+    start,
+    angleSnap = false,
+    ignoreWallIds,
+    step: overrideStep,
+    magnetic = true,
+    gridSnap,
+  } = args
+
+  // Discrete special points (corner / midpoint / crossing) are taken from the
+  // raw cursor so an interim grid snap can't mask them. A corner always wins,
+  // then the nearer of midpoint / crossing — see `findWallSpecialPointSnap`.
+  if (magnetic) {
+    const special = findWallSpecialPointSnap(point, walls, ignoreWallIds)
+    if (special) return special
+  }
+
+  const step = overrideStep ?? getSegmentGridStep()
   const angleStep = getWallAngleSnapStep(step)
   const basePoint =
     start && angleSnap
-      ? snapPointTo45Degrees(start, point, step, angleStep)
-      : snapPointToGrid(point, step)
+      ? snapPointTo45Degrees(start, point, step, angleStep, gridSnap)
+      : gridSnap
+        ? gridSnap(point)
+        : snapPointToGrid(point, step)
+
+  if (magnetic) {
+    const wallSnap = findWallSnapTarget(basePoint, walls, { ignoreWallIds })
+    if (wallSnap) return { point: wallSnap, snap: 'wall' }
+  }
 
-  return (
-    findWallSnapTarget(basePoint, walls, {
-      ignoreWallIds,
-    }) ?? basePoint
-  )
+  return { point: basePoint, snap: null }
+}
+
+export function snapWallDraftPoint(args: SnapWallDraftArgs): WallPlanPoint {
+  return snapWallDraftPointDetailed(args).point
 }
 
-export function isWallLongEnough(start: WallPlanPoint, end: WallPlanPoint): boolean {
+export function isSegmentLongEnough(start: WallPlanPoint, end: WallPlanPoint): boolean {
   return distanceSquared(start, end) >= WALL_MIN_LENGTH * WALL_MIN_LENGTH
 }
 
@@ -405,7 +400,7 @@ export function createWallOnCurrentLevel(
   const { createNode, createNodes, deleteNode, nodes } = useScene.getState()
   const { updateNodes } = useScene.getState()
 
-  if (!(currentLevelId && isWallLongEnough(start, end))) {
+  if (!(currentLevelId && isSegmentLongEnough(start, end))) {
     return null
   }
 
@@ -444,7 +439,7 @@ export function createWallOnCurrentLevel(
     resolvedStart = splitStart.point
   }
 
-  if (!isWallLongEnough(resolvedStart, resolvedEnd) || pointsEqual(resolvedStart, resolvedEnd)) {
+  if (!isSegmentLongEnough(resolvedStart, resolvedEnd) || pointsEqual(resolvedStart, resolvedEnd)) {
     return null
   }
 
@@ -458,7 +453,12 @@ export function createWallOnCurrentLevel(
   }
 
   const wallCount = Object.values(nodes).filter((node) => node.type === 'wall').length
+  // A placed wall preset seeds `toolDefaults.wall` (thickness, height,
+  // materials, sides) before the tool activates; merge those first so the
+  // drawn wall reproduces the preset. Identity + endpoints always win.
+  const defaults = useEditor.getState().toolDefaults.wall ?? {}
   const wall = WallSchema.parse({
+    ...defaults,
     name: `Wall ${wallCount + 1}`,
     start: resolvedStart,
     end: resolvedEnd,

package/src/components/tools/wall/wall-snap-geometry.test.ts

@@ -0,0 +1,79 @@
+import { describe, expect, test } from 'bun:test'
+import type { WallNode } from '@pascal-app/core'
+import {
+  findWallSnapTarget,
+  findWallSpecialPointSnap,
+  type WallPlanPoint,
+} from './wall-snap-geometry'
+
+function makeWall(start: WallPlanPoint, end: WallPlanPoint, id?: string): WallNode {
+  return {
+    object: 'node',
+    id: (id ?? `wall_${start.join('_')}_${end.join('_')}`) as WallNode['id'],
+    type: 'wall',
+    name: 'Wall',
+    parentId: null,
+    visible: true,
+    metadata: {},
+    children: [],
+    start,
+    end,
+    thickness: 0.1,
+    frontSide: 'unknown',
+    backSide: 'unknown',
+  } as unknown as WallNode
+}
+
+describe('findWallSpecialPointSnap', () => {
+  test('snaps to a wall corner (endpoint) when near it', () => {
+    const walls = [makeWall([0, 0], [4, 0])]
+    const result = findWallSpecialPointSnap([0.1, 0.1], walls)
+    expect(result?.snap).toBe('endpoint')
+    expect(result?.point).toEqual([0, 0])
+  })
+
+  test('snaps to a wall midpoint when near it (not a corner)', () => {
+    const walls = [makeWall([0, 0], [4, 0])]
+    const result = findWallSpecialPointSnap([2.1, 0.2], walls)
+    expect(result?.snap).toBe('midpoint')
+    expect(result?.point).toEqual([2, 0])
+  })
+
+  test('snaps to the crossing of two walls (intersection)', () => {
+    // A runs along z=0; B crosses it at x=1. B's own midpoint is [1,1], far
+    // from the crossing, so the snap is the intersection, not a midpoint.
+    const walls = [makeWall([0, 0], [4, 0], 'a'), makeWall([1, -1], [1, 3], 'b')]
+    const result = findWallSpecialPointSnap([1.1, 0.1], walls)
+    expect(result?.snap).toBe('intersection')
+    expect(result?.point[0]).toBeCloseTo(1, 6)
+    expect(result?.point[1]).toBeCloseTo(0, 6)
+  })
+
+  test('corner wins over a midpoint when both are in range', () => {
+    const walls = [makeWall([0, 0], [1, 0])]
+    const result = findWallSpecialPointSnap([0.9, 0.1], walls)
+    expect(result?.snap).toBe('endpoint')
+    expect(result?.point).toEqual([1, 0])
+  })
+
+  test('returns null when no special point is in range', () => {
+    const walls = [makeWall([0, 0], [4, 0])]
+    // Near the wall body but far from corner/midpoint — that's an edge snap,
+    // handled separately by findWallSnapTarget, not a special point.
+    expect(findWallSpecialPointSnap([1.2, 0.1], walls)).toBeNull()
+  })
+})
+
+describe('findWallSnapTarget (edge / along-wall)', () => {
+  test('projects onto a wall body within range', () => {
+    const walls = [makeWall([0, 0], [4, 0])]
+    const result = findWallSnapTarget([1.2, 0.1], walls)
+    expect(result?.[0]).toBeCloseTo(1.2, 6)
+    expect(result?.[1]).toBeCloseTo(0, 6)
+  })
+
+  test('returns null when too far from any wall', () => {
+    const walls = [makeWall([0, 0], [4, 0])]
+    expect(findWallSnapTarget([1.2, 2], walls)).toBeNull()
+  })
+})