@commenda/pathfinder 0.0.0-stage → 0.1.0

package/dist/components/table/TableToolbarActions.js

@@ -0,0 +1,77 @@
+import { Button as e } from "../button/Button.js";
+import { IconButton as t } from "../icon-button/IconButton.js";
+import { Dropdown as n } from "../dropdown/Dropdown.js";
+import { DotsHorizontalIcon as r } from "../icons/DotsHorizontalIcon.js";
+import { Download01Icon as i } from "../icons/Download01Icon.js";
+import { SplitButton as a } from "../split-button/SplitButton.js";
+import o from "clsx";
+import { jsx as s, jsxs as c } from "react/jsx-runtime";
+//#region src/components/table/TableToolbarActions.tsx
+function l({ config: l }) {
+	if (!l) return null;
+	let u = l.primaryAction ?? l.actions?.[0], d = l.secondaryAction ?? l.actions?.[1], f = l.actions?.slice(2) ?? [], p = { groups: [...f.length ? [{
+		id: "extra",
+		items: f.map((e) => ({
+			type: "action",
+			id: e.id,
+			label: e.label,
+			disabled: e.disabled,
+			onClick: e.onAction
+		}))
+	}] : [], ...l.moreMenu?.groups ?? []] }, m = l.primaryAction?.menu;
+	return /* @__PURE__ */ c("div", {
+		className: o("pf:flex pf:items-center pf:gap-xs pf:shrink-0 pf:whitespace-nowrap", (u || d) && "pf:@max-[600px]/table:w-full pf:@max-[600px]/table:flex-wrap"),
+		children: [
+			l.onExport && (u || d ? /* @__PURE__ */ s(t, {
+				label: "Export",
+				size: "sm",
+				onClick: l.onExport,
+				children: /* @__PURE__ */ s(i, {})
+			}) : /* @__PURE__ */ s(e, {
+				variant: "secondary",
+				className: "pf:shrink-0 pf:whitespace-nowrap",
+				size: "sm",
+				leadingIcon: /* @__PURE__ */ s(i, {}),
+				onClick: l.onExport,
+				children: "Export"
+			})),
+			p.groups.length > 0 && /* @__PURE__ */ s(n, {
+				menu: p,
+				trigger: /* @__PURE__ */ s(t, {
+					label: "More table actions",
+					size: "sm",
+					children: /* @__PURE__ */ s(r, {})
+				})
+			}),
+			(u || d) && /* @__PURE__ */ s("span", {
+				"aria-hidden": "true",
+				className: "pf:mx-xs pf:h-[16px] pf:w-[0.5px] pf:shrink-0 pf:bg-soft-pearl-300"
+			}),
+			d && /* @__PURE__ */ s(e, {
+				variant: "secondary",
+				size: "sm",
+				disabled: d.disabled,
+				leadingIcon: d.icon,
+				onClick: d.onAction,
+				children: d.label
+			}),
+			u && (m ? /* @__PURE__ */ s(a, {
+				size: "sm",
+				label: u.label,
+				disabled: u.disabled,
+				onClick: u.onAction,
+				leadingIcon: l.primaryAction?.icon,
+				menuConfig: { ...m }
+			}) : /* @__PURE__ */ s(e, {
+				variant: "primary",
+				size: "sm",
+				disabled: u.disabled,
+				onClick: u.onAction,
+				leadingIcon: l.primaryAction?.icon,
+				children: u.label
+			}))
+		]
+	});
+}
+//#endregion
+export { l as TableToolbarActions };

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

@@ -0,0 +1,13 @@
+export type { TableCellEditor, TableEditCellProps, } from '../tabular/table-edit-types.js';
+export { TableCell } from '../tabular/TableCell.js';
+export type { TableCellProps } from '../tabular/TableCell.js';
+export { TableEditCell } from '../tabular/TableEditCell.js';
+export { TableNumberCell } from '../tabular/TableNumberCell.js';
+export type { TableNumberCellProps } from '../tabular/TableNumberCell.js';
+export { TableRowActions } from '../tabular/TableRowActions.js';
+export type { TableIconAction, TableRowActionsProps, } from '../tabular/TableRowActions.js';
+export type { TableAction, TableColumn, TableFilter, TableFilterOperator, TableFilterOption, TablePage, TablePaginationConfig, TableProps, TableSelection, TableSort, TableToolbarConfig, TabularStateConfig, } from './table-types.js';
+export { Table } from './Table.js';
+export { TableSummary } from './TableSummary.js';
+export type { TableSummaryProps } from './TableSummary.js';
+export { TablePresetFilters, type TablePresetFiltersProps, } from './TablePresetFilters.js';

package/dist/components/table/index.js

@@ -0,0 +1,8 @@
+import { TableNumberCell as e } from "../tabular/TableNumberCell.js";
+import { TableCell as t } from "../tabular/TableCell.js";
+import { TableEditCell as n } from "../tabular/TableEditCell.js";
+import { TableRowActions as r } from "../tabular/TableRowActions.js";
+import { Table as i } from "./Table.js";
+import { TableSummary as a } from "./TableSummary.js";
+import { TablePresetFilters as o } from "./TablePresetFilters.js";
+export { i as Table, t as TableCell, n as TableEditCell, e as TableNumberCell, o as TablePresetFilters, r as TableRowActions, a as TableSummary };

package/dist/components/table/table-column-style.d.ts

@@ -0,0 +1,3 @@
+import type { CSSProperties } from 'react';
+import type { TableColumn } from './table-types.js';
+export declare function tableColumnStyle<TRow>(column: TableColumn<TRow>, columns: readonly TableColumn<TRow>[], selectionWidth?: number, actionWidth?: number): CSSProperties | undefined;

package/dist/components/table/table-column-style.js

@@ -0,0 +1,13 @@
+//#region src/components/table/table-column-style.ts
+function e(e, t, n = 0, r = 0) {
+	if (!e.pin) return;
+	let i = t.findIndex((t) => t.id === e.id), a = t.slice(0, i).filter((e) => e.pin === "start"), o = t.slice(i + 1).filter((e) => e.pin === "end"), s = (e.pin === "start" ? a : o).reduce((e, t) => e + (t.width ?? 160), e.pin === "start" ? n : r);
+	return {
+		position: "sticky",
+		zIndex: 2,
+		...e.pin === "start" && !t.slice(i + 1).some((e) => e.pin === "start") ? { borderInlineEnd: "2px solid var(--pf-color-blue-300)" } : e.pin === "end" && !t.slice(0, i).some((e) => e.pin === "end") ? { borderInlineStart: "2px solid var(--pf-color-blue-300)" } : {},
+		...e.pin === "start" ? { insetInlineStart: s } : { insetInlineEnd: s }
+	};
+}
+//#endregion
+export { e as tableColumnStyle };

package/dist/components/table/table-filter-model.d.ts

@@ -0,0 +1,9 @@
+import type { TableFilter, TableFilterOperator } from './table-filter-types.js';
+/** FILTER-001: AND between fields; membership within a choice field. Remote data is never filtered here. */
+export declare class TableFilterModel {
+    static labels: Record<TableFilterOperator, string>;
+    static operators<TRow>(filter: TableFilter<TRow>): TableFilterOperator[];
+    static operator<TRow>(filter: TableFilter<TRow>, value?: TableFilterOperator): TableFilterOperator;
+    static summary<TRow>(filter: TableFilter<TRow>, values: readonly string[]): string;
+    static matches<TRow>(filter: TableFilter<TRow>, values: readonly string[], requested: TableFilterOperator | undefined, row: TRow): boolean;
+}

package/dist/components/table/table-filter-model.js

@@ -0,0 +1,57 @@
+//#region src/components/table/table-filter-model.ts
+var e = class e {
+	static labels = {
+		is: "is",
+		isNot: "is not",
+		isAnyOf: "is either of",
+		within: "is within",
+		greaterThan: "is greater than",
+		lessThan: "is less than"
+	};
+	static operators(e) {
+		return e.type === "date" ? ["within", "isNot"] : e.type === "number" ? [
+			"is",
+			"isNot",
+			"greaterThan",
+			"lessThan",
+			"within"
+		] : e.type === "single" ? ["is", "isNot"] : [
+			"isAnyOf",
+			"is",
+			"isNot"
+		];
+	}
+	static operator(t, n) {
+		let r = e.operators(t);
+		return n && r.includes(n) ? n : r[0] ?? "is";
+	}
+	static summary(e, t) {
+		if (e.type === "date") return e.presets?.find((e) => e.start === t[0] && e.end === t[1])?.label ?? t.join(" – ");
+		if (e.type === "number") return t.join(" – ");
+		let n = e.options.filter((e) => t.includes(e.value)).map((e) => e.label);
+		return n.length > 2 ? `${n[0]} +${String(n.length - 1)}` : n.join(", ");
+	}
+	static matches(t, n, r, i) {
+		if (!n.length) return !0;
+		let a = e.operator(t, r), o;
+		if (t.type === "number") {
+			let e = t.getValue(i);
+			if (e == null || !Number.isFinite(e)) return !1;
+			if (a === "within" && (!n[0] || !n[1])) return !0;
+			let r = Number(n[0]), s = Number(n[1]);
+			if (n[0] === "" || !Number.isFinite(r)) return !0;
+			o = a === "greaterThan" ? e > r : a === "lessThan" ? e < r : a === "within" ? Number.isFinite(s) && e >= r && e <= s : e === r;
+		} else if (t.type === "date") {
+			let e = t.getValue(i);
+			if (!n[0] || !n[1]) return !0;
+			if (!e) return !1;
+			o = e >= n[0] && e <= n[1];
+		} else {
+			let e = t.getValue?.(i);
+			o = t.matches ? t.matches(i, n) : e != null && n.includes(e);
+		}
+		return a === "isNot" ? !o : o;
+	}
+};
+//#endregion
+export { e as TableFilterModel };

package/dist/components/table/table-filter-types.d.ts

@@ -0,0 +1,35 @@
+import type { ReactNode } from 'react';
+export type TableFilterOperator = 'is' | 'isNot' | 'isAnyOf' | 'within' | 'greaterThan' | 'lessThan';
+export interface TableFilterOption {
+    value: string;
+    label: string;
+    leading?: ReactNode;
+    disabled?: boolean;
+}
+interface TableFilterBase {
+    id: string;
+    label: string;
+    icon?: ReactNode;
+    /** Secondary fields are available through More filters. */
+    initiallyVisible?: boolean;
+}
+export type TableFilter<TRow> = TableFilterBase & ({
+    type?: 'single' | 'multiple';
+    options: readonly TableFilterOption[];
+    searchable?: boolean;
+    getValue?: (row: TRow) => string | null | undefined;
+    matches?: (row: TRow, values: readonly string[]) => boolean;
+} | {
+    type: 'date';
+    getValue: (row: TRow) => string | null | undefined;
+    presets?: readonly {
+        id: string;
+        label: string;
+        start: string;
+        end: string;
+    }[];
+} | {
+    type: 'number';
+    getValue: (row: TRow) => number | null | undefined;
+});
+export {};

package/dist/components/table/table-types.d.ts

@@ -0,0 +1,154 @@
+import type { ReactNode } from 'react';
+import type { SelectionProps } from '../controls/selection-types.js';
+import type { DropdownMenu } from '../dropdown/dropdown-types.js';
+import type { TableFilter, TableFilterOperator } from './table-filter-types.js';
+export type { TableFilter, TableFilterOperator, TableFilterOption, } from './table-filter-types.js';
+export interface TableSort {
+    columnId: string;
+    direction: 'asc' | 'desc';
+}
+export interface TablePage {
+    page: number;
+    pageSize: number;
+}
+export type TableSelection = {
+    kind: 'ids';
+    ids: readonly string[];
+} | {
+    kind: 'all';
+    queryKey: string;
+    excludedIds: readonly string[];
+};
+export interface TableColumn<TRow> {
+    id: string;
+    header: string;
+    /** Supplemental header information, available through a keyboard-accessible tooltip. */
+    description?: string;
+    value?: (row: TRow) => string | number | null | undefined;
+    cell?: (row: TRow) => ReactNode;
+    align?: 'start' | 'center' | 'end';
+    width?: number;
+    minWidth?: number;
+    maxWidth?: number;
+    resizable?: boolean;
+    pinnable?: boolean;
+    sortable?: boolean;
+    compare?: (left: TRow, right: TRow) => number;
+    hideable?: boolean;
+    pin?: 'start' | 'end';
+}
+export interface TableAction {
+    icon?: ReactNode;
+    id: string;
+    label: string;
+    onAction: () => void;
+    disabled?: boolean;
+}
+export interface TabularStateConfig {
+    isLoading?: boolean;
+    error?: {
+        message: string;
+        onRetry: () => void;
+    };
+    empty?: {
+        title: string;
+        description?: string;
+        action?: TableAction;
+    };
+}
+export interface TableToolbarConfig {
+    /** Prefer named actions. Legacy actions use first=primary, second=secondary, remainder=overflow. */
+    actions?: readonly TableAction[];
+    primaryAction?: TableAction & {
+        menu?: DropdownMenu;
+        icon?: ReactNode;
+    };
+    secondaryAction?: TableAction;
+    onExport?: () => void;
+    moreMenu?: DropdownMenu;
+}
+export type TablePaginationConfig = ({
+    mode?: 'pages';
+    totalRows?: number;
+    pageSizes?: readonly number[];
+} & SelectionProps<TablePage>) | {
+    mode: 'cursor';
+    hasNext: boolean;
+    hasPrevious: boolean;
+    onNext: () => void;
+    onPrevious: () => void;
+    summary?: string;
+    pageSize: number;
+    onPageSizeChange?: (size: number) => void;
+};
+export interface TableCommonProps<TRow> {
+    label: string;
+    rows: readonly TRow[];
+    columns: readonly TableColumn<TRow>[];
+    rowConfig: {
+        getId: (row: TRow) => string;
+        getLabel: (row: TRow) => string;
+        onActivate?: (row: TRow) => void;
+        menu?: (row: TRow) => DropdownMenu;
+    };
+    viewConfig?: {
+        density?: SelectionProps<'compact' | 'relaxed'>;
+        hiddenColumns?: SelectionProps<readonly string[]>;
+        columnWidths?: SelectionProps<Readonly<Partial<Record<string, number>>>>;
+        columnPinning?: SelectionProps<Readonly<Partial<Record<string, 'start' | 'end' | null>>>>;
+    };
+    groupingConfig?: {
+        getId: (row: TRow) => string;
+        getLabel: (id: string) => string;
+        leading?: (id: string) => ReactNode;
+        summary?: (id: string, pageRows: readonly TRow[]) => ReactNode;
+        collapsedGroups?: SelectionProps<readonly string[]>;
+    };
+    container?: 'card' | 'flat';
+    sortingConfig?: SelectionProps<TableSort | null>;
+    searchConfig?: SelectionProps<string> & {
+        getText?: (row: TRow) => string;
+        placeholder?: string;
+    };
+    filterConfig?: {
+        filters: readonly TableFilter<TRow>[];
+        operators?: SelectionProps<Readonly<Record<string, TableFilterOperator>>>;
+        value: Readonly<Record<string, readonly string[]>>;
+        onValueChange: (value: Record<string, readonly string[]>) => void;
+    };
+    selectionConfig?: SelectionProps<TableSelection> & {
+        canSelect?: (row: TRow) => boolean;
+        allMatching?: {
+            queryKey: string;
+            total: number;
+        };
+        actions?: readonly TableAction[];
+        moreMenu?: DropdownMenu;
+    };
+    toolbarConfig?: TableToolbarConfig;
+    stateConfig?: TabularStateConfig;
+    summary?: ReactNode;
+    footerConfig?: {
+        total?: {
+            label: string;
+            cells: Readonly<Record<string, ReactNode>>;
+        };
+        addAction?: TableAction;
+    };
+    className?: string;
+}
+export type TableProps<TRow> = TableCommonProps<TRow> & ({
+    dataMode?: 'local';
+    paginationConfig?: Extract<TablePaginationConfig, {
+        mode?: 'pages';
+    }>;
+} | {
+    dataMode: 'remote';
+    paginationConfig: (Extract<TablePaginationConfig, {
+        mode?: 'pages';
+    }> & {
+        totalRows: number;
+    }) | Extract<TablePaginationConfig, {
+        mode: 'cursor';
+    }>;
+});

package/dist/components/table/table-validation.d.ts

@@ -0,0 +1,6 @@
+import type { TableColumn, TablePage } from './table-types.js';
+export declare class TableValidation {
+    static identifiers<TRow>(rows: readonly TRow[], columns: readonly TableColumn<TRow>[], getId: (row: TRow) => string): void;
+    static page(page: TablePage): void;
+    static total(total: number): void;
+}

package/dist/components/table/table-validation.js

@@ -0,0 +1,29 @@
+//#region src/components/table/table-validation.ts
+var e = class {
+	static identifiers(e, t, n) {
+		for (let e of t) {
+			let t = e.minWidth ?? 80, n = e.maxWidth ?? 800;
+			if (![
+				t,
+				n,
+				e.width ?? 160
+			].every((e) => Number.isFinite(e) && e > 0) || t > n) throw Error("Table column widths must be finite positive pixels with minWidth <= maxWidth.");
+		}
+		if (t.length === 0) throw Error("Table requires at least one column.");
+		for (let [r, i] of [["row", e.map(n)], ["column", t.map((e) => e.id)]]) {
+			let e = /* @__PURE__ */ new Set();
+			for (let t of i) {
+				if (!t.trim() || e.has(t)) throw Error(`Table ${r} IDs must be nonempty and unique: ${t}`);
+				e.add(t);
+			}
+		}
+	}
+	static page(e) {
+		if (!Number.isSafeInteger(e.page) || e.page < 1 || !Number.isSafeInteger(e.pageSize) || e.pageSize < 1) throw Error("Table page and pageSize must be positive safe integers.");
+	}
+	static total(e) {
+		if (!Number.isSafeInteger(e) || e < 0) throw Error("Remote Table numbered pages require a nonnegative integer totalRows; use cursor mode for unknown totals.");
+	}
+};
+//#endregion
+export { e as TableValidation };

package/dist/components/table/useTableData.d.ts

@@ -0,0 +1,25 @@
+import type { TableFilterOperator } from './table-filter-types.js';
+import type { TablePage, TableProps, TableSort } from './table-types.js';
+export declare function useTableData<TRow>(props: TableProps<TRow>): {
+    changePage: (next: TablePage) => void;
+    changeSearch: (next: string) => void;
+    changeSort: (id: string, direction?: "asc" | "desc" | null) => void;
+    resetPage: () => void;
+    columns: import("./table-types.js").TableColumn<TRow>[];
+    setWidth: (id: string, width: number) => void;
+    setPin: (id: string, pin: "start" | "end" | null) => void;
+    hidden: string[];
+    density: "compact" | "relaxed";
+    setHidden: (next: readonly string[]) => void;
+    setDensity: (next: "compact" | "relaxed") => void;
+    filterOperators: Readonly<Record<string, TableFilterOperator>>;
+    changeOperator: (id: string, operator: TableFilterOperator) => void;
+    sort: TableSort | null;
+    search: string;
+    page: {
+        page: number;
+        pageSize: number;
+    };
+    total: number;
+    rows: TRow[];
+};

package/dist/components/table/useTableData.js

@@ -0,0 +1,122 @@
+import { TableFilterModel as e } from "./table-filter-model.js";
+import { getCoreRowModel as t, getFilteredRowModel as n, getSortedRowModel as r } from "../../node_modules/.pnpm/@tanstack_table-core@8.21.3/node_modules/@tanstack/table-core/build/lib/index.js";
+import { useReactTable as i } from "../../node_modules/.pnpm/@tanstack_react-table@8.21.3_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@tanstack/react-table/build/lib/index.js";
+import { TableValidation as a } from "./table-validation.js";
+import { useTableView as o } from "./useTableView.js";
+import { useMemo as s, useState as c } from "react";
+//#region src/components/table/useTableData.ts
+function l(l) {
+	let [u, d] = c(l.sortingConfig?.defaultValue ?? null), [f, p] = c(l.searchConfig?.defaultValue ?? ""), [m, h] = c(l.filterConfig?.operators?.defaultValue ?? {}), g = l.filterConfig?.operators?.value ?? m, _ = l.paginationConfig, [v, y] = c(_?.mode === "cursor" ? {
+		page: 1,
+		pageSize: _.pageSize
+	} : _?.defaultValue ?? {
+		page: 1,
+		pageSize: 25
+	}), b = o(l), x = l.sortingConfig?.value === void 0 ? u : l.sortingConfig.value, S = l.searchConfig?.value ?? f, C = _?.mode === "cursor" ? {
+		page: 1,
+		pageSize: _.pageSize
+	} : _?.value ?? v;
+	a.page(C), l.dataMode === "remote" && l.paginationConfig.mode !== "cursor" && a.total(l.paginationConfig.totalRows);
+	let w = (e) => {
+		let t = {
+			page: Math.max(1, Math.floor(e.page)),
+			pageSize: Math.max(1, Math.floor(e.pageSize))
+		};
+		y(t), _?.mode !== "cursor" && _?.onValueChange?.(t);
+	}, T = (e) => {
+		p(e), l.searchConfig?.onValueChange?.(e), w({
+			...C,
+			page: 1
+		});
+	}, E = (e, t) => {
+		let n = t === void 0 ? x?.columnId === e ? x.direction === "asc" ? {
+			columnId: e,
+			direction: "desc"
+		} : null : {
+			columnId: e,
+			direction: "asc"
+		} : t === null ? null : {
+			columnId: e,
+			direction: t
+		};
+		d(n), l.sortingConfig?.onValueChange?.(n), w({
+			...C,
+			page: 1
+		});
+	}, D = s(() => l.columns.map((e) => ({
+		id: e.id,
+		accessorFn: e.value ?? (() => null),
+		enableSorting: e.sortable === !0,
+		sortingFn: e.compare ? (t, n) => e.compare?.(t.original, n.original) ?? 0 : "auto",
+		sortUndefined: "last"
+	})), [l.columns]), O = s(() => (a.identifiers(l.rows, l.columns, l.rowConfig.getId), [...l.rows]), [
+		l.rows,
+		l.columns,
+		l.rowConfig.getId
+	]), k = JSON.stringify([l.filterConfig?.value ?? {}, g]), A = i({
+		data: O,
+		columns: D,
+		getRowId: l.rowConfig.getId,
+		getCoreRowModel: t(),
+		getFilteredRowModel: n(),
+		getSortedRowModel: r(),
+		manualFiltering: l.dataMode === "remote",
+		manualSorting: l.dataMode === "remote",
+		manualPagination: l.dataMode === "remote" || _?.mode === "cursor",
+		autoResetPageIndex: !1,
+		state: {
+			sorting: x ? [{
+				id: x.columnId,
+				desc: x.direction === "desc"
+			}] : [],
+			globalFilter: S + "\0" + k,
+			pagination: {
+				pageIndex: Math.max(0, C.page - 1),
+				pageSize: Math.max(1, C.pageSize)
+			}
+		},
+		globalFilterFn: (t) => (l.searchConfig?.getText?.(t.original) ?? l.columns.map((e) => e.value?.(t.original) ?? "").join(" ")).toLocaleLowerCase().includes(S.toLocaleLowerCase()) && (l.filterConfig?.filters.every((n) => {
+			let r = l.filterConfig?.value[n.id] ?? [];
+			return e.matches(n, r, g[n.id], t.original);
+		}) ?? !0),
+		getColumnCanGlobalFilter: () => !0
+	}), j = l.dataMode === "remote" ? _?.mode === "cursor" ? l.rows.length : _?.totalRows ?? l.rows.length : A.getFilteredRowModel().rows.length, M = Math.max(1, Math.ceil(j / Math.max(1, C.pageSize))), N = l.dataMode === "remote" || _?.mode === "cursor" ? C.page : Math.min(Math.max(1, C.page), M), P = l.dataMode === "remote" || _?.mode === "cursor" ? A.getSortedRowModel().rows : A.getSortedRowModel().rows.slice((N - 1) * C.pageSize, N * C.pageSize);
+	return {
+		filterOperators: g,
+		changeOperator: (e, t) => {
+			let n = l.filterConfig?.filters.find((t) => t.id === e), r = l.filterConfig?.value[e];
+			t === "is" && n?.type !== "number" && r && r.length > 1 && l.filterConfig?.onValueChange({
+				...l.filterConfig.value,
+				[e]: r.slice(0, 1)
+			});
+			let i = {
+				...g,
+				[e]: t
+			};
+			h(i), l.filterConfig?.operators?.onValueChange?.(i), w({
+				...C,
+				page: 1
+			});
+		},
+		sort: x,
+		search: S,
+		page: {
+			...C,
+			page: N
+		},
+		total: j,
+		rows: P.map((e) => e.original),
+		...b,
+		changePage: w,
+		changeSearch: T,
+		changeSort: E,
+		resetPage: () => {
+			w({
+				...C,
+				page: 1
+			});
+		}
+	};
+}
+//#endregion
+export { l as useTableData };

package/dist/components/table/useTableGroups.d.ts

@@ -0,0 +1,10 @@
+import type { TableProps } from './table-types.js';
+/** Group only the current page. Hidden descendants remain in page selection and totals. */
+export declare function useTableGroups<TRow>(rows: readonly TRow[], config: TableProps<TRow>['groupingConfig']): {
+    groups: {
+        id: string;
+        rows: TRow[];
+    }[];
+    collapsed: readonly string[];
+    toggle: (id: string) => void;
+};

package/dist/components/table/useTableGroups.js

@@ -0,0 +1,22 @@
+import { useState as e } from "react";
+//#region src/components/table/useTableGroups.ts
+function t(t, n) {
+	let [r, i] = e(n?.collapsedGroups?.defaultValue ?? []), a = n?.collapsedGroups?.value ?? r, o = /* @__PURE__ */ new Map();
+	for (let e of t) {
+		let t = n?.getId(e) ?? "records", r = o.get(t);
+		r ? r.push(e) : o.set(t, [e]);
+	}
+	return {
+		groups: [...o].map(([e, t]) => ({
+			id: e,
+			rows: t
+		})),
+		collapsed: a,
+		toggle: (e) => {
+			let t = a.includes(e) ? a.filter((t) => t !== e) : [...a, e];
+			i(t), n?.collapsedGroups?.onValueChange?.(t);
+		}
+	};
+}
+//#endregion
+export { t as useTableGroups };

package/dist/components/table/useTableSelection.d.ts

@@ -0,0 +1,13 @@
+import type { TableProps } from './table-types.js';
+export declare function useTableSelection<TRow>(props: TableProps<TRow>, visibleRows: readonly TRow[]): {
+    selected: (id: string) => boolean;
+    allMatchingSelected: boolean;
+    toggle: (id: string, checked: boolean) => void;
+    togglePage: (checked: boolean) => void;
+    allPage: boolean;
+    somePage: boolean;
+    pageDisabled: boolean;
+    count: number;
+    clear: () => void;
+    selectAll: () => void;
+};

package/dist/components/table/useTableSelection.js

@@ -0,0 +1,54 @@
+import { useState as e } from "react";
+//#region src/components/table/useTableSelection.ts
+function t(t, n) {
+	let r = t.selectionConfig, [i, a] = e(r?.defaultValue ?? {
+		kind: "ids",
+		ids: []
+	}), o = r?.value ?? i, s = o.kind === "all" && o.queryKey !== r?.allMatching?.queryKey ? {
+		kind: "ids",
+		ids: []
+	} : o, c = (e) => s.kind === "all" ? !s.excludedIds.includes(e) : s.ids.includes(e), l = (e) => {
+		a(e), r?.onValueChange?.(e);
+	}, u = (e, t) => {
+		s.kind === "all" ? l({
+			...s,
+			excludedIds: t ? s.excludedIds.filter((t) => t !== e) : [.../* @__PURE__ */ new Set([...s.excludedIds, e])]
+		}) : l({
+			kind: "ids",
+			ids: t ? [.../* @__PURE__ */ new Set([...s.ids, e])] : s.ids.filter((t) => t !== e)
+		});
+	}, d = n.filter((e) => r?.canSelect?.(e) !== !1).map(t.rowConfig.getId), f = d.filter(c).length;
+	return {
+		selected: c,
+		allMatchingSelected: s.kind === "all" && s.excludedIds.length === 0,
+		toggle: u,
+		togglePage: (e) => {
+			s.kind === "all" ? l({
+				...s,
+				excludedIds: e ? s.excludedIds.filter((e) => !d.includes(e)) : [.../* @__PURE__ */ new Set([...s.excludedIds, ...d])]
+			}) : l({
+				kind: "ids",
+				ids: e ? [.../* @__PURE__ */ new Set([...s.ids, ...d])] : s.ids.filter((e) => !d.includes(e))
+			});
+		},
+		allPage: d.length > 0 && f === d.length,
+		somePage: f > 0 && f < d.length,
+		pageDisabled: d.length === 0,
+		count: s.kind === "all" ? Math.max(0, (r?.allMatching?.total ?? 0) - s.excludedIds.length) : s.ids.length,
+		clear: () => {
+			l({
+				kind: "ids",
+				ids: []
+			});
+		},
+		selectAll: () => {
+			r?.allMatching && l({
+				kind: "all",
+				queryKey: r.allMatching.queryKey,
+				excludedIds: []
+			});
+		}
+	};
+}
+//#endregion
+export { t as useTableSelection };