@pascal-app/editor 0.9.1 → 0.9.2

package/src/lib/quick-measurement.test.ts

@@ -0,0 +1,77 @@
+import { describe, expect, test } from 'bun:test'
+import { createQuickMeasurementPointerScheduler } from './quick-measurement'
+
+function pointer(clientX: number, clientY: number): PointerEvent {
+  return { clientX, clientY } as PointerEvent
+}
+
+function createFrameDriver() {
+  let nextId = 1
+  const callbacks = new Map<number, FrameRequestCallback>()
+  return {
+    driver: {
+      request: (callback: FrameRequestCallback) => {
+        const id = nextId++
+        callbacks.set(id, callback)
+        return id
+      },
+      cancel: (frameId: number) => callbacks.delete(frameId),
+    },
+    pending: () => callbacks.size,
+    runNext: (timestamp: number) => {
+      const next = callbacks.entries().next().value as [number, FrameRequestCallback] | undefined
+      if (!next) throw new Error('No animation frame scheduled')
+      callbacks.delete(next[0])
+      next[1](timestamp)
+    },
+  }
+}
+
+describe('createQuickMeasurementPointerScheduler', () => {
+  test('keeps only the latest pointer event and caps expensive work', () => {
+    const frames = createFrameDriver()
+    const processed: PointerEvent[] = []
+    const scheduler = createQuickMeasurementPointerScheduler(
+      (event) => processed.push(event),
+      frames.driver,
+    )
+
+    scheduler.enqueue(pointer(1, 1))
+    scheduler.enqueue(pointer(8, 4))
+    expect(frames.pending()).toBe(1)
+    frames.runNext(0)
+    expect(processed.map((event) => [event.clientX, event.clientY])).toEqual([[8, 4]])
+
+    scheduler.enqueue(pointer(12, 4))
+    frames.runNext(16)
+    expect(processed).toHaveLength(1)
+    expect(frames.pending()).toBe(1)
+
+    scheduler.enqueue(pointer(20, 7))
+    frames.runNext(32)
+    expect(processed.map((event) => [event.clientX, event.clientY])).toEqual([
+      [8, 4],
+      [20, 7],
+    ])
+  })
+
+  test('ignores sub-pixel jitter and cancels queued work', () => {
+    const frames = createFrameDriver()
+    const processed: PointerEvent[] = []
+    const scheduler = createQuickMeasurementPointerScheduler(
+      (event) => processed.push(event),
+      frames.driver,
+    )
+
+    scheduler.enqueue(pointer(10, 10))
+    frames.runNext(0)
+    scheduler.enqueue(pointer(10.5, 10.5))
+    frames.runNext(32)
+    expect(processed).toHaveLength(1)
+
+    scheduler.enqueue(pointer(20, 20))
+    scheduler.clear()
+    expect(frames.pending()).toBe(0)
+    expect(processed).toHaveLength(1)
+  })
+})

package/src/lib/quick-measurement.ts

@@ -0,0 +1,109 @@
+import {
+  type AnyNode,
+  type AnyNodeId,
+  type GeometryContext,
+  nodeRegistry,
+  type QuickMeasurementReport,
+} from '@pascal-app/core'
+
+const QUICK_MEASUREMENT_QUERY_INTERVAL_MS = 30
+const QUICK_MEASUREMENT_MIN_DISTANCE_SQ = 1
+
+export function createQuickMeasurementPointerScheduler(
+  onPointerMove: (event: PointerEvent) => void,
+  frameDriver: {
+    request: (callback: FrameRequestCallback) => number
+    cancel: (frameId: number) => void
+  } = {
+    request: (callback) => requestAnimationFrame(callback),
+    cancel: (frameId) => cancelAnimationFrame(frameId),
+  },
+): {
+  enqueue: (event: PointerEvent) => void
+  clear: () => void
+} {
+  let latestEvent: PointerEvent | null = null
+  let frameId: number | null = null
+  let lastProcessedAt = Number.NEGATIVE_INFINITY
+  let lastClientX = Number.NaN
+  let lastClientY = Number.NaN
+
+  const schedule = () => {
+    if (frameId === null) frameId = frameDriver.request(flush)
+  }
+  const flush = (timestamp: number) => {
+    frameId = null
+    if (!latestEvent) return
+    if (timestamp - lastProcessedAt < QUICK_MEASUREMENT_QUERY_INTERVAL_MS) {
+      schedule()
+      return
+    }
+
+    const event = latestEvent
+    latestEvent = null
+    const deltaX = event.clientX - lastClientX
+    const deltaY = event.clientY - lastClientY
+    if (
+      Number.isFinite(lastClientX) &&
+      deltaX * deltaX + deltaY * deltaY < QUICK_MEASUREMENT_MIN_DISTANCE_SQ
+    ) {
+      return
+    }
+
+    lastClientX = event.clientX
+    lastClientY = event.clientY
+    lastProcessedAt = timestamp
+    onPointerMove(event)
+    if (latestEvent) schedule()
+  }
+
+  return {
+    enqueue: (event) => {
+      latestEvent = event
+      schedule()
+    },
+    clear: () => {
+      if (frameId !== null) frameDriver.cancel(frameId)
+      latestEvent = null
+      frameId = null
+      lastProcessedAt = Number.NEGATIVE_INFINITY
+      lastClientX = Number.NaN
+      lastClientY = Number.NaN
+    },
+  }
+}
+
+export function quickMeasurementContext(
+  node: AnyNode,
+  nodes: Record<AnyNodeId, AnyNode>,
+): GeometryContext {
+  const resolve: GeometryContext['resolve'] = <N = AnyNode>(id: AnyNodeId) =>
+    nodes[id] as N | undefined
+  const childIds =
+    'children' in node && Array.isArray(node.children) ? (node.children as AnyNodeId[]) : []
+  const children = childIds
+    .map((id) => nodes[id])
+    .filter((child): child is AnyNode => child !== undefined)
+  const parent = node.parentId ? (nodes[node.parentId as AnyNodeId] ?? null) : null
+  const siblings =
+    parent && 'children' in parent && Array.isArray(parent.children)
+      ? (parent.children as AnyNodeId[])
+          .map((id) => nodes[id])
+          .filter(
+            (sibling): sibling is AnyNode => sibling !== undefined && sibling.type === node.type,
+          )
+      : []
+
+  return { resolve, children, parent, siblings }
+}
+
+export function resolveQuickMeasurementReport(
+  nodeId: string | null,
+  nodes: Record<AnyNodeId, AnyNode>,
+): QuickMeasurementReport | null {
+  if (!nodeId) return null
+  const node = nodes[nodeId as AnyNodeId]
+  if (!node || node.visible === false) return null
+  const quickMeasure = nodeRegistry.get(node.type)?.measurement?.quickMeasure
+  return quickMeasure ? quickMeasure(node, quickMeasurementContext(node, nodes)) : null
+}

package/src/lib/roof-duplication.ts

@@ -80,7 +80,7 @@ export function duplicateRoofSubtree(
   const scene = useScene.getState()
   const sourceRoof = scene.nodes[sourceRoofId]
 
-  if (!sourceRoof || sourceRoof.type !== 'roof') {
+  if (sourceRoof?.type !== 'roof') {
     throw new Error(`Node "${sourceRoofId}" is not a roof`)
   }
 
@@ -105,7 +105,7 @@ export function duplicateRoofSubtree(
   const segmentClones: RoofSegmentNode[] = []
   for (const childId of sourceRoof.children ?? []) {
     const childNode = scene.nodes[childId as AnyNodeId]
-    if (!childNode || childNode.type !== 'roof-segment') {
+    if (childNode?.type !== 'roof-segment') {
       continue
     }
 
@@ -125,7 +125,7 @@ export function duplicateRoofSubtree(
 
   const nextScene = useScene.getState()
   const createdRoof = nextScene.nodes[roofClone.id as AnyNodeId]
-  if (!createdRoof || createdRoof.type !== 'roof') {
+  if (createdRoof?.type !== 'roof') {
     throw new Error(`Duplicated roof "${roofClone.id}" was not created`)
   }
 
@@ -151,7 +151,7 @@ export function duplicateRoofSubtree(
 
   const invalidSegment = segmentIds.find((segmentId) => {
     const segment = nextScene.nodes[segmentId as AnyNodeId]
-    return !segment || segment.type !== 'roof-segment' || segment.parentId !== createdRoof.id
+    return segment?.type !== 'roof-segment' || segment.parentId !== createdRoof.id
   })
   if (invalidSegment) {
     throw new Error(
@@ -179,7 +179,7 @@ export function clearRoofDuplicateMetadata(
 ) {
   const scene = useScene.getState()
   const roofNode = scene.nodes[roofId]
-  if (!roofNode || roofNode.type !== 'roof') {
+  if (roofNode?.type !== 'roof') {
     return
   }
 
@@ -198,7 +198,7 @@ export function clearRoofDuplicateMetadata(
 
   for (const childId of roofNode.children ?? []) {
     const childNode = scene.nodes[childId as AnyNodeId]
-    if (!childNode || childNode.type !== 'roof-segment') {
+    if (childNode?.type !== 'roof-segment') {
       continue
     }
 

package/src/lib/roof-hover-outline-proxy.ts

@@ -0,0 +1,22 @@
+import { type AnyNodeId, sceneRegistry, useScene } from '@pascal-app/core'
+import type * as THREE from 'three'
+
+export const HOVERED_ROOF_SEGMENT_OUTLINE_PROXY_NAME = '__roof-hover-outline-proxy__'
+
+function hoveredRoofSegmentOutlineProxyName(segmentId: string) {
+  return `${HOVERED_ROOF_SEGMENT_OUTLINE_PROXY_NAME}:${segmentId}`
+}
+
+export function getHoveredRoofSegmentOutlineProxy(segmentId: string): THREE.Object3D | null {
+  const segment = useScene.getState().nodes[segmentId as AnyNodeId]
+  if (!(segment?.type === 'roof-segment' && segment.parentId)) return null
+  return (
+    sceneRegistry.nodes
+      .get(segment.parentId)
+      ?.getObjectByName(hoveredRoofSegmentOutlineProxyName(segmentId)) ?? null
+  )
+}
+
+export function getHoveredRoofSegmentOutlineProxyName(segmentId: string): string {
+  return hoveredRoofSegmentOutlineProxyName(segmentId)
+}

package/src/lib/roof-wall-hit.ts

@@ -0,0 +1,164 @@
+import {
+  type AnyNodeId,
+  getRoofSegmentWallFaces,
+  getScaledDimensions,
+  type ItemNode,
+  type RoofNode,
+  type RoofSegmentNode,
+  type RoofSegmentWallFace,
+  type RoofWallFaceId,
+  sceneRegistry,
+  segmentPointToRoofWallFace,
+  useScene,
+} from '@pascal-app/core'
+import * as THREE from 'three'
+
+const worldPoint = new THREE.Vector3()
+const worldNormal = new THREE.Vector3()
+const localPoint = new THREE.Vector3()
+const localNormal = new THREE.Vector3()
+const inverseMatrix = new THREE.Matrix4()
+
+export type RoofWallHit = {
+  segment: RoofSegmentNode
+  face: RoofSegmentWallFace
+  /** Face coords of the hit (u along the face, v above the segment base). */
+  u: number
+  v: number
+}
+
+/** Pointer hits more than this far off the wall plane are not wall hits. */
+const PLANE_TOLERANCE = 0.06
+/** Reject faces whose normal disagrees with the hit normal (slope / soffit). */
+const NORMAL_ALIGNMENT = 0.7
+/** A wall face is vertical; slope faces on low pitches have |ny| ≫ 0. */
+const MAX_NORMAL_Y = 0.4
+
+/**
+ * Resolve a pointer hit on a roof to one of its segments' vertical wall
+ * faces (base walls under the roof + the coplanar gable/shed/gambrel end
+ * faces). Counterpart of `resolveRoofSegmentHit`, which resolves to the
+ * sloped top surface instead.
+ *
+ * `normal` must be the raw `NodeEvent.normal` (hit-object-local) together
+ * with the `object` it came from — roof events can originate from the
+ * merged-roof mesh (roof-local frame) or a painted segment mesh
+ * (segment-local frame), so the normal is normalised through world space
+ * here instead of trusting the event frame.
+ *
+ * Lives in `@pascal-app/editor` because both the kind-owned door/window
+ * tools (in `@pascal-app/nodes`, which depends on editor) and the item
+ * placement coordinator (in editor itself) consume it.
+ */
+export function resolveRoofWallHit(
+  roof: RoofNode,
+  position: [number, number, number],
+  normal: [number, number, number] | undefined,
+  object: THREE.Object3D | undefined,
+): RoofWallHit | null {
+  if (!normal || !object) return null
+
+  worldPoint.set(position[0], position[1], position[2])
+  worldNormal.set(normal[0], normal[1], normal[2])
+  object.updateWorldMatrix(true, false)
+  worldNormal.transformDirection(object.matrixWorld)
+
+  const state = useScene.getState()
+  let best: { hit: RoofWallHit; score: number } | null = null
+
+  for (const childId of roof.children ?? []) {
+    const segment = state.nodes[childId as AnyNodeId] as RoofSegmentNode | undefined
+    if (segment?.type !== 'roof-segment') continue
+    const segObj = sceneRegistry.nodes.get(segment.id)
+    if (!segObj) continue
+    segObj.updateWorldMatrix(true, false)
+
+    localPoint.copy(worldPoint)
+    segObj.worldToLocal(localPoint)
+    inverseMatrix.copy(segObj.matrixWorld).invert()
+    localNormal.copy(worldNormal).transformDirection(inverseMatrix)
+
+    if (Math.abs(localNormal.y) > MAX_NORMAL_Y) continue
+
+    for (const face of getRoofSegmentWallFaces(segment)) {
+      const alignment =
+        localNormal.x * face.normal[0] +
+        localNormal.y * face.normal[1] +
+        localNormal.z * face.normal[2]
+      if (alignment < NORMAL_ALIGNMENT) continue
+
+      const { u, v, dist } = segmentPointToRoofWallFace(segment, face.id, [
+        localPoint.x,
+        localPoint.y,
+        localPoint.z,
+      ])
+      if (Math.abs(dist) > PLANE_TOLERANCE) continue
+      if (u < -PLANE_TOLERANCE || u > face.length + PLANE_TOLERANCE) continue
+      if (v < -PLANE_TOLERANCE) continue
+
+      const score = Math.abs(dist)
+      if (!best || score < best.score) {
+        best = { hit: { segment, face, u, v }, score }
+      }
+    }
+  }
+
+  return best?.hit ?? null
+}
+
+/**
+ * Overlap guard for nodes sharing a roof-segment wall face — the
+ * roof-host analogue of `hasWallChildOverlap`. Hosted children store
+ * FACE-LOCAL coords + an explicit `roofFace`, so siblings compare
+ * directly: doors/windows are center-anchored in v, wall items
+ * bottom-anchored.
+ */
+export function hasRoofFaceChildOverlap(
+  segment: RoofSegmentNode,
+  faceId: RoofWallFaceId,
+  u: number,
+  v: number,
+  width: number,
+  height: number,
+  ignoreId?: string,
+): boolean {
+  const nodes = useScene.getState().nodes
+  const newLeft = u - width / 2
+  const newRight = u + width / 2
+  const newBottom = v - height / 2
+  const newTop = v + height / 2
+
+  for (const childId of segment.children ?? []) {
+    if (childId === ignoreId) continue
+    const child = nodes[childId as AnyNodeId]
+    if (!child) continue
+    if ((child as { roofFace?: RoofWallFaceId }).roofFace !== faceId) continue
+    const position = (child as { position?: [number, number, number] }).position
+    if (!position) continue
+
+    let childW: number
+    let childBottom: number
+    let childTop: number
+    if (child.type === 'door' || child.type === 'window') {
+      const opening = child as { width: number; height: number }
+      childW = opening.width
+      childBottom = position[1] - opening.height / 2
+      childTop = position[1] + opening.height / 2
+    } else if (child.type === 'item') {
+      const item = child as ItemNode
+      if (item.asset.attachTo !== 'wall' && item.asset.attachTo !== 'wall-side') continue
+      const [w, h] = getScaledDimensions(item)
+      childW = w
+      // Items anchor position[1] at their bottom edge.
+      childBottom = position[1]
+      childTop = position[1] + h
+    } else {
+      continue
+    }
+
+    const xOverlap = newLeft < position[0] + childW / 2 && newRight > position[0] - childW / 2
+    const yOverlap = newBottom < childTop && newTop > childBottom
+    if (xOverlap && yOverlap) return true
+  }
+  return false
+}

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)
+  })
+})