@pascal-app/editor 0.8.0 → 0.9.2

package/src/lib/plugin-panels.ts

@@ -0,0 +1,91 @@
+import type { IconRef, LazyComponent } from '@pascal-app/core'
+
+export type EditorHostPanelWorkspace = string & {}
+
+export type EditorHostPanel = {
+  id: string
+  label: string
+  icon: IconRef
+  component: LazyComponent
+  kinds?: readonly string[]
+  workspaces?: readonly EditorHostPanelWorkspace[]
+  pluginId?: string
+  description?: string
+  creator?: {
+    name: string
+    url?: string
+  }
+  pluginUrl?: string
+  defaultInstalled?: boolean
+}
+
+function isDevMode(): boolean {
+  try {
+    const meta = import.meta as { env?: { DEV?: boolean } }
+    if (typeof meta?.env?.DEV === 'boolean') return meta.env.DEV
+  } catch {
+    // import.meta unavailable in some CJS contexts — fall through.
+  }
+  if (typeof process !== 'undefined' && process.env?.NODE_ENV) {
+    return process.env.NODE_ENV !== 'production'
+  }
+  return false
+}
+
+class EditorHostPanelRegistryImpl {
+  private readonly panels = new Map<string, EditorHostPanel>()
+  private readonly listeners = new Set<() => void>()
+  private cached: EditorHostPanel[] = []
+
+  subscribe = (onChange: () => void): (() => void) => {
+    this.listeners.add(onChange)
+    return () => {
+      this.listeners.delete(onChange)
+    }
+  }
+
+  getSnapshot = (): EditorHostPanel[] => this.cached
+
+  panelForKind = (kind: string): string | undefined =>
+    this.cached.find((panel) => panel.kinds?.includes(kind))?.id
+
+  getDefaultInstalledPluginIds = (): string[] =>
+    Array.from(
+      new Set(
+        this.cached
+          .filter((panel) => panel.pluginId && panel.defaultInstalled)
+          .map((panel) => panel.pluginId as string),
+      ),
+    )
+
+  reset(): void {
+    this.panels.clear()
+    this.emit()
+  }
+
+  registerPanel(panel: EditorHostPanel): void {
+    if (typeof panel.id !== 'string' || panel.id.length === 0) {
+      throw new Error('[editor:host-panels] panel id must be a non-empty string')
+    }
+    if (this.panels.has(panel.id)) {
+      if (isDevMode()) {
+        console.warn(`[editor:host-panels] re-registering panel "${panel.id}" (HMR)`)
+      } else {
+        throw new Error(`[editor:host-panels] duplicate panel id: "${panel.id}" already registered`)
+      }
+    }
+    this.panels.set(panel.id, panel)
+    this.emit()
+  }
+
+  private emit(): void {
+    this.cached = Array.from(this.panels.values())
+    for (const listener of this.listeners) listener()
+  }
+}
+
+export const editorHostPanelRegistry = new EditorHostPanelRegistryImpl()
+
+export function registerEditorHostPanel(panel: EditorHostPanel): void {
+  editorHostPanelRegistry.registerPanel(panel)
+}

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(
@@ -175,11 +175,11 @@ export function duplicateRoofSubtree(
 
 export function clearRoofDuplicateMetadata(
   roofId: AnyNodeId,
-  updates: Partial<Pick<RoofNode, 'position' | 'rotation' | 'metadata'>> = {},
+  updates: Partial<Pick<RoofNode, 'position' | 'rotation' | 'metadata' | 'visible'>> = {},
 ) {
   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
+}