@pascal-app/editor 0.9.1 → 0.9.2

package/src/lib/slab-plan-snap.ts

@@ -0,0 +1,108 @@
+import { type AnyNode, snapSlabEdgeToWallBand, useScene } from '@pascal-app/core'
+import { WALL_CONNECT_SNAP_RADIUS } from '../components/tools/wall/wall-drafting'
+import useAlignmentGuides from '../store/use-alignment-guides'
+import { isMagneticSnapActive } from '../store/use-editor'
+import useWallSnapIndicator from '../store/use-wall-snap-indicator'
+import {
+  clearSurfacePlanSnapFeedback,
+  getLevelWalls,
+  resolveSurfacePlanPointSnap,
+  SURFACE_ALIGNMENT_THRESHOLD_M,
+  type SurfacePlanSnapInput,
+  type SurfacePlanSnapResult,
+} from './surface-plan-snap'
+
+const SLAB_SNAP_MOVING_ID = '__slab_snap__'
+
+export const SLAB_ALIGNMENT_THRESHOLD_M = SURFACE_ALIGNMENT_THRESHOLD_M
+export type SlabPlanSnapInput = SurfacePlanSnapInput
+export type SlabPlanSnapResult = SurfacePlanSnapResult
+
+export function clearSlabSnapFeedback() {
+  clearSurfacePlanSnapFeedback()
+}
+
+export function resolveSlabPlanPointSnap(input: SlabPlanSnapInput): SlabPlanSnapResult {
+  return resolveSurfacePlanPointSnap({
+    ...input,
+    highlightWalls: input.highlightWalls ?? false,
+    movingId: input.movingId ?? SLAB_SNAP_MOVING_ID,
+  })
+}
+
+export type SlabEdgeBandSnapInput = {
+  /** Candidate edge endpoints after the raw/grid perpendicular translation. */
+  edge: [[number, number], [number, number]]
+  levelId?: string | null
+  nodes?: Readonly<Record<string, AnyNode>>
+  /**
+   * Plan point (typically the cursor) the snap beacon should hug along
+   * the wall. Falls back to the snapped edge's midpoint.
+   */
+  referencePoint?: [number, number]
+  /** Override the mode-driven magnetic gate (tests). */
+  magnetic?: boolean
+}
+
+export type SlabEdgeBandSnapResult = {
+  /** The candidate edge translated onto the wall centerline. */
+  edge: [[number, number], [number, number]]
+  wallId: string
+}
+
+/**
+ * Edge-level slab reshape snap against wall footprint bands. Unlike the
+ * cursor-based `resolveSlabPlanPointSnap`, this tests the DRAGGED EDGE
+ * itself (band adoption, span overlap — same permissiveness as the
+ * render rule) and sticks it onto the wall CENTERLINE, the canonical
+ * stored position; the render rule then places it flush with the face.
+ * The beacon, the live preview and the committed polygon therefore all
+ * agree. In non-magnetic modes only a tight connect-radius stick
+ * remains, mirroring the sanctioned wall connect snap. Publishes /
+ * clears the wall-snap beacon as a side effect.
+ */
+export function resolveSlabEdgeBandSnap(
+  input: SlabEdgeBandSnapInput,
+): SlabEdgeBandSnapResult | null {
+  const nodes = input.nodes ?? useScene.getState().nodes
+  const walls = getLevelWalls(nodes, input.levelId)
+  const magnetic = input.magnetic ?? isMagneticSnapActive()
+
+  const snap = snapSlabEdgeToWallBand(
+    input.edge[0],
+    input.edge[1],
+    walls,
+    magnetic ? undefined : { maxLateral: WALL_CONNECT_SNAP_RADIUS },
+  )
+  if (!snap) {
+    useWallSnapIndicator.getState().clear()
+    useAlignmentGuides.getState().clear()
+    return null
+  }
+
+  const [a, b] = snap.edge
+  const dx = b[0] - a[0]
+  const dz = b[1] - a[1]
+  const lengthSquared = dx * dx + dz * dz
+  let beacon: [number, number] = [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2]
+  if (input.referencePoint && lengthSquared > 1e-12) {
+    const t = Math.max(
+      0,
+      Math.min(
+        1,
+        ((input.referencePoint[0] - a[0]) * dx + (input.referencePoint[1] - a[1]) * dz) /
+          lengthSquared,
+      ),
+    )
+    beacon = [a[0] + dx * t, a[1] + dz * t]
+  }
+  useWallSnapIndicator.getState().set({
+    x: beacon[0],
+    z: beacon[1],
+    kind: 'wall',
+    wallIds: [snap.wallId],
+  })
+  useAlignmentGuides.getState().clear()
+
+  return { edge: snap.edge, wallId: snap.wallId }
+}

package/src/lib/snapping-mode.test.ts

@@ -0,0 +1,138 @@
+import { describe, expect, it } from 'bun:test'
+import {
+  cycleSnappingModeIn,
+  DEFAULT_SNAPPING_MODE,
+  defaultSnappingModeFor,
+  nextSnappingMode,
+  resolveSnapFlags,
+  SNAPPING_MODES,
+  snapContextOf,
+  snappingModesFor,
+} from './snapping-mode'
+
+describe('resolveSnapFlags', () => {
+  it('default mode is grid', () => {
+    expect(DEFAULT_SNAPPING_MODE).toBe('grid')
+  })
+
+  it("modes are exclusive: 'grid' snaps to the lattice only", () => {
+    expect(resolveSnapFlags('grid')).toEqual({ grid: true, magnetic: false, angles: false })
+  })
+
+  it("'off' disables grid, magnetic, and angles", () => {
+    expect(resolveSnapFlags('off')).toEqual({ grid: false, magnetic: false, angles: false })
+  })
+
+  it("'lines' keeps magnetic but drops the grid lattice and angle lock", () => {
+    expect(resolveSnapFlags('lines')).toEqual({ grid: false, magnetic: true, angles: false })
+  })
+
+  it("'angles' keeps the angle lock but drops grid and magnetic", () => {
+    expect(resolveSnapFlags('angles')).toEqual({ grid: false, magnetic: false, angles: true })
+  })
+
+  it("'lines' and 'angles' are distinct", () => {
+    expect(resolveSnapFlags('lines')).not.toEqual(resolveSnapFlags('angles'))
+  })
+
+  it('cycles through every mode and wraps', () => {
+    const seen = [DEFAULT_SNAPPING_MODE]
+    let mode = DEFAULT_SNAPPING_MODE
+    for (let i = 0; i < SNAPPING_MODES.length - 1; i += 1) {
+      mode = nextSnappingMode(mode)
+      seen.push(mode)
+    }
+    expect(seen).toEqual(SNAPPING_MODES)
+    expect(nextSnappingMode(mode)).toBe(DEFAULT_SNAPPING_MODE)
+  })
+})
+
+describe('per-context snapping', () => {
+  it('items default to grid with no angle lock', () => {
+    expect(defaultSnappingModeFor('item')).toBe('grid')
+    expect(snappingModesFor('item')).toEqual(['lines', 'grid', 'off'])
+    expect(snappingModesFor('item')).not.toContain('angles')
+  })
+
+  it('walls default to grid and expose the angle lock; polygons do NOT', () => {
+    expect(defaultSnappingModeFor('wall')).toBe('grid')
+    expect(defaultSnappingModeFor('polygon')).toBe('grid')
+    expect(snappingModesFor('wall')).toContain('angles')
+    // Angle lock is wall/fence-only — slabs, curves and translates never get it.
+    expect(snappingModesFor('polygon')).not.toContain('angles')
+    expect(snappingModesFor('polygon')).toEqual(['grid', 'lines', 'off'])
+  })
+
+  it('cycles within the context set and clamps a foreign value', () => {
+    expect(cycleSnappingModeIn('item', 'lines')).toBe('grid')
+    expect(cycleSnappingModeIn('item', 'off')).toBe('lines')
+    // 'angles' isn't an item mode → restart at the first entry
+    expect(cycleSnappingModeIn('item', 'angles')).toBe('lines')
+  })
+})
+
+describe('snapContextOf (profile-driven, node-declared)', () => {
+  // Stands in for the registry's declared `def.snapProfile` (the only per-kind
+  // data) — the resolver itself has no kind switch.
+  const declared: Record<string, 'item' | 'structural'> = {
+    wall: 'structural',
+    fence: 'structural',
+    item: 'item',
+    slab: 'structural',
+    ceiling: 'structural',
+    roof: 'structural',
+    zone: 'structural',
+  }
+  const profileOf = (t: string) => declared[t]
+  const ctx = (
+    scope: { kind: string; nodeType?: string; reshape?: string; tool?: string },
+    mode = 'select',
+    tool: string | null = null,
+  ) => snapContextOf({ scope, mode, tool, profileOf })
+
+  it('translating a whole structural node has no angle (polygon, not wall)', () => {
+    expect(ctx({ kind: 'moving', nodeType: 'wall' })).toBe('polygon')
+    expect(ctx({ kind: 'moving', nodeType: 'slab' })).toBe('polygon')
+    expect(ctx({ kind: 'placing', nodeType: 'item' }, 'build', 'item')).toBe('item')
+  })
+
+  it('endpoint reshape is angle-bearing (wall); curve + polygon vertex edits are not', () => {
+    expect(ctx({ kind: 'reshaping', reshape: 'endpoint' })).toBe('wall')
+    expect(ctx({ kind: 'reshaping', reshape: 'curve' })).toBe('polygon')
+    expect(ctx({ kind: 'reshaping', reshape: 'boundary' })).toBe('polygon')
+    expect(ctx({ kind: 'reshaping', reshape: 'hole' })).toBe('polygon')
+  })
+
+  it('drafting a structural kind (wall OR slab) is angle-bearing (wall)', () => {
+    expect(ctx({ kind: 'idle' }, 'build', 'wall')).toBe('wall')
+    expect(ctx({ kind: 'idle' }, 'build', 'slab')).toBe('wall')
+    expect(ctx({ kind: 'idle' }, 'build', 'item')).toBe('item')
+    expect(ctx({ kind: 'idle' }, 'select', null)).toBeNull()
+  })
+
+  it('an undeclared kind (no snapProfile) gets no snap context', () => {
+    expect(ctx({ kind: 'moving', nodeType: 'door' })).toBeNull()
+    expect(ctx({ kind: 'idle' }, 'build', 'shelf')).toBeNull()
+  })
+
+  it('drafting a non-directional structural kind is angle-less (polygon, not wall)', () => {
+    // Roof / stair / elevator are placed as footprints, not directional draws →
+    // declared `snapDraftDirectional: false`, so their draft context drops the
+    // angle-lock mode. Directional structural kinds (no flag) stay `wall`.
+    const draftDirectionalOf = (t: string) => t !== 'roof'
+    const draftCtx = (tool: string) =>
+      snapContextOf({ scope: { kind: 'idle' }, mode: 'build', tool, profileOf, draftDirectionalOf })
+    expect(draftCtx('roof')).toBe('polygon')
+    expect(draftCtx('wall')).toBe('wall')
+    // Also via the explicit `drafting` scope path.
+    expect(
+      snapContextOf({
+        scope: { kind: 'drafting', tool: 'roof' },
+        mode: 'build',
+        tool: 'roof',
+        profileOf,
+        draftDirectionalOf,
+      }),
+    ).toBe('polygon')
+  })
+})

package/src/lib/snapping-mode.ts

@@ -0,0 +1,179 @@
+import type { SnapProfile } from '@pascal-app/core'
+import { GROUP_MOVE_DRAG_LABEL } from './contextual-help'
+
+/**
+ * Snapping mode is a single global, user-cyclable control that maps onto the
+ * two pre-existing snap knobs (`gridSnapStep` grid snap + `magneticSnap`).
+ * The default `'grid'` resolves to the exact pair the editor shipped with
+ * before this control existed (grid on, magnetic on), so the default path is
+ * behaviourally unchanged — only when a user opts into `'lines'` or `'off'`
+ * does any snap math get suppressed.
+ */
+export type SnappingMode = 'grid' | 'lines' | 'angles' | 'off'
+
+export const SNAPPING_MODES: SnappingMode[] = ['grid', 'lines', 'angles', 'off']
+
+export const DEFAULT_SNAPPING_MODE: SnappingMode = 'grid'
+
+export type SnapFlags = {
+  grid: boolean
+  magnetic: boolean
+  angles: boolean
+}
+
+/**
+ * Pure mapping from the mode enum onto the individual snap knobs. Modes are
+ * EXCLUSIVE — each does exactly what its chip label says, one guide at a time,
+ * so the HUD is honest:
+ *
+ * - `grid`   → grid lattice only.
+ * - `lines`  → magnetic only: alignment axes + wall corner-join (connectivity
+ *   is part of the "lines" magnetic snap, not a separate always-on behaviour).
+ * - `angles` → angle lock only (15°/45° rays).
+ * - `off`    → nothing snaps (raw cursor).
+ */
+export function resolveSnapFlags(mode: SnappingMode): SnapFlags {
+  switch (mode) {
+    case 'grid':
+      return { grid: true, magnetic: false, angles: false }
+    case 'lines':
+      return { grid: false, magnetic: true, angles: false }
+    case 'angles':
+      return { grid: false, magnetic: false, angles: true }
+    case 'off':
+      return { grid: false, magnetic: false, angles: false }
+  }
+}
+
+const SNAPPING_MODE_LABELS: Record<SnappingMode, string> = {
+  grid: 'Grid',
+  lines: 'Lines',
+  angles: 'Angles',
+  off: 'Off',
+}
+
+export function getSnappingModeLabel(mode: SnappingMode): string {
+  return SNAPPING_MODE_LABELS[mode]
+}
+
+export function nextSnappingMode(mode: SnappingMode): SnappingMode {
+  const index = SNAPPING_MODES.indexOf(mode)
+  return SNAPPING_MODES[(index + 1) % SNAPPING_MODES.length] ?? DEFAULT_SNAPPING_MODE
+}
+
+// ── Per-context snapping ──────────────────────────────────────────────────────
+//
+// Snapping is no longer one global value: each *activity* has its own mode set
+// and default, because they want different behaviour (drawing a wall wants a
+// grid + angle lock; nudging an item wants free movement that only catches on
+// alignment lines). The mode is remembered per context and shown live, so it's
+// never a silent surprise — it just matches what you're doing.
+
+export type SnapContext = 'wall' | 'item' | 'polygon'
+
+// The cyclable mode-set for a context (distinct from the node's `SnapProfile`).
+type SnapModeSet = { modes: SnappingMode[]; default: SnappingMode }
+
+// `modes[0]` is the cycle's first entry; `default` is what a context starts at.
+// The 'wall' set is the ONLY one with an angle lock — it applies solely when
+// you're setting a segment's DIRECTION (wall/fence drafting + endpoint drag).
+// Translating a whole wall, curving it, or drawing/moving a slab can't change an
+// angle, so those use the no-angle 'polygon' set.
+const SNAP_PROFILES: Record<SnapContext, SnapModeSet> = {
+  // Wall / fence drafting + endpoint reshape: direction matters → angle lock.
+  wall: { modes: ['grid', 'lines', 'angles', 'off'], default: 'grid' },
+  // Item placement / move: grid by default; lines = magnetic alignment only (no
+  // grid lattice), no angle lock (meaningless for a footprint).
+  item: { modes: ['lines', 'grid', 'off'], default: 'grid' },
+  // Structural / surface, no direction to set: slab / ceiling / roof draft+move,
+  // whole wall/fence translate, curve reshape, polygon boundary edit. Grid by
+  // default, NO angle lock.
+  polygon: { modes: ['grid', 'lines', 'off'], default: 'grid' },
+}
+
+export const SNAP_CONTEXTS: SnapContext[] = ['wall', 'item', 'polygon']
+
+export function snappingModesFor(context: SnapContext): SnappingMode[] {
+  return SNAP_PROFILES[context].modes
+}
+
+export function defaultSnappingModeFor(context: SnapContext): SnappingMode {
+  return SNAP_PROFILES[context].default
+}
+
+// Cycle within the context's own set (clamps a foreign value to the first entry).
+export function cycleSnappingModeIn(context: SnapContext, mode: SnappingMode): SnappingMode {
+  const modes = SNAP_PROFILES[context].modes
+  const index = modes.indexOf(mode)
+  return modes[(index + 1) % modes.length] ?? modes[0] ?? DEFAULT_SNAPPING_MODE
+}
+
+// The kind's declared `snapProfile` (from the registry) → the active mode-set
+// context. The only behaviour difference is the angle lock, which a `structural`
+// kind gets while SETTING DIRECTION (drafting a run/polygon, dragging an endpoint
+// or a polygon vertex) — never while translating or curving. A node with no
+// declared profile has no snapping UI (chip) yet — returns null.
+function contextForProfile(
+  profile: SnapProfile | undefined,
+  directionSetting: boolean,
+): SnapContext | null {
+  if (profile === 'item') return 'item'
+  if (profile === 'structural') return directionSetting ? 'wall' : 'polygon'
+  return null
+}
+
+/**
+ * The active snapping context, derived from what the user is doing — fully
+ * node-declared: the kind's `snapProfile` (looked up via the injected
+ * `profileOf`) supplies the data, and this maps (profile × action) to the
+ * mode-set. No per-kind switch lives here. `profileOf` is injected so this stays
+ * pure + testable and `snapping-mode` need not import the registry.
+ *
+ * Prefers the authoritative interaction scope; falls back to the build tool
+ * because the `drafting` scope isn't wired yet (wall/slab draw runs idle).
+ * Returns null when nothing snappable is active → no chip, safe-default snap.
+ */
+export function snapContextOf(args: {
+  scope: {
+    kind: string
+    nodeType?: string
+    reshape?: string
+    nodeId?: string
+    tool?: string
+    handle?: string
+  }
+  mode: string
+  tool: string | null
+  profileOf: (typeOrTool: string) => SnapProfile | undefined
+  // Whether drafting a kind sets a direction (angle-lock meaningful). Injected
+  // like `profileOf` so `snapping-mode` need not import the registry; defaults
+  // to `true` (the structural draw default) when not supplied.
+  draftDirectionalOf?: (typeOrTool: string) => boolean
+}): SnapContext | null {
+  const { scope, mode, tool, profileOf, draftDirectionalOf } = args
+  // The group-move gizmo translates the whole selection — same no-angle
+  // treatment as a single-node move, so Shift cycles the 'item' modes and the
+  // HUD shows the item snapping chips for the drag.
+  if (scope.kind === 'handle-drag' && scope.handle === GROUP_MOVE_DRAG_LABEL) {
+    return 'item'
+  }
+  switch (scope.kind) {
+    case 'placing':
+    case 'moving':
+      // A whole-node translate never sets direction → no angle.
+      return scope.nodeType ? contextForProfile(profileOf(scope.nodeType), false) : null
+    case 'reshaping':
+      // Dragging a wall ENDPOINT sets the segment's direction → angle-bearing
+      // 'wall'. Curving, and polygon vertex/edge edits (boundary / hole), don't
+      // — they use the no-angle 'polygon' set (grid / lines / off).
+      return scope.reshape === 'endpoint' ? 'wall' : 'polygon'
+    case 'drafting':
+      return scope.tool
+        ? contextForProfile(profileOf(scope.tool), draftDirectionalOf?.(scope.tool) ?? true)
+        : null
+    default:
+      return mode === 'build' && tool
+        ? contextForProfile(profileOf(tool), draftDirectionalOf?.(tool) ?? true)
+        : null
+  }
+}

package/src/lib/stair-duplication.ts

@@ -37,7 +37,7 @@ function stripDuplicateFlags(metadata: unknown) {
 
 function moveStairWhenRegistered(stairId: StairNode['id'], attempt = 0) {
   const latestStair = useScene.getState().nodes[stairId as AnyNodeId]
-  if (!latestStair || latestStair.type !== 'stair') {
+  if (latestStair?.type !== 'stair') {
     return
   }
 
@@ -64,7 +64,7 @@ export function duplicateStairSubtree(
   const scene = useScene.getState()
   const sourceStair = scene.nodes[sourceStairId]
 
-  if (!sourceStair || sourceStair.type !== 'stair') {
+  if (sourceStair?.type !== 'stair') {
     throw new Error(`Node "${sourceStairId}" is not a stair`)
   }
 
@@ -89,7 +89,7 @@ export function duplicateStairSubtree(
   const segmentClones: StairSegmentNode[] = []
   for (const childId of sourceStair.children ?? []) {
     const childNode = scene.nodes[childId as AnyNodeId]
-    if (!childNode || childNode.type !== 'stair-segment') {
+    if (childNode?.type !== 'stair-segment') {
       continue
     }
 
@@ -108,7 +108,7 @@ export function duplicateStairSubtree(
   ])
 
   const createdStair = useScene.getState().nodes[stairClone.id as AnyNodeId]
-  if (!createdStair || createdStair.type !== 'stair') {
+  if (createdStair?.type !== 'stair') {
     throw new Error(`Duplicated stair "${stairClone.id}" was not created`)
   }
 

package/src/lib/surface-plan-snap.test.ts

@@ -0,0 +1,71 @@
+import { describe, expect, test } from 'bun:test'
+import type { AnyNode, WallNode } from '@pascal-app/core'
+import { resolveSurfacePlanPointSnap } from './surface-plan-snap'
+
+const wall = (id: string, start: [number, number], end: [number, number]): WallNode =>
+  ({
+    id,
+    type: 'wall',
+    start,
+    end,
+    visible: true,
+  }) as WallNode
+
+const nodesOf = (...walls: WallNode[]): Record<string, AnyNode> =>
+  Object.fromEntries(walls.map((node) => [node.id, node as AnyNode]))
+
+// The measurement tool passes `magnetic` explicitly so its snapping never
+// depends on the construction snapping-mode chip (whose default 'grid' mode
+// turns `isMagneticSnapActive()` off). These tests pin that seam.
+describe('resolveSurfacePlanPointSnap magnetic override', () => {
+  const walls = [wall('wall-a', [0, 0], [4, 0]), wall('wall-b', [0, 0], [0, 4])]
+  const nodes = nodesOf(...walls)
+
+  test('magnetic: true acquires a shared wall corner from the full endpoint radius', () => {
+    const result = resolveSurfacePlanPointSnap({
+      rawPoint: [0.3, 0.2],
+      nodes,
+      magnetic: true,
+      align: false,
+    })
+    expect(result.point).toEqual([0, 0])
+    expect(result.wallSnap).toBe('endpoint')
+    expect(result.wallIds.sort()).toEqual(['wall-a', 'wall-b'])
+  })
+
+  test('magnetic: true acquires a T-junction crossing on a wall body', () => {
+    const crossing = [wall('wall-a', [0, 0], [4, 0]), wall('wall-c', [3, -1], [3, 3])]
+    const result = resolveSurfacePlanPointSnap({
+      rawPoint: [3.05, 0.1],
+      nodes: nodesOf(...crossing),
+      magnetic: true,
+      align: false,
+    })
+    expect(result.point).toEqual([3, 0])
+    expect(result.wallSnap).toBe('intersection')
+  })
+
+  test('magnetic: false keeps the fallback point outside the tight connect radius', () => {
+    const result = resolveSurfacePlanPointSnap({
+      rawPoint: [0.3, 0.2],
+      fallbackPoint: [0.3, 0.2],
+      nodes,
+      magnetic: false,
+      align: false,
+    })
+    expect(result.point).toEqual([0.3, 0.2])
+    expect(result.wallSnap).toBeNull()
+  })
+
+  test('magnetic: false still sticks within the connect radius so ends can meet', () => {
+    const result = resolveSurfacePlanPointSnap({
+      rawPoint: [0.03, 0.02],
+      fallbackPoint: [0.03, 0.02],
+      nodes,
+      magnetic: false,
+      align: false,
+    })
+    expect(result.point).toEqual([0, 0])
+    expect(result.wallSnap).toBe('endpoint')
+  })
+})