@pascal-app/editor 0.8.0 → 0.9.2

package/src/lib/scene-clipboard.test.ts

@@ -0,0 +1,196 @@
+import { beforeEach, describe, expect, test } from 'bun:test'
+import {
+  type AnyNode,
+  type AnyNodeId,
+  CabinetModuleNode,
+  type CabinetModuleNode as CabinetModuleNodeType,
+  CabinetNode,
+  type CabinetNode as CabinetNodeType,
+  type LevelNode,
+  MeasurementNode,
+  useScene,
+  WallNode,
+} from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
+import {
+  copySelectedNodesToEditorClipboard,
+  getEditorClipboardSnapshot,
+  pasteEditorClipboardToLevel,
+} from './scene-clipboard'
+
+const sourceLevelId = 'level_clipboard-source' as LevelNode['id']
+const targetLevelId = 'level_clipboard-target' as LevelNode['id']
+const runId = 'cabinet_clipboard-run' as CabinetNodeType['id']
+const leftModuleId = 'cabinet-module_clipboard-left' as CabinetModuleNodeType['id']
+const rightModuleId = 'cabinet-module_clipboard-right' as CabinetModuleNodeType['id']
+
+function makeLevel(id: AnyNodeId, children: AnyNodeId[] = []): AnyNode {
+  return {
+    id,
+    type: 'level',
+    object: 'node',
+    visible: true,
+    name: '',
+    metadata: {},
+    position: [0, 0, 0],
+    rotation: 0,
+    parentId: null,
+    level: 0,
+    children,
+  } as unknown as AnyNode
+}
+
+function seedCabinetRun() {
+  const sourceLevel = makeLevel(sourceLevelId, [runId])
+  const targetLevel = makeLevel(targetLevelId)
+  const run = CabinetNode.parse({
+    id: runId,
+    parentId: sourceLevelId,
+    position: [1, 0, 2],
+    rotation: 0,
+    children: [leftModuleId, rightModuleId],
+    withCountertop: true,
+    showPlinth: true,
+  })
+  const leftModule = CabinetModuleNode.parse({
+    id: leftModuleId,
+    parentId: runId,
+    position: [-0.45, 0.1, 0],
+    width: 0.9,
+    showPlinth: false,
+    withCountertop: false,
+  })
+  const rightModule = CabinetModuleNode.parse({
+    id: rightModuleId,
+    parentId: runId,
+    position: [0.45, 0.1, 0],
+    width: 0.9,
+    showPlinth: false,
+    withCountertop: false,
+  })
+
+  useScene.setState({
+    nodes: {
+      [sourceLevel.id]: sourceLevel,
+      [targetLevel.id]: targetLevel,
+      [run.id]: run as AnyNode,
+      [leftModule.id]: leftModule as AnyNode,
+      [rightModule.id]: rightModule as AnyNode,
+    },
+    rootNodeIds: [sourceLevel.id, targetLevel.id],
+  } as never)
+  useViewer.getState().setSelection({
+    levelId: sourceLevelId,
+    selectedIds: [],
+  })
+}
+
+function isPastedCabinetRun(node: AnyNode): node is CabinetNodeType {
+  return node.type === 'cabinet' && node.id !== runId
+}
+
+function pastedCabinetRun() {
+  return Object.values(useScene.getState().nodes).find(isPastedCabinetRun)
+}
+
+describe('scene clipboard', () => {
+  beforeEach(() => {
+    seedCabinetRun()
+    useScene.temporal.getState().clear()
+  })
+
+  test('copies a selected cabinet run as one subtree instead of independent modules', () => {
+    const copied = copySelectedNodesToEditorClipboard([runId, leftModuleId, rightModuleId])
+
+    expect(copied).toBe(true)
+    expect(getEditorClipboardSnapshot()?.rootIds).toEqual([runId])
+
+    const result = pasteEditorClipboardToLevel(targetLevelId)
+    expect(result?.pastedIds).toHaveLength(1)
+
+    const pastedRun = pastedCabinetRun()
+    expect(pastedRun).toBeDefined()
+    expect(pastedRun?.parentId).toBe(targetLevelId)
+    expect(pastedRun?.children).toHaveLength(2)
+
+    for (const childId of pastedRun?.children ?? []) {
+      const child = useScene.getState().nodes[childId as AnyNodeId]
+      expect(child?.type).toBe('cabinet-module')
+      expect(child?.parentId).toBe(pastedRun?.id)
+    }
+
+    const sourceRun = useScene.getState().nodes[runId]
+    expect(sourceRun?.type).toBe('cabinet')
+    expect((sourceRun as CabinetNodeType | undefined)?.children).toEqual([
+      leftModuleId,
+      rightModuleId,
+    ] satisfies CabinetModuleNodeType['id'][])
+  })
+
+  test('promotes a complete module selection to the cabinet run before copying', () => {
+    const copied = copySelectedNodesToEditorClipboard([leftModuleId, rightModuleId])
+
+    expect(copied).toBe(true)
+    expect(getEditorClipboardSnapshot()?.rootIds).toEqual([runId])
+
+    const result = pasteEditorClipboardToLevel(targetLevelId)
+    expect(result?.pastedIds).toHaveLength(1)
+    expect(pastedCabinetRun()?.children).toHaveLength(2)
+  })
+
+  test('remaps a measurement association when its host is copied with it', () => {
+    const wall = WallNode.parse({
+      id: 'wall_clipboard-host',
+      type: 'wall',
+      parentId: sourceLevelId,
+      start: [0, 0],
+      end: [3, 0],
+    })
+    const measurement = MeasurementNode.parse({
+      id: 'measurement_clipboard-associated',
+      type: 'measurement',
+      parentId: sourceLevelId,
+      measurement: {
+        kind: 'distance',
+        points: [
+          {
+            kind: 'feature',
+            reference: { nodeId: wall.id, featureId: 'wall:face:left', parameters: { t: 0 } },
+            fallback: [0, 0, 0],
+          },
+          [3, 0, 0],
+        ],
+      },
+    })
+    useScene.setState((state) => ({
+      nodes: {
+        ...state.nodes,
+        [sourceLevelId]: makeLevel(sourceLevelId, [wall.id, measurement.id]),
+        [wall.id]: wall,
+        [measurement.id]: measurement,
+      },
+    }))
+
+    expect(copySelectedNodesToEditorClipboard([wall.id, measurement.id])).toBe(true)
+    expect(pasteEditorClipboardToLevel(targetLevelId)?.pastedIds).toHaveLength(2)
+
+    const pastedWall = Object.values(useScene.getState().nodes).find(
+      (node) => node.type === 'wall' && node.id !== wall.id,
+    )
+    const pastedMeasurement = Object.values(useScene.getState().nodes).find(
+      (node) => node.type === 'measurement' && node.id !== measurement.id,
+    )
+    expect(pastedWall?.type).toBe('wall')
+    expect(pastedMeasurement?.type).toBe('measurement')
+    if (
+      pastedWall?.type !== 'wall' ||
+      pastedMeasurement?.type !== 'measurement' ||
+      pastedMeasurement.measurement.kind !== 'distance'
+    ) {
+      return
+    }
+    const anchor = pastedMeasurement.measurement.points[0]
+    expect(Array.isArray(anchor)).toBe(false)
+    if (!Array.isArray(anchor)) expect(anchor.reference.nodeId).toBe(pastedWall.id)
+  })
+})

package/src/lib/scene-clipboard.ts

@@ -0,0 +1,332 @@
+import {
+  AnyNode,
+  type AnyNodeId,
+  generateId,
+  type LevelNode,
+  remapMeasurementReferences,
+  type StairNode,
+  useScene,
+} from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
+
+type ClipboardPayload = {
+  copiedAt: number
+  nodes: AnyNode[]
+  rootIds: AnyNodeId[]
+}
+
+type PasteResult = {
+  pastedIds: AnyNodeId[]
+  skippedIds: AnyNodeId[]
+}
+
+const COPYABLE_ROOT_TYPES = new Set<AnyNode['type']>([
+  'wall',
+  'fence',
+  'column',
+  'item',
+  'slab',
+  'ceiling',
+  'roof',
+  'stair',
+  'spawn',
+  'zone',
+  'cabinet',
+  'cabinet-module',
+  'measurement',
+])
+
+let clipboardPayload: ClipboardPayload | null = null
+const subscribers = new Set<() => void>()
+
+function notifySubscribers() {
+  for (const subscriber of subscribers) {
+    subscriber()
+  }
+}
+
+export function subscribeEditorClipboard(subscriber: () => void) {
+  subscribers.add(subscriber)
+  return () => {
+    subscribers.delete(subscriber)
+  }
+}
+
+export function getEditorClipboardSnapshot() {
+  return clipboardPayload
+}
+
+export function hasEditorClipboard() {
+  return !!clipboardPayload && clipboardPayload.rootIds.length > 0
+}
+
+function extractIdPrefix(id: string) {
+  const underscoreIndex = id.indexOf('_')
+  return underscoreIndex === -1 ? 'node' : id.slice(0, underscoreIndex)
+}
+
+function collectSubtreeIds(
+  nodes: Record<AnyNodeId, AnyNode>,
+  rootId: AnyNodeId,
+  ids: Set<AnyNodeId>,
+) {
+  if (ids.has(rootId)) return
+  const node = nodes[rootId]
+  if (!node) return
+  ids.add(rootId)
+
+  if ('children' in node && Array.isArray(node.children)) {
+    for (const childId of node.children as AnyNodeId[]) {
+      collectSubtreeIds(nodes, childId, ids)
+    }
+  }
+}
+
+function hasSelectedAncestor(
+  nodes: Record<AnyNodeId, AnyNode>,
+  id: AnyNodeId,
+  selectedIds: Set<AnyNodeId>,
+) {
+  let parentId = nodes[id]?.parentId as AnyNodeId | null
+
+  while (parentId) {
+    if (selectedIds.has(parentId)) return true
+    parentId = nodes[parentId]?.parentId as AnyNodeId | null
+  }
+
+  return false
+}
+
+function isLevelChildRoot(nodes: Record<AnyNodeId, AnyNode>, node: AnyNode) {
+  const parentId = node.parentId as AnyNodeId | null
+  if (!parentId) return true
+  return nodes[parentId]?.type === 'level'
+}
+
+function getPromotedCabinetRunId(
+  nodes: Record<AnyNodeId, AnyNode>,
+  node: AnyNode,
+  selectedIds: Set<AnyNodeId>,
+) {
+  if (node.type !== 'cabinet-module') return null
+
+  const parentId = node.parentId as AnyNodeId | null
+  const parent = parentId ? nodes[parentId] : null
+  if (parent?.type !== 'cabinet') return null
+  if (!parentId) return null
+  if (selectedIds.has(parentId)) return parentId
+
+  const siblingIds = Array.isArray(parent.children) ? (parent.children as AnyNodeId[]) : []
+  const hasOnlySelectedModules =
+    siblingIds.length > 0 &&
+    siblingIds.every((childId) => {
+      const child = nodes[childId]
+      return child?.type === 'cabinet-module' && selectedIds.has(childId)
+    })
+
+  return hasOnlySelectedModules ? parentId : null
+}
+
+function getPasteTargetLevel(targetLevelId?: AnyNodeId) {
+  const scene = useScene.getState()
+  const resolvedLevelId =
+    targetLevelId ?? (useViewer.getState().selection.levelId as AnyNodeId | null)
+  if (!resolvedLevelId) return null
+
+  const level = scene.nodes[resolvedLevelId]
+  return level?.type === 'level' ? level : null
+}
+
+function getNextLevelId(level: LevelNode, nodes: Record<AnyNodeId, AnyNode>) {
+  const parentId = level.parentId as AnyNodeId | null
+  if (!parentId) return null
+
+  const building = nodes[parentId]
+  if (building?.type !== 'building') return null
+
+  const siblingLevels = building.children
+    .map((childId) => nodes[childId as AnyNodeId])
+    .filter((node): node is LevelNode => node?.type === 'level')
+
+  return (
+    siblingLevels
+      .filter((candidate) => candidate.level > level.level)
+      .sort((a, b) => a.level - b.level)[0]?.id ?? null
+  )
+}
+
+function remapNodeReferences(
+  node: AnyNode,
+  oldId: AnyNodeId,
+  targetLevel: LevelNode,
+  idMap: Map<AnyNodeId, AnyNodeId>,
+  rootIds: Set<AnyNodeId>,
+  nodes: Record<AnyNodeId, AnyNode>,
+) {
+  const clone = JSON.parse(JSON.stringify(node)) as AnyNode
+  ;(clone as Record<string, unknown>).id = idMap.get(oldId)
+
+  if (rootIds.has(oldId)) {
+    clone.parentId = targetLevel.id
+  } else if (clone.parentId && typeof clone.parentId === 'string') {
+    clone.parentId = idMap.get(clone.parentId as AnyNodeId) ?? clone.parentId
+  }
+
+  if ('children' in clone && Array.isArray(clone.children)) {
+    ;(clone as Record<string, unknown>).children = (clone.children as AnyNodeId[])
+      .map((childId) => idMap.get(childId))
+      .filter((childId): childId is AnyNodeId => !!childId)
+  }
+
+  if ('wallId' in clone && typeof clone.wallId === 'string') {
+    const nextWallId = idMap.get(clone.wallId as AnyNodeId)
+    if (nextWallId) {
+      ;(clone as Record<string, unknown>).wallId = nextWallId
+    } else {
+      delete (clone as Record<string, unknown>).wallId
+    }
+  }
+
+  if (clone.type === 'stair') {
+    const nextLevelId = getNextLevelId(targetLevel, nodes)
+    ;(clone as StairNode).fromLevelId = targetLevel.id
+    ;(clone as StairNode).toLevelId = nextLevelId
+  }
+
+  if (clone.type === 'measurement') {
+    clone.measurement = remapMeasurementReferences(clone.measurement, idMap)
+  }
+
+  const metadata =
+    clone.metadata && typeof clone.metadata === 'object' && !Array.isArray(clone.metadata)
+      ? { ...(clone.metadata as Record<string, unknown>) }
+      : {}
+  delete metadata.isNew
+  delete metadata.isTransient
+  ;(clone as Record<string, unknown>).metadata = metadata
+
+  return AnyNode.parse(clone)
+}
+
+function buildClipboardPayload(ids: AnyNodeId[]): ClipboardPayload | null {
+  const scene = useScene.getState()
+  const selectedIdSet = new Set(ids)
+  const promotedIds = ids.map((id) => {
+    const node = scene.nodes[id]
+    return node ? (getPromotedCabinetRunId(scene.nodes, node, selectedIdSet) ?? id) : id
+  })
+  const rootIds = Array.from(new Set(promotedIds)).filter((id) => {
+    const node = scene.nodes[id]
+    return (
+      node &&
+      COPYABLE_ROOT_TYPES.has(node.type) &&
+      isLevelChildRoot(scene.nodes, node) &&
+      !hasSelectedAncestor(scene.nodes, id, selectedIdSet)
+    )
+  })
+
+  if (rootIds.length === 0) {
+    return null
+  }
+
+  const subtreeIds = new Set<AnyNodeId>()
+  for (const rootId of rootIds) {
+    collectSubtreeIds(scene.nodes, rootId, subtreeIds)
+  }
+
+  return {
+    copiedAt: Date.now(),
+    nodes: [...subtreeIds]
+      .map((id) => scene.nodes[id])
+      .filter((node): node is AnyNode => !!node)
+      .map((node) => JSON.parse(JSON.stringify(node)) as AnyNode),
+    rootIds,
+  }
+}
+
+export function copySelectedNodesToEditorClipboard(selectedIds?: AnyNodeId[]) {
+  const ids = selectedIds ?? (useViewer.getState().selection.selectedIds as AnyNodeId[])
+  const payload = buildClipboardPayload(ids)
+  if (!payload) return false
+
+  clipboardPayload = payload
+  notifySubscribers()
+
+  return true
+}
+
+/**
+ * Clone the given nodes (subtrees included, ids remapped) onto the target /
+ * active level in place — the same copy + paste pipeline in one step, WITHOUT
+ * touching the user's editor clipboard. Selects the clones. Used by the group
+ * action menu's Duplicate.
+ */
+export function duplicateNodesToLevel(
+  ids: AnyNodeId[],
+  targetLevelId?: AnyNodeId,
+): PasteResult | null {
+  const payload = buildClipboardPayload(ids)
+  if (!payload) return null
+  return applyClipboardPayloadToLevel(payload, targetLevelId)
+}
+
+export function pasteEditorClipboardToLevel(targetLevelId?: AnyNodeId): PasteResult | null {
+  if (!clipboardPayload) return null
+  return applyClipboardPayloadToLevel(clipboardPayload, targetLevelId)
+}
+
+function applyClipboardPayloadToLevel(
+  payload: ClipboardPayload,
+  targetLevelId?: AnyNodeId,
+): PasteResult | null {
+  const targetLevel = getPasteTargetLevel(targetLevelId)
+  if (!targetLevel) return null
+
+  const scene = useScene.getState()
+  const idMap = new Map<AnyNodeId, AnyNodeId>()
+
+  for (const node of payload.nodes) {
+    idMap.set(node.id as AnyNodeId, generateId(extractIdPrefix(node.id)) as AnyNodeId)
+  }
+
+  const rootIdSet = new Set(payload.rootIds)
+  const pastedNodes: AnyNode[] = []
+  const skippedIds: AnyNodeId[] = []
+
+  for (const node of payload.nodes) {
+    try {
+      pastedNodes.push(
+        remapNodeReferences(node, node.id as AnyNodeId, targetLevel, idMap, rootIdSet, scene.nodes),
+      )
+    } catch (error) {
+      console.error('Failed to paste copied node', node.id, error)
+      skippedIds.push(node.id as AnyNodeId)
+    }
+  }
+
+  if (pastedNodes.length === 0) {
+    return { pastedIds: [], skippedIds }
+  }
+
+  scene.createNodes(
+    pastedNodes.map((node) => ({
+      node,
+      parentId: (node.parentId as AnyNodeId | null) ?? undefined,
+    })),
+  )
+
+  const pastedNodeIds = new Set(pastedNodes.map((node) => node.id as AnyNodeId))
+  const pastedRootIds = payload.rootIds
+    .map((rootId) => idMap.get(rootId))
+    .filter((id): id is AnyNodeId => !!id && pastedNodeIds.has(id))
+
+  useViewer.getState().setSelection({
+    levelId: targetLevel.id,
+    selectedIds: pastedRootIds,
+  })
+
+  return {
+    pastedIds: pastedRootIds,
+    skippedIds,
+  }
+}

package/src/lib/scene.ts

@@ -1,16 +1,28 @@
 'use client'
 
-import { resolveLevelId, sceneRegistry, useScene } from '@pascal-app/core'
+import {
+  clearSceneHistory,
+  nodeRegistry,
+  resolveLevelId,
+  sceneRegistry,
+  useScene,
+} from '@pascal-app/core'
 import { useViewer } from '@pascal-app/viewer'
 import useEditor, {
   hasCustomPersistedEditorUiState,
   normalizePersistedEditorUiState,
   type PersistedEditorUiState,
 } from '../store/use-editor'
+import { editorHostPanelRegistry } from './plugin-panels'
 
 export type SceneGraph = {
   nodes: Record<string, unknown>
   rootNodeIds: string[]
+  // Document-level scene state that travels with the graph. Optional so older
+  // payloads (and callers that only build nodes) stay valid.
+  collections?: Record<string, unknown>
+  materials?: Record<string, unknown>
+  installedPlugins?: string[]
 }
 
 type PersistedSelectionPath = {
@@ -220,7 +232,11 @@ function getValidatedSelectionForScene(
 
     const selectedIds = selection.selectedIds.filter((id) => {
       const node = sceneNodes[id]
-      return Boolean(node) && resolveLevelId(node, sceneNodes) === levelId
+      if (!node) return false
+      if (resolveLevelId(node, sceneNodes) === levelId) return true
+
+      const def = nodeRegistry.get(node.type)
+      return def?.floorplanScope === 'building' && node.parentId === buildingId
     })
 
     return {
@@ -283,7 +299,11 @@ export function syncEditorSelectionFromCurrentScene() {
 
     if (shouldRestoreEditorUiState) {
       if (restoredSelection) {
-        useViewer.getState().setSelection(restoredSelection)
+        // PersistedSelectionPath carries plain `string` ids (read from
+        // localStorage, no branded-template-literal guarantee). The viewer's
+        // SelectionPath expects branded ids. The runtime values match the
+        // brand; the cast bridges the static gap.
+        useViewer.getState().setSelection(restoredSelection as never)
         useEditor.setState(
           restoredEditorUiState.phase === 'site'
             ? (selectionDrivenEditorUiState ?? restoredEditorUiState)
@@ -305,7 +325,7 @@ export function syncEditorSelectionFromCurrentScene() {
     }
 
     if (restoredSelection) {
-      useViewer.getState().setSelection(restoredSelection)
+      useViewer.getState().setSelection(restoredSelection as never)
       if (selectionDrivenEditorUiState) {
         useEditor.setState(selectionDrivenEditorUiState)
       }
@@ -347,10 +367,9 @@ function resetEditorInteractionState() {
     structureLayer: 'elements',
     catalogCategory: null,
     selectedItem: null,
-    movingNode: null,
     selectedReferenceId: null,
     spaces: {},
-    editingHole: null,
+    hoveredHole: null,
     isPreviewMode: false,
   })
 }
@@ -364,13 +383,26 @@ function hasUsableSceneGraph(sceneGraph?: SceneGraph | null): sceneGraph is Scen
 }
 
 export function applySceneGraphToEditor(sceneGraph?: SceneGraph | null) {
+  const defaultInstalledPlugins = editorHostPanelRegistry.getDefaultInstalledPluginIds()
   if (hasUsableSceneGraph(sceneGraph)) {
-    const { nodes, rootNodeIds } = sceneGraph
-    useScene.getState().setScene(nodes as any, rootNodeIds as any)
+    const { nodes, rootNodeIds, collections, materials, installedPlugins } = sceneGraph
+    useScene.getState().setScene(nodes as any, rootNodeIds as any, {
+      collections: collections as any,
+      materials: materials as any,
+      installedPlugins: installedPlugins ?? defaultInstalledPlugins,
+      hasExplicitPluginInstallState: installedPlugins !== undefined,
+    })
   } else {
     useScene.getState().clearScene()
+    useScene.getState().setInstalledPlugins(defaultInstalledPlugins, { explicit: false })
   }
 
+  // The loaded scene is the undo floor. Loading records history entries of
+  // its own (`unloadScene` + `setScene`/`clearScene` are tracked writes), so
+  // without this reset a few Ctrl+Z presses could step past the load into the
+  // pre-load — often empty — state and wipe the whole project.
+  clearSceneHistory()
+
   syncEditorSelectionFromCurrentScene()
 }