@svelte-lean/table 0.1.0

package/dist/table/data-table.svelte.d.ts

@@ -0,0 +1,41 @@
+import type { TableProps, RowId } from '../types.js';
+declare function $$render<T>(): {
+    props: TableProps<T>;
+    exports: {
+        scrollTo: (config: {
+            key?: RowId;
+            index?: number;
+            top?: number;
+            offset?: number;
+            align?: ScrollLogicalPosition;
+        }) => void;
+    };
+    bindings: "state";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<T> {
+    props(): ReturnType<typeof $$render<T>>['props'];
+    events(): ReturnType<typeof $$render<T>>['events'];
+    slots(): ReturnType<typeof $$render<T>>['slots'];
+    bindings(): "state";
+    exports(): {
+        scrollTo: (config: {
+            key?: RowId;
+            index?: number;
+            top?: number;
+            offset?: number;
+            align?: ScrollLogicalPosition;
+        }) => void;
+    };
+}
+interface $$IsomorphicComponent {
+    new <T>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<T>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<T>['props']>, ReturnType<__sveltets_Render<T>['events']>, ReturnType<__sveltets_Render<T>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<T>['bindings']>;
+    } & ReturnType<__sveltets_Render<T>['exports']>;
+    <T>(internal: unknown, props: ReturnType<__sveltets_Render<T>['props']> & {}): ReturnType<__sveltets_Render<T>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
+declare const DataTable: $$IsomorphicComponent;
+type DataTable<T> = InstanceType<typeof DataTable<T>>;
+export default DataTable;

package/dist/table/navigation.d.ts

@@ -0,0 +1,4 @@
+/** The previous or next data cell in the same row. */
+export declare function horizontalCell(cell: HTMLTableCellElement, delta: 1 | -1): HTMLTableCellElement | undefined;
+/** The nearest cell with the same `data-column` in a following or preceding row. */
+export declare function verticalCell(cell: HTMLTableCellElement, delta: 1 | -1): HTMLTableCellElement | undefined;

package/dist/table/navigation.js

@@ -0,0 +1,26 @@
+/**
+ * Keyboard navigation over the rendered `<tbody>`. Cells are found by structure, not by counting
+ * columns, so spanning cells and detail rows do not shift the target.
+ */
+function dataCells(row) {
+    return Array.from(row.children).filter((child) => child.matches('td[data-cell]'));
+}
+/** The previous or next data cell in the same row. */
+export function horizontalCell(cell, delta) {
+    const row = cell.parentElement;
+    if (!row)
+        return undefined;
+    const cells = dataCells(row);
+    return cells[cells.indexOf(cell) + delta];
+}
+/** The nearest cell with the same `data-column` in a following or preceding row. */
+export function verticalCell(cell, delta) {
+    const column = cell.dataset.column;
+    const sibling = delta > 0 ? 'nextElementSibling' : 'previousElementSibling';
+    for (let row = cell.parentElement?.[sibling]; row; row = row[sibling]) {
+        const target = dataCells(row).find((candidate) => candidate.dataset.column === column);
+        if (target)
+            return target;
+    }
+    return undefined;
+}

package/dist/table.svelte.d.ts

@@ -0,0 +1,92 @@
+import type { Column, FilterOperator, TableState, ModelContext, Pin, RowId, RowModel } from './types.js';
+import { type HeaderCell } from './core.js';
+/** A plain value or a getter. Getters keep the engine reactive to the caller's `$state`. */
+export type MaybeGetter<T> = T | (() => T);
+export type SelectionMode = false | 'single' | 'multiple';
+export interface TableOptions<T> {
+    data: MaybeGetter<readonly T[]>;
+    columns: MaybeGetter<readonly Column<T>[]>;
+    getRowId: (row: T) => RowId;
+    getSubRows?: (row: T) => readonly T[] | undefined;
+    /**
+     * A plain object (or nothing) is the initial state of a table that owns its state.
+     * A getter makes the table controlled: it reads the caller's state and reports every
+     * change through `onStateChange` without storing anything itself.
+     */
+    state?: Partial<TableState> | (() => Partial<TableState>);
+    onStateChange?: (state: TableState) => void;
+    getRowModel?: (context: ModelContext<T>) => RowModel<T>;
+    manual?: MaybeGetter<boolean | undefined>;
+    rowCount?: MaybeGetter<number | undefined>;
+    /** Manual mode: the page count when the total is unknown. */
+    pageCount?: MaybeGetter<number | undefined>;
+    /** Replaces the searchable text of a row (default: visible searchable columns). */
+    searchText?: (row: T) => string;
+    locale?: MaybeGetter<string | undefined>;
+    /** `false` builds the model with every row on one page. Default `true`. */
+    pagination?: MaybeGetter<boolean | undefined>;
+    /** Default `'multiple'`. `false` makes every selection helper a no-op. */
+    selection?: MaybeGetter<SelectionMode | undefined>;
+    isRowSelectable?: (row: T) => boolean;
+    /** Rows that `selectAll()` and `allSelected` consider: the current page or every filtered row. */
+    selectionScope?: MaybeGetter<'page' | 'filtered' | undefined>;
+}
+export interface Table<T> {
+    readonly state: TableState;
+    readonly model: RowModel<T>;
+    /** Column definitions as given, including groups. */
+    readonly columns: readonly Column<T>[];
+    readonly leafColumns: Column<T>[];
+    /** Leaf columns that are not hidden, in pin zone and user order. */
+    readonly visibleColumns: Column<T>[];
+    readonly headers: HeaderCell<T>[][];
+    /** Ids of rows a selection control may act on, within `selectionScope`. */
+    readonly selectable: RowId[];
+    readonly allSelected: boolean;
+    readonly someSelected: boolean;
+    isSelected(id: RowId): boolean;
+    isExpanded(id: RowId): boolean;
+    /**
+     * The sort on a column id, or on a column: then a sort on one of its `sortKeys` counts too.
+     * `id` is the sort id that matched.
+     */
+    sortOf(column: string | Column<T>): {
+        id: string;
+        desc: boolean;
+        index: number;
+    } | undefined;
+    pinOf(column: Column<T>): Pin | undefined;
+    columnWidth(column: Column<T>): number;
+    /** Merges a patch into the state, stores it when the table owns its state, and reports it. */
+    setState(patch: Partial<TableState>): TableState;
+    /**
+     * Cycles none → ascending → descending → none (descending first for a column with
+     * `sortDescFirst`). `multi` keeps other sorted columns.
+     */
+    toggleSort(id: string, multi?: boolean): void;
+    /** Toggles one row; in `'single'` mode the row replaces the selection. */
+    toggleSelection(id: RowId, selected?: boolean): void;
+    /** Selects or clears many rows; defaults to `selectable` and to "select unless all are selected". */
+    selectAll(ids?: readonly RowId[], selected?: boolean): void;
+    /** Returns the new expanded state of the row. */
+    toggleExpanded(id: RowId, expanded?: boolean): boolean;
+    setSearch(search: string): void;
+    /** Replaces the filter for a column; `undefined` removes it. */
+    setFilter(id: string, value: unknown, operator?: FilterOperator): void;
+    setPage(index: number): void;
+    /** `0` shows every row on one page. Resets the page index. */
+    setPageSize(size: number): void;
+    /** Moves a visible column `delta` places within the visible order. */
+    moveColumn(id: string, delta: number): void;
+    /** Stores a width clamped to the column's bounds. */
+    resizeColumn(id: string, width: number): void;
+    pin(id: string, pin: Pin): void;
+    toggleColumn(id: string, visible?: boolean): void;
+}
+/**
+ * The table engine below `<DataTable />`: derives the row model, visible columns and headers from
+ * data, columns and state, and exposes the state transitions a renderer needs. It holds no DOM and
+ * no per-row objects beyond the row model. Every option is read lazily, so `data`, `columns` and
+ * `state` may be getters over the caller's `$state`.
+ */
+export declare function createTable<T>(options: TableOptions<T>): Table<T>;

package/dist/table.svelte.js

@@ -0,0 +1,157 @@
+import { clampWidth, columnWidth, createRowModel, defaultState, headerRows, leafColumns, reorder, toggleId, sortOf, toggleSelection, toggleSort, visibleColumns } from './core.js';
+function resolve(value) {
+    return typeof value === 'function' ? value() : value;
+}
+/**
+ * The table engine below `<DataTable />`: derives the row model, visible columns and headers from
+ * data, columns and state, and exposes the state transitions a renderer needs. It holds no DOM and
+ * no per-row objects beyond the row model. Every option is read lazily, so `data`, `columns` and
+ * `state` may be getters over the caller's `$state`.
+ */
+export function createTable(options) {
+    const controlled = typeof options.state === 'function';
+    let owned = $state.raw(defaultState(controlled ? {} : options.state));
+    const state = $derived(controlled ? defaultState(options.state()) : owned);
+    const columns = $derived(resolve(options.columns));
+    const leaves = $derived(leafColumns(columns));
+    const visible = $derived(visibleColumns(columns, state));
+    const headers = $derived(headerRows(columns, visible));
+    const model = $derived.by(() => {
+        const paginated = resolve(options.pagination) ?? true;
+        const context = {
+            data: resolve(options.data),
+            columns,
+            state: paginated ? state : { ...state, pageIndex: 0, pageSize: 0 },
+            getRowId: options.getRowId,
+            getSubRows: options.getSubRows,
+            manual: resolve(options.manual) ?? false,
+            rowCount: resolve(options.rowCount),
+            pageCount: resolve(options.pageCount),
+            searchText: options.searchText,
+            locale: resolve(options.locale)
+        };
+        return (options.getRowModel ?? createRowModel)(context);
+    });
+    const selected = $derived(new Set(state.selection));
+    const expanded = $derived(new Set(state.expanded));
+    const mode = $derived(resolve(options.selection) ?? 'multiple');
+    const selectable = $derived.by(() => {
+        if (!mode)
+            return [];
+        const scope = resolve(options.selectionScope) ?? 'page';
+        const eligible = options.isRowSelectable ?? (() => true);
+        return (scope === 'filtered' ? model.all : model.rows)
+            .filter((node) => node.data !== undefined && eligible(node.data))
+            .map((node) => node.id);
+    });
+    const allSelected = $derived(selectable.length > 0 && selectable.every((id) => selected.has(id)));
+    const someSelected = $derived(selectable.some((id) => selected.has(id)));
+    function setState(patch) {
+        const next = { ...state, ...patch };
+        if (!controlled)
+            owned = next;
+        options.onStateChange?.(next);
+        return next;
+    }
+    return {
+        get state() {
+            return state;
+        },
+        get model() {
+            return model;
+        },
+        get columns() {
+            return columns;
+        },
+        get leafColumns() {
+            return leaves;
+        },
+        get visibleColumns() {
+            return visible;
+        },
+        get headers() {
+            return headers;
+        },
+        get selectable() {
+            return selectable;
+        },
+        get allSelected() {
+            return allSelected;
+        },
+        get someSelected() {
+            return someSelected;
+        },
+        isSelected: (id) => selected.has(id),
+        isExpanded: (id) => expanded.has(id),
+        sortOf: (column) => sortOf(state.sorting, typeof column === 'string' ? { id: column } : column),
+        pinOf: (column) => state.pinning[column.id] ?? column.pin,
+        columnWidth: (column) => columnWidth(column, state),
+        setState,
+        toggleSort(id, multi = false) {
+            const descFirst = leaves.find((leaf) => leaf.id === id)?.sortDescFirst;
+            setState({ sorting: toggleSort(state.sorting, id, multi, descFirst), pageIndex: 0 });
+        },
+        toggleSelection(id, value) {
+            if (!mode)
+                return;
+            if (mode === 'single') {
+                setState({ selection: value === false ? [] : [id] });
+                return;
+            }
+            const has = selected.has(id);
+            if ((value ?? !has) !== has)
+                setState({ selection: toggleId(state.selection, id) });
+        },
+        selectAll(ids = selectable, value) {
+            if (!mode)
+                return;
+            setState({ selection: toggleSelection(state.selection, [...ids], value) });
+        },
+        toggleExpanded(id, value) {
+            const has = expanded.has(id);
+            const next = value ?? !has;
+            if (next !== has)
+                setState({ expanded: toggleId(state.expanded, id) });
+            return next;
+        },
+        setSearch(search) {
+            setState({ search, pageIndex: 0 });
+        },
+        setFilter(id, value, operator) {
+            const others = state.filters.filter((filter) => filter.id !== id);
+            setState({
+                filters: value === undefined ? others : [...others, { id, value, operator }],
+                pageIndex: 0
+            });
+        },
+        setPage(index) {
+            setState({ pageIndex: Math.max(0, Math.min(Math.floor(index), model.pageCount - 1)) });
+        },
+        setPageSize(size) {
+            setState({ pageSize: Math.max(0, Math.floor(size)), pageIndex: 0 });
+        },
+        moveColumn(id, delta) {
+            const ids = visible.map((column) => column.id);
+            const from = ids.indexOf(id);
+            const target = from < 0 ? undefined : ids[from + delta];
+            if (target !== undefined)
+                setState({ order: reorder(ids, id, target) });
+        },
+        resizeColumn(id, width) {
+            const column = leaves.find((leaf) => leaf.id === id);
+            if (column)
+                setState({ widths: { ...state.widths, [id]: clampWidth(column, width) } });
+        },
+        pin(id, pin) {
+            setState({ pinning: { ...state.pinning, [id]: pin } });
+        },
+        toggleColumn(id, visible) {
+            const hidden = state.hidden.includes(id);
+            if ((visible ?? hidden) === !hidden)
+                return;
+            setState({
+                hidden: hidden ? state.hidden.filter((item) => item !== id) : [...state.hidden, id]
+            });
+        }
+    };
+}

package/dist/types.d.ts

@@ -0,0 +1,317 @@
+import type { Snippet } from 'svelte';
+export type RowId = string | number;
+export type Sort = {
+    id: string;
+    desc: boolean;
+};
+export type FilterOperator = 'contains' | 'equals' | 'startsWith' | 'gt' | 'gte' | 'lt' | 'lte' | 'between' | 'in' | 'empty';
+export interface Filter {
+    id: string;
+    operator?: FilterOperator;
+    value: unknown;
+}
+export type Pin = 'left' | 'right' | false;
+export type Aggregate = 'sum' | 'mean' | 'min' | 'max' | 'count' | ((values: unknown[]) => unknown);
+export interface CellContext<T> {
+    row: T;
+    value: unknown;
+    rowId: RowId;
+    index: number;
+    column: Column<T>;
+}
+/**
+ * What a `headerCell` snippet receives: the column, its current sort and the transitions a custom
+ * sort control needs. `sort` also reports a sort on one of the column's `sortKeys`.
+ */
+export interface HeaderContext<T> {
+    column: Column<T>;
+    sort: {
+        id: string;
+        desc: boolean;
+        index: number;
+    } | undefined;
+    sorting: Sort[];
+    /** The column's own cycle (the same as a click on the built-in sort button). */
+    toggleSort: (multi?: boolean) => void;
+    /** Replaces the whole sort state, for controls that sort by arbitrary ids. Resets the page. */
+    setSorting: (sorting: Sort[]) => void;
+}
+/** What the `empty` snippet receives, to tell "nothing matches" from "nothing here". */
+export interface EmptyContext {
+    search: string;
+    /** `true` while a column filter holds a value. */
+    filtered: boolean;
+    loading: boolean;
+}
+/** Second argument of the `rowDetails` snippet. */
+export interface RowDetailsContext {
+    rowId: RowId;
+    index: number;
+    collapse: () => void;
+}
+export interface CellSpan {
+    rows?: number;
+    columns?: number;
+}
+export interface Column<T> {
+    id: string;
+    header: string;
+    accessor?: keyof T | string | ((row: T) => unknown);
+    children?: Column<T>[];
+    width?: number;
+    minWidth?: number;
+    maxWidth?: number;
+    align?: 'start' | 'center' | 'end';
+    sortable?: boolean;
+    /** The first activation sorts descending: descending → ascending → none. */
+    sortDescFirst?: boolean;
+    /**
+     * Further sort ids that count as this column's sort for `aria-sort` and the sort icon, for a
+     * column whose `headerCell` sorts by several fields.
+     */
+    sortKeys?: string[];
+    compare?: (a: unknown, b: unknown, aRow: T, bRow: T) => number;
+    filterable?: boolean;
+    filter?: (value: unknown, filter: Filter, row: T) => boolean;
+    searchable?: boolean;
+    hideable?: boolean;
+    resizable?: boolean;
+    pin?: Pin;
+    /** Text of the cell. `null` or `''` renders the table's `placeholder`. */
+    format?: (value: unknown, row: T) => string | null;
+    cell?: Snippet<[CellContext<T>]>;
+    headerCell?: Snippet<[HeaderContext<T>]>;
+    editable?: boolean | ((row: T) => boolean);
+    editor?: 'text' | 'number' | 'date' | 'select';
+    options?: {
+        label: string;
+        value: string;
+    }[];
+    parse?: (value: string, row: T) => unknown;
+    validate?: (value: unknown, row: T) => string | undefined;
+    aggregate?: Aggregate;
+    span?: (context: CellContext<T>) => CellSpan | undefined;
+    ellipsis?: boolean | {
+        showTitle?: boolean;
+    };
+    /** Class of the body cells: a string, or one computed per row. */
+    class?: string | ((row: T) => string);
+    /** Class of the header cell. */
+    headerClass?: string;
+}
+export interface TableState {
+    sorting: Sort[];
+    filters: Filter[];
+    search: string;
+    pageIndex: number;
+    pageSize: number;
+    selection: RowId[];
+    expanded: RowId[];
+    hidden: string[];
+    order: string[];
+    widths: Record<string, number>;
+    pinning: Record<string, Pin>;
+    rowPinning: {
+        top: RowId[];
+        bottom: RowId[];
+    };
+}
+export interface RowNode<T> {
+    id: RowId;
+    data?: T;
+    depth: number;
+    children: RowNode<T>[];
+    kind: 'row' | 'group';
+    label?: string;
+    count?: number;
+    aggregates?: Record<string, unknown>;
+}
+export interface RowModel<T> {
+    rows: RowNode<T>[];
+    /** Filtered root/group count, used for pagination. */
+    total: number;
+    pageCount: number;
+    pageIndex: number;
+    /** Filtered data rows, including collapsed descendants. */
+    all: RowNode<T>[];
+}
+export interface ModelContext<T> {
+    data: readonly T[];
+    columns: readonly Column<T>[];
+    state: TableState;
+    getRowId: (row: T) => RowId;
+    getSubRows?: (row: T) => readonly T[] | undefined;
+    manual?: boolean;
+    rowCount?: number;
+    /** Manual mode: the page count when the total is unknown (`rowCount` absent). */
+    pageCount?: number;
+    /** Replaces the searchable text of a row (default: visible searchable columns). */
+    searchText?: (row: T) => string;
+    locale?: string;
+}
+export interface EditEvent<T> {
+    row: T;
+    rowId: RowId;
+    columnId: string;
+    previous: unknown;
+    value: unknown;
+}
+export interface CellPosition {
+    row: RowId;
+    column: string;
+}
+export interface CellRange {
+    start: CellPosition;
+    end: CellPosition;
+}
+export interface TableMessages {
+    search: string;
+    columns: string;
+    selectAll: string;
+    selectRow: string;
+    expand: string;
+    collapse: string;
+    previous: string;
+    next: string;
+    first: string;
+    last: string;
+    pageSize: string;
+    loading: string;
+    empty: string;
+    retry: string;
+    save: string;
+    cancel: string;
+    edit: string;
+    resize: string;
+    /** Column controls: move a column earlier/later in the order. */
+    moveLeft: string;
+    moveRight: string;
+    /** Row reordering buttons rendered when `onRowMove` is set. */
+    moveUp: string;
+    moveDown: string;
+    /** Accessible name of the column-controls pin select (`"Pin: <column>"`). */
+    pin: string;
+    unpin: string;
+    pinLeft: string;
+    pinRight: string;
+    /** Page-size option that shows every row (`pageSize: 0`). */
+    allRows: string;
+    /** Read to assistive technology before a column's multi-sort precedence number. */
+    sortOrder: string;
+    /** Visually hidden header text of the selection column. */
+    selectionHeader: string;
+    /** Visually hidden header text of the expand column (`expandColumn`). */
+    expandHeader: string;
+    /** Accessible name of a column filter input. */
+    filter: (column: string) => string;
+    /** Pagination status. `rows` is `undefined` when a manual table does not know its total. */
+    page: (page: number, pages: number, rows: number | undefined) => string;
+    /** Accessible name of a numbered page button. */
+    pageNumber: (page: number) => string;
+    selected: (count: number) => string;
+}
+export interface TableProps<T> {
+    data: readonly T[];
+    columns: readonly Column<T>[];
+    getRowId: (row: T) => RowId;
+    state?: Partial<TableState>;
+    onStateChange?: (state: TableState) => void;
+    getSubRows?: ModelContext<T>['getSubRows'];
+    getRowModel?: (context: ModelContext<T>) => RowModel<T>;
+    manual?: boolean;
+    rowCount?: number;
+    /**
+     * Manual mode: the number of pages when the total is unknown, e.g. `pageIndex + 2` while the
+     * server reports a next page. Without it the page count follows `rowCount`.
+     */
+    pageCount?: number;
+    /**
+     * `id` of the root element. With `selection: 'single'` it also names the row radios
+     * (`<id>-selection`) so they form one native radio group; without it they stay unnamed.
+     * Authored, never generated (SSR relationships).
+     */
+    id?: string;
+    label?: string;
+    caption?: string;
+    title?: Snippet<[RowModel<T>]>;
+    showHeader?: boolean;
+    tableLayout?: 'auto' | 'fixed';
+    searchable?: boolean;
+    /** Milliseconds between the last keystroke in the search box or a filter input and the state change. */
+    searchDelay?: number;
+    /** The text a search term is matched against, per row. Default: visible searchable columns. */
+    searchText?: (row: T) => string;
+    filters?: boolean;
+    columnControls?: boolean;
+    selection?: false | 'single' | 'multiple';
+    isRowSelectable?: (row: T) => boolean;
+    selectionScope?: 'page' | 'filtered';
+    hideSelectAll?: boolean;
+    /** Accessible name of a row in its selection, expand and move controls. Default: the row id. */
+    rowLabel?: (row: T) => string;
+    rowDetails?: Snippet<[T, RowDetailsContext]>;
+    /** Renders the expand toggle in its own leading column instead of the first data column. */
+    expandColumn?: boolean;
+    rowExpandable?: (row: T) => boolean;
+    expandRowByClick?: boolean;
+    indentSize?: number;
+    onExpand?: (expanded: boolean, row: T) => void;
+    onExpandedRowsChange?: (rows: RowId[]) => void;
+    loading?: boolean;
+    fetching?: boolean;
+    /** Skeleton rows drawn while `loading` and no row is present. */
+    skeletonRows?: number;
+    error?: string;
+    onRetry?: () => void;
+    empty?: Snippet<[EmptyContext]>;
+    toolbar?: Snippet<[RowModel<T>]>;
+    footer?: Snippet<[RowModel<T>]>;
+    summary?: Record<string, string | number>;
+    density?: 'compact' | 'comfortable' | 'spacious';
+    striped?: boolean;
+    bordered?: boolean;
+    /**
+     * Keeps the header row in view. With `height` it sticks inside the scroll region; without, it
+     * sticks to the page while the table fits its width (`--slean-table-sticky-top` offsets it below
+     * a fixed application bar) and inside the region once the table scrolls sideways.
+     */
+    stickyHeader?: boolean;
+    height?: string;
+    /**
+     * Progressive mounting for large pages. When at least this many new rows arrive after the table
+     * has mounted (a fetch, a page change), the first batch renders at once and the rest follow in
+     * slices of about one frame each, so the main thread never blocks on the whole set. `true` means
+     * 100. The first render (server output, hydration) is always complete. Default `false`.
+     */
+    progressive?: boolean | number;
+    pagination?: boolean;
+    /** Page sizes offered by the pager; the current size is always included. */
+    pageSizeOptions?: number[];
+    /** Text of an empty value (`null`, `undefined`, `''`, or `format` returning `null`/`''`). */
+    placeholder?: string;
+    rowHoverable?: boolean;
+    /**
+     * Text direction of the table. When absent the root carries no `dir` attribute and keyboard,
+     * resize and pinning follow the nearest `dir` attribute in the document.
+     */
+    dir?: 'ltr' | 'rtl';
+    locale?: string;
+    messages?: Partial<TableMessages>;
+    onEdit?: (event: EditEvent<T>) => void | Promise<void>;
+    /**
+     * Click on a row, outside its controls. Rows become focusable and answer Enter and Space unless
+     * the table has cell navigation (`onEdit`, `onCellRangeChange`).
+     */
+    /** `index` is the row's position on the current page, as in `CellContext`. */
+    onRowClick?: (row: T, event: MouseEvent | KeyboardEvent, index: number) => void;
+    onRowDoubleClick?: (row: T, event: MouseEvent) => void;
+    onRowContextMenu?: (row: T, event: MouseEvent) => void;
+    onScroll?: (event: Event) => void;
+    onAction?: (action: string, row: T, trigger: HTMLElement, index: number) => void;
+    rowClass?: (row: T, index: number) => string;
+    /** Controlled drag/reorder; disabled while sorting, filtering or using tree/group models. */
+    onRowMove?: (source: RowId, target: RowId) => void;
+    cellRange?: CellRange | null;
+    onCellRangeChange?: (range: CellRange | null) => void;
+    class?: string;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};