@pascal-app/editor 1.0.3 → 1.0.4

package/src/components/tools/item/use-draft-node.test.tsx

@@ -1,13 +1,19 @@
-import { beforeEach, describe, expect, test } from 'bun:test'
+import { beforeEach, describe, expect, spyOn, test } from 'bun:test'
 import {
   type AnyNodeId,
+  applySceneSnapshot,
   BlockNode,
   BuildingNode,
+  beginSceneHistoryPauseSession,
   getBlockFaceFrame,
+  getSceneHistoryPauseDepth,
   ItemNode,
   LevelNode,
   type NodeEvent,
+  pauseSceneHistory,
+  resumeSceneHistory,
   useScene,
+  WallNode,
 } from '@pascal-app/core'
 import { useViewer } from '@pascal-app/viewer'
 import { renderToString } from 'react-dom/server'
@@ -76,6 +82,232 @@ beforeEach(() => {
 })
 
 describe('useDraftNode block face commit', () => {
+  test.each(
+    (['parse', 'write'] as const).flatMap((failure) =>
+      (['retry', 'cancel', 'foreign move then cancel'] as const).map((finish) => ({
+        failure,
+        finish,
+      })),
+    ),
+  )('an adopted $failure rejection retains owned history through $finish', ({
+    failure,
+    finish,
+  }) => {
+    const item = ItemNode.parse({
+      parentId: LEVEL_ID,
+      position: [1, 0, 1],
+      asset: { id: 'box', name: 'Box', category: 'decor', thumbnail: '', src: '/box.glb' },
+    })
+    useScene.getState().createNode(item, LEVEL_ID as AnyNodeId)
+    useScene.temporal.getState().clear()
+    const originalNodes = structuredClone(useScene.getState().nodes)
+    const draft = draftNode!
+    draft.adopt(item)
+    draft.updateSurface({ position: [2, 0, 2] }, null)
+    const commit = (position: ItemNode['position']) => {
+      const drop = beginSceneHistoryPauseSession(useScene, { gesture: item.id })
+      try {
+        return drop.commitStep(() => draft.commit({ parentId: LEVEL_ID, position }))
+      } finally {
+        drop.end()
+      }
+    }
+    const updateNodes = useScene.getState().updateNodes
+    try {
+      if (failure === 'write') {
+        useScene.setState({
+          updateNodes: (updates) => {
+            if (
+              useScene.temporal.getState().isTracking &&
+              updates.some(
+                (update) =>
+                  update.id === item.id &&
+                  'position' in update.data &&
+                  update.data.position?.[0] === 3,
+              )
+            ) {
+              throw new Error('Rejected tracked write before publication')
+            }
+            return updateNodes(updates)
+          },
+        })
+      }
+      expect(() => commit(failure === 'parse' ? [Number.NaN, 0, 3] : [3, 0, 3])).toThrow()
+      useScene.setState({ updateNodes })
+      expect(draft.current?.id).toBe(item.id)
+      expect(useScene.getState().nodes).toEqual(originalNodes)
+      expect(useScene.temporal.getState().pastStates).toHaveLength(0)
+      expect(useScene.temporal.getState().isTracking).toBe(true)
+      expect(getSceneHistoryPauseDepth()).toBe(0)
+
+      draft.updateSurface({ position: [4, 0, 4] }, null)
+      useScene.getState().updateNode(item.id, { name: 'Foreign rename' })
+      expect(useScene.temporal.getState().pastStates).toHaveLength(1)
+      expect(useScene.temporal.getState().pastStates[0]?.nodes).toEqual(originalNodes)
+      const renamedNodes = {
+        ...originalNodes,
+        [item.id]: { ...originalNodes[item.id]!, name: 'Foreign rename' },
+      }
+
+      if (finish === 'retry') {
+        expect(commit([5, 0, 5])).toBe(item.id)
+        expect(draft.current).toBeNull()
+        const committedNodes = structuredClone(useScene.getState().nodes)
+        expect(committedNodes[item.id]).toMatchObject({
+          name: 'Foreign rename',
+          position: [5, 0, 5],
+        })
+        expect(useScene.temporal.getState().pastStates).toHaveLength(2)
+        useScene.temporal.getState().undo()
+        expect(useScene.getState().nodes).toEqual(renamedNodes)
+        useScene.temporal.getState().redo()
+        expect(useScene.getState().nodes).toEqual(committedNodes)
+      } else if (finish === 'cancel') {
+        draft.destroy()
+        expect(useScene.getState().nodes).toEqual(renamedNodes)
+        expect(useScene.temporal.getState().pastStates).toHaveLength(1)
+        useScene.temporal.getState().undo()
+        expect(useScene.getState().nodes).toEqual(originalNodes)
+        useScene.temporal.getState().redo()
+        expect(useScene.getState().nodes).toEqual(renamedNodes)
+      } else {
+        useScene.getState().updateNode(item.id, { position: [7, 0, 7] })
+        const foreignNodes = structuredClone(useScene.getState().nodes)
+        draft.destroy()
+        expect(useScene.getState().nodes).toEqual(foreignNodes)
+        expect(useScene.temporal.getState().pastStates).toHaveLength(2)
+        useScene.temporal.getState().undo()
+        expect(useScene.getState().nodes).toEqual(renamedNodes)
+        useScene.temporal.getState().redo()
+        expect(useScene.getState().nodes).toEqual(foreignNodes)
+      }
+      expect(useScene.temporal.getState().isTracking).toBe(true)
+      expect(getSceneHistoryPauseDepth()).toBe(0)
+    } finally {
+      useScene.setState({ updateNodes })
+      draft.destroy()
+    }
+  })
+
+  test('a drop on an undone host waits for a new valid placement target', () => {
+    const item = ItemNode.parse({
+      parentId: LEVEL_ID,
+      position: [1, 0, 1],
+      asset: { id: 'box', name: 'Box', category: 'decor', thumbnail: '', src: '/box.glb' },
+    })
+    useScene.getState().createNode(item, LEVEL_ID as AnyNodeId)
+    useScene.temporal.getState().clear()
+    const wall = WallNode.parse({ parentId: LEVEL_ID, start: [10, 10], end: [14, 10] })
+    useScene.getState().createNode(wall, LEVEL_ID as AnyNodeId)
+    const draft = draftNode!
+    draft.adopt(item)
+    draft.updateSurface({ parentId: wall.id, position: [2, 1, 0] }, null)
+    useScene.temporal.getState().undo()
+    expect(useScene.getState().nodes[wall.id]).toBeUndefined()
+    expect(draft.commit({ parentId: wall.id, position: [2, 1, 0] })).toBeNull()
+    expect(draft.current).not.toBeNull()
+    expect(useScene.temporal.getState().pastStates).toHaveLength(0)
+    expect(draft.commit({ parentId: LEVEL_ID, position: [12, 1, 10] })).toBe(item.id)
+    expect(useScene.getState().nodes[item.id]).toMatchObject({
+      parentId: LEVEL_ID,
+      position: [12, 1, 10],
+    })
+  })
+
+  test('a subscriber failure after create cannot strand a transient node', () => {
+    let createdId: AnyNodeId | undefined
+    const unsubscribe = useScene.subscribe((state) => {
+      if (createdId) return
+      const created = Object.values(state.nodes).find(
+        (node) => node.type === 'item' && node.metadata?.isTransient,
+      )
+      if (!created) return
+      createdId = created.id
+      throw new Error('subscriber rejected published draft')
+    })
+    try {
+      expect(() =>
+        draftNode!.create(new Vector3(), {
+          id: 'box',
+          name: 'Box',
+          category: 'decor',
+          thumbnail: '',
+          src: '/box.glb',
+        }),
+      ).toThrow('subscriber rejected published draft')
+    } finally {
+      unsubscribe()
+    }
+    expect(createdId).toBeDefined()
+    expect(useScene.getState().nodes[createdId!]).toBeUndefined()
+    expect((useScene.getState().nodes[LEVEL_ID as AnyNodeId] as LevelNode).children).not.toContain(
+      createdId!,
+    )
+    expect(useScene.temporal.getState().pastStates).toHaveLength(0)
+    draftNode!.destroy()
+  })
+
+  test('a failed create releases its history draft so host snapshots still load', () => {
+    const createNode = spyOn(useScene.getState(), 'createNode').mockImplementation(() => {
+      throw new Error('create rejected')
+    })
+    try {
+      expect(() =>
+        draftNode!.create(new Vector3(), {
+          id: 'box',
+          name: 'Box',
+          category: 'decor',
+          thumbnail: '',
+          src: '/box.glb',
+        }),
+      ).toThrow('create rejected')
+    } finally {
+      createNode.mockRestore()
+    }
+    draftNode!.destroy()
+    const state = useScene.getState()
+    expect(() =>
+      applySceneSnapshot(
+        {
+          nodes: state.nodes,
+          rootNodeIds: state.rootNodeIds,
+          collections: state.collections,
+          materials: state.materials,
+          installedPlugins: state.installedPlugins,
+        },
+        { origin: 'host' },
+      ),
+    ).not.toThrow()
+  })
+
+  test('a rejected fresh drop keeps its draft registered until cancel', () => {
+    const fresh = ItemNode.parse({
+      parentId: LEVEL_ID,
+      metadata: { isNew: true },
+      asset: { id: 'box', name: 'Box', category: 'decor', thumbnail: '', src: '/box.glb' },
+    })
+    useScene.getState().createNode(fresh, LEVEL_ID as AnyNodeId)
+    const draft = draftNode!
+    draft.adopt(fresh)
+    useScene.setState({ readOnly: true })
+    expect(draft.commit({ position: [2, 0, 3] })).toBeNull()
+    useScene.setState({ readOnly: false })
+    const state = useScene.getState()
+    expect(() =>
+      applySceneSnapshot(
+        {
+          nodes: state.nodes,
+          rootNodeIds: state.rootNodeIds,
+          collections: state.collections,
+          materials: state.materials,
+          installedPlugins: state.installedPlugins,
+        },
+        { origin: 'host' },
+      ),
+    ).toThrow()
+    draft.destroy()
+  })
+
   test('persists the face host used by the placement preview', () => {
     const draft = draftNode!
     draft.create(new Vector3(0, 0, 0), {
@@ -115,6 +347,8 @@ describe('useDraftNode block face commit', () => {
       dimensions: [0.5, 0.39, 0.5],
     })!
 
+    expect(useScene.temporal.getState().isTracking).toBe(false)
+    useScene.temporal.getState().resume()
     const committedId = draft.commit({
       parentId: BLOCK_ID,
       position: [0.5, 0, 0],
@@ -142,6 +376,27 @@ describe('useDraftNode block face commit', () => {
     )
   })
 
+  test('a duplicate drops into the collections of the item it copies, in its one undo step', () => {
+    const asset = { id: 'lamp', name: 'Lamp', category: 'decor', thumbnail: '', src: '/lamp.glb' }
+    useScene.temporal.getState().pause()
+    const lamp = ItemNode.parse({ parentId: LEVEL_ID, position: [1, 0, 1], asset })
+    useScene.getState().createNode(lamp, LEVEL_ID as AnyNodeId)
+    const lightingId = useScene.getState().createCollection('Lighting', [lamp.id])
+    const lighting = useScene.getState().collections[lightingId]
+    const source = useScene.getState().nodes[lamp.id] as ItemNode
+    const draft = draftNode!
+    draft.create(new Vector3(3, 0, 3), asset, undefined, undefined, source)
+    useScene.temporal.getState().resume()
+
+    const copyId = draft.commit({ parentId: LEVEL_ID, position: [3, 0, 3] }) as AnyNodeId
+
+    expect(useScene.getState().nodes[copyId]).toMatchObject({ collectionIds: [lightingId] })
+    expect(useScene.getState().collections[lightingId]?.nodeIds).toEqual([lamp.id, copyId])
+    useScene.temporal.getState().undo()
+    expect(useScene.getState().nodes[copyId]).toBeUndefined()
+    expect(useScene.getState().collections[lightingId]).toEqual(lighting)
+  })
+
   test('moves a block-face item to the floor as one undoable reparent', () => {
     const hosted = ItemNode.parse({
       id: 'item_hosted-potted-plant',
@@ -164,6 +419,8 @@ describe('useDraftNode block face commit', () => {
 
     const draft = draftNode!
     draft.adopt(hosted)
+    expect(useScene.temporal.getState().isTracking).toBe(false)
+    useScene.temporal.getState().resume()
     draft.commit({
       parentId: LEVEL_ID,
       position: [2, 0, 3],
@@ -202,6 +459,180 @@ describe('useDraftNode block face commit', () => {
     )
   })
 
+  test('drops onto the level when the original host was deleted mid-carry', () => {
+    const hosted = ItemNode.parse({
+      id: 'item_host-deleted-plant',
+      parentId: BLOCK_ID,
+      asset: {
+        id: 'potted-plant',
+        category: 'decor',
+        name: 'Potted plant',
+        thumbnail: '/potted-plant.png',
+        src: '/potted-plant.glb',
+        dimensions: [0.5, 0.39, 0.5],
+      },
+      position: [0.5, 0, 0],
+      blockFaceId: 'face-top',
+    })
+    useScene.getState().createNode(hosted, BLOCK_ID as AnyNodeId)
+    useScene.temporal.getState().clear()
+
+    const draft = draftNode!
+    draft.adopt(hosted)
+    draft.updateSurface({ parentId: LEVEL_ID, position: [1, 0, 1], blockFaceId: undefined }, null)
+    // A collaborator deletes the block the item came from.
+    useScene.getState().deleteNode(BLOCK_ID as AnyNodeId)
+    draft.commit({ position: [2, 0, 3] })
+
+    const nodes = useScene.getState().nodes
+    expect(nodes[BLOCK_ID as AnyNodeId]).toBeUndefined()
+    expect(nodes[hosted.id as AnyNodeId]).toMatchObject({ parentId: LEVEL_ID, position: [2, 0, 3] })
+    expect((nodes[LEVEL_ID as AnyNodeId] as LevelNode).children).toContain(hosted.id)
+    for (const state of useScene.temporal.getState().pastStates) {
+      const recorded = state.nodes?.[hosted.id as AnyNodeId]
+      if (recorded?.parentId) expect(state.nodes?.[recorded.parentId as AnyNodeId]).toBeDefined()
+    }
+  })
+
+  test('cancel after the original host was deleted mid-carry keeps the item on the level', () => {
+    const hosted = ItemNode.parse({
+      id: 'item_host-deleted-cancel',
+      parentId: BLOCK_ID,
+      asset: {
+        id: 'potted-plant',
+        category: 'decor',
+        name: 'Potted plant',
+        thumbnail: '/potted-plant.png',
+        src: '/potted-plant.glb',
+        dimensions: [0.5, 0.39, 0.5],
+      },
+      position: [0.5, 0, 0],
+      blockFaceId: 'face-top',
+    })
+    useScene.getState().createNode(hosted, BLOCK_ID as AnyNodeId)
+    useScene.temporal.getState().clear()
+
+    const draft = draftNode!
+    draft.adopt(hosted)
+    draft.updateSurface({ parentId: LEVEL_ID, position: [1, 0, 1], blockFaceId: undefined }, null)
+    useScene.getState().deleteNode(BLOCK_ID as AnyNodeId)
+    draft.destroy()
+
+    const nodes = useScene.getState().nodes
+    expect(nodes[hosted.id as AnyNodeId]?.parentId).toBe(LEVEL_ID)
+    expect((nodes[LEVEL_ID as AnyNodeId] as LevelNode).children).toContain(hosted.id)
+  })
+
+  test("cancel and drop-then-undo keep a collaborator's later position", () => {
+    const plant = ItemNode.parse({
+      id: 'item_collab-position-plant',
+      parentId: LEVEL_ID,
+      asset: {
+        id: 'potted-plant',
+        category: 'decor',
+        name: 'Potted plant',
+        thumbnail: '/potted-plant.png',
+        src: '/potted-plant.glb',
+        dimensions: [0.5, 0.39, 0.5],
+      },
+      position: [0, 0, 0],
+    })
+    useScene.getState().createNode(plant, LEVEL_ID as AnyNodeId)
+    const id = plant.id as AnyNodeId
+    const position = () => (useScene.getState().nodes[id] as ItemNode).position
+
+    // Escape keeps the collaborator's position.
+    useScene.temporal.getState().clear()
+    const draft = draftNode!
+    draft.adopt(useScene.getState().nodes[id] as ItemNode)
+    draft.updateSurface({ position: [1, 0, 1] }, null)
+    useScene.getState().updateNode(id, { position: [7, 0, 7] })
+    draft.destroy()
+    expect(position()).toEqual([7, 0, 7])
+
+    // Drop, then undo, returns to the collaborator's position.
+    useScene.temporal.getState().clear()
+    draft.adopt(useScene.getState().nodes[id] as ItemNode)
+    draft.updateSurface({ position: [1, 0, 1] }, null)
+    useScene.getState().updateNode(id, { position: [5, 0, 5] })
+    draft.commit({ parentId: LEVEL_ID, position: [2, 0, 3] })
+    expect(position()).toEqual([2, 0, 3])
+    useScene.temporal.getState().undo()
+    expect(position()).toEqual([5, 0, 5])
+  })
+
+  test("the 3D drop keeps an agent's metadata edit made during the carry, in one step", () => {
+    const plant = ItemNode.parse({
+      id: 'item_agent-metadata-plant',
+      parentId: LEVEL_ID,
+      asset: {
+        id: 'potted-plant',
+        category: 'decor',
+        name: 'Potted plant',
+        thumbnail: '/potted-plant.png',
+        src: '/potted-plant.glb',
+        dimensions: [0.5, 0.39, 0.5],
+      },
+      position: [0, 0, 0],
+    })
+    useScene.getState().createNode(plant, LEVEL_ID as AnyNodeId)
+    const id = plant.id as AnyNodeId
+    useScene.temporal.getState().clear()
+    const draft = draftNode!
+    draft.adopt(useScene.getState().nodes[id] as ItemNode)
+    draft.updateSurface({ position: [1, 0, 1] }, null)
+    const metadata = useScene.getState().nodes[id]!.metadata as Record<string, unknown>
+    useScene.getState().updateNode(id, { metadata: { ...metadata, tag: 'x' } })
+    const past = useScene.temporal.getState().pastStates.length
+    // Placement strategies hand the drop the adoption-time metadata.
+    draft.commit({ parentId: LEVEL_ID, position: [2, 0, 3], metadata: {} })
+
+    const live = useScene.getState().nodes[id] as ItemNode
+    expect(live.position).toEqual([2, 0, 3])
+    expect((live.metadata as Record<string, unknown>).tag).toBe('x')
+    expect((live.metadata as Record<string, unknown>).isTransient).toBeUndefined()
+    expect(useScene.temporal.getState().pastStates).toHaveLength(past + 1)
+    useScene.temporal.getState().undo()
+    expect((useScene.getState().nodes[id] as ItemNode).position).toEqual([0, 0, 0])
+    expect(useScene.getState().nodes[id]?.metadata?.isTransient).toBeUndefined()
+  })
+
+  test('never resumes history that another owner is pausing', () => {
+    const hosted = ItemNode.parse({
+      id: 'item_owned-pause-plant',
+      parentId: LEVEL_ID,
+      asset: {
+        id: 'potted-plant',
+        category: 'decor',
+        name: 'Potted plant',
+        thumbnail: '/potted-plant.png',
+        src: '/potted-plant.glb',
+        dimensions: [0.5, 0.39, 0.5],
+      },
+      position: [0, 0, 0],
+    })
+    useScene.getState().createNode(hosted, LEVEL_ID as AnyNodeId)
+    useScene.temporal.getState().clear()
+    pauseSceneHistory(useScene)
+    try {
+      const draft = draftNode!
+      draft.adopt(hosted)
+      draft.commit({ parentId: LEVEL_ID, position: [2, 0, 3] })
+      draft.create(new Vector3(1, 0, 1), hosted.asset)
+      draft.commit({ parentId: LEVEL_ID, position: [1, 0, 1] })
+
+      expect(useScene.getState().nodes[hosted.id as AnyNodeId]).toMatchObject({
+        position: [2, 0, 3],
+      })
+      expect(useScene.temporal.getState().isTracking).toBe(false)
+      expect(useScene.temporal.getState().pastStates).toHaveLength(0)
+      expect(getSceneHistoryPauseDepth()).toBe(1)
+    } finally {
+      resumeSceneHistory(useScene)
+    }
+    expect(useScene.temporal.getState().isTracking).toBe(true)
+  })
+
   test('keeps a hosted item visible through a block topology edit and its undo', () => {
     useScene.temporal.getState().pause()
     const draft = draftNode!