@pascal-app/editor 0.9.1 → 1.0.0-beta.1

package/src/components/editor/use-floorplan-background-placement.ts

@@ -2,24 +2,27 @@
 
 import { emitter, type FenceNode, isCurvedWall, type WallNode } from '@pascal-app/core'
 import { type MouseEvent as ReactMouseEvent, useCallback } from 'react'
+import { resolveCeilingPlanPointSnap } from '../../lib/ceiling-plan-snap'
 import { alignFloorplanDraftPoint, getPlanPointDistance } from '../../lib/floorplan'
+import { resolveSlabPlanPointSnap } from '../../lib/slab-plan-snap'
+import useAlignmentGuides from '../../store/use-alignment-guides'
+import useEditor, { isAngleSnapActive, isMagneticSnapActive } from '../../store/use-editor'
+import usePlacementPreview from '../../store/use-placement-preview'
+import useSegmentDraftChain from '../../store/use-segment-draft-chain'
 import { snapFenceDraftPoint } from '../tools/fence/fence-drafting'
-import {
-  WALL_FINE_GRID_STEP,
-  WALL_GRID_STEP,
-  type WallPlanPoint,
-} from '../tools/wall/wall-drafting'
+import { getSegmentGridStep, type WallPlanPoint } from '../tools/wall/wall-drafting'
 
 type UseFloorplanBackgroundPlacementArgs = {
   activePolygonDraftPoints: WallPlanPoint[]
   ceilingDraftPoints: WallPlanPoint[]
   clearFencePlacementDraft: () => void
   clearRoofPlacementDraft: () => void
+  clearWallPlacementDraft: () => void
   emitFloorplanGridEvent: (
     type: 'click' | 'double-click' | 'move',
     planPoint: WallPlanPoint,
     event: ReactMouseEvent<SVGSVGElement>,
-  ) => WallPlanPoint
+  ) => void
   fenceDraftStart: WallPlanPoint | null
   fences: FenceNode[]
   findClosestWallPoint: (
@@ -40,7 +43,7 @@ type UseFloorplanBackgroundPlacementArgs = {
   ) => boolean
   handleCeilingPlacementPoint: (point: WallPlanPoint) => void
   handleSlabPlacementPoint: (point: WallPlanPoint) => void
-  handleWallPlacementPoint: (point: WallPlanPoint, options?: { singleWall?: boolean }) => void
+  handleWallPlacementPoint: (point: WallPlanPoint) => void
   handleZonePlacementPoint: (point: WallPlanPoint) => void
   isCeilingBuildActive: boolean
   isCeilingItemPlacementActive: boolean
@@ -51,18 +54,19 @@ type UseFloorplanBackgroundPlacementArgs = {
   isRoofBuildActive: boolean
   isWallBuildActive: boolean
   isZoneBuildActive: boolean
+  levelId: string | null
   roofDraftStart: WallPlanPoint | null
   setCursorPoint: React.Dispatch<React.SetStateAction<WallPlanPoint | null>>
   setFenceDraftEnd: React.Dispatch<React.SetStateAction<WallPlanPoint | null>>
   setFenceDraftStart: React.Dispatch<React.SetStateAction<WallPlanPoint | null>>
   setRoofDraftEnd: React.Dispatch<React.SetStateAction<WallPlanPoint | null>>
   setRoofDraftStart: React.Dispatch<React.SetStateAction<WallPlanPoint | null>>
-  shiftPressed: boolean
   snapWallDraftPoint: (args: {
     point: WallPlanPoint
     walls: WallNode[]
     start?: WallPlanPoint
     angleSnap?: boolean
+    bypassSnap?: boolean
     step?: number
     gridSnap?: (point: WallPlanPoint) => WallPlanPoint
   }) => WallPlanPoint
@@ -77,7 +81,7 @@ type UseFloorplanBackgroundPlacementArgs = {
    * Snap a building-local plan point to the world XZ grid at `step`.
    * Injected so the hook doesn't have to know the building's rotation
    * or position — used by wall / fence branches that snap at variable
-   * step (Shift = fine).
+   * step.
    */
   worldGridSnap: (point: WallPlanPoint, step: number) => WallPlanPoint
 }
@@ -87,6 +91,7 @@ export function useFloorplanBackgroundPlacement({
   ceilingDraftPoints,
   clearFencePlacementDraft,
   clearRoofPlacementDraft,
+  clearWallPlacementDraft,
   emitFloorplanGridEvent,
   fenceDraftStart,
   fences,
@@ -107,13 +112,13 @@ export function useFloorplanBackgroundPlacement({
   isRoofBuildActive,
   isWallBuildActive,
   isZoneBuildActive,
+  levelId,
   roofDraftStart,
   setCursorPoint,
   setFenceDraftEnd,
   setFenceDraftStart,
   setRoofDraftEnd,
   setRoofDraftStart,
-  shiftPressed,
   snapWallDraftPoint,
   snapPolygonDraftPoint,
   toPoint2D,
@@ -144,22 +149,29 @@ export function useFloorplanBackgroundPlacement({
             stopPropagation: () => {},
           } as any)
         }
+        // Drop the off-wall ghost on commit so it doesn't linger at the
+        // just-placed spot before the next pointer move re-evaluates.
+        usePlacementPreview.getState().clear()
         return true
       }
 
       if (isCeilingBuildActive) {
-        // Align the committed vertex the same way the move-preview did, so
-        // the placed point matches what the user saw. Skip when angle snap
-        // owns the vertex (matches the move branch).
-        const angleSnap = ceilingDraftPoints.length > 0 && !shiftPressed
-        let snappedPoint = snapPolygonDraftPoint({
+        // Align the committed vertex the same way the move-preview did, so the
+        // placed point matches what the user saw — mode-driven (the chip):
+        // `grid` quantizes, `angles` locks 15° rays, `lines` snaps onto walls /
+        // alignment, `off` is free. Alt remains force/free at commit time.
+        const angleSnap = ceilingDraftPoints.length > 0 && isAngleSnapActive()
+        const fallbackPoint = snapPolygonDraftPoint({
           point: planPoint,
           start: ceilingDraftPoints[ceilingDraftPoints.length - 1],
           angleSnap,
         })
-        if (!angleSnap) {
-          snappedPoint = alignFloorplanDraftPoint(snappedPoint, { bypass: event.altKey })
-        }
+        const snappedPoint = resolveCeilingPlanPointSnap({
+          rawPoint: planPoint,
+          fallbackPoint,
+          levelId,
+          align: !angleSnap,
+        }).point
 
         emitFloorplanGridEvent('click', snappedPoint, event)
         handleCeilingPlacementPoint(snappedPoint)
@@ -167,8 +179,11 @@ export function useFloorplanBackgroundPlacement({
       }
 
       if (isRoofBuildActive) {
+        // Footprint placement (polygon context: grid / lines / off, no angle),
+        // mode-driven to match the chip. Alt is force/free at commit time;
+        // alignment display/pull follows the active magnetic mode.
         const snappedPoint = alignFloorplanDraftPoint(getSnappedFloorplanPoint(planPoint), {
-          bypass: event.altKey,
+          applySnap: isMagneticSnapActive(),
         })
         emitFloorplanGridEvent('click', snappedPoint, event)
         setCursorPoint(snappedPoint)
@@ -183,16 +198,19 @@ export function useFloorplanBackgroundPlacement({
       }
 
       if (isFenceBuildActive) {
-        // Fence draft: grid snap (+ existing-wall/fence endpoint snap), then
-        // Figma alignment — endpoint snap wins (same precedence as move).
-        // `gridSnap` keeps the snap on the world XZ grid even when the
-        // building is rotated.
-        const fenceStep = shiftPressed ? WALL_FINE_GRID_STEP : WALL_GRID_STEP
+        // Fence draft: mode-driven (matches the chip), same as the move
+        // preview. `grid` snaps to the world XZ grid (rotation-safe via the
+        // `gridSnap` callback), `angles` locks 15° rays from the start, `lines`
+        // pulls onto walls / fences / alignment, `off` is free.
+        const fenceStep = getSegmentGridStep()
+        const fenceAngleSnap = fenceDraftStart !== null && isAngleSnapActive()
         const fenceSnapped = snapFenceDraftPoint({
           point: planPoint,
           walls,
           fences,
-          step: shiftPressed ? WALL_FINE_GRID_STEP : undefined,
+          start: fenceDraftStart ?? undefined,
+          angleSnap: fenceAngleSnap,
+          magnetic: isMagneticSnapActive(),
           gridSnap: (p) => worldGridSnap(p, fenceStep),
         })
         const fenceGridBase = worldGridSnap(planPoint, fenceStep)
@@ -200,18 +218,42 @@ export function useFloorplanBackgroundPlacement({
           fenceSnapped[0] !== fenceGridBase[0] || fenceSnapped[1] !== fenceGridBase[1]
         const snappedPoint = fenceLocked
           ? fenceSnapped
-          : alignFloorplanDraftPoint(fenceSnapped, { bypass: event.altKey })
+          : alignFloorplanDraftPoint(fenceSnapped, {
+              applySnap: isMagneticSnapActive() && !fenceAngleSnap,
+            })
 
         emitFloorplanGridEvent('click', snappedPoint, event)
         setCursorPoint(snappedPoint)
 
+        // Double-click finishes the chain. The emit above already made the
+        // 3D fence tool stopDrafting (its detail >= 2 guard), so close the
+        // 2D draft too — leaving it open desyncs the two views.
+        if (fenceDraftStart && event.detail >= 2) {
+          clearFencePlacementDraft()
+          return true
+        }
+
         if (!fenceDraftStart) {
           setFenceDraftStart(snappedPoint)
           setFenceDraftEnd(snappedPoint)
         } else if (
           getPlanPointDistance(toPoint2D(fenceDraftStart), toPoint2D(snappedPoint)) >= 0.01
         ) {
-          clearFencePlacementDraft()
+          // Single mode commits one segment per click: the same emit above
+          // already made the 3D fence tool stopDrafting, so close the 2D
+          // draft too instead of chaining.
+          if (useEditor.getState().getContinuation('fence') === 'single') {
+            clearFencePlacementDraft()
+            setCursorPoint(snappedPoint)
+            return true
+          }
+          // The 3D fence tool owns creation and keeps chaining from the
+          // committed fence's resolved end — chain the 2D draft from the
+          // same published point so both views draft the next segment
+          // from the same start.
+          const nextStart = useSegmentDraftChain.getState().fence ?? snappedPoint
+          setFenceDraftStart(nextStart)
+          setFenceDraftEnd(nextStart)
         } else {
           setFenceDraftEnd(snappedPoint)
         }
@@ -224,15 +266,20 @@ export function useFloorplanBackgroundPlacement({
       // swallow the click and skip local draft state updates — leaving
       // the 2D draft polygon invisible while the 3D tool builds fine).
       if (isPolygonBuildActive) {
-        const angleSnap = activePolygonDraftPoints.length > 0 && !shiftPressed
-        let snappedPoint = snapPolygonDraftPoint({
+        const angleSnap = activePolygonDraftPoints.length > 0 && isAngleSnapActive()
+        const fallbackPoint = snapPolygonDraftPoint({
           point: planPoint,
           start: activePolygonDraftPoints[activePolygonDraftPoints.length - 1],
           angleSnap,
         })
-        if (!angleSnap) {
-          snappedPoint = alignFloorplanDraftPoint(snappedPoint, { bypass: event.altKey })
-        }
+        // Zone shares the slab surface snap (wall corners / midpoints /
+        // crossings + alignment) — it's the same polygon-on-a-level draw.
+        const snappedPoint = resolveSlabPlanPointSnap({
+          rawPoint: planPoint,
+          fallbackPoint,
+          levelId,
+          align: !angleSnap,
+        }).point
 
         // Emit the grid event so the registry-driven slab tool also
         // sees the click (parity with ceiling / fence / roof branches
@@ -255,26 +302,45 @@ export function useFloorplanBackgroundPlacement({
       // / draftEnd state in the floor plan would never update, leaving
       // the dashed-line draft preview invisible.
       if (isWallBuildActive) {
-        // Wall draft: grid snap (+ existing-wall endpoint/join snap), then
-        // Figma alignment — endpoint/join snap wins (same precedence as the
-        // move-preview branch), so committing onto a corner still works.
-        // `gridSnap` keeps the snap on the world XZ grid even when the
-        // building is rotated.
-        const wallStep = shiftPressed ? WALL_FINE_GRID_STEP : WALL_GRID_STEP
+        // Wall draft: mode-driven (matches the chip + the move-preview branch).
+        // `grid` snaps to the world XZ grid (rotation-safe via `gridSnap`),
+        // `angles` locks 15° rays from the start, `lines` pulls the endpoint
+        // onto existing wall corners / edges + alignment, `off` is free.
+        const wallStep = getSegmentGridStep()
+        const wallAngleSnap = draftStart !== null && isAngleSnapActive()
         const wallSnapped = snapWallDraftPoint({
           point: planPoint,
           walls,
-          step: shiftPressed ? WALL_FINE_GRID_STEP : undefined,
+          start: draftStart ?? undefined,
+          angleSnap: wallAngleSnap,
           gridSnap: (p) => worldGridSnap(p, wallStep),
         })
         const wallGridBase = worldGridSnap(planPoint, wallStep)
         const wallLocked = wallSnapped[0] !== wallGridBase[0] || wallSnapped[1] !== wallGridBase[1]
-        const snappedPoint = wallLocked
-          ? wallSnapped
-          : alignFloorplanDraftPoint(wallSnapped, { bypass: false })
+        let snappedPoint = wallSnapped
+        if (wallLocked) {
+          useAlignmentGuides.getState().clear()
+        } else {
+          // Alignment lines are shown in every mode; the pull applies only when
+          // magnetic ('lines') and the segment isn't angle-locked.
+          snappedPoint = alignFloorplanDraftPoint(wallSnapped, {
+            applySnap: isMagneticSnapActive() && !wallAngleSnap,
+          })
+        }
 
         emitFloorplanGridEvent('click', snappedPoint, event)
-        handleWallPlacementPoint(snappedPoint, { singleWall: event.altKey })
+
+        // Double-click finishes the chain. The emit above already made the
+        // 3D wall tool stopDrafting (its detail >= 2 guard), so close the
+        // 2D draft too — otherwise it stays open against a closed 3D tool
+        // and the next previewed segment is silently never created.
+        if (draftStart && event.detail >= 2) {
+          clearWallPlacementDraft()
+          setCursorPoint(snappedPoint)
+          return true
+        }
+
+        handleWallPlacementPoint(snappedPoint)
         return true
       }
 
@@ -291,7 +357,8 @@ export function useFloorplanBackgroundPlacement({
       // local floor-plan draft handler (column / spawn / shelf / etc.).
       // The tool's `grid:click` subscriber owns the placement.
       if (isFloorplanGridInteractionActive) {
-        const snappedPoint = emitFloorplanGridEvent('click', planPoint, event)
+        const snappedPoint = getSnappedFloorplanPoint(planPoint)
+        emitFloorplanGridEvent('click', snappedPoint, event)
         setCursorPoint(snappedPoint)
         return true
       }
@@ -303,6 +370,7 @@ export function useFloorplanBackgroundPlacement({
       ceilingDraftPoints,
       clearFencePlacementDraft,
       clearRoofPlacementDraft,
+      clearWallPlacementDraft,
       emitFloorplanGridEvent,
       fenceDraftStart,
       fences,
@@ -322,13 +390,13 @@ export function useFloorplanBackgroundPlacement({
       isRoofBuildActive,
       isWallBuildActive,
       isZoneBuildActive,
+      levelId,
       roofDraftStart,
       setCursorPoint,
       setFenceDraftEnd,
       setFenceDraftStart,
       setRoofDraftEnd,
       setRoofDraftStart,
-      shiftPressed,
       snapWallDraftPoint,
       snapPolygonDraftPoint,
       toPoint2D,

package/src/components/editor/use-floorplan-hit-testing.test.ts

@@ -0,0 +1,82 @@
+import { describe, expect, test } from 'bun:test'
+import { collectRegistrySelectionIdsInBounds } from './use-floorplan-hit-testing'
+
+const identityMatrix = {
+  inverse() {
+    return this
+  },
+}
+
+function pointFactory() {
+  return {
+    x: 0,
+    y: 0,
+    matrixTransform() {
+      return pointFactoryWithPosition(this.x, this.y)
+    },
+  }
+}
+
+function pointFactoryWithPosition(x: number, y: number) {
+  return {
+    x,
+    y,
+    matrixTransform() {
+      return pointFactoryWithPosition(x, y)
+    },
+  }
+}
+
+function geometry(x: number, y: number, width: number, height: number) {
+  return {
+    getBBox: () => ({ x, y, width, height }),
+    getScreenCTM: () => identityMatrix,
+  } as unknown as SVGGraphicsElement
+}
+
+function entry(nodeId: string, children: SVGGraphicsElement[]) {
+  return {
+    dataset: { nodeId },
+    querySelectorAll: () => children,
+  } as unknown as SVGGElement
+}
+
+function scene(entries: SVGGElement[]) {
+  return {
+    getScreenCTM: () => identityMatrix,
+    ownerSVGElement: {
+      createSVGPoint: pointFactory,
+    },
+    querySelectorAll: () => entries,
+  } as unknown as SVGGElement
+}
+
+describe('collectRegistrySelectionIdsInBounds', () => {
+  test('selects rendered registry geometry and preserves candidate order', () => {
+    const renderedScene = scene([
+      entry('wall_1', [geometry(0, 0, 4, 0.2)]),
+      entry('door_1', [geometry(1, 1, 0.9, 0.9)]),
+      entry('outside_1', [geometry(20, 20, 1, 1)]),
+    ])
+
+    expect(
+      collectRegistrySelectionIdsInBounds(renderedScene, { minX: -1, minY: -1, maxX: 5, maxY: 5 }, [
+        'door_1',
+        'outside_1',
+        'wall_1',
+      ]),
+    ).toEqual(['door_1', 'wall_1'])
+  })
+
+  test('ignores rendered entries outside the selectable registry candidates', () => {
+    const renderedScene = scene([entry('zone_1', [geometry(0, 0, 2, 2)])])
+
+    expect(
+      collectRegistrySelectionIdsInBounds(
+        renderedScene,
+        { minX: -1, minY: -1, maxX: 3, maxY: 3 },
+        [],
+      ),
+    ).toEqual([])
+  })
+})