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

package/src/lib/direct-manipulation.test.ts

@@ -9,9 +9,12 @@ import {
 import { z } from 'zod'
 import {
   canDirectMoveNode,
+  EDITOR_HANDLE_HIT_AREA_USER_DATA_KEY,
+  pointerEventHitsEditorHandle,
   resolveDirectManipulationNode,
   resolveDirectRotationDragDelta,
   resolveMoveActionNode,
+  shouldStartDirectMoveDrag,
   snapDirectRotationDelta,
 } from './direct-manipulation'
 
@@ -116,6 +119,91 @@ describe('canDirectMoveNode', () => {
   })
 })
 
+describe('shouldStartDirectMoveDrag', () => {
+  test('arms a plain drag for a kind that opts into direct dragging', () => {
+    expect(
+      shouldStartDirectMoveDrag({
+        allowPlainDrag: true,
+        commandModifier: false,
+        handleOwnsPointer: false,
+        nodeId: 'cabinet_existing',
+        selectedIds: [],
+      }),
+    ).toBe(true)
+  })
+
+  test('keeps modifier dragging limited to the sole selected node', () => {
+    expect(
+      shouldStartDirectMoveDrag({
+        allowPlainDrag: false,
+        commandModifier: true,
+        handleOwnsPointer: false,
+        nodeId: 'item_selected',
+        selectedIds: ['item_selected'],
+      }),
+    ).toBe(true)
+    expect(
+      shouldStartDirectMoveDrag({
+        allowPlainDrag: false,
+        commandModifier: true,
+        handleOwnsPointer: false,
+        nodeId: 'item_other',
+        selectedIds: ['item_selected'],
+      }),
+    ).toBe(false)
+  })
+
+  test('does not arm body dragging when a resize handle owns the pointer', () => {
+    expect(
+      shouldStartDirectMoveDrag({
+        allowPlainDrag: true,
+        commandModifier: false,
+        handleOwnsPointer: true,
+        nodeId: 'cabinet_selected',
+        selectedIds: ['cabinet_selected'],
+      }),
+    ).toBe(false)
+  })
+})
+
+describe('pointerEventHitsEditorHandle', () => {
+  test('keeps a visible resize handle from falling through to a nearer cabinet body', () => {
+    expect(
+      pointerEventHitsEditorHandle({
+        intersections: [
+          { object: { userData: {} } },
+          {
+            object: {
+              userData: { [EDITOR_HANDLE_HIT_AREA_USER_DATA_KEY]: true },
+            },
+          },
+        ],
+      }),
+    ).toBe(true)
+  })
+
+  test('recognises a handle when it is the nearest R3F intersection', () => {
+    expect(
+      pointerEventHitsEditorHandle({
+        intersections: [
+          {
+            object: {
+              userData: { [EDITOR_HANDLE_HIT_AREA_USER_DATA_KEY]: true },
+            },
+          },
+          { object: { userData: {} } },
+        ],
+      }),
+    ).toBe(true)
+  })
+
+  test('does not claim ordinary scene intersections', () => {
+    expect(pointerEventHitsEditorHandle({ intersections: [{ object: { userData: {} } }] })).toBe(
+      false,
+    )
+  })
+})
+
 describe('resolveDirectManipulationNode', () => {
   test('routes proxied members to their assembly for direct transforms', () => {
     const group = {
@@ -272,4 +360,48 @@ describe('resolveMoveActionNode', () => {
       }),
     ).toBe(child)
   })
+
+  test('routes a parent-frame child move to a rotatable assembly parent', () => {
+    const parentKind = 'move-action-rotatable-parent-kind-test'
+    const childKind = 'move-action-rotatable-child-kind-test'
+    registerTestDefinition(parentKind, {
+      capabilities: { rotatable: { axes: ['y'], snapAngles: [Math.PI / 4] } },
+    })
+    registerTestDefinition(childKind, {
+      capabilities: {
+        movable: {
+          axes: ['x', 'z'],
+          gridSnap: true,
+          parentFrame: {
+            resolveParent: (node: AnyNode, nodes: Readonly<Record<string, AnyNode>>) =>
+              (node.parentId ? nodes[node.parentId] : null) ?? null,
+            parentRotationY: () => 0,
+            localToPlan: (_parent: AnyNode, local: readonly [number, number, number]) => [
+              local[0],
+              local[1],
+              local[2],
+            ],
+            planToLocal: (_parent: AnyNode, planX: number, localY: number, planZ: number) => [
+              planX,
+              localY,
+              planZ,
+            ],
+          },
+        },
+      },
+    })
+    const parent = { id: 'move_action_rotatable_run', type: parentKind } as unknown as AnyNode
+    const child = {
+      id: 'move_action_rotatable_module',
+      type: childKind,
+      parentId: parent.id,
+    } as unknown as AnyNode
+
+    expect(
+      resolveMoveActionNode(child, {
+        [parent.id]: parent,
+        [child.id]: child,
+      }),
+    ).toBe(parent)
+  })
 })

package/src/lib/direct-manipulation.ts

@@ -45,6 +45,25 @@ const BESPOKE_SELECTION_MOVE_KINDS = new Set([
   'liquid-line',
 ])
 
+export const EDITOR_HANDLE_HIT_AREA_USER_DATA_KEY = 'editorHandleHitArea'
+
+export function pointerEventHitsEditorHandle(event: unknown): boolean {
+  if (!event || typeof event !== 'object') return false
+  const intersections = (
+    event as {
+      intersections?: readonly {
+        object?: { userData?: Record<string, unknown> }
+      }[]
+    }
+  ).intersections
+  return (
+    intersections?.some(
+      (intersection) =>
+        intersection.object?.userData?.[EDITOR_HANDLE_HIT_AREA_USER_DATA_KEY] === true,
+    ) ?? false
+  )
+}
+
 export function canDirectMoveNode(node: AnyNode): boolean {
   // These MEP kinds own move through bespoke selection rigs (latch cubes,
   // directional arrows, grid-driven previews). Sending body drags/clicks
@@ -64,6 +83,24 @@ export function canDirectMoveNode(node: AnyNode): boolean {
   return isMovable(node)
 }
 
+export function shouldStartDirectMoveDrag({
+  allowPlainDrag,
+  commandModifier,
+  handleOwnsPointer,
+  nodeId,
+  selectedIds,
+}: {
+  allowPlainDrag: boolean
+  commandModifier: boolean
+  handleOwnsPointer: boolean
+  nodeId: string
+  selectedIds: readonly string[]
+}): boolean {
+  if (handleOwnsPointer) return false
+  if (commandModifier) return selectedIds.length === 1 && selectedIds[0] === nodeId
+  return allowPlainDrag && selectedIds.length < 2
+}
+
 export function resolveDirectManipulationNode(
   node: AnyNode,
   nodes: Readonly<Record<string, AnyNode | undefined>>,
@@ -80,7 +117,7 @@ export function resolveMoveActionNode(
 ): AnyNode {
   const parentFrame = nodeRegistry.get(node.type)?.capabilities?.movable?.parentFrame
   const parent = parentFrame?.resolveParent(node, nodes as Readonly<Record<string, AnyNode>>)
-  return parent?.type === node.type ? parent : node
+  return parent && (parent.type === node.type || canDirectRotateNode(parent)) ? parent : node
 }
 
 export function snapDirectRotationDelta(delta: number, free: boolean): number {

package/src/lib/editor-api.ts

@@ -1,6 +1,7 @@
-import type { AnyNode, EditorApi } from '@pascal-app/core'
+import { type AnyNode, type EditorApi, useScene } from '@pascal-app/core'
 import useEditor from '../store/use-editor'
 import useInteractionScope from '../store/use-interaction-scope'
+import { resolveDirectManipulationNode, resolveMoveActionNode } from './direct-manipulation'
 import {
   controlPointReshapeScope,
   endpointReshapeScope,
@@ -25,14 +26,16 @@ export function createEditorApi(): EditorApi {
       // (every concrete kind enumerated). Descriptors pass any node; the
       // cast lets registry-driven move kinds through without forcing a
       // schema-level type widening.
-      editor.setMovingNode(node as Parameters<typeof editor.setMovingNode>[0])
+      const target = resolveMoveActionNode(node, useScene.getState().nodes)
+      editor.setMovingNode(target as Parameters<typeof editor.setMovingNode>[0])
     },
     engageMoveDrag(node: AnyNode) {
       const editor = useEditor.getState()
       // Flag drag mode BEFORE mounting the move tool so the coordinator reads
       // it at setup and wires its commit-on-release listener.
       editor.setPlacementDragMode(true)
-      editor.setMovingNode(node as Parameters<typeof editor.setMovingNode>[0])
+      const target = resolveDirectManipulationNode(node, useScene.getState().nodes)
+      editor.setMovingNode(target as Parameters<typeof editor.setMovingNode>[0])
     },
     engageEndpointMove(node: AnyNode, endpoint: 'start' | 'end') {
       // Endpoint reshape is kind-agnostic: the scope carries the node id + which

package/src/lib/elevation-guides.test.ts

@@ -1,9 +1,10 @@
-import { describe, expect, test } from 'bun:test'
+import { afterEach, describe, expect, test } from 'bun:test'
 import { type AnyNode, CeilingNode, LevelNode, SlabNode } from '@pascal-app/core'
 import useElevationGuides from '../store/use-elevation-guides'
 import {
   clearStructuralElevationGuide,
   collectElevationSnapTargets,
+  publishResolvedElevationGuide,
   publishStructuralElevationGuide,
   resolveElevationSnapMatch,
   resolveStructuralElevationSnap,
@@ -42,6 +43,10 @@ function structuralScene() {
 }
 
 describe('elevation guides', () => {
+  afterEach(() => {
+    useElevationGuides.setState({ guide: null })
+  })
+
   test('collects the level, slab faces, and ceiling plane on the source level', () => {
     const { level, nodes, slab } = structuralScene()
     const targets = collectElevationSnapTargets(
@@ -104,4 +109,26 @@ describe('elevation guides', () => {
     publishStructuralElevationGuide(source, 0.7, nodes)
     expect(useElevationGuides.getState().guide).toBeNull()
   })
+
+  test('publishes an explicitly resolved neighboring datum', () => {
+    const { level } = structuralScene()
+    useElevationGuides.setState({ guide: null })
+
+    publishResolvedElevationGuide(
+      { nodeId: 'leanto_moving', levelId: level.id, anchor: [2, 1] },
+      {
+        id: 'leanto_neighbor:high-edge',
+        elevation: 3.4,
+        anchor: [5, 1],
+        label: 'Neighbor shed edge',
+      },
+    )
+
+    expect(useElevationGuides.getState().guide).toMatchObject({
+      ownerId: 'leanto_moving',
+      elevation: 3.4,
+      direction: [1, 0],
+      label: 'Neighbor shed edge',
+    })
+  })
 })

package/src/lib/elevation-guides.ts

@@ -1,6 +1,7 @@
 import {
   type AnyNode,
   type AnyNodeId,
+  type FenceNode,
   findLevelAncestorId,
   getWallBaseElevationForNodes,
   getWallEffectiveHeightForNodes,
@@ -53,8 +54,10 @@ function segmentCenter(
 // A stale host resolves to the level base — the sculpted ground under the
 // fence's start point, sampled where the builder samples it, so the guide line
 // lands on the rail it claims to describe.
-function fenceBaseElevation(node: AnyNode, nodes: Record<string, AnyNode>): number {
-  if (node.type !== 'fence') return 0
+export function getFenceBaseElevationForNodes(
+  node: FenceNode,
+  nodes: Record<string, AnyNode>,
+): number {
   const host = node.supportSlabId ? nodes[node.supportSlabId as AnyNodeId] : undefined
   const hosted = host?.type === 'slab' && (host.parentId ?? null) === (node.parentId ?? null)
   const levelId = findLevelAncestorId(node.id as AnyNodeId, nodes)
@@ -161,7 +164,7 @@ export function collectElevationSnapTargets(
     }
 
     if (node.type === 'fence') {
-      const base = fenceBaseElevation(node, nodes)
+      const base = getFenceBaseElevationForNodes(node, nodes)
       const center = segmentCenter(node.start, node.end)
       targets.push({
         id: `${node.id}:base`,
@@ -245,8 +248,20 @@ export function publishStructuralElevationGuide(
     return
   }
 
-  const dx = match.target.anchor[0] - source.anchor[0]
-  const dz = match.target.anchor[1] - source.anchor[1]
+  publishResolvedElevationGuide(source, match.target)
+}
+
+export function publishResolvedElevationGuide(
+  source: ElevationGuideSource,
+  target: ElevationSnapTarget,
+): void {
+  if (!source.levelId) {
+    clearStructuralElevationGuide(source.nodeId)
+    return
+  }
+
+  const dx = target.anchor[0] - source.anchor[0]
+  const dz = target.anchor[1] - source.anchor[1]
   const length = Math.hypot(dx, dz)
   const direction: [number, number] = length > 1e-6 ? [dx / length, dz / length] : [1, 0]
 
@@ -255,8 +270,8 @@ export function publishStructuralElevationGuide(
     levelId: source.levelId,
     center: source.anchor,
     direction,
-    elevation: match.elevation,
-    label: match.target.label,
+    elevation: target.elevation,
+    label: target.label,
   })
 }
 

package/src/lib/floating-menu-scale.test.ts

@@ -0,0 +1,29 @@
+import { describe, expect, test } from 'bun:test'
+import { OrthographicCamera, PerspectiveCamera, Vector3 } from 'three'
+import { getFloatingMenuScale } from './floating-menu-scale'
+
+describe('getFloatingMenuScale', () => {
+  test('uses the standard orthographic zoom scale and clamps its range', () => {
+    const camera = new OrthographicCamera()
+    const anchor = new Vector3()
+
+    camera.zoom = 15
+    expect(getFloatingMenuScale(camera, anchor)).toBe(0.75)
+    camera.zoom = 2
+    expect(getFloatingMenuScale(camera, anchor)).toBe(0.5)
+    camera.zoom = 40
+    expect(getFloatingMenuScale(camera, anchor)).toBe(1)
+  })
+
+  test('uses inverse perspective-camera distance and clamps its range', () => {
+    const camera = new PerspectiveCamera()
+    const anchor = new Vector3()
+
+    camera.position.set(0, 0, 16)
+    expect(getFloatingMenuScale(camera, anchor)).toBe(0.75)
+    camera.position.set(0, 0, 48)
+    expect(getFloatingMenuScale(camera, anchor)).toBe(0.5)
+    camera.position.set(0, 0, 6)
+    expect(getFloatingMenuScale(camera, anchor)).toBe(1)
+  })
+})

package/src/lib/floating-menu-scale.ts

@@ -0,0 +1,14 @@
+import { type Camera, OrthographicCamera, type Vector3 } from 'three'
+
+const MIN_MENU_SCALE = 0.5
+const MAX_MENU_SCALE = 1
+const REF_ORTHO_ZOOM = 20
+const REF_CAMERA_DISTANCE = 12
+
+export function getFloatingMenuScale(camera: Camera, anchor: Vector3): number {
+  const raw =
+    camera instanceof OrthographicCamera
+      ? camera.zoom / REF_ORTHO_ZOOM
+      : REF_CAMERA_DISTANCE / Math.max(camera.position.distanceTo(anchor), 0.001)
+  return Math.min(MAX_MENU_SCALE, Math.max(MIN_MENU_SCALE, raw))
+}

package/src/lib/floorplan/apply-alignment.test.ts

@@ -1,8 +1,23 @@
-import { afterEach, describe, expect, test } from 'bun:test'
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+import { LevelNode, useScene, WallNode } from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
 import useAlignmentGuides from '../../store/use-alignment-guides'
-import { applyFloorplanAlignment } from './apply-alignment'
+import { alignFloorplanDraftPoint, applyFloorplanAlignment } from './apply-alignment'
 
 describe('applyFloorplanAlignment', () => {
+  beforeEach(() => {
+    // These tests assume no active building (alignment runs on world axes).
+    // The scene/viewer stores are process-wide singletons, so an earlier test
+    // FILE can leak a selected building fixture into them — under bun's
+    // platform-dependent file order that turned into an order-dependent
+    // failure (getActiveBuildingPose reading a fixture building without a
+    // rotation array). Pin the empty-scene context explicitly.
+    useScene.setState({ nodes: {} } as never)
+    useViewer.setState({
+      selection: { buildingId: null, levelId: null, zoneId: null, selectedIds: [] },
+    } as never)
+  })
+
   afterEach(() => {
     useAlignmentGuides.getState().clear()
   })
@@ -22,4 +37,34 @@ describe('applyFloorplanAlignment', () => {
     expect(result.guides).toHaveLength(1)
     expect(useAlignmentGuides.getState().guides).toHaveLength(1)
   })
+
+  test('can restrict candidates to the active level', () => {
+    const lowerLevel = LevelNode.parse({ id: 'level_lower', level: 0 })
+    const upperLevel = LevelNode.parse({ id: 'level_upper', level: 1 })
+    const lowerWall = WallNode.parse({
+      id: 'wall_lower',
+      parentId: lowerLevel.id,
+      start: [10, 10],
+      end: [14, 10],
+    })
+    const upperWall = WallNode.parse({
+      id: 'wall_upper',
+      parentId: upperLevel.id,
+      start: [0, 0],
+      end: [4, 0],
+    })
+    useScene.setState({
+      nodes: Object.fromEntries(
+        [lowerLevel, upperLevel, lowerWall, upperWall].map((node) => [node.id, node]),
+      ),
+    } as never)
+
+    expect(
+      alignFloorplanDraftPoint([0.04, 0], {
+        applySnap: true,
+        levelId: lowerLevel.id,
+      }),
+    ).toEqual([0.04, 0])
+    expect(useAlignmentGuides.getState().guides).toHaveLength(0)
+  })
 })

package/src/lib/floorplan/apply-alignment.ts

@@ -2,6 +2,7 @@ import {
   type AlignmentAnchor,
   type AlignmentGuide,
   collectAlignmentAnchors,
+  resolveLevelId,
   useScene,
 } from '@pascal-app/core'
 import useAlignmentGuides from '../../store/use-alignment-guides'
@@ -96,13 +97,21 @@ export function alignFloorplanDraftPoint(
     bypass?: boolean
     threshold?: number
     excludeIds?: readonly string[]
+    levelId?: string | null
   },
 ): [number, number] {
   if (opts?.bypass) {
     useAlignmentGuides.getState().clear()
     return [point[0], point[1]]
   }
-  let candidates = collectAlignmentAnchors(useScene.getState().nodes, FLOORPLAN_DRAFT_ALIGN_ID)
+  const nodes = useScene.getState().nodes
+  let candidates = collectAlignmentAnchors(nodes, FLOORPLAN_DRAFT_ALIGN_ID)
+  if (opts && 'levelId' in opts) {
+    candidates = candidates.filter((anchor) => {
+      const candidate = nodes[anchor.nodeId as keyof typeof nodes]
+      return candidate ? resolveLevelId(candidate, nodes) === opts.levelId : false
+    })
+  }
   if (opts?.excludeIds?.length) {
     const excluded = new Set(opts.excludeIds)
     candidates = candidates.filter((anchor) => !excluded.has(anchor.nodeId))