@pascal-app/editor 0.9.1 → 0.9.2

package/src/store/use-measurement-draft.ts

@@ -0,0 +1,543 @@
+'use client'
+
+import {
+  areMeasurementPointsCoplanar,
+  MEASUREMENT_PLANAR_TOLERANCE,
+  type MeasurementAnchor,
+  type MeasurementFeatureAnchor,
+  MeasurementNode,
+  type MeasurementSnapKind,
+  measurementNormal,
+  useScene,
+} from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
+import { create } from 'zustand'
+
+export type MeasurementKind = 'distance' | 'angle' | 'area' | 'perimeter' | 'volume'
+export type MeasurementDraftOwner = '2d' | '3d'
+export type MeasurementDraftStage = 'collecting' | 'extruding' | 'ready'
+export type MeasurementAxis = 'x' | 'y' | 'z'
+export type MeasurementPoint = [number, number, number]
+
+export type MeasurementAxisGuide = {
+  axis: MeasurementAxis
+  from: MeasurementPoint
+  to: MeasurementPoint
+  snapped: boolean
+  proximity?: boolean
+}
+
+export type MeasurementSurfacePoint = {
+  point: MeasurementPoint
+  normal: MeasurementPoint
+  targetNodeId: string | null
+  anchor?: MeasurementFeatureAnchor
+  semantic?: {
+    label: string
+    length: number | null
+    snapKind: MeasurementSnapKind
+  }
+}
+
+export type MeasurementVertexDrag = {
+  owner: MeasurementDraftOwner
+  index: number
+  originalPoint: MeasurementPoint
+  originalAnchor: MeasurementFeatureAnchor | null
+  inserted: boolean
+}
+
+export type MeasurementDraftPayload =
+  | { kind: 'distance'; points: [MeasurementAnchor, MeasurementAnchor] }
+  | { kind: 'angle'; points: [MeasurementAnchor, MeasurementAnchor, MeasurementAnchor] }
+  | { kind: 'area'; base: MeasurementAnchor[] }
+  | { kind: 'perimeter'; base: MeasurementAnchor[] }
+  | { kind: 'volume'; base: MeasurementAnchor[]; extrusion: MeasurementPoint }
+
+type MeasurementDraftState = {
+  kind: MeasurementKind
+  owner: MeasurementDraftOwner | null
+  levelId: string | null
+  stage: MeasurementDraftStage
+  points: MeasurementPoint[]
+  anchors: Array<MeasurementFeatureAnchor | null>
+  hover: MeasurementSurfacePoint | null
+  hoverOwner: MeasurementDraftOwner | null
+  axisGuide: MeasurementAxisGuide | null
+  vertexDrag: MeasurementVertexDrag | null
+  collectionPlane: { point: MeasurementPoint; normal: MeasurementPoint } | null
+  baseNormal: MeasurementPoint | null
+  extrusionHeight: number
+  error: string | null
+  setKind(kind: MeasurementKind): void
+  setHover(
+    owner: MeasurementDraftOwner,
+    hover: MeasurementSurfacePoint | null,
+    axisGuide?: MeasurementAxisGuide | null,
+  ): void
+  beginVertexDrag(owner: MeasurementDraftOwner, index: number): boolean
+  beginMidpointVertexDrag(owner: MeasurementDraftOwner, edgeIndex: number): boolean
+  updateDraggedVertex(
+    owner: MeasurementDraftOwner,
+    hover: MeasurementSurfacePoint,
+    axisGuide?: MeasurementAxisGuide | null,
+  ): boolean
+  finishVertexDrag(owner: MeasurementDraftOwner): boolean
+  cancelVertexDrag(owner: MeasurementDraftOwner): boolean
+  addPoint(
+    owner: MeasurementDraftOwner,
+    point: MeasurementPoint,
+    anchor?: MeasurementFeatureAnchor,
+    surfaceNormal?: MeasurementPoint,
+  ): boolean
+  closeBase(owner: MeasurementDraftOwner, preferredNormal?: MeasurementPoint): boolean
+  setExtrusionHeight(owner: MeasurementDraftOwner, height: number): boolean
+  finishExtrusion(owner: MeasurementDraftOwner): boolean
+  removeLast(owner: MeasurementDraftOwner): boolean
+  getCommitPayload(owner: MeasurementDraftOwner): MeasurementDraftPayload | null
+  reset(): void
+}
+
+const MIN_EXTRUSION = 0.001
+
+const clonePoint = (point: MeasurementPoint): MeasurementPoint => [...point]
+
+function normalizePoint(point: MeasurementPoint | undefined): MeasurementPoint | null {
+  if (!point?.every(Number.isFinite)) return null
+  const length = Math.hypot(...point)
+  return length > 1e-9 ? [point[0] / length, point[1] / length, point[2] / length] : null
+}
+
+export function measurementPolygonMidpoints(
+  points: readonly MeasurementPoint[],
+): Array<{ edgeIndex: number; point: MeasurementPoint }> {
+  if (points.length < 3) return []
+  return points.map((start, edgeIndex) => {
+    const end = points[(edgeIndex + 1) % points.length]!
+    return {
+      edgeIndex,
+      point: [(start[0] + end[0]) / 2, (start[1] + end[1]) / 2, (start[2] + end[2]) / 2],
+    }
+  })
+}
+
+function idleState(kind: MeasurementKind) {
+  return {
+    kind,
+    owner: null,
+    levelId: null,
+    stage: 'collecting' as const,
+    points: [],
+    anchors: [],
+    hover: null,
+    hoverOwner: null,
+    axisGuide: null,
+    vertexDrag: null,
+    collectionPlane: null,
+    baseNormal: null,
+    extrusionHeight: 0,
+    error: null,
+  }
+}
+
+function payloadFor(state: MeasurementDraftState): MeasurementDraftPayload | null {
+  if (state.stage !== 'ready') return null
+
+  const anchorAt = (index: number): MeasurementAnchor =>
+    state.anchors[index] ?? clonePoint(state.points[index]!)
+
+  if (state.kind === 'distance') {
+    const [start, end] = state.points
+    if (!(start && end)) return null
+    return { kind: 'distance', points: [anchorAt(0), anchorAt(1)] }
+  }
+
+  if (state.kind === 'angle') {
+    if (state.points.length !== 3) return null
+    return { kind: 'angle', points: [anchorAt(0), anchorAt(1), anchorAt(2)] }
+  }
+
+  if (state.kind === 'area' || state.kind === 'perimeter') {
+    if (state.points.length < 3) return null
+    return { kind: state.kind, base: state.points.map((_, index) => anchorAt(index)) }
+  }
+
+  if (!(state.baseNormal && state.points.length >= 3)) return null
+  return {
+    kind: 'volume',
+    base: state.points.map((_, index) => anchorAt(index)),
+    extrusion: [
+      state.baseNormal[0] * state.extrusionHeight,
+      state.baseNormal[1] * state.extrusionHeight,
+      state.baseNormal[2] * state.extrusionHeight,
+    ],
+  }
+}
+
+export const useMeasurementDraft = create<MeasurementDraftState>((set, get) => ({
+  ...idleState('distance'),
+
+  setKind: (kind) => set((state) => (state.kind === kind ? state : { ...idleState(kind) })),
+
+  setHover: (owner, hover, axisGuide = null) =>
+    set((state) => {
+      if (state.owner && state.owner !== owner) return state
+      if (state.levelId && state.levelId !== useViewer.getState().selection.levelId) return state
+      if (state.vertexDrag) return state
+      if (!hover && !state.hover && !state.axisGuide) return state
+      return { hover, hoverOwner: hover ? owner : null, axisGuide }
+    }),
+
+  beginVertexDrag: (owner, index) => {
+    const state = get()
+    const point = state.points[index]
+    if (
+      state.owner !== owner ||
+      state.levelId !== useViewer.getState().selection.levelId ||
+      state.stage !== 'collecting' ||
+      state.vertexDrag ||
+      !Number.isInteger(index) ||
+      !point
+    ) {
+      return false
+    }
+
+    set({
+      vertexDrag: {
+        owner,
+        index,
+        originalPoint: clonePoint(point),
+        originalAnchor: state.anchors[index] ?? null,
+        inserted: false,
+      },
+      hover: null,
+      hoverOwner: null,
+      axisGuide: null,
+      error: null,
+    })
+    return true
+  },
+
+  beginMidpointVertexDrag: (owner, edgeIndex) => {
+    const state = get()
+    if (
+      state.owner !== owner ||
+      state.levelId !== useViewer.getState().selection.levelId ||
+      state.stage !== 'collecting' ||
+      state.vertexDrag ||
+      state.kind === 'distance' ||
+      state.kind === 'angle' ||
+      state.points.length < 3 ||
+      !Number.isInteger(edgeIndex) ||
+      edgeIndex < 0 ||
+      edgeIndex >= state.points.length
+    ) {
+      return false
+    }
+
+    const start = state.points[edgeIndex]!
+    const end = state.points[(edgeIndex + 1) % state.points.length]!
+    const midpoint: MeasurementPoint = [
+      (start[0] + end[0]) / 2,
+      (start[1] + end[1]) / 2,
+      (start[2] + end[2]) / 2,
+    ]
+    const index = edgeIndex + 1
+    const points = [...state.points.slice(0, index), midpoint, ...state.points.slice(index)]
+    const anchors = [...state.anchors.slice(0, index), null, ...state.anchors.slice(index)]
+
+    set({
+      points,
+      anchors,
+      vertexDrag: {
+        owner,
+        index,
+        originalPoint: clonePoint(midpoint),
+        originalAnchor: null,
+        inserted: true,
+      },
+      hover: null,
+      hoverOwner: null,
+      axisGuide: null,
+      error: null,
+    })
+    return true
+  },
+
+  updateDraggedVertex: (owner, hover, axisGuide = null) => {
+    const state = get()
+    const drag = state.vertexDrag
+    if (
+      !drag ||
+      drag.owner !== owner ||
+      state.levelId !== useViewer.getState().selection.levelId ||
+      state.stage !== 'collecting' ||
+      ![...hover.point, ...hover.normal].every(Number.isFinite)
+    ) {
+      return false
+    }
+
+    const points = state.points.map((point, index) =>
+      index === drag.index ? clonePoint(hover.point) : point,
+    )
+    const anchors = state.anchors.map((anchor, index) =>
+      index === drag.index ? (hover.anchor ?? null) : anchor,
+    )
+    set({
+      points,
+      anchors,
+      hover: {
+        point: clonePoint(hover.point),
+        normal: clonePoint(hover.normal),
+        targetNodeId: hover.targetNodeId,
+        anchor: hover.anchor,
+        semantic: hover.semantic,
+      },
+      hoverOwner: owner,
+      axisGuide: axisGuide
+        ? {
+            axis: axisGuide.axis,
+            from: clonePoint(axisGuide.from),
+            to: clonePoint(axisGuide.to),
+            snapped: axisGuide.snapped,
+            proximity: axisGuide.proximity,
+          }
+        : null,
+      error: null,
+    })
+    return true
+  },
+
+  finishVertexDrag: (owner) => {
+    const drag = get().vertexDrag
+    if (!drag || drag.owner !== owner) return false
+    set({ vertexDrag: null, hover: null, hoverOwner: null, axisGuide: null, error: null })
+    return true
+  },
+
+  cancelVertexDrag: (owner) => {
+    const state = get()
+    const drag = state.vertexDrag
+    if (!drag || drag.owner !== owner) return false
+    const points = drag.inserted
+      ? state.points.filter((_, index) => index !== drag.index)
+      : state.points.map((point, index) =>
+          index === drag.index ? clonePoint(drag.originalPoint) : point,
+        )
+    const anchors = drag.inserted
+      ? state.anchors.filter((_, index) => index !== drag.index)
+      : state.anchors.map((anchor, index) => (index === drag.index ? drag.originalAnchor : anchor))
+    set({
+      points,
+      anchors,
+      vertexDrag: null,
+      hover: null,
+      hoverOwner: null,
+      axisGuide: null,
+      error: null,
+    })
+    return true
+  },
+
+  addPoint: (owner, point, anchor, surfaceNormal) => {
+    const state = get()
+    const activeLevelId = useViewer.getState().selection.levelId
+    if (!activeLevelId) return false
+    if (state.stage !== 'collecting' || state.vertexDrag || (state.owner && state.owner !== owner))
+      return false
+    if (state.levelId && state.levelId !== activeLevelId) {
+      set({ error: 'The active level changed. Start a new measurement.' })
+      return false
+    }
+    if (state.kind === 'distance' && state.points.length >= 2) return false
+    if (state.kind === 'angle' && state.points.length >= 3) return false
+
+    const points = [...state.points, clonePoint(point)]
+    const anchors = [...state.anchors, anchor ?? null]
+    const polygon = state.kind === 'area' || state.kind === 'perimeter' || state.kind === 'volume'
+    const planeNormal = polygon && state.points.length === 0 ? normalizePoint(surfaceNormal) : null
+    const ready =
+      (state.kind === 'distance' && points.length === 2) ||
+      (state.kind === 'angle' && points.length === 3)
+    set({
+      owner,
+      levelId: state.levelId ?? activeLevelId,
+      points,
+      anchors,
+      collectionPlane: planeNormal
+        ? { point: clonePoint(point), normal: planeNormal }
+        : state.collectionPlane,
+      stage: ready ? 'ready' : 'collecting',
+      hover: null,
+      hoverOwner: null,
+      axisGuide: null,
+      error: null,
+    })
+    return true
+  },
+
+  closeBase: (owner, preferredNormal) => {
+    const state = get()
+    if (
+      state.owner !== owner ||
+      state.levelId !== useViewer.getState().selection.levelId ||
+      state.stage !== 'collecting' ||
+      state.vertexDrag ||
+      state.kind === 'distance' ||
+      state.kind === 'angle' ||
+      state.points.length < 3
+    ) {
+      return false
+    }
+
+    if (!areMeasurementPointsCoplanar(state.points, MEASUREMENT_PLANAR_TOLERANCE)) {
+      set({ error: 'Measurement points must be on one plane.' })
+      return false
+    }
+
+    let normal = measurementNormal(state.points)
+    if (!normal) {
+      set({ error: 'Measurement points must enclose an area.' })
+      return false
+    }
+    if (
+      preferredNormal &&
+      normal[0] * preferredNormal[0] +
+        normal[1] * preferredNormal[1] +
+        normal[2] * preferredNormal[2] <
+        0
+    ) {
+      normal = [
+        normal[0] === 0 ? 0 : -normal[0],
+        normal[1] === 0 ? 0 : -normal[1],
+        normal[2] === 0 ? 0 : -normal[2],
+      ]
+    }
+
+    set({
+      baseNormal: clonePoint(normal),
+      stage: state.kind === 'volume' ? 'extruding' : 'ready',
+      hover: null,
+      hoverOwner: null,
+      axisGuide: null,
+      error: null,
+    })
+    return true
+  },
+
+  setExtrusionHeight: (owner, height) => {
+    const state = get()
+    if (
+      state.owner !== owner ||
+      state.levelId !== useViewer.getState().selection.levelId ||
+      state.stage !== 'extruding' ||
+      !Number.isFinite(height)
+    ) {
+      return false
+    }
+    set({ extrusionHeight: height, error: null })
+    return true
+  },
+
+  finishExtrusion: (owner) => {
+    const state = get()
+    if (
+      state.owner !== owner ||
+      state.levelId !== useViewer.getState().selection.levelId ||
+      state.stage !== 'extruding' ||
+      Math.abs(state.extrusionHeight) < MIN_EXTRUSION
+    ) {
+      return false
+    }
+    set({ stage: 'ready', hover: null, hoverOwner: null, axisGuide: null, error: null })
+    return true
+  },
+
+  removeLast: (owner) => {
+    const state = get()
+    if (
+      state.owner !== owner ||
+      state.levelId !== useViewer.getState().selection.levelId ||
+      state.vertexDrag ||
+      state.points.length === 0
+    ) {
+      return false
+    }
+
+    const points = state.points.slice(0, -1)
+    const anchors = state.anchors.slice(0, -1)
+    set({
+      owner: points.length > 0 ? owner : null,
+      levelId: points.length > 0 ? state.levelId : null,
+      stage: 'collecting',
+      points,
+      anchors,
+      hover: null,
+      hoverOwner: null,
+      axisGuide: null,
+      collectionPlane: points.length > 0 ? state.collectionPlane : null,
+      baseNormal: null,
+      extrusionHeight: 0,
+      error: null,
+    })
+    return true
+  },
+
+  getCommitPayload: (owner) => {
+    const state = get()
+    return state.owner === owner && state.levelId === useViewer.getState().selection.levelId
+      ? payloadFor(state)
+      : null
+  },
+
+  reset: () => set((state) => ({ ...idleState(state.kind) })),
+}))
+
+export function commitMeasurementDraft(owner: MeasurementDraftOwner): MeasurementNode['id'] | null {
+  const draft = useMeasurementDraft.getState()
+  const levelId = draft.levelId
+  if (!levelId || useViewer.getState().selection.levelId !== levelId) {
+    draft.reset()
+    return null
+  }
+  const measurement = draft.getCommitPayload(owner)
+  if (!measurement) return null
+
+  const { createNode, nodes } = useScene.getState()
+  const count = Object.values(nodes).filter((node) => node.type === 'measurement').length
+  const node = MeasurementNode.parse({ name: `Measurement ${count + 1}`, measurement })
+  createNode(node, levelId)
+  draft.reset()
+  return node.id
+}
+
+export function finishMeasurementDraft(
+  owner: MeasurementDraftOwner,
+  preferredNormal?: MeasurementPoint,
+): boolean {
+  const draft = useMeasurementDraft.getState()
+  if (draft.stage === 'collecting') {
+    if (draft.kind === 'distance' || draft.kind === 'angle') return false
+    if (!draft.closeBase(owner, preferredNormal)) return false
+    if (draft.kind === 'area' || draft.kind === 'perimeter') {
+      return commitMeasurementDraft(owner) !== null
+    }
+    return true
+  }
+  if (draft.stage === 'extruding') {
+    if (!draft.finishExtrusion(owner)) return false
+  }
+  return commitMeasurementDraft(owner) !== null
+}
+
+export function handleMeasurementDraftEscape(
+  owner: MeasurementDraftOwner,
+  preferredNormal?: MeasurementPoint,
+): boolean {
+  const draft = useMeasurementDraft.getState()
+  if (draft.owner !== owner) return false
+
+  const preserveArea = draft.kind === 'area' && draft.points.length >= 3
+  if (!finishMeasurementDraft(owner, preferredNormal) && !preserveArea) draft.reset()
+  return true
+}

package/src/store/use-opening-guides.ts

@@ -0,0 +1,41 @@
+// Ephemeral store for the 3D opening proximity/alignment guides published by the
+// door/window move + placement tools during a drag — the wall-plane counterpart
+// of `useAlignmentGuides` (which only carries floor-plane XZ guides). Guides are
+// already transformed into the move tool's render frame — the same building-local
+// frame as the drag cursor (ToolManager's group) — so the renderer stays dumb.
+// Producers clear on commit, cancel, leave, and unmount.
+
+import { create } from 'zustand'
+
+export type OpeningGuideVec3 = [number, number, number]
+
+// A stable identity per guide slot (`sill`, `head`, `gap:left`, `vertical`,
+// `spacing:0`, …) so the renderer can key by semantic role: as the guide set
+// churns each drag tick, a slot that persists keeps its React element — and its
+// drei `<Html>` portal — mounted instead of remounting when the list shape
+// shifts under index keys.
+export type OpeningGuide3D =
+  // A measured line + distance pill: sill (floor → bottom edge), head (top edge
+  // → wall top), or along-wall edge-to-edge proximity.
+  | { kind: 'dimension'; id: string; from: OpeningGuideVec3; to: OpeningGuideVec3; value: number }
+  // A dashed line connecting two openings that share a sill / centre / top.
+  | { kind: 'align-line'; id: string; from: OpeningGuideVec3; to: OpeningGuideVec3 }
+  // A Figma-style "=" badge marking one gap in an equal-spacing run.
+  | { kind: 'badge'; id: string; at: OpeningGuideVec3; value: number }
+
+type OpeningGuidesState = {
+  guides: OpeningGuide3D[]
+  set(guides: OpeningGuide3D[]): void
+  clear(): void
+}
+
+const useOpeningGuides = create<OpeningGuidesState>((set) => ({
+  guides: [],
+  set: (guides) => set({ guides }),
+  // No-op when already empty so the common no-guide hover frame (fallback
+  // cursor, invalid target, roof hover) doesn't push a fresh `[]` and notify
+  // subscribers — the layer would re-render to the same nothing every tick.
+  clear: () => set((s) => (s.guides.length > 0 ? { guides: [] } : s)),
+}))
+
+export default useOpeningGuides

package/src/store/use-placement-preview.ts

@@ -18,14 +18,22 @@ type PlacementPreviewState = {
   /** Transient preview node, already positioned + rotated at the (snapped,
    *  aligned) cursor. `null` when no placement is active. */
   node: AnyNode | null
-  set(node: AnyNode | null): void
+  /** Optional synthetic parent for the preview's `def.floorplan` context.
+   *  Door / window glyph builders need `ctx.parent` to be a wall to draw their
+   *  real symbol (swing arc / panes); off any real wall we hand them a
+   *  synthetic wall segment centred at the cursor so the floating ghost shows
+   *  the faithful blueprint symbol instead of a bare rectangle. `null` for
+   *  self-contained kinds (column / elevator). */
+  parentNode: AnyNode | null
+  set(node: AnyNode | null, parentNode?: AnyNode | null): void
   clear(): void
 }
 
 const usePlacementPreview = create<PlacementPreviewState>((set) => ({
   node: null,
-  set: (node) => set({ node }),
-  clear: () => set({ node: null }),
+  parentNode: null,
+  set: (node, parentNode = null) => set({ node, parentNode }),
+  clear: () => set({ node: null, parentNode: null }),
 }))
 
 export default usePlacementPreview

package/src/store/use-quick-measurement-hud.test.ts

@@ -0,0 +1,53 @@
+import { afterEach, describe, expect, test } from 'bun:test'
+import type { QuickMeasurementReport } from '@pascal-app/core'
+import { selectQuickMeasurementHudEntry, useQuickMeasurementHud } from './use-quick-measurement-hud'
+
+const report = (title: string): QuickMeasurementReport => ({
+  title,
+  kindLabel: 'Wall',
+  anchor: [0, 0, 0],
+  metrics: [],
+})
+
+afterEach(() => {
+  useQuickMeasurementHud.setState({
+    activeSource: null,
+    sources: { '2d': null, '3d': null },
+  })
+})
+
+describe('quick measurement HUD ownership', () => {
+  test('uses one active source across split view while single views stay pinned to their pane', () => {
+    const twoDimensional = { lensState: 'live' as const, report: report('2D wall') }
+    const threeDimensional = { lensState: 'pinned' as const, report: report('3D wall') }
+    const store = useQuickMeasurementHud.getState()
+    store.publish('2d', twoDimensional)
+    store.publish('3d', threeDimensional)
+
+    expect(selectQuickMeasurementHudEntry(useQuickMeasurementHud.getState(), 'split')).toBe(
+      twoDimensional,
+    )
+    store.activate('3d')
+    expect(selectQuickMeasurementHudEntry(useQuickMeasurementHud.getState(), 'split')).toBe(
+      threeDimensional,
+    )
+    expect(selectQuickMeasurementHudEntry(useQuickMeasurementHud.getState(), '2d')).toBe(
+      twoDimensional,
+    )
+    expect(selectQuickMeasurementHudEntry(useQuickMeasurementHud.getState(), '3d')).toBe(
+      threeDimensional,
+    )
+  })
+
+  test('falls back to the sibling only when the active source unmounts', () => {
+    const store = useQuickMeasurementHud.getState()
+    store.publish('2d', { lensState: 'pinned', report: report('2D wall') })
+    store.publish('3d', { lensState: 'live', report: report('3D wall') })
+    store.activate('3d')
+    store.clear('3d')
+
+    const state = useQuickMeasurementHud.getState()
+    expect(state.activeSource).toBe('2d')
+    expect(selectQuickMeasurementHudEntry(state, 'split')?.report.title).toBe('2D wall')
+  })
+})