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

package/src/lib/selection-routing.test.ts

@@ -0,0 +1,313 @@
+import { describe, expect, test } from 'bun:test'
+import { type AnyNode, emitter, nodeRegistry, registerNode } from '@pascal-app/core'
+import { z } from 'zod'
+import {
+  emitCanvasNodeSelection,
+  resolveCanvasSelectionNode,
+  resolveNodeSelectionTarget,
+  resolveSelectedIdsForNodeClick,
+  selectionModifiersFromEvent,
+  shouldPreserveSelectedRoofHostTarget,
+} from './selection-routing'
+
+function registerTestDefinition(kind: string, overrides: Record<string, unknown> = {}) {
+  if (nodeRegistry.has(kind)) return
+  registerNode({
+    kind,
+    schemaVersion: 1,
+    schema: z.object({ type: z.literal(kind) }) as never,
+    category: 'furnish',
+    defaults: () => ({ type: kind }) as never,
+    capabilities: {},
+    renderer: { kind: 'parametric', module: async () => ({ default: () => null }) },
+    ...overrides,
+  } as never)
+}
+
+describe('resolveSelectedIdsForNodeClick', () => {
+  test('preserves the pre-routing selection when a phase switch clears current ids', () => {
+    expect(
+      resolveSelectedIdsForNodeClick({
+        baseSelectedIds: ['wall_1'],
+        currentSelectedIds: [],
+        modifierKeys: { meta: true, ctrl: false, shift: false },
+        nodeId: 'item_1',
+      }),
+    ).toEqual(['wall_1', 'item_1'])
+  })
+
+  test('toggles from the pre-routing selection while a modifier is held', () => {
+    expect(
+      resolveSelectedIdsForNodeClick({
+        baseSelectedIds: ['wall_1', 'item_1'],
+        currentSelectedIds: [],
+        modifierKeys: { meta: false, ctrl: false, shift: true },
+        nodeId: 'item_1',
+      }),
+    ).toEqual(['wall_1'])
+  })
+})
+
+describe('emitCanvasNodeSelection', () => {
+  test('publishes the accepted canvas node once', () => {
+    const node = { id: 'wall_1', type: 'wall' } as unknown as AnyNode
+    const received: AnyNode[] = []
+    const onSelection = (selectedNode: AnyNode) => received.push(selectedNode)
+    emitter.on('selection:canvas-node-click', onSelection)
+
+    emitCanvasNodeSelection(node)
+
+    emitter.off('selection:canvas-node-click', onSelection)
+    expect(received).toEqual([node])
+  })
+})
+
+describe('selectionModifiersFromEvent', () => {
+  test('falls back to tracked modifier state when the click event omits keys', () => {
+    expect(selectionModifiersFromEvent({}, { meta: false, ctrl: true, shift: false })).toEqual({
+      meta: false,
+      ctrl: true,
+      shift: false,
+    })
+  })
+
+  test('prefers explicit event key state over stale tracked modifiers', () => {
+    expect(
+      selectionModifiersFromEvent(
+        { metaKey: false, ctrlKey: false, shiftKey: false },
+        { meta: true, ctrl: true, shift: true },
+      ),
+    ).toEqual({
+      meta: false,
+      ctrl: false,
+      shift: false,
+    })
+  })
+})
+
+describe('resolveNodeSelectionTarget', () => {
+  test('routes furniture items to furnish', () => {
+    const node = {
+      id: 'item_1',
+      type: 'item',
+      asset: { category: 'furniture' },
+    } as unknown as AnyNode
+
+    expect(resolveNodeSelectionTarget(node)).toEqual({ phase: 'furnish' })
+  })
+
+  test('routes door and window catalog items to structure', () => {
+    const node = {
+      id: 'item_1',
+      type: 'item',
+      asset: { category: 'door' },
+    } as unknown as AnyNode
+
+    expect(resolveNodeSelectionTarget(node)).toEqual({
+      phase: 'structure',
+      structureLayer: 'elements',
+    })
+  })
+})
+
+describe('resolveCanvasSelectionNode', () => {
+  // Mirrors the cabinet-module setup: modules proxy to their run for grouped
+  // move / rotate, but declare `selectionProxy.bypassDirectPick` so a direct
+  // body click selects the clicked module.
+  const groupKind = 'selection-routing-proxy-group-test'
+  const memberKind = 'selection-routing-proxy-member-test'
+
+  function registerBypassKinds() {
+    registerTestDefinition(groupKind)
+    registerTestDefinition(memberKind, {
+      selectionProxy: {
+        bypassDirectPick: (node: AnyNode, proxyTarget: AnyNode) =>
+          (node.type as string) === memberKind && (proxyTarget.type as string) === groupKind,
+      },
+    })
+  }
+
+  test('keeps proxied members individually selectable when the kind declares bypassDirectPick', () => {
+    registerBypassKinds()
+    const run = { id: 'group_run', type: groupKind, metadata: {} } as unknown as AnyNode
+    const module = {
+      id: 'group_member',
+      type: memberKind,
+      parentId: run.id,
+      metadata: { nodeSelectionProxyId: run.id },
+    } as unknown as AnyNode
+
+    expect(
+      resolveCanvasSelectionNode({
+        node: module,
+        nodes: {
+          [run.id]: run,
+          [module.id]: module,
+        },
+        selectedIds: [],
+      }),
+    ).toBe(module)
+  })
+
+  test('keeps nested proxied members leaf-selectable by default', () => {
+    registerBypassKinds()
+    const rootRun = { id: 'group_root_run', type: groupKind, metadata: {} } as unknown as AnyNode
+    const legRun = {
+      id: 'group_leg_run',
+      type: groupKind,
+      parentId: rootRun.id,
+      metadata: { nodeSelectionProxyId: rootRun.id },
+    } as unknown as AnyNode
+    const nestedCornerBase = {
+      id: 'group_nested_member',
+      type: memberKind,
+      parentId: legRun.id,
+      metadata: { nodeSelectionProxyId: legRun.id },
+    } as unknown as AnyNode
+
+    expect(
+      resolveCanvasSelectionNode({
+        node: nestedCornerBase,
+        nodes: {
+          [rootRun.id]: rootRun,
+          [legRun.id]: legRun,
+          [nestedCornerBase.id]: nestedCornerBase,
+        },
+        selectedIds: [],
+      }),
+    ).toBe(nestedCornerBase)
+  })
+
+  test('follows the proxy when the kind declares no bypass', () => {
+    const kind = 'selection-routing-proxy-no-bypass-test'
+    registerTestDefinition(kind)
+    const group = { id: 'plain_group', type: kind, metadata: {} } as unknown as AnyNode
+    const member = {
+      id: 'plain_member',
+      type: kind,
+      parentId: group.id,
+      metadata: { nodeSelectionProxyId: group.id },
+    } as unknown as AnyNode
+
+    expect(
+      resolveCanvasSelectionNode({
+        node: member,
+        nodes: {
+          [group.id]: group,
+          [member.id]: member,
+        },
+        selectedIds: [],
+      }),
+    ).toBe(group)
+  })
+
+  test('keeps parent-frame children routed to their parent when that parent is solely selected', () => {
+    const kind = 'selection-routing-parent-frame-test'
+    registerTestDefinition(kind, {
+      capabilities: {
+        movable: {
+          axes: ['x', 'z'],
+          gridSnap: true,
+          parentFrame: {
+            resolveParent: (node: AnyNode, nodes: Readonly<Record<string, AnyNode>>) =>
+              (node.parentId ? nodes[node.parentId] : null) ?? null,
+          },
+        },
+      },
+    })
+
+    const parent = { id: 'parent_1', type: groupKind, metadata: {} } as unknown as AnyNode
+    const child = {
+      id: 'child_1',
+      type: kind,
+      parentId: parent.id,
+      metadata: {},
+    } as unknown as AnyNode
+
+    expect(
+      resolveCanvasSelectionNode({
+        node: child,
+        nodes: {
+          [parent.id]: parent,
+          [child.id]: child,
+        },
+        selectedIds: [parent.id],
+      }),
+    ).toBe(parent)
+  })
+
+  test('prefers an explicit selection proxy before parent-frame routing', () => {
+    const kind = 'selection-routing-proxy-before-parent-frame-test'
+    registerTestDefinition(kind, {
+      capabilities: {
+        movable: {
+          axes: ['x', 'z'],
+          gridSnap: true,
+          parentFrame: {
+            resolveParent: (node: AnyNode, nodes: Readonly<Record<string, AnyNode>>) =>
+              (node.parentId ? nodes[node.parentId] : null) ?? null,
+          },
+        },
+      },
+    })
+
+    const root = { id: 'root_1', type: groupKind, metadata: {} } as unknown as AnyNode
+    const proxyGroup = { id: 'proxy_1', type: groupKind, metadata: {} } as unknown as AnyNode
+    const child = {
+      id: 'child_proxy_1',
+      type: kind,
+      parentId: root.id,
+      metadata: { nodeSelectionProxyId: proxyGroup.id },
+    } as unknown as AnyNode
+
+    expect(
+      resolveCanvasSelectionNode({
+        node: child,
+        nodes: {
+          [root.id]: root,
+          [proxyGroup.id]: proxyGroup,
+          [child.id]: child,
+        },
+        selectedIds: [root.id],
+      }),
+    ).toBe(proxyGroup)
+  })
+})
+
+describe('shouldPreserveSelectedRoofHostTarget', () => {
+  test('keeps the roof host target while that roof is the sole armed selection', () => {
+    const node = { id: 'roof_1', type: 'roof' } as unknown as AnyNode
+
+    expect(
+      shouldPreserveSelectedRoofHostTarget({
+        node,
+        selectedIds: ['roof_1'],
+        armedRoofId: 'roof_1',
+      }),
+    ).toBe(true)
+  })
+
+  test('falls back to segment targeting when the roof host is not armed', () => {
+    const node = { id: 'roof_1', type: 'roof' } as unknown as AnyNode
+
+    expect(
+      shouldPreserveSelectedRoofHostTarget({
+        node,
+        selectedIds: ['roof_1'],
+        armedRoofId: null,
+      }),
+    ).toBe(false)
+  })
+
+  test('falls back to segment targeting when the roof is no longer the sole selection', () => {
+    const node = { id: 'roof_1', type: 'roof' } as unknown as AnyNode
+
+    expect(
+      shouldPreserveSelectedRoofHostTarget({
+        node,
+        selectedIds: ['roof_1', 'wall_1'],
+        armedRoofId: 'roof_1',
+      }),
+    ).toBe(false)
+  })
+})

package/src/lib/selection-routing.ts

@@ -0,0 +1,180 @@
+import {
+  type AnyNode,
+  emitter,
+  type ItemNode,
+  nodeRegistry,
+  resolveSelectionProxyId,
+} from '@pascal-app/core'
+
+export type SelectionModifierKeys = {
+  meta: boolean
+  ctrl: boolean
+  shift: boolean
+}
+
+export type NodeSelectionTarget = {
+  phase: 'site' | 'structure' | 'furnish'
+  structureLayer?: 'zones' | 'elements'
+}
+
+export function emitCanvasNodeSelection(node: AnyNode): void {
+  emitter.emit('selection:canvas-node-click', node)
+}
+
+function shouldBypassSelectionProxy(node: AnyNode, target: AnyNode): boolean {
+  if (node.id === target.id) return false
+  // Kind-declared bypass (`def.selectionProxy.bypassDirectPick`): the kind
+  // keeps a proxy for grouped affordances but wants a direct body click to
+  // select the clicked node itself.
+  return nodeRegistry.get(node.type)?.selectionProxy?.bypassDirectPick?.(node, target) ?? false
+}
+
+export function resolveCanvasSelectionNode({
+  node,
+  nodes,
+  selectedIds,
+}: {
+  node: AnyNode
+  nodes: Readonly<Record<string, AnyNode | undefined>>
+  selectedIds: readonly string[]
+}): AnyNode {
+  const proxiedTarget = nodes[resolveSelectionProxyId(node, nodes)] ?? node
+  let target = shouldBypassSelectionProxy(node, proxiedTarget) ? node : proxiedTarget
+  const parentFrame = nodeRegistry.get(target.type)?.capabilities?.movable?.parentFrame
+  if (parentFrame) {
+    const parent = parentFrame.resolveParent(target, nodes as Readonly<Record<string, AnyNode>>)
+    if (parent && selectedIds.length === 1 && selectedIds[0] === parent.id) {
+      target = parent
+    }
+  }
+  return target
+}
+
+export function isSelectionModifierActive(keys: SelectionModifierKeys): boolean {
+  return keys.meta || keys.ctrl || keys.shift
+}
+
+export function selectionModifiersFromEvent(
+  event?: {
+    metaKey?: boolean
+    ctrlKey?: boolean
+    shiftKey?: boolean
+    nativeEvent?: {
+      metaKey?: boolean
+      ctrlKey?: boolean
+      shiftKey?: boolean
+    }
+  } | null,
+  fallback?: Partial<SelectionModifierKeys>,
+): SelectionModifierKeys {
+  const fromEvent = (
+    key: keyof SelectionModifierKeys,
+    eventKey: 'metaKey' | 'ctrlKey' | 'shiftKey',
+  ) => {
+    if (typeof event?.[eventKey] === 'boolean') return event[eventKey]
+    if (typeof event?.nativeEvent?.[eventKey] === 'boolean') return event.nativeEvent[eventKey]
+    return Boolean(fallback?.[key])
+  }
+
+  return {
+    meta: fromEvent('meta', 'metaKey'),
+    ctrl: fromEvent('ctrl', 'ctrlKey'),
+    shift: fromEvent('shift', 'shiftKey'),
+  }
+}
+
+export function resolveSelectedIdsForNodeClick({
+  baseSelectedIds,
+  currentSelectedIds,
+  modifierKeys,
+  nodeId,
+}: {
+  baseSelectedIds?: readonly string[]
+  currentSelectedIds: readonly string[]
+  modifierKeys: SelectionModifierKeys
+  nodeId: string
+}): string[] {
+  if (isSelectionModifierActive(modifierKeys)) {
+    const selectedIds = baseSelectedIds ?? currentSelectedIds
+    if (selectedIds.includes(nodeId)) {
+      return selectedIds.filter((id) => id !== nodeId)
+    }
+    return [...selectedIds, nodeId]
+  }
+
+  return [nodeId]
+}
+
+export function shouldPreserveSelectedRoofHostTarget({
+  node,
+  selectedIds,
+  armedRoofId,
+}: {
+  node: AnyNode
+  selectedIds: readonly string[]
+  armedRoofId: string | null
+}): boolean {
+  return (
+    node.type === 'roof' &&
+    armedRoofId === node.id &&
+    selectedIds.length === 1 &&
+    selectedIds[0] === node.id
+  )
+}
+
+export function resolveNodeSelectionTarget(node: AnyNode): NodeSelectionTarget | null {
+  if (node.type === 'building') {
+    return { phase: 'site' }
+  }
+
+  if (node.type === 'zone') {
+    return {
+      phase: 'structure',
+      structureLayer: 'zones',
+    }
+  }
+
+  if (node.type === 'item') {
+    const item = node as ItemNode
+    if (item.asset.category === 'door' || item.asset.category === 'window') {
+      return {
+        phase: 'structure',
+        structureLayer: 'elements',
+      }
+    }
+    return { phase: 'furnish' }
+  }
+
+  if (
+    node.type === 'wall' ||
+    node.type === 'fence' ||
+    node.type === 'column' ||
+    node.type === 'elevator' ||
+    node.type === 'slab' ||
+    node.type === 'ceiling' ||
+    node.type === 'roof' ||
+    node.type === 'roof-segment' ||
+    node.type === 'stair' ||
+    node.type === 'stair-segment' ||
+    node.type === 'spawn' ||
+    node.type === 'window' ||
+    node.type === 'door'
+  ) {
+    return {
+      phase: 'structure',
+      structureLayer: 'elements',
+    }
+  }
+
+  const def = nodeRegistry.get(node.type)
+  if (!def) return null
+
+  if (def.category === 'furnish') {
+    return { phase: 'furnish' }
+  }
+
+  return {
+    phase: 'structure',
+    structureLayer: 'elements',
+  }
+}

package/src/lib/sfx/index.ts

@@ -1,2 +1,3 @@
 export { initSFXBus, sfxEmitter, triggerSFX } from '../sfx-bus'
 export { playSFX, SFX, type SFXName, updateSFXVolumes } from '../sfx-player'
+export { movementSfxStepKey } from './movement-tick'

package/src/lib/sfx/movement-tick.test.ts

@@ -0,0 +1,65 @@
+import { describe, expect, test } from 'bun:test'
+import { movementSfxStepKey } from './movement-tick'
+
+describe('movementSfxStepKey', () => {
+  test('keeps tiny free-move changes in the same bucket', () => {
+    expect(
+      movementSfxStepKey({
+        coords: [1.01, 2.04],
+        gridSnapActive: false,
+        gridStep: 0.5,
+      }),
+    ).toBe(
+      movementSfxStepKey({
+        coords: [1.04, 2.01],
+        gridSnapActive: false,
+        gridStep: 0.5,
+      }),
+    )
+  })
+
+  test('changes bucket after crossing the free-move cadence', () => {
+    expect(
+      movementSfxStepKey({
+        coords: [1.01, 2.04],
+        gridSnapActive: false,
+        gridStep: 0.5,
+      }),
+    ).not.toBe(
+      movementSfxStepKey({
+        coords: [1.16, 2.04],
+        gridSnapActive: false,
+        gridStep: 0.5,
+      }),
+    )
+  })
+
+  test('uses the live grid step when grid snapping is active', () => {
+    expect(
+      movementSfxStepKey({
+        coords: [0.24, 0],
+        gridSnapActive: true,
+        gridStep: 0.5,
+      }),
+    ).toBe(
+      movementSfxStepKey({
+        coords: [0.21, 0],
+        gridSnapActive: true,
+        gridStep: 0.5,
+      }),
+    )
+    expect(
+      movementSfxStepKey({
+        coords: [0.24, 0],
+        gridSnapActive: true,
+        gridStep: 0.5,
+      }),
+    ).not.toBe(
+      movementSfxStepKey({
+        coords: [0.76, 0],
+        gridSnapActive: true,
+        gridStep: 0.5,
+      }),
+    )
+  })
+})

package/src/lib/sfx/movement-tick.ts

@@ -0,0 +1,18 @@
+const DEFAULT_FREE_MOVEMENT_SFX_STEP_M = 0.1
+
+type MovementSfxStepKeyArgs = {
+  coords: readonly number[]
+  gridSnapActive: boolean
+  gridStep: number
+  freeStep?: number
+}
+
+export function movementSfxStepKey({
+  coords,
+  gridSnapActive,
+  gridStep,
+  freeStep = DEFAULT_FREE_MOVEMENT_SFX_STEP_M,
+}: MovementSfxStepKeyArgs): string {
+  const step = gridSnapActive && gridStep > 0 ? gridStep : freeStep
+  return coords.map((coord) => Math.round(coord / step)).join(',')
+}