@duro-app/ui 5.24.0 → 5.26.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duro-app/ui",
-  "version": "5.24.0",
+  "version": "5.26.0",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -92,7 +92,7 @@
   "dependencies": {
     "@tanstack/react-virtual": "^3.14.13",
     "qrcode": "^1.5.4",
-    "@duro-app/tokens": "^5.24.0"
+    "@duro-app/tokens": "^5.26.0"
   },
   "devDependencies": {
     "@babel/preset-typescript": "^7.28.0",

package/src/components/Tree/Tree.meta.ts

@@ -2,7 +2,7 @@ import type {ComponentMeta} from '../component-meta'
 
 export const meta: ComponentMeta = {
   description:
-    'Hierarchy of items with single selection and expandable branches (the WAI-ARIA tree pattern): one tab stop, arrow keys, Home/End, typeahead. A click or Enter on a branch row with no href selects it and toggles it open or closed (a folder); a branch with href navigates, and its chevron toggles. An Item with href renders its row as a real link (cmd-click opens a tab) outside the tab order; Enter/Space follows it, through onNavigate(href, event) when given. Compound component — Root is required. On React Native each row is a pressable link (href) or button, and a branch has its own chevron control that expands it (named by the optional Root prop expandLabel(text), default the item text); selection, expansion and aria-level are the same, the keyboard model (arrows, Home/End, typeahead) is web only. On native onNavigate is required for in-app routes: without it a relative href goes to the system (Linking.openURL). On web a tree with more items than Root virtualizeThreshold (default 150, open or not) is windowed: only the rows in view mount, as flat treeitems with aria-level, aria-setsize and aria-posinset; maxHeight caps its scroll viewport. Items must be JSX descendants of Root (fragments and arrays are fine, an Item hidden inside another component is not seen by the window). Native renders every row.',
+    'Hierarchy of items with single selection and expandable branches (the WAI-ARIA tree pattern): one tab stop, arrow keys, Home/End, typeahead. A click or Enter on a branch row with no href selects it and toggles it open or closed (a folder); a branch with href navigates, and its chevron toggles. An Item with expandable is a branch before its children exist (a directory listed only when opened): it opens like any branch and onExpandedChange tells the app to load them. An Item with href renders its row as a real link (cmd-click opens a tab) outside the tab order; Enter/Space follows it, through onNavigate(href, event) when given. Compound component — Root is required. On React Native each row is a pressable link (href) or button, and a branch has its own chevron control that expands it (named by the optional Root prop expandLabel(text), default the item text); selection, expansion and aria-level are the same, the keyboard model (arrows, Home/End, typeahead) is web only. On native onNavigate is required for in-app routes: without it a relative href goes to the system (Linking.openURL). On web a tree with more items than Root virtualizeThreshold (default 150, open or not) is windowed: only the rows in view mount, as flat treeitems with aria-level, aria-setsize and aria-posinset; maxHeight caps its scroll viewport. Items must be JSX descendants of Root (fragments and arrays are fine, an Item hidden inside another component is not seen by the window). Native renders every row.',
   whenToUse: [
     'Browsing data that nests to any depth — a file tree, zones › services › capabilities, namespace › resource',
     'Picking one node of a hierarchy to show its details beside the tree',

package/src/components/Tree/Tree.stories.tsx

@@ -616,3 +616,42 @@ export const BranchRowToggles: Story = {
     await expect(branch).toHaveAttribute('aria-expanded', 'false')
   },
 }
+
+/** A file tree that lists a directory only when it is opened (`expandable`). */
+function LazyFolders() {
+  const [expanded, setExpanded] = useState<string[]>([])
+  const [loaded, setLoaded] = useState<ReadonlySet<string>>(() => new Set())
+  return (
+    <Tree.Root
+      aria-label="Folders"
+      expanded={expanded}
+      onExpandedChange={(next) => {
+        setExpanded(next)
+        // The app lists a directory the first time it opens.
+        setLoaded((prev) => new Set([...prev, ...next]))
+      }}
+    >
+      <Tree.Item value="src" label="src" expandable>
+        {loaded.has('src') ? <Tree.Item value="app" label="app.ts" /> : null}
+      </Tree.Item>
+      <Tree.Item value="readme" label="README.md" />
+    </Tree.Root>
+  )
+}
+
+export const ExpandableBranchLoadsOnOpen: Story = {
+  name: 'Expandable branch loads on open',
+  render: () => <LazyFolders />,
+  play: async ({canvas, userEvent}) => {
+    const branch = canvas.getByRole('treeitem', {name: 'src'})
+    // A branch before its children exist: it can open, a leaf cannot.
+    await expect(branch).toHaveAttribute('aria-expanded', 'false')
+    await expect(canvas.getByRole('treeitem', {name: 'README.md'})).not.toHaveAttribute(
+      'aria-expanded',
+    )
+    branch.focus()
+    await userEvent.keyboard('{ArrowRight}')
+    await expect(branch).toHaveAttribute('aria-expanded', 'true')
+    await expect(await canvas.findByRole('treeitem', {name: 'app.ts'})).toBeVisible()
+  },
+}

package/src/components/Tree/Tree.tsx

@@ -164,10 +164,19 @@ function Root({
 
 // --- Item ---
 
-function Item({value, label, textValue, children, meta, href, onNavigate}: TreeItemProps) {
+function Item({
+  value,
+  label,
+  textValue,
+  children,
+  meta,
+  href,
+  onNavigate,
+  expandable,
+}: TreeItemProps) {
   const {isExpanded} = useTree()
   const level = useContext(TreeLevelContext)
-  const hasChildren = Children.count(children) > 0
+  const hasChildren = Children.count(children) > 0 || expandable === true
 
   return (
     <TreeItemRow

package/src/components/Tree/TreeRows.ts

@@ -9,8 +9,14 @@ export interface TreeItemProps {
   label: ReactNode
   /** plain text for typeahead when `label` isn't a string */
   textValue?: string
-  /** nested items: the branch's children (none = a leaf) */
+  /** nested items: the branch's children (none = a leaf, unless `expandable`) */
   children?: ReactNode
+  /**
+   * A branch before its children exist (a directory not listed yet): it shows the
+   * chevron and opens like any branch, and `onExpandedChange` tells the app to load
+   * them. Pass the children once they are there (or a loading row meanwhile).
+   */
+  expandable?: boolean
   /** trailing content on the row (a count, a status) */
   meta?: ReactNode
   /**
@@ -97,8 +103,17 @@ export function collectRows(
   const visit = (nodes: ReactNode, level: number, parent: string | null, visible: boolean) => {
     const items = itemsOf(nodes, isItem)
     items.forEach((item, index) => {
-      const {value, label, textValue, children: nested, meta, href, onNavigate} = item.props
-      const hasChildren = Children.count(nested) > 0
+      const {
+        value,
+        label,
+        textValue,
+        children: nested,
+        meta,
+        href,
+        onNavigate,
+        expandable,
+      } = item.props
+      const hasChildren = Children.count(nested) > 0 || expandable === true
       if (hasChildren && countLeaves(nested) !== itemsOf(nested, isItem).length) complete = false
       const open = hasChildren && isOpen(value)
       total += 1

package/src/components/VirtualList/VirtualList.meta.ts

@@ -2,7 +2,7 @@ import type {ComponentMeta} from '../component-meta'
 
 export const meta: ComponentMeta = {
   description:
-    'A windowed list on @tanstack/react-virtual: only the rows in view (plus overscan) are mounted, and rows are measured so they may differ in height. role="list" with listitem rows carrying aria-setsize and aria-posinset. anchor="end" opens at the last item and stays pinned to the bottom while new items arrive and the reader is at the bottom (a transcript, a log). It fills its parent, or stops at maxHeight. onStartReached fires once each time the reader scrolls to the start (load older history), and prepending items keeps the first visible row in place. On native it is a FlatList with the same props (role list; rows carry no listitem role, which React Native lacks) (maintainVisibleContentPosition for prepend). The scroll region is a tab stop with a focus ring, so the keyboard can scroll rows that hold no control.',
+    'A windowed list on @tanstack/react-virtual: only the rows in view (plus overscan) are mounted, and rows are measured so they may differ in height. role="list" with listitem rows carrying aria-setsize and aria-posinset. anchor="end" opens at the last item and stays pinned to the bottom while new items arrive and the reader is at the bottom (a transcript, a log). It fills its parent, or stops at maxHeight. onStartReached fires once each time the reader scrolls to the start (load older history), and prepending items keeps the first visible row in place. On native it is a FlatList with the same props (role list; rows carry no listitem role, which React Native lacks) (maintainVisibleContentPosition for prepend). The scroll region is a tab stop with a focus ring, so the keyboard can scroll rows that hold no control. onEndReached mirrors onStartReached at the end (load newer items in a window opened on an older point); scrollToKey centres one item each time it changes to a key in the list (a link to one message), and anchor="end" stops following the end while it applies.',
   whenToUse: [
     'Hundreds to tens of thousands of rows: sessions, a chat transcript, log lines',
     'A list that grows at the bottom while the reader follows it (anchor="end")',

package/src/components/VirtualList/VirtualList.native.tsx

@@ -1,4 +1,4 @@
-import {useCallback, useRef} from 'react'
+import {useCallback, useEffect, useRef} from 'react'
 import {FlatList, type NativeScrollEvent, type NativeSyntheticEvent, StyleSheet} from 'react-native'
 import {html} from 'react-strict-dom'
 import {SIZES_PX} from '@duro-app/tokens/keys'
@@ -31,6 +31,8 @@ export function VirtualList<T>({
   getKey,
   anchor = 'start',
   onStartReached,
+  onEndReached,
+  scrollToKey,
   maxHeight,
   'aria-label': ariaLabel,
 }: VirtualListProps<T>) {
@@ -43,6 +45,18 @@ export function VirtualList<T>({
       contentSize.height - contentOffset.y - layoutMeasurement.height <= BOTTOM_SLOP
   }, [])
 
+  // `scrollToKey`: centre that item once per key, as soon as the items hold it.
+  const scrolledTo = useRef<string | number | null | undefined>(undefined)
+  useEffect(() => {
+    if (scrollToKey === null || scrollToKey === undefined || scrolledTo.current === scrollToKey)
+      return
+    const at = items.findIndex((item, i) => getKey(item, i) === scrollToKey)
+    if (at < 0) return
+    scrolledTo.current = scrollToKey
+    atBottom.current = false
+    listRef.current?.scrollToIndex({index: at, viewPosition: 0.5, animated: false})
+  }, [getKey, items, scrollToKey])
+
   const followEnd = useCallback(() => {
     if (anchor === 'end' && atBottom.current) listRef.current?.scrollToEnd({animated: false})
   }, [anchor])
@@ -65,6 +79,15 @@ export function VirtualList<T>({
         maintainVisibleContentPosition={MAINTAIN_POSITION}
         onStartReached={onStartReached ? () => onStartReached() : undefined}
         onStartReachedThreshold={0.1}
+        onEndReached={onEndReached ? () => onEndReached() : undefined}
+        onEndReachedThreshold={0.1}
+        // A row not measured yet: jump near it by estimate, then centre it once laid out.
+        onScrollToIndexFailed={({index, averageItemLength}) => {
+          listRef.current?.scrollToOffset({offset: index * averageItemLength, animated: false})
+          requestAnimationFrame(() =>
+            listRef.current?.scrollToIndex({index, viewPosition: 0.5, animated: false}),
+          )
+        }}
         onScroll={onScroll}
         scrollEventThrottle={16}
         onContentSizeChange={followEnd}

package/src/components/VirtualList/VirtualList.stories.tsx

@@ -263,3 +263,65 @@ export const ShortListDoesNotLoopOnFreshArrays: StoryObj<{onStartReached: () =>
     await expect(args.onStartReached).toHaveBeenCalledTimes(1)
   },
 }
+
+/** A link to one message: the list opens anchored to the end, then centres that message. */
+function JumpTo({target}: {target: number | null}) {
+  return (
+    <VirtualList
+      aria-label="Transcript"
+      items={ITEMS}
+      getKey={(m) => m.id}
+      estimateSize="controlLg"
+      anchor="end"
+      scrollToKey={target}
+      maxHeight="previewMaxH"
+      renderItem={(m) => <Text>{m.text}</Text>}
+    />
+  )
+}
+
+export const ScrollToKeyCentresTheItem: Story = {
+  render: () => <JumpTo target={4_200} />,
+  play: async ({canvas}) => {
+    const list = canvas.getByRole('list', {name: 'Transcript'})
+    const row = await waitFor(() => canvas.getByText('Message 4201'))
+    const listBox = list.getBoundingClientRect()
+    const rowBox = row.getBoundingClientRect()
+    await expect(rowBox.top).toBeGreaterThanOrEqual(listBox.top)
+    await expect(rowBox.bottom).toBeLessThanOrEqual(listBox.bottom)
+    // It stays there: anchor="end" does not pull it back to the last message.
+    await new Promise((resolve) => requestAnimationFrame(() => requestAnimationFrame(resolve)))
+    await expect(canvas.queryByText('Message 10000')).toBeNull()
+  },
+}
+
+export const EndReachedFiresOncePerApproach: StoryObj<{onEndReached: () => void}> = {
+  args: {onEndReached: fn()},
+  render: (args) => (
+    <VirtualList
+      aria-label="Transcript"
+      items={ITEMS.slice(0, 200)}
+      getKey={(m) => m.id}
+      estimateSize="controlLg"
+      onEndReached={args.onEndReached}
+      maxHeight="previewMaxH"
+      renderItem={(m) => <Text>{m.text}</Text>}
+    />
+  ),
+  play: async ({canvas, args}) => {
+    const list = canvas.getByRole('list', {name: 'Transcript'})
+    await waitFor(() => expect(canvas.getAllByRole('listitem').length).toBeGreaterThan(0))
+    const scrollTo = async (top: number) => {
+      list.scrollTop = top
+      await new Promise((resolve) => requestAnimationFrame(() => requestAnimationFrame(resolve)))
+    }
+    await expect(args.onEndReached).not.toHaveBeenCalled()
+    await scrollTo(list.scrollHeight)
+    await waitFor(() => expect(args.onEndReached).toHaveBeenCalledTimes(1))
+    await scrollTo(list.scrollHeight)
+    await expect(args.onEndReached).toHaveBeenCalledTimes(1)
+    await scrollTo(0)
+    await scrollTo(list.scrollHeight)
+    await waitFor(() => expect(args.onEndReached).toHaveBeenCalledTimes(2))
+  },
+}

package/src/components/VirtualList/VirtualList.tsx

@@ -33,6 +33,8 @@ export function VirtualList<T>({
   overscan = 5,
   anchor = 'start',
   onStartReached,
+  onEndReached,
+  scrollToKey,
   maxHeight,
   'aria-label': ariaLabel,
 }: VirtualListProps<T>) {
@@ -52,6 +54,9 @@ export function VirtualList<T>({
   const startArmed = useRef(true)
   const startCallback = useRef(onStartReached)
   startCallback.current = onStartReached
+  const endArmed = useRef(true)
+  const endCallback = useRef(onEndReached)
+  endCallback.current = onEndReached
   // The items a short list last asked more for: a new array with the same
   // first key and length is the same content, so it does not ask again.
   const askedFor = useRef<string | undefined>(undefined)
@@ -60,6 +65,12 @@ export function VirtualList<T>({
     if (!el) return
     const onScroll = () => {
       atBottom.current = el.scrollHeight - el.scrollTop - el.clientHeight <= BOTTOM_SLOP
+      if (!atBottom.current) {
+        endArmed.current = true
+      } else if (endArmed.current && el.scrollHeight > el.clientHeight) {
+        endArmed.current = false
+        endCallback.current?.()
+      }
       if (el.scrollTop > START_SLOP) {
         startArmed.current = true
       } else if (startArmed.current) {
@@ -156,6 +167,18 @@ export function VirtualList<T>({
     // Runs when `items` changes; scrolling is read by the frame-coalesced listener.
   }, [items, readSeenRow, virtualizer])
 
+  // `scrollToKey`: centre that item once per key, as soon as the items hold it.
+  const scrolledTo = useRef<string | number | null | undefined>(undefined)
+  useLayoutEffect(() => {
+    if (scrollToKey === null || scrollToKey === undefined || scrolledTo.current === scrollToKey)
+      return
+    const at = items.findIndex((item, i) => getKeyRef.current(item, i) === scrollToKey)
+    if (at < 0) return
+    scrolledTo.current = scrollToKey
+    atBottom.current = false
+    virtualizer.scrollToIndex(at, {align: 'center'})
+  }, [items, scrollToKey, virtualizer])
+
   useLayoutEffect(() => {
     if (anchor !== 'end' || items.length === 0 || !atBottom.current) return
     virtualizer.scrollToIndex(items.length - 1, {align: 'end'})

package/src/components/VirtualList/props.ts

@@ -24,6 +24,19 @@ export interface VirtualListProps<T> {
    * Prepending items keeps the first visible row where it was on screen.
    */
   onStartReached?: () => void
+  /**
+   * Called once each time the reader scrolls to within 44px (touchTarget) of the
+   * end (load newer items, as in a window opened on an older point). It fires
+   * again only after they move away.
+   */
+  onEndReached?: () => void
+  /**
+   * Bring this item into view, centred, each time the key changes to an item in
+   * the list (a link to one message). A key not in the list yet waits for the
+   * items that hold it; `null` or `undefined` does nothing. While it applies,
+   * `anchor="end"` stops following the end.
+   */
+  scrollToKey?: string | number | null
   /** Cap the list's height; without it, it fills its parent. */
   maxHeight?: Length
   /** The list's accessible name. */