@pascal-app/editor 1.0.7 → 1.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pascal-app/editor",
-  "version": "1.0.7",
+  "version": "1.1.0",
   "description": "Pascal building editor component",
   "license": "MIT",
   "type": "module",
@@ -18,8 +18,8 @@
     "test": "bun test src"
   },
   "peerDependencies": {
-    "@pascal-app/core": "^1.0.7",
-    "@pascal-app/viewer": "^1.0.7",
+    "@pascal-app/core": "^1.1.0",
+    "@pascal-app/viewer": "^1.1.0",
     "@react-three/drei": "^10",
     "@react-three/fiber": "^9",
     "next": ">=15",
@@ -34,8 +34,8 @@
     "@iconify/react": "^6.0.4",
     "@lingui/core": "6.12.0",
     "@number-flow/react": "^0.6.2",
-    "@pascal-app/geometry-script": "^1.0.7",
-    "@pascal-app/ifc-converter": "^1.0.7",
+    "@pascal-app/geometry-script": "^1.1.0",
+    "@pascal-app/ifc-converter": "^1.1.0",
     "@pascal-app/lingo": "^0.5.0",
     "@radix-ui/react-alert-dialog": "^1.2.1",
     "@radix-ui/react-context-menu": "^2.4.1",
@@ -69,8 +69,8 @@
     "zustand": "^5.0.16"
   },
   "devDependencies": {
-    "@pascal-app/core": "^1.0.7",
-    "@pascal-app/viewer": "^1.0.7",
+    "@pascal-app/core": "^1.1.0",
+    "@pascal-app/viewer": "^1.1.0",
     "@pascal/typescript-config": "*",
     "@react-three/test-renderer": "^9.1.1",
     "@types/blob-stream": "^0.1.33",

package/src/components/editor/custom-camera-controls.tsx

@@ -29,6 +29,7 @@ import {
   type Camera,
   type OrthographicCamera,
   type PerspectiveCamera,
+  Sphere,
   Spherical,
   Vector3,
 } from 'three'
@@ -74,6 +75,13 @@ import {
 } from '../../store/use-interaction-scope'
 import { visibleScene } from '../../store/view-layout'
 import { createCameraDraggingLifecycle } from './camera-dragging-lifecycle'
+import {
+  type FitSceneLookAt,
+  type PendingFitScene,
+  planFitSceneOnEvent,
+  planFitSceneOnOrbitResume,
+  planLevelFollow,
+} from './fit-scene-framing'
 import { FloorAwareCameraControls } from './floor-aware-camera-controls'
 import { FloorSurface } from './floor-surface'
 
@@ -84,6 +92,7 @@ const tempDelta = new Vector3()
 const tempPosition = new Vector3()
 const tempSize = new Vector3()
 const tempTarget = new Vector3()
+const fitSceneSphere = new Sphere()
 const transitionFreezePosition = new Vector3()
 const transitionFreezeTarget = new Vector3()
 const keyboardPanSpherical = new Spherical()
@@ -120,6 +129,23 @@ function keepEyeOverGround(x: number, eyeY: number, z: number, previousEyeY = ey
   return overviewEyeY(eyeY, previousEyeY, groundY, useViewer.getState().eyeUnderGround)
 }
 
+function applyFitLookAt(control: CameraControlsImpl, lookAt: FitSceneLookAt) {
+  control.setLookAt(
+    lookAt.eyeX,
+    keepEyeOverGround(lookAt.eyeX, lookAt.eyeY, lookAt.eyeZ, lookAt.eyeHeight),
+    lookAt.eyeZ,
+    lookAt.targetX,
+    lookAt.targetY,
+    lookAt.targetZ,
+    true,
+  )
+  if (isOrthographicCamera(control.camera)) {
+    fitSceneSphere.center.set(...lookAt.fitSphere.center)
+    fitSceneSphere.radius = lookAt.fitSphere.radius
+    control.fitToSphere(fitSceneSphere, true)
+  }
+}
+
 function levelOf(nodeId: string): string | null {
   const nodes = useScene.getState().nodes
   let node: AnyNode | undefined = nodes[nodeId as AnyNodeId]
@@ -407,6 +433,9 @@ export const CustomCameraControls = ({ paused = false }: { paused?: boolean }) =
   if (selection.levelId) lastLevelId.current = selection.levelId
   const currentLevelId = lastLevelId.current
   const firstLoad = useRef(true)
+  // Survives first-person (orbit unmounted) so scene-ready fit still applies
+  // once CameraControls remount.
+  const pendingFitSceneRef = useRef<PendingFitScene | null>(null)
   const floorY = useScene((state) =>
     currentLevelId ? getLevelPresentationY(currentLevelId, state.nodes, levelMode) : 0,
   )
@@ -615,19 +644,32 @@ export const CustomCameraControls = ({ paused = false }: { paused?: boolean }) =
     }
   }, [scene, gl, camera])
 
+  const previousLevelIdRef = useRef<string | null>(null)
+  const previousLevelModeRef = useRef(levelMode)
+  const previousCameraRef = useRef(camera)
   // `camera` too: drei builds a fresh controls instance (pivot at the origin)
   // when the default camera mounts or changes; it is rested on the floor too.
-  // biome-ignore lint/correctness/useExhaustiveDependencies: camera re-runs this on a new instance
   useEffect(() => {
     if (isPreviewMode || isFirstPersonMode || isRestoringFirstPersonPose()) return
     // Analytic destination, not `sceneRegistry` mesh position: a level created
     // this frame still sits at y=0 (LevelSystem lerps it later), and a mode
-    // switch leaves every level mid-lerp — the camera must pan to where the
+    // switch leaves every level mid-lerp - the camera must pan to where the
     // level will settle, in the CURRENT presentation mode.
     const targetY = orbitGroundY(currentLevelId, levelMode)
     if (!controls.current) return
-    if (firstLoad.current) {
-      firstLoad.current = false
+    const plan = planLevelFollow({
+      firstLoad: firstLoad.current,
+      sceneEmpty: Object.keys(useScene.getState().nodes).length === 0,
+      levelChanged: previousLevelIdRef.current !== currentLevelId,
+      modeChanged: previousLevelModeRef.current !== levelMode,
+      cameraChanged: previousCameraRef.current !== camera,
+    })
+    firstLoad.current = false
+    previousLevelIdRef.current = currentLevelId
+    previousLevelModeRef.current = levelMode
+    previousCameraRef.current = camera
+    if (plan === 'none') return
+    if (plan === 'default-pose') {
       controls.current.setLookAt(
         20,
         keepEyeOverGround(20, 20 + targetY, 20, 20),
@@ -637,6 +679,7 @@ export const CustomCameraControls = ({ paused = false }: { paused?: boolean }) =
         0,
         true,
       )
+      return
     }
     controls.current.getOrbitTarget(currentTarget)
     // Idempotence guard: skip when already there — also swallows the thumbnail
@@ -692,6 +735,19 @@ export const CustomCameraControls = ({ paused = false }: { paused?: boolean }) =
     controls.current.floorSurface = diveFloor === null ? floorSurface : null
   }, [camera, currentLevelId, diveFloor, floorMinY, floorSurface, isFirstPersonMode])
 
+  const flushPendingFitScene = useCallback(() => {
+    const plan = planFitSceneOnOrbitResume({
+      isPreviewMode,
+      isFirstPersonMode: useEditor.getState().isFirstPersonMode,
+      hasControls: !!controls.current,
+      pending: pendingFitSceneRef.current,
+      groundY: orbitGroundY(lastLevelId.current),
+    })
+    if (plan.action !== 'apply' || !controls.current) return
+    pendingFitSceneRef.current = null
+    applyFitLookAt(controls.current, plan.lookAt)
+  }, [isPreviewMode])
+
   const focusNode = useCallback(
     (nodeId: string) => {
       if (isPreviewMode || isFirstPersonMode || !controls.current) return
@@ -1388,37 +1444,22 @@ export const CustomCameraControls = ({ paused = false }: { paused?: boolean }) =
     }
 
     const handleFitScene = ({ bounds }: CameraControlFitSceneEvent) => {
-      if (isFirstPersonMode || !controls.current || isPreviewMode) return
-      const groundY = orbitGroundY(lastLevelId.current)
-      if (!bounds) {
-        // Restore default framing pose when no bounds were computed.
-        controls.current.setLookAt(
-          20,
-          keepEyeOverGround(20, 20 + groundY, 20, 20),
-          20,
-          0,
-          groundY,
-          0,
-          true,
-        )
+      const plan = planFitSceneOnEvent({
+        isPreviewMode,
+        isFirstPersonMode,
+        hasControls: !!controls.current,
+        bounds: bounds ?? null,
+        groundY: orbitGroundY(lastLevelId.current),
+      })
+      if (plan.action === 'ignore') return
+      if (plan.action === 'queue') {
+        pendingFitSceneRef.current = plan.pending
+        // Orbit path with a not-yet-attached ref: retry next frame.
+        if (!isFirstPersonMode) requestAnimationFrame(flushPendingFitScene)
         return
       }
-      const [cx, cz] = bounds.center
-      const [w, d] = bounds.size
-      // Use the longer horizontal extent to size the orbit radius so the whole
-      // footprint sits in view regardless of aspect ratio.
-      const maxExtent = Math.max(w, d)
-      const distance = Math.max(maxExtent * 1.4, 15)
-      const height = Math.max(maxExtent * 0.8, 10)
-      controls.current.setLookAt(
-        cx + distance * 0.7,
-        keepEyeOverGround(cx + distance * 0.7, height + groundY, cz + distance * 0.7, height),
-        cz + distance * 0.7,
-        cx,
-        groundY,
-        cz,
-        true,
-      )
+      pendingFitSceneRef.current = null
+      if (controls.current) applyFitLookAt(controls.current, plan.lookAt)
     }
 
     emitter.on('camera-controls:capture', handleNodeCapture)
@@ -1440,7 +1481,22 @@ export const CustomCameraControls = ({ paused = false }: { paused?: boolean }) =
       emitter.off('camera-controls:orbit-ccw', handleOrbitCCW)
       emitter.off('camera-controls:fit-scene', handleFitScene)
     }
-  }, [camera, cancelPoseApplication, focusNode, isPreviewMode, isFirstPersonMode])
+  }, [
+    camera,
+    cancelPoseApplication,
+    flushPendingFitScene,
+    focusNode,
+    isPreviewMode,
+    isFirstPersonMode,
+  ])
+
+  // Apply a fit that arrived while first-person (orbit unmounted). Wait one
+  // frame so CameraControls can remount and attach its ref.
+  useEffect(() => {
+    if (isFirstPersonMode || isPreviewMode || !pendingFitSceneRef.current) return
+    const frame = requestAnimationFrame(flushPendingFitScene)
+    return () => cancelAnimationFrame(frame)
+  }, [flushPendingFitScene, isFirstPersonMode, isPreviewMode])
 
   const onTransitionStart = useCallback(() => {
     cameraDraggingLifecycle.begin()

package/src/components/editor/duplicate-node.ts

@@ -9,6 +9,7 @@ import {
   FenceNode,
   generateId,
   ItemNode,
+  isNodeDuplicable,
   nodeRegistry,
   RoofSegmentNode,
   runSceneHistoryDraftWrite,
@@ -48,7 +49,7 @@ export function copyCollectionIds(copy: AnyNode): CollectionId[] {
  * every inspector's Duplicate. The copy is in the collections its source is in.
  */
 export function duplicateNodeAndPickUp(node: AnyNode) {
-  if (!node.parentId) return
+  if (!(node.parentId && isNodeDuplicable(node))) return
   if (startZoneRoomTransform(node, 'duplicate')) return
   sfxEmitter.emit('sfx:item-pick')
   const { setMovingNode } = useEditor.getState()

package/src/components/editor/first-person-controls.tsx

@@ -85,18 +85,16 @@ import { acceleratedRaycast, computeBoundsTree, disposeBoundsTree } from 'three-
 import '../../three-types'
 import {
   closeDoorOpenState,
+  closeWindowOpenState,
   DOOR_SWING_OPEN_ANGLE,
   getDisplayedDoorValue,
-  isOperationDoorType,
-  toggleDoorOpenState,
-} from '../../lib/door-interaction'
-import { isTypingTarget } from '../../lib/typing-target'
-import {
-  closeWindowOpenState,
   getDisplayedWindowValue,
   isOperableWindowType,
+  isOperationDoorType,
+  toggleDoorOpenState,
   toggleWindowOpenState,
-} from '../../lib/window-interaction'
+} from '@pascal-app/core'
+import { isTypingTarget } from '../../lib/typing-target'
 import useEditor from '../../store/use-editor'
 import { useFirstPersonHud, type WalkthroughInteract } from '../../store/use-first-person-hud'
 import { DroneHud, WalkthroughHud } from '../walkthrough-hud'

package/src/components/editor/fit-scene-framing.test.ts

@@ -0,0 +1,318 @@
+import { describe, expect, test } from 'bun:test'
+import { CameraControlsImpl } from '@react-three/drei'
+import * as THREE from 'three'
+import {
+  computeFitSceneLookAt,
+  type PendingFitScene,
+  planFitSceneOnEvent,
+  planFitSceneOnOrbitResume,
+  planLevelFollow,
+} from './fit-scene-framing'
+
+const sampleBounds = {
+  center: [10, 20] as [number, number],
+  size: [30, 40] as [number, number],
+}
+
+describe('fit-scene framing', () => {
+  test('computes default look-at when bounds are null', () => {
+    expect(computeFitSceneLookAt(null)).toEqual({
+      eyeX: 20,
+      eyeY: 20,
+      eyeZ: 20,
+      targetX: 0,
+      targetY: 0,
+      targetZ: 0,
+      eyeHeight: 20,
+      fitSphere: { center: [0, 0, 0], radius: 15 },
+    })
+  })
+
+  test('computes orbit look-at from scene bounds', () => {
+    const lookAt = computeFitSceneLookAt(sampleBounds)
+    // Longer extent is depth=40 → distance=56, height=32
+    expect(lookAt).toEqual({
+      eyeX: 10 + 56 * 0.7,
+      eyeY: 32,
+      eyeZ: 20 + 56 * 0.7,
+      targetX: 10,
+      targetY: 0,
+      targetZ: 20,
+      eyeHeight: 32,
+      fitSphere: { center: [10, 0, 20], radius: 25 * 1.3 },
+    })
+  })
+
+  test('rests the pivot and lifts the eye by the level ground height', () => {
+    const lookAt = computeFitSceneLookAt(sampleBounds, 3)
+    expect(lookAt.targetY).toBe(3)
+    expect(lookAt.eyeY).toBe(35)
+    expect(lookAt.eyeHeight).toBe(32)
+    expect(computeFitSceneLookAt(null, 3)).toMatchObject({ eyeY: 23, targetY: 3 })
+  })
+
+  test('fits the orthographic sphere around the footprint at the pivot', () => {
+    const lookAt = computeFitSceneLookAt(sampleBounds, 3)
+    expect(lookAt.fitSphere.center).toEqual([lookAt.targetX, lookAt.targetY, lookAt.targetZ])
+    const [cx, cz] = sampleBounds.center
+    const [w, d] = sampleBounds.size
+    for (const [x, z] of [
+      [cx - w / 2, cz - d / 2],
+      [cx + w / 2, cz + d / 2],
+      [cx - w / 2, cz + d / 2],
+    ] as const) {
+      expect(Math.hypot(x - cx, z - cz)).toBeLessThan(lookAt.fitSphere.radius)
+    }
+    const lone = computeFitSceneLookAt({ center: [0, 0], size: [1, 0.2] })
+    expect(lone.fitSphere.radius).toBe(5)
+    expect(computeFitSceneLookAt(null, 3).fitSphere).toEqual({ center: [0, 3, 0], radius: 15 })
+  })
+
+  test('an orthographic camera fitted to the sphere shows the whole footprint whatever its zoom was', () => {
+    const previous = globalThis.DOMRect
+    globalThis.DOMRect ??= class {} as typeof DOMRect
+    CameraControlsImpl.install({ THREE })
+    const camera = new THREE.OrthographicCamera(-8, 8, 5, -5, 0.1, 1000)
+    const control = new CameraControlsImpl(camera)
+    const bounds = { center: [60, -20] as [number, number], size: [80, 30] as [number, number] }
+    try {
+      // The previous project left the camera zoomed in on a small room.
+      control.zoomTo(12, false)
+      const lookAt = computeFitSceneLookAt(bounds)
+      control.setLookAt(
+        lookAt.eyeX,
+        lookAt.eyeY,
+        lookAt.eyeZ,
+        lookAt.targetX,
+        lookAt.targetY,
+        lookAt.targetZ,
+        false,
+      )
+      const sphere = new THREE.Sphere(
+        new THREE.Vector3(...lookAt.fitSphere.center),
+        lookAt.fitSphere.radius,
+      )
+      control.fitToSphere(sphere, false)
+      control.update(0)
+      camera.updateMatrixWorld(true)
+
+      const target = control.getTarget(new THREE.Vector3())
+      expect(target.toArray()).toEqual([lookAt.targetX, lookAt.targetY, lookAt.targetZ])
+      const [cx, cz] = bounds.center
+      const [w, d] = bounds.size
+      for (const x of [cx - w / 2, cx + w / 2])
+        for (const z of [cz - d / 2, cz + d / 2]) {
+          const projected = new THREE.Vector3(x, 0, z).project(camera)
+          expect(Math.abs(projected.x)).toBeLessThanOrEqual(1)
+          expect(Math.abs(projected.y)).toBeLessThanOrEqual(1)
+        }
+    } finally {
+      control.dispose()
+      globalThis.DOMRect = previous
+    }
+  })
+
+  test('applies immediately when orbit controls are live', () => {
+    const plan = planFitSceneOnEvent({
+      isPreviewMode: false,
+      isFirstPersonMode: false,
+      hasControls: true,
+      bounds: sampleBounds,
+    })
+
+    expect(plan).toEqual({
+      action: 'apply',
+      lookAt: computeFitSceneLookAt(sampleBounds),
+    })
+  })
+
+  test('ignores fit-scene while preview mode is active', () => {
+    const plan = planFitSceneOnEvent({
+      isPreviewMode: true,
+      isFirstPersonMode: false,
+      hasControls: true,
+      bounds: sampleBounds,
+    })
+    expect(plan).toEqual({ action: 'ignore' })
+  })
+
+  test('queues fit-scene while first-person is active (scene-ready during FP)', () => {
+    const plan = planFitSceneOnEvent({
+      isPreviewMode: false,
+      isFirstPersonMode: true,
+      hasControls: false,
+      bounds: sampleBounds,
+    })
+
+    expect(plan).toEqual({
+      action: 'queue',
+      pending: { bounds: sampleBounds },
+    })
+  })
+
+  test('queues fit-scene when orbit controls are not mounted yet', () => {
+    const plan = planFitSceneOnEvent({
+      isPreviewMode: false,
+      isFirstPersonMode: false,
+      hasControls: false,
+      bounds: sampleBounds,
+    })
+
+    expect(plan).toEqual({
+      action: 'queue',
+      pending: { bounds: sampleBounds },
+    })
+  })
+
+  test('scene-ready during first-person then return to orbit applies the pending frame', () => {
+    // Mirrors the blocking lifecycle: fit arrives while FP is active, then
+    // orbit remounts and the queued frame must still apply.
+    let pending: PendingFitScene | null = null
+
+    const duringFirstPerson = planFitSceneOnEvent({
+      isPreviewMode: false,
+      isFirstPersonMode: true,
+      hasControls: false,
+      bounds: sampleBounds,
+    })
+    expect(duringFirstPerson.action).toBe('queue')
+    if (duringFirstPerson.action === 'queue') {
+      pending = duringFirstPerson.pending
+    }
+
+    // Still in first-person: controls are not ready, keep the pending frame.
+    expect(
+      planFitSceneOnOrbitResume({
+        isPreviewMode: false,
+        isFirstPersonMode: true,
+        hasControls: false,
+        pending,
+      }),
+    ).toEqual({ action: 'noop' })
+
+    // Leave first-person; orbit controls remount and can apply the frame.
+    const afterOrbitResume = planFitSceneOnOrbitResume({
+      isPreviewMode: false,
+      isFirstPersonMode: false,
+      hasControls: true,
+      pending,
+    })
+
+    expect(afterOrbitResume).toEqual({
+      action: 'apply',
+      lookAt: computeFitSceneLookAt(sampleBounds),
+    })
+  })
+
+  test('latest fit-scene while first-person wins when orbit resumes', () => {
+    let pending: PendingFitScene | null = null
+    const first = planFitSceneOnEvent({
+      isPreviewMode: false,
+      isFirstPersonMode: true,
+      hasControls: false,
+      bounds: null,
+    })
+    if (first.action === 'queue') pending = first.pending
+
+    const secondBounds = {
+      center: [0, 0] as [number, number],
+      size: [10, 10] as [number, number],
+    }
+    const second = planFitSceneOnEvent({
+      isPreviewMode: false,
+      isFirstPersonMode: true,
+      hasControls: false,
+      bounds: secondBounds,
+    })
+    if (second.action === 'queue') pending = second.pending
+
+    expect(
+      planFitSceneOnOrbitResume({
+        isPreviewMode: false,
+        isFirstPersonMode: false,
+        hasControls: true,
+        pending,
+      }),
+    ).toEqual({
+      action: 'apply',
+      lookAt: computeFitSceneLookAt(secondBounds),
+    })
+  })
+
+  test('does not flush a pending frame into preview mode', () => {
+    expect(
+      planFitSceneOnOrbitResume({
+        isPreviewMode: true,
+        isFirstPersonMode: false,
+        hasControls: true,
+        pending: { bounds: sampleBounds },
+      }),
+    ).toEqual({ action: 'noop' })
+  })
+})
+
+describe('level follow', () => {
+  type Inputs = { levelId: string | null; levelMode: string; camera: object; sceneEmpty: boolean }
+
+  // The effect's bookkeeping: one instance per mounted CustomCameraControls.
+  function mountLevelFollow(initial: Inputs) {
+    let firstLoad = true
+    let previous = { ...initial }
+    return (next: Inputs) => {
+      const plan = planLevelFollow({
+        firstLoad,
+        sceneEmpty: next.sceneEmpty,
+        levelChanged: previous.levelId !== next.levelId,
+        modeChanged: previous.levelMode !== next.levelMode,
+        cameraChanged: previous.camera !== next.camera,
+      })
+      firstLoad = false
+      previous = { ...next }
+      return plan
+    }
+  }
+
+  const perspective = {}
+  const loaded: Inputs = {
+    levelId: 'level_1',
+    levelMode: 'stacked',
+    camera: perspective,
+    sceneEmpty: false,
+  }
+
+  test('an empty first load takes the default pose', () => {
+    const run = mountLevelFollow({ ...loaded, levelId: null, sceneEmpty: true })
+    expect(run({ ...loaded, levelId: null, sceneEmpty: true })).toBe('default-pose')
+  })
+
+  test('a remount over a loaded scene rests the fresh pivot on the level', () => {
+    const run = mountLevelFollow(loaded)
+    expect(run(loaded)).toBe('rest-pivot')
+    expect(run(loaded)).toBe('none')
+  })
+
+  test('a level-mode change pans the pivot', () => {
+    const run = mountLevelFollow(loaded)
+    run(loaded)
+    expect(run({ ...loaded, levelMode: 'exploded' })).toBe('rest-pivot')
+  })
+
+  test('the first pick after a site-phase load pans to the level', () => {
+    const site = { ...loaded, levelId: null }
+    const run = mountLevelFollow(site)
+    run(site)
+    expect(run(loaded)).toBe('rest-pivot')
+  })
+
+  test('re-picking the same level does not move the pivot', () => {
+    const run = mountLevelFollow(loaded)
+    run(loaded)
+    expect(run({ ...loaded })).toBe('none')
+  })
+
+  test('a camera swap re-rests the new controls pivot', () => {
+    const run = mountLevelFollow(loaded)
+    run(loaded)
+    expect(run({ ...loaded, camera: {} })).toBe('rest-pivot')
+  })
+})