@capra/core 1.12.0 → 1.14.0

package/docs/core-autocompletefield--usage.md

@@ -5,7 +5,7 @@ AutocompleteField combines a text field with a suggestions list. Consumers can s
 | Prop | Type | Required | Default | Description |
 | --- | --- | --- | --- | --- |
 | `canClear` | `boolean` | No | `--` | Whether to show a clear button for the input. |
-| `children` | `React.ReactNode \| ((     values: T & {       defaultChildren: React.ReactNode \| undefined;     },   ) => React.ReactNode)` | No | `--` | The children to render in the dropdown. |
+| `children` | `ChildrenOrFunction` | No | `--` | The children to render in the dropdown. |
 | `itemFilter` | `(textValue: string, inputValue: string) => boolean` | No | `--` | A function that filters the items based on the input value. |
 | `onChange` | `(value: string) => void` | No | `--` | A callback function that is called when the input value changes. |
 | `onOpenChange` | `(isOpen: boolean) => void` | No | `--` | A callback function that is called when the dropdown is opened or closed. |

package/docs/core-badge--design.md

@@ -16,6 +16,10 @@ Badges support `md` and `sm` sizes. Use `sm` when composing with smaller control
 
 Use a dot to show notifications without a count.
 
+### Decorative
+
+Use `decorative` when the badge is purely visual and its meaning is already conveyed nearby, such as adjacent text. Decorative badges are removed from the accessibility tree and must not be combined with `aria-label` or `aria-labelledby`.
+
 ### Appearance
 
 Badges can be colored based on their status. The `attention` appearance is the general purpose color used for numbered badges and does not necessarily communicate severity.
@@ -49,6 +53,7 @@ Do:
 * Do cap displayed values at 99 with a "99+" label.
 * Do use the dot variant for simple presence indicators.
 * Do associate interactive anchors with badge count context using `aria-describedby`.
+* Do use `decorative` when the badge is redundant with nearby text or another accessible name.
 
 Don't:
 
@@ -57,12 +62,15 @@ Don't:
 * Don't place Badge on non-interactive decorative elements.
 * Don't use Badge colors as the only method to communicate status.
 * Don't include badge count context in the anchor's `aria-label`.
+* Don't combine `decorative` with `aria-label` or `aria-labelledby`.
 
 ## Accessibility
 
-* Badge requires an accessible label via `aria-label` or `aria-labelledby` that describes the count or status (e.g., "76 unread").
+* Named badges require `aria-label` or `aria-labelledby` that describes the count or status (e.g., "76 unread").
+* Counter badges use `role="status"` so naming attributes are valid and the visible count is not presentational. Dot badges use `role="img"` because they have no text.
+* Use `decorative` when the badge is purely presentational and the meaning is already available to assistive technology. Decorative badges omit the role and accessible name and set `aria-hidden`. Do not combine `decorative` with `aria-label` or `aria-labelledby`.
 * When composing with interactive controls such as `Button` or `IconButton`, set `aria-describedby` on the anchor to the badge's `id`. Keep the anchor's accessible name limited to the control action or label (e.g., "Messages"), not the badge content.
-* Use `aria-live="polite"` on the parent for dynamic badge updates.
+* Counter badges are a polite live region via `role="status"`. Use `aria-live="polite"` on a parent only when you need to announce grouped updates beyond the badge itself.
 
 ## Content
 

package/docs/core-badge--usage.md

@@ -13,4 +13,10 @@ Badges display an indicator/counter on an associated component.
 | `className` | `never` | No | `--` | Use `FORCE__className` instead. |
 | `style` | `never` | No | `--` | Inline styles are not supported; use component props or `FORCE__className`. |
 | `FORCE__className` | `string` | No | `--` | 🚨 This prop is meant to be an escape hatch. 🚨<br><br>If the desired style cannot be achieved using component props, use this as a last resort. The inner workings of Capra components are implementation details and this escape hatch gives one access to those implementation details. We cannot make any guarantees that styles will applied correctly across version updates. Please use it responsibly.<br><br>Add a CSS class to the component. |
-| `aria-live` | `React.AriaAttributes['aria-live']` | No | `--` | `--` |
+| `aria-live` | `React.AriaAttributes['aria-live']` | No | `--` | `--` |
+
+## Accessibility
+
+Named badges require `aria-label` or `aria-labelledby`. Counter badges expose `role="status"` so the visible count is not treated as presentational. Dot badges expose `role="img"` because they have no text.
+
+Use `decorative` when the badge is purely presentational and the meaning is already conveyed nearby. Decorative badges omit the role and accessible name and set `aria-hidden`. Do not combine `decorative` with `aria-label` or `aria-labelledby`.

package/docs/core-checkbox--usage.md

@@ -8,6 +8,7 @@ Checkbox component for capturing boolean user input. Supports controlled and unc
 | `checked` | `boolean` | No | `--` | Controlled checked state. Use with onChange for controlled component. |
 | `defaultChecked` | `boolean` | No | `--` | Default checked state for uncontrolled component. |
 | `children` | `string \| React.ReactNode` | No | `--` | The label for the checkbox. |
+| `slot` | `string \| null` | No | `--` | Slot name for React Aria context wiring (e.g. "selection" in Table). |
 | `className` | `never` | No | `--` | Use `FORCE__className` instead. |
 | `style` | `never` | No | `--` | Inline styles are not supported; use component props or `FORCE__className`. |
 | `FORCE__className` | `string` | No | `--` | 🚨 This prop is meant to be an escape hatch. 🚨<br><br>If the desired style cannot be achieved using component props, use this as a last resort. The inner workings of Capra components are implementation details and this escape hatch gives one access to those implementation details. We cannot make any guarantees that styles will applied correctly across version updates. Please use it responsibly.<br><br>Add a CSS class to the component. |

package/docs/core-selectfield--design.md

@@ -0,0 +1,66 @@
+# Core/SelectField - Design
+
+## Anatomy
+
+1. **Label**: describes the field and carries the required marker when needed.
+2. **Trigger**: matches Capra text-input sizing and state treatments.
+3. **Popover**: contains the option list and optional search field.
+4. **ListBox items**: support single-select rows or multi-select rows with checkmarks.
+5. **Sections**: optional grouped options with a non-selectable header label.
+
+## Properties
+
+### Layout
+
+Use `layout="vertical"` by default. Use `layout="horizontal"` only when space is constrained.
+
+### Multiple Selection
+
+For multi-select fields, selected options appear as removable tags inside the trigger. Tags wrap onto additional lines when they exceed the field width, and selected rows show a checkmark in the popover.
+
+### Search
+
+Enable `canSearch` for longer option lists. Search filters the visible options inside the popover without changing the trigger layout. When nothing matches, the popover shows "No results" so the list never appears empty.
+
+### Sections
+
+Larger option lists can be organized into smaller groups using sections. Each section has a header to label the grouping. Pass `items` with nested `children` to build sections from data, or wrap static options in `SelectField.Section` with a `SelectField.Header`.
+
+## States
+
+* Match the standard input states: default, hover, focus, disabled, placeholder, warning, and danger.
+* `appearance="danger"` drives the invalid visual state and helper text treatment.
+* Small and medium sizes align with `TextInput`.
+
+## Behavior
+
+* Use `SelectField` for fixed option sets, especially when the option count is greater than about five.
+* Prefer `RadioGroup` when the user should see all mutually exclusive choices at once.
+* Prefer `AutocompleteField` when freeform typing or custom values are required.
+
+## Accessibility
+
+### Keyboard interaction
+
+| Key                          | Function                                                                                                                                                                                                                                                                             |
+| ---------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `Tab` / `Shift + Tab`        | Moves focus into the multiselect TagGroup (first selected tag) or the open button, then to the next or previous focusable element. Remove buttons are not sequential tab stops. If the option list is open, these keys are ignored.                                                  |
+| `Left Arrow` / `Right Arrow` | In multiple-select mode with the TagGroup focused: moves focus between selected tags.                                                                                                                                                                                                |
+| `Delete` / `Backspace`       | In multiple-select mode with a selected tag focused: removes that tag.                                                                                                                                                                                                               |
+| `Down Arrow` / `Up Arrow`    | If the option list is closed and the open button has focus: opens the list and moves focus to the selected item (the first selected item in multiple-select mode), or the first/last item when nothing is selected. If the list is open: moves focus to the next or previous option. |
+| `Enter` / `Space`            | If the option list is closed: opens the option list (from the open button). If the list is open: selects the focused option. In single-select mode the list closes after selection; in multiple-select mode the list stays open.                                                     |
+| `Esc`                        | If the option list is open: closes the list and returns focus to the select trigger.                                                                                                                                                                                                 |
+
+While the option list is open, focus stays inside the popover in both selection modes.
+
+In multiple-select mode, selected values use React Aria’s `TagGroup` in the trigger (styled to match Capra Tag). Keyboard behavior follows TagGroup defaults: arrows move between tags; Delete/Backspace removes; clicking the remove control also removes.
+
+### Labeling
+
+All select fields require a label. Provide a visible `label` prop when possible. When a visible label is not spatially associated with the trigger, use `aria-label` or `aria-labelledby`.
+
+### Focus treatment
+
+* The trigger uses the Capra 2px focus outline (`token('border.focus')`).
+* List options show a keyboard focus ring on the active row; the popover container suppresses the browser default panel outline (same pattern as `Menu`).
+* Warning and danger icons in the trigger are decorative (`aria-hidden`); invalid state is conveyed with `aria-invalid` on the trigger.

package/docs/core-selectfield--usage.md

@@ -0,0 +1,145 @@
+# Core/SelectField - Usage
+
+## Basic usage
+
+```tsx
+import { SelectField } from '@private/core';
+
+const animals = [
+  { id: '1', label: 'Dog' },
+  { id: '2', label: 'Cat' },
+  { id: '3', label: 'Bird' },
+];
+
+function Example() {
+  return (
+    <SelectField label="Animal" placeholder="Select" items={animals} />
+  );
+}
+```
+
+## Props
+
+## Examples
+
+### Single select
+
+Pass `items` to render a list of options. Each item should have an `id` and a `label` property if using the default item renderer. You can also pass a custom item renderer to render each item as you need (see [Custom item renderer](#custom-item-renderer)).
+
+```tsx
+const animals = [
+  { id: '1', label: 'Dog' },
+  { id: '2', label: 'Cat' },
+  { id: '3', label: 'Bird' },
+];
+
+<SelectField label="Animal" placeholder="Select" items={animals} />
+```
+
+### Multiple select
+
+Set `selectionMode="multiple"` when more than one value can be selected. Selected options render as tags in the input.
+
+```tsx
+const states = [
+  { id: '1', label: 'California' },
+  { id: '2', label: 'New York' },
+  { id: '3', label: 'Texas' },
+];
+
+<SelectField label="States" selectionMode="multiple" defaultValue={['CA', 'NY']} items={states} />
+```
+
+### Custom item renderer
+
+When the default item renderer doesn't meet your needs, you can provide a custom item renderer. Each item **must** be a `SelectField.Item` or `SelectField.Section` component. `SelectField.Item` should be passed an `id` and `textValue` prop. `textValue` is used for typeahead and accessibility naming.
+
+:::warning
+
+For performance reasons, custom item renderers are cached on component mount. Custom item render functions should be pure functions that take only the passed item as an argument. Any reliance on external state or props will mostly likely cause unexpected and undesired behavior.
+
+:::
+
+```tsx
+const users = [
+  { id: '1', name: 'Malcolm Reynolds', email: 'malcolm.reynolds@example.com' },
+  { id: '2', name: 'Inara Serra', email: 'inara.serra@example.com' },
+  { id: '3', name: 'Kaylee Frye', email: 'kaylee.frye@example.com' },
+];
+
+<SelectField label="Users" selectionMode="multiple" defaultValue={['1', '2']} items={users}>
+  {(user) => (
+    <SelectField.Item id={user.id} textValue={user.name}>
+      <div>{user.name}</div>
+      <div>{user.email}</div>
+    </SelectField.Item>
+  )}
+</SelectField>
+```
+
+### Searchable options
+
+Enable `canSearch` for longer lists so users can filter options inside the popover.
+
+```tsx
+const categories = [
+  { id: '1', name: 'Electronics' },
+  { id: '2', name: 'Clothing' },
+  { id: '3', name: 'Books' },
+  // ...
+  { id: '100', name: 'Other' },
+];
+
+<SelectField label="Category" items={categories} canSearch searchPlaceholder="Search categories">
+  {(item) => (
+    <SelectField.Item id={item.id} textValue={item.name}>
+      {item.name}
+    </SelectField.Item>
+  )}
+</SelectField>
+```
+
+When a search matches none of the options, the popover shows "No results" in place of the option list.
+
+### Sections
+
+Organize larger option lists into labeled groups by passing `items` with nested `children`, using the default item renderer. If a section has no visible `label`, provide `aria-label` on the section.
+
+```tsx
+const items = [
+  {
+    id: 'fruit',
+    label: 'Fruit',
+    children: [
+      { id: 'apple', label: 'Apple' },
+      { id: 'banana', label: 'Banana' },
+    ],
+  },
+  {
+    id: 'veg',
+    label: 'Vegetable',
+    children: [
+      { id: 'broccoli', label: 'Broccoli' },
+      { id: 'carrots', label: 'Carrots' },
+    ],
+  },
+];
+
+<SelectField label="Healthy Snack" placeholder="Select an item" items={items} />
+```
+
+Sections can also be built with `SelectField.Section` and `SelectField.Header` JSX children when using static options instead of `items`.
+
+### Item icons
+
+When an item has an `icon`, it renders before the label in the list. Selecting that item also shows the icon in the trigger for single select, or in the tag for multiple select.
+
+```tsx
+const items = [
+  { id: '1', label: 'Favorites', icon: StarIcon },
+  { id: '2', label: 'Settings', icon: CogIcon },
+  { id: '3', label: 'Help', icon: HelpIcon },
+];
+
+<SelectField label="Menu" items={items} />
+```

package/docs/core-table--design.md

@@ -0,0 +1,17 @@
+# Core/Table - Design
+
+A component for rendering tabular data
+
+## Properties
+
+### Density
+
+Tables have 3 different row sizes: `default`, `compact`, and `tight`.
+
+### Appearance
+
+Striped rows (aka: Zebra striping) provide contrast between rows by alternating the background color. This can be disabled with `appearance="flat"`.
+
+### Loading
+
+When tables are in a loading state the content is replaced with 5 rows of skeleton content that represents the general shape of the data.

package/docs/core-table--usage.md

@@ -0,0 +1,198 @@
+# Core/Table - Usage
+
+A component for rendering tabular data
+
+## Basic usage
+
+```tsx
+import { Table } from '@capra/core';
+
+type User = {
+  id: string;
+  name: string;
+};
+
+const userColumns = defineColumns<User>([
+  { id: 'name', label: 'Name', allowsSorting: true },
+])
+
+const users = [
+  {
+    id: 1,
+    name: 'Alice Johnson',
+  },
+  {
+    id: 2,
+    name: 'Bob Williams',
+  },
+];
+
+<Table
+  columns={userColumns}
+  visibleColumns={['name']}
+  items={users}
+/>
+```
+
+## Props
+
+| Prop | Type | Required | Default | Description |
+| --- | --- | --- | --- | --- |
+| `items` | `ItemRecord[]` | Yes | `--` | The data to render as rows in the Table |
+| `density` | `'default' \| 'compact' \| 'tight'` | No | 'default' | The density of the table, affects row height |
+| `appearance` | `'zebra' \| 'flat'` | No | 'zebra' | Whether to apply zebra-striping to rows |
+| `sortDescriptor` | `SortDescriptor` | No | `--` | Key and direction for sorting the Table |
+| `onSortChange` | `(sortDescriptor: SortDescriptor) => void` | No | `--` | Callback function fired when a the sorting configuration is changed |
+| `columns` | `ColumnConfig<ColumnKey, ItemRecord>[]` | Yes | `--` | The columns to render in the Table |
+| `visibleColumns` | `ColumnKey[]` | Yes | `--` | Which columns should be visible |
+| `isLoading` | `boolean` | No | false | Whether the table is in a loading state |
+| `enableDragAndDrop` | `boolean` | No | false | Whether drag-and-dropping rows is enabled |
+| `renderActionColumn` | `(item: ItemRecord) => React.ReactNode` | No | `--` | todo: is this prop needed? |
+| `selectionMode` | `SelectionMode` | No | `--` | Mode of row selection<br>@default 'none' |
+| `selectedKeys` | `Selection` | No | `--` | The currently selected keys (controlled) |
+| `onSelectionChange` | `(keys: Selection) => void` | No | `--` | Callback fired when selection changes |
+| `className` | `never` | No | `--` | Use `FORCE__className` instead. |
+| `style` | `never` | No | `--` | Inline styles are not supported; use component props or `FORCE__className`. |
+| `FORCE__className` | `string` | No | `--` | 🚨 This prop is meant to be an escape hatch. 🚨<br><br>If the desired style cannot be achieved using component props, use this as a last resort. The inner workings of Capra components are implementation details and this escape hatch gives one access to those implementation details. We cannot make any guarantees that styles will applied correctly across version updates. Please use it responsibly.<br><br>Add a CSS class to the component. |
+
+## Examples
+
+### Sorting
+
+```tsx
+import { Table } from '@capra/core';
+
+const userColumns = defineColumns<User>([
+  { id: 'name', label: 'Name', allowsSorting: true },
+  // ...
+])
+
+function SortableTable() {
+  const [sortDescriptor, setSortDescriptor] = useState<SortDescriptor | undefined>({
+    column: 'name',
+    direction: 'ascending',
+  });
+  const sortedItems = useMemo(() => sortItems(items, sortDescriptor), [sortDescriptor, items]);
+  return (
+    <Table
+      {...props}
+      items={sortedItems}
+      sortDescriptor={sortDescriptor}
+      onSortChange={setSortDescriptor}
+      visibleColumns={reverseColumns ? visibleColumns.toReversed() : visibleColumns}
+    />
+  );
+}
+```
+
+### Selection
+
+Use the `selectionMode` prop to enable `single` or `multiple` selection of rows.
+
+```tsx
+<Table
+  columns={userColumns}
+  visibleColumns={['name', 'email', 'balance', 'enabled', 'description', 'trend']}
+  items={sortedItems}
+  selectionMode="multiple"
+/>
+```
+
+### Filter toolbar
+
+Use the `FilterToolbar` component to support filtering and/or bulk editing.
+
+Note: `FilterToolbar` is only supported instances of `Table` with controlled selection.
+
+```tsx
+import { FilterToolbar, Table } from '@capra/core';
+
+function TableWithToolbar() {
+  const [filterString, setFilterString] = useState('');
+  const [selectedKeys, setSelectedKeys] = useState<Selection>(new Set());
+  const sortedItems = useMemo(() => sortItems(users, sortDescriptor), [sortDescriptor] );
+  const filteredItems = filterUsers(sortedItems, filterString)
+  const selectableCount = sortedItems.filter((item) => !item.isDisabled).length;
+  const selectedCount = selectedKeys === 'all' ? selectableCount : selectedKeys.size;
+
+  return (
+    <div style={{ display: 'flex', gap: '8px', flexDirection: 'column' }}>
+      <TableToolbar
+        filterInputProps={{
+          onChange: (value: string) => setFilterString(value)
+        }}
+        renderActions={() => (
+          <Button size="sm" variant="primary">Add user</Button>
+        )}
+        renderBulkEditText={() => (
+          <Text>
+            {selectedCount} of {sortedItems.length} users selected
+          </Text>
+        )}
+        renderBulkEditActions={() => (
+          <div style={{ display: 'flex', gap: '8px' }}>
+            <Button appearance="neutral" size="sm">
+              Delete
+            </Button>
+            <Button appearance="neutral" variant="tertiary" size="sm">
+              Cancel
+            </Button>
+          </div>
+        )}
+        selectedKeys={selectedKeys}
+      />
+      <Table
+        columns={userColumns}
+        visibleColumns={['name', 'email', 'balance']}
+        items={filteredItems}
+        selectionMode="multiple"
+        selectedKeys={selectedKeys}
+        onSelectionChange={setSelectedKeys}
+      />
+    </div>
+  );
+}
+```
+
+### Custom cell rendering
+
+```tsx
+import { Table } from '@capra/core';
+
+type User = {
+  id: string;
+  name: string;
+  email: string;
+};
+
+const userColumns = defineColumns<User>([
+  { id: 'name', label: 'Name', allowsSorting: true },
+  {
+    id: 'email',
+    label: 'Email',
+    allowsSorting: true,
+    render(value) {
+      return <Link href={`mailto:${value as string}`}>{value as string}</Link>;
+    },
+  },
+])
+
+const users = [
+  {
+    id: 1,
+    name: 'Alice Johnson',
+    email: 'alice@example.com',
+  },
+  {
+    id: 2,
+    name: 'Bob Williams',
+    email: 'bob@example.com',
+  },
+];
+
+<Table
+  columns={userColumns}
+  visibleColumns={['name', 'email']}
+  items={users}
+/>
+```

package/docs/core-togglebuttongroup--design.md

@@ -0,0 +1,89 @@
+# Core/ToggleButtonGroup - Design
+
+A group of toggle buttons for choosing one or more options from a set.
+
+## When to use
+
+Toggle button groups behave similarly to radio buttons, providing selection between multiple mutually exclusive options. They are also used to switch views, such as between list and grid view.
+
+Toggle button groups affect section-level views and are not a replacement for tabs.
+
+## Properties
+
+### Size
+
+The default size for toggle button groups is medium, which should be used in most cases. A small size is also available when the group appears inline with another component.
+
+### Label
+
+Labels should be short and succinct. For longer labels, consider a [Radio](?path=/docs/core-radio--design) or [SelectField](?path=/docs/core-selectfield--design).
+
+### Icon
+
+Icons may appear with a label as part of each button. All buttons within a group should have an icon, or none should.
+
+## Behavior
+
+### Control count
+
+Toggle button groups can have between 2 and 4 buttons.
+
+### View switching
+
+Toggle button groups can be used to switch the view of data at the section level, such as between a list view and grid view.
+
+Views should be presented in a consistent order:
+
+* List
+* Grid
+* Graph / Chart
+* Metrics
+
+### Filtering
+
+Toggle button groups can be used to filter data at the section level, such as a data range within a graph.
+
+## Best practices
+
+### Count
+
+**Do**
+
+Do consider a toggle button group if you have 2 to 4 succinct choices.
+
+**Don't**
+
+Don't use more than 4 buttons in a single group. Consider a [SelectField](?path=/docs/core-selectfield--design) if more than 4 choices are needed.
+
+### Wording
+
+**Do**
+
+Do keep labels short.
+
+**Don't**
+
+Don't use long, multi-word labels.
+
+### Consistent layout
+
+**Do**
+
+Do keep icons consistent and unchanged when a button becomes active.
+
+**Don't**
+
+Don't replace icons when in an active state.
+
+## Accessibility
+
+### Keyboard interaction
+
+| Key                             | Function                                                                                                                                                                                                                               |
+| ------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `Tab`<br />`Shift + Tab`        | Move focus into and out of the button group. When focus moves into a button group:<br />- if a button is checked, focus is set on the checked button;<br />- if no buttons are checked, focus is set on the first button in the group. |
+| `Enter`<br />`Space`            | Checks the focused button if not already selected.                                                                                                                                                                                     |
+| `Right Arrow`<br />`Down Arrow` | Move focus to the next button in the group.                                                                                                                                                                                            |
+| `Left Arrow`<br />`Up Arrow`    | Move focus to the previous button in the group.                                                                                                                                                                                        |
+
+Icon-only items require an `aria-label` because there is no visible text label. The group itself requires an `aria-label` (or `aria-labelledby`) so assistive technologies can identify the control set.