@pascal-app/editor 0.8.0 → 0.9.1

package/src/components/tools/select/select-candidates.test.ts

@@ -0,0 +1,109 @@
+import { beforeAll, beforeEach, describe, expect, test } from 'bun:test'
+import {
+  type AnyNode,
+  type AnyNodeDefinition,
+  nodeRegistry,
+  registerNode,
+  useScene,
+} from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
+import { z } from 'zod'
+import useEditor from '../../../store/use-editor'
+import { collectSelectableCandidateIds } from './select-candidates'
+
+function registerSelectableElevatorTestKind() {
+  if (nodeRegistry.has('elevator')) return
+
+  registerNode({
+    kind: 'elevator',
+    schemaVersion: 1,
+    schema: z.object({ type: z.literal('elevator') }) as never,
+    category: 'structure',
+    defaults: () => ({}),
+    capabilities: { selectable: {} },
+    floorplanScope: 'building',
+    renderer: { kind: 'parametric', module: async () => ({ default: () => null }) },
+  } as AnyNodeDefinition)
+}
+
+describe('selectable candidates', () => {
+  beforeAll(() => {
+    registerSelectableElevatorTestKind()
+  })
+
+  beforeEach(() => {
+    useScene.setState({
+      nodes: {},
+      rootNodeIds: [],
+      dirtyNodes: new Set(),
+      collections: {},
+    } as never)
+    useViewer.setState({
+      selection: {
+        buildingId: 'building_test',
+        levelId: 'level_test',
+        zoneId: null,
+        selectedIds: [],
+      },
+      previewSelectedIds: [],
+    })
+    useEditor.setState({
+      phase: 'structure',
+      structureLayer: 'elements',
+    })
+  })
+
+  test('includes building-scoped elevators for the active level building', () => {
+    useScene.setState({
+      nodes: {
+        building_test: {
+          id: 'building_test',
+          type: 'building',
+          children: ['level_test', 'elevator_test'],
+        },
+        level_test: {
+          id: 'level_test',
+          type: 'level',
+          parentId: 'building_test',
+          children: [],
+        },
+        elevator_test: {
+          id: 'elevator_test',
+          type: 'elevator',
+          parentId: 'building_test',
+          position: [1, 0, 2],
+          rotation: 0,
+        },
+      } as unknown as Record<string, AnyNode>,
+    } as never)
+
+    expect(collectSelectableCandidateIds()).toContain('elevator_test')
+  })
+
+  test('includes legacy level-parented elevators already loaded in the editor', () => {
+    useScene.setState({
+      nodes: {
+        building_test: {
+          id: 'building_test',
+          type: 'building',
+          children: ['level_test'],
+        },
+        level_test: {
+          id: 'level_test',
+          type: 'level',
+          parentId: 'building_test',
+          children: ['elevator_test'],
+        },
+        elevator_test: {
+          id: 'elevator_test',
+          type: 'elevator',
+          parentId: 'level_test',
+          position: [1, 0, 2],
+          rotation: 0,
+        },
+      } as unknown as Record<string, AnyNode>,
+    } as never)
+
+    expect(collectSelectableCandidateIds()).toContain('elevator_test')
+  })
+})

package/src/components/tools/select/select-candidates.ts

@@ -0,0 +1,85 @@
+import {
+  type AnyNode,
+  type AnyNodeId,
+  isRegistrySelectable,
+  type LevelNode,
+  nodeRegistry,
+  resolveBuildingForLevel,
+  resolveLevelId,
+  useScene,
+} from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
+import useEditor from '../../../store/use-editor'
+
+function isVisibleSelectableNode(node: AnyNode): boolean {
+  if ((node as { visible?: boolean }).visible === false) return false
+  return isRegistrySelectable(node.type)
+}
+
+export function collectSelectableCandidateIds(): string[] {
+  const { levelId } = useViewer.getState().selection
+  const { nodes } = useScene.getState()
+  const { phase, structureLayer } = useEditor.getState()
+  const result: string[] = []
+  const seen = new Set<string>()
+  const addNode = (node: AnyNode | undefined) => {
+    if (!node || seen.has(node.id) || (node as { visible?: boolean }).visible === false) return
+    seen.add(node.id)
+    result.push(node.id)
+  }
+  const visitLevelDescendant = (id: AnyNodeId) => {
+    const node = nodes[id]
+    if (!node || seen.has(node.id) || (node as { visible?: boolean }).visible === false) return
+
+    if (isRegistrySelectable(node.type)) {
+      addNode(node)
+    }
+
+    const children = 'children' in node && Array.isArray(node.children) ? node.children : []
+    for (const childId of children) {
+      visitLevelDescendant(childId as AnyNodeId)
+    }
+  }
+
+  if (phase === 'site') {
+    for (const node of Object.values(nodes)) {
+      if (node.type === 'building') addNode(node)
+    }
+    return result
+  }
+
+  if (!levelId) return []
+  const levelNode = nodes[levelId as AnyNodeId] as LevelNode | undefined
+  if (!levelNode || levelNode.type !== 'level') return []
+
+  if (phase === 'structure' && structureLayer === 'zones') {
+    for (const childId of levelNode.children) {
+      const node = nodes[childId as AnyNodeId]
+      if (node?.type === 'zone') addNode(node)
+    }
+    return result
+  }
+
+  for (const childId of levelNode.children) {
+    visitLevelDescendant(childId as AnyNodeId)
+  }
+
+  const buildingId = resolveBuildingForLevel(levelId as AnyNodeId, nodes)
+  for (const node of Object.values(nodes)) {
+    if (!node || node.type === 'level' || !isVisibleSelectableNode(node)) continue
+
+    const def = nodeRegistry.get(node.type)
+    const isBuildingScoped = def?.floorplanScope === 'building'
+    const parentId = (node as { parentId?: AnyNodeId | null }).parentId
+    if (isBuildingScoped && buildingId && parentId === buildingId) {
+      addNode(node)
+      continue
+    }
+
+    if (!isBuildingScoped && resolveLevelId(node, nodes) === levelId) {
+      addNode(node)
+    }
+  }
+
+  return result
+}

package/src/components/tools/shared/affordance-dispatch.ts

@@ -0,0 +1,30 @@
+import { nodeRegistry } from '@pascal-app/core'
+import { type ComponentType, lazy } from 'react'
+
+/**
+ * Phase 5 Stage D — runtime lazy-load of a kind's affordance tool.
+ *
+ * The editor can't statically import from `@pascal-app/nodes` (the
+ * nodes package depends on editor — static imports would cycle). The
+ * kind declares its drag-affordance components in
+ * `def.affordanceTools[<key>]: () => import('./<name>-tool')`; this
+ * helper resolves that to a `React.lazy` component at the call site.
+ *
+ * Returns null when the kind doesn't declare the affordance — callers
+ * mount the legacy fallback in that case.
+ */
+const lazyToolCache = new WeakMap<() => Promise<unknown>, ComponentType>()
+
+export function getRegistryAffordanceTool(
+  kind: string,
+  affordance: string,
+): ComponentType<any> | null {
+  const def = nodeRegistry.get(kind)
+  const loader = def?.affordanceTools?.[affordance]
+  if (!loader) return null
+  const cached = lazyToolCache.get(loader)
+  if (cached) return cached
+  const Comp = lazy(loader as () => Promise<{ default: ComponentType<any> }>)
+  lazyToolCache.set(loader, Comp as unknown as ComponentType)
+  return Comp as unknown as ComponentType<any>
+}

package/src/components/tools/shared/drag-bounding-box.tsx

@@ -0,0 +1,171 @@
+'use client'
+
+import { sceneRegistry } from '@pascal-app/core'
+import { useEffect, useMemo } from 'react'
+import {
+  Box3,
+  BoxGeometry,
+  EdgesGeometry,
+  Matrix4,
+  type Mesh,
+  type Object3D,
+  PlaneGeometry,
+  Vector3,
+} from 'three'
+import { distance, smoothstep, uv, vec2 } from 'three/tsl'
+import { LineBasicNodeMaterial, MeshBasicNodeMaterial } from 'three/webgpu'
+import { EDITOR_LAYER } from '../../../lib/constants'
+
+const NO_RAYCAST = () => null
+
+/** green-500 — matches the item placement box's "placeable" state. */
+const DEFAULT_COLOR = 0x22_c5_5e
+
+type LocalBounds = { size: [number, number, number]; center: [number, number, number] }
+
+/**
+ * The node's bounding box in its OWN, unrotated frame — measured from the
+ * rendered geometry so it captures the full extent (base, cap, overhang),
+ * not just the declared width/height/depth. World position + rotation are
+ * cancelled out (invert the root's world matrix), so the result is stable
+ * regardless of where the live drag has moved the node; the caller re-applies
+ * the current Y rotation on the group. Returns null when nothing measurable.
+ */
+function measureLocalBounds(obj: Object3D): LocalBounds | null {
+  obj.updateWorldMatrix(true, true)
+  const inverseRoot = new Matrix4().copy(obj.matrixWorld).invert()
+  const box = new Box3()
+  const meshBox = new Box3()
+  const toLocal = new Matrix4()
+  let measured = false
+  obj.traverse((child) => {
+    const mesh = child as Mesh
+    if (!mesh.isMesh || !mesh.geometry) return
+    if (!mesh.geometry.boundingBox) mesh.geometry.computeBoundingBox()
+    const bb = mesh.geometry.boundingBox
+    if (!bb) return
+    toLocal.copy(inverseRoot).multiply(mesh.matrixWorld)
+    meshBox.copy(bb).applyMatrix4(toLocal)
+    box.union(meshBox)
+    measured = true
+  })
+  if (!measured || box.isEmpty()) return null
+  const size = box.getSize(new Vector3())
+  const center = box.getCenter(new Vector3())
+  return { size: [size.x, size.y, size.z], center: [center.x, center.y, center.z] }
+}
+
+interface DragBoundingBoxProps {
+  /** Node whose rendered geometry is measured for the box extents. */
+  nodeId: string
+  /** Footprint origin on the floor, `[x, 0, z]` — the node's live position. */
+  position: [number, number, number]
+  /** Y rotation (radians) applied to the box, matching the dragged node. */
+  rotationY?: number
+  /** Declared `[width, height, depth]`, used until/if the mesh can't be measured. */
+  fallbackSize?: [number, number, number]
+  /**
+   * Hard override for the box extents — wins over both mesh measurement and
+   * `fallbackSize`. Use when the rendered mesh contains extras the user
+   * wouldn't read as "the thing being dragged" (e.g. an elevator whose mesh
+   * includes per-level landings outside the shaft footprint).
+   */
+  size?: [number, number, number]
+  /** Y center of the box in the node's local frame. Defaults to `size[1] / 2`. */
+  centerY?: number
+  color?: number
+}
+
+/**
+ * Footprint box drawn around a node while it is being dragged — the same
+ * affordance items get during placement: a wireframe cube spanning the node's
+ * full measured extent plus a ground plane with a radial opacity gradient
+ * (transparent in the centre, opaque toward the edges). Overlay layer +
+ * `depthTest: false` keep it drawn on top of scene geometry throughout the
+ * drag, and the box visualises the bounds that drive alignment snapping.
+ */
+export function DragBoundingBox({
+  nodeId,
+  position,
+  rotationY = 0,
+  fallbackSize = [0, 0, 0],
+  size,
+  centerY,
+  color = DEFAULT_COLOR,
+}: DragBoundingBoxProps) {
+  const measured = useMemo(() => {
+    if (size) return null
+    const obj = sceneRegistry.nodes.get(nodeId)
+    return obj ? measureLocalBounds(obj) : null
+  }, [nodeId, size])
+
+  const [w, h, d] = size ?? measured?.size ?? fallbackSize
+  const [cx, cy, cz] = size
+    ? [0, centerY ?? size[1] / 2, 0]
+    : (measured?.center ?? [0, fallbackSize[1] / 2, 0])
+  const minY = cy - h / 2
+
+  const edgeGeometry = useMemo(() => {
+    const box = new BoxGeometry(w, h, d)
+    const edges = new EdgesGeometry(box)
+    box.dispose()
+    return edges
+  }, [w, h, d])
+
+  // Flat on the ground (XZ) at the box's base, nudged up 0.01m to avoid
+  // z-fighting with slabs.
+  const planeGeometry = useMemo(() => {
+    const plane = new PlaneGeometry(w, d)
+    plane.rotateX(-Math.PI / 2)
+    plane.translate(cx, minY + 0.01, cz)
+    return plane
+  }, [w, d, cx, minY, cz])
+
+  const edgeMaterial = useMemo(
+    () => new LineBasicNodeMaterial({ color, linewidth: 3, depthTest: false, depthWrite: false }),
+    [color],
+  )
+
+  const planeMaterial = useMemo(() => {
+    const material = new MeshBasicNodeMaterial({
+      color,
+      transparent: true,
+      depthTest: false,
+      depthWrite: false,
+    })
+    material.opacityNode = smoothstep(0, 0.7, distance(uv(), vec2(0.5, 0.5))).mul(0.6)
+    return material
+  }, [color])
+
+  useEffect(
+    () => () => {
+      edgeGeometry.dispose()
+      planeGeometry.dispose()
+      edgeMaterial.dispose()
+      planeMaterial.dispose()
+    },
+    [edgeGeometry, planeGeometry, edgeMaterial, planeMaterial],
+  )
+
+  if (w <= 0 || h <= 0 || d <= 0) return null
+
+  return (
+    <group position={position} rotation={[0, rotationY, 0]}>
+      <mesh
+        geometry={planeGeometry}
+        layers={EDITOR_LAYER}
+        material={planeMaterial}
+        raycast={NO_RAYCAST}
+        renderOrder={999}
+      />
+      <lineSegments
+        geometry={edgeGeometry}
+        layers={EDITOR_LAYER}
+        material={edgeMaterial}
+        position={[cx, cy, cz]}
+        raycast={NO_RAYCAST}
+        renderOrder={999}
+      />
+    </group>
+  )
+}

package/src/components/tools/shared/floor-stack-preview.ts

@@ -0,0 +1,25 @@
+import { type AnyNode, type AnyNodeId, getFloorStackedPosition, useScene } from '@pascal-app/core'
+
+type FloorStackPreviewArgs = {
+  node: AnyNode
+  position: [number, number, number]
+  rotation?: unknown
+  levelId?: string | null
+  nodes?: Record<AnyNodeId, AnyNode>
+}
+
+export function getFloorStackPreviewPosition({
+  node,
+  position,
+  rotation,
+  levelId,
+  nodes,
+}: FloorStackPreviewArgs): [number, number, number] {
+  return getFloorStackedPosition({
+    node,
+    nodes: nodes ?? useScene.getState().nodes,
+    position,
+    rotation,
+    levelId,
+  })
+}

package/src/components/tools/shared/fresh-placement-visibility.ts

@@ -0,0 +1,61 @@
+'use client'
+
+import { type AnyNode, type AnyNodeId, sceneRegistry, useScene } from '@pascal-app/core'
+import { useCallback, useRef, useState } from 'react'
+import { isFreshPlacementMetadata } from '../../../lib/placement-metadata'
+import useEditor from '../../../store/use-editor'
+
+type FreshPlacementNode = Pick<AnyNode, 'id' | 'metadata'>
+
+type FreshPlacementVisibilityArgs = {
+  node: FreshPlacementNode
+  enabled?: boolean
+}
+
+export function useFreshPlacementVisibility({
+  node,
+  enabled = true,
+}: FreshPlacementVisibilityArgs) {
+  const isFreshPlacement = enabled && isFreshPlacementMetadata(node.metadata)
+  const useAbsoluteCursorPlacement = isFreshPlacement && !useEditor.getState().placementDragMode
+  const shouldStartHidden = useAbsoluteCursorPlacement
+
+  const [visibility, setVisibility] = useState(() => ({
+    nodeId: node.id,
+    visible: !shouldStartHidden,
+  }))
+  const visibilityRef = useRef(visibility)
+  const previewVisible = visibility.nodeId === node.id ? visibility.visible : !shouldStartHidden
+
+  const setPreviewVisibleForNode = useCallback(
+    (visible: boolean) => {
+      const current = visibilityRef.current
+      if (current.nodeId === node.id && current.visible === visible) return
+      const next = { nodeId: node.id, visible }
+      visibilityRef.current = next
+      setVisibility(next)
+    },
+    [node.id],
+  )
+
+  const revealFreshPlacement = useCallback(() => {
+    if (!isFreshPlacement) return
+    setPreviewVisibleForNode(true)
+
+    sceneRegistry.nodes.get(node.id)?.traverse((child) => {
+      child.visible = true
+    })
+
+    const liveNode = useScene.getState().nodes[node.id as AnyNodeId]
+    if (liveNode?.visible === false) {
+      useScene.getState().updateNode(node.id as AnyNodeId, { visible: true } as Partial<AnyNode>)
+    }
+  }, [isFreshPlacement, node.id, setPreviewVisibleForNode])
+
+  return {
+    isFreshPlacement,
+    previewVisible,
+    revealFreshPlacement,
+    useAbsoluteCursorPlacement,
+  }
+}

package/src/components/tools/shared/placement-box-geometry.ts

@@ -0,0 +1,123 @@
+import { BufferGeometry, Float32BufferAttribute, type LineSegments } from 'three'
+
+/**
+ * Axis-aligned box description shared by every placement-cursor wireframe.
+ * `dimensions` is the box extent on each axis; `center` is its centre in the
+ * cursor group's local space (so an off-centre mesh bbox stays off-centre).
+ * `min`/`max` are kept for callers that need the explicit corners.
+ */
+export type PreviewBounds = {
+  min: [number, number, number]
+  max: [number, number, number]
+  dimensions: [number, number, number]
+  center: [number, number, number]
+}
+
+export function createLineGeometry(points: number[] = [0, 0, 0, 0, 0, 0]): BufferGeometry {
+  const geometry = new BufferGeometry()
+  geometry.setAttribute('position', new Float32BufferAttribute(points, 3))
+  return geometry
+}
+
+/** Flatten a box's 12 edges into a `LineSegments` position array. */
+export function getBoxEdgePoints(bounds: PreviewBounds): number[] {
+  const [width, height, depth] = bounds.dimensions
+  const [centerX, centerY, centerZ] = bounds.center
+  const minX = centerX - width / 2
+  const maxX = centerX + width / 2
+  const minY = centerY - height / 2
+  const maxY = centerY + height / 2
+  const minZ = centerZ - depth / 2
+  const maxZ = centerZ + depth / 2
+
+  return [
+    minX,
+    minY,
+    minZ,
+    maxX,
+    minY,
+    minZ,
+    maxX,
+    minY,
+    minZ,
+    maxX,
+    minY,
+    maxZ,
+    maxX,
+    minY,
+    maxZ,
+    minX,
+    minY,
+    maxZ,
+    minX,
+    minY,
+    maxZ,
+    minX,
+    minY,
+    minZ,
+
+    minX,
+    maxY,
+    minZ,
+    maxX,
+    maxY,
+    minZ,
+    maxX,
+    maxY,
+    minZ,
+    maxX,
+    maxY,
+    maxZ,
+    maxX,
+    maxY,
+    maxZ,
+    minX,
+    maxY,
+    maxZ,
+    minX,
+    maxY,
+    maxZ,
+    minX,
+    maxY,
+    minZ,
+
+    minX,
+    minY,
+    minZ,
+    minX,
+    maxY,
+    minZ,
+    maxX,
+    minY,
+    minZ,
+    maxX,
+    maxY,
+    minZ,
+    maxX,
+    minY,
+    maxZ,
+    maxX,
+    maxY,
+    maxZ,
+    minX,
+    minY,
+    maxZ,
+    minX,
+    maxY,
+    maxZ,
+  ]
+}
+
+export function updateLineGeometry(ref: React.RefObject<LineSegments>, points: number[]) {
+  const geometry = ref.current?.geometry
+  if (!geometry) return
+
+  const attribute = geometry.getAttribute('position') as Float32BufferAttribute | undefined
+  if (!attribute || attribute.array.length !== points.length) {
+    geometry.setAttribute('position', new Float32BufferAttribute(points, 3))
+  } else {
+    attribute.set(points)
+    attribute.needsUpdate = true
+  }
+  geometry.computeBoundingSphere()
+}