@pascal-app/editor 0.9.1 → 0.9.2

package/src/lib/fresh-planar-placement.test.ts

@@ -1,7 +1,17 @@
 import { beforeEach, describe, expect, test } from 'bun:test'
-import type { AnyNode, AnyNodeId } from '@pascal-app/core'
-import { useScene } from '@pascal-app/core'
-import { commitFreshPlacementSubtree } from './fresh-planar-placement'
+import {
+  type AnyNode,
+  type AnyNodeDefinition,
+  type AnyNodeId,
+  CabinetModuleNode,
+  CabinetNode,
+  findLevelAncestorId,
+  nodeRegistry,
+  registerNode,
+  useScene,
+} from '@pascal-app/core'
+import { z } from 'zod'
+import { commitFreshPlacementSubtree, createFreshPlacementSubtree } from './fresh-planar-placement'
 
 type RafFn = (cb: (time: number) => void) => number
 ;(globalThis as { requestAnimationFrame?: RafFn }).requestAnimationFrame ??= ((
@@ -14,6 +24,61 @@ type RafFn = (cb: (time: number) => void) => number
 
 const LEVEL_ID = 'level_test' as AnyNodeId
 const SHELF_ID = 'shelf_draft' as AnyNodeId
+const CABINET_RUN_ID = 'cabinet_original-run' as AnyNodeId
+const CABINET_LEFT_ID = 'cabinet-module_original-left' as AnyNodeId
+const CABINET_RIGHT_ID = 'cabinet-module_original-right' as AnyNodeId
+const CABINET_CHILD_RUN_ID = 'cabinet_child-run' as AnyNodeId
+const CABINET_CHILD_MODULE_ID = 'cabinet-module_child-module' as AnyNodeId
+
+function registerCabinetClonePrepTestKind() {
+  if (nodeRegistry.has('cabinet')) return
+
+  registerNode({
+    kind: 'cabinet',
+    schemaVersion: 1,
+    schema: z.any() as never,
+    category: 'furnish',
+    defaults: () => ({}),
+    capabilities: {
+      duplicable: {
+        subtree: true,
+        prepareSubtreeClone: ({ root, descendants, rootId, nodes }) => {
+          const parent = root.parentId ? nodes[root.parentId as AnyNodeId] : null
+          if (root.type !== 'cabinet' || parent?.type !== 'cabinet') {
+            return { root, descendants }
+          }
+          const parentPosition = (parent as { position: [number, number, number] }).position
+          const parentRotation = (parent as { rotation: number }).rotation
+          const childPosition = (root as { position: [number, number, number] }).position
+          const childRotation = (root as { rotation: number }).rotation
+          const cos = Math.cos(parentRotation)
+          const sin = Math.sin(parentRotation)
+          const {
+            cabinetCornerDerivedRun: _derived,
+            nodeSelectionProxyId: _proxy,
+            ...metadata
+          } = (root.metadata ?? {}) as Record<string, unknown>
+          return {
+            root: {
+              ...root,
+              parentId: findLevelAncestorId(rootId, nodes),
+              position: [
+                parentPosition[0] + childPosition[0] * cos + childPosition[2] * sin,
+                parentPosition[1] + childPosition[1],
+                parentPosition[2] - childPosition[0] * sin + childPosition[2] * cos,
+              ],
+              rotation: parentRotation + childRotation,
+              metadata,
+            } as AnyNode,
+            descendants,
+            parentId: findLevelAncestorId(rootId, nodes),
+          }
+        },
+      },
+    },
+    renderer: { kind: 'parametric', module: async () => ({ default: () => null }) },
+  } as AnyNodeDefinition)
+}
 
 function level(children: AnyNodeId[]): AnyNode {
   return {
@@ -53,6 +118,42 @@ function shelf(): AnyNode {
   } as AnyNode
 }
 
+function seedCabinetRun() {
+  const run = CabinetNode.parse({
+    id: CABINET_RUN_ID,
+    parentId: LEVEL_ID,
+    position: [0, 0, 0],
+    rotation: 0,
+    children: [CABINET_LEFT_ID, CABINET_RIGHT_ID],
+    showPlinth: true,
+    withCountertop: true,
+  })
+  const left = CabinetModuleNode.parse({
+    id: CABINET_LEFT_ID,
+    parentId: CABINET_RUN_ID,
+    position: [-0.45, 0.1, 0],
+    width: 0.9,
+  })
+  const right = CabinetModuleNode.parse({
+    id: CABINET_RIGHT_ID,
+    parentId: CABINET_RUN_ID,
+    position: [0.45, 0.1, 0],
+    width: 0.9,
+  })
+
+  useScene.setState({
+    nodes: {
+      [LEVEL_ID]: level([CABINET_RUN_ID]),
+      [CABINET_RUN_ID]: run as AnyNode,
+      [CABINET_LEFT_ID]: left as AnyNode,
+      [CABINET_RIGHT_ID]: right as AnyNode,
+    },
+    rootNodeIds: [LEVEL_ID],
+    collections: {},
+    dirtyNodes: new Set(),
+  } as never)
+}
+
 describe('commitFreshPlacementSubtree', () => {
   beforeEach(() => {
     useScene.setState({
@@ -99,4 +200,140 @@ describe('commitFreshPlacementSubtree', () => {
     expect(useScene.getState().nodes[SHELF_ID]).toBeUndefined()
     expect((useScene.getState().nodes[LEVEL_ID] as { children: AnyNodeId[] }).children).toEqual([])
   })
+
+  test('commits a duplicated cabinet draft without deleting the original modules', () => {
+    seedCabinetRun()
+    useScene.temporal.getState().clear()
+    useScene.temporal.getState().pause()
+
+    const draftId = createFreshPlacementSubtree(CABINET_RUN_ID)
+    expect(draftId).toBeTruthy()
+    expect(draftId).not.toBe(CABINET_RUN_ID)
+
+    const draft = useScene.getState().nodes[draftId as AnyNodeId] as
+      | (AnyNode & { children: AnyNodeId[]; metadata?: Record<string, unknown> })
+      | undefined
+    expect(draft?.metadata?.isNew).toBe(true)
+    expect(draft?.children).toHaveLength(2)
+    expect(draft?.children).not.toContain(CABINET_LEFT_ID)
+    expect(draft?.children).not.toContain(CABINET_RIGHT_ID)
+
+    const finalId = commitFreshPlacementSubtree(
+      draftId as AnyNodeId,
+      {
+        position: [2, 0, 3],
+        visible: true,
+      } as Partial<AnyNode>,
+    )
+    expect(finalId).toBeTruthy()
+
+    const nodes = useScene.getState().nodes
+    expect(nodes[CABINET_RUN_ID]).toBeDefined()
+    expect(nodes[CABINET_LEFT_ID]).toBeDefined()
+    expect(nodes[CABINET_RIGHT_ID]).toBeDefined()
+
+    const finalRun = nodes[finalId as AnyNodeId] as
+      | (AnyNode & { children: AnyNodeId[]; metadata?: Record<string, unknown> })
+      | undefined
+    expect(finalRun?.children).toHaveLength(2)
+    expect(finalRun?.metadata?.isNew).toBeUndefined()
+    for (const childId of finalRun?.children ?? []) {
+      const child = nodes[childId]
+      expect(child?.type).toBe('cabinet-module')
+      expect(child?.parentId).toBe(finalId)
+    }
+  })
+
+  test('flattens duplicated nested cabinet runs into level coordinates before dragging', () => {
+    registerCabinetClonePrepTestKind()
+    const parentRun = {
+      id: CABINET_RUN_ID,
+      type: 'cabinet',
+      object: 'node',
+      visible: true,
+      metadata: {},
+      parentId: LEVEL_ID,
+      position: [4, 0, 5],
+      rotation: Math.PI / 2,
+      children: [CABINET_LEFT_ID, CABINET_CHILD_RUN_ID],
+      width: 0.6,
+      depth: 0.58,
+      carcassHeight: 0.72,
+      plinthHeight: 0.1,
+      toeKickDepth: 0.075,
+      boardThickness: 0.018,
+      countertopThickness: 0.02,
+      countertopOverhang: 0.02,
+      countertopBackOverhang: 0,
+      withFinishedBack: false,
+      withWaterfall: false,
+      frontThickness: 0.018,
+      frontGap: 0.003,
+      frontStyle: 'slab',
+      handleStyle: 'bar',
+      handlePosition: 'auto',
+      frontOverlay: 'full',
+      withBottomPanel: true,
+      showPlinth: true,
+      withCountertop: true,
+      operationState: 0,
+      runTier: 'base',
+    } as AnyNode
+    const parentModule = CabinetModuleNode.parse({
+      id: CABINET_LEFT_ID,
+      parentId: CABINET_RUN_ID,
+      position: [0.5, 0.1, 0],
+      width: 1,
+    })
+    const childRun = CabinetNode.parse({
+      id: CABINET_CHILD_RUN_ID,
+      parentId: CABINET_RUN_ID,
+      position: [1, 0, 0.25],
+      rotation: Math.PI / 2,
+      children: [CABINET_CHILD_MODULE_ID],
+      metadata: {
+        cabinetCornerDerivedRun: { role: 'base-leg', side: 'right', sourceRunId: CABINET_RUN_ID },
+        nodeSelectionProxyId: CABINET_RUN_ID,
+      },
+    })
+    const childModule = CabinetModuleNode.parse({
+      id: CABINET_CHILD_MODULE_ID,
+      parentId: CABINET_CHILD_RUN_ID,
+      position: [0, 0.1, 0],
+      width: 0.9,
+    })
+    useScene.setState({
+      nodes: {
+        [LEVEL_ID]: level([CABINET_RUN_ID]),
+        [CABINET_RUN_ID]: parentRun as AnyNode,
+        [CABINET_LEFT_ID]: parentModule as AnyNode,
+        [CABINET_CHILD_RUN_ID]: childRun as AnyNode,
+        [CABINET_CHILD_MODULE_ID]: childModule as AnyNode,
+      },
+      rootNodeIds: [LEVEL_ID],
+      collections: {},
+      dirtyNodes: new Set(),
+    } as never)
+
+    const draftId = createFreshPlacementSubtree(CABINET_CHILD_RUN_ID)
+    const draft = useScene.getState().nodes[draftId as AnyNodeId] as
+      | (AnyNode & {
+          children: AnyNodeId[]
+          metadata?: Record<string, unknown>
+          position: [number, number, number]
+          rotation: number
+        })
+      | undefined
+
+    expect(draft).toBeDefined()
+    expect(draft?.parentId).toBe(LEVEL_ID)
+    expect(draft?.position[0]).toBeCloseTo(4.25)
+    expect(draft?.position[2]).toBeCloseTo(4)
+    expect(draft?.rotation).toBeCloseTo(Math.PI)
+    expect(draft?.metadata?.isNew).toBe(true)
+    expect(draft?.metadata?.cabinetCornerDerivedRun).toBeUndefined()
+    expect(draft?.metadata?.nodeSelectionProxyId).toBeUndefined()
+    expect(draft?.children).toHaveLength(1)
+    expect(draft?.children).not.toContain(CABINET_CHILD_MODULE_ID)
+  })
 })

package/src/lib/fresh-planar-placement.ts

@@ -3,9 +3,11 @@ import {
   type AnyNodeId,
   cloneNodesInto,
   collectSubtree,
+  type DuplicableConfig,
+  nodeRegistry,
   useScene,
 } from '@pascal-app/core'
-import { stripPlacementMetadataFlags } from './placement-metadata'
+import { getPlacementMetadataRecord, stripPlacementMetadataFlags } from './placement-metadata'
 
 function cleanPlacementMetadata<N extends AnyNode>(node: N): N {
   return {
@@ -19,6 +21,71 @@ function parentIdOf(node: AnyNode): AnyNodeId | undefined {
   return parentId ?? undefined
 }
 
+function duplicableConfigFor(node: AnyNode): DuplicableConfig | null {
+  const duplicable = nodeRegistry.get(node.type)?.capabilities?.duplicable
+  return duplicable && typeof duplicable === 'object' ? duplicable : null
+}
+
+export function duplicatesAsFreshSubtree(node: AnyNode): boolean {
+  const children = (node as { children?: unknown }).children
+  return (
+    duplicableConfigFor(node)?.subtree === true && Array.isArray(children) && children.length > 0
+  )
+}
+
+/**
+ * Creates a fresh draft copy of a live subtree, with every child reference
+ * rewired before move mode starts.
+ */
+export function createFreshPlacementSubtree(
+  rootId: AnyNodeId,
+  rootPatch: Partial<AnyNode> = {},
+): AnyNodeId | null {
+  const scene = useScene.getState()
+  const subtree = collectSubtree(scene.nodes, rootId)
+  if (!subtree) return null
+
+  const baseRoot = {
+    ...subtree.root,
+    ...rootPatch,
+  } as AnyNode
+  const prepared = duplicableConfigFor(subtree.root)?.prepareSubtreeClone?.({
+    root: baseRoot,
+    descendants: subtree.descendants,
+    rootId,
+    rootPatch,
+    nodes: scene.nodes,
+  })
+  const preparedRoot = prepared?.root ?? baseRoot
+  const root = {
+    ...preparedRoot,
+    metadata: {
+      ...getPlacementMetadataRecord(stripPlacementMetadataFlags(preparedRoot.metadata)),
+      isNew: true,
+    },
+  } as AnyNode
+  const descendants = (prepared?.descendants ?? subtree.descendants).map((node: AnyNode) => ({
+    ...node,
+    metadata: stripPlacementMetadataFlags(node.metadata),
+  })) as AnyNode[]
+  const parentId =
+    prepared && Object.hasOwn(prepared, 'parentId')
+      ? (prepared.parentId ?? undefined)
+      : parentIdOf(root)
+  const cloned = cloneNodesInto([root, ...descendants], {
+    rootId,
+    parentId,
+  })
+
+  useScene
+    .getState()
+    .createNodes(
+      cloned.nodes.map((node, index) => (index === 0 && parentId ? { node, parentId } : { node })),
+    )
+
+  return cloned.rootId
+}
+
 /**
  * Finalises a fresh catalog/duplicate draft as a single undoable creation.
  *