@pascal-app/editor 1.0.3 → 1.0.5

package/src/hooks/use-keyboard.test.ts

@@ -10,20 +10,30 @@ import {
   nodeRegistry,
   PipeFittingNode,
   PipeSegmentNode,
+  registerNode,
+  useInteractive,
   useScene,
 } from '@pascal-app/core'
+import { useSidebarStore } from '../components/ui/primitives/sidebar'
 import { runRedo, runUndo } from '../lib/history'
 import { meshEditScope } from '../lib/interaction/scope'
+import { setSidebarTabIds } from '../lib/sidebar-panel'
 import useEditor from '../store/use-editor'
 import useInteractionScope from '../store/use-interaction-scope'
 import {
+  armPaintFromShortcut,
+  armWallToolFromShortcut,
   blocksSnappingShortcut,
   canCycleSnappingModeShortcut,
   canRunGlobalRotationShortcut,
+  hasSceneKeyboardFocus,
   isToolOwnedCanopyForm,
   isToolOwnedRotation,
   markToolCancelConsumed,
+  openItemCatalogFromShortcut,
   runHistoryShortcut,
+  runNodeInteraction,
+  switchPhaseFromShortcut,
 } from './use-keyboard'
 
 type RafFn = (callback: (time: number) => void) => number
@@ -39,28 +49,76 @@ type RafFn = (callback: (time: number) => void) => number
 const NODE_ID = 'block_history' as AnyNodeId
 
 describe('snapping shortcuts while entering a run length', () => {
+  test('document panes keep copy, delete and editing shortcuts away from the scene until it is focused', () => {
+    useEditor.setState({ viewLayouts: {} })
+    expect(hasSceneKeyboardFocus()).toBe(true)
+    useEditor.getState().showView('document:plan', { beside: true })
+    expect(hasSceneKeyboardFocus()).toBe(false)
+    useEditor.getState().focusViewPane(0)
+    expect(hasSceneKeyboardFocus()).toBe(true)
+    useEditor
+      .getState()
+      .setViewLayout({ split: false, panes: ['document:plan', '3d'], ratio: 0.5, focus: 0 })
+    expect(hasSceneKeyboardFocus()).toBe(false)
+    useEditor.getState().closeView('document:plan')
+  })
   test('allows snap mode and spacing shortcuts in the duct and pipe length field', () => {
-    expect(
-      blocksSnappingShortcut({
-        tagName: 'INPUT',
-        isContentEditable: false,
-        hasAttribute: (name) => name === 'data-run-length-input',
-      }),
-    ).toBe(false)
+    const field = {
+      tagName: 'INPUT',
+      isContentEditable: false,
+      hasAttribute: (name: string) => name === 'data-run-length-input',
+      closest: (): object => field,
+    }
+    expect(blocksSnappingShortcut(field)).toBe(false)
   })
 
   test('continues to protect ordinary text fields and editable content', () => {
-    for (const tagName of ['INPUT', 'TEXTAREA', 'DIV']) {
-      expect(
-        blocksSnappingShortcut({
-          tagName,
-          isContentEditable: tagName === 'DIV',
-          hasAttribute: () => false,
-        }),
-      ).toBe(true)
+    for (const tagName of ['INPUT', 'TEXTAREA', 'SELECT', 'DIV']) {
+      const field = {
+        tagName,
+        isContentEditable: tagName === 'DIV',
+        hasAttribute: () => false,
+        closest: (): object => field,
+      }
+      expect(blocksSnappingShortcut(field)).toBe(true)
     }
     expect(blocksSnappingShortcut(null)).toBe(false)
   })
+
+  test('honors closest-owned fields and dialogs without claiming ordinary canvas keys', () => {
+    // Model the DOM closest result, not its selector spelling. Native descendant
+    // propagation is checked by the protected browser fixture.
+    for (const role of ['textbox', 'combobox', 'dialog', 'alertdialog']) {
+      const owner = { role }
+      const descendant = {
+        tagName: 'SPAN',
+        isContentEditable: false,
+        hasAttribute: () => false,
+        closest: () => owner,
+      }
+      expect(blocksSnappingShortcut(descendant)).toBe(true)
+    }
+    const canvas = {
+      tagName: 'CANVAS',
+      isContentEditable: false,
+      hasAttribute: () => false,
+      closest: () => null,
+    }
+    expect(blocksSnappingShortcut(canvas)).toBe(false)
+    expect(blocksSnappingShortcut({ ...canvas, tagName: 'SPAN', isContentEditable: true })).toBe(
+      true,
+    )
+  })
+
+  test('reserves the run-length exception for its actual input, not another editable owner', () => {
+    const textarea = {
+      tagName: 'TEXTAREA',
+      isContentEditable: false,
+      hasAttribute: (name: string) => name === 'data-run-length-input',
+      closest: (): object => textarea,
+    }
+    expect(blocksSnappingShortcut(textarea)).toBe(true)
+  })
 })
 
 beforeEach(() => {
@@ -80,7 +138,7 @@ beforeEach(() => {
 afterEach(() => {
   useInteractionScope.getState().end()
   useEditor.getState().armToolMode({ mode: 'select' })
-  useEditor.setState({ selectedItem: null })
+  useEditor.setState({ selectedItem: null, viewLayouts: {} })
   clearSceneHistory()
 })
 
@@ -106,11 +164,10 @@ describe('rotation shortcut ownership', () => {
     expect(isToolOwnedRotation()).toBe(true)
   })
 
-  test('leaves R to the wall tool for its line / rectangle toggle, but not T', () => {
+  test('does not reserve R for the wall tool: its shape is picked in the Build panel', () => {
     useEditor.getState().armToolMode({ mode: 'build', tool: 'wall' })
 
-    expect(isToolOwnedRotation('r')).toBe(true)
-    expect(isToolOwnedRotation('t')).toBe(false)
+    expect(isToolOwnedRotation()).toBe(false)
   })
 
   test('leaves R and T to a moving lean-to extension', () => {
@@ -249,3 +306,170 @@ describe('history while drawing distribution runs', () => {
     })
   }
 })
+
+describe('E on a single selected node', () => {
+  function registerKind(overrides: Record<string, unknown>) {
+    const kind = `test:e-${crypto.randomUUID()}`
+    registerNode({
+      kind,
+      schemaVersion: 1,
+      category: 'furnish',
+      defaults: () => ({}),
+      capabilities: {},
+      ...overrides,
+    } as never)
+    return { object: 'node', id: `${kind}_1`, type: kind } as unknown as AnyNode
+  }
+
+  const switchMechanism = {
+    has: () => true,
+    isOn: (node: AnyNode, state: ReturnType<typeof useInteractive.getState>) =>
+      Boolean(state.mechanisms[node.id]),
+    set: (node: AnyNode, on: boolean) => useInteractive.getState().setMechanism(node.id, on),
+  }
+
+  test('runs the mechanism of a kind that declares only the capability', () => {
+    const node = registerKind({ capabilities: { mechanism: switchMechanism } })
+    try {
+      expect(runNodeInteraction(node)).toBe(true)
+      expect(useInteractive.getState().mechanisms[node.id]).toBe(true)
+      expect(runNodeInteraction(node)).toBe(true)
+      expect(useInteractive.getState().mechanisms[node.id]).toBe(false)
+    } finally {
+      useInteractive.getState().removeMechanism(node.id)
+    }
+  })
+
+  test("prefers the kind's own E action over its mechanism", () => {
+    let ran = 0
+    const node = registerKind({
+      capabilities: { mechanism: switchMechanism },
+      keyboardActions: { e: { appliesTo: () => true, run: () => (ran += 1) } },
+    })
+    expect(runNodeInteraction(node)).toBe(true)
+    expect(ran).toBe(1)
+    expect(useInteractive.getState().mechanisms[node.id]).toBeUndefined()
+  })
+
+  test('leaves E to the door and window fallbacks when nothing applies', () => {
+    const node = registerKind({
+      capabilities: { mechanism: { ...switchMechanism, has: () => false } },
+    })
+    expect(runNodeInteraction(node)).toBe(false)
+    expect(runNodeInteraction(registerKind({}))).toBe(false)
+  })
+})
+
+describe('B and P open their panel', () => {
+  afterEach(() => {
+    setSidebarTabIds([])
+    useSidebarStore.getState().setIsCollapsed(false)
+    useEditor.getState().setContinuation('wall', 'room')
+    useEditor.getState().armToolMode({ mode: 'select' })
+  })
+
+  test('1 goes to site and 2 into the building; 3 is no longer a shortcut', () => {
+    useEditor.getState().armToolMode({ mode: 'build', tool: 'wall' })
+    expect(switchPhaseFromShortcut('1')).toBe(true)
+    expect(useEditor.getState().phase).toBe('site')
+    expect(useEditor.getState().mode).toBe('select')
+    expect(switchPhaseFromShortcut('2')).toBe(true)
+    expect(useEditor.getState().phase).toBe('building')
+    expect(switchPhaseFromShortcut('3')).toBe(false)
+    expect(useEditor.getState().phase).toBe('building')
+  })
+
+  test('F, B and P arm their tool and keep the building', () => {
+    setSidebarTabIds(['site', 'build', 'paint', 'items'])
+    useEditor.getState().setPhase('building')
+    for (const [arm, mode, tool] of [
+      [openItemCatalogFromShortcut, 'build', 'item'],
+      [armWallToolFromShortcut, 'build', 'wall'],
+      [armPaintFromShortcut, 'material-paint', null],
+    ] as const) {
+      arm()
+      expect(useEditor.getState().phase).toBe('building')
+      expect(useEditor.getState().mode).toBe(mode)
+      expect(useEditor.getState().tool).toBe(tool)
+    }
+    openItemCatalogFromShortcut()
+    expect(useEditor.getState().activeSidebarPanel).toBe('items')
+  })
+
+  test('F, B and P also keep Site when arming their tool', () => {
+    setSidebarTabIds(['site', 'build', 'paint', 'items'])
+    for (const arm of [
+      openItemCatalogFromShortcut,
+      armWallToolFromShortcut,
+      armPaintFromShortcut,
+    ]) {
+      useEditor.getState().setPhase('site')
+      useEditor.getState().armToolMode({ mode: 'select' })
+      arm()
+      expect(useEditor.getState().phase).toBe('site')
+    }
+  })
+
+  test('F opens a collapsed catalog sidebar', () => {
+    setSidebarTabIds(['site', 'build', 'items'])
+    useSidebarStore.getState().setIsCollapsed(true)
+    openItemCatalogFromShortcut()
+    expect(useEditor.getState().activeSidebarPanel).toBe('items')
+    expect(useSidebarStore.getState().isCollapsed).toBe(false)
+  })
+
+  test('B arms the wall tool on Rectangle and shows the Build panel', () => {
+    setSidebarTabIds(['site', 'build', 'paint', 'items'])
+    useEditor.getState().setActiveSidebarPanel('items')
+    useSidebarStore.getState().setIsCollapsed(true)
+    useEditor.getState().setContinuation('wall', 'single')
+
+    armWallToolFromShortcut()
+
+    const editor = useEditor.getState()
+    expect(editor.mode).toBe('build')
+    expect(editor.tool).toBe('wall')
+    expect(editor.getContinuation('wall')).toBe('rectangle')
+    expect(editor.activeSidebarPanel).toBe('build')
+    expect(useSidebarStore.getState().isCollapsed).toBe(false)
+  })
+
+  // A host may drop the armed tool when the panel changes (the community does,
+  // with any placement in flight), so B and F open their panel first.
+  test('B and F keep their tool from another panel where the host disarms on a panel change', () => {
+    setSidebarTabIds(['build', 'paint', 'items', 'ai'])
+    const unsubscribe = useEditor.subscribe((state, prev) => {
+      if (state.activeSidebarPanel !== prev.activeSidebarPanel) {
+        useEditor.getState().armToolMode({ mode: 'select' })
+      }
+    })
+    try {
+      for (const [arm, from, panel, tool] of [
+        [armWallToolFromShortcut, 'ai', 'build', 'wall'],
+        [openItemCatalogFromShortcut, 'paint', 'items', 'item'],
+      ] as const) {
+        useEditor.getState().setActiveSidebarPanel(from)
+        arm()
+        const editor = useEditor.getState()
+        expect(editor.activeSidebarPanel).toBe(panel)
+        expect(editor.mode).toBe('build')
+        expect(editor.tool).toBe(tool)
+      }
+    } finally {
+      unsubscribe()
+    }
+  })
+
+  test('P arms paint and shows the Paint panel, or Build where the host has none', () => {
+    setSidebarTabIds(['build', 'paint', 'items'])
+    useEditor.getState().setActiveSidebarPanel('items')
+    armPaintFromShortcut()
+    expect(useEditor.getState().mode).toBe('material-paint')
+    expect(useEditor.getState().activeSidebarPanel).toBe('paint')
+
+    setSidebarTabIds(['site', 'build', 'items'])
+    useEditor.getState().setActiveSidebarPanel('items')
+    armPaintFromShortcut()
+    expect(useEditor.getState().activeSidebarPanel).toBe('build')
+  })
+})