@pascal-app/editor 1.0.0 → 1.0.1

package/src/components/tools/item/shelf-surface-strategy-resolver.test.ts

@@ -0,0 +1,257 @@
+import { afterEach, beforeEach, expect, spyOn, test } from 'bun:test'
+import * as core from '@pascal-app/core'
+import {
+  ItemNode,
+  nodeRegistry,
+  registerNode,
+  type ShelfEvent,
+  ShelfNode,
+  sceneRegistry,
+  useScene,
+} from '@pascal-app/core'
+import { Euler, Group, Quaternion, Vector3 } from 'three'
+import useEditor from '../../../store/use-editor'
+import useInteractionScope from '../../../store/use-interaction-scope'
+import { shelfSurfaceStrategy } from './placement-strategies'
+import type { PlacementContext } from './placement-types'
+
+const host = ShelfNode.parse({ id: 'shelf_resolver-host', width: 2, depth: 1, height: 2 })
+const child = ItemNode.parse({
+  id: 'item_shelf-resolver-child',
+  asset: {
+    id: 'book',
+    name: 'Book',
+    category: 'decor',
+    thumbnail: '',
+    src: '/book.glb',
+    dimensions: [0.5, 0.25, 0.25],
+  },
+  rotation: [0.1, 0.2, 0.3],
+})
+let rows: number[]
+let restoreRegistry: () => void
+let savedNodes: ReturnType<typeof useScene.getState>['nodes']
+let savedEditor: ReturnType<typeof useEditor.getState>
+let savedScope: ReturnType<typeof useInteractionScope.getState>
+let resolver: ReturnType<typeof spyOn<typeof core, 'resolveSurfacePlacement'>>
+
+beforeEach(() => {
+  restoreRegistry = nodeRegistry._snapshot()
+  nodeRegistry._reset()
+  rows = [0.5, 1.5]
+  registerNode({
+    kind: 'shelf',
+    schemaVersion: 1,
+    schema: ShelfNode,
+    category: 'furnish',
+    defaults: () => ({}),
+    capabilities: {
+      surfaces: {
+        custom: () => rows.map((y) => ({ position: [0, y, 0], normal: [0, 1, 0] })),
+      },
+    },
+  })
+  registerNode({
+    kind: 'item',
+    schemaVersion: 1,
+    schema: ItemNode,
+    category: 'furnish',
+    snapProfile: 'item',
+    defaults: () => ({}),
+    capabilities: {},
+  })
+  savedNodes = useScene.getState().nodes
+  savedEditor = useEditor.getState()
+  savedScope = useInteractionScope.getState()
+  useScene.setState({ nodes: { [host.id]: host, [child.id]: child } })
+  useInteractionScope.setState({ scope: { kind: 'idle' } })
+  useEditor.setState({ mode: 'build', tool: 'item', gridSnapStep: 0.5 })
+  useEditor.getState().setSnappingMode('item', 'grid')
+  const mesh = new Group()
+  mesh.updateMatrixWorld(true)
+  sceneRegistry.nodes.set(host.id, mesh)
+  resolver = spyOn(core, 'resolveSurfacePlacement')
+})
+
+afterEach(() => {
+  resolver.mockRestore()
+  restoreRegistry()
+  sceneRegistry.nodes.delete(host.id)
+  useScene.setState({ nodes: savedNodes })
+  useEditor.setState(savedEditor)
+  useInteractionScope.setState(savedScope)
+})
+
+function context(draftItem = child): PlacementContext {
+  return {
+    asset: draftItem.asset,
+    draftItem,
+    state: {
+      surface: 'floor',
+      wallId: null,
+      roofSegmentId: null,
+      ceilingId: null,
+      surfaceItemId: null,
+      shelfId: null,
+    },
+    currentCursorRotationY: 0.7,
+    gridPosition: new Vector3(),
+    levelId: 'level_test',
+  } as PlacementContext
+}
+
+function onShelf(ctx: PlacementContext): PlacementContext {
+  return { ...ctx, state: { ...ctx.state, surface: 'shelf-surface', shelfId: host.id } }
+}
+
+function hit(y = 1, z = -0.1): ShelfEvent {
+  const object = sceneRegistry.nodes.get(host.id)!
+  return {
+    node: host,
+    object,
+    normal: [0, 1, 0],
+    position: object.localToWorld(new Vector3(0.37, y, z)).toArray(),
+    localPosition: [0.37, y, z],
+    nativeEvent: {},
+    stopPropagation() {},
+  } as ShelfEvent
+}
+
+test.each([
+  'grid',
+  'off',
+] as const)('midpoint keeps the first declared row and preserves X/Z with grid %s', (mode) => {
+  useEditor.getState().setSnappingMode('item', mode)
+  for (const declared of [
+    [0.5, 1.5],
+    [1.5, 0.5],
+  ]) {
+    rows = declared
+    const expected: [number, number, number] =
+      mode === 'grid' ? [0.25, rows[0]!, 0.125] : [0.37, rows[0]!, -0.1]
+    const ctx = context()
+    const entered = shelfSurfaceStrategy.enter(ctx, hit())!
+    expect(entered.nodeUpdate).toEqual({
+      position: expected,
+      parentId: host.id,
+      rotation: [0.1, 0.7, 0.3],
+    })
+    expect(entered.gridPosition).toEqual(expected)
+    expect(entered.cursorPosition).toEqual(expected)
+    const moved = shelfSurfaceStrategy.move(onShelf(ctx), hit())!
+    expect(moved.nodeUpdate).toEqual({ position: expected })
+    expect(moved.cursorPosition).toEqual(expected)
+    const committed = shelfSurfaceStrategy.click(
+      { ...onShelf(ctx), gridPosition: new Vector3(...entered.gridPosition) },
+      hit(),
+    )!
+    expect(committed.nodeUpdate.position).toEqual(expected)
+    expect(committed.nodeUpdate.parentId).toBe(host.id)
+  }
+  expect(resolver).toHaveBeenCalledTimes(6)
+})
+
+test.each([
+  [0.999, 0.5],
+  [1.001, 1.5],
+])('hit Y %s elects nearest row %s on enter and move', (y, expected) => {
+  expect(shelfSurfaceStrategy.enter(context(), hit(y))!.gridPosition[1]).toBe(expected)
+  expect(shelfSurfaceStrategy.move(onShelf(context()), hit(y))!.gridPosition[1]).toBe(expected)
+})
+
+test.each([
+  [2.01, 0.25],
+  [0.5, 1.01],
+])('scaled footprint %s by %s overhang is accepted on enter and move', (width, depth) => {
+  const draft = ItemNode.parse({
+    ...child,
+    asset: { ...child.asset, dimensions: [width / 2, 0.25, depth / 2] },
+    scale: [2, 1, 2],
+  })
+  const ctx = context(draft)
+  expect(shelfSurfaceStrategy.enter(ctx, hit())).not.toBeNull()
+  expect(shelfSurfaceStrategy.move(onShelf(ctx), hit())).not.toBeNull()
+  expect(resolver.mock.calls.map(([args]) => args.checkFootprint)).toEqual([true, true])
+})
+
+test('a full-board object is refused when grid snapping puts its centre outside the board', () => {
+  const draft = ItemNode.parse({
+    ...child,
+    asset: { ...child.asset, dimensions: [host.width, 0.25, host.depth] },
+  })
+  expect(shelfSurfaceStrategy.enter(context(draft), hit(1, -0.39))).toBeNull()
+})
+
+test.each([
+  'grid',
+  'off',
+] as const)('shelf frame conversion retains exact poses with grid %s', (mode) => {
+  useEditor.getState().setSnappingMode('item', mode)
+  const mesh = sceneRegistry.nodes.get(host.id)!
+  mesh.position.set(4, 2, -3)
+  mesh.rotation.set(0, Math.PI / 3, 0)
+  mesh.updateMatrixWorld(true)
+  const event = hit(1.2)
+  const local = mesh.worldToLocal(new Vector3(...event.position))
+  const expected: [number, number, number] =
+    mode === 'grid' ? [0.25, 1.5, 0.125] : [local.x, 1.5, local.z]
+  const yaw = new Euler().setFromQuaternion(mesh.getWorldQuaternion(new Quaternion()), 'YXZ').y
+  const entered = shelfSurfaceStrategy.enter(context(), event)!
+  expect(entered.nodeUpdate).toEqual({
+    position: expected,
+    parentId: host.id,
+    rotation: [0.1, 0.7 - yaw, 0.3],
+  })
+  expect(entered.cursorPosition).toEqual(mesh.localToWorld(new Vector3(...expected)).toArray())
+  expect(shelfSurfaceStrategy.move(onShelf(context()), event)!.gridPosition).toEqual(expected)
+})
+
+test('only enter requires an upward normal; moves keep electing rows', () => {
+  for (const normal of [[1, 0, 0], [0, -1, 0], undefined] as ShelfEvent['normal'][]) {
+    const event = { ...hit(), normal }
+    expect(shelfSurfaceStrategy.enter(context(), event)).toBeNull()
+    expect(shelfSurfaceStrategy.move(onShelf(context()), event)!.gridPosition[1]).toBe(0.5)
+  }
+})
+
+test('missing rows and resolver rejection leave the draft untouched', () => {
+  const before = useScene.getState().nodes
+  rows = []
+  expect(shelfSurfaceStrategy.enter(context(), hit())).toBeNull()
+  expect(shelfSurfaceStrategy.move(onShelf(context()), hit())).toBeNull()
+  rows = [0.5, 1.5]
+  resolver.mockReturnValue(null)
+  expect(shelfSurfaceStrategy.enter(context(), hit())).toBeNull()
+  expect(shelfSurfaceStrategy.move(onShelf(context()), hit())).toBeNull()
+  expect(useScene.getState().nodes).toBe(before)
+})
+
+test('a centred unrotated object exactly matching the board is accepted with epsilon tolerance', () => {
+  useEditor.getState().setSnappingMode('item', 'off')
+  const region = core.shelfSurfaceProvider.surfaces!(host, {
+    scene: core.createSceneApi(useScene),
+  })[0]!.region
+  const draft = ItemNode.parse({
+    ...child,
+    rotation: [0, 0, 0],
+    asset: { ...child.asset, dimensions: [region.size![0] * 2, 0.25, region.size![1] * 2] },
+  })
+  const ctx = { ...context(draft), currentCursorRotationY: 0 }
+  for (const x of [0, 1e-7]) {
+    const event = { ...hit(), position: [x, 0.5, 0], localPosition: [x, 0.5, 0] } as ShelfEvent
+    expect(shelfSurfaceStrategy.enter(ctx, event)).not.toBeNull()
+  }
+})
+
+test('shelf validation uses the current shelf after leaving a different surface host', () => {
+  const other = ItemNode.parse({
+    ...child,
+    id: 'item_previous-host',
+    asset: { ...child.asset, dimensions: [0.01, 0.1, 0.01] },
+  })
+  useScene.setState({ nodes: { ...useScene.getState().nodes, [other.id]: other } })
+  const ctx = onShelf(context(ItemNode.parse({ ...child, rotation: [0, 0, 0] })))
+  ctx.state.surfaceItemId = other.id
+  ctx.gridPosition.set(0, 0.5, 0)
+  expect(shelfSurfaceStrategy.click(ctx, hit())).not.toBeNull()
+})

package/src/components/tools/item/use-draft-node.ts

@@ -9,10 +9,17 @@ import {
 import { beginPerfAction, commitPerfAction, useViewer } from '@pascal-app/viewer'
 import { useCallback, useMemo, useRef } from 'react'
 import type { Vector3 } from 'three'
+import {
+  surfaceAttachmentId,
+  surfaceAttachmentUpdates,
+  surfaceFramePose,
+  updateSurfaceNode,
+} from '../../../lib/surface-attachment'
 import usePlacementPreview from '../../../store/use-placement-preview'
 import { stripTransient } from './placement-math'
 
 interface OriginalState {
+  surfaceId: string | null
   position: [number, number, number]
   rotation: [number, number, number]
   side: ItemNode['side']
@@ -26,6 +33,7 @@ interface OriginalState {
 }
 
 export interface DraftNodeHandle {
+  updateSurface: (data: Partial<ItemNode>, surfaceId: string | null) => void
   /** Current draft item, or null */
   readonly current: ItemNode | null
   /** Whether the current draft was adopted (move mode) vs created (create mode) */
@@ -112,6 +120,7 @@ export function useDraftNode(): DraftNodeHandle {
         : {}
 
     originalStateRef.current = {
+      surfaceId: surfaceAttachmentId(node),
       position: [...node.position] as [number, number, number],
       rotation: [...node.rotation] as [number, number, number],
       side: node.side,
@@ -122,7 +131,10 @@ export function useDraftNode(): DraftNodeHandle {
       metadata: node.metadata,
     }
 
-    draftRef.current = node
+    draftRef.current = {
+      ...node,
+      ...surfaceFramePose(node.parentId, surfaceAttachmentId(node), node, false),
+    }
     adoptedRef.current = true
 
     // Mark as transient so it renders as a draft
@@ -149,6 +161,14 @@ export function useDraftNode(): DraftNodeHandle {
       const draft = draftRef.current
       if (!draft) return null
 
+      const surfaceId = surfaceAttachmentId(useScene.getState().nodes[draft.id] ?? draft)
+      const stored = surfaceFramePose(
+        finalUpdate.parentId ?? draft.parentId,
+        surfaceId,
+        { ...draft, ...finalUpdate },
+        true,
+      )
+      finalUpdate = { ...finalUpdate, ...stored }
       if (adoptedRef.current) {
         // Move mode: update in place (single undoable action)
         const { parentId: newParentId, ...updateProps } = finalUpdate
@@ -159,16 +179,20 @@ export function useDraftNode(): DraftNodeHandle {
         const original = originalStateRef.current!
 
         // Restore original state while paused — so the undo baseline is clean
-        useScene.getState().updateNode(draft.id, {
-          position: original.position,
-          rotation: original.rotation,
-          side: original.side,
-          parentId: original.parentId,
-          roofSegmentId: original.roofSegmentId,
-          roofFace: original.roofFace,
-          blockFaceId: original.blockFaceId,
-          metadata: original.metadata,
-        })
+        updateSurfaceNode(
+          draft.id,
+          {
+            position: original.position,
+            rotation: original.rotation,
+            side: original.side,
+            parentId: original.parentId,
+            roofSegmentId: original.roofSegmentId,
+            roofFace: original.roofFace,
+            blockFaceId: original.blockFaceId,
+            metadata: original.metadata,
+          },
+          original.surfaceId,
+        )
 
         // Resume → tracked update (undo reverts to original)
         useScene.temporal.getState().resume()
@@ -180,28 +204,32 @@ export function useDraftNode(): DraftNodeHandle {
           metadata: updateProps.metadata ?? stripTransient(draft.metadata),
         })
 
-        useScene.getState().updateNode(draft.id, {
-          position: updateProps.position ?? draft.position,
-          rotation: updateProps.rotation ?? draft.rotation,
-          side: updateProps.side ?? draft.side,
-          metadata: updateProps.metadata ?? stripTransient(draft.metadata),
-          parentId: parentId as string,
-          // Forward the roof host explicitly: strategies set it on every
-          // commit (segment id on a roof face, undefined elsewhere), and
-          // dropping it here strands the item in the roof frame without
-          // the segment transform.
-          roofSegmentId: updateProps.roofSegmentId,
-          roofFace: updateProps.roofFace,
-          blockFaceId: updateProps.blockFaceId,
-          // Only when the strategy decided about wallId (roof commits clear
-          // it) — floor/ceiling commits never managed the field.
-          ...('wallId' in updateProps ? { wallId: updateProps.wallId } : {}),
-          ...resolveSupportSlabPatch(effectiveNode, useScene.getState().nodes, {
-            maxElevation: options?.supportElevationCap,
-            preferredSlabId: options?.preferredSupportSlabId,
-            pinSupport: options?.pinSupport,
-          }),
-        })
+        updateSurfaceNode(
+          draft.id,
+          {
+            position: updateProps.position ?? draft.position,
+            rotation: updateProps.rotation ?? draft.rotation,
+            side: updateProps.side ?? draft.side,
+            metadata: updateProps.metadata ?? stripTransient(draft.metadata),
+            parentId: parentId as string,
+            // Forward the roof host explicitly: strategies set it on every
+            // commit (segment id on a roof face, undefined elsewhere), and
+            // dropping it here strands the item in the roof frame without
+            // the segment transform.
+            roofSegmentId: updateProps.roofSegmentId,
+            roofFace: updateProps.roofFace,
+            blockFaceId: updateProps.blockFaceId,
+            // Only when the strategy decided about wallId (roof commits clear
+            // it) — floor/ceiling commits never managed the field.
+            ...('wallId' in updateProps ? { wallId: updateProps.wallId } : {}),
+            ...resolveSupportSlabPatch(effectiveNode, useScene.getState().nodes, {
+              maxElevation: options?.supportElevationCap,
+              preferredSlabId: options?.preferredSupportSlabId,
+              pinSupport: options?.pinSupport,
+            }),
+          },
+          surfaceId,
+        )
 
         useScene.temporal.getState().pause()
 
@@ -222,6 +250,7 @@ export function useDraftNode(): DraftNodeHandle {
 
       beginPerfAction('place:item', draft.id)
       // Delete draft while paused (invisible to undo)
+      updateSurfaceNode(draft.id, {}, null)
       useScene.getState().deleteNode(draft.id)
       draftRef.current = null
 
@@ -259,7 +288,10 @@ export function useDraftNode(): DraftNodeHandle {
           },
         ),
       })
-      useScene.getState().createNode(committedNode, parentId)
+      useScene.getState().applyNodeChanges({
+        create: [{ node: committedNode, parentId }],
+        update: surfaceAttachmentUpdates(committedNode.id, parentId, surfaceId),
+      })
       if (usePlacementPreview.getState().node?.id === draft.id) {
         usePlacementPreview.getState().clear()
       }
@@ -293,6 +325,7 @@ export function useDraftNode(): DraftNodeHandle {
       const live = useScene.getState().nodes[id as AnyNodeId] as ItemNode | undefined
       const livePosition = live?.position
       const externallyMoved =
+        !live?.metadata?.isTransient &&
         !!livePosition &&
         (livePosition[0] !== original.position[0] ||
           livePosition[1] !== original.position[1] ||
@@ -307,16 +340,20 @@ export function useDraftNode(): DraftNodeHandle {
         return
       }
 
-      useScene.getState().updateNode(id, {
-        position: original.position,
-        rotation: original.rotation,
-        side: original.side,
-        parentId: original.parentId,
-        roofSegmentId: original.roofSegmentId,
-        roofFace: original.roofFace,
-        blockFaceId: original.blockFaceId,
-        metadata: original.metadata,
-      })
+      updateSurfaceNode(
+        id,
+        {
+          position: original.position,
+          rotation: original.rotation,
+          side: original.side,
+          parentId: original.parentId,
+          roofSegmentId: original.roofSegmentId,
+          roofFace: original.roofFace,
+          blockFaceId: original.blockFaceId,
+          metadata: original.metadata,
+        },
+        original.surfaceId,
+      )
 
       // Also reset the Three.js mesh directly — the store update triggers a React
       // re-render but the mesh position was mutated by useFrame and may not reset
@@ -329,6 +366,7 @@ export function useDraftNode(): DraftNodeHandle {
       }
     } else {
       // Create mode: delete the transient node
+      updateSurfaceNode(draftRef.current.id, {}, null)
       useScene.getState().deleteNode(draftRef.current.id)
     }
 
@@ -340,6 +378,17 @@ export function useDraftNode(): DraftNodeHandle {
     }
   }, [])
 
+  const updateSurface = useCallback((data: Partial<ItemNode>, surfaceId: string | null) => {
+    const draft = draftRef.current
+    if (!draft) return
+    const pose = { ...draft, ...data }
+    updateSurfaceNode(
+      draft.id,
+      { ...data, ...surfaceFramePose(pose.parentId, surfaceId, pose, true) },
+      surfaceId,
+    )
+  }, [])
+
   return useMemo(
     () => ({
       get current() {
@@ -348,11 +397,12 @@ export function useDraftNode(): DraftNodeHandle {
       get isAdopted() {
         return adoptedRef.current
       },
+      updateSurface,
       create,
       adopt,
       commit,
       destroy,
     }),
-    [create, adopt, commit, destroy],
+    [create, adopt, commit, destroy, updateSurface],
   )
 }