@fusion.dev/helix-headless 0.144.0 → 0.146.0

package/dist/table/root/table-root.d.ts

@@ -1,5 +1,6 @@
 import { AriaForwardController, HelixElement } from '@fusion.dev/helix-core';
 import { type PropertyValues, type TemplateResult } from 'lit';
+import '../../checkbox/index.js';
 import { type HelixHeadlessTableColumn } from '../column/table-column.js';
 declare const HelixHeadlessTable_base: (new (...args: any[]) => import("@fusion.dev/helix-core").CollectionElement) & typeof HelixElement;
 /**
@@ -16,10 +17,42 @@ declare const HelixHeadlessTable_base: (new (...args: any[]) => import("@fusion.
  * `rowheader` for a `header` cell in a row of values. Rows are
  * `display: contents`, so their cells become items of the one grid.
  *
- * A column with `sortable` and a `field` sorts the rows by the text of its
- * cells, numbers by their value. Your markup is not reordered: the table draws
- * the rows in the sorted order. `helix-sort` asks first, so you can refuse it
- * and reorder the rows yourself.
+ * **Sorting.** A column with `sortable` and a `field` draws its heading as a
+ * button that sorts the rows by the text of its cells, numbers by their value.
+ * Your markup is not reordered: the table draws the rows in the sorted order.
+ *
+ * 1. Each press cycles the column through ascending, descending, and the
+ *    order the rows were written in, which keeps a server's own ranking
+ *    reachable.
+ * 2. `helix-sort` asks first, with `field:direction`, or empty for the written
+ *    order. Refuse it to keep the order, or to sort the rows yourself and set
+ *    `sort`.
+ * 3. `helix-sorted` follows once the order stands, and `sort` holds it.
+ * 4. The heading carries `aria-sort`, and a screen reader hears `sorted-label`
+ *    ("Sorted by Name, ascending") or `unsorted-label` from a polite region.
+ *
+ * Tab reaches each sort button, and Enter or Space presses it.
+ *
+ * The `heading` slot names the table: slot a heading or a line of text into
+ * it, and the table is named by its words. An `aria-label` or `aria-labelledby` on the
+ * host wins over it.
+ *
+ * **Selecting.** `selectable` adds a column of checkboxes.
+ *
+ * 1. Each row is known by its `value`, or by its place among the rows where it
+ *    has none, and `selected` holds the chosen keys, comma separated, the same
+ *    shape `DataTable` uses. `default-selected` is where it starts.
+ * 2. A row's checkbox is named by `select-row-label` ("Select {row}") with the
+ *    words of the row's first cell. The checkbox in the heading selects every
+ *    row, and shows a dash while only some are chosen.
+ * 3. `helix-select` asks first, with every key the change would leave.
+ *    Refuse it to keep the selection. `helix-selected` follows once it stands.
+ * 4. A chosen row takes `:state(selected)`, and a screen reader hears
+ *    `selected-label` ("2 selected") from a polite region.
+ *
+ * Tab reaches each checkbox, and Space ticks it. For a grid a reader moves
+ * through with the arrow keys, with typeahead and range selection, use
+ * `DataTable`. To act on one row, put a link or a button in a cell.
  *
  * The CSS custom properties listed for this component are written by it and
  * read by the stylesheet that draws it. Do not set them. Each holds a number
@@ -33,13 +66,29 @@ declare const HelixHeadlessTable_base: (new (...args: any[]) => import("@fusion.
  * @documentation https://fusion.dev/helix/components/table
  *
  * @slot - The table's rows.
+ * @slot heading - Words that name the table, shown above it, such as a heading.
  *
+ * @event {HelixSelectEvent} helix-select - The selection is about to change. The event carries every selected key, separated by commas. Cancelable: cancel it to keep the current selection.
+ * @event {HelixSelectedEvent} helix-selected - Fired after the selection changes, with every selected key, separated by commas.
  * @event {HelixSortEvent} helix-sort - A different sort order was requested, as `field:direction`, or empty for the order the rows were written in. Cancelable: cancel it to keep the current order.
+ * @event {HelixSortedEvent} helix-sorted - Fired after the sort order changes, with the new order.
  *
+ * @csspart checkbox - The checkbox in the heading that selects every row, in a `selectable` table.
+ * @csspart checkbox-box - The box drawn for the checkbox's input.
+ * @csspart checkbox-control - The checkbox's input.
+ * @csspart checkbox-feedback - Forwarded from the checkbox. Not shown in the table.
+ * @csspart checkbox-field - The row that holds the checkbox's box.
+ * @csspart checkbox-hint - Forwarded from the checkbox. Not shown in the table.
+ * @csspart checkbox-label - Forwarded from the checkbox. The label is read by screen readers only.
+ * @csspart checkbox-mark - The check mark, or the dash while some rows are selected.
+ * @csspart checkbox-mark-checked - Added to `checkbox-mark` while its box is checked.
+ * @csspart checkbox-mark-dash - Added to `checkbox-mark` while it draws the dash, which it keeps until its box is checked.
+ * @csspart checkbox-mark-indeterminate - Added to `checkbox-mark` while only some rows are selected.
  * @csspart empty - The text shown when there are no rows.
  * @csspart head - The row that holds the column headings. It has `display: contents`, so it takes no space of its own.
  * @csspart live - A live region that repeats the empty and loading text, so screen readers announce it when it changes. Visually hidden in the styled tier.
  * @csspart loading - The text shown while the rows are loading.
+ * @csspart select-all - The heading that holds the checkbox that selects every row.
  * @csspart table - The grid.
  *
  * @cssproperty --table-template - The column track list the table works out from its columns. The component writes it inline on the element that reads it, so setting it has no effect. Set `columns` to change the tracks.
@@ -78,6 +127,11 @@ export declare class HelixHeadlessTable extends HelixHeadlessTable_base {
      * declared in it has nowhere else to be sized from.
      */
     columns: string;
+    /**
+     * The keys selected at the start, separated by commas. Used until `selected`
+     * is set.
+     */
+    defaultSelected: string;
     /**
      * The starting sort order, used until `sort` is set.
      */
@@ -91,6 +145,32 @@ export declare class HelixHeadlessTable extends HelixHeadlessTable_base {
      * wins over this.
      */
     label: string;
+    /**
+     * Adds a column of checkboxes for selecting rows. Each row is known by its
+     * `value`, and by its place among the rows as written where it has none.
+     */
+    selectable: boolean;
+    /** The name of the checkbox in the heading that selects every row. */
+    selectAllLabel: string;
+    /**
+     * The keys of the selected rows, separated by commas.
+     *
+     * A reader's press fires `helix-select` first, and refusing it leaves the
+     * selection as it was. `default-selected` seeds a selection this element
+     * then owns.
+     */
+    get selected(): string;
+    set selected(next: string);
+    /**
+     * What screen readers hear when the chosen rows change. `{count}` is how many
+     * rows are chosen.
+     */
+    selectedLabel: string;
+    /**
+     * The name of a row's checkbox. `{row}` is replaced with the words of the
+     * row's first cell.
+     */
+    selectRowLabel: string;
     /**
      * The sort order, as `field:direction`, where `field` is a sortable column's
      * `field`.
@@ -110,6 +190,9 @@ export declare class HelixHeadlessTable extends HelixHeadlessTable_base {
     /** What screen readers hear when the table stops being sorted. */
     unsortedLabel: string;
     private sortState;
+    private selectedState;
+    /** Whether the heading names the table, so taking it away clears only this element's own name. */
+    private headed;
     /**
      * Carries a host `aria-label` and `aria-labelledby` to the grid, which is
      * the element with the `table` role.
@@ -148,6 +231,39 @@ export declare class HelixHeadlessTable extends HelixHeadlessTable_base {
      * new order is said. Not on the first render, which is the table arriving.
      */
     private news;
+    /** The sort as the last render had it, so a selection said beside a sort waits. */
+    private heardSortBefore;
+    /** The selection last heard, so a render that changed nothing says nothing. */
+    private heardSelected;
+    /** The rows as written, each with the key `selected` lists it by. */
+    private get keyed();
+    /** The keys selected now. */
+    private get chosen();
+    /** Asks for a different set of selected rows, and reports whether the request stood. */
+    private requestSelected;
+    /**
+     * A checkbox this table drew asked to change: a row's, or the one in the
+     * heading. Refused, and asked of the selection instead, so a box shows only
+     * what `selected` says. A checkbox a consumer put in a cell is theirs and is
+     * left alone.
+     */
+    private readonly handleToggle;
+    /**
+     * Tells each row whether it is selected and what its checkbox is called.
+     *
+     * Pushed down for the reason the sort is: the selection is the table's, and
+     * the checkbox is drawn by the row.
+     */
+    private markSelected;
+    /**
+     * Names the table by its heading, where the host names it no other way.
+     *
+     * Through element reflection, because the heading is the consumer's markup
+     * and the table is in this shadow root, which an id cannot reach across.
+     */
+    private nameByHeading;
+    /** What the heading slot is given. */
+    private get headings();
     /**
      * Tells each column which way it is ordered, if it is the one.
      *
@@ -175,6 +291,8 @@ export declare class HelixHeadlessTable extends HelixHeadlessTable_base {
      * track for one that declares neither.
      */
     private get template();
+    /** The tracks of the columns, before any checkbox column. */
+    private get tracks();
     /**
      * Tracks for the columns that set nothing, from how much text each holds.
      *
@@ -195,6 +313,8 @@ export declare class HelixHeadlessTable extends HelixHeadlessTable_base {
      * after. Sampled, so a table of thousands of rows reads `SAMPLE` of them.
      */
     private fitted;
+    /** Asks for the render a hydration put off, which reads the rows. */
+    protected firstUpdated(changed: PropertyValues): void;
     private readonly handleSlotChange;
     /**
      * Watches the light DOM for rows and columns arriving, leaving and moving.
@@ -278,6 +398,8 @@ export declare class HelixHeadlessTable extends HelixHeadlessTable_base {
     private alignCells;
     protected willUpdate(changed: PropertyValues): void;
     protected updated(changed: PropertyValues): void;
+    /** The heading of the checkbox column, which selects every row. */
+    private renderSelectAll;
     protected render(): TemplateResult;
 }
 declare global {

package/dist/table/root/table-root.js

@@ -4,10 +4,11 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { AriaForwardController, customElement, fillTemplate, HelixElement, HelixSortEvent, MixinCollection, requestChange, splitValues, } from '@fusion.dev/helix-core';
-import { html, nothing } from 'lit';
+import { AriaForwardController, commaList, customElement, cycle, fillTemplate, format, HelixElement, HelixSelectEvent, HelixSelectedEvent, HelixSortEvent, HelixSortedEvent, MixinCollection, parse, reflectElements, requestChange, sort, splitValues, toggleEvery, whenHydrated, } from '@fusion.dev/helix-core';
+import { nothing } from 'lit';
 import { property, state } from 'lit/decorators.js';
-import { cycle, format, parse, sort } from '../../data-table/root/order.js';
+import { html } from 'lit/static-html.js';
+import '../../checkbox/index.js';
 import { edgeOf } from '../column/table-column.js';
 const tracksOf = (list, wanted) => {
     const words = splitValues(list, ' ');
@@ -47,17 +48,51 @@ let HelixHeadlessTable = class HelixHeadlessTable extends MixinCollection(HelixE
         super(...arguments);
         this.ascendingLabel = 'ascending';
         this.columns = '';
+        this.defaultSelected = '';
         this.defaultSort = '';
         this.descendingLabel = 'descending';
         this.label = '';
+        this.selectable = false;
+        this.selectAllLabel = 'Select every row';
+        this.selectedLabel = '{count} selected';
+        this.selectRowLabel = 'Select {row}';
         this.sortedLabel = 'Sorted by {column}, {order}';
         this.unsortedLabel = 'Not sorted';
         this.sortState = undefined;
+        this.selectedState = undefined;
+        this.headed = false;
         this.aria = new AriaForwardController(this, {
             label: true,
             target: () => this.partNamed('table'),
         });
         this.heardSort = undefined;
+        this.heardSortBefore = undefined;
+        this.heardSelected = undefined;
+        this.handleToggle = (event) => {
+            const origin = event.composedPath()[0];
+            if (!(origin instanceof Element) || origin.getAttribute('part') !== 'checkbox') {
+                return;
+            }
+            const root = origin.getRootNode();
+            const keys = this.chosen;
+            if (root === this.renderRoot) {
+                event.preventDefault();
+                this.requestSelected(new Set(toggleEvery(keys, this.keyed.map(({ key }) => key))));
+                return;
+            }
+            const found = this.keyed.find(({ row }) => row.shadowRoot === root);
+            if (!found) {
+                return;
+            }
+            event.preventDefault();
+            if (event.detail.checked) {
+                keys.add(found.key);
+            }
+            else {
+                keys.delete(found.key);
+            }
+            this.requestSelected(keys);
+        };
         this.handleHeadClick = (event) => {
             const path = event.composedPath();
             if (!path.some((node) => node instanceof Element && node.getAttribute('part') === 'sort')) {
@@ -76,6 +111,14 @@ let HelixHeadlessTable = class HelixHeadlessTable extends MixinCollection(HelixE
         this.alignment = undefined;
         this.aligned = '';
     }
+    get selected() {
+        return this.selectedState ?? this.defaultSelected;
+    }
+    set selected(next) {
+        const previous = this.selected;
+        this.selectedState = next;
+        this.requestUpdate('selected', previous);
+    }
     get sort() {
         return this.sortState ?? this.defaultSort;
     }
@@ -90,6 +133,7 @@ let HelixHeadlessTable = class HelixHeadlessTable extends MixinCollection(HelixE
                 const previous = this.sort;
                 this.sortState = value;
                 this.requestUpdate('sort', previous);
+                this.dispatchEvent(new HelixSortedEvent({ value }));
             },
             event: (value) => new HelixSortEvent({ value }),
             host: this,
@@ -133,8 +177,57 @@ let HelixHeadlessTable = class HelixHeadlessTable extends MixinCollection(HelixE
                 : this.unsortedLabel;
         }
         this.heardSort = current;
+        const selected = this.selectable ? this.selected : '';
+        if (this.hasUpdated && current === this.heardSortBefore && selected !== this.heardSelected) {
+            said = fillTemplate(this.selectedLabel, { count: this.chosen.size });
+        }
+        this.heardSortBefore = current;
+        this.heardSelected = selected;
         return said;
     }
+    get keyed() {
+        return this.slotted.map((row, index) => ({
+            key: row.value || String(index),
+            row: row,
+        }));
+    }
+    get chosen() {
+        return new Set(commaList(this.selected));
+    }
+    requestSelected(keys) {
+        return requestChange({
+            apply: (value) => {
+                const previous = this.selected;
+                this.selectedState = value;
+                this.requestUpdate('selected', previous);
+                this.dispatchEvent(new HelixSelectedEvent({ value }));
+            },
+            event: (value) => new HelixSelectEvent({ value }),
+            host: this,
+            next: [...keys].join(','),
+        });
+    }
+    markSelected() {
+        const keys = this.chosen;
+        for (const { key, row } of this.keyed) {
+            if (!row.isTableRow) {
+                continue;
+            }
+            const label = fillTemplate(this.selectRowLabel, { row: textOf(row.children[0]) || key });
+            whenHydrated(row, () => {
+                row.selectable = this.selectable;
+                row.selected = keys.has(key);
+                row.selectLabel = label;
+            });
+        }
+    }
+    nameByHeading() {
+        const named = this.hasAttribute('aria-label') || this.hasAttribute('aria-labelledby');
+        this.headed = reflectElements(this.partNamed('table'), 'ariaLabelledByElements', named ? [] : this.headings, this.headed);
+    }
+    get headings() {
+        return [...(this.children ?? [])].filter((child) => child.getAttribute('slot') === 'heading');
+    }
     markSorted() {
         const current = parse(this.sort);
         for (const column of this.tableColumns) {
@@ -150,6 +243,10 @@ let HelixHeadlessTable = class HelixHeadlessTable extends MixinCollection(HelixE
         return this.knownChildren.filter((child) => 'isTableColumn' in child && child.isTableColumn === true);
     }
     get template() {
+        const tracks = this.tracks;
+        return this.selectable && tracks ? `max-content ${tracks}` : tracks;
+    }
+    get tracks() {
         const declared = this.tableColumns;
         if (declared.length === 0) {
             return this.columns;
@@ -187,17 +284,23 @@ let HelixHeadlessTable = class HelixHeadlessTable extends MixinCollection(HelixE
                 : 'max-content';
         });
     }
+    firstUpdated(changed) {
+        super.firstUpdated(changed);
+        this.finishHydration();
+    }
     connectedCallback() {
         super.connectedCallback();
         this.watcher = new MutationObserver(() => this.requestUpdate());
         this.watcher.observe(this, { characterData: true, childList: true, subtree: true });
         this.addEventListener('click', this.handleHeadClick);
+        this.addEventListener('helix-before-toggle', this.handleToggle);
     }
     disconnectedCallback() {
         super.disconnectedCallback();
         this.watcher?.disconnect();
         this.watcher = undefined;
         this.removeEventListener('click', this.handleHeadClick);
+        this.removeEventListener('helix-before-toggle', this.handleToggle);
     }
     static { this.shadowRootOptions = {
         ...HelixElement.shadowRootOptions,
@@ -205,7 +308,7 @@ let HelixHeadlessTable = class HelixHeadlessTable extends MixinCollection(HelixE
     }; }
     get slotted() {
         const columns = new Set(this.tableColumns);
-        return [...(this.children ?? [])].filter((child) => !columns.has(child));
+        return [...(this.children ?? [])].filter((child) => !columns.has(child) && child.getAttribute('slot') !== 'heading');
     }
     assign() {
         if (this.assignsByName) {
@@ -221,6 +324,9 @@ let HelixHeadlessTable = class HelixHeadlessTable extends MixinCollection(HelixE
         }
         head.assign(...this.tableColumns);
         body.assign(...this.arrangedRows);
+        this.renderRoot
+            ?.querySelector('slot[name="heading"]')
+            ?.assign(...this.headings);
     }
     alignCells() {
         if (typeof CSSStyleSheet === 'undefined' || !('replaceSync' in CSSStyleSheet.prototype)) {
@@ -252,17 +358,40 @@ let HelixHeadlessTable = class HelixHeadlessTable extends MixinCollection(HelixE
         this.assign();
         this.alignCells();
         this.markSorted();
+        this.markSelected();
+        this.nameByHeading();
+    }
+    renderSelectAll() {
+        if (!this.selectable) {
+            return nothing;
+        }
+        const every = this.childrenKnown ? this.keyed.map(({ key }) => key) : [];
+        const keys = this.chosen;
+        const count = every.filter((key) => keys.has(key)).length;
+        const checkbox = this.tag('checkbox');
+        return html `<span part="select-all" role="columnheader"
+      ><${checkbox}
+        part="checkbox"
+        exportparts="box: checkbox-box, control: checkbox-control, feedback: checkbox-feedback,
+          field: checkbox-field, hint: checkbox-hint, label: checkbox-label, mark: checkbox-mark,
+          mark-checked: checkbox-mark-checked, mark-dash: checkbox-mark-dash,
+          mark-indeterminate: checkbox-mark-indeterminate"
+        aria-label=${this.selectAllLabel}
+        .checked=${every.length > 0 && count === every.length}
+        .indeterminate=${count > 0 && count < every.length}
+      ></${checkbox}
+    ></span>`;
     }
     render() {
         const template = this.template;
-        return html `<div
+        return html `<slot name="heading"></slot><div
       part="table"
       role="table"
       aria-busy=${this.loading ? 'true' : nothing}
       aria-label=${this.label || 'Table'}
       style=${template ? `--table-template: ${template}` : ''}
     >
-      <div part="head" role="row"><slot name="columns"></slot></div>
+      <div part="head" role="row">${this.renderSelectAll()}<slot name="columns"></slot></div>
       <slot
         @slotchange=${(event) => {
             this.countRows(event);
@@ -279,6 +408,9 @@ __decorate([
 __decorate([
     property()
 ], HelixHeadlessTable.prototype, "columns", void 0);
+__decorate([
+    property({ attribute: 'default-selected' })
+], HelixHeadlessTable.prototype, "defaultSelected", void 0);
 __decorate([
     property({ attribute: 'default-sort' })
 ], HelixHeadlessTable.prototype, "defaultSort", void 0);
@@ -288,6 +420,21 @@ __decorate([
 __decorate([
     property()
 ], HelixHeadlessTable.prototype, "label", void 0);
+__decorate([
+    property({ type: Boolean })
+], HelixHeadlessTable.prototype, "selectable", void 0);
+__decorate([
+    property({ attribute: 'select-all-label' })
+], HelixHeadlessTable.prototype, "selectAllLabel", void 0);
+__decorate([
+    property()
+], HelixHeadlessTable.prototype, "selected", null);
+__decorate([
+    property({ attribute: 'selected-label' })
+], HelixHeadlessTable.prototype, "selectedLabel", void 0);
+__decorate([
+    property({ attribute: 'select-row-label' })
+], HelixHeadlessTable.prototype, "selectRowLabel", void 0);
 __decorate([
     property()
 ], HelixHeadlessTable.prototype, "sort", null);
@@ -300,6 +447,9 @@ __decorate([
 __decorate([
     state()
 ], HelixHeadlessTable.prototype, "sortState", void 0);
+__decorate([
+    state()
+], HelixHeadlessTable.prototype, "selectedState", void 0);
 HelixHeadlessTable = __decorate([
     customElement('helix-headless-table')
 ], HelixHeadlessTable);

package/dist/table/row/table-row.d.ts

@@ -1,5 +1,6 @@
 import { HelixElement } from '@fusion.dev/helix-core';
-import { type PropertyValues, type TemplateResult } from 'lit';
+import { nothing, type PropertyValues, type TemplateResult } from 'lit';
+import '../../checkbox/index.js';
 /**
  * @summary One row of a table.
  *
@@ -9,12 +10,31 @@ import { type PropertyValues, type TemplateResult } from 'lit';
  * across rows. The row still exists as an element, so you can style it, hide
  * it, or make it interactive.
  *
+ * In a `selectable` table the row draws a checkbox cell before its own cells,
+ * and `value` is the key the table's `selected` lists it by.
+ *
  * @since 0.1.0
  * @status stable
  * @aliases Row, TableRow
  * @documentation https://fusion.dev/helix/components/table
  *
  * @slot - The row's cells.
+ *
+ * @csspart checkbox - The row's checkbox, in a `selectable` table.
+ * @csspart checkbox-box - The box drawn for the checkbox's input.
+ * @csspart checkbox-control - The checkbox's input.
+ * @csspart checkbox-feedback - Forwarded from the checkbox. Not shown in the table.
+ * @csspart checkbox-field - The row that holds the checkbox's box.
+ * @csspart checkbox-hint - Forwarded from the checkbox. Not shown in the table.
+ * @csspart checkbox-label - Forwarded from the checkbox. The label is read by screen readers only.
+ * @csspart checkbox-mark - The check mark.
+ * @csspart checkbox-mark-checked - Added to `checkbox-mark` while its box is checked.
+ * @csspart checkbox-mark-dash - Added to `checkbox-mark` while it draws the dash, which it keeps until its box is checked.
+ * @csspart checkbox-mark-indeterminate - Added to `checkbox-mark` while only some rows are selected.
+ * @csspart select - The cell that holds the row's checkbox, in a `selectable` table.
+ * @csspart select-selected - Added to `select` while the row is selected.
+ *
+ * @cssstate selected - While the row is selected, in a `selectable` table.
  */
 export declare class HelixHeadlessTableRow extends HelixElement {
     /**
@@ -22,6 +42,23 @@ export declare class HelixHeadlessTableRow extends HelixElement {
      * finds its columns. Not a consumer's to read or set.
      */
     readonly isTableRow = true;
+    /**
+     * The key the table's `selected` lists this row by. Left empty, the row is
+     * known by its place among the rows as written.
+     */
+    value: string;
+    /**
+     * @internal Whether the table this row sits in is `selectable`, written by
+     * that table. Not a consumer's to set: the selection is the table's.
+     */
+    selectable: boolean;
+    /**
+     * @internal Whether the row is selected, written by the table that owns the
+     * selection. Not a consumer's to set: write the table's `selected`.
+     */
+    selected: boolean;
+    /** @internal The name of the row's checkbox, written by the table. Not a consumer's to set. */
+    selectLabel: string;
     /** The table's rules this row holds, so the next ones replace them rather than pile up. */
     private columnRules;
     /**
@@ -39,6 +76,15 @@ export declare class HelixHeadlessTableRow extends HelixElement {
      * upgrades while its row is still being parsed has no value beside it yet.
      */
     private readonly handleSlotChange;
+    /**
+     * The checkbox cell, in a `selectable` table.
+     *
+     * A cell of the row's own, before the consumer's cells, so the table's grid
+     * gives it the first track. The table hears its `helix-before-toggle`,
+     * refuses it and asks for the new selection, so the box shows only what the
+     * table's `selected` says.
+     */
+    protected renderSelect(): TemplateResult | typeof nothing;
     protected render(): TemplateResult;
 }
 declare global {

package/dist/table/row/table-row.js

@@ -5,11 +5,18 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { customElement, HelixElement, hostAria } from '@fusion.dev/helix-core';
-import { html } from 'lit';
+import { nothing } from 'lit';
+import { property, state } from 'lit/decorators.js';
+import { html } from 'lit/static-html.js';
+import '../../checkbox/index.js';
 let HelixHeadlessTableRow = class HelixHeadlessTableRow extends HelixElement {
     constructor() {
         super(...arguments);
         this.isTableRow = true;
+        this.value = '';
+        this.selectable = false;
+        this.selected = false;
+        this.selectLabel = '';
         this.columnRules = undefined;
         this.handleSlotChange = () => {
             for (const cell of this.children) {
@@ -34,11 +41,41 @@ let HelixHeadlessTableRow = class HelixHeadlessTableRow extends HelixElement {
     willUpdate(changed) {
         super.willUpdate(changed);
         hostAria(this.internals, { role: 'row' });
+        this.toggleState('selected', this.selectable && this.selected);
+    }
+    renderSelect() {
+        if (!this.selectable) {
+            return nothing;
+        }
+        const checkbox = this.tag('checkbox');
+        return html `<span part="select${this.selected ? ' select-selected' : ''}" role="cell"
+      ><${checkbox}
+        part="checkbox"
+        exportparts="box: checkbox-box, control: checkbox-control, feedback: checkbox-feedback,
+          field: checkbox-field, hint: checkbox-hint, label: checkbox-label, mark: checkbox-mark,
+          mark-checked: checkbox-mark-checked, mark-dash: checkbox-mark-dash,
+          mark-indeterminate: checkbox-mark-indeterminate"
+        aria-label=${this.selectLabel}
+        .checked=${this.selected}
+      ></${checkbox}
+    ></span>`;
     }
     render() {
-        return html `<slot @slotchange=${this.handleSlotChange}></slot>`;
+        return html `${this.renderSelect()}<slot @slotchange=${this.handleSlotChange}></slot>`;
     }
 };
+__decorate([
+    property()
+], HelixHeadlessTableRow.prototype, "value", void 0);
+__decorate([
+    state()
+], HelixHeadlessTableRow.prototype, "selectable", void 0);
+__decorate([
+    state()
+], HelixHeadlessTableRow.prototype, "selected", void 0);
+__decorate([
+    state()
+], HelixHeadlessTableRow.prototype, "selectLabel", void 0);
 HelixHeadlessTableRow = __decorate([
     customElement('helix-headless-table-row')
 ], HelixHeadlessTableRow);