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

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

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

@@ -0,0 +1,77 @@
+import type { QuickMeasurementReport } from '@pascal-app/core'
+import { create } from 'zustand'
+import type { ViewMode } from './use-editor'
+
+export type QuickMeasurementHudSource = '2d' | '3d'
+
+export type QuickMeasurementHudEntry = {
+  lensState: 'live' | 'pinned'
+  report: QuickMeasurementReport
+}
+
+export type QuickMeasurementHudState = {
+  activeSource: QuickMeasurementHudSource | null
+  sources: Record<QuickMeasurementHudSource, QuickMeasurementHudEntry | null>
+  activate(source: QuickMeasurementHudSource): void
+  clear(source: QuickMeasurementHudSource): void
+  publish(source: QuickMeasurementHudSource, entry: QuickMeasurementHudEntry | null): void
+}
+
+export const useQuickMeasurementHud = create<QuickMeasurementHudState>((set) => ({
+  activeSource: null,
+  sources: { '2d': null, '3d': null },
+  activate: (source) =>
+    set((state) => (state.activeSource === source ? state : { activeSource: source })),
+  clear: (source) =>
+    set((state) => {
+      if (state.sources[source] === null && state.activeSource !== source) return state
+      const sibling = source === '2d' ? '3d' : '2d'
+      return {
+        activeSource:
+          state.activeSource === source
+            ? state.sources[sibling]
+              ? sibling
+              : null
+            : state.activeSource,
+        sources: { ...state.sources, [source]: null },
+      }
+    }),
+  publish: (source, entry) =>
+    set((state) => {
+      const current = state.sources[source]
+      if (
+        current?.report === entry?.report &&
+        current?.lensState === entry?.lensState &&
+        Boolean(current) === Boolean(entry)
+      ) {
+        return state
+      }
+      return {
+        activeSource: state.activeSource ?? (entry ? source : null),
+        sources: { ...state.sources, [source]: entry },
+      }
+    }),
+}))
+
+export function selectQuickMeasurementHudEntry(
+  state: QuickMeasurementHudState,
+  viewMode: ViewMode,
+): QuickMeasurementHudEntry | null {
+  const source = viewMode === 'split' ? state.activeSource : viewMode
+  return source ? state.sources[source] : null
+}
+
+export function activateQuickMeasurementHudSource(source: QuickMeasurementHudSource) {
+  useQuickMeasurementHud.getState().activate(source)
+}
+
+export function publishQuickMeasurementHudSource(
+  source: QuickMeasurementHudSource,
+  entry: QuickMeasurementHudEntry | null,
+) {
+  useQuickMeasurementHud.getState().publish(source, entry)
+}
+
+export function clearQuickMeasurementHudSource(source: QuickMeasurementHudSource) {
+  useQuickMeasurementHud.getState().clear(source)
+}

package/src/store/use-segment-draft-chain.ts

@@ -0,0 +1,28 @@
+// Ephemeral store for the wall / fence tools' click-chaining start points.
+// The 3D tools (`@pascal-app/nodes` wall/tool.tsx, fence/tool.tsx) own node
+// creation for both views; after each chained commit they publish the
+// created segment's resolved end here so the 2D floor-plan draft chains its
+// next segment from the same point instead of re-deriving it through a
+// different snap pipeline. Cleared on cancel, single-segment commit, and
+// unmount — never persisted, never in undo history.
+
+import { create } from 'zustand'
+import type { WallPlanPoint } from '../components/tools/wall/wall-snap-geometry'
+
+type SegmentKind = 'wall' | 'fence'
+
+type SegmentDraftChainState = {
+  wall: WallPlanPoint | null
+  fence: WallPlanPoint | null
+  setChainStart(kind: SegmentKind, point: WallPlanPoint | null): void
+  clear(kind: SegmentKind): void
+}
+
+const useSegmentDraftChain = create<SegmentDraftChainState>((set) => ({
+  wall: null,
+  fence: null,
+  setChainStart: (kind, point) => set({ [kind]: point }),
+  clear: (kind) => set({ [kind]: null }),
+}))
+
+export default useSegmentDraftChain

package/src/store/use-stair-build-preview.ts

@@ -0,0 +1,53 @@
+// Ephemeral store for the stair tool's 2D floor-plan build preview. The stair
+// tool's snapped cursor point + rotation publish here on each `grid:move` / R-T
+// rotate; the floor-plan stair preview layer subscribes and renders the ghost
+// staircase. This mirrors how `usePlacementPreview` keeps column / elevator
+// placement smooth: the preview lives OUTSIDE `FloorplanPanel`, so a per-move
+// update re-renders only the tiny preview layer, not the (expensive) panel.
+//
+// Editor-only, same rationale as `usePlacementPreview`. Producers clear on
+// tool-inactive, commit, and unmount.
+
+import { create } from 'zustand'
+
+export type StairPreviewPoint = [number, number]
+
+type StairBuildPreviewState = {
+  /** Snapped plan-XZ point the ghost staircase sits at; `null` when idle. */
+  point: StairPreviewPoint | null
+  /** Yaw (radians), cycled by R / T. */
+  rotation: number
+  /** Set the snapped point. No-ops (skips the store update, so subscribers
+   *  don't re-render) when the point is unchanged — `grid:move` fires far more
+   *  often than the snapped cell actually changes. */
+  setPoint(point: StairPreviewPoint | null): void
+  setPreview(point: StairPreviewPoint | null, rotation: number): void
+  rotateBy(deltaRadians: number): void
+  reset(): void
+}
+
+export const useStairBuildPreview = create<StairBuildPreviewState>((set) => ({
+  point: null,
+  rotation: 0,
+  setPoint: (point) =>
+    set((state) => {
+      const prev = state.point
+      if (!point && !prev) return state
+      if (point && prev && prev[0] === point[0] && prev[1] === point[1]) return state
+      return { point: point ? [point[0], point[1]] : null }
+    }),
+  setPreview: (point, rotation) =>
+    set((state) => {
+      const samePoint =
+        (!point && !state.point) ||
+        Boolean(point && state.point && state.point[0] === point[0] && state.point[1] === point[1])
+      return samePoint && state.rotation === rotation
+        ? state
+        : { point: point ? [point[0], point[1]] : null, rotation }
+    }),
+  rotateBy: (deltaRadians) => set((state) => ({ rotation: state.rotation + deltaRadians })),
+  reset: () =>
+    set((state) =>
+      state.point === null && state.rotation === 0 ? state : { point: null, rotation: 0 },
+    ),
+}))

package/src/store/use-wall-snap-indicator.ts

@@ -15,6 +15,8 @@ export type WallSnapPoint = {
   x: number
   z: number
   kind: WallSnapKind
+  /** Optional wall ids whose geometry produced this snap. */
+  wallIds?: string[]
 }
 
 type WallSnapIndicatorState = {