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

package/src/store/live-draft-preview-stores.test.ts

@@ -0,0 +1,136 @@
+import { afterEach, describe, expect, test } from 'bun:test'
+import useFenceCurveDraft from './use-fence-curve-draft'
+import { useFloorplanDraftPreview } from './use-floorplan-draft-preview'
+import { usePathDraftPreview } from './use-path-draft-preview'
+import { useStairBuildPreview } from './use-stair-build-preview'
+
+afterEach(() => {
+  useFenceCurveDraft.getState().reset()
+  useFloorplanDraftPreview.getState().reset()
+  usePathDraftPreview.getState().reset()
+  useStairBuildPreview.getState().reset()
+})
+
+describe('live draft preview stores', () => {
+  test('dedupes polygon snapshots and owns an immutable point copy', () => {
+    let changes = 0
+    const unsubscribe = useFloorplanDraftPreview.subscribe(() => {
+      changes += 1
+    })
+    const points: Array<[number, number]> = [
+      [0, 0],
+      [2, 0],
+    ]
+    useFloorplanDraftPreview.getState().setPolygonDraft('slab', points)
+    useFloorplanDraftPreview.getState().setPolygonDraft('slab', points)
+    points[0]![0] = 9
+
+    expect(changes).toBe(1)
+    expect(useFloorplanDraftPreview.getState().polygonDraftPoints).toEqual([
+      [0, 0],
+      [2, 0],
+    ])
+    unsubscribe()
+  })
+
+  test('publishes stair point and rotation atomically', () => {
+    let changes = 0
+    const unsubscribe = useStairBuildPreview.subscribe(() => {
+      changes += 1
+    })
+    useStairBuildPreview.getState().setPreview([3, 4], Math.PI / 2)
+    useStairBuildPreview.getState().setPreview([3, 4], Math.PI / 2)
+
+    expect(changes).toBe(1)
+    expect(useStairBuildPreview.getState()).toMatchObject({
+      point: [3, 4],
+      rotation: Math.PI / 2,
+    })
+    unsubscribe()
+  })
+
+  test('dedupes curved-fence control points and cursor', () => {
+    let changes = 0
+    const unsubscribe = useFenceCurveDraft.subscribe(() => {
+      changes += 1
+    })
+    const points: Array<[number, number]> = [
+      [0, 0],
+      [1, 1],
+    ]
+    useFenceCurveDraft.getState().setDraft(points, [2, 0])
+    useFenceCurveDraft.getState().setDraft(points, [2, 0])
+    points[0]![0] = 5
+
+    expect(changes).toBe(1)
+    expect(useFenceCurveDraft.getState()).toMatchObject({
+      cursor: [2, 0],
+      pointCount: 2,
+      points: [
+        [0, 0],
+        [1, 1],
+      ],
+    })
+    unsubscribe()
+  })
+
+  test('dedupes path drafts and owns immutable point, parameter, and related-node copies', () => {
+    let changes = 0
+    const unsubscribe = usePathDraftPreview.subscribe(() => {
+      changes += 1
+    })
+    const points: Array<[number, number, number]> = [[0, 1, 2]]
+    const parameters = { diameter: 6, shape: 'round' }
+    const relatedNodes = [
+      {
+        angle: 90,
+        branchAngle: 90,
+        diameter: 6,
+        diameter2: 6,
+        ductMaterial: 'sheet-metal' as const,
+        fittingType: 'elbow' as const,
+        height: 8,
+        height2: 8,
+        id: 'duct-fitting_live-draft-0' as const,
+        metadata: {},
+        object: 'node' as const,
+        parentId: 'level_1' as const,
+        position: [1, 2, 3] as [number, number, number],
+        rotation: [0, 0, 0] as [number, number, number],
+        shape: 'round' as const,
+        shape2: 'round' as const,
+        slots: undefined,
+        system: 'supply' as const,
+        type: 'duct-fitting' as const,
+        visible: true,
+        width: 14,
+        width2: 14,
+      },
+    ]
+    usePathDraftPreview
+      .getState()
+      .setDraft('duct-segment', points, [3, 4, 5], parameters, relatedNodes)
+    usePathDraftPreview
+      .getState()
+      .setDraft('duct-segment', points, [3, 4, 5], parameters, relatedNodes)
+    points[0]![0] = 9
+    parameters.diameter = 12
+    relatedNodes[0]!.position[0] = 9
+
+    expect(changes).toBe(1)
+    expect(usePathDraftPreview.getState()).toMatchObject({
+      cursor: [3, 4, 5],
+      kind: 'duct-segment',
+      parameters: { diameter: 6, shape: 'round' },
+      points: [[0, 1, 2]],
+      relatedNodes: [
+        expect.objectContaining({
+          id: 'duct-fitting_live-draft-0',
+          position: [1, 2, 3],
+          type: 'duct-fitting',
+        }),
+      ],
+    })
+    unsubscribe()
+  })
+})

package/src/store/navigation-sync-pose-store.test.ts

@@ -0,0 +1,34 @@
+import { afterEach, describe, expect, test } from 'bun:test'
+import {
+  navigationSyncPoseStore,
+  publishNavigationSyncPoseToStore,
+  subscribeNavigationSyncPose,
+} from './navigation-sync-pose-store'
+import type { NavigationSyncPose } from './use-editor'
+
+const pose = {
+  source: '2d' as const,
+  revision: 1,
+  target: [1, 2, 3] as [number, number, number],
+  azimuth: 0.5,
+  viewWidth: 12,
+}
+
+afterEach(() => {
+  navigationSyncPoseStore.setState({ pose: null })
+})
+
+describe('navigation sync pose store', () => {
+  test('replays the latest pose and streams only later pose writes', () => {
+    publishNavigationSyncPoseToStore(pose)
+    const received: NavigationSyncPose[] = []
+    const unsubscribe = subscribeNavigationSyncPose((nextPose) => received.push(nextPose))
+    const nextPose = { ...pose, revision: 2, viewWidth: 8 }
+
+    publishNavigationSyncPoseToStore(nextPose)
+    unsubscribe()
+    publishNavigationSyncPoseToStore({ ...pose, revision: 3 })
+
+    expect(received).toEqual([pose, nextPose])
+  })
+})

package/src/store/navigation-sync-pose-store.ts

@@ -0,0 +1,27 @@
+import { subscribeWithSelector } from 'zustand/middleware'
+import { createStore } from 'zustand/vanilla'
+import type { NavigationSyncPose } from './use-editor'
+
+type NavigationSyncPoseState = {
+  pose: NavigationSyncPose | null
+}
+
+export const navigationSyncPoseStore = createStore<NavigationSyncPoseState>()(
+  subscribeWithSelector<NavigationSyncPoseState>(() => ({ pose: null })),
+)
+
+export function publishNavigationSyncPoseToStore(pose: NavigationSyncPose) {
+  navigationSyncPoseStore.setState({ pose })
+}
+
+export function subscribeNavigationSyncPose(listener: (pose: NavigationSyncPose) => void) {
+  const currentPose = navigationSyncPoseStore.getState().pose
+  if (currentPose) listener(currentPose)
+
+  return navigationSyncPoseStore.subscribe(
+    (state) => state.pose,
+    (pose) => {
+      if (pose) listener(pose)
+    },
+  )
+}

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

@@ -0,0 +1,223 @@
+import { afterEach, describe, expect, test } from 'bun:test'
+import useEditor, { isBrushMode, type Mode, normalizePersistedEditorUiState } from './use-editor'
+import useInteractionScope from './use-interaction-scope'
+
+/**
+ * The mode-lifecycle contract for terrain sculpting.
+ *
+ * These are not tests of the brush — that lives in `core`'s terrain-brush tests.
+ * They cover the part the user experiences as "does the tool fight the rest of
+ * the editor": entering sculpt mode must not leave conflicting affordances
+ * armed, and leaving it must not leak sculpt-only state into select mode.
+ */
+
+function reset() {
+  // These come first: each one forces `mode: 'select'` on entry, so leaving one
+  // latched would make the next test's `setMode('terrain-sculpt')` a no-op.
+  useEditor.getState().setPreviewMode(false)
+  useEditor.getState().setFirstPersonMode(false)
+  useEditor.getState().setWorkspaceMode('edit')
+  // Before the mode: `setViewMode('2d')` disarms sculpt, and leaving a stale view
+  // behind would silently change what the next test's `setMode` does.
+  useEditor.getState().setViewMode('3d')
+  useEditor.getState().setMode('select')
+  useEditor.getState().setTerrainVerb('flatten')
+  useEditor.getState().setTerrainSampling(false)
+  useInteractionScope.getState().end()
+}
+afterEach(reset)
+
+describe('terrain-sculpt mode lifecycle', () => {
+  test('entering claims the sculpting scope for the whole mode', () => {
+    useEditor.getState().setMode('terrain-sculpt')
+    // Held by the mode, not by a pointer gesture: an active scope is what makes
+    // every other node's handles and the floating action menu step back.
+    expect(useInteractionScope.getState().scope.kind).toBe('sculpting')
+  })
+
+  test('leaving releases it, so selection works again', () => {
+    useEditor.getState().setMode('terrain-sculpt')
+    useEditor.getState().setMode('select')
+    expect(useInteractionScope.getState().scope.kind).toBe('idle')
+  })
+
+  test('arming sculpt from another phase moves to the site phase', () => {
+    useEditor.getState().setPhase('structure')
+    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.
+    expect(useEditor.getState().phase).toBe('site')
+    expect(useEditor.getState().mode).toBe('terrain-sculpt')
+  })
+
+  test('a phase switch out of site drops the scope', () => {
+    useEditor.getState().setMode('terrain-sculpt')
+    // This path rewrites `mode` without going through `setMode`, which is
+    // exactly why the scope sync is its own function.
+    useEditor.getState().setPhase('structure')
+    expect(useInteractionScope.getState().scope.kind).toBe('idle')
+  })
+})
+
+describe('the eyedropper arm is not allowed to outlive sculpt mode', () => {
+  test('leaving via setMode disarms it', () => {
+    useEditor.getState().setMode('terrain-sculpt')
+    useEditor.getState().setTerrainSampling(true)
+    useEditor.getState().setMode('select')
+    // A one-shot arm that survived would swallow the user's first click back in
+    // select mode, with the panel that showed it as armed already unmounted.
+    expect(useEditor.getState().terrainSampling).toBe(false)
+  })
+
+  test('leaving via a phase switch disarms it too', () => {
+    useEditor.getState().setMode('terrain-sculpt')
+    useEditor.getState().setTerrainSampling(true)
+    useEditor.getState().setPhase('furnish')
+    expect(useEditor.getState().terrainSampling).toBe(false)
+  })
+
+  test('switching away from flatten disarms it', () => {
+    useEditor.getState().setMode('terrain-sculpt')
+    useEditor.getState().setTerrainSampling(true)
+    useEditor.getState().setTerrainVerb('raise')
+    expect(useEditor.getState().terrainSampling).toBe(false)
+  })
+
+  test('staying on flatten keeps it armed', () => {
+    useEditor.getState().setMode('terrain-sculpt')
+    useEditor.getState().setTerrainSampling(true)
+    useEditor.getState().setTerrainVerb('flatten')
+    expect(useEditor.getState().terrainSampling).toBe(true)
+  })
+
+  test('picking a target consumes the arm', () => {
+    useEditor.getState().setMode('terrain-sculpt')
+    useEditor.getState().setTerrainSampling(true)
+    useEditor.getState().setTerrainFlattenTarget(2.5)
+    expect(useEditor.getState().terrainFlattenTarget).toBe(2.5)
+    expect(useEditor.getState().terrainSampling).toBe(false)
+  })
+})
+
+describe('the brush and the 3D canvas travel together', () => {
+  // In `2d` the 3D pane is still mounted but `display: none`, so nothing about an
+  // armed brush is observable and no pointer event can reach it. Every path that
+  // could pair the two has to resolve it, and they resolve it in opposite
+  // directions on purpose: arming the mode asks for the ground (so the view
+  // 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().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(useEditor.getState().mode).toBe('terrain-sculpt')
+  })
+
+  test('switching to the 2D floorplan disarms the brush', () => {
+    useEditor.getState().setMode('terrain-sculpt')
+    useEditor.getState().setViewMode('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.
+    expect(useInteractionScope.getState().scope.kind).toBe('idle')
+  })
+
+  test('split keeps it armed — the canvas is right there', () => {
+    useEditor.getState().setMode('terrain-sculpt')
+    useEditor.getState().setViewMode('split')
+    expect(useEditor.getState().mode).toBe('terrain-sculpt')
+  })
+
+  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.
+    const state = normalizePersistedEditorUiState({
+      phase: 'site',
+      mode: 'terrain-sculpt',
+      viewMode: '2d',
+    })
+    expect(state.mode).toBe('select')
+  })
+
+  test('rehydrating sculpt beside a visible canvas restores the mode', () => {
+    const state = normalizePersistedEditorUiState({
+      phase: 'site',
+      mode: 'terrain-sculpt',
+      viewMode: 'split',
+    })
+    expect(state.mode).toBe('terrain-sculpt')
+  })
+})
+
+describe('the modes that hide the editing canvas release the brush', () => {
+  // Preview / walkthrough / studio all unmount `ToolManager` (via `noEditing`),
+  // so the sculpt tool that would release the scope on unmount is gone. Each one
+  // resets `mode` with a raw `set` rather than `setMode`, which is exactly the
+  // bug class `setPhase` had: a `sculpting` scope leaked here disables selection
+  // across the whole editor with nothing left mounted to clear it.
+  test('entering preview releases it', () => {
+    useEditor.getState().setMode('terrain-sculpt')
+    useEditor.getState().setPreviewMode(true)
+    expect(useEditor.getState().mode).toBe('select')
+    expect(useInteractionScope.getState().scope.kind).toBe('idle')
+  })
+
+  test('entering the first-person walkthrough releases it', () => {
+    useEditor.getState().setMode('terrain-sculpt')
+    useEditor.getState().setFirstPersonMode(true)
+    expect(useInteractionScope.getState().scope.kind).toBe('idle')
+  })
+
+  test('entering the studio workspace releases it', () => {
+    useEditor.getState().setMode('terrain-sculpt')
+    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().setMode('build')
+    useEditor.getState().setTool('wall')
+    useEditor.getState().setMode('terrain-sculpt')
+    // A ghost still armed under the brush would place a wall on the first dab.
+    expect(useEditor.getState().tool).toBeNull()
+  })
+})
+
+describe('isBrushMode', () => {
+  /**
+   * The set of modes that hold their interaction scope for the whole mode rather
+   * than for a pointer gesture. It matters outside the store because a scope is
+   * single-owner: anything calling `begin()` while a brush mode holds its scope
+   * evicts it silently, leaving the brush armed and painting while the editor
+   * believes a drag is running. Nearly every producer needs a selection — which
+   * entering a brush mode clears — but the clipboard paths read the clipboard, so
+   * `pasteSelectionAndPickUp` asks this before picking clones up.
+   */
+  test('is exactly the two modes that hold a scope for their duration', () => {
+    const modes: Mode[] = ['select', 'edit', 'delete', 'build', 'material-paint', 'terrain-sculpt']
+    const held: Mode[] = []
+    for (const mode of modes) {
+      useEditor.getState().setMode(mode)
+      const kind = useInteractionScope.getState().scope.kind
+      if (kind === 'painting' || kind === 'sculpting') held.push(mode)
+    }
+    // Derived from observed scope behaviour rather than restating the literal, so
+    // a third brush mode that forgets `isBrushMode` fails here.
+    expect(held.filter(isBrushMode)).toEqual(held)
+    expect(modes.filter(isBrushMode)).toEqual(held)
+  })
+})

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

@@ -0,0 +1,27 @@
+import { create } from 'zustand'
+
+type DeleteConfirmationRequest = {
+  count: number
+  onConfirm: () => void
+}
+
+type DeleteConfirmationStore = {
+  request: DeleteConfirmationRequest | null
+  cancel: () => void
+  confirm: () => void
+  requestConfirmation: (request: DeleteConfirmationRequest) => void
+}
+
+const useDeleteConfirmation = create<DeleteConfirmationStore>((set, get) => ({
+  request: null,
+  cancel: () => set({ request: null }),
+  confirm: () => {
+    const request = get().request
+    if (!request) return
+    set({ request: null })
+    request.onConfirm()
+  },
+  requestConfirmation: (request) => set({ request }),
+}))
+
+export default useDeleteConfirmation

package/src/store/use-direct-manipulation-feedback.ts

@@ -0,0 +1,20 @@
+import type { AnyNodeId } from '@pascal-app/core'
+import { create } from 'zustand'
+
+type DirectManipulationFeedbackState = {
+  activeRotateNodeId: AnyNodeId | null
+  setActiveRotateNodeId(nodeId: AnyNodeId | null): void
+  clearActiveRotateNodeId(nodeId?: AnyNodeId): void
+}
+
+const useDirectManipulationFeedback = create<DirectManipulationFeedbackState>((set) => ({
+  activeRotateNodeId: null,
+  setActiveRotateNodeId: (activeRotateNodeId) => set({ activeRotateNodeId }),
+  clearActiveRotateNodeId: (nodeId) =>
+    set((state) => {
+      if (nodeId !== undefined && state.activeRotateNodeId !== nodeId) return {}
+      return { activeRotateNodeId: null }
+    }),
+}))
+
+export default useDirectManipulationFeedback

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

@@ -0,0 +1,23 @@
+import { describe, expect, test } from 'bun:test'
+import useDrawingView, { normalizeAnnotationLayoutOverrides } from './use-drawing-view'
+
+describe('drawing type', () => {
+  test('keeps the workspace on the floor plan', () => {
+    expect(useDrawingView.getState().drawingType).toBe('floor-plan')
+    expect('setDrawingType' in useDrawingView.getState()).toBe(false)
+  })
+})
+
+describe('normalizeAnnotationLayoutOverrides', () => {
+  test('keeps finite pinned drawing-view annotation offsets', () => {
+    expect(
+      normalizeAnnotationLayoutOverrides({
+        a: { dx: 1.25, dy: -0.5, pinned: true },
+        stale: { dx: Number.NaN, dy: 0, pinned: true },
+        unpinned: { dx: 1, dy: 2, pinned: false },
+      }),
+    ).toEqual({
+      a: { dx: 1.25, dy: -0.5, pinned: true },
+    })
+  })
+})

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

@@ -0,0 +1,84 @@
+'use client'
+
+import type { ConstructionDrawingType } from '@pascal-app/core'
+import { create } from 'zustand'
+import { persist } from 'zustand/middleware'
+
+export const DRAWING_TYPE_OPTIONS = [
+  { id: 'floor-plan', label: 'Floor plan' },
+  { id: 'foundation-plan', label: 'Foundation plan' },
+  { id: 'reflected-ceiling-plan', label: 'Reflected ceiling plan' },
+  { id: 'roof-plan', label: 'Roof plan' },
+  { id: 'site-plan', label: 'Site plan' },
+] as const satisfies readonly { id: ConstructionDrawingType; label: string }[]
+
+export type DrawingAnnotationLayoutOverride = {
+  dx: number
+  dy: number
+  pinned: true
+}
+
+export type DrawingAnnotationLayoutOverrides = Record<string, DrawingAnnotationLayoutOverride>
+
+type DrawingViewState = {
+  drawingType: Extract<ConstructionDrawingType, 'floor-plan'>
+  annotationLayoutOverrides: DrawingAnnotationLayoutOverrides
+  setAnnotationLayoutOverride: (
+    id: string,
+    override: DrawingAnnotationLayoutOverride | null,
+  ) => void
+}
+
+export function normalizeAnnotationLayoutOverrides(
+  value: unknown,
+): DrawingAnnotationLayoutOverrides {
+  if (!value || typeof value !== 'object') return {}
+  const out: DrawingAnnotationLayoutOverrides = {}
+  for (const [id, raw] of Object.entries(value)) {
+    if (!id || !raw || typeof raw !== 'object') continue
+    const dx = (raw as { dx?: unknown }).dx
+    const dy = (raw as { dy?: unknown }).dy
+    const pinned = (raw as { pinned?: unknown }).pinned
+    if (
+      typeof dx === 'number' &&
+      Number.isFinite(dx) &&
+      typeof dy === 'number' &&
+      Number.isFinite(dy) &&
+      pinned === true
+    ) {
+      out[id] = { dx, dy, pinned: true }
+    }
+  }
+  return out
+}
+
+const useDrawingView = create<DrawingViewState>()(
+  persist(
+    (set) => ({
+      drawingType: 'floor-plan',
+      annotationLayoutOverrides: {},
+      setAnnotationLayoutOverride: (id, override) =>
+        set((state) => {
+          const next = { ...state.annotationLayoutOverrides }
+          if (override) next[id] = override
+          else delete next[id]
+          return { annotationLayoutOverrides: next }
+        }),
+    }),
+    {
+      name: 'pascal-floorplan-drawing-view',
+      merge: (persistedState, currentState) => ({
+        ...currentState,
+        annotationLayoutOverrides: normalizeAnnotationLayoutOverrides(
+          (persistedState as { annotationLayoutOverrides?: unknown } | undefined)
+            ?.annotationLayoutOverrides,
+        ),
+      }),
+      partialize: (state) => ({
+        annotationLayoutOverrides: state.annotationLayoutOverrides,
+      }),
+    },
+  ),
+)
+
+export default useDrawingView