@pascal-app/editor 1.0.3 → 1.0.4

package/src/lib/level-duplication.ts

@@ -1,195 +0,0 @@
-import { cloneLevelSubtree } from '@pascal-app/core/clone-scene-graph'
-import { type AnyNode, type AnyNodeId, type LevelNode, UnitNode } from '@pascal-app/core/schema'
-
-export type LevelDuplicatePreset =
-  | 'everything'
-  | 'structure'
-  | 'structure-materials'
-  | 'structure-furniture'
-
-const NON_DUPLICABLE_NODE_TYPES = new Set<AnyNode['type']>(['scan', 'guide', 'spawn'])
-const STRUCTURAL_NODE_TYPES = new Set<AnyNode['type']>([
-  'level',
-  'wall',
-  'fence',
-  'zone',
-  'slab',
-  'ceiling',
-  'roof',
-  'roof-segment',
-  'stair',
-  'stair-segment',
-  'window',
-  'door',
-])
-
-function shouldKeepNode(node: AnyNode, preset: LevelDuplicatePreset) {
-  if (NON_DUPLICABLE_NODE_TYPES.has(node.type)) return false
-  if (preset === 'everything') return true
-  if (preset === 'structure-furniture') return true
-  if (preset === 'structure' || preset === 'structure-materials') {
-    return STRUCTURAL_NODE_TYPES.has(node.type)
-  }
-  return true
-}
-
-/**
- * Material field keys per kind, used by the `structure` duplicate preset
- * to strip materials from the cloned subtree. Lookup table replaces the
- * legacy per-kind switch — the Phase 6 grep gate flagged `case '<kind>':`
- * in this file as the remaining per-kind dispatch outside the registry.
- *
- * Future: move this to a `capabilities.materialFields` declaration on
- * each kind's `NodeDefinition` so adding a new kind with materials is a
- * registry-only edit. Today the registry doesn't surface material fields
- * in a uniform way (each kind's panel reads / writes them directly), so
- * this map mirrors the legacy behavior 1:1.
- */
-const MATERIAL_FIELDS_BY_KIND: Record<string, ReadonlyArray<string>> = {
-  wall: [
-    'material',
-    'materialPreset',
-    'interiorMaterial',
-    'interiorMaterialPreset',
-    'exteriorMaterial',
-    'exteriorMaterialPreset',
-  ],
-  slab: ['material', 'materialPreset'],
-  ceiling: ['material', 'materialPreset'],
-  fence: ['material', 'materialPreset'],
-  shelf: ['material', 'materialPreset'],
-  'roof-segment': ['material', 'materialPreset'],
-  'stair-segment': ['material', 'materialPreset'],
-  window: ['material', 'materialPreset'],
-  door: ['material', 'materialPreset'],
-  roof: [
-    'material',
-    'materialPreset',
-    'topMaterial',
-    'topMaterialPreset',
-    'edgeMaterial',
-    'edgeMaterialPreset',
-    'wallMaterial',
-    'wallMaterialPreset',
-  ],
-  stair: [
-    'material',
-    'materialPreset',
-    'railingMaterial',
-    'railingMaterialPreset',
-    'treadMaterial',
-    'treadMaterialPreset',
-    'sideMaterial',
-    'sideMaterialPreset',
-  ],
-}
-
-function stripMaterials(node: AnyNode): AnyNode {
-  const fields = MATERIAL_FIELDS_BY_KIND[node.type]
-  if (!fields) return node
-  const next = { ...node } as Record<string, unknown>
-  for (const field of fields) delete next[field]
-  return next as AnyNode
-}
-
-function findLevelBuildingId(nodes: Record<AnyNodeId, AnyNode>, levelId: AnyNodeId) {
-  for (const node of Object.values(nodes)) {
-    if (node.type !== 'building' || !('children' in node) || !Array.isArray(node.children)) {
-      continue
-    }
-
-    if ((node.children as AnyNodeId[]).includes(levelId)) {
-      return node.id as AnyNodeId
-    }
-  }
-
-  return undefined
-}
-
-export function buildLevelDuplicateCreateOps({
-  nodes,
-  level,
-  levels,
-  preset,
-}: {
-  nodes: Record<AnyNodeId, AnyNode>
-  level: LevelNode
-  levels: LevelNode[]
-  preset: LevelDuplicatePreset
-}) {
-  const { clonedNodes, newLevelId, idMap } = cloneLevelSubtree(nodes, level.id)
-  const parentBuildingId =
-    (level.parentId as AnyNodeId | null) ?? findLevelBuildingId(nodes, level.id)
-  const nextLevelNumber = level.level + 1
-  const shiftedLevels = levels
-    .filter((entry) => entry.id !== level.id && entry.level >= nextLevelNumber)
-    .map((entry) => ({
-      id: entry.id,
-      level: entry.level + 1,
-    }))
-
-  const filteredNodes = clonedNodes
-    .filter((node) => shouldKeepNode(node, preset))
-    .map((node) => (preset === 'structure' ? stripMaterials(node) : node))
-
-  const keptIds = new Set(filteredNodes.map((node) => node.id))
-
-  const cleanedNodes = filteredNodes.map((node) => {
-    if (!('children' in node && Array.isArray(node.children))) {
-      return node
-    }
-
-    return {
-      ...node,
-      children: node.children.filter((childId) => keptIds.has(childId as AnyNodeId)),
-    } as AnyNode
-  })
-
-  if (parentBuildingId && nodes[parentBuildingId]?.type === 'building') {
-    for (const unit of Object.values(nodes)) {
-      if (
-        unit.type !== 'unit' ||
-        unit.parentId !== parentBuildingId ||
-        unit.members.length === 0 ||
-        !unit.members.every((id) => {
-          const zone = nodes[id]
-          const remapped = idMap.get(id)
-          return (
-            zone?.type === 'zone' &&
-            zone.parentId === level.id &&
-            remapped !== undefined &&
-            keptIds.has(remapped as AnyNodeId)
-          )
-        })
-      )
-        continue
-      cleanedNodes.push(
-        UnitNode.parse({
-          ...unit,
-          id: undefined,
-          parentId: parentBuildingId,
-          name: `${unit.name} copy`,
-          members: unit.members.map((id) => idMap.get(id)),
-        }),
-      )
-    }
-  }
-
-  return {
-    createOps: cleanedNodes.map((node) => ({
-      node:
-        node.id === newLevelId
-          ? ({
-              ...node,
-              level: nextLevelNumber,
-            } as AnyNode)
-          : node,
-      parentId:
-        node.id === newLevelId
-          ? parentBuildingId
-          : ((node.parentId as AnyNodeId | null) ?? undefined),
-    })),
-    newLevelId,
-    shiftedLevels,
-  }
-}