@vuecs/table 1.0.0

package/dist/components/TableSortIndicators.vue.d.ts

@@ -0,0 +1,335 @@
+import type { ExtractPublicPropTypes, PropType, SlotsType } from 'vue';
+import type { SortDescriptor, TableColumn, TableSortIndicatorsThemeClasses, TableSortState } from '../types';
+declare const tableSortIndicatorsProps: {
+    themeClass: {
+        type: PropType<import("@vuecs/core").ThemeClassesOverride<TableSortIndicatorsThemeClasses>>;
+        default: any;
+    };
+    themeVariant: {
+        type: PropType<import("@vuecs/core").VariantValues>;
+        default: any;
+    };
+    /**
+     * Sort state to render. Use `v-model:sort` for two-way binding.
+     * `null` is treated as "empty array" so consumers carrying
+     * migration-era `ref<TableSortState | null>(null)` don't crash.
+     * When BOTH `:sort` and `:columns` are omitted, the component
+     * falls back to `useTable()` context — note that with the
+     * default `<table>` rendering, slot children render INSIDE the
+     * `<table>`, so the v-model path is the recommended placement
+     * for chip rows above / below the table.
+     */
+    sort: {
+        type: PropType<TableSortState | null>;
+        default: any;
+    };
+    /**
+     * Columns the sort can reference. Required when using v-model
+     * mode (to look up labels + filter the add-column dropdown).
+     * Falls back to `useTable()` context when omitted.
+     */
+    columns: {
+        type: PropType<TableColumn[]>;
+        default: any;
+    };
+    /**
+     * Cap on the sort-state array length (mirrors `<VCTable
+     * :max-sort-keys>`). `0` = unlimited. When the cap is hit,
+     * adding via this component evicts the oldest descriptor.
+     * Falls back to `useTable().maxSortKeys` when omitted; defaults
+     * to `0` (unlimited) in stand-alone v-model mode without a
+     * context.
+     */
+    maxSortKeys: {
+        type: NumberConstructor;
+        default: any;
+    };
+    /** Override the leading label text. Falls back to global defaults. */
+    label: {
+        type: StringConstructor;
+        default: any;
+    };
+    /** Override the empty-state copy. Falls back to global defaults. */
+    emptyContent: {
+        type: StringConstructor;
+        default: any;
+    };
+    /** Override the add-column trigger text. Falls back to global defaults. */
+    addLabel: {
+        type: StringConstructor;
+        default: any;
+    };
+    /** Override the clear-all trigger text. Falls back to global defaults. */
+    clearLabel: {
+        type: StringConstructor;
+        default: any;
+    };
+    /** Override the aria-label applied to per-chip remove buttons. */
+    removeAriaLabel: {
+        type: StringConstructor;
+        default: any;
+    };
+    /** Hide the add-column dropdown (consumer brings their own affordance). */
+    hideAdd: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Hide the clear-all button. */
+    hideClear: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+};
+export type TableSortIndicatorsProps = ExtractPublicPropTypes<typeof tableSortIndicatorsProps>;
+export type TableSortIndicatorsChipSlotProps = {
+    descriptor: SortDescriptor;
+    /** 0-based index in the sort array. */
+    index: number;
+    /** 1-based position (`index + 1`). */
+    position: number;
+    column: TableColumn | undefined;
+    /** Toggle this descriptor's direction (asc ↔ desc). */
+    toggle: () => void;
+    /** Remove this descriptor from the sort. */
+    remove: () => void;
+};
+export type TableSortIndicatorsAddSlotProps = {
+    /** Columns that are `:sortable` but not currently in the sort array. */
+    options: TableColumn[];
+    /** Append a column to the sort with `asc` direction. */
+    add: (key: string) => void;
+};
+export type TableSortIndicatorsClearSlotProps = {
+    /** Clear the entire sort. */
+    clear: () => void;
+};
+/**
+ * Discoverable, modifier-key-free alternative to Shift-click for
+ * managing multi-column sort state. Renders a chip per active
+ * `SortDescriptor`, an add-column dropdown for unsorted sortable
+ * columns, and a clear-all action.
+ *
+ * Two wiring modes:
+ *
+ * 1. **v-model (recommended)** — pass `:sort` + `:columns` and bind
+ *    `v-model:sort`. Place the chip row anywhere (above or below
+ *    the table). This is the only mode that supports the natural
+ *    "chip row above table" layout because `<VCTable>`'s default
+ *    slot children render inside `<table>` and a `<div>` there is
+ *    invalid HTML.
+ *
+ *    ```vue
+ *    <VCTableSortIndicators v-model:sort="sort" :columns="columns" />
+ *    <VCTable v-model:sort="sort" :columns :data ... />
+ *    ```
+ *
+ * 2. **Context fallback** — mount inside a `<VCTable>` and omit
+ *    `:sort` / `:columns`. The component reads from `useTable()`
+ *    and calls `setSortState`. Only safe in custom layouts where
+ *    a `<div>` is legal at the mount point.
+ *
+ * Slot customization:
+ * - `default` — replace the whole layout (slot props include all
+ *   chip handlers + add + clear)
+ * - `#label` — replace the leading "Sort:" label
+ * - `#empty` — replace the empty-state hint
+ * - `#chip="{ descriptor, index, position, toggle, remove }"` —
+ *   replace per-chip rendering
+ * - `#add="{ options, add }"` — replace the add-column trigger
+ * - `#clear="{ clear }"` — replace the clear-all trigger
+ *
+ * Text strings flow through `useComponentDefaults('tableSortIndicators', …)`
+ * so consumers can localize via
+ * `app.use(vuecs, { defaults: { tableSortIndicators: { … } } })`.
+ */
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    themeClass: {
+        type: PropType<import("@vuecs/core").ThemeClassesOverride<TableSortIndicatorsThemeClasses>>;
+        default: any;
+    };
+    themeVariant: {
+        type: PropType<import("@vuecs/core").VariantValues>;
+        default: any;
+    };
+    /**
+     * Sort state to render. Use `v-model:sort` for two-way binding.
+     * `null` is treated as "empty array" so consumers carrying
+     * migration-era `ref<TableSortState | null>(null)` don't crash.
+     * When BOTH `:sort` and `:columns` are omitted, the component
+     * falls back to `useTable()` context — note that with the
+     * default `<table>` rendering, slot children render INSIDE the
+     * `<table>`, so the v-model path is the recommended placement
+     * for chip rows above / below the table.
+     */
+    sort: {
+        type: PropType<TableSortState | null>;
+        default: any;
+    };
+    /**
+     * Columns the sort can reference. Required when using v-model
+     * mode (to look up labels + filter the add-column dropdown).
+     * Falls back to `useTable()` context when omitted.
+     */
+    columns: {
+        type: PropType<TableColumn[]>;
+        default: any;
+    };
+    /**
+     * Cap on the sort-state array length (mirrors `<VCTable
+     * :max-sort-keys>`). `0` = unlimited. When the cap is hit,
+     * adding via this component evicts the oldest descriptor.
+     * Falls back to `useTable().maxSortKeys` when omitted; defaults
+     * to `0` (unlimited) in stand-alone v-model mode without a
+     * context.
+     */
+    maxSortKeys: {
+        type: NumberConstructor;
+        default: any;
+    };
+    /** Override the leading label text. Falls back to global defaults. */
+    label: {
+        type: StringConstructor;
+        default: any;
+    };
+    /** Override the empty-state copy. Falls back to global defaults. */
+    emptyContent: {
+        type: StringConstructor;
+        default: any;
+    };
+    /** Override the add-column trigger text. Falls back to global defaults. */
+    addLabel: {
+        type: StringConstructor;
+        default: any;
+    };
+    /** Override the clear-all trigger text. Falls back to global defaults. */
+    clearLabel: {
+        type: StringConstructor;
+        default: any;
+    };
+    /** Override the aria-label applied to per-chip remove buttons. */
+    removeAriaLabel: {
+        type: StringConstructor;
+        default: any;
+    };
+    /** Hide the add-column dropdown (consumer brings their own affordance). */
+    hideAdd: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Hide the clear-all button. */
+    hideClear: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ["update:sort"], "update:sort", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    themeClass: {
+        type: PropType<import("@vuecs/core").ThemeClassesOverride<TableSortIndicatorsThemeClasses>>;
+        default: any;
+    };
+    themeVariant: {
+        type: PropType<import("@vuecs/core").VariantValues>;
+        default: any;
+    };
+    /**
+     * Sort state to render. Use `v-model:sort` for two-way binding.
+     * `null` is treated as "empty array" so consumers carrying
+     * migration-era `ref<TableSortState | null>(null)` don't crash.
+     * When BOTH `:sort` and `:columns` are omitted, the component
+     * falls back to `useTable()` context — note that with the
+     * default `<table>` rendering, slot children render INSIDE the
+     * `<table>`, so the v-model path is the recommended placement
+     * for chip rows above / below the table.
+     */
+    sort: {
+        type: PropType<TableSortState | null>;
+        default: any;
+    };
+    /**
+     * Columns the sort can reference. Required when using v-model
+     * mode (to look up labels + filter the add-column dropdown).
+     * Falls back to `useTable()` context when omitted.
+     */
+    columns: {
+        type: PropType<TableColumn[]>;
+        default: any;
+    };
+    /**
+     * Cap on the sort-state array length (mirrors `<VCTable
+     * :max-sort-keys>`). `0` = unlimited. When the cap is hit,
+     * adding via this component evicts the oldest descriptor.
+     * Falls back to `useTable().maxSortKeys` when omitted; defaults
+     * to `0` (unlimited) in stand-alone v-model mode without a
+     * context.
+     */
+    maxSortKeys: {
+        type: NumberConstructor;
+        default: any;
+    };
+    /** Override the leading label text. Falls back to global defaults. */
+    label: {
+        type: StringConstructor;
+        default: any;
+    };
+    /** Override the empty-state copy. Falls back to global defaults. */
+    emptyContent: {
+        type: StringConstructor;
+        default: any;
+    };
+    /** Override the add-column trigger text. Falls back to global defaults. */
+    addLabel: {
+        type: StringConstructor;
+        default: any;
+    };
+    /** Override the clear-all trigger text. Falls back to global defaults. */
+    clearLabel: {
+        type: StringConstructor;
+        default: any;
+    };
+    /** Override the aria-label applied to per-chip remove buttons. */
+    removeAriaLabel: {
+        type: StringConstructor;
+        default: any;
+    };
+    /** Hide the add-column dropdown (consumer brings their own affordance). */
+    hideAdd: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** Hide the clear-all button. */
+    hideClear: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    "onUpdate:sort"?: (...args: any[]) => any;
+}>, {
+    label: string;
+    columns: TableColumn<unknown, string>[];
+    maxSortKeys: number;
+    sort: TableSortState;
+    themeClass: import("@vuecs/core").ThemeClassesOverride<TableSortIndicatorsThemeClasses>;
+    themeVariant: import("@vuecs/core").VariantValues;
+    emptyContent: string;
+    addLabel: string;
+    clearLabel: string;
+    removeAriaLabel: string;
+    hideAdd: boolean;
+    hideClear: boolean;
+}, SlotsType<{
+    default(props: {
+        sort: SortDescriptor[];
+        chips: TableSortIndicatorsChipSlotProps[];
+        add: TableSortIndicatorsAddSlotProps;
+        clear: TableSortIndicatorsClearSlotProps;
+    }): unknown;
+    label(): unknown;
+    empty(): unknown;
+    chip(props: TableSortIndicatorsChipSlotProps): unknown;
+    add(props: TableSortIndicatorsAddSlotProps): unknown;
+    clear(props: TableSortIndicatorsClearSlotProps): unknown;
+}>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//# sourceMappingURL=TableSortIndicators.vue.d.ts.map

package/dist/components/TableSortIndicators.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TableSortIndicators.vue.d.ts","sourceRoot":"","sources":["../../src/components/TableSortIndicators.vue"],"names":[],"mappings":"AAscA,OAAO,KAAK,EAAE,sBAAsB,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,KAAK,CAAC;AAQvE,OAAO,KAAK,EACR,cAAc,EACd,WAAW,EACX,+BAA+B,EAC/B,cAAc,EACjB,MAAM,UAAU,CAAC;AAiClB,QAAA,MAAM,wBAAwB;;;;;;;;;IAC1B;;;;;;;;;OASG;;cACoB,QAAQ,CAAC,cAAc,GAAG,IAAI,CAAC;;;IACtD;;;;OAIG;;cACuB,QAAQ,CAAC,WAAW,EAAE,CAAC;;;IACjD;;;;;;;OAOG;;;;;IAEH,sEAAsE;;;;;IAEtE,oEAAoE;;;;;IAEpE,2EAA2E;;;;;IAE3E,0EAA0E;;;;;IAE1E,kEAAkE;;;;;IAElE,2EAA2E;;;;;IAE3E,iCAAiC;;;;;CAGpC,CAAC;AAEF,MAAM,MAAM,wBAAwB,GAAG,sBAAsB,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE/F,MAAM,MAAM,gCAAgC,GAAG;IAC3C,UAAU,EAAE,cAAc,CAAC;IAC3B,uCAAuC;IACvC,KAAK,EAAE,MAAM,CAAC;IACd,sCAAsC;IACtC,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,WAAW,GAAG,SAAS,CAAC;IAChC,uDAAuD;IACvD,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB,4CAA4C;IAC5C,MAAM,EAAE,MAAM,IAAI,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,+BAA+B,GAAG;IAC1C,wEAAwE;IACxE,OAAO,EAAE,WAAW,EAAE,CAAC;IACvB,wDAAwD;IACxD,GAAG,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;CAC9B,CAAC;AAEF,MAAM,MAAM,iCAAiC,GAAG;IAC5C,6BAA6B;IAC7B,KAAK,EAAE,MAAM,IAAI,CAAC;CACrB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;wBACkB,OAAO,YAAY;AAAxC,wBAAyC;AAQzC,QAAA,MAAM,YAAY;;;;;;;;;IArHd;;;;;;;;;OASG;;cACoB,QAAQ,CAAC,cAAc,GAAG,IAAI,CAAC;;;IACtD;;;;OAIG;;cACuB,QAAQ,CAAC,WAAW,EAAE,CAAC;;;IACjD;;;;;;;OAOG;;;;;IAEH,sEAAsE;;;;;IAEtE,oEAAoE;;;;;IAEpE,2EAA2E;;;;;IAE3E,0EAA0E;;;;;IAE1E,kEAAkE;;;;;IAElE,2EAA2E;;;;;IAE3E,iCAAiC;;;;;;;;;;;;;;;;IAtCjC;;;;;;;;;OASG;;cACoB,QAAQ,CAAC,cAAc,GAAG,IAAI,CAAC;;;IACtD;;;;OAIG;;cACuB,QAAQ,CAAC,WAAW,EAAE,CAAC;;;IACjD;;;;;;;OAOG;;;;;IAEH,sEAAsE;;;;;IAEtE,oEAAoE;;;;;IAEpE,2EAA2E;;;;;IAE3E,0EAA0E;;;;;IAE1E,kEAAkE;;;;;IAElE,2EAA2E;;;;;IAE3E,iCAAiC;;;;;;;;;;;;;;;;;;;;;mBAqFd;QACX,IAAI,EAAE,cAAc,EAAE,CAAC;QACvB,KAAK,EAAE,gCAAgC,EAAE,CAAC;QAC1C,GAAG,EAAE,+BAA+B,CAAC;QACrC,KAAK,EAAE,iCAAiC,CAAC;KAC5C,GAAG,OAAO;aACF,OAAO;aACP,OAAO;gBACJ,gCAAgC,GAAG,OAAO;eAC3C,+BAA+B,GAAG,OAAO;iBACvC,iCAAiC,GAAG,OAAO;yEAwQ9D,CAAC"}

package/dist/components/index.d.ts

@@ -0,0 +1,23 @@
+export { default as VCTable } from './Table.vue';
+export { default as VCTableLite } from './TableLite.vue';
+export { default as VCTableHeader } from './TableHeader.vue';
+export { default as VCTableBody } from './TableBody.vue';
+export { default as VCTableFooter } from './TableFooter.vue';
+export { default as VCTableRow } from './TableRow.vue';
+export { default as VCTableCell } from './TableCell.vue';
+export { default as VCTableHeadCell } from './TableHeadCell.vue';
+export { default as VCTableEmpty } from './TableEmpty.vue';
+export { default as VCTableLoading } from './TableLoading.vue';
+export { default as VCTableSortIndicators } from './TableSortIndicators.vue';
+export type { TableProps } from './Table.vue';
+export type { TableLiteProps } from './TableLite.vue';
+export type { TableHeaderProps } from './TableHeader.vue';
+export type { TableBodyProps } from './TableBody.vue';
+export type { TableFooterProps } from './TableFooter.vue';
+export type { TableRowProps } from './TableRow.vue';
+export type { TableCellProps } from './TableCell.vue';
+export type { TableHeadCellProps } from './TableHeadCell.vue';
+export type { TableEmptyProps } from './TableEmpty.vue';
+export type { TableLoadingProps } from './TableLoading.vue';
+export type { TableSortIndicatorsAddSlotProps, TableSortIndicatorsChipSlotProps, TableSortIndicatorsClearSlotProps, TableSortIndicatorsProps, } from './TableSortIndicators.vue';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/components/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,OAAO,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,iBAAiB,CAAC;AACzD,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAC7D,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,iBAAiB,CAAC;AACzD,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAC7D,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACvD,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,iBAAiB,CAAC;AACzD,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACjE,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAC3D,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAC/D,OAAO,EAAE,OAAO,IAAI,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAE7E,YAAY,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,YAAY,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACtD,YAAY,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,YAAY,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACtD,YAAY,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,YAAY,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AACpD,YAAY,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACtD,YAAY,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAC9D,YAAY,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AACxD,YAAY,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAC5D,YAAY,EACR,+BAA+B,EAC/B,gCAAgC,EAChC,iCAAiC,EACjC,wBAAwB,GAC3B,MAAM,2BAA2B,CAAC"}

package/dist/composables/context.d.ts

@@ -0,0 +1,104 @@
+import type { Ref } from 'vue';
+import type { SortDirection, TableColumn, TableSortState } from '../types';
+import type { RowSelectionKey, RowSelectionState } from './selection';
+export type TableContext<Row = unknown> = {
+    data: Ref<Row[]>;
+    busy: Ref<boolean>;
+    columns: Ref<TableColumn<Row>[]>;
+    sort: Ref<TableSortState>;
+    /**
+     * Cycle the sort state for `key`. `opts.append` (Shift-click) adds
+     * the key as a secondary/tertiary descriptor instead of replacing.
+     * `opts.direction` jumps straight to a given direction.
+     */
+    setSort: (key: string, opts?: {
+        append?: boolean;
+        direction?: SortDirection;
+    }) => void;
+    /**
+     * Replace the entire sort state directly. Used by
+     * `<VCTableSortIndicators>` to remove / reorder / clear descriptors
+     * without invoking the per-key cycle logic.
+     */
+    setSortState: (next: TableSortState) => void;
+    /**
+     * Cap on the sort-state array length (`<VCTable :max-sort-keys>`).
+     * Exposed so descendants like `<VCTableSortIndicators>` can
+     * enforce the cap consistently — `setSortState` itself bypasses
+     * cycle logic, so the cap is enforced at the call site.
+     */
+    maxSortKeys: Ref<number>;
+    /**
+     * Whether the host table can actually mutate sort state.
+     * `<VCTable>` sets this to `true`; `<VCTableLite>` sets it to
+     * `false` (it ships no sort machine). Descendants like
+     * `<VCTableSortIndicators>` check this in their context-fallback
+     * path so they refuse to silently no-op when mounted inside Lite.
+     */
+    supportsSortMutation: boolean;
+    /** Whether `<VCTable>` was passed `:rowClickable`. */
+    rowClickable: Ref<boolean>;
+    /** Currently focused row index (row keyboard nav). `null` when nothing focused. */
+    focusedRow: Ref<number | null>;
+    setFocusedRow: (index: number | null) => void;
+    /** Resolved colspan (Shape A: `columns.length`; Shape B: auto-counted from `<VCTableHeadCell>` siblings). */
+    colspan: Ref<number>;
+    /** Emit a `row-click` event from inside a body row. */
+    emitRowClick: (row: Row, index: number, event: Event) => void;
+    /**
+     * The positioned wrapper element that wraps the `<table>` in the DOM.
+     * `<VCTableLoading :overlay>` teleports here so its `<div>` isn't
+     * fostered out of the table by the HTML parser AND so it has a real
+     * positioning context for `position: absolute; inset: 0`.
+     */
+    wrapperEl: Ref<globalThis.HTMLElement | null>;
+    /**
+     * Row selection state (plan 033 v1.x-A). Always provided; reports
+     * mode `undefined` and `isSelected: () => false` when selection is
+     * disabled, so descendants don't need to null-check. `<VCTableRow>`
+     * calls `selection.toggle()` on activation and reads `isSelected`
+     * to render `aria-selected` + the `selected` theme variant.
+     */
+    selection: RowSelectionState;
+    /** Resolve the selection key for a given row (function or index fallback). */
+    getRowKey: (row: Row, index: number) => RowSelectionKey;
+    /**
+     * Set of row indices that are currently interactive (focusable +
+     * keyboard-navigable). Each `<VCTableRow>` registers / unregisters
+     * itself based on its own `isInteractive` state. Used by:
+     *
+     * - Roving-tabindex fallback — when `focusedRow` is unset or stale,
+     *   the FIRST interactive row gets `tabindex="0"` (so a disabled
+     *   row 0 doesn't lock the grid out of Tab navigation).
+     * - Arrow / Home / End nav — skips disabled rows by walking the
+     *   sorted registry rather than the raw data index.
+     */
+    interactiveRows: Ref<Set<number>>;
+    registerInteractiveRow(index: number): void;
+    unregisterInteractiveRow(index: number): void;
+};
+export declare function provideTableContext<Row>(ctx: TableContext<Row>): void;
+export declare function useTable<Row = unknown>(): TableContext<Row> | null;
+export type TableRowContext<Row = unknown> = {
+    row: Ref<Row>;
+    index: Ref<number>;
+    /** Resolved row-level variant from `row._rowVariant`. */
+    rowVariant: Ref<string | null>;
+    /** Resolved per-cell variants from `row._cellVariants`. */
+    cellVariants: Ref<Record<string, string>>;
+    /** `true` when `useTable().focusedRow === index`. */
+    focused: Ref<boolean>;
+    /** Resolved selection key for this row (memoized per render). */
+    selectionKey: Ref<RowSelectionKey>;
+    /** `true` when the parent table's selection includes this row. */
+    selected: Ref<boolean>;
+};
+export declare function provideTableRowContext<Row>(ctx: TableRowContext<Row>): void;
+export declare function useTableRow<Row = unknown>(): TableRowContext<Row> | null;
+export type HeadCellCountContext = {
+    register: () => void;
+    unregister: () => void;
+};
+export declare function provideHeadCellCountContext(ctx: HeadCellCountContext): void;
+export declare function useHeadCellCountContext(): HeadCellCountContext | null;
+//# sourceMappingURL=context.d.ts.map

package/dist/composables/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/composables/context.ts"],"names":[],"mappings":"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"}

package/dist/composables/define-table.d.ts

@@ -0,0 +1,48 @@
+import type { ComputedRef, Ref } from 'vue';
+import type { SortDirection, TableColumn, TableColumnRaw, TableSortState } from '../types';
+export type DefineTableOptions<Row> = {
+    /** Initial data array. */
+    data?: Row[];
+    /** Initial column definitions (TableColumn or bare-string shorthand). */
+    columns?: TableColumnRaw<Row>[];
+    /** Initial busy flag. */
+    busy?: boolean;
+    /** Initial sort state (array of descriptors). Empty array means no sort. */
+    sort?: TableSortState;
+    /** Max sort keys retained in multi-sort mode. `0` = unlimited. Default `3`. */
+    maxSortKeys?: number;
+    /** When `true`, the sort cycle skips the `null` step. Mirrors `<VCTable :must-sort>`. */
+    mustSort?: boolean;
+};
+export type TableState<Row> = {
+    data: Ref<Row[]>;
+    columns: ComputedRef<TableColumn<Row>[]>;
+    rawColumns: Ref<TableColumnRaw<Row>[]>;
+    busy: Ref<boolean>;
+    mustSort: Ref<boolean>;
+    sort: Ref<TableSortState>;
+    setSort: (key: string, opts?: {
+        append?: boolean;
+        direction?: SortDirection;
+    }) => void;
+};
+/**
+ * Pinia-style factory mirroring `defineList()`. Returns reactive state
+ * containers + a `setSort` mutator. Useful when a consumer wants to share
+ * a table's state across multiple components without prop drilling, or
+ * when wiring a controlled table outside the SFC.
+ *
+ *   const usersTable = defineTable<User>({
+ *       columns: ['id', 'name', 'email'],
+ *       data: [],
+ *       busy: false,
+ *   });
+ *
+ *   <VCTable :data="usersTable.data" :columns="usersTable.columns" ... />
+ *
+ * The sort cycle composes `useSortMachine` internally — same semantics
+ * as the `<VCTable>` SFC path (honors per-column `initialSortDirection`
+ * + `mustSort`).
+ */
+export declare function defineTable<Row = unknown>(options?: DefineTableOptions<Row>): TableState<Row>;
+//# sourceMappingURL=define-table.d.ts.map

package/dist/composables/define-table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"define-table.d.ts","sourceRoot":"","sources":["../../src/composables/define-table.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,KAAK,CAAC;AAC5C,OAAO,KAAK,EACR,aAAa,EACb,WAAW,EACX,cAAc,EACd,cAAc,EACjB,MAAM,UAAU,CAAC;AAIlB,MAAM,MAAM,kBAAkB,CAAC,GAAG,IAAI;IAClC,0BAA0B;IAC1B,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC;IACb,yEAAyE;IACzE,OAAO,CAAC,EAAE,cAAc,CAAC,GAAG,CAAC,EAAE,CAAC;IAChC,yBAAyB;IACzB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,4EAA4E;IAC5E,IAAI,CAAC,EAAE,cAAc,CAAC;IACtB,+EAA+E;IAC/E,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,yFAAyF;IACzF,QAAQ,CAAC,EAAE,OAAO,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,UAAU,CAAC,GAAG,IAAI;IAC1B,IAAI,EAAE,GAAG,CAAC,GAAG,EAAE,CAAC,CAAC;IACjB,OAAO,EAAE,WAAW,CAAC,WAAW,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IACzC,UAAU,EAAE,GAAG,CAAC,cAAc,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IACvC,IAAI,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC;IACnB,QAAQ,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC;IACvB,IAAI,EAAE,GAAG,CAAC,cAAc,CAAC,CAAC;IAC1B,OAAO,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,OAAO,CAAC;QAAC,SAAS,CAAC,EAAE,aAAa,CAAA;KAAE,KAAK,IAAI,CAAC;CAC1F,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,WAAW,CAAC,GAAG,GAAG,OAAO,EACrC,OAAO,GAAE,kBAAkB,CAAC,GAAG,CAAM,GACtC,UAAU,CAAC,GAAG,CAAC,CAkCjB"}

package/dist/composables/index.d.ts

@@ -0,0 +1,5 @@
+export * from './context';
+export * from './define-table';
+export * from './selection';
+export * from './sort';
+//# sourceMappingURL=index.d.ts.map

package/dist/composables/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/composables/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC;AAC5B,cAAc,QAAQ,CAAC"}

package/dist/composables/selection.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Thin re-export over `@vuecs/core`'s shared `useSelectionMachine` —
+ * the same composable powers `@vuecs/list` (ARIA listbox) and
+ * `@vuecs/table` (ARIA grid). Table-specific `RowSelection*` aliases
+ * are kept for back-compat with consumers who imported the older
+ * names; new code can import directly from `@vuecs/core`.
+ */
+export { useSelectionMachine as useRowSelectionMachine, } from '@vuecs/core';
+export type { SelectionKey as RowSelectionKey, SelectionMode as RowSelectionMode, SelectionState as RowSelectionState, SelectionValue as RowSelectionValue, UseSelectionMachineArgs as UseRowSelectionMachineArgs, } from '@vuecs/core';
+//# sourceMappingURL=selection.d.ts.map

package/dist/composables/selection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selection.d.ts","sourceRoot":"","sources":["../../src/composables/selection.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EACH,mBAAmB,IAAI,sBAAsB,GAChD,MAAM,aAAa,CAAC;AACrB,YAAY,EACR,YAAY,IAAI,eAAe,EAC/B,aAAa,IAAI,gBAAgB,EACjC,cAAc,IAAI,iBAAiB,EACnC,cAAc,IAAI,iBAAiB,EACnC,uBAAuB,IAAI,0BAA0B,GACxD,MAAM,aAAa,CAAC"}

package/dist/composables/sort.d.ts

@@ -0,0 +1,61 @@
+import type { ComputedRef, Ref } from 'vue';
+import type { SortDirection, TableColumn, TableSortState } from '../types';
+export type UseSortMachineOptions<Row = unknown> = {
+    /** Reactive source-of-truth from the consumer's `v-model:sort`. May be `undefined`. */
+    source: Ref<TableSortState | undefined>;
+    /** Reactive column list — needed to resolve `initialSortDirection`. */
+    columns: Ref<TableColumn<Row>[]>;
+    /** When `true`, the cycle skips the `null` step → `null → asc → desc → asc`. */
+    mustSort: Ref<boolean>;
+    /**
+     * Maximum number of sort keys retained in multi-sort mode (plan 033
+     * v1.x-B). When adding a key past this cap, the oldest descriptor
+     * is dropped. Defaults to `3` in `<VCTable>`.
+     */
+    maxSortKeys: Ref<number>;
+    /** Emit handler that propagates each change back to the consumer. */
+    emit: (next: TableSortState) => void;
+};
+export type SortMachine = {
+    state: ComputedRef<TableSortState>;
+    /**
+     * Cycle the sort state for `key`.
+     *
+     * - Plain call (no opts) — replace state with this key alone. Cycles
+     *   through `initial → opposite → cleared` (or `→ initial` when
+     *   `mustSort`).
+     * - `opts.append === true` (Shift-click) — add `key` as a secondary
+     *   descriptor at the end of the array OR cycle its direction if
+     *   already present. Cycling past clears just that key.
+     * - `opts.direction` — jump straight to that direction. Honors
+     *   `append` for placement.
+     */
+    setSort: (key: string, opts?: {
+        append?: boolean;
+        direction?: SortDirection;
+    }) => void;
+    /**
+     * Replace the entire sort state directly. Bypasses cycle + multi-sort
+     * gating — used by the chip-row indicator UX which mutates the array
+     * declaratively (remove, reorder, clear).
+     */
+    setState: (next: TableSortState) => void;
+    /** Direction for a key (regardless of sort position), or `null`. */
+    directionFor: (key: string) => SortDirection | null;
+    /** 1-based position of a key within the sort array, or `null`. */
+    positionFor: (key: string) => number | null;
+};
+/**
+ * Controlled sort machine. The consumer owns the sort state via
+ * `v-model:sort` — the table emits intent only. When `<VCTable
+ * :client-sort>` is set, the table additionally sorts data internally
+ * via `sortRows()` from `utils/sort-rows.ts`; the controlled v-model
+ * still emits, so consumers stay observable.
+ *
+ * State shape is `SortDescriptor[]` from v1.x-B onward — single-column
+ * sort is an array of length 0–1. Multi-key cycling lives entirely
+ * here; `<VCTableHeadCell>` reads `directionFor` / `positionFor` to
+ * paint the indicator + numeric badge.
+ */
+export declare function useSortMachine<Row = unknown>(options: UseSortMachineOptions<Row>): SortMachine;
+//# sourceMappingURL=sort.d.ts.map

package/dist/composables/sort.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort.d.ts","sourceRoot":"","sources":["../../src/composables/sort.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,KAAK,CAAC;AAC5C,OAAO,KAAK,EAER,aAAa,EACb,WAAW,EACX,cAAc,EACjB,MAAM,UAAU,CAAC;AAElB,MAAM,MAAM,qBAAqB,CAAC,GAAG,GAAG,OAAO,IAAI;IAC/C,uFAAuF;IACvF,MAAM,EAAE,GAAG,CAAC,cAAc,GAAG,SAAS,CAAC,CAAC;IACxC,uEAAuE;IACvE,OAAO,EAAE,GAAG,CAAC,WAAW,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IACjC,gFAAgF;IAChF,QAAQ,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC;IACvB;;;;OAIG;IACH,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACzB,qEAAqE;IACrE,IAAI,EAAE,CAAC,IAAI,EAAE,cAAc,KAAK,IAAI,CAAC;CACxC,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACtB,KAAK,EAAE,WAAW,CAAC,cAAc,CAAC,CAAC;IACnC;;;;;;;;;;;OAWG;IACH,OAAO,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,OAAO,CAAC;QAAC,SAAS,CAAC,EAAE,aAAa,CAAA;KAAE,KAAK,IAAI,CAAC;IACvF;;;;OAIG;IACH,QAAQ,EAAE,CAAC,IAAI,EAAE,cAAc,KAAK,IAAI,CAAC;IACzC,oEAAoE;IACpE,YAAY,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,aAAa,GAAG,IAAI,CAAC;IACpD,kEAAkE;IAClE,WAAW,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAC;CAC/C,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAAC,GAAG,GAAG,OAAO,EACxC,OAAO,EAAE,qBAAqB,CAAC,GAAG,CAAC,GACpC,WAAW,CAwIb"}