@pascal-app/editor 1.0.3 → 1.0.5

package/src/components/editor/delete-confirmation-dialog.tsx

@@ -1,7 +1,17 @@
 'use client'
 
-import { useEffect } from 'react'
-import useDeleteConfirmation from '../../store/use-delete-confirmation'
+import {
+  type AnyNode,
+  type DeleteZonePayload,
+  type StructureNodes,
+  useScene,
+} from '@pascal-app/core'
+import { useEffect, useMemo, useRef } from 'react'
+import { cn } from '../../lib/utils'
+import useDeleteConfirmation, {
+  type DeleteConfirmationRequest,
+  type RoomConstructionChange,
+} from '../../store/use-delete-confirmation'
 import {
   Dialog,
   DialogContent,
@@ -11,10 +21,268 @@ import {
   DialogTitle,
 } from '../ui/primitives/dialog'
 
+const count = (n: number, one: string, many = `${one}s`) => `${n} ${n === 1 ? one : many}`
+
+function sentenceList(parts: string[]) {
+  if (parts.length <= 1) return parts.join('')
+  return `${parts.slice(0, -1).join(', ')} and ${parts.at(-1)}`
+}
+
+/**
+ * A mezzanine takes its own plate (with its railing) and the ceiling core
+ * derived over it; kept items come down to the floor below.
+ */
+function mezzanineDeletionDescription(room: DeleteZonePayload, nodes: StructureNodes) {
+  const hasCeiling = Object.values(nodes).some(
+    (node) => node.type === 'ceiling' && node.zoneId === room.zoneId,
+  )
+  const sentences = [
+    hasCeiling
+      ? 'Removes the mezzanine floor, its railing and the ceiling over it.'
+      : 'Removes the mezzanine floor and its railing.',
+  ]
+  const items = room.itemIds.length
+  if (items)
+    sentences.push(
+      `${count(items, 'item')} ${items === 1 ? 'is' : 'are'} on it. Keep ${items === 1 ? 'it' : 'them'} on the floor below, or delete ${items === 1 ? 'it' : 'them'} too.`,
+    )
+  return sentences.join(' ')
+}
+
+/**
+ * An area Divide made goes back into the room across its dividing line: the
+ * line and the area's own finish go, the walls and anything standing in it stay.
+ */
+function mergeDescription(room: DeleteZonePayload, nodes: StructureNodes) {
+  const into = nodes[room.mergedIntoZoneId ?? '']?.name?.trim()
+  const lines = room.separatorIds.length === 1 ? 'dividing line' : 'dividing lines'
+  const sentences = [
+    `Merges it back into ${into || 'the room next to it'}: removes the ${lines} and its floor finish. The walls stay.`,
+  ]
+  const items = room.itemIds.length
+  if (items)
+    sentences.push(
+      `${count(items, 'item')} inside ${items === 1 ? 'stays where it is' : 'stay where they are'}.`,
+    )
+  return sentences.join(' ')
+}
+
+function roomDeletionDescription(room: DeleteZonePayload, nodes: StructureNodes) {
+  if (isMezzanine(room, nodes)) return mezzanineDeletionDescription(room, nodes)
+  if (room.mode === 'merge') return mergeDescription(room, nodes)
+  const sentences: string[] = []
+  const typeCount = (type: string) =>
+    room.openingIds.filter((id) => nodes[id]?.type === type).length
+  const removed = [
+    room.wallIds.length ? count(room.wallIds.length, 'wall') : '',
+    room.separatorIds.length ? count(room.separatorIds.length, 'separator') : '',
+    typeCount('door') ? count(typeCount('door'), 'door') : '',
+    typeCount('window') ? count(typeCount('window'), 'window') : '',
+  ].filter(Boolean)
+  sentences.push(
+    removed.length
+      ? `Removes ${sentenceList(removed)}, with the floor finish and ceiling.`
+      : 'Removes the floor finish and ceiling.',
+  )
+  if (room.keptSharedWallIds.length + room.keptSharedSeparatorIds.length > 0)
+    sentences.push('Walls shared with other rooms stay.')
+  if (room.opensZoneIds.length) {
+    const names = room.opensZoneIds.map((id) => nodes[id]?.name?.trim() || 'the next room')
+    sentences.push(`Opens into ${sentenceList(names)}.`)
+  }
+  const items = room.itemIds.length
+  if (items)
+    sentences.push(
+      `${count(items, 'item')} ${items === 1 ? 'is' : 'are'} inside. Keep ${items === 1 ? 'it' : 'them'} where ${items === 1 ? 'it is' : 'they are'}, or delete ${items === 1 ? 'it' : 'them'} too.`,
+    )
+  return sentences.join(' ')
+}
+
+/** A hosted node's kind from its type and structure — never from its name. */
+function hostedKind(node: AnyNode | undefined) {
+  if (node?.type === 'door' || node?.type === 'window') return node.type
+  if (node?.type === 'item' && node.asset.interactive?.effects.some((e) => e.kind === 'light'))
+    return 'light'
+  return 'item'
+}
+
+function hostedName(node: AnyNode | undefined) {
+  return (node?.name || (node?.type === 'item' ? node.asset.name : '') || '').trim()
+}
+
+function shownNames(names: string[]) {
+  const named = [...new Set(names.filter(Boolean))]
+  return named.slice(0, 3).join(', ') + (named.length > 3 ? ', …' : '')
+}
+
+/** "1 door (Front door), 2 windows and 1 light": counts per kind, a few names, no ids. */
+export function hostedSummary(ids: readonly string[], nodes: StructureNodes) {
+  const groups = new Map<string, string[]>()
+  for (const id of ids) {
+    const kind = hostedKind(nodes[id])
+    groups.set(kind, [...(groups.get(kind) ?? []), hostedName(nodes[id])])
+  }
+  return sentenceList(
+    [...groups].map(([kind, names]) => {
+      const shown = shownNames(names)
+      return `${count(names.length, kind)}${shown ? ` (${shown})` : ''}`
+    }),
+  )
+}
+
+const pronouns = (one: boolean) =>
+  one
+    ? { it: 'it', is: 'is', its: 'its', verb: (v: string) => `${v}s` }
+    : { it: 'them', is: 'are', its: 'their', verb: (v: string) => v }
+
+function ceilingContent(
+  change: RoomConstructionChange,
+  nodes: StructureNodes,
+  room: string,
+  canKeep: boolean,
+): DeleteConfirmationContent {
+  const ids = change.hostedIds
+  const p = pronouns(ids.length === 1)
+  const manual = change.manualCeilings ?? []
+  const sentences: string[] = []
+  if (manual.length) {
+    const names = shownNames(manual)
+    sentences.push(
+      manual.length === 1
+        ? `Removes the hand-drawn ceiling${names ? ` (${names})` : ''}.`
+        : `Removes ${manual.length} hand-drawn ceilings${names ? ` (${names})` : ''}.`,
+    )
+    if (change.alsoCovers?.length)
+      sentences.push(
+        `${manual.length === 1 ? 'It also covers' : 'They also cover'} ${sentenceList(change.alsoCovers)}.`,
+      )
+  }
+  // Lights are known from their light effect; anything else reads as an item.
+  const lights = ids.length > 0 && ids.every((id) => hostedKind(nodes[id]) === 'light')
+  if (ids.length) {
+    const names = shownNames(ids.map((id) => hostedName(nodes[id])))
+    sentences.push(
+      lights
+        ? `${hostedSummary(ids, nodes)} ${p.verb('hang')} from it.`
+        : `${count(ids.length, 'item')} ${p.is} on the ceiling${names ? ` (${names})` : ''}.`,
+      `Keep ${p.it} in place, or delete ${p.it} too.`,
+    )
+  }
+  return {
+    title: `Remove the ceiling from ${room}?`,
+    description: sentences.length ? sentences.join(' ') : 'Removes the ceiling.',
+    keepLabel: ids.length && canKeep ? (lights ? 'Keep lights' : 'Keep items') : null,
+    confirmLabel: ids.length ? 'Remove all' : 'Remove',
+    destructive: true,
+  }
+}
+
+function constructionContent(
+  change: RoomConstructionChange,
+  nodes: StructureNodes,
+  canKeep: boolean,
+): DeleteConfirmationContent {
+  const room = change.roomName.trim() || 'this room'
+  const hosted = hostedSummary(change.hostedIds, nodes)
+  const p = pronouns(change.hostedIds.length === 1)
+  if (change.part === 'walls' && change.action === 'add') {
+    return {
+      title: `Add walls to ${room}?`,
+      description: `Adds ${count(change.wallCount ?? 0, 'wall')} · the room loses ${(change.areaLoss ?? 0).toFixed(2)} m² of floor.`,
+      keepLabel: null,
+      confirmLabel: 'Add walls',
+      destructive: false,
+    }
+  }
+  if (change.part === 'walls') {
+    const walls = count(change.wallCount ?? 0, 'wall')
+    return {
+      title: `Remove walls from ${room}?`,
+      description: [
+        hosted
+          ? `Turns ${walls} into separators and removes ${hosted}.`
+          : `Turns ${walls} into separators.`,
+        change.sharedWalls ? 'Shared walls remain.' : '',
+      ]
+        .filter(Boolean)
+        .join(' '),
+      keepLabel: null,
+      confirmLabel: 'Remove walls',
+      destructive: true,
+    }
+  }
+  if (change.part === 'floor') {
+    return {
+      title: `Remove the floor from ${room}?`,
+      description: hosted
+        ? `${hosted} ${p.verb('stand')} on it. Keep ${p.it} at ${p.its} height, or delete ${p.it} too.`
+        : 'Removes the floor.',
+      keepLabel: hosted && canKeep ? 'Keep items' : null,
+      confirmLabel: hosted ? 'Delete items' : 'Remove',
+      destructive: true,
+    }
+  }
+  return ceilingContent(change, nodes, room, canKeep)
+}
+
+export type DeleteConfirmationContent = {
+  title: string
+  description: string
+  /** Delete the room but leave its items in place — offered only when it has items. */
+  keepLabel: string | null
+  confirmLabel: string
+  /** Red confirm for removals; adding walls confirms in the neutral style. */
+  destructive: boolean
+}
+
+/** The words and choices the confirmation offers, from the request alone. */
+function isMezzanine(room: DeleteZonePayload, nodes: StructureNodes) {
+  const zone = nodes[room.zoneId]
+  return zone?.type === 'zone' && zone.floor?.support === 'open'
+}
+
+export function deleteConfirmationContent(
+  request: DeleteConfirmationRequest,
+  nodes: StructureNodes,
+): DeleteConfirmationContent {
+  if (request.construction)
+    return constructionContent(request.construction, nodes, !!request.onKeepContents)
+  const room = request.room
+  if (!room)
+    return {
+      title: `Delete ${count(request.count, 'element')}?`,
+      description:
+        'This removes every selected element. You can undo the deletion while it remains in the editor history.',
+      keepLabel: null,
+      confirmLabel: 'Delete',
+      destructive: true,
+    }
+  const merge = room.mode === 'merge'
+  // A merged area's items always stay, so there is nothing to choose.
+  const hasItems = room.itemIds.length > 0 && !merge
+  return {
+    title: `Delete ${room.name.trim() || (isMezzanine(room, nodes) ? 'this mezzanine' : merge ? 'this area' : 'this room')}?`,
+    description: roomDeletionDescription(room, nodes),
+    keepLabel: hasItems && request.onKeepContents ? 'Keep items' : null,
+    confirmLabel: hasItems ? 'Delete all' : 'Delete',
+    destructive: true,
+  }
+}
+
 export function DeleteConfirmationDialog() {
   const request = useDeleteConfirmation((state) => state.request)
   const cancel = useDeleteConfirmation((state) => state.cancel)
   const confirm = useDeleteConfirmation((state) => state.confirm)
+  const nodes = useScene((state) => (request ? state.nodes : null))
+  const live = useMemo(
+    () => (request && nodes ? deleteConfirmationContent(request, nodes) : null),
+    [request, nodes],
+  )
+  // Hold the last words through the close animation so the dialog never empties.
+  const shown = useRef(live)
+  if (live) shown.current = live
+  const content = shown.current
+  const blocked = !!request?.conflict
 
   useEffect(() => cancel, [cancel])
 
@@ -26,10 +294,12 @@ export function DeleteConfirmationDialog() {
         showCloseButton={false}
       >
         <DialogHeader>
-          <DialogTitle>Delete {request?.count ?? 0} elements?</DialogTitle>
+          <DialogTitle>{content?.title}</DialogTitle>
           <DialogDescription>
-            This removes every selected element. You can undo the deletion while it remains in the
-            editor history.
+            {content?.description}
+            {request?.conflict && (
+              <span className="mt-2 block text-destructive">{request.conflict}</span>
+            )}
           </DialogDescription>
         </DialogHeader>
         <DialogFooter>
@@ -40,12 +310,32 @@ export function DeleteConfirmationDialog() {
           >
             Cancel
           </button>
+          {content?.keepLabel && (
+            <button
+              className="rounded-full border border-border px-4 py-2 text-sm transition-colors hover:bg-accent disabled:pointer-events-none disabled:opacity-50"
+              disabled={blocked}
+              onClick={() => {
+                const keep = request?.onKeepContents
+                cancel()
+                keep?.()
+              }}
+              type="button"
+            >
+              {content.keepLabel}
+            </button>
+          )}
           <button
-            className="rounded-full bg-red-600 px-4 py-2 text-sm text-white transition-colors hover:bg-red-700"
+            className={cn(
+              'rounded-full px-4 py-2 text-sm transition-colors disabled:pointer-events-none disabled:opacity-50',
+              content?.destructive === false
+                ? 'bg-primary text-primary-foreground hover:bg-primary/90'
+                : 'bg-red-600 text-white hover:bg-red-700',
+            )}
+            disabled={blocked}
             onClick={confirm}
             type="button"
           >
-            Delete
+            {content?.confirmLabel}
           </button>
         </DialogFooter>
       </DialogContent>

package/src/components/editor/duplicate-node.ts

@@ -0,0 +1,244 @@
+import {
+  type AnyNode,
+  type AnyNodeId,
+  type CollectionId,
+  ColumnNode,
+  collectionIdsOf,
+  DoorNode,
+  ElevatorNode,
+  FenceNode,
+  generateId,
+  ItemNode,
+  nodeRegistry,
+  RoofSegmentNode,
+  runSceneHistoryDraftWrite,
+  SpawnNode,
+  StairSegmentNode,
+  useScene,
+  WallNode,
+  WindowNode,
+} from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
+import {
+  createFreshPlacementSubtree,
+  duplicatesAsFreshSubtree,
+  prepareFreshPlacementRootDuplicate,
+} from '../../lib/fresh-planar-placement'
+import { duplicateWithoutMove, registryMoveDisabled } from '../../lib/node-action-movement'
+import { duplicateRoofSubtree } from '../../lib/roof-duplication'
+import { sfxEmitter } from '../../lib/sfx-bus'
+import useEditor from '../../store/use-editor'
+import { startZoneRoomTransform } from './room-controls'
+
+let carriedCopy: { id: AnyNodeId; sourceId: AnyNodeId } | null = null
+
+/**
+ * The collections a copy being placed joins when its move tool creates it:
+ * its draft's when the copy is in the scene, else those of the node it copies.
+ */
+export function copyCollectionIds(copy: AnyNode): CollectionId[] {
+  const { collections, nodes } = useScene.getState()
+  if (nodes[copy.id as AnyNodeId]) return collectionIdsOf(collections, copy.id as AnyNodeId)
+  if (carriedCopy?.id !== copy.id) return []
+  return collectionIdsOf(collections, carriedCopy.sourceId)
+}
+
+/**
+ * Duplicate one node and hand the copy to its move tool: the toolbar's and
+ * every inspector's Duplicate. The copy is in the collections its source is in.
+ */
+export function duplicateNodeAndPickUp(node: AnyNode) {
+  if (!node.parentId) return
+  if (startZoneRoomTransform(node, 'duplicate')) return
+  sfxEmitter.emit('sfx:item-pick')
+  const { setMovingNode } = useEditor.getState()
+  const { setSelection } = useViewer.getState()
+
+  if (registryMoveDisabled(node)) {
+    try {
+      const id = duplicateWithoutMove(node)
+      if (id) setSelection({ selectedIds: [id] })
+    } catch (error) {
+      console.error('Failed to duplicate node', error)
+    }
+    return
+  }
+
+  if (node.type === 'roof') {
+    try {
+      duplicateRoofSubtree(node.id as AnyNodeId, { mode: 'move' })
+    } catch (error) {
+      console.error('Failed to duplicate roof', error)
+    }
+    return
+  }
+
+  runSceneHistoryDraftWrite(() => {
+    if (duplicatesAsFreshSubtree(node)) {
+      let draftId: AnyNodeId | null = null
+      try {
+        draftId = createFreshPlacementSubtree(node.id as AnyNodeId)
+        const draft = draftId ? useScene.getState().nodes[draftId] : null
+        if (draft) {
+          setMovingNode(draft)
+          setSelection({ selectedIds: [] })
+          return
+        }
+      } catch (error) {
+        if (draftId && useScene.getState().nodes[draftId]) {
+          useScene.getState().deleteNode(draftId)
+        }
+        console.error('Failed to duplicate node subtree', error)
+      }
+      return
+    }
+
+    const duplicateInfo = prepareFreshPlacementRootDuplicate(node) as any
+
+    let duplicate: AnyNode | null = null
+    try {
+      if (node.type === 'door') {
+        duplicate = DoorNode.parse(duplicateInfo)
+      } else if (node.type === 'window') {
+        duplicate = WindowNode.parse(duplicateInfo)
+      } else if (node.type === 'item') {
+        duplicate = ItemNode.parse(duplicateInfo)
+      } else if (node.type === 'elevator') {
+        duplicate = ElevatorNode.parse(duplicateInfo)
+      } else if (node.type === 'column') {
+        duplicate = ColumnNode.parse(duplicateInfo)
+      } else if (node.type === 'wall') {
+        duplicate = WallNode.parse(duplicateInfo)
+      } else if (node.type === 'fence') {
+        duplicate = FenceNode.parse(duplicateInfo)
+        duplicate.start = [duplicate.start[0] + 1, duplicate.start[1] + 1]
+        duplicate.end = [duplicate.end[0] + 1, duplicate.end[1] + 1]
+      } else if (node.type === 'roof-segment') {
+        duplicateInfo.id = generateId('rseg')
+        duplicate = RoofSegmentNode.parse(duplicateInfo)
+      } else if (node.type === 'stair-segment') {
+        duplicate = StairSegmentNode.parse(duplicateInfo)
+      } else if (node.type === 'spawn') {
+        duplicate = SpawnNode.parse(duplicateInfo)
+      }
+
+      // Registry-driven fallback: any kind with a NodeDefinition can be
+      // duplicated through its schema's parse(). Future built-in kinds
+      // get duplicate for free.
+      if (!duplicate) {
+        const def = nodeRegistry.get(node.type)
+        if (def) {
+          duplicate = def.schema.parse(duplicateInfo) as AnyNode
+        }
+      }
+    } catch (error) {
+      console.error('Failed to parse duplicate', error)
+      return
+    }
+
+    if (!duplicate) {
+      return
+    }
+
+    const copy = duplicate
+    // The copy is in the collections its source is in, from its draft on.
+    const createCopy = () =>
+      useScene.getState().createNodes([
+        {
+          node: copy,
+          parentId: copy.parentId as AnyNodeId,
+          collectionIds: collectionIdsOf(useScene.getState().collections, node.id),
+        },
+      ])
+    if (
+      duplicate.type === 'door' ||
+      duplicate.type === 'window' ||
+      duplicate.type === 'elevator' ||
+      duplicate.type === 'wall' ||
+      duplicate.type === 'fence'
+    ) {
+      createCopy()
+    } else if (duplicate.type === 'roof-segment' || duplicate.type === 'stair-segment') {
+      // Add small offset to make it visible
+      if ('position' in duplicate) {
+        duplicate.position = [
+          duplicate.position[0] + 1,
+          duplicate.position[1],
+          duplicate.position[2] + 1,
+        ]
+      }
+      createCopy()
+    } else if (
+      duplicate.type === 'item' ||
+      duplicate.type === 'chimney' ||
+      duplicate.type === 'dormer'
+    ) {
+      // Items, chimneys & dormers use pure drag-to-place: NO node is
+      // inserted into the scene until the user clicks to commit. The
+      // `setMovingNode` call below hands the clone (with
+      // `metadata.isNew = true` + no id) to its move tool —
+      // `MoveItemTool` / `MoveChimneyTool` / `MoveDormerTool` — which
+      // create a draft and call `createNode` on the commit click.
+      // Pre-creating here would drop a second copy into the scene
+      // before any click — the furnish-tab "duplicate auto-places an
+      // item without clicking" bug. (Item has its own
+      // draft-committing move tool, so it must skip the generic
+      // registry auto-create branch below.)
+      carriedCopy = { id: duplicate.id as AnyNodeId, sourceId: node.id as AnyNodeId }
+    } else if (
+      duplicate.type === 'duct-segment' ||
+      duplicate.type === 'duct-fitting' ||
+      duplicate.type === 'pipe-segment' ||
+      duplicate.type === 'lineset' ||
+      duplicate.type === 'liquid-line'
+    ) {
+      // Duct runs & fittings, DWV pipe runs, and refrigerant linesets use
+      // pure drag-to-place: NO node is inserted into the scene until the
+      // commit click. `setMovingNode` below hands the clone (with
+      // `metadata.isNew`) to its ghost tool (`MoveDuctSegmentTool` /
+      // `MoveDuctFittingTool` / `MovePipeSegmentTool` / `MoveLinesetTool`),
+      // which previews a translucent copy inside a footprint bounding box
+      // on the cursor and calls `createNode` on the drop click.
+      // Pre-creating here would drop a copy before any click — the
+      // "auto-places it" bug.
+      carriedCopy = { id: duplicate.id as AnyNodeId, sourceId: node.id as AnyNodeId }
+    } else if (nodeRegistry.has(duplicate.type)) {
+      // Registry-driven kinds: offset slightly so the duplicate doesn't
+      // overlap exactly, then create + hand to the move tool. Mirrors the
+      // roof-segment / stair-segment behavior.
+      if ('position' in duplicate && Array.isArray((duplicate as any).position)) {
+        const pos = (duplicate as { position: [number, number, number] }).position
+        ;(duplicate as { position: [number, number, number] }).position = [
+          pos[0] + 1,
+          pos[1],
+          pos[2] + 1,
+        ]
+      } else if ('path' in duplicate && Array.isArray((duplicate as any).path)) {
+        // Other polyline kinds (pipe / lineset) carry a `path`, not a
+        // `position`. Create the copy HIDDEN so nothing is auto-placed:
+        // their shared path mover reveals it as a cursor-following preview
+        // on the first mouse move and commits on the next click.
+        ;(duplicate as { visible?: boolean }).visible = false
+      }
+      createCopy()
+    }
+    if (
+      duplicate.type === 'item' ||
+      duplicate.type === 'elevator' ||
+      duplicate.type === 'column' ||
+      duplicate.type === 'wall' ||
+      duplicate.type === 'fence' ||
+      duplicate.type === 'window' ||
+      duplicate.type === 'door' ||
+      duplicate.type === 'roof-segment' ||
+      duplicate.type === 'spawn' ||
+      duplicate.type === 'stair-segment' ||
+      // Registry-driven kinds get picked up by MoveTool's generic
+      // fallback (MoveRegistryNodeTool) so the user can reposition.
+      nodeRegistry.has(duplicate.type)
+    ) {
+      setMovingNode(duplicate)
+    }
+    setSelection({ selectedIds: [] })
+  })
+}