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

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

@@ -0,0 +1,206 @@
+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'
+import useInteractionScope from './use-interaction-scope'
+
+// A placing/moving scope carries the node inline. Tests only assert on id/type,
+// so a structural stand-in is enough.
+const mockNode = (id: string, type: string): AnyNode => ({ id, type }) as unknown as AnyNode
+
+function reset() {
+  useInteractionScope.getState().end()
+}
+afterEach(reset)
+
+describe('use-interaction-scope state machine', () => {
+  test('starts idle', () => {
+    expect(useInteractionScope.getState().scope.kind).toBe('idle')
+    expect(isIdle(useInteractionScope.getState().scope)).toBe(true)
+  })
+
+  test('begin enters an interaction; end returns to idle atomically', () => {
+    const s = useInteractionScope.getState()
+    s.begin({
+      kind: 'moving',
+      node: mockNode('item_1', 'item'),
+      nodeId: 'item_1',
+      nodeType: 'item',
+      view: '3d',
+    })
+    expect(useInteractionScope.getState().scope).toEqual({
+      kind: 'moving',
+      node: mockNode('item_1', 'item'),
+      nodeId: 'item_1',
+      nodeType: 'item',
+      view: '3d',
+    })
+    s.end()
+    // No interaction payload leaks past end — the scope is plain idle, so a
+    // stale nodeId/handle is unrepresentable.
+    expect(useInteractionScope.getState().scope).toEqual({ kind: 'idle' })
+    expect(scopeNodeId(useInteractionScope.getState().scope)).toBeNull()
+  })
+
+  test('begin is single-owner: a new interaction replaces the prior one', () => {
+    const s = useInteractionScope.getState()
+    s.begin({ kind: 'drafting', tool: 'wall' })
+    s.begin({ kind: 'handle-drag', nodeId: 'wall_1', handle: 'height' })
+    const scope = useInteractionScope.getState().scope
+    expect(scope.kind).toBe('handle-drag')
+    // The prior drafting payload is gone — illegal "drafting + handle-drag"
+    // combination is unrepresentable.
+    expect(scopeNodeId(scope)).toBe('wall_1')
+  })
+
+  test('update patches the live payload of the active scope', () => {
+    const s = useInteractionScope.getState()
+    s.begin({
+      kind: 'placing',
+      node: mockNode('i1', 'item'),
+      nodeId: 'i1',
+      nodeType: 'item',
+      view: '3d',
+      pressDrag: false,
+    })
+    s.update({ pressDrag: true })
+    const scope = useInteractionScope.getState().scope
+    expect(scope.kind === 'placing' && scope.pressDrag).toBe(true)
+  })
+
+  test('update is a no-op when idle', () => {
+    useInteractionScope.getState().update({
+      kind: 'moving',
+      node: mockNode('x', 'item'),
+      nodeId: 'x',
+      nodeType: 'item',
+      view: '3d',
+    })
+    expect(useInteractionScope.getState().scope.kind).toBe('idle')
+  })
+
+  test('update cannot change which interaction is running', () => {
+    const s = useInteractionScope.getState()
+    s.begin({
+      kind: 'moving',
+      node: mockNode('i1', 'item'),
+      nodeId: 'i1',
+      nodeType: 'item',
+      view: '3d',
+    })
+    s.update({
+      kind: 'placing',
+      node: mockNode('i1', 'item'),
+      nodeId: 'i1',
+      nodeType: 'item',
+      view: '3d',
+      pressDrag: true,
+    })
+    expect(useInteractionScope.getState().scope.kind).toBe('moving')
+  })
+
+  test('selectionEnabled only while idle', () => {
+    const s = useInteractionScope.getState()
+    expect(selectionEnabled(useInteractionScope.getState().scope)).toBe(true)
+    s.begin({ kind: 'box-select' })
+    expect(selectionEnabled(useInteractionScope.getState().scope)).toBe(false)
+    expect(isActive(useInteractionScope.getState().scope)).toBe(true)
+  })
+
+  test('end is idempotent', () => {
+    const s = useInteractionScope.getState()
+    s.end()
+    s.end()
+    expect(useInteractionScope.getState().scope.kind).toBe('idle')
+  })
+})
+
+describe('derived flag views are leak-free (no parallel flags)', () => {
+  const scope = () => useInteractionScope.getState().scope
+
+  test('handleDragInfo mirrors handle-drag and clears on end', () => {
+    const s = useInteractionScope.getState()
+    s.begin({ kind: 'handle-drag', nodeId: 'wall_1', handle: 'height' })
+    expect(handleDragInfo(scope())).toEqual({ nodeId: 'wall_1', label: 'height' })
+    s.end()
+    // After end the derived view is null — a stale activeHandleDrag is
+    // unrepresentable because it is a pure function of the single scope.
+    expect(handleDragInfo(scope())).toBeNull()
+  })
+
+  test('editingHoleInfo mirrors a hole reshape and clears on end', () => {
+    const s = useInteractionScope.getState()
+    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()
+  })
+
+  test('a non-hole reshape never reads as an editing hole', () => {
+    const s = useInteractionScope.getState()
+    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',
+      driver: 'tool',
+      holeIndex: 0,
+    })
+    expect(handleDragInfo(scope())).toBeNull()
+    expect(editingHoleInfo(scope())).toEqual({ nodeId: 'slab_1', holeIndex: 0 })
+  })
+
+  test('every active scope kind leaves at most the views it owns', () => {
+    const s = useInteractionScope.getState()
+    const kinds: ActiveInteractionScope[] = [
+      {
+        kind: 'placing',
+        node: mockNode('i', 'item'),
+        nodeId: 'i',
+        nodeType: 'item',
+        view: '3d',
+        pressDrag: false,
+      },
+      { kind: 'moving', node: mockNode('i', 'item'), nodeId: 'i', nodeType: 'item', view: '3d' },
+      { kind: 'drafting', tool: 'wall' },
+      { kind: 'box-select' },
+      { kind: 'painting' },
+      { kind: 'sculpting' },
+    ]
+    for (const k of kinds) {
+      s.begin(k)
+      // None of these own a handle-drag or hole view.
+      expect(handleDragInfo(scope())).toBeNull()
+      expect(editingHoleInfo(scope())).toBeNull()
+    }
+    s.end()
+  })
+})

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

@@ -0,0 +1,140 @@
+'use client'
+
+import { type AnyNode, type AnyNodeId, useScene } from '@pascal-app/core'
+import { useRef } from 'react'
+import { create } from 'zustand'
+import { useShallow } from 'zustand/react/shallow'
+import {
+  type ActiveInteractionScope,
+  controlPointReshapeInfo,
+  editingHoleInfo,
+  endpointReshapeInfo,
+  handleDragInfo,
+  IDLE_SCOPE,
+  type InteractionScope,
+  isCurveReshape,
+  isFloorplanDrivenReshape,
+  isToolDrivenReshape,
+  movingNodeOf,
+  reshapingNodeId,
+  tangentReshapeInfo,
+} from '../lib/interaction/scope'
+
+// The authoritative interaction state machine. A single owner holds exactly one
+// scope at a time. `begin` enters an interaction (atomically replacing any prior
+// one — a single owner, no producer races), `update` narrows the live payload,
+// and `end` returns to idle atomically so no interaction payload can leak past
+// 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`.
+
+export type InteractionScopeState = {
+  scope: InteractionScope
+  // Enter an interaction. If one is already active it is ended first, so the
+  // store is always single-owner.
+  begin: (scope: ActiveInteractionScope) => void
+  // Patch the current scope's payload. Ignored when idle, or when the patch's
+  // implied kind differs from the active kind — payload updates must not change
+  // which interaction is running (use `begin` for that).
+  update: (patch: Partial<ActiveInteractionScope>) => void
+  // Return to idle atomically. Both commit and cancel paths call this; the
+  // distinction (write vs revert) lives in the interaction body, not here.
+  end: () => void
+  // Return to idle only if the active scope matches `match`. Used when scope is
+  // driven from independent legacy flag clears, so clearing one flag (e.g. a
+  // fence curve) cannot stomp an unrelated active scope (e.g. a wall move).
+  endIf: (match: (scope: ActiveInteractionScope) => boolean) => void
+}
+
+const useInteractionScope = create<InteractionScopeState>((set, get) => ({
+  scope: IDLE_SCOPE,
+  begin: (scope) => set({ scope }),
+  update: (patch) =>
+    set((state) => {
+      if (state.scope.kind === 'idle') return state
+      if ('kind' in patch && patch.kind !== state.scope.kind) return state
+      return { scope: { ...state.scope, ...patch } as InteractionScope }
+    }),
+  end: () => {
+    if (get().scope.kind === 'idle') return
+    set({ scope: IDLE_SCOPE })
+  },
+  endIf: (match) => {
+    const scope = get().scope
+    if (scope.kind === 'idle') return
+    if (match(scope)) set({ scope: IDLE_SCOPE })
+  },
+}))
+
+// 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
+// subscribers (camera controls, floating menu) don't re-render on every update.
+export const useActiveHandleDrag = (): { nodeId: string; label: string } | null =>
+  useInteractionScope(useShallow((s) => handleDragInfo(s.scope)))
+
+export const useEditingHole = (): { nodeId: string; holeIndex: number } | null =>
+  useInteractionScope(useShallow((s) => editingHoleInfo(s.scope)))
+
+// Imperative (non-React) reads for event handlers / effects.
+export const getEditingHole = (): { nodeId: string; holeIndex: number } | null =>
+  editingHoleInfo(useInteractionScope.getState().scope)
+
+export const getIsCurveReshape = (): boolean => isCurveReshape(useInteractionScope.getState().scope)
+
+// Replaces the legacy `curvingWall` / `curvingFence` existence flags. The
+// wall-vs-fence distinction (both now map to one `reshaping/'curve'` scope) is
+// 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 =>
+  useInteractionScope(useShallow((s) => endpointReshapeInfo(s.scope)))
+
+export const useControlPointReshape = (): { nodeId: string; index: number } | null =>
+  useInteractionScope(useShallow((s) => controlPointReshapeInfo(s.scope)))
+
+export const useTangentReshape = (): { nodeId: string; index: number; side: 'in' | 'out' } | null =>
+  useInteractionScope(useShallow((s) => tangentReshapeInfo(s.scope)))
+
+// The node currently being reshaped (curve / endpoint / hole), looked up live
+// from the scene by the scope's `nodeId`. During a reshape the scene node holds
+// the same data the legacy `curvingWall` / `movingWallEndpoint.wall` carried, so
+// consumers that need the full node (affordance-tool mounts, wall-vs-fence type
+// checks) read it here instead of from a parallel flag.
+export const useReshapingNode = (): AnyNode | null => {
+  const nodeId = useInteractionScope((s) => reshapingNodeId(s.scope))
+  // Snapshot the node ONCE when the reshape begins (keyed on nodeId), like the
+  // legacy `curvingWall` / `movingWallEndpoint.wall` flags did. The affordance
+  // tools write the node live during the drag; subscribing to the live scene
+  // node would feed those writes straight back into the tool — the curve resets
+  // on pointer-stop, the endpoint drag loops and freezes. nodeId is stable for
+  // the whole gesture, so a ref snapshot stays frozen until the next reshape.
+  const snapshot = useRef<{ id: string | null; node: AnyNode | null }>({ id: null, node: null })
+  if (snapshot.current.id !== nodeId) {
+    snapshot.current = {
+      id: nodeId,
+      node: nodeId ? (useScene.getState().nodes[nodeId as AnyNodeId] ?? null) : null,
+    }
+  }
+  return snapshot.current.node
+}
+
+// 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.
+export const useMovingNode = (): AnyNode | null => useInteractionScope((s) => movingNodeOf(s.scope))
+
+// Imperative (non-React) read for event handlers / effects.
+export const getMovingNode = (): AnyNode | null =>
+  movingNodeOf(useInteractionScope.getState().scope)
+
+export default useInteractionScope