@pascal-app/editor 0.8.0 → 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-move-ghosts.ts

@@ -0,0 +1,36 @@
+import { create } from 'zustand'
+
+/**
+ * Ephemeral preview state for wall move's bridge walls.
+ *
+ * When the user drags a wall whose corner neighbours are off-axis to
+ * the move direction, the junction planner emits a `bridgePlan` for
+ * each — a new wall that would be inserted between the original and
+ * new corner on commit. The 3D `MoveWallTool` already renders these
+ * as translucent ghost meshes mid-drag; the 2D `wallFloorplanMoveTarget`
+ * writes here so the floor-plan SVG layer can render the same hint.
+ *
+ * Writer: `packages/nodes/src/wall/floorplan-move.ts` (on each `apply`,
+ * cleared on `commit` and by the move overlay's cleanup).
+ * Reader: `packages/editor/src/components/editor-2d/floorplan-wall-move-ghost-layer.tsx`.
+ */
+export type WallMoveGhostBridge = {
+  id: string
+  start: [number, number]
+  end: [number, number]
+  /** Plan-space thickness already passed through `getFloorplanWallThickness`. */
+  thickness: number
+  color: string
+}
+
+type WallMoveGhostsState = {
+  bridges: WallMoveGhostBridge[]
+  setBridges: (bridges: WallMoveGhostBridge[]) => void
+  clear: () => void
+}
+
+export const useWallMoveGhosts = create<WallMoveGhostsState>((set) => ({
+  bridges: [],
+  setBridges: (bridges) => set({ bridges }),
+  clear: () => set({ bridges: [] }),
+}))

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

@@ -0,0 +1,34 @@
+// Ephemeral store for the "magnetic" wall-snap beacon shown during wall
+// drafting. The wall tool writes the active snap point on pointermove when
+// the draft endpoint locks onto existing wall geometry (a corner or a point
+// along a wall); the 3D beacon layer subscribes and draws a vertical marker
+// there. Cleared on commit, cancel, and unmount — same lifecycle as
+// `use-alignment-guides`.
+
+import { create } from 'zustand'
+
+/** Which kind of wall geometry the draft point snapped to. */
+export type WallSnapKind = 'endpoint' | 'midpoint' | 'intersection' | 'wall'
+
+export type WallSnapPoint = {
+  /** Building-local plan coordinates (XZ meters). */
+  x: number
+  z: number
+  kind: WallSnapKind
+  /** Optional wall ids whose geometry produced this snap. */
+  wallIds?: string[]
+}
+
+type WallSnapIndicatorState = {
+  point: WallSnapPoint | null
+  set(point: WallSnapPoint | null): void
+  clear(): void
+}
+
+const useWallSnapIndicator = create<WallSnapIndicatorState>((set) => ({
+  point: null,
+  set: (point) => set({ point }),
+  clear: () => set({ point: null }),
+}))
+
+export default useWallSnapIndicator