@pascal-app/editor 1.0.0-beta.4 → 1.0.0

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

@@ -40,6 +40,7 @@ type FloorplanDraftPreviewState = {
   wallDraftStart: WallPlanPoint | null
   fenceDraftStart: WallPlanPoint | null
   roofDraftStart: WallPlanPoint | null
+  roofDraftQuarterTurn: boolean
   polygonDraftType: FloorplanPolygonDraftType | null
   polygonDraftPoints: WallPlanPoint[]
   /** Set the snapped cursor point. No-ops (skips the store update, so
@@ -54,6 +55,7 @@ type FloorplanDraftPreviewState = {
   setWallDraftStart(point: WallPlanPoint | null): void
   setFenceDraftStart(point: WallPlanPoint | null): void
   setRoofDraftStart(point: WallPlanPoint | null): void
+  setRoofDraftQuarterTurn(quarterTurn: boolean): void
   setPolygonDraft(type: FloorplanPolygonDraftType | null, points: readonly WallPlanPoint[]): void
   reset(): void
 }
@@ -94,6 +96,7 @@ export const useFloorplanDraftPreview = create<FloorplanDraftPreviewState>((set)
   wallDraftStart: null,
   fenceDraftStart: null,
   roofDraftStart: null,
+  roofDraftQuarterTurn: false,
   polygonDraftType: null,
   polygonDraftPoints: [],
   setCursorPoint: (point) =>
@@ -116,6 +119,10 @@ export const useFloorplanDraftPreview = create<FloorplanDraftPreviewState>((set)
   setWallDraftStart: (point) => set(setPlanPointField('wallDraftStart', point)),
   setFenceDraftStart: (point) => set(setPlanPointField('fenceDraftStart', point)),
   setRoofDraftStart: (point) => set(setPlanPointField('roofDraftStart', point)),
+  setRoofDraftQuarterTurn: (quarterTurn) =>
+    set((state) =>
+      state.roofDraftQuarterTurn === quarterTurn ? state : { roofDraftQuarterTurn: quarterTurn },
+    ),
   setPolygonDraft: (type, points) =>
     set((state) =>
       state.polygonDraftType === type && planPointsEqual(state.polygonDraftPoints, points)
@@ -132,6 +139,7 @@ export const useFloorplanDraftPreview = create<FloorplanDraftPreviewState>((set)
       state.wallDraftStart === null &&
       state.fenceDraftStart === null &&
       state.roofDraftStart === null &&
+      state.roofDraftQuarterTurn === false &&
       state.polygonDraftType === null &&
       state.polygonDraftPoints.length === 0
         ? state
@@ -144,6 +152,7 @@ export const useFloorplanDraftPreview = create<FloorplanDraftPreviewState>((set)
             wallDraftStart: null,
             fenceDraftStart: null,
             roofDraftStart: null,
+            roofDraftQuarterTurn: false,
             polygonDraftType: null,
             polygonDraftPoints: [],
           },

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

@@ -1,4 +1,4 @@
-import { afterEach, describe, expect, test } from 'bun:test'
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
 import type { AnyNode } from '@pascal-app/core'
 import {
   type ActiveInteractionScope,
@@ -8,6 +8,7 @@ import {
   isActive,
   isIdle,
   isToolDrivenReshape,
+  meshEditScope,
   scopeNodeId,
   selectionEnabled,
 } from '../lib/interaction/scope'
@@ -20,6 +21,7 @@ const mockNode = (id: string, type: string): AnyNode => ({ id, type }) as unknow
 function reset() {
   useInteractionScope.getState().end()
 }
+beforeEach(reset)
 afterEach(reset)
 
 describe('use-interaction-scope state machine', () => {
@@ -71,6 +73,7 @@ describe('use-interaction-scope state machine', () => {
       nodeType: 'item',
       view: '3d',
       pressDrag: false,
+      driver: 'move-tool',
     })
     s.update({ pressDrag: true })
     const scope = useInteractionScope.getState().scope
@@ -104,6 +107,7 @@ describe('use-interaction-scope state machine', () => {
       nodeType: 'item',
       view: '3d',
       pressDrag: true,
+      driver: 'move-tool',
     })
     expect(useInteractionScope.getState().scope.kind).toBe('moving')
   })
@@ -116,6 +120,22 @@ describe('use-interaction-scope state machine', () => {
     expect(isActive(useInteractionScope.getState().scope)).toBe(true)
   })
 
+  test('mesh edit mode owns its node and disables scene selection for the full session', () => {
+    const s = useInteractionScope.getState()
+    s.begin(meshEditScope('block_1'))
+    expect(scopeNodeId(useInteractionScope.getState().scope)).toBe('block_1')
+    expect(selectionEnabled(useInteractionScope.getState().scope)).toBe(false)
+
+    s.begin(meshEditScope('block_1', 'operating', 'translate'))
+    expect(useInteractionScope.getState().scope).toEqual({
+      kind: 'mesh-editing',
+      nodeId: 'block_1',
+      phase: 'operating',
+      operator: 'translate',
+    })
+    expect(selectionEnabled(useInteractionScope.getState().scope)).toBe(false)
+  })
+
   test('end is idempotent', () => {
     const s = useInteractionScope.getState()
     s.end()
@@ -188,9 +208,11 @@ describe('derived flag views are leak-free (no parallel flags)', () => {
         nodeType: 'item',
         view: '3d',
         pressDrag: false,
+        driver: 'move-tool',
       },
       { kind: 'moving', node: mockNode('i', 'item'), nodeId: 'i', nodeType: 'item', view: '3d' },
       { kind: 'drafting', tool: 'wall' },
+      { kind: 'mesh-editing', nodeId: 'mesh_1', phase: 'selecting' },
       { kind: 'box-select' },
       { kind: 'painting' },
       { kind: 'sculpting' },

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

@@ -1,6 +1,12 @@
 'use client'
 
 import { type AnyNode, type AnyNodeId, useScene } from '@pascal-app/core'
+import {
+  beginPerfAction,
+  commitPerfAction,
+  getActivePerfActionId,
+  hasUncommittedPerfAction,
+} from '@pascal-app/viewer'
 import { useRef } from 'react'
 import { create } from 'zustand'
 import { useShallow } from 'zustand/react/shallow'
@@ -45,9 +51,60 @@ export type InteractionScopeState = {
   endIf: (match: (scope: ActiveInteractionScope) => boolean) => void
 }
 
+// Perf action ledger (`?perf`): every 3D gesture funnels through this store, so
+// begin/end are the one generic bracket for action-cost receipts. A more
+// specific call site (use-drag-action, the 2D floorplan layer) may have begun
+// its own action first — yield to it while ITS gesture is in flight, but a
+// merely-settling previous action must not swallow a new gesture. The scope
+// remembers the id it began and commits only that action at `end`, so a
+// specific site's receipt (or a cancelled one finalized via
+// markToolCancelConsumed) is never committed by the generic bracket. Known
+// limit: a scope-begun gesture cancelled through a path that skips
+// markToolCancelConsumed still commits at end and bills its revert as settle.
+let scopePerfActionId: number | null = null
+
+function beginScopePerfAction(scope: ActiveInteractionScope): void {
+  if (hasUncommittedPerfAction()) return
+  switch (scope.kind) {
+    case 'moving':
+      scopePerfActionId = beginPerfAction('drag:move', scope.nodeId)
+      break
+    case 'placing':
+      scopePerfActionId = beginPerfAction(
+        `place:${scope.node?.type ?? 'node'}`,
+        scope.node?.id ?? '',
+      )
+      break
+    case 'reshaping': {
+      const nodeType = useScene.getState().nodes[scope.nodeId as AnyNodeId]?.type
+      scopePerfActionId = beginPerfAction(
+        `drag:${nodeType ? `${nodeType}-` : ''}${scope.reshape}`,
+        scope.nodeId,
+      )
+      break
+    }
+    case 'handle-drag':
+      scopePerfActionId = beginPerfAction(`drag:${scope.handle}`, scope.nodeId)
+      break
+    default:
+      // drafting / mesh-editing are long-lived modes, not gestures
+      break
+  }
+}
+
+function commitScopePerfAction(): void {
+  if (scopePerfActionId !== null && getActivePerfActionId() === scopePerfActionId) {
+    commitPerfAction()
+  }
+  scopePerfActionId = null
+}
+
 const useInteractionScope = create<InteractionScopeState>((set, get) => ({
   scope: IDLE_SCOPE,
-  begin: (scope) => set({ scope }),
+  begin: (scope) => {
+    beginScopePerfAction(scope)
+    set({ scope })
+  },
   update: (patch) =>
     set((state) => {
       if (state.scope.kind === 'idle') return state
@@ -56,12 +113,16 @@ const useInteractionScope = create<InteractionScopeState>((set, get) => ({
     }),
   end: () => {
     if (get().scope.kind === 'idle') return
+    commitScopePerfAction()
     set({ scope: IDLE_SCOPE })
   },
   endIf: (match) => {
     const scope = get().scope
     if (scope.kind === 'idle') return
-    if (match(scope)) set({ scope: IDLE_SCOPE })
+    if (match(scope)) {
+      commitScopePerfAction()
+      set({ scope: IDLE_SCOPE })
+    }
   },
 }))
 

package/src/store/use-placement-preview.ts

@@ -14,10 +14,22 @@
 import type { AnyNode } from '@pascal-app/core'
 import { create } from 'zustand'
 
+export type PlacementPreviewDimension = {
+  id: string
+  start: [number, number, number]
+  end: [number, number, number]
+  offsetNormal: [number, number]
+  offsetDistance: number
+  value: number
+  renderIn3d?: boolean
+  renderInFloorplan?: boolean
+}
+
 type PlacementPreviewState = {
   /** Transient preview node, already positioned + rotated at the (snapped,
    *  aligned) cursor. `null` when no placement is active. */
   node: AnyNode | null
+  contextNodes: AnyNode[]
   /** Optional synthetic parent for the preview's `def.floorplan` context.
    *  Door / window glyph builders need `ctx.parent` to be a wall to draw their
    *  real symbol (swing arc / panes); off any real wall we hand them a
@@ -25,15 +37,56 @@ type PlacementPreviewState = {
    *  the faithful blueprint symbol instead of a bare rectangle. `null` for
    *  self-contained kinds (column / elevator). */
   parentNode: AnyNode | null
-  set(node: AnyNode | null, parentNode?: AnyNode | null): void
+  dimensions: PlacementPreviewDimension[]
+  activeDimensionId: string | null
+  dimensionInput: string
+  set(
+    node: AnyNode | null,
+    parentNode?: AnyNode | null,
+    dimensions?: PlacementPreviewDimension[],
+    contextNodes?: AnyNode[],
+  ): void
+  selectDimension(id: string | null): void
+  setDimensionInput(value: string): void
+  clearDimensionEditor(): void
   clear(): void
 }
 
 const usePlacementPreview = create<PlacementPreviewState>((set) => ({
   node: null,
+  contextNodes: [],
   parentNode: null,
-  set: (node, parentNode = null) => set({ node, parentNode }),
-  clear: () => set({ node: null, parentNode: null }),
+  dimensions: [],
+  activeDimensionId: null,
+  dimensionInput: '',
+  set: (node, parentNode = null, dimensions = [], contextNodes = []) =>
+    set((state) => {
+      const activeDimensionId = dimensions.some(
+        (dimension) => dimension.id === state.activeDimensionId,
+      )
+        ? state.activeDimensionId
+        : null
+      return {
+        node,
+        contextNodes,
+        parentNode,
+        dimensions,
+        activeDimensionId,
+        dimensionInput: activeDimensionId ? state.dimensionInput : '',
+      }
+    }),
+  selectDimension: (id) => set({ activeDimensionId: id, dimensionInput: '' }),
+  setDimensionInput: (dimensionInput) => set({ dimensionInput }),
+  clearDimensionEditor: () => set({ activeDimensionId: null, dimensionInput: '' }),
+  clear: () =>
+    set({
+      node: null,
+      contextNodes: [],
+      parentNode: null,
+      dimensions: [],
+      activeDimensionId: null,
+      dimensionInput: '',
+    }),
 }))
 
 export default usePlacementPreview

package/src/store/use-session-groups.ts

@@ -0,0 +1,103 @@
+import { type AnyNodeId, useScene } from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
+import { create } from 'zustand'
+import {
+  canCreateSessionGroup,
+  createSessionGroup,
+  expandSessionGroupMembers,
+  type SessionSelectionGroup,
+  selectionIntersectsSessionGroup,
+  selectionMatchesSessionGroup,
+  ungroupSessionSelection,
+} from '../lib/session-groups'
+import { sfxEmitter } from '../lib/sfx-bus'
+
+type SessionGroupsState = {
+  groups: SessionSelectionGroup[]
+  setGroups: (groups: SessionSelectionGroup[]) => void
+  clearGroups: () => void
+}
+
+const useSessionGroups = create<SessionGroupsState>((set) => ({
+  groups: [],
+  setGroups: (groups) => set({ groups }),
+  clearGroups: () => set({ groups: [] }),
+}))
+
+function liveNodeIdSet(): Set<string> {
+  return new Set(Object.keys(useScene.getState().nodes))
+}
+
+/**
+ * Membership is never rewritten when a member is deleted — every read filters
+ * against the live scene instead. Deleting a member and undoing must restore it
+ * to its group, and a destructive prune would have already dropped it (or the
+ * whole group, once it fell under the two-member floor).
+ */
+export function expandSessionSelectionForNode(nodeId: string): string[] | null {
+  const groups = useSessionGroups.getState().groups
+  if (groups.length === 0) return null
+  return expandSessionGroupMembers(groups, nodeId, liveNodeIdSet())
+}
+
+/** Ctrl/Cmd+G — create session group from multi-selection. */
+export function groupCurrentSelection(): boolean {
+  const selectedIds = useViewer.getState().selection.selectedIds as string[]
+  if (selectedIds.length < 2) return false
+
+  const liveIds = liveNodeIdSet()
+  const { groups, created } = createSessionGroup(useSessionGroups.getState().groups, selectedIds, {
+    liveIds,
+  })
+  useSessionGroups.getState().setGroups(groups)
+  if (!created) return false
+
+  useViewer.getState().setSelection({
+    selectedIds: created.memberIds as AnyNodeId[],
+  })
+  sfxEmitter.emit('sfx:menu-click')
+  return true
+}
+
+/** Ctrl/Cmd+Shift+G — dissolve session groups intersecting selection. */
+export function ungroupCurrentSelection(): boolean {
+  const selectedIds = useViewer.getState().selection.selectedIds as string[]
+  if (selectedIds.length === 0) return false
+
+  const liveIds = liveNodeIdSet()
+  const { groups, dissolved } = ungroupSessionSelection(
+    useSessionGroups.getState().groups,
+    selectedIds,
+    liveIds,
+  )
+  if (dissolved.length === 0) return false
+  useSessionGroups.getState().setGroups(groups)
+  sfxEmitter.emit('sfx:menu-click')
+  return true
+}
+
+export function currentSelectionMatchesSessionGroup(): SessionSelectionGroup | null {
+  return selectionMatchesSessionGroup(
+    useSessionGroups.getState().groups,
+    useViewer.getState().selection.selectedIds as string[],
+    liveNodeIdSet(),
+  )
+}
+
+export function currentSelectionIntersectsSessionGroup(): boolean {
+  return selectionIntersectsSessionGroup(
+    useSessionGroups.getState().groups,
+    useViewer.getState().selection.selectedIds as string[],
+    liveNodeIdSet(),
+  )
+}
+
+export function currentSelectionCanCreateSessionGroup(): boolean {
+  return canCreateSessionGroup(
+    useSessionGroups.getState().groups,
+    useViewer.getState().selection.selectedIds as string[],
+    liveNodeIdSet(),
+  )
+}
+
+export default useSessionGroups