@furystack/shades-common-components 14.0.0 → 15.0.0

package/src/components/markdown/markdown-display.spec.tsx

@@ -240,4 +240,136 @@ describe('MarkdownDisplay', () => {
       expect(root?.children.length).toBe(0)
     })
   })
+
+  describe('keyboard navigation', () => {
+    it('should make links focusable', async () => {
+      await usingAsync(new Injector(), async (injector) => {
+        const rootElement = document.getElementById('root') as HTMLDivElement
+
+        initializeShadeRoot({
+          injector,
+          rootElement,
+          jsxElement: <MarkdownDisplay content="[Link A](https://a.com) and [Link B](https://b.com)" />,
+        })
+
+        await flushUpdates()
+
+        const links = document.querySelectorAll<HTMLAnchorElement>('shade-markdown-display .md-link')
+        expect(links.length).toBe(2)
+
+        links[0].focus()
+        expect(document.activeElement).toBe(links[0])
+
+        links[1].focus()
+        expect(document.activeElement).toBe(links[1])
+      })
+    })
+
+    it('should make code blocks focusable via tabIndex', async () => {
+      await usingAsync(new Injector(), async (injector) => {
+        const rootElement = document.getElementById('root') as HTMLDivElement
+
+        initializeShadeRoot({
+          injector,
+          rootElement,
+          jsxElement: <MarkdownDisplay content={'```js\nconsole.log("hi")\n```'} />,
+        })
+
+        await flushUpdates()
+
+        const codeBlock = document.querySelector('shade-markdown-display .md-code-block') as HTMLPreElement
+        expect(codeBlock).not.toBeNull()
+        expect(codeBlock.tabIndex).toBe(0)
+
+        codeBlock.focus()
+        expect(document.activeElement).toBe(codeBlock)
+      })
+    })
+
+    it('should make checkbox inputs focusable when not disabled', async () => {
+      await usingAsync(new Injector(), async (injector) => {
+        const rootElement = document.getElementById('root') as HTMLDivElement
+
+        initializeShadeRoot({
+          injector,
+          rootElement,
+          jsxElement: <MarkdownDisplay content={'- [ ] Task A\n- [ ] Task B'} readOnly={false} onChange={() => {}} />,
+        })
+
+        await flushUpdates()
+
+        const checkboxes = document.querySelectorAll<HTMLInputElement>(
+          'shade-markdown-display shade-checkbox input[type="checkbox"]',
+        )
+        expect(checkboxes.length).toBe(2)
+
+        checkboxes[0].focus()
+        expect(document.activeElement).toBe(checkboxes[0])
+        expect(checkboxes[0].disabled).toBe(false)
+      })
+    })
+
+    it('should toggle checkbox via keyboard activation', async () => {
+      await usingAsync(new Injector(), async (injector) => {
+        const rootElement = document.getElementById('root') as HTMLDivElement
+        const onChange = vi.fn()
+
+        initializeShadeRoot({
+          injector,
+          rootElement,
+          jsxElement: <MarkdownDisplay content="- [ ] My Task" readOnly={false} onChange={onChange} />,
+        })
+
+        await flushUpdates()
+
+        const input = document.querySelector(
+          'shade-markdown-display shade-checkbox input[type="checkbox"]',
+        ) as HTMLInputElement
+        expect(input).not.toBeNull()
+
+        input.focus()
+        expect(document.activeElement).toBe(input)
+
+        input.click()
+        await flushUpdates()
+
+        expect(onChange).toHaveBeenCalledOnce()
+        expect(onChange).toHaveBeenCalledWith('- [x] My Task')
+      })
+    })
+
+    it('should have correct focus order for mixed interactive elements', async () => {
+      await usingAsync(new Injector(), async (injector) => {
+        const rootElement = document.getElementById('root') as HTMLDivElement
+
+        const content = [
+          '[First link](https://first.com)',
+          '',
+          '```js',
+          'code()',
+          '```',
+          '',
+          '[Second link](https://second.com)',
+        ].join('\n')
+
+        initializeShadeRoot({
+          injector,
+          rootElement,
+          jsxElement: <MarkdownDisplay content={content} />,
+        })
+
+        await flushUpdates()
+
+        const focusableElements = document.querySelectorAll(
+          'shade-markdown-display a[href], shade-markdown-display [tabindex="0"]',
+        )
+        expect(focusableElements.length).toBe(3)
+
+        const [firstLink, codeBlock, secondLink] = focusableElements
+        expect(firstLink.tagName).toBe('A')
+        expect(codeBlock.tagName).toBe('PRE')
+        expect(secondLink.tagName).toBe('A')
+      })
+    })
+  })
 })

package/src/components/markdown/markdown-display.tsx

@@ -60,7 +60,7 @@ const renderBlock = (
       return <Typography variant="body1">{renderInline(node.children)}</Typography>
     case 'codeBlock':
       return (
-        <pre className="md-code-block" data-language={node.language || undefined}>
+        <pre className="md-code-block" data-language={node.language || undefined} tabIndex={0}>
           <code>{node.content}</code>
         </pre>
       )
@@ -136,6 +136,11 @@ export const MarkdownDisplay = Shade<MarkdownDisplayProps>({
       whiteSpace: 'pre',
     },
 
+    '& .md-code-block:focus-visible': {
+      outline: cssVariableTheme.action.focusOutline,
+      outlineOffset: '-2px',
+    },
+
     '& .md-blockquote': {
       borderLeft: `4px solid ${cssVariableTheme.palette.primary.main}`,
       margin: `${cssVariableTheme.spacing.sm} 0`,
@@ -150,6 +155,12 @@ export const MarkdownDisplay = Shade<MarkdownDisplayProps>({
     '& .md-link:hover': {
       textDecoration: 'underline',
     },
+    '& .md-link:focus-visible': {
+      textDecoration: 'underline',
+      outline: cssVariableTheme.action.focusOutline,
+      outlineOffset: '2px',
+      borderRadius: cssVariableTheme.shape.borderRadius.xs,
+    },
 
     '& .md-image': {
       maxWidth: '100%',

package/src/components/markdown/markdown-editor.spec.tsx

@@ -400,4 +400,127 @@ describe('MarkdownEditor', () => {
       })
     })
   })
+
+  describe('keyboard navigation', () => {
+    it('should have a focusable textarea in side-by-side layout', async () => {
+      await usingAsync(new Injector(), async (injector) => {
+        const rootElement = document.getElementById('root') as HTMLDivElement
+
+        initializeShadeRoot({
+          injector,
+          rootElement,
+          jsxElement: <MarkdownEditor value="# Hello" />,
+        })
+
+        await flushUpdates()
+
+        const textarea = document.querySelector('shade-markdown-editor textarea') as HTMLTextAreaElement
+        expect(textarea).not.toBeNull()
+
+        textarea.focus()
+        expect(document.activeElement).toBe(textarea)
+      })
+    })
+
+    it('should have focusable tab buttons in tabs layout', async () => {
+      await usingAsync(new Injector(), async (injector) => {
+        const rootElement = document.getElementById('root') as HTMLDivElement
+
+        initializeShadeRoot({
+          injector,
+          rootElement,
+          jsxElement: <MarkdownEditor value="# Hello" layout="tabs" />,
+        })
+
+        await flushUpdates()
+
+        const tabButtons = document.querySelectorAll<HTMLButtonElement>('shade-markdown-editor .shade-tab-btn')
+        expect(tabButtons.length).toBe(2)
+
+        tabButtons[0].focus()
+        expect(document.activeElement).toBe(tabButtons[0])
+
+        tabButtons[1].focus()
+        expect(document.activeElement).toBe(tabButtons[1])
+      })
+    })
+
+    it('should use tabIndex to indicate active tab in controlled tabs layout', async () => {
+      await usingAsync(new Injector(), async (injector) => {
+        const rootElement = document.getElementById('root') as HTMLDivElement
+
+        initializeShadeRoot({
+          injector,
+          rootElement,
+          jsxElement: <MarkdownEditor value="# Hello" layout="tabs" />,
+        })
+
+        await flushUpdates()
+
+        const tabButtons = document.querySelectorAll<HTMLButtonElement>('shade-markdown-editor .shade-tab-btn')
+
+        const activeTab = Array.from(tabButtons).find((btn) => btn.classList.contains('active'))
+        const inactiveTab = Array.from(tabButtons).find((btn) => !btn.classList.contains('active'))
+
+        expect(activeTab).not.toBeUndefined()
+        expect(inactiveTab).not.toBeUndefined()
+        expect(activeTab?.tabIndex).toBe(0)
+        expect(inactiveTab?.tabIndex).toBe(-1)
+      })
+    })
+
+    it('should switch tabs when tab button is clicked via keyboard activation', async () => {
+      await usingAsync(new Injector(), async (injector) => {
+        const rootElement = document.getElementById('root') as HTMLDivElement
+
+        initializeShadeRoot({
+          injector,
+          rootElement,
+          jsxElement: <MarkdownEditor value="# Hello" layout="tabs" />,
+        })
+
+        await flushUpdates()
+
+        const tabButtons = document.querySelectorAll<HTMLButtonElement>('shade-markdown-editor .shade-tab-btn')
+
+        const previewButton = Array.from(tabButtons).find((btn) => btn.textContent?.includes('Preview'))
+        expect(previewButton).not.toBeUndefined()
+
+        previewButton!.click()
+        await flushUpdates()
+
+        const display = document.querySelector('shade-markdown-editor shade-markdown-display')
+        expect(display).not.toBeNull()
+      })
+    })
+
+    it('should have focusable interactive elements in preview pane', async () => {
+      await usingAsync(new Injector(), async (injector) => {
+        const rootElement = document.getElementById('root') as HTMLDivElement
+
+        initializeShadeRoot({
+          injector,
+          rootElement,
+          jsxElement: (
+            <MarkdownEditor
+              value={'- [ ] Task A\n- [x] Task B\n\n[A link](https://example.com)'}
+              onValueChange={() => {}}
+            />
+          ),
+        })
+
+        await flushUpdates()
+
+        const checkboxes = document.querySelectorAll(
+          'shade-markdown-editor shade-markdown-display shade-checkbox input[type="checkbox"]',
+        )
+        expect(checkboxes.length).toBe(2)
+
+        const link = document.querySelector('shade-markdown-editor shade-markdown-display .md-link')
+        expect(link).not.toBeNull()
+        ;(checkboxes[0] as HTMLElement).focus()
+        expect(document.activeElement).toBe(checkboxes[0])
+      })
+    })
+  })
 })

package/src/components/menu/menu.tsx

@@ -250,7 +250,7 @@ export const Menu = Shade<MenuProps>({
     useHostProps({
       role: mode === 'horizontal' ? 'menubar' : 'menu',
       'data-mode': mode,
-      tabindex: '0',
+      tabIndex: 0,
     })
 
     useHostProps({

package/src/components/modal.spec.tsx

@@ -1,5 +1,5 @@
 import { Injector } from '@furystack/inject'
-import { initializeShadeRoot, createComponent, Shade, flushUpdates } from '@furystack/shades'
+import { initializeShadeRoot, createComponent, Shade, flushUpdates, SpatialNavigationService } from '@furystack/shades'
 import { usingAsync } from '@furystack/utils'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import { Modal } from './modal.js'
@@ -308,4 +308,127 @@ describe('Modal', () => {
       })
     })
   })
+
+  describe('spatial navigation', () => {
+    it('should render with data-nav-section attribute when visible', async () => {
+      await usingAsync(new Injector(), async (injector) => {
+        const rootElement = document.getElementById('root') as HTMLDivElement
+
+        initializeShadeRoot({
+          injector,
+          rootElement,
+          jsxElement: (
+            <Modal isVisible={true}>
+              <div>Content</div>
+            </Modal>
+          ),
+        })
+
+        await flushUpdates()
+        const backdrop = document.querySelector('.shade-backdrop')
+        expect(backdrop?.getAttribute('data-nav-section')).toBeTruthy()
+      })
+    })
+
+    it('should render with custom navSection name', async () => {
+      await usingAsync(new Injector(), async (injector) => {
+        const rootElement = document.getElementById('root') as HTMLDivElement
+
+        initializeShadeRoot({
+          injector,
+          rootElement,
+          jsxElement: (
+            <Modal isVisible={true} navSection="my-modal">
+              <div>Content</div>
+            </Modal>
+          ),
+        })
+
+        await flushUpdates()
+        const backdrop = document.querySelector('.shade-backdrop')
+        expect(backdrop?.getAttribute('data-nav-section')).toBe('my-modal')
+      })
+    })
+
+    it('should push focus trap when trapFocus is true and service is active', async () => {
+      await usingAsync(new Injector(), async (injector) => {
+        const spatialNav = injector.getInstance(SpatialNavigationService)
+        const pushSpy = vi.spyOn(spatialNav, 'pushFocusTrap')
+
+        const rootElement = document.getElementById('root') as HTMLDivElement
+
+        initializeShadeRoot({
+          injector,
+          rootElement,
+          jsxElement: (
+            <Modal isVisible={true} trapFocus={true} navSection="trapped-modal">
+              <div>Content</div>
+            </Modal>
+          ),
+        })
+
+        await flushUpdates()
+
+        expect(pushSpy).toHaveBeenCalledWith('trapped-modal')
+        expect(spatialNav.activeSection.getValue()).toBe('trapped-modal')
+      })
+    })
+
+    it('should not push focus trap when trapFocus is false', async () => {
+      await usingAsync(new Injector(), async (injector) => {
+        const spatialNav = injector.getInstance(SpatialNavigationService)
+        const pushSpy = vi.spyOn(spatialNav, 'pushFocusTrap')
+
+        const rootElement = document.getElementById('root') as HTMLDivElement
+
+        initializeShadeRoot({
+          injector,
+          rootElement,
+          jsxElement: (
+            <Modal isVisible={true} trapFocus={false}>
+              <div>Content</div>
+            </Modal>
+          ),
+        })
+
+        await flushUpdates()
+
+        expect(pushSpy).not.toHaveBeenCalled()
+        spatialNav.activeSection.setValue('other-section')
+        expect(spatialNav.activeSection.getValue()).toBe('other-section')
+      })
+    })
+
+    it('should pop focus trap when visibility changes from true to false', async () => {
+      let setVisible!: (v: boolean) => void
+
+      const Wrapper = Shade({
+        customElementName: 'modal-trap-visibility-test',
+        render: ({ useState }) => {
+          const [visible, setter] = useState('visible', true)
+          setVisible = setter
+          return (
+            <Modal isVisible={visible} trapFocus={true} navSection="trap-test">
+              <div>Content</div>
+            </Modal>
+          )
+        },
+      })
+
+      await usingAsync(new Injector(), async (injector) => {
+        const spatialNav = injector.getInstance(SpatialNavigationService)
+        const rootElement = document.getElementById('root') as HTMLDivElement
+
+        initializeShadeRoot({ injector, rootElement, jsxElement: <Wrapper /> })
+        await flushUpdates()
+
+        expect(spatialNav.activeSection.getValue()).toBe('trap-test')
+
+        setVisible(false)
+        await flushUpdates()
+
+        expect(spatialNav.activeSection.getValue()).not.toBe('trap-test')
+      })
+    })
+  })
 })

package/src/components/modal.tsx

@@ -1,12 +1,24 @@
-import { Shade, createComponent } from '@furystack/shades'
+import { Shade, createComponent, SpatialNavigationService } from '@furystack/shades'
 import { cssVariableTheme } from '../services/css-variable-theme.js'
 
+let nextModalId = 0
+
 export type ModalProps = {
   backdropStyle?: Partial<CSSStyleDeclaration>
   isVisible: boolean
   onClose?: () => void
   showAnimation?: (el: Element | null) => Promise<unknown>
   hideAnimation?: (el: Element | null) => Promise<unknown>
+  /**
+   * When true, traps spatial navigation within the modal's bounds.
+   * If SpatialNavigationService is not yet instantiated, it will be created with defaults.
+   */
+  trapFocus?: boolean
+  /**
+   * Section name for spatial navigation scoping.
+   * @default 'modal'
+   */
+  navSection?: string
 }
 
 export const Modal = Shade<ModalProps>({
@@ -22,9 +34,34 @@ export const Modal = Shade<ModalProps>({
       left: '0',
     },
   },
-  render: ({ props, children, useRef }) => {
-    const { isVisible } = props
+  render: ({ props, children, injector, useRef, useDisposable, useState }) => {
+    const { isVisible, trapFocus, navSection } = props
     const backdropRef = useRef<HTMLDivElement>('backdrop')
+    const [generatedSectionId] = useState('generatedSectionId', String(nextModalId++))
+    const sectionName = navSection ?? `modal-${generatedSectionId}`
+
+    useDisposable(
+      'spatial-nav-trap',
+      () => {
+        if (!isVisible || !trapFocus) return { [Symbol.dispose]: () => {} }
+
+        const spatialNav = injector.getInstance(SpatialNavigationService)
+
+        const previousSection = spatialNav.activeSection.getValue()
+        spatialNav.pushFocusTrap(sectionName)
+
+        return {
+          [Symbol.dispose]: () => {
+            try {
+              spatialNav.popFocusTrap(sectionName, previousSection)
+            } catch {
+              // Service may already be disposed during injector teardown
+            }
+          },
+        }
+      },
+      [isVisible, trapFocus],
+    )
 
     if (isVisible) {
       queueMicrotask(() => {
@@ -36,6 +73,7 @@ export const Modal = Shade<ModalProps>({
       <div
         ref={backdropRef}
         className="shade-backdrop"
+        data-nav-section={sectionName}
         onclick={async () => {
           await props.hideAnimation?.(backdropRef.current)
           props.onClose?.()

package/src/components/page-layout/index.spec.tsx

@@ -647,6 +647,26 @@ describe('PageLayout component', () => {
       })
     })
 
+    it('should set data-nav-section="content" on the content area for spatial navigation scoping', async () => {
+      await usingAsync(new Injector(), async (injector) => {
+        const rootElement = document.getElementById('root') as HTMLDivElement
+
+        initializeShadeRoot({
+          injector,
+          rootElement,
+          jsxElement: (
+            <PageLayout>
+              <div>Content</div>
+            </PageLayout>
+          ),
+        })
+
+        await flushUpdates()
+        const contentArea = document.querySelector('.page-layout-content')
+        expect(contentArea?.getAttribute('data-nav-section')).toBe('content')
+      })
+    })
+
     it('should set CSS variable for zero paddingTop when no AppBar is configured', async () => {
       await usingAsync(new Injector(), async (injector) => {
         const rootElement = document.getElementById('root') as HTMLDivElement

package/src/components/page-layout/index.tsx

@@ -407,7 +407,7 @@ export const PageLayout = Shade<PageLayoutProps>({
         )}
 
         {/* Main Content */}
-        <main className="page-layout-content" data-testid="page-layout-content">
+        <main className="page-layout-content" data-testid="page-layout-content" data-nav-section="content">
           {children}
         </main>
       </div>