@pascal-app/editor 1.0.3 → 1.0.4

package/src/store/terrain-sculpt-mode.test.ts

@@ -1,6 +1,7 @@
 import { afterEach, describe, expect, test } from 'bun:test'
 import useEditor, { isBrushMode, type Mode, normalizePersistedEditorUiState } from './use-editor'
 import useInteractionScope from './use-interaction-scope'
+import { isViewVisible, sceneLayout, VIEW_2D, visibleScene } from './view-layout'
 
 /**
  * The mode-lifecycle contract for terrain sculpting.
@@ -17,9 +18,9 @@ function reset() {
   useEditor.getState().setPreviewMode(false)
   useEditor.getState().setFirstPersonMode(false)
   useEditor.getState().setWorkspaceMode('edit')
-  // Before the mode: `setViewMode('2d')` disarms sculpt, and leaving a stale view
+  // Before the mode: hiding 3D disarms sculpt, and leaving a stale layout
   // behind would silently change what the next test's `setMode` does.
-  useEditor.getState().setViewMode('3d')
+  useEditor.getState().setViewLayout(sceneLayout('3d'))
   useEditor.getState().setMode('select')
   useEditor.getState().setTerrainVerb('flatten')
   useEditor.getState().setTerrainSampling(false)
@@ -41,8 +42,8 @@ describe('terrain-sculpt mode lifecycle', () => {
     expect(useInteractionScope.getState().scope.kind).toBe('idle')
   })
 
-  test('arming sculpt from another phase moves to the site phase', () => {
-    useEditor.getState().setPhase('structure')
+  test('arming sculpt from the building moves to site', () => {
+    useEditor.getState().setPhase('building')
     useEditor.getState().setMode('terrain-sculpt')
     // Otherwise `normalizeModeForPhase` rejects the mode on the next rehydrate
     // and the UI shows a mode the store does not hold.
@@ -53,7 +54,7 @@ describe('terrain-sculpt mode lifecycle', () => {
   test('a phase switch out of site drops the scope', () => {
     useEditor.getState().setMode('terrain-sculpt')
     // The phase setter delegates its mode rewrite to the ToolMode transition.
-    useEditor.getState().setPhase('structure')
+    useEditor.getState().setPhase('building')
     expect(useInteractionScope.getState().scope.kind).toBe('idle')
   })
 })
@@ -71,7 +72,7 @@ describe('the eyedropper arm is not allowed to outlive sculpt mode', () => {
   test('leaving via a phase switch disarms it too', () => {
     useEditor.getState().setMode('terrain-sculpt')
     useEditor.getState().setTerrainSampling(true)
-    useEditor.getState().setPhase('furnish')
+    useEditor.getState().setPhase('building')
     expect(useEditor.getState().terrainSampling).toBe(false)
   })
 
@@ -106,17 +107,17 @@ describe('the brush and the 3D canvas travel together', () => {
   // moves), while choosing the floorplan asks for the floorplan (so the mode
   // yields).
   test('arming from the 2D floorplan opens a 3D pane beside it', () => {
-    useEditor.getState().setViewMode('2d')
+    useEditor.getState().setViewLayout(sceneLayout('2d'))
     useEditor.getState().setMode('terrain-sculpt')
     // `split`, not `3d`: the floorplan was a deliberate choice, so keep it.
-    expect(useEditor.getState().viewMode).toBe('split')
-    expect(useEditor.getState().isFloorplanOpen).toBe(true)
+    expect(visibleScene(useEditor.getState())).toBe('split')
+    expect(isViewVisible(useEditor.getState(), VIEW_2D)).toBe(true)
     expect(useEditor.getState().mode).toBe('terrain-sculpt')
   })
 
   test('switching to the 2D floorplan disarms the brush', () => {
     useEditor.getState().setMode('terrain-sculpt')
-    useEditor.getState().setViewMode('2d')
+    useEditor.getState().setViewLayout(sceneLayout('2d'))
     expect(useEditor.getState().mode).toBe('select')
     // And the scope goes with it — otherwise selection stays suppressed in the
     // floorplan the user just asked for, with no visible way out.
@@ -125,10 +126,16 @@ describe('the brush and the 3D canvas travel together', () => {
 
   test('split keeps it armed — the canvas is right there', () => {
     useEditor.getState().setMode('terrain-sculpt')
-    useEditor.getState().setViewMode('split')
+    useEditor.getState().setViewLayout(sceneLayout('split'))
     expect(useEditor.getState().mode).toBe('terrain-sculpt')
   })
 
+  test('another view in the 3D pane disarms it, as the plan does', () => {
+    useEditor.getState().setMode('terrain-sculpt')
+    useEditor.getState().showView('gallery')
+    expect(useEditor.getState().mode).toBe('select')
+  })
+
   test('rehydrating the pair resolves it to select', () => {
     // Mode and view persist independently and rehydrate runs neither setter, so
     // this is the one reconciliation the setters cannot cover.
@@ -172,20 +179,11 @@ describe('the modes that hide the editing canvas release the brush', () => {
     useEditor.getState().setWorkspaceMode('studio')
     expect(useInteractionScope.getState().scope.kind).toBe('idle')
   })
-
-  test('a structure-layer switch releases it', () => {
-    useEditor.getState().setMode('terrain-sculpt')
-    // Reachable from the layer toggle while sculpt is armed, and it takes the
-    // same raw-`set` path — the mode resets, so the scope has to follow.
-    useEditor.getState().setStructureLayer('zones')
-    expect(useEditor.getState().mode).toBe('select')
-    expect(useInteractionScope.getState().scope.kind).toBe('idle')
-  })
 })
 
 describe('entering sculpt mode stands other affordances down', () => {
   test('the armed build tool is cleared', () => {
-    useEditor.getState().setPhase('structure')
+    useEditor.getState().setPhase('building')
     useEditor.getState().setMode('build')
     useEditor.getState().setTool('wall')
     useEditor.getState().setMode('terrain-sculpt')

package/src/store/tool-mode.test.ts

@@ -1,9 +1,14 @@
 import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+import { type AnyNode, useScene } from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
+import { beginGesture } from '../lib/gesture-lifecycle'
 import useEditor, { normalizePersistedEditorUiState } from './use-editor'
+import useInteractionScope from './use-interaction-scope'
 
 function resetToolMode() {
-  useEditor.getState().setPhase('structure')
-  useEditor.getState().setStructureLayer('elements')
+  useEditor.getState().clearRoom()
+  useViewer.getState().setSelection({ selectedIds: [], zoneId: null })
+  useEditor.getState().setPhase('building')
   useEditor.getState().armToolMode({ mode: 'select' })
   useEditor.getState().setActivePaintMaterial(null)
 }
@@ -12,6 +17,18 @@ beforeEach(resetToolMode)
 afterEach(resetToolMode)
 
 describe('ToolMode transition', () => {
+  test('arming building tools preserves the current phase', () => {
+    for (const phase of ['site', 'building'] as const) {
+      useEditor.getState().setPhase(phase)
+      useEditor.getState().armToolMode({ mode: 'select' })
+      for (const tool of ['item', 'wall', 'measurement', 'zone'] as const) {
+        useEditor.getState().armToolMode({ mode: 'build', tool })
+        expect(useEditor.getState().phase).toBe(phase)
+        expect(useEditor.getState().tool).toBe(tool)
+      }
+    }
+  })
+
   test('choosing a paint swatch while selected arms material paint', () => {
     useEditor.getState().armToolMode({ mode: 'select' })
     useEditor.getState().armMaterialPaint({
@@ -56,14 +73,129 @@ describe('ToolMode transition', () => {
   })
 })
 
+describe('leaving Select ends the selection', () => {
+  const ROOM = { levelId: 'level_1', zoneId: 'zone_1' }
+
+  function selectRoomAndNode() {
+    useEditor.getState().armToolMode({ mode: 'select' })
+    useViewer
+      .getState()
+      .setSelection({ selectedIds: ['wall_1' as never], zoneId: 'zone_1' as never })
+    useEditor.getState().selectRoom(ROOM)
+    useEditor.getState().setSelectedReferenceId(null)
+  }
+
+  function expectNothingSelected() {
+    expect(useViewer.getState().selection.selectedIds).toEqual([])
+    expect(useViewer.getState().selection.zoneId).toBeNull()
+    expect(useEditor.getState().room).toBeNull()
+  }
+
+  test('picking a catalog item (the item tool) clears the room and node selection', () => {
+    selectRoomAndNode()
+    useEditor.getState().setSelectedItem({ id: 'chair' } as never)
+    useEditor.getState().setTool('item')
+    expectNothingSelected()
+  })
+
+  test('the door and window tools clear it', () => {
+    for (const tool of ['door', 'window'] as const) {
+      selectRoomAndNode()
+      useEditor.getState().armToolMode({ mode: 'build', tool })
+      expectNothingSelected()
+    }
+  })
+
+  test('draw tools clear it, and so does switching from one tool to another', () => {
+    selectRoomAndNode()
+    useEditor.getState().setMode('build')
+    expect(useEditor.getState().tool).toBe('wall')
+    expectNothingSelected()
+
+    // A tool that selects what it just drew (the roof, to draw into it next)
+    // loses that selection when another tool is picked.
+    useViewer.getState().setSelection({ selectedIds: ['roof_1' as never] })
+    useEditor.getState().armToolMode({ mode: 'build', tool: 'slab' })
+    expectNothingSelected()
+  })
+
+  test('re-arming the tool already in hand is not a transition', () => {
+    useEditor.getState().armToolMode({ mode: 'build', tool: 'roof' })
+    useViewer.getState().setSelection({ selectedIds: ['roof_1' as never] })
+    useEditor.getState().setTool('roof')
+    expect(useViewer.getState().selection.selectedIds).toEqual(['roof_1'])
+  })
+
+  test('paint clears it, after taking its target from the selection', () => {
+    const previousNodes = useScene.getState().nodes
+    useScene.setState({
+      nodes: { roof_1: { id: 'roof_1', type: 'roof' } as unknown as AnyNode } as never,
+    })
+    try {
+      useEditor.getState().setActivePaintTarget('wall')
+      selectRoomAndNode()
+      useViewer.getState().setSelection({ selectedIds: ['roof_1' as never] })
+      useEditor.getState().armMaterialPaint()
+      expect(useEditor.getState().mode).toBe('material-paint')
+      expect(useEditor.getState().activePaintTarget).toBe('roof')
+      expectNothingSelected()
+    } finally {
+      useScene.setState({ nodes: previousNodes })
+    }
+  })
+
+  test('terrain sculpt and delete clear it', () => {
+    for (const mode of ['terrain-sculpt', 'delete'] as const) {
+      selectRoomAndNode()
+      useEditor.getState().armToolMode({ mode })
+      expectNothingSelected()
+    }
+  })
+
+  test('the level and building context survive', () => {
+    useViewer
+      .getState()
+      .setSelection({ buildingId: 'building_1' as never, levelId: 'level_1' as never })
+    selectRoomAndNode()
+    useEditor.getState().armToolMode({ mode: 'build', tool: 'door' })
+    expect(useViewer.getState().selection.levelId).toBe('level_1')
+    expect(useViewer.getState().selection.buildingId).toBe('building_1')
+  })
+
+  test('Select, and a move or handle drag inside it, keep the selection', () => {
+    selectRoomAndNode()
+    useEditor.getState().armToolMode({ mode: 'select' })
+    expect(useViewer.getState().selection.selectedIds).toEqual(['wall_1'])
+    expect(useEditor.getState().room).toEqual(ROOM)
+
+    let cancelled = false
+    const handle = beginGesture({
+      kind: 'test-handle',
+      onCancel: () => {
+        cancelled = true
+      },
+    })
+    useEditor.getState().armToolMode({ mode: 'select' })
+    expect(handle.active).toBe(true)
+    handle.end()
+    expect(cancelled).toBe(false)
+
+    useEditor.getState().setMovingNode({ id: 'wall_1', type: 'wall' } as unknown as AnyNode)
+    expect(useInteractionScope.getState().scope.kind).toBe('moving')
+    expect(useEditor.getState().mode).toBe('select')
+    expect(useViewer.getState().selection.selectedIds).toEqual(['wall_1'])
+    useEditor.getState().setMovingNode(null)
+    expect(useViewer.getState().selection.selectedIds).toEqual(['wall_1'])
+  })
+})
+
 describe('persisted ToolMode normalization', () => {
   test('elects a default for build with a null tool', () => {
     const state = normalizePersistedEditorUiState({
-      phase: 'structure',
+      phase: 'building',
       toolMode: { mode: 'build', tool: null as never },
       mode: 'select',
       tool: 'slab',
-      structureLayer: 'elements',
     })
 
     expect(state.toolMode).toEqual({ mode: 'build', tool: 'wall' })
@@ -73,11 +205,10 @@ describe('persisted ToolMode normalization', () => {
 
   test('clears a persisted tool from a non-build mode', () => {
     const state = normalizePersistedEditorUiState({
-      phase: 'structure',
+      phase: 'building',
       toolMode: { mode: 'select' },
       mode: 'build',
       tool: 'wall',
-      structureLayer: 'elements',
     })
 
     expect(state.toolMode).toEqual({ mode: 'select' })

package/src/store/use-delete-confirmation.ts

@@ -1,6 +1,33 @@
+import type { DeleteZonePayload } from '@pascal-app/core'
 import { create } from 'zustand'
 
-type DeleteConfirmationRequest = {
+/** Changing one of a room's construction parts, with what it takes along. */
+export type RoomConstructionChange = {
+  part: 'floor' | 'walls' | 'ceiling'
+  /** Walls can be confirmed on the way in too; everything else asks on removal. */
+  action?: 'add' | 'remove'
+  roomName: string
+  /**
+   * Walls: hosted openings and objects removed with them. Ceiling: items
+   * hanging from it. Floor: items standing on it.
+   */
+  hostedIds: string[]
+  /** Walls turned into separators, or built on them. */
+  wallCount?: number
+  sharedWalls?: boolean
+  /** Walls added: clear floor area the room gives up to them, m². */
+  areaLoss?: number
+  /** Ceiling: names of the hand-drawn ceilings removed ('' when unnamed). */
+  manualCeilings?: string[]
+  /** Ceiling: other rooms those hand-drawn ceilings also cover. */
+  alsoCovers?: string[]
+}
+
+export type DeleteConfirmationRequest = {
+  room?: DeleteZonePayload
+  construction?: RoomConstructionChange
+  conflict?: string
+  onKeepContents?: () => void
   count: number
   onConfirm: () => void
 }

package/src/store/use-drawing-view.test.ts

@@ -1,10 +1,31 @@
 import { describe, expect, test } from 'bun:test'
-import useDrawingView, { normalizeAnnotationLayoutOverrides } from './use-drawing-view'
+import useDrawingView, {
+  EDITOR_DRAWING_TYPE_OPTIONS,
+  normalizeAnnotationLayoutOverrides,
+  normalizeEditorDrawingType,
+} from './use-drawing-view'
 
 describe('drawing type', () => {
-  test('keeps the workspace on the floor plan', () => {
+  test('starts on the floor plan', () => {
     expect(useDrawingView.getState().drawingType).toBe('floor-plan')
-    expect('setDrawingType' in useDrawingView.getState()).toBe(false)
+  })
+
+  test('switches between the drawing types the editor can render', () => {
+    useDrawingView.getState().setDrawingType('site-plan')
+    expect(useDrawingView.getState().drawingType).toBe('site-plan')
+    useDrawingView.getState().setDrawingType('floor-plan')
+    expect(useDrawingView.getState().drawingType).toBe('floor-plan')
+  })
+
+  test('only offers the two types that have a renderer', () => {
+    expect(EDITOR_DRAWING_TYPE_OPTIONS.map((o) => o.id)).toEqual(['floor-plan', 'site-plan'])
+  })
+
+  test('a persisted value the editor cannot render falls back to the floor plan', () => {
+    expect(normalizeEditorDrawingType('site-plan')).toBe('site-plan')
+    expect(normalizeEditorDrawingType('roof-plan')).toBe('floor-plan')
+    expect(normalizeEditorDrawingType(undefined)).toBe('floor-plan')
+    expect(normalizeEditorDrawingType(42)).toBe('floor-plan')
   })
 })
 

package/src/store/use-drawing-view.ts

@@ -20,8 +20,24 @@ export type DrawingAnnotationLayoutOverride = {
 
 export type DrawingAnnotationLayoutOverrides = Record<string, DrawingAnnotationLayoutOverride>
 
+/**
+ * Drawing types the 2D editor can actually render today. `floor-plan` is the
+ * default; `site-plan` renders through
+ * `lib/floorplan/site-plan/buildSitePlanDrawing`. The remaining
+ * `ConstructionDrawingType` members exist on annotations (they gate dimension
+ * visibility) but have no editor renderer yet, so the switch does not offer
+ * them — widen this union as each one lands.
+ */
+export type EditorDrawingType = Extract<ConstructionDrawingType, 'floor-plan' | 'site-plan'>
+
+export const EDITOR_DRAWING_TYPE_OPTIONS = [
+  { id: 'floor-plan', label: 'Floor plan' },
+  { id: 'site-plan', label: 'Site plan' },
+] as const satisfies readonly { id: EditorDrawingType; label: string }[]
+
 type DrawingViewState = {
-  drawingType: Extract<ConstructionDrawingType, 'floor-plan'>
+  drawingType: EditorDrawingType
+  setDrawingType: (drawingType: EditorDrawingType) => void
   annotationLayoutOverrides: DrawingAnnotationLayoutOverrides
   setAnnotationLayoutOverride: (
     id: string,
@@ -52,10 +68,18 @@ export function normalizeAnnotationLayoutOverrides(
   return out
 }
 
+/** Persisted value → a drawing type the editor can render. Unknown → floor-plan. */
+export function normalizeEditorDrawingType(value: unknown): EditorDrawingType {
+  return EDITOR_DRAWING_TYPE_OPTIONS.some((o) => o.id === value)
+    ? (value as EditorDrawingType)
+    : 'floor-plan'
+}
+
 const useDrawingView = create<DrawingViewState>()(
   persist(
     (set) => ({
       drawingType: 'floor-plan',
+      setDrawingType: (drawingType) => set({ drawingType }),
       annotationLayoutOverrides: {},
       setAnnotationLayoutOverride: (id, override) =>
         set((state) => {
@@ -69,12 +93,16 @@ const useDrawingView = create<DrawingViewState>()(
       name: 'pascal-floorplan-drawing-view',
       merge: (persistedState, currentState) => ({
         ...currentState,
+        drawingType: normalizeEditorDrawingType(
+          (persistedState as { drawingType?: unknown } | undefined)?.drawingType,
+        ),
         annotationLayoutOverrides: normalizeAnnotationLayoutOverrides(
           (persistedState as { annotationLayoutOverrides?: unknown } | undefined)
             ?.annotationLayoutOverrides,
         ),
       }),
       partialize: (state) => ({
+        drawingType: state.drawingType,
         annotationLayoutOverrides: state.annotationLayoutOverrides,
       }),
     },