@pascal-app/editor 0.8.0 → 0.9.2

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

@@ -0,0 +1,298 @@
+import { describe, expect, test } from 'bun:test'
+import { type AnyNode, nodeRegistry, registerNode } from '@pascal-app/core'
+import { z } from 'zod'
+import {
+  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('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,175 @@
+import {
+  type AnyNode,
+  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'
+}
+
+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(',')
+}

package/src/lib/sfx-bus.ts

@@ -1,5 +1,5 @@
 import mitt from 'mitt'
-import { playSFX } from './sfx-player'
+import { disposeSFX, playSFX } from './sfx-player'
 
 /**
  * SFX-specific events that tools can trigger
@@ -10,9 +10,14 @@ type SFXEvents = {
   'sfx:item-pick': undefined
   'sfx:item-place': undefined
   'sfx:item-rotate': undefined
+  'sfx:resize': undefined
+  'sfx:structure-build-start': undefined
   'sfx:structure-build': undefined
   'sfx:structure-delete': undefined
   'sfx:snapshot-capture': undefined
+  'sfx:menu-hover': undefined
+  'sfx:menu-click': undefined
+  'sfx:paint-apply': undefined
 }
 
 /**
@@ -23,6 +28,20 @@ export const sfxEmitter = mitt<SFXEvents>()
 
 let sfxBusInitialized = false
 
+const handleGridSnap = () => playSFX('gridSnap')
+const handleItemDelete = () => playSFX('itemDelete')
+const handleItemPick = () => playSFX('itemPick')
+const handleItemPlace = () => playSFX('itemPlace')
+const handleItemRotate = () => playSFX('itemRotate')
+const handleResize = () => playSFX('resize')
+const handleStructureBuildStart = () => playSFX('structureBuildStart')
+const handleStructureBuild = () => playSFX('structureBuildEnd')
+const handleStructureDelete = () => playSFX('structureDelete')
+const handleSnapshotCapture = () => playSFX('snapshotCapture')
+const handleMenuHover = () => playSFX('menuHover')
+const handleMenuClick = () => playSFX('menuClick')
+const handlePaintApply = () => playSFX('paintApply')
+
 /**
  * Initialize SFX Bus - connects SFX events to actual sound playback.
  * Safe to call multiple times; re-registration is a no-op once initialized.
@@ -30,15 +49,39 @@ let sfxBusInitialized = false
 export function initSFXBus() {
   if (sfxBusInitialized) return
   sfxBusInitialized = true
-  // Map SFX events to sound playback
-  sfxEmitter.on('sfx:grid-snap', () => playSFX('gridSnap'))
-  sfxEmitter.on('sfx:item-delete', () => playSFX('itemDelete'))
-  sfxEmitter.on('sfx:item-pick', () => playSFX('itemPick'))
-  sfxEmitter.on('sfx:item-place', () => playSFX('itemPlace'))
-  sfxEmitter.on('sfx:item-rotate', () => playSFX('itemRotate'))
-  sfxEmitter.on('sfx:structure-build', () => playSFX('structureBuild'))
-  sfxEmitter.on('sfx:structure-delete', () => playSFX('structureDelete'))
-  sfxEmitter.on('sfx:snapshot-capture', () => playSFX('snapshotCapture'))
+  sfxEmitter.on('sfx:grid-snap', handleGridSnap)
+  sfxEmitter.on('sfx:item-delete', handleItemDelete)
+  sfxEmitter.on('sfx:item-pick', handleItemPick)
+  sfxEmitter.on('sfx:item-place', handleItemPlace)
+  sfxEmitter.on('sfx:item-rotate', handleItemRotate)
+  sfxEmitter.on('sfx:resize', handleResize)
+  sfxEmitter.on('sfx:structure-build-start', handleStructureBuildStart)
+  sfxEmitter.on('sfx:structure-build', handleStructureBuild)
+  sfxEmitter.on('sfx:structure-delete', handleStructureDelete)
+  sfxEmitter.on('sfx:snapshot-capture', handleSnapshotCapture)
+  sfxEmitter.on('sfx:menu-hover', handleMenuHover)
+  sfxEmitter.on('sfx:menu-click', handleMenuClick)
+  sfxEmitter.on('sfx:paint-apply', handlePaintApply)
+}
+
+export function disposeSFXBus() {
+  if (sfxBusInitialized) {
+    sfxEmitter.off('sfx:grid-snap', handleGridSnap)
+    sfxEmitter.off('sfx:item-delete', handleItemDelete)
+    sfxEmitter.off('sfx:item-pick', handleItemPick)
+    sfxEmitter.off('sfx:item-place', handleItemPlace)
+    sfxEmitter.off('sfx:item-rotate', handleItemRotate)
+    sfxEmitter.off('sfx:resize', handleResize)
+    sfxEmitter.off('sfx:structure-build-start', handleStructureBuildStart)
+    sfxEmitter.off('sfx:structure-build', handleStructureBuild)
+    sfxEmitter.off('sfx:structure-delete', handleStructureDelete)
+    sfxEmitter.off('sfx:snapshot-capture', handleSnapshotCapture)
+    sfxEmitter.off('sfx:menu-hover', handleMenuHover)
+    sfxEmitter.off('sfx:menu-click', handleMenuClick)
+    sfxEmitter.off('sfx:paint-apply', handlePaintApply)
+    sfxBusInitialized = false
+  }
+  disposeSFX()
 }
 
 /**
@@ -49,3 +92,19 @@ export function initSFXBus() {
 export function triggerSFX(event: keyof SFXEvents) {
   sfxEmitter.emit(event)
 }
+
+/**
+ * Node types whose deletion should use the lighter item-delete cue rather
+ * than the heavier structure-delete one. Shelves are furniture-like placeable
+ * objects, so they sound like items being removed, not structures demolished.
+ */
+const ITEM_DELETE_NODE_TYPES = new Set(['item', 'shelf'])
+
+/**
+ * Emit the delete SFX appropriate for a deleted node's type.
+ */
+export function emitDeleteSFX(nodeType: string | undefined) {
+  sfxEmitter.emit(
+    nodeType && ITEM_DELETE_NODE_TYPES.has(nodeType) ? 'sfx:item-delete' : 'sfx:structure-delete',
+  )
+}