@pascal-app/editor 0.9.1 → 1.0.0-beta.1

package/src/lib/quick-action-nodes.test.ts

@@ -0,0 +1,94 @@
+import { describe, expect, test } from 'bun:test'
+import type { AnyNode, AnyNodeId } from '@pascal-app/core'
+import { collectQuickActionNodeScope } from './quick-action-nodes'
+
+function fixtureNode({
+  id,
+  parentId,
+  children = [],
+  type = 'item',
+}: {
+  id: string
+  parentId?: string
+  children?: string[]
+  type?: string
+}) {
+  return {
+    id,
+    type,
+    parentId,
+    children,
+  } as unknown as AnyNode
+}
+
+describe('collectQuickActionNodeScope', () => {
+  test('includes nested children of a selected node sibling', () => {
+    const run = fixtureNode({
+      id: 'run',
+      children: ['left-base', 'selected-base'],
+    })
+    const leftBase = fixtureNode({
+      id: 'left-base',
+      parentId: run.id,
+      children: ['expanded-wall'],
+    })
+    const selectedBase = fixtureNode({ id: 'selected-base', parentId: run.id })
+    const expandedWall = fixtureNode({ id: 'expanded-wall', parentId: leftBase.id })
+    const nodes = Object.fromEntries(
+      [run, leftBase, selectedBase, expandedWall].map((node) => [node.id, node]),
+    ) as Record<AnyNodeId, AnyNode>
+
+    const collected = collectQuickActionNodeScope(nodes, selectedBase.id)
+
+    expect(collected?.[expandedWall.id as AnyNodeId]).toBe(expandedWall)
+  })
+
+  test('includes other run subtrees when the provider declares level scope', () => {
+    const level = fixtureNode({
+      id: 'level',
+      type: 'level',
+      children: ['selected-run', 'other-run'],
+    })
+    const selectedRun = fixtureNode({
+      id: 'selected-run',
+      parentId: level.id,
+      children: ['selected-base'],
+    })
+    const selectedBase = fixtureNode({ id: 'selected-base', parentId: selectedRun.id })
+    const otherRun = fixtureNode({
+      id: 'other-run',
+      parentId: level.id,
+      children: ['other-base'],
+    })
+    const otherBase = fixtureNode({
+      id: 'other-base',
+      parentId: otherRun.id,
+      children: ['expanded-wall'],
+    })
+    const expandedWall = fixtureNode({ id: 'expanded-wall', parentId: otherBase.id })
+    const nodes = Object.fromEntries(
+      [level, selectedRun, selectedBase, otherRun, otherBase, expandedWall].map((node) => [
+        node.id,
+        node,
+      ]),
+    ) as Record<AnyNodeId, AnyNode>
+
+    expect(
+      collectQuickActionNodeScope(nodes, selectedBase.id)?.[expandedWall.id as AnyNodeId],
+    ).toBeUndefined()
+    expect(
+      collectQuickActionNodeScope(nodes, selectedBase.id, 'level')?.[expandedWall.id as AnyNodeId],
+    ).toBe(expandedWall)
+  })
+
+  test('fails closed when a level-scoped provider has no level ancestor', () => {
+    const run = fixtureNode({ id: 'run', children: ['selected-base'] })
+    const selectedBase = fixtureNode({ id: 'selected-base', parentId: run.id })
+    const nodes = Object.fromEntries([run, selectedBase].map((node) => [node.id, node])) as Record<
+      AnyNodeId,
+      AnyNode
+    >
+
+    expect(collectQuickActionNodeScope(nodes, selectedBase.id, 'level')).toBeNull()
+  })
+})

package/src/lib/quick-action-nodes.ts

@@ -0,0 +1,47 @@
+import type { AnyNode, AnyNodeId, NodeQuickActionNodeScope } from '@pascal-app/core'
+
+export function collectQuickActionNodeScope(
+  nodes: Record<AnyNodeId, AnyNode>,
+  selectedId: string,
+  scope: NodeQuickActionNodeScope = 'family',
+): Record<AnyNodeId, AnyNode> | null {
+  const selected = nodes[selectedId as AnyNodeId]
+  if (!selected) return null
+
+  const collected: Record<AnyNodeId, AnyNode> = {}
+  const addSubtree = (rootId: string | null | undefined) => {
+    if (!rootId) return
+    const pending = [rootId]
+
+    while (pending.length > 0) {
+      const id = pending.pop()
+      if (!id || collected[id as AnyNodeId]) continue
+      const node = nodes[id as AnyNodeId]
+      if (!node) continue
+
+      collected[node.id as AnyNodeId] = node
+      for (const childId of (node as { children?: readonly string[] }).children ?? []) {
+        pending.push(childId)
+      }
+    }
+  }
+
+  if (scope === 'level') {
+    const visited = new Set<AnyNodeId>()
+    let current: AnyNode | undefined = selected
+    while (current && !visited.has(current.id as AnyNodeId)) {
+      visited.add(current.id as AnyNodeId)
+      if (current.type === 'level') {
+        addSubtree(current.id)
+        return collected
+      }
+      current = current.parentId ? nodes[current.parentId as AnyNodeId] : undefined
+    }
+    return null
+  }
+
+  addSubtree(selected.id)
+  addSubtree(selected.parentId)
+
+  return collected
+}

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