@pascal-app/editor 0.9.2 → 1.0.0-beta.2

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

package/src/store/use-interaction-scope.test.ts

@@ -2,10 +2,12 @@ import { afterEach, describe, expect, test } from 'bun:test'
 import type { AnyNode } from '@pascal-app/core'
 import {
   type ActiveInteractionScope,
+  curveReshapeScope,
   editingHoleInfo,
   handleDragInfo,
   isActive,
   isIdle,
+  isToolDrivenReshape,
   scopeNodeId,
   selectionEnabled,
 } from '../lib/interaction/scope'
@@ -137,7 +139,13 @@ describe('derived flag views are leak-free (no parallel flags)', () => {
 
   test('editingHoleInfo mirrors a hole reshape and clears on end', () => {
     const s = useInteractionScope.getState()
-    s.begin({ kind: 'reshaping', nodeId: 'slab_1', reshape: 'hole', holeIndex: 2 })
+    s.begin({
+      kind: 'reshaping',
+      nodeId: 'slab_1',
+      reshape: 'hole',
+      driver: 'tool',
+      holeIndex: 2,
+    })
     expect(editingHoleInfo(scope())).toEqual({ nodeId: 'slab_1', holeIndex: 2 })
     s.end()
     expect(editingHoleInfo(scope())).toBeNull()
@@ -145,16 +153,27 @@ describe('derived flag views are leak-free (no parallel flags)', () => {
 
   test('a non-hole reshape never reads as an editing hole', () => {
     const s = useInteractionScope.getState()
-    s.begin({ kind: 'reshaping', nodeId: 'wall_1', reshape: 'curve' })
+    s.begin({ kind: 'reshaping', nodeId: 'wall_1', reshape: 'curve', driver: 'tool' })
     expect(editingHoleInfo(scope())).toBeNull()
   })
 
+  test('a floorplan-owned curve drag does not activate the registry reshape tool', () => {
+    expect(isToolDrivenReshape(curveReshapeScope('wall_1', 'floorplan'))).toBe(false)
+    expect(isToolDrivenReshape(curveReshapeScope('wall_1', 'tool'))).toBe(true)
+  })
+
   test('switching interactions never leaks the prior derived view', () => {
     const s = useInteractionScope.getState()
     s.begin({ kind: 'handle-drag', nodeId: 'wall_1', handle: 'height' })
     // Single-owner replacement: the handle-drag view must vanish the instant a
     // different interaction begins — the two cannot be simultaneously active.
-    s.begin({ kind: 'reshaping', nodeId: 'slab_1', reshape: 'hole', holeIndex: 0 })
+    s.begin({
+      kind: 'reshaping',
+      nodeId: 'slab_1',
+      reshape: 'hole',
+      driver: 'tool',
+      holeIndex: 0,
+    })
     expect(handleDragInfo(scope())).toBeNull()
     expect(editingHoleInfo(scope())).toEqual({ nodeId: 'slab_1', holeIndex: 0 })
   })
@@ -174,6 +193,7 @@ describe('derived flag views are leak-free (no parallel flags)', () => {
       { kind: 'drafting', tool: 'wall' },
       { kind: 'box-select' },
       { kind: 'painting' },
+      { kind: 'sculpting' },
     ]
     for (const k of kinds) {
       s.begin(k)

package/src/store/use-interaction-scope.ts

@@ -13,6 +13,8 @@ import {
   IDLE_SCOPE,
   type InteractionScope,
   isCurveReshape,
+  isFloorplanDrivenReshape,
+  isToolDrivenReshape,
   movingNodeOf,
   reshapingNodeId,
   tangentReshapeInfo,
@@ -84,6 +86,12 @@ export const getIsCurveReshape = (): boolean => isCurveReshape(useInteractionSco
 // recovered by reading the reshaped node's type from `useReshapingNode`.
 export const useIsCurveReshape = (): boolean => useInteractionScope((s) => isCurveReshape(s.scope))
 
+export const useIsToolDrivenReshape = (): boolean =>
+  useInteractionScope((s) => isToolDrivenReshape(s.scope))
+
+export const useIsFloorplanDrivenReshape = (): boolean =>
+  useInteractionScope((s) => isFloorplanDrivenReshape(s.scope))
+
 // Replaces the legacy `movingWallEndpoint` / `movingFenceEndpoint` payloads,
 // minus the node (fetch it from `useReshapingNode`).
 export const useEndpointReshape = (): { nodeId: string; endpoint: 'start' | 'end' } | null =>

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

@@ -195,6 +195,7 @@ describe('measurement draft transitions', () => {
       }),
     ).toBe(true)
     expect(draft.finishVertexDrag('3d')).toBe(true)
+    expect(useMeasurementDraft.getState().points[0]).toEqual(point(0, 0, 0))
     expect(useMeasurementDraft.getState().collectionPlane).toEqual({
       point: point(0, 0, 0),
       normal: point(0, 1, 0),
@@ -208,6 +209,34 @@ describe('measurement draft transitions', () => {
     expect(useMeasurementDraft.getState().collectionPlane).toBeNull()
   })
 
+  test('projects every later polygon point and feature fallback onto the first surface plane', () => {
+    const draft = useMeasurementDraft.getState()
+    const anchor = {
+      kind: 'feature' as const,
+      reference: {
+        nodeId: 'slab_host',
+        featureId: 'slab:boundary',
+        parameters: { t: 0.25 },
+      },
+      fallback: point(2, 0.4, 0),
+    }
+    draft.setKind('area')
+    draft.addPoint('3d', point(0, 0, 0), undefined, point(0, 1, 0))
+    draft.addPoint('3d', anchor.fallback, anchor, point(1, 0, 0))
+    draft.addPoint('3d', point(2, -0.7, 2), undefined, point(0, -1, 0))
+
+    expect(useMeasurementDraft.getState().points).toEqual([
+      point(0, 0, 0),
+      point(2, 0, 0),
+      point(2, 0, 2),
+    ])
+    expect(useMeasurementDraft.getState().anchors[1]).toMatchObject({
+      fallback: point(2, 0, 0),
+    })
+    expect(draft.closeBase('3d')).toBe(true)
+    expect(useMeasurementDraft.getState().error).toBeNull()
+  })
+
   test('closes a volume base before accepting explicit extrusion', () => {
     const draft = useMeasurementDraft.getState()
     draft.setKind('volume')

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

@@ -108,6 +108,29 @@ function normalizePoint(point: MeasurementPoint | undefined): MeasurementPoint |
   return length > 1e-9 ? [point[0] / length, point[1] / length, point[2] / length] : null
 }
 
+function projectPointToPlane(
+  point: MeasurementPoint,
+  plane: { point: MeasurementPoint; normal: MeasurementPoint } | null,
+): MeasurementPoint {
+  if (!plane) return clonePoint(point)
+  const distance =
+    (point[0] - plane.point[0]) * plane.normal[0] +
+    (point[1] - plane.point[1]) * plane.normal[1] +
+    (point[2] - plane.point[2]) * plane.normal[2]
+  return [
+    point[0] - plane.normal[0] * distance,
+    point[1] - plane.normal[1] * distance,
+    point[2] - plane.normal[2] * distance,
+  ]
+}
+
+function anchorWithFallback(
+  anchor: MeasurementFeatureAnchor | undefined,
+  fallback: MeasurementPoint,
+): MeasurementFeatureAnchor | null {
+  return anchor ? { ...anchor, fallback: clonePoint(fallback) } : null
+}
+
 export function measurementPolygonMidpoints(
   points: readonly MeasurementPoint[],
 ): Array<{ edgeIndex: number; point: MeasurementPoint }> {
@@ -277,17 +300,18 @@ export const useMeasurementDraft = create<MeasurementDraftState>((set, get) => (
       return false
     }
 
+    const projectedPoint = projectPointToPlane(hover.point, state.collectionPlane)
     const points = state.points.map((point, index) =>
-      index === drag.index ? clonePoint(hover.point) : point,
+      index === drag.index ? projectedPoint : point,
     )
     const anchors = state.anchors.map((anchor, index) =>
-      index === drag.index ? (hover.anchor ?? null) : anchor,
+      index === drag.index ? anchorWithFallback(hover.anchor, projectedPoint) : anchor,
     )
     set({
       points,
       anchors,
       hover: {
-        point: clonePoint(hover.point),
+        point: clonePoint(projectedPoint),
         normal: clonePoint(hover.normal),
         targetNodeId: hover.targetNodeId,
         anchor: hover.anchor,
@@ -352,9 +376,12 @@ export const useMeasurementDraft = create<MeasurementDraftState>((set, get) => (
     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 projectedPoint = polygon
+      ? projectPointToPlane(point, state.collectionPlane)
+      : clonePoint(point)
+    const points = [...state.points, projectedPoint]
+    const anchors = [...state.anchors, anchorWithFallback(anchor, projectedPoint)]
     const planeNormal = polygon && state.points.length === 0 ? normalizePoint(surfaceNormal) : null
     const ready =
       (state.kind === 'distance' && points.length === 2) ||
@@ -365,7 +392,7 @@ export const useMeasurementDraft = create<MeasurementDraftState>((set, get) => (
       points,
       anchors,
       collectionPlane: planeNormal
-        ? { point: clonePoint(point), normal: planeNormal }
+        ? { point: clonePoint(projectedPoint), normal: planeNormal }
         : state.collectionPlane,
       stage: ready ? 'ready' : 'collecting',
       hover: null,

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

@@ -0,0 +1,90 @@
+import type { AnyNode } from '@pascal-app/core'
+import { create } from 'zustand'
+
+export type PathDraftKind = 'duct-segment' | 'lineset' | 'liquid-line' | 'pipe-segment'
+export type PathDraftPoint = [number, number, number]
+export type PathDraftParameter = boolean | number | string
+export type PathDraftParameters = Record<string, PathDraftParameter>
+
+type PathDraftPreviewState = {
+  kind: PathDraftKind | null
+  points: PathDraftPoint[]
+  cursor: PathDraftPoint | null
+  parameters: PathDraftParameters
+  relatedNodes: AnyNode[]
+  setDraft(
+    kind: PathDraftKind,
+    points: readonly PathDraftPoint[],
+    cursor: PathDraftPoint | null,
+    parameters?: Readonly<PathDraftParameters>,
+    relatedNodes?: readonly AnyNode[],
+  ): void
+  clear(kind: PathDraftKind): void
+  reset(): void
+}
+
+function pointEquals(a: PathDraftPoint | null, b: PathDraftPoint | null) {
+  return (!a && !b) || Boolean(a && b && a[0] === b[0] && a[1] === b[1] && a[2] === b[2])
+}
+
+function pointsEqual(a: readonly PathDraftPoint[], b: readonly PathDraftPoint[]) {
+  return a.length === b.length && a.every((point, index) => pointEquals(point, b[index] ?? null))
+}
+
+function parametersEqual(a: PathDraftParameters, b: Readonly<PathDraftParameters>) {
+  const keys = Object.keys(a)
+  const nextKeys = Object.keys(b)
+  return keys.length === nextKeys.length && keys.every((key) => a[key] === b[key])
+}
+
+function relatedNodesEqual(a: readonly AnyNode[], b: readonly AnyNode[]) {
+  return (
+    a.length === b.length &&
+    a.every((node, index) => JSON.stringify(node) === JSON.stringify(b[index]))
+  )
+}
+
+const EMPTY_DRAFT: Pick<
+  PathDraftPreviewState,
+  'cursor' | 'kind' | 'parameters' | 'points' | 'relatedNodes'
+> = {
+  cursor: null,
+  kind: null,
+  parameters: {},
+  points: [],
+  relatedNodes: [],
+}
+
+export const usePathDraftPreview = create<PathDraftPreviewState>((set) => ({
+  ...EMPTY_DRAFT,
+  setDraft: (kind, points, cursor, parameters = {}, relatedNodes = []) =>
+    set((state) => {
+      if (
+        state.kind === kind &&
+        pointEquals(state.cursor, cursor) &&
+        pointsEqual(state.points, points) &&
+        parametersEqual(state.parameters, parameters) &&
+        relatedNodesEqual(state.relatedNodes, relatedNodes)
+      ) {
+        return state
+      }
+      return {
+        cursor: cursor ? [...cursor] : null,
+        kind,
+        parameters: { ...parameters },
+        points: points.map((point) => [...point]),
+        relatedNodes: relatedNodes.map((node) => structuredClone(node)),
+      }
+    }),
+  clear: (kind) => set((state) => (state.kind === kind ? EMPTY_DRAFT : state)),
+  reset: () =>
+    set((state) =>
+      state.kind === null &&
+      state.points.length === 0 &&
+      state.cursor === null &&
+      Object.keys(state.parameters).length === 0 &&
+      state.relatedNodes.length === 0
+        ? state
+        : EMPTY_DRAFT,
+    ),
+}))

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

@@ -10,7 +10,7 @@
 
 import { create } from 'zustand'
 
-type StairPreviewPoint = [number, number]
+export type StairPreviewPoint = [number, number]
 
 type StairBuildPreviewState = {
   /** Snapped plan-XZ point the ghost staircase sits at; `null` when idle. */
@@ -21,6 +21,7 @@ type StairBuildPreviewState = {
    *  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
 }
@@ -33,7 +34,16 @@ export const useStairBuildPreview = create<StairBuildPreviewState>((set) => ({
       const prev = state.point
       if (!point && !prev) return state
       if (point && prev && prev[0] === point[0] && prev[1] === point[1]) return state
-      return { point }
+      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: () =>