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

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

@@ -0,0 +1,40 @@
+import { create } from 'zustand'
+
+export type ElevationGuide3D = {
+  ownerId: string
+  levelId: string
+  center: readonly [number, number]
+  direction: readonly [number, number]
+  elevation: number
+  label: string
+}
+
+type ElevationGuidesState = {
+  guide: ElevationGuide3D | null
+  publish(guide: ElevationGuide3D): void
+  clear(ownerId: string): void
+}
+
+const useElevationGuides = create<ElevationGuidesState>((set) => ({
+  guide: null,
+  publish: (guide) =>
+    set((state) => {
+      const current = state.guide
+      if (
+        current?.ownerId === guide.ownerId &&
+        current.levelId === guide.levelId &&
+        current.elevation === guide.elevation &&
+        current.label === guide.label &&
+        current.center[0] === guide.center[0] &&
+        current.center[1] === guide.center[1] &&
+        current.direction[0] === guide.direction[0] &&
+        current.direction[1] === guide.direction[1]
+      ) {
+        return state
+      }
+      return { guide }
+    }),
+  clear: (ownerId) => set((state) => (state.guide?.ownerId === ownerId ? { guide: null } : state)),
+}))
+
+export default useElevationGuides

package/src/store/use-facing-pose.ts

@@ -0,0 +1,44 @@
+// Ephemeral store for the forward-facing floor triangle shown while placing or
+// moving a node. A single editor-side overlay (`<FacingPoseIndicator>`)
+// subscribes and renders the triangle; every placement/move path publishes its
+// ghost pose here instead of drawing its own triangle. This is deliberately the
+// one renderer for the facing indicator: rendering it from inside a tool's own
+// cursor ghost (especially tools living in `@pascal-app/nodes`) left it
+// invisible, while the editor-side overlay renders reliably. Producers clear on
+// commit, cancel, and unmount.
+//
+// Poses are in the same building-local frame the tools already work in (the
+// overlay is mounted inside ToolManager's building-local group).
+
+import { create } from 'zustand'
+
+export type FacingPose = {
+  /** Ghost origin in building-local space. */
+  position: [number, number, number]
+  /** Ghost yaw (radians). The triangle inherits this so it points where the
+   *  node faces. */
+  rotationY: number
+  /** Footprint depth along the ghost's local +Z; the triangle sits just past
+   *  `center[1] + depth / 2`. */
+  depth: number
+  /** Footprint centre offset `[x, z]` in the ghost's local frame. Defaults to
+   *  the origin. Kinds whose forward edge isn't centred on the origin (e.g. a
+   *  stair, whose run starts at the entry) shift the triangle via this. */
+  center?: [number, number]
+  /** Point along local -Z (the front is the -Z side) instead of +Z. */
+  reversed?: boolean
+}
+
+type FacingPoseState = {
+  pose: FacingPose | null
+  set(pose: FacingPose): void
+  clear(): void
+}
+
+const useFacingPose = create<FacingPoseState>((set) => ({
+  pose: null,
+  set: (pose) => set({ pose }),
+  clear: () => set({ pose: null }),
+}))
+
+export default useFacingPose

package/src/store/use-fence-curve-draft.ts

@@ -0,0 +1,51 @@
+// Ephemeral store for the in-progress curved-fence draft. Written by the 3D
+// spline tool and read by the contextual helper plus out-of-tree consumers.
+// Reset on commit, cancel, and unmount — never persisted or recorded in undo
+// history.
+
+import { create } from 'zustand'
+
+export type FenceCurveDraftPoint = [number, number]
+
+type FenceCurveDraftState = {
+  pointCount: number
+  points: FenceCurveDraftPoint[]
+  cursor: FenceCurveDraftPoint | null
+  setDraft(points: readonly FenceCurveDraftPoint[], cursor: FenceCurveDraftPoint | null): void
+  reset(): void
+}
+
+function pointsEqual(a: readonly FenceCurveDraftPoint[], b: readonly FenceCurveDraftPoint[]) {
+  return (
+    a.length === b.length &&
+    a.every((point, index) => point[0] === b[index]?.[0] && point[1] === b[index]?.[1])
+  )
+}
+
+const useFenceCurveDraft = create<FenceCurveDraftState>((set) => ({
+  pointCount: 0,
+  points: [],
+  cursor: null,
+  setDraft: (points, cursor) =>
+    set((state) => {
+      const sameCursor =
+        (!cursor && !state.cursor) ||
+        Boolean(
+          cursor && state.cursor && state.cursor[0] === cursor[0] && state.cursor[1] === cursor[1],
+        )
+      if (sameCursor && pointsEqual(state.points, points)) return state
+      return {
+        pointCount: points.length,
+        points: points.map(([x, z]) => [x, z] as FenceCurveDraftPoint),
+        cursor: cursor ? [cursor[0], cursor[1]] : null,
+      }
+    }),
+  reset: () =>
+    set((state) =>
+      state.pointCount === 0 && state.points.length === 0 && state.cursor === null
+        ? state
+        : { pointCount: 0, points: [], cursor: null },
+    ),
+}))
+
+export default useFenceCurveDraft

package/src/store/use-first-person-hud.ts

@@ -0,0 +1,40 @@
+import { create } from 'zustand'
+
+export type WalkthroughInteract = { label: string; verb: string } | null
+
+export type FirstPersonHudState = {
+  floorLabel: string | null
+  zoneLabel: string | null
+  interact: WalkthroughInteract
+  setHud: (hud: Partial<Pick<FirstPersonHudState, 'floorLabel' | 'zoneLabel' | 'interact'>>) => void
+  reset: () => void
+}
+
+export const useFirstPersonHud = create<FirstPersonHudState>((set) => ({
+  floorLabel: null,
+  zoneLabel: null,
+  interact: null,
+  setHud: (hud) =>
+    set((state) => {
+      const floorLabel = hud.floorLabel === undefined ? state.floorLabel : hud.floorLabel
+      const zoneLabel = hud.zoneLabel === undefined ? state.zoneLabel : hud.zoneLabel
+      const interact = hud.interact === undefined ? state.interact : hud.interact
+
+      if (
+        floorLabel === state.floorLabel &&
+        zoneLabel === state.zoneLabel &&
+        interact?.label === state.interact?.label &&
+        interact?.verb === state.interact?.verb
+      ) {
+        return state
+      }
+
+      return { floorLabel, zoneLabel, interact }
+    }),
+  reset: () =>
+    set((state) =>
+      state.floorLabel === null && state.zoneLabel === null && state.interact === null
+        ? state
+        : { floorLabel: null, zoneLabel: null, interact: null },
+    ),
+}))

package/src/store/use-floorplan-annotation-visibility.ts

@@ -0,0 +1,60 @@
+'use client'
+
+import { create } from 'zustand'
+import { persist } from 'zustand/middleware'
+import {
+  DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY,
+  type FloorplanAnnotationCategory,
+  type FloorplanAnnotationVisibility,
+  normalizeFloorplanAnnotationVisibility,
+} from '../lib/floorplan/annotation-visibility'
+import {
+  DEFAULT_FLOORPLAN_WALL_DIMENSION_REFERENCE,
+  type FloorplanWallDimensionReference,
+  normalizeFloorplanWallDimensionReference,
+} from '../lib/floorplan/floorplan-extension'
+
+type FloorplanAnnotationVisibilityState = {
+  visibility: FloorplanAnnotationVisibility
+  wallDimensionReference: FloorplanWallDimensionReference
+  setCategory: (category: FloorplanAnnotationCategory, visible: boolean) => void
+  setWallDimensionReference: (reference: FloorplanWallDimensionReference) => void
+  reset: () => void
+}
+
+const useFloorplanAnnotationVisibility = create<FloorplanAnnotationVisibilityState>()(
+  persist(
+    (set) => ({
+      visibility: { ...DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY },
+      wallDimensionReference: DEFAULT_FLOORPLAN_WALL_DIMENSION_REFERENCE,
+      setCategory: (category, visible) =>
+        set((state) => ({ visibility: { ...state.visibility, [category]: visible } })),
+      setWallDimensionReference: (wallDimensionReference) => set({ wallDimensionReference }),
+      reset: () =>
+        set({
+          visibility: { ...DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY },
+          wallDimensionReference: DEFAULT_FLOORPLAN_WALL_DIMENSION_REFERENCE,
+        }),
+    }),
+    {
+      name: 'pascal-floorplan-annotation-visibility',
+      merge: (persistedState, currentState) => ({
+        ...currentState,
+        visibility: normalizeFloorplanAnnotationVisibility(
+          (persistedState as { visibility?: unknown } | undefined)?.visibility,
+        ),
+        wallDimensionReference: normalizeFloorplanWallDimensionReference(
+          (persistedState as { wallDimensionReference?: unknown } | undefined)
+            ?.wallDimensionReference,
+        ),
+      }),
+      partialize: (state) =>
+        ({
+          visibility: state.visibility,
+          wallDimensionReference: state.wallDimensionReference,
+        }) as FloorplanAnnotationVisibilityState,
+    },
+  ),
+)
+
+export default useFloorplanAnnotationVisibility

package/src/store/use-floorplan-draft-preview.ts

@@ -0,0 +1,151 @@
+// Ephemeral store for the 2D floor-plan's in-flight DRAFT preview state — the
+// hot, per-pointer-move values every build/edit tool republishes on `grid:move`
+// (the snapped cursor point today; wall/fence/roof draft endpoints as later
+// slices land here). It exists so those per-move updates DON'T live in
+// `FloorplanPanel`'s own `useState`: the panel is a ~10k-line component whose
+// render costs ~120-220ms, so a `setState` per move made every 2D draft tool
+// feel laggy. Producers write via `getState().setX(...)` (no panel re-render);
+// the small overlay leaves subscribe and re-render alone. Same pattern that
+// keeps stair / column / elevator placement smooth (`useStairBuildPreview`,
+// `usePlacementPreview`).
+//
+// Editor-only. Producers clear on tool-inactive, commit, and unmount.
+
+import type { WallPlanPoint } from '@pascal-app/core'
+import { create } from 'zustand'
+
+/** Screen-space (SVG-local px) cursor point — drives the coordinate badge. */
+type SvgPoint = { x: number; y: number }
+
+export type FloorplanPolygonDraftType = 'ceiling' | 'slab' | 'zone'
+
+type FloorplanDraftPreviewState = {
+  /** Snapped plan-XZ point under the cursor; drives the crosshair + the
+   *  cursor-following polygon-draft preview. `null` when idle. */
+  cursorPoint: WallPlanPoint | null
+  /** Screen-space cursor point driving the coordinate-indicator badge. Set on
+   *  every SVG `pointermove` while a build/select tool is active, so it's the
+   *  single hottest 2D update — keeping it out of panel state is what stops the
+   *  panel re-rendering per move. `null` when idle. */
+  cursorPosition: SvgPoint | null
+  /** Live END point of the open wall / fence / roof draft segment — the per-move
+   *  endpoint that drives the 2D draft polygon + measurement. Each is `null`
+   *  unless that tool's draft is open. The START points are mirrored here (set
+   *  per click / per 3D draft move) so out-of-tree consumers — e.g. the hosted
+   *  host-owned preview publishers — can observe the whole open
+   *  segment; panel state remains the 2D interaction source of truth. */
+  wallDraftEnd: WallPlanPoint | null
+  fenceDraftEnd: WallPlanPoint | null
+  roofDraftEnd: WallPlanPoint | null
+  wallDraftStart: WallPlanPoint | null
+  fenceDraftStart: WallPlanPoint | null
+  roofDraftStart: WallPlanPoint | null
+  polygonDraftType: FloorplanPolygonDraftType | null
+  polygonDraftPoints: WallPlanPoint[]
+  /** Set the snapped cursor point. No-ops (skips the store update, so
+   *  subscribers don't re-render) when unchanged — `grid:move` fires far more
+   *  often than the snapped cell actually changes. */
+  setCursorPoint(point: WallPlanPoint | null): void
+  /** Set the screen-space cursor point (deduped on x/y). */
+  setCursorPosition(point: SvgPoint | null): void
+  setWallDraftEnd(point: WallPlanPoint | null): void
+  setFenceDraftEnd(point: WallPlanPoint | null): void
+  setRoofDraftEnd(point: WallPlanPoint | null): void
+  setWallDraftStart(point: WallPlanPoint | null): void
+  setFenceDraftStart(point: WallPlanPoint | null): void
+  setRoofDraftStart(point: WallPlanPoint | null): void
+  setPolygonDraft(type: FloorplanPolygonDraftType | null, points: readonly WallPlanPoint[]): void
+  reset(): void
+}
+
+function planPointsEqual(a: readonly WallPlanPoint[], b: readonly WallPlanPoint[]) {
+  return (
+    a.length === b.length &&
+    a.every((point, index) => point[0] === b[index]?.[0] && point[1] === b[index]?.[1])
+  )
+}
+
+function setPlanPointField(
+  field:
+    | 'fenceDraftEnd'
+    | 'fenceDraftStart'
+    | 'roofDraftEnd'
+    | 'roofDraftStart'
+    | 'wallDraftEnd'
+    | 'wallDraftStart',
+  point: WallPlanPoint | null,
+) {
+  return (
+    state: FloorplanDraftPreviewState,
+  ): Partial<FloorplanDraftPreviewState> | typeof state => {
+    const prev = state[field]
+    if (!point && !prev) return state
+    if (point && prev && prev[0] === point[0] && prev[1] === point[1]) return state
+    return { [field]: point }
+  }
+}
+
+export const useFloorplanDraftPreview = create<FloorplanDraftPreviewState>((set) => ({
+  cursorPoint: null,
+  cursorPosition: null,
+  wallDraftEnd: null,
+  fenceDraftEnd: null,
+  roofDraftEnd: null,
+  wallDraftStart: null,
+  fenceDraftStart: null,
+  roofDraftStart: null,
+  polygonDraftType: null,
+  polygonDraftPoints: [],
+  setCursorPoint: (point) =>
+    set((state) => {
+      const prev = state.cursorPoint
+      if (!point && !prev) return state
+      if (point && prev && prev[0] === point[0] && prev[1] === point[1]) return state
+      return { cursorPoint: point }
+    }),
+  setCursorPosition: (point) =>
+    set((state) => {
+      const prev = state.cursorPosition
+      if (!point && !prev) return state
+      if (point && prev && prev.x === point.x && prev.y === point.y) return state
+      return { cursorPosition: point }
+    }),
+  setWallDraftEnd: (point) => set(setPlanPointField('wallDraftEnd', point)),
+  setFenceDraftEnd: (point) => set(setPlanPointField('fenceDraftEnd', point)),
+  setRoofDraftEnd: (point) => set(setPlanPointField('roofDraftEnd', point)),
+  setWallDraftStart: (point) => set(setPlanPointField('wallDraftStart', point)),
+  setFenceDraftStart: (point) => set(setPlanPointField('fenceDraftStart', point)),
+  setRoofDraftStart: (point) => set(setPlanPointField('roofDraftStart', point)),
+  setPolygonDraft: (type, points) =>
+    set((state) =>
+      state.polygonDraftType === type && planPointsEqual(state.polygonDraftPoints, points)
+        ? state
+        : { polygonDraftType: type, polygonDraftPoints: points.map(([x, z]) => [x, z]) },
+    ),
+  reset: () =>
+    set((state) =>
+      state.cursorPoint === null &&
+      state.cursorPosition === null &&
+      state.wallDraftEnd === null &&
+      state.fenceDraftEnd === null &&
+      state.roofDraftEnd === null &&
+      state.wallDraftStart === null &&
+      state.fenceDraftStart === null &&
+      state.roofDraftStart === null &&
+      state.polygonDraftType === null &&
+      state.polygonDraftPoints.length === 0
+        ? state
+        : {
+            cursorPoint: null,
+            cursorPosition: null,
+            wallDraftEnd: null,
+            fenceDraftEnd: null,
+            roofDraftEnd: null,
+            wallDraftStart: null,
+            fenceDraftStart: null,
+            roofDraftStart: null,
+            polygonDraftType: null,
+            polygonDraftPoints: [],
+          },
+    ),
+}))

package/src/store/use-floorplan-marquee.ts

@@ -0,0 +1,50 @@
+// Ephemeral store for the 2D floor-plan marquee (box-select) drag — the hot,
+// per-pointer-move rectangle the select tool republishes on every move. It
+// lives here, not in `FloorplanPanel`'s `useState`, for the same reason as
+// `useFloorplanDraftPreview`: the panel is a ~10k-line component whose render
+// costs ~120-220ms, so a `setState` per move made dragging a selection box
+// re-render the whole panel. Producers write via `getState()` (no panel
+// re-render); the small marquee overlay leaf subscribes and re-renders alone.
+//
+// The whole drag struct lives here (not just the moving corner) so the
+// pointer-move / -up handlers read it non-reactively via `getState()` and the
+// panel never subscribes. Editor-only; reset on pointer-up / cancel /
+// tool-inactive.
+
+import type { WallPlanPoint } from '@pascal-app/core'
+import { create } from 'zustand'
+
+export type FloorplanMarqueeDrag = {
+  pointerId: number
+  startClientX: number
+  startClientY: number
+  startPlanPoint: WallPlanPoint
+  /** Moving corner under the cursor — the only field that changes per move. */
+  currentPlanPoint: WallPlanPoint
+}
+
+type FloorplanMarqueeState = {
+  drag: FloorplanMarqueeDrag | null
+  begin(drag: FloorplanMarqueeDrag): void
+  /** Advance the moving corner. No-ops (skips the store update, so the overlay
+   *  doesn't re-render) when the snapped point is unchanged or no drag is open. */
+  setCurrent(point: WallPlanPoint): void
+  reset(): void
+}
+
+export const useFloorplanMarquee = create<FloorplanMarqueeState>((set) => ({
+  drag: null,
+  begin: (drag) => set({ drag }),
+  setCurrent: (point) =>
+    set((state) => {
+      const prev = state.drag
+      if (!prev) return state
+      if (prev.currentPlanPoint[0] === point[0] && prev.currentPlanPoint[1] === point[1]) {
+        return state
+      }
+      return { drag: { ...prev, currentPlanPoint: point } }
+    }),
+  reset: () => set((state) => (state.drag === null ? state : { drag: null })),
+}))
+
+export default useFloorplanMarquee

package/src/store/use-floorplan-mode.ts

@@ -0,0 +1,110 @@
+'use client'
+
+import { create } from 'zustand'
+import { persist } from 'zustand/middleware'
+import {
+  DEFAULT_FLOORPLAN_MODE,
+  type FloorplanMode,
+  normalizeFloorplanModesByProject,
+} from '../lib/floorplan/floorplan-mode'
+
+export type FloorplanModeNotice = {
+  id: number
+  kind: 'info' | 'switch-to-expert'
+  message: string
+}
+
+type FloorplanModeState = {
+  mode: FloorplanMode
+  projectId: string | null
+  modesByProject: Record<string, FloorplanMode>
+  hasShownDefaultReassurance: boolean
+  notice: FloorplanModeNotice | null
+  dismissNotice: () => void
+  setMode: (mode: FloorplanMode) => void
+  setProjectId: (projectId: string | null) => void
+  showExpertModeNotice: (toolLabel: string) => void
+  showNotice: (message: string) => void
+}
+
+let nextNoticeId = 0
+
+const useFloorplanMode = create<FloorplanModeState>()(
+  persist(
+    (set) => ({
+      mode: DEFAULT_FLOORPLAN_MODE,
+      projectId: null,
+      modesByProject: {},
+      hasShownDefaultReassurance: false,
+      notice: null,
+      dismissNotice: () => set({ notice: null }),
+      setMode: (mode) =>
+        set((state) => {
+          const shouldReassure =
+            state.mode === 'expert' && mode === 'default' && !state.hasShownDefaultReassurance
+          return {
+            mode,
+            modesByProject: state.projectId
+              ? { ...state.modesByProject, [state.projectId]: mode }
+              : state.modesByProject,
+            hasShownDefaultReassurance: state.hasShownDefaultReassurance || shouldReassure,
+            notice: shouldReassure
+              ? {
+                  id: ++nextNoticeId,
+                  kind: 'info',
+                  message:
+                    'Default mode hides Expert annotations. Your saved work was not deleted.',
+                }
+              : state.notice,
+          }
+        }),
+      setProjectId: (projectId) =>
+        set((state) => ({
+          projectId,
+          mode: projectId
+            ? (state.modesByProject[projectId] ?? DEFAULT_FLOORPLAN_MODE)
+            : DEFAULT_FLOORPLAN_MODE,
+          notice: null,
+        })),
+      showExpertModeNotice: (toolLabel) =>
+        set({
+          notice: {
+            id: ++nextNoticeId,
+            kind: 'switch-to-expert',
+            message: `${toolLabel} is available in Expert mode.`,
+          },
+        }),
+      showNotice: (message) =>
+        set({
+          notice: {
+            id: ++nextNoticeId,
+            kind: 'info',
+            message,
+          },
+        }),
+    }),
+    {
+      name: 'pascal-floorplan-mode-by-project',
+      merge: (persistedState, currentState) => {
+        const persisted = persistedState as
+          | { hasShownDefaultReassurance?: unknown; modesByProject?: unknown }
+          | undefined
+        const modesByProject = normalizeFloorplanModesByProject(persisted?.modesByProject)
+        return {
+          ...currentState,
+          modesByProject,
+          hasShownDefaultReassurance: persisted?.hasShownDefaultReassurance === true,
+          mode: currentState.projectId
+            ? (modesByProject[currentState.projectId] ?? DEFAULT_FLOORPLAN_MODE)
+            : DEFAULT_FLOORPLAN_MODE,
+        }
+      },
+      partialize: (state) => ({
+        hasShownDefaultReassurance: state.hasShownDefaultReassurance,
+        modesByProject: state.modesByProject,
+      }),
+    },
+  ),
+)
+
+export default useFloorplanMode