@pascal-app/editor 1.0.0 → 1.0.3

package/src/store/rotation-snapping.test.ts

@@ -0,0 +1,53 @@
+import { afterEach, expect, test } from 'bun:test'
+import { GROUP_ROTATE_DRAG_LABEL, ROTATE_HANDLE_DRAG_LABEL } from '../lib/contextual-help'
+import useEditor, {
+  getActiveSnapContext,
+  isAngleSnapActive,
+  normalizePersistedEditorLayoutState,
+} from './use-editor'
+import useInteractionScope from './use-interaction-scope'
+
+const initialEditor = useEditor.getState()
+const initialScope = useInteractionScope.getState()
+afterEach(() => {
+  useEditor.setState(initialEditor)
+  useInteractionScope.setState(initialScope)
+})
+
+for (const handle of [ROTATE_HANDLE_DRAG_LABEL, GROUP_ROTATE_DRAG_LABEL]) {
+  test(`${handle} reads and cycles the shared mode without changing placement modes`, () => {
+    useInteractionScope.getState().begin({ kind: 'handle-drag', nodeId: 'item_test', handle })
+    const placementModes = useEditor.getState().snappingModeByContext
+    expect(getActiveSnapContext()).toBe('rotation')
+    expect(isAngleSnapActive()).toBe(true)
+    expect(useEditor.getState().cycleSnappingMode()).toBe('off')
+    expect(isAngleSnapActive()).toBe(false)
+    expect(useEditor.getState().snappingModeByContext.wall).toBe(placementModes.wall)
+    expect(useEditor.getState().snappingModeByContext.item).toBe(placementModes.item)
+    expect(useEditor.getState().cycleSnappingMode()).toBe('angles')
+    expect(isAngleSnapActive()).toBe(true)
+  })
+}
+
+test('older persisted preferences receive the rotation default and retain other modes', () => {
+  const merged = normalizePersistedEditorLayoutState({
+    snappingModeByContext: { wall: 'off', item: 'lines', polygon: 'grid' },
+  })
+  expect(merged?.snappingModeByContext).toEqual({
+    wall: 'off',
+    item: 'lines',
+    polygon: 'grid',
+    rotation: 'angles',
+  })
+})
+
+test('persisted rotation mode is retained when valid and reset when invalid', () => {
+  expect(
+    normalizePersistedEditorLayoutState({ snappingModeByContext: { rotation: 'off' } })
+      .snappingModeByContext.rotation,
+  ).toBe('off')
+  expect(
+    normalizePersistedEditorLayoutState({ snappingModeByContext: { rotation: 'grid' } })
+      .snappingModeByContext.rotation,
+  ).toBe('angles')
+})

package/src/store/use-editor.tsx

@@ -570,6 +570,7 @@ export const DEFAULT_PERSISTED_EDITOR_LAYOUT_STATE: PersistedEditorLayoutState =
     wall: defaultSnappingModeFor('wall'),
     item: defaultSnappingModeFor('item'),
     polygon: defaultSnappingModeFor('polygon'),
+    rotation: defaultSnappingModeFor('rotation'),
   },
   continuationByContext: {
     wall: CONTINUATION_PROFILES.wall.default,
@@ -800,8 +801,14 @@ function normalizeContinuationByContext(
   }
 }
 
-function normalizePersistedEditorLayoutState(
-  state: (Partial<PersistedEditorLayoutState> & LegacyContinuationState) | null | undefined,
+export function normalizePersistedEditorLayoutState(
+  state:
+    | (Omit<Partial<PersistedEditorLayoutState>, 'snappingModeByContext'> &
+        LegacyContinuationState & {
+          snappingModeByContext?: Partial<Record<SnapContext, unknown>>
+        })
+    | null
+    | undefined,
 ): PersistedEditorLayoutState {
   return {
     activeSidebarPanel:
@@ -821,6 +828,7 @@ function normalizePersistedEditorLayoutState(
       wall: migrateSnappingMode(state?.snappingModeByContext?.wall, 'wall'),
       item: migrateSnappingMode(state?.snappingModeByContext?.item, 'item'),
       polygon: migrateSnappingMode(state?.snappingModeByContext?.polygon, 'polygon'),
+      rotation: migrateSnappingMode(state?.snappingModeByContext?.rotation, 'rotation'),
     },
     continuationByContext: normalizeContinuationByContext(state),
     showReferenceFloor: state?.showReferenceFloor === true,

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

@@ -40,6 +40,9 @@ type FloorplanDraftPreviewState = {
   wallDraftStart: WallPlanPoint | null
   fenceDraftStart: WallPlanPoint | null
   roofDraftStart: WallPlanPoint | null
+  /** First corner of an open rectangle-wall draft; the live cursor is the
+   *  opposite corner, so the rectangle tool publishes only per click. */
+  wallRectangleDraftStart: WallPlanPoint | null
   roofDraftQuarterTurn: boolean
   polygonDraftType: FloorplanPolygonDraftType | null
   polygonDraftPoints: WallPlanPoint[]
@@ -55,6 +58,7 @@ type FloorplanDraftPreviewState = {
   setWallDraftStart(point: WallPlanPoint | null): void
   setFenceDraftStart(point: WallPlanPoint | null): void
   setRoofDraftStart(point: WallPlanPoint | null): void
+  setWallRectangleDraftStart(point: WallPlanPoint | null): void
   setRoofDraftQuarterTurn(quarterTurn: boolean): void
   setPolygonDraft(type: FloorplanPolygonDraftType | null, points: readonly WallPlanPoint[]): void
   reset(): void
@@ -74,7 +78,8 @@ function setPlanPointField(
     | 'roofDraftEnd'
     | 'roofDraftStart'
     | 'wallDraftEnd'
-    | 'wallDraftStart',
+    | 'wallDraftStart'
+    | 'wallRectangleDraftStart',
   point: WallPlanPoint | null,
 ) {
   return (
@@ -96,6 +101,7 @@ export const useFloorplanDraftPreview = create<FloorplanDraftPreviewState>((set)
   wallDraftStart: null,
   fenceDraftStart: null,
   roofDraftStart: null,
+  wallRectangleDraftStart: null,
   roofDraftQuarterTurn: false,
   polygonDraftType: null,
   polygonDraftPoints: [],
@@ -119,6 +125,7 @@ export const useFloorplanDraftPreview = create<FloorplanDraftPreviewState>((set)
   setWallDraftStart: (point) => set(setPlanPointField('wallDraftStart', point)),
   setFenceDraftStart: (point) => set(setPlanPointField('fenceDraftStart', point)),
   setRoofDraftStart: (point) => set(setPlanPointField('roofDraftStart', point)),
+  setWallRectangleDraftStart: (point) => set(setPlanPointField('wallRectangleDraftStart', point)),
   setRoofDraftQuarterTurn: (quarterTurn) =>
     set((state) =>
       state.roofDraftQuarterTurn === quarterTurn ? state : { roofDraftQuarterTurn: quarterTurn },
@@ -139,6 +146,7 @@ export const useFloorplanDraftPreview = create<FloorplanDraftPreviewState>((set)
       state.wallDraftStart === null &&
       state.fenceDraftStart === null &&
       state.roofDraftStart === null &&
+      state.wallRectangleDraftStart === null &&
       state.roofDraftQuarterTurn === false &&
       state.polygonDraftType === null &&
       state.polygonDraftPoints.length === 0
@@ -152,6 +160,7 @@ export const useFloorplanDraftPreview = create<FloorplanDraftPreviewState>((set)
             wallDraftStart: null,
             fenceDraftStart: null,
             roofDraftStart: null,
+            wallRectangleDraftStart: null,
             roofDraftQuarterTurn: false,
             polygonDraftType: null,
             polygonDraftPoints: [],

package/src/store/use-handle-group.ts

@@ -0,0 +1,4 @@
+import { create } from 'zustand'
+export const useHandleGroup = create<{ active: { nodeId: string; group: string } | null }>(() => ({
+  active: null,
+}))

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

@@ -1,6 +1,13 @@
 'use client'
 
-import { type AnyNode, type AnyNodeId, useScene } from '@pascal-app/core'
+import {
+  type AnyNode,
+  type AnyNodeId,
+  collectSubtree,
+  useLiveNodeOverrides,
+  useLiveTransforms,
+  useScene,
+} from '@pascal-app/core'
 import {
   beginPerfAction,
   commitPerfAction,
@@ -10,6 +17,7 @@ import {
 import { useRef } from 'react'
 import { create } from 'zustand'
 import { useShallow } from 'zustand/react/shallow'
+import { discardFreshPlacementSubtree } from '../lib/fresh-planar-placement'
 import {
   type ActiveInteractionScope,
   controlPointReshapeInfo,
@@ -25,6 +33,7 @@ import {
   reshapingNodeId,
   tangentReshapeInfo,
 } from '../lib/interaction/scope'
+import usePlacementPreview from './use-placement-preview'
 
 // The authoritative interaction state machine. A single owner holds exactly one
 // scope at a time. `begin` enters an interaction (atomically replacing any prior
@@ -33,8 +42,21 @@ import {
 // the end of its interaction. There is no setter that can leave the store in an
 // illegal half-state: the only writable shape is `InteractionScope`.
 
+type SubtreeCreation = {
+  rootId: AnyNodeId
+  node: AnyNode
+  hydrationId: object | null
+}
+type OwnedSubtree = { creation: SubtreeCreation; gesture: object }
+
 export type InteractionScopeState = {
   scope: InteractionScope
+  gesture: object | null
+  pendingSubtree: SubtreeCreation | null
+  ownedSubtree: OwnedSubtree | null
+  noteSubtreeCreation: (node: AnyNode) => void
+  adoptSubtree: (rootId: AnyNodeId) => boolean
+  finishSubtree: (rootId: AnyNodeId) => void
   // Enter an interaction. If one is already active it is ended first, so the
   // store is always single-owner.
   begin: (scope: ActiveInteractionScope) => void
@@ -101,9 +123,62 @@ function commitScopePerfAction(): void {
 
 const useInteractionScope = create<InteractionScopeState>((set, get) => ({
   scope: IDLE_SCOPE,
+  gesture: null,
+  pendingSubtree: null,
+  ownedSubtree: null,
+  noteSubtreeCreation: (node) =>
+    set({
+      pendingSubtree: { rootId: node.id, node, hydrationId: useScene.getState().hydrationId },
+    }),
+  adoptSubtree: (rootId) => {
+    const state = get()
+    if (state.ownedSubtree?.creation.rootId === rootId)
+      return (
+        state.ownedSubtree.gesture === state.gesture &&
+        isCurrentCreation(state.ownedSubtree.creation)
+      )
+    const creation = state.pendingSubtree
+    if (
+      !creation ||
+      creation.rootId !== rootId ||
+      !state.gesture ||
+      movingNodeOf(state.scope)?.id !== rootId ||
+      !isCurrentCreation(creation)
+    )
+      return false
+    set({ ownedSubtree: { creation, gesture: state.gesture }, pendingSubtree: null })
+    return true
+  },
+  finishSubtree: (rootId) =>
+    set((state) => {
+      if (state.ownedSubtree?.creation.rootId !== rootId && state.pendingSubtree?.rootId !== rootId)
+        return state
+      return {
+        ownedSubtree: state.ownedSubtree?.creation.rootId === rootId ? null : state.ownedSubtree,
+        pendingSubtree: state.pendingSubtree?.rootId === rootId ? null : state.pendingSubtree,
+      }
+    }),
   begin: (scope) => {
+    const state = get()
+    const nodeId = movingNodeOf(scope)?.id
+    const creation = state.ownedSubtree?.creation ?? state.pendingSubtree
+    if (
+      nodeId &&
+      nodeId === movingNodeOf(state.scope)?.id &&
+      creation?.rootId === nodeId &&
+      isCurrentCreation(creation)
+    ) {
+      set({ scope })
+      return
+    }
     beginScopePerfAction(scope)
-    set({ scope })
+    set({
+      scope,
+      gesture: {},
+      ownedSubtree: null,
+      pendingSubtree:
+        get().pendingSubtree?.rootId === movingNodeOf(scope)?.id ? get().pendingSubtree : null,
+    })
   },
   update: (patch) =>
     set((state) => {
@@ -114,18 +189,92 @@ const useInteractionScope = create<InteractionScopeState>((set, get) => ({
   end: () => {
     if (get().scope.kind === 'idle') return
     commitScopePerfAction()
-    set({ scope: IDLE_SCOPE })
+    set({ scope: IDLE_SCOPE, gesture: null, ownedSubtree: null, pendingSubtree: null })
   },
   endIf: (match) => {
     const scope = get().scope
     if (scope.kind === 'idle') return
     if (match(scope)) {
       commitScopePerfAction()
-      set({ scope: IDLE_SCOPE })
+      set({ scope: IDLE_SCOPE, gesture: null, ownedSubtree: null, pendingSubtree: null })
     }
   },
 }))
 
+function isCurrentCreation(creation: SubtreeCreation): boolean {
+  const scene = useScene.getState()
+  return (
+    scene.hydrationId === creation.hydrationId && scene.nodes[creation.rootId] === creation.node
+  )
+}
+
+export function isInteractionSubtreeDraft(
+  rootId = movingNodeOf(useInteractionScope.getState().scope)?.id,
+): boolean {
+  const state = useInteractionScope.getState()
+  const creation = state.ownedSubtree?.creation ?? state.pendingSubtree
+  return Boolean(
+    creation &&
+      state.gesture &&
+      rootId === movingNodeOf(state.scope)?.id &&
+      creation.rootId === rootId &&
+      (!state.ownedSubtree || state.ownedSubtree.gesture === state.gesture) &&
+      isCurrentCreation(creation),
+  )
+}
+
+// Track the identity of the factory-created node through scene patches, never through metadata.
+// Hydration or deletion invalidates the creation even if a later scene reuses the same id.
+useScene.subscribe((scene, previous) => {
+  const state = useInteractionScope.getState()
+  for (const creation of [state.pendingSubtree, state.ownedSubtree?.creation]) {
+    if (!creation) continue
+    if (
+      scene.hydrationId !== creation.hydrationId ||
+      previous.nodes[creation.rootId] !== creation.node ||
+      !scene.nodes[creation.rootId]
+    ) {
+      state.finishSubtree(creation.rootId)
+    } else creation.node = scene.nodes[creation.rootId]!
+  }
+})
+
+// Factory drafts belong to their gesture even before a mover mounts to adopt them.
+useInteractionScope.subscribe((state, previous) => {
+  if (
+    state.gesture === previous.gesture &&
+    movingNodeOf(state.scope)?.id === movingNodeOf(previous.scope)?.id
+  )
+    return
+  const owned =
+    previous.ownedSubtree ??
+    (previous.pendingSubtree && previous.gesture
+      ? { creation: previous.pendingSubtree, gesture: previous.gesture }
+      : null)
+  if (
+    !owned ||
+    owned.gesture !== previous.gesture ||
+    movingNodeOf(previous.scope)?.id !== owned.creation.rootId ||
+    !isCurrentCreation(owned.creation)
+  )
+    return
+  const node = owned.creation.node
+  const subtree = collectSubtree(useScene.getState().nodes, node.id)
+  const temporal = useScene.temporal.getState()
+  const wasTracking = temporal.isTracking
+  temporal.pause()
+  try {
+    discardFreshPlacementSubtree(node.id)
+    for (const entry of subtree ? [subtree.root, ...subtree.descendants] : []) {
+      useLiveTransforms.getState().clear(entry.id)
+      useLiveNodeOverrides.getState().clear(entry.id)
+    }
+    if (usePlacementPreview.getState().node?.id === node.id) usePlacementPreview.getState().clear()
+  } finally {
+    if (wasTracking) temporal.resume()
+  }
+})
+
 // Derived, reference-stable views of the active scope, replacing the legacy
 // `useEditor.activeHandleDrag` / `useEditor.editingHole` flags. `useShallow`
 // keeps the result reference-stable across unrelated scope changes, so hot-path
@@ -190,8 +339,8 @@ export const useReshapingNode = (): AnyNode | null => {
 // The node currently being placed or moved. Replaces the legacy
 // `useEditor.movingNode` flag. Unlike `useReshapingNode`, no `useRef` snapshot is
 // needed: the node is carried inline in the scope and set once at `begin`, so it
-// is already a stable reference for the whole gesture (nothing calls `begin` mid
-// drag). Returns null whenever no placing/moving interaction is active.
+// remains stable until a caller explicitly re-arms the same interaction.
+// Returns null whenever no placing/moving interaction is active.
 export const useMovingNode = (): AnyNode | null => useInteractionScope((s) => movingNodeOf(s.scope))
 
 // Imperative (non-React) read for event handlers / effects.

package/src/store/use-send-to-app.ts

@@ -0,0 +1,21 @@
+import { create } from 'zustand'
+
+/** Progress of a "Send to Blender" hand-off. Lives outside the settings panel so
+ * switching tabs mid-send neither drops the lock nor loses the outcome. */
+export type SendToAppStep = 'probing' | 'exporting' | 'sending' | 'importing'
+
+export type SendToAppMessage = { tone: 'info' | 'error'; text: string }
+
+type SendToAppState = {
+  step: SendToAppStep | null
+  message: SendToAppMessage | null
+  setStep: (step: SendToAppStep | null) => void
+  setMessage: (message: SendToAppMessage | null) => void
+}
+
+export const useSendToApp = create<SendToAppState>((set) => ({
+  step: null,
+  message: null,
+  setStep: (step) => set({ step }),
+  setMessage: (message) => set({ message }),
+}))