@pascal-app/editor 0.9.1 → 0.9.2

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,43 @@
+// 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'
+
+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
+  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 }
+    }),
+  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 = {