@datum-cloud/datum-ui 0.3.0-alpha.9d90881 → 0.3.0-alpha.ffa8392

package/dist/data-table/index.mjs

@@ -13,10 +13,10 @@ import { c as TableRow, i as TableCell, n as TableBody, o as TableHead, s as Tab
 import { t as CalendarDatePicker } from "../calendar-date-picker-BBAg78Lg.mjs";
 import { cva } from "class-variance-authority";
 import { ArrowDown, ArrowUp, ArrowUpDown, Check, ChevronDown, ChevronLeft, ChevronRight, MoreHorizontal, X } from "lucide-react";
-import { createContext, use, useCallback, useEffect, useId, useMemo, useRef, useState } from "react";
+import { createContext, use, useCallback, useEffect, useId, useMemo, useRef, useState, useSyncExternalStore } from "react";
 import { jsx, jsxs } from "react/jsx-runtime";
-import { parseAsInteger, parseAsJson, parseAsString, useQueryStates } from "nuqs";
-import { flexRender, getCoreRowModel, getFilteredRowModel, getPaginationRowModel, getSortedRowModel, useReactTable } from "@tanstack/react-table";
+import { parseAsInteger, parseAsString, useQueryStates } from "nuqs";
+import { flexRender, getCoreRowModel, getPaginationRowModel, getSortedRowModel, useReactTable } from "@tanstack/react-table";
 
 //#region src/components/features/data-table/constants.ts
 const DEFAULT_PAGE_SIZE = 20;
@@ -32,15 +32,32 @@ const DEFAULT_LOADING_ROWS = 5;
 //#endregion
 //#region src/components/features/data-table/adapters/nuqs-adapter.ts
 /**
-* Default parsers for core DataTable state.
-* URL params: ?sort=[...]&q=hello&page=0&size=20
+* Serialize SortingState to URL-friendly string.
+* Format: "name" (asc), "-name" (desc), comma-separated for multi-sort.
+* Example: "-department,name" → [{id:"department",desc:true},{id:"name",desc:false}]
 */
-function sortingValidator(value) {
-	if (!Array.isArray(value)) return null;
-	return value.every((item) => typeof item === "object" && item !== null && typeof item.id === "string" && typeof item.desc === "boolean") ? value : null;
+function serializeSorting(sorting) {
+	if (sorting.length === 0) return "";
+	return sorting.map((s) => s.desc ? `-${s.id}` : s.id).join(",");
+}
+/**
+* Parse URL sort string back to SortingState.
+*/
+function parseSorting(value) {
+	if (!value) return [];
+	return value.split(",").filter(Boolean).map((part) => {
+		if (part.startsWith("-")) return {
+			id: part.slice(1),
+			desc: true
+		};
+		return {
+			id: part,
+			desc: false
+		};
+	});
 }
 const coreSearchParams = {
-	sort: parseAsJson(sortingValidator).withDefault([]),
+	sort: parseAsString.withDefault(""),
 	q: parseAsString.withDefault(""),
 	page: parseAsInteger.withDefault(0),
 	size: parseAsInteger.withDefault(DEFAULT_PAGE_SIZE)
@@ -48,22 +65,21 @@ const coreSearchParams = {
 /**
 * Hook that creates a StateAdapter backed by nuqs URL query state.
 *
-* Manages sorting, search, pageIndex, and pageSize automatically.
-* Consumer only needs to declare custom filter parsers.
+* URL format:
+* - `?sort=name` (asc) or `?sort=-name` (desc), comma-separated for multi-sort
+* - `?q=search` for search text
+* - `?page=0&size=20` for pagination
+* - Custom filter keys as declared in options
 *
 * Requires `nuqs` to be installed in the consumer app.
 *
 * @example
 * ```tsx
-* // Zero config — all defaults synced to URL
-* const stateAdapter = useNuqsAdapter()
-* const tableState = useDataTableClient({ data, columns, stateAdapter })
-*
-* // With custom filters synced to URL
-* import { parseAsString } from 'nuqs'
-*
 * const stateAdapter = useNuqsAdapter({
-*   filters: { status: parseAsString.withDefault('') },
+*   filters: {
+*     status: parseAsString.withDefault(''),
+*     department: parseAsArrayOf(parseAsString).withDefault([]),
+*   },
 * })
 * const tableState = useDataTableClient({ data, columns, stateAdapter })
 * ```
@@ -75,7 +91,7 @@ function useNuqsAdapter(options = {}) {
 	const [filterState, setFilterState] = useQueryStates(hasFilters ? filterParsers : { _dt: parseAsString.withDefault("") });
 	return useMemo(() => ({
 		read: () => ({
-			sorting: coreState.sort,
+			sorting: parseSorting(coreState.sort),
 			search: coreState.q,
 			pageIndex: coreState.page,
 			pageSize: coreState.size,
@@ -83,19 +99,24 @@ function useNuqsAdapter(options = {}) {
 		}),
 		write: (state) => {
 			setCoreState({
-				sort: state.sorting,
+				sort: serializeSorting(state.sorting),
 				q: state.search,
 				page: state.pageIndex ?? 0,
 				size: state.pageSize ?? DEFAULT_PAGE_SIZE
 			});
-			if (hasFilters) setFilterState(state.filters);
+			if (hasFilters && filterParsers) {
+				const update = {};
+				for (const key of Object.keys(filterParsers)) update[key] = state.filters?.[key] ?? null;
+				setFilterState(update);
+			}
 		}
 	}), [
 		coreState,
 		filterState,
 		hasFilters,
 		setCoreState,
-		setFilterState
+		setFilterState,
+		filterParsers
 	]);
 }
 
@@ -131,22 +152,439 @@ function withSelectionColumn(columns, options = {}) {
 	return [createSelectionColumn(options), ...columns];
 }
 
+//#endregion
+//#region src/components/features/data-table/core/filter-engine.ts
+const FILTER_STRATEGIES = {
+	"checkbox": (cellValue, filterValue) => {
+		if (filterValue == null) return true;
+		if (Array.isArray(filterValue) && filterValue.length === 0) return true;
+		if (!Array.isArray(filterValue)) return cellValue === filterValue;
+		if (Array.isArray(cellValue)) return cellValue.some((v) => filterValue.includes(v));
+		return filterValue.includes(cellValue);
+	},
+	"select": (cellValue, filterValue) => {
+		if (filterValue == null || filterValue === "") return true;
+		return cellValue === filterValue;
+	},
+	"date-gte": (cellValue, filterValue) => {
+		if (!filterValue) return true;
+		const cell = new Date(cellValue);
+		const filter = new Date(filterValue);
+		if (Number.isNaN(cell.getTime()) || Number.isNaN(filter.getTime())) return true;
+		return cell >= filter;
+	},
+	"date-lte": (cellValue, filterValue) => {
+		if (!filterValue) return true;
+		const cell = new Date(cellValue);
+		const filter = new Date(filterValue);
+		if (Number.isNaN(cell.getTime()) || Number.isNaN(filter.getTime())) return true;
+		return cell <= filter;
+	}
+};
+function resolveStrategy(strategy) {
+	if (!strategy) return void 0;
+	if (typeof strategy === "function") return strategy;
+	return FILTER_STRATEGIES[strategy];
+}
+function applyFilters(data, filters, search, registeredFilters, customFilterFns, searchConfig) {
+	const hasFilters = Object.keys(filters).length > 0;
+	const hasSearch = search.length > 0;
+	if (!hasFilters && !hasSearch) return data;
+	return data.filter((row) => {
+		if (hasFilters) for (const [column, value] of Object.entries(filters)) {
+			const fn = customFilterFns[column] ?? resolveStrategy(registeredFilters.get(column));
+			if (!fn) {
+				console.warn(`[DataTable] No filter strategy registered for column "${column}". Filter ignored.`);
+				continue;
+			}
+			const cellValue = row[column];
+			if (!fn(cellValue, value)) return false;
+		}
+		if (hasSearch) {
+			const query = search.toLowerCase();
+			if (searchConfig.searchFn) return searchConfig.searchFn(row, search);
+			if (searchConfig.searchableColumns && searchConfig.searchableColumns.length > 0) return searchConfig.searchableColumns.some((col) => {
+				const cellValue = row[col];
+				return cellValue != null && String(cellValue).toLowerCase().includes(query);
+			});
+			return Object.values(row).some((val) => {
+				if (val == null) return false;
+				return String(val).toLowerCase().includes(query);
+			});
+		}
+		return true;
+	});
+}
+
+//#endregion
+//#region src/components/features/data-table/core/store.ts
+function createDataTableStore(options) {
+	const registeredFilters = /* @__PURE__ */ new Map();
+	const listeners = /* @__PURE__ */ new Set();
+	function computeFilteredData(s) {
+		if (s.mode === "server") return s.data;
+		return applyFilters(s.data, s.filters, s.search, registeredFilters, options.filterFns ?? {}, {
+			searchFn: options.searchFn,
+			searchableColumns: options.searchableColumns
+		});
+	}
+	let state = {
+		data: options.data,
+		filteredData: options.data,
+		sorting: options.defaultSort ?? [],
+		filters: options.defaultFilters ?? {},
+		search: "",
+		rowSelection: {},
+		pageIndex: 0,
+		pageSize: options.pageSize ?? DEFAULT_PAGE_SIZE,
+		mode: options.mode,
+		isLoading: false,
+		error: null,
+		inlineContents: []
+	};
+	if (options.defaultFilters && Object.keys(options.defaultFilters).length > 0) state = {
+		...state,
+		filteredData: computeFilteredData(state)
+	};
+	function notify() {
+		for (const listener of listeners) listener();
+	}
+	function setState(next) {
+		state = next;
+		notify();
+	}
+	return {
+		getSnapshot: () => state,
+		subscribe: (listener) => {
+			listeners.add(listener);
+			return () => listeners.delete(listener);
+		},
+		setData: (data) => {
+			const next = {
+				...state,
+				data,
+				pageIndex: 0,
+				rowSelection: {}
+			};
+			setState({
+				...next,
+				filteredData: computeFilteredData(next)
+			});
+		},
+		setServerData: (data) => {
+			setState({
+				...state,
+				data,
+				filteredData: data
+			});
+		},
+		setTable: (_t) => {},
+		setSorting: (sorting) => {
+			setState({
+				...state,
+				sorting,
+				rowSelection: {}
+			});
+		},
+		setFilter: (key, value) => {
+			const next = {
+				...state,
+				filters: {
+					...state.filters,
+					[key]: value
+				},
+				rowSelection: {},
+				pageIndex: 0
+			};
+			setState({
+				...next,
+				filteredData: computeFilteredData(next)
+			});
+		},
+		clearFilter: (key) => {
+			const filters = Object.fromEntries(Object.entries(state.filters).filter(([k]) => k !== key));
+			const next = {
+				...state,
+				filters,
+				rowSelection: {},
+				pageIndex: 0
+			};
+			setState({
+				...next,
+				filteredData: computeFilteredData(next)
+			});
+		},
+		clearAllFilters: () => {
+			const next = {
+				...state,
+				filters: {},
+				rowSelection: {},
+				pageIndex: 0
+			};
+			setState({
+				...next,
+				filteredData: computeFilteredData(next)
+			});
+		},
+		setSearch: (search) => {
+			const next = {
+				...state,
+				search,
+				rowSelection: {},
+				pageIndex: 0
+			};
+			setState({
+				...next,
+				filteredData: computeFilteredData(next)
+			});
+		},
+		clearSearch: () => {
+			const next = {
+				...state,
+				search: "",
+				rowSelection: {},
+				pageIndex: 0
+			};
+			setState({
+				...next,
+				filteredData: computeFilteredData(next)
+			});
+		},
+		setRowSelection: (rowSelection) => {
+			setState({
+				...state,
+				rowSelection
+			});
+		},
+		setPageIndex: (pageIndex) => {
+			setState({
+				...state,
+				pageIndex,
+				rowSelection: {}
+			});
+		},
+		setPageSize: (pageSize) => {
+			setState({
+				...state,
+				pageSize,
+				pageIndex: 0,
+				rowSelection: {}
+			});
+		},
+		setLoading: (isLoading) => {
+			setState({
+				...state,
+				isLoading
+			});
+		},
+		setError: (error) => {
+			setState({
+				...state,
+				error
+			});
+		},
+		registerFilter: (column, strategy) => {
+			registeredFilters.set(column, strategy);
+			const filteredData = computeFilteredData(state);
+			setState({
+				...state,
+				filteredData
+			});
+		},
+		unregisterFilter: (column) => {
+			registeredFilters.delete(column);
+			if (column in state.filters) {
+				const filteredData = computeFilteredData(state);
+				setState({
+					...state,
+					filteredData
+				});
+			}
+		},
+		registerInlineContent: (entry) => {
+			const existing = state.inlineContents.findIndex((e) => e.id === entry.id);
+			const inlineContents = existing >= 0 ? state.inlineContents.map((e, i) => i === existing ? entry : e) : [...state.inlineContents, entry];
+			setState({
+				...state,
+				inlineContents
+			});
+		},
+		unregisterInlineContent: (id) => {
+			const inlineContents = state.inlineContents.filter((e) => e.id !== id);
+			setState({
+				...state,
+				inlineContents
+			});
+		}
+	};
+}
+
 //#endregion
 //#region src/components/features/data-table/core/data-table-context.tsx
+const DataTableStoreContext = createContext(null);
+const TableInstanceContext = createContext(null);
 const DataTableContext = createContext(null);
+function useDataTableStore() {
+	const store = use(DataTableStoreContext);
+	if (!store) throw new Error("useDataTableStore must be used within a <DataTable.Client> or <DataTable.Server> provider");
+	return store;
+}
+function useTableInstance() {
+	const table = use(TableInstanceContext);
+	if (!table) throw new Error("useTableInstance must be used within a <DataTable.Client> or <DataTable.Server> provider");
+	return table;
+}
+
+//#endregion
+//#region src/components/features/data-table/hooks/use-selectors.ts
+function shallowEqual(a, b) {
+	const keysA = Object.keys(a);
+	const keysB = Object.keys(b);
+	if (keysA.length !== keysB.length) return false;
+	for (const key of keysA) {
+		const va = a[key];
+		const vb = b[key];
+		if (va === vb) continue;
+		if (Array.isArray(va) && Array.isArray(vb)) {
+			if (va.length !== vb.length) return false;
+			for (let i = 0; i < va.length; i++) if (va[i] !== vb[i]) return false;
+			continue;
+		}
+		return false;
+	}
+	return true;
+}
+function useSliceSelector(selector) {
+	const store = useDataTableStore();
+	const cachedRef = useRef(null);
+	const getSnapshot = useCallback(() => {
+		const next = selector(store.getSnapshot());
+		if (cachedRef.current && shallowEqual(cachedRef.current, next)) return cachedRef.current;
+		cachedRef.current = next;
+		return next;
+	}, [store, selector]);
+	return useSyncExternalStore(store.subscribe, getSnapshot);
+}
+function useDataTableFilters() {
+	const store = useDataTableStore();
+	return useSliceSelector(useCallback((state) => ({
+		filters: state.filters,
+		setFilter: store.setFilter,
+		clearFilter: store.clearFilter,
+		clearAllFilters: store.clearAllFilters,
+		registerFilter: store.registerFilter,
+		unregisterFilter: store.unregisterFilter
+	}), [store]));
+}
+function useDataTableSearch() {
+	const store = useDataTableStore();
+	return useSliceSelector(useCallback((state) => ({
+		search: state.search,
+		setSearch: store.setSearch,
+		clearSearch: store.clearSearch
+	}), [store]));
+}
+function useDataTableSorting() {
+	const store = useDataTableStore();
+	return useSliceSelector(useCallback((state) => ({
+		sorting: state.sorting,
+		setSorting: store.setSorting
+	}), [store]));
+}
+function useDataTableSelection() {
+	const store = useDataTableStore();
+	const table = useTableInstance();
+	return useSliceSelector(useCallback((state) => ({
+		rowSelection: state.rowSelection,
+		setRowSelection: store.setRowSelection,
+		selectedRows: table.getFilteredSelectedRowModel().rows.map((r) => r.original)
+	}), [store, table]));
+}
+function useDataTablePagination() {
+	const store = useDataTableStore();
+	const table = useTableInstance();
+	const nextPage = useCallback(() => table.nextPage(), [table]);
+	const prevPage = useCallback(() => table.previousPage(), [table]);
+	return useSliceSelector(useCallback((state) => ({
+		canNextPage: table.getCanNextPage(),
+		canPrevPage: table.getCanPreviousPage(),
+		nextPage,
+		prevPage,
+		pageIndex: state.pageIndex,
+		pageCount: table.getPageCount(),
+		setPageIndex: store.setPageIndex,
+		pageSize: state.pageSize,
+		setPageSize: store.setPageSize,
+		totalRows: state.filteredData.length
+	}), [
+		store,
+		table,
+		nextPage,
+		prevPage
+	]));
+}
+function useDataTableRows() {
+	const table = useTableInstance();
+	return useSliceSelector(useCallback((_state) => ({
+		rows: table.getRowModel().rows,
+		headerGroups: table.getHeaderGroups(),
+		totalColumns: table.getAllColumns().length
+	}), [table]));
+}
+function useDataTableLoading() {
+	return useSliceSelector(useCallback((state) => ({
+		isLoading: state.isLoading,
+		error: state.error
+	}), []));
+}
+function useDataTableInlineContents() {
+	const store = useDataTableStore();
+	return useSliceSelector(useCallback((state) => ({
+		inlineContents: state.inlineContents,
+		registerInlineContent: store.registerInlineContent,
+		unregisterInlineContent: store.unregisterInlineContent
+	}), [store]));
+}
 function useDataTableContext() {
-	const context = use(DataTableContext);
-	if (!context) throw new Error("useDataTableContext must be used within a DataTable provider");
-	return context;
+	const store = useDataTableStore();
+	const table = useTableInstance();
+	const state = useSyncExternalStore(store.subscribe, store.getSnapshot);
+	return {
+		table,
+		mode: state.mode,
+		sorting: state.sorting,
+		filters: state.filters,
+		search: state.search,
+		rowSelection: state.rowSelection,
+		isLoading: state.isLoading,
+		setSorting: store.setSorting,
+		setFilter: store.setFilter,
+		clearFilter: store.clearFilter,
+		clearAllFilters: store.clearAllFilters,
+		setSearch: store.setSearch,
+		clearSearch: store.clearSearch,
+		setRowSelection: store.setRowSelection,
+		pagination: {
+			canNextPage: table.getCanNextPage(),
+			canPrevPage: table.getCanPreviousPage(),
+			nextPage: () => table.nextPage(),
+			prevPage: () => table.previousPage(),
+			pageIndex: state.pageIndex,
+			pageCount: table.getPageCount(),
+			setPageIndex: store.setPageIndex,
+			pageSize: state.pageSize,
+			setPageSize: store.setPageSize
+		},
+		inlineContents: state.inlineContents,
+		registerInlineContent: store.registerInlineContent,
+		unregisterInlineContent: store.unregisterInlineContent
+	};
 }
 
 //#endregion
 //#region src/components/features/data-table/components/bulk-actions.tsx
 function DataTableBulkActions({ children, className }) {
-	const { table, rowSelection } = useDataTableContext();
-	const selectedRows = useMemo(() => {
-		return table.getFilteredSelectedRowModel().rows.map((row) => row.original);
-	}, [table, rowSelection]);
+	const { selectedRows } = useDataTableSelection();
 	if (selectedRows.length === 0) return null;
 	return /* @__PURE__ */ jsx("div", {
 		"data-slot": "dt-bulk-actions",
@@ -170,7 +608,7 @@ function DataTableColumnHeader({ column, title, className }) {
 		children: /* @__PURE__ */ jsxs("button", {
 			type: "button",
 			className: "flex items-center gap-1 hover:text-foreground -ml-3 h-8 px-3 cursor-pointer",
-			onClick: () => column.toggleSorting(sorted === "asc"),
+			onClick: column.getToggleSortingHandler(),
 			children: [/* @__PURE__ */ jsx("span", { children: title }), sorted === "desc" ? /* @__PURE__ */ jsx(ArrowDown, { className: "size-4" }) : sorted === "asc" ? /* @__PURE__ */ jsx(ArrowUp, { className: "size-4" }) : /* @__PURE__ */ jsx(ArrowUpDown, { className: "size-4" })]
 		})
 	});
@@ -197,10 +635,10 @@ function renderInlineContentRow(entry, colSpan, rows) {
 	}, entry.id);
 }
 function DataTableContent({ emptyMessage, className, tableClassName, headerClassName, headerRowClassName, headerCellClassName, bodyClassName, rowClassName, cellClassName }) {
-	const { table, inlineContents } = useDataTableContext();
-	const rows = table.getRowModel().rows;
+	const { rows, headerGroups, totalColumns } = useDataTableRows();
+	const { inlineContents } = useDataTableInlineContents();
 	const openInlineContents = useMemo(() => inlineContents.filter((e) => e.open), [inlineContents]);
-	const colSpan = table.getAllColumns().length;
+	const colSpan = totalColumns;
 	return /* @__PURE__ */ jsx("div", {
 		className: cn("datum-ui-data-table", className),
 		"data-slot": "dt",
@@ -211,7 +649,7 @@ function DataTableContent({ emptyMessage, className, tableClassName, headerClass
 			children: [/* @__PURE__ */ jsx(TableHeader, {
 				className: cn(headerClassName),
 				"data-slot": "dt-header",
-				children: table.getHeaderGroups().map((headerGroup) => /* @__PURE__ */ jsx(TableRow, {
+				children: headerGroups.map((headerGroup) => /* @__PURE__ */ jsx(TableRow, {
 					className: cn(headerRowClassName),
 					"data-slot": "dt-header-row",
 					children: headerGroup.headers.map((header) => /* @__PURE__ */ jsx(TableHead, {
@@ -228,6 +666,7 @@ function DataTableContent({ emptyMessage, className, tableClassName, headerClass
 					if (rowEntry) return renderInlineContentRow(rowEntry, colSpan, rows);
 					return /* @__PURE__ */ jsx(TableRow, {
 						className: cn(resolveClassName(rowClassName, row)),
+						style: { transitionProperty: "none" },
 						"data-slot": "dt-row",
 						"data-state": row.getIsSelected() ? "selected" : void 0,
 						children: row.getVisibleCells().map((cell) => /* @__PURE__ */ jsx(TableCell, {
@@ -254,7 +693,7 @@ function DataTableContent({ emptyMessage, className, tableClassName, headerClass
 //#region src/components/features/data-table/components/inline-content.tsx
 function DataTableInlineContent({ position, rowId, open, onClose, className, children }) {
 	const id = useId();
-	const { registerInlineContent, unregisterInlineContent } = useDataTableContext();
+	const { registerInlineContent, unregisterInlineContent } = useDataTableInlineContents();
 	const initialRender = useRef(true);
 	useEffect(() => {
 		registerInlineContent({
@@ -325,57 +764,116 @@ function DataTableLoading({ rows = DEFAULT_LOADING_ROWS, columns = 4, className
 
 //#endregion
 //#region src/components/features/data-table/components/pagination.tsx
+/**
+* Generates page numbers with ellipsis for large page counts.
+* Shows up to 7 items: first, last, current +/- 1 neighbor, and ellipsis gaps.
+*/
+function getPageNumbers(currentPage, totalPages) {
+	if (totalPages <= 7) return Array.from({ length: totalPages }, (_, i) => i + 1);
+	const pages = [1];
+	const current = currentPage + 1;
+	if (current <= 4) {
+		for (let i = 2; i <= 5; i++) pages.push(i);
+		pages.push("...");
+		pages.push(totalPages);
+	} else if (current >= totalPages - 3) {
+		pages.push("...");
+		for (let i = totalPages - 4; i <= totalPages; i++) pages.push(i);
+	} else {
+		pages.push("...");
+		for (let i = current - 1; i <= current + 1; i++) pages.push(i);
+		pages.push("...");
+		pages.push(totalPages);
+	}
+	return pages;
+}
 function DataTablePagination({ pageSizes = DEFAULT_PAGE_SIZES, className }) {
-	const { pagination, mode } = useDataTableContext();
+	const { canNextPage, canPrevPage, nextPage, prevPage, pageIndex, pageCount, setPageIndex, pageSize, setPageSize, totalRows } = useDataTablePagination();
+	const isClientMode = pageCount > 0;
+	const startRow = pageIndex * pageSize + 1;
+	const endRow = Math.min((pageIndex + 1) * pageSize, totalRows);
+	const pageNumbers = useMemo(() => getPageNumbers(pageIndex, pageCount), [pageIndex, pageCount]);
 	return /* @__PURE__ */ jsxs("div", {
-		className: cn("flex items-center justify-between px-2 py-4", className),
+		className: cn("flex flex-col-reverse items-center justify-between gap-4 px-2 py-4 sm:flex-row", className),
 		"data-slot": "dt-pagination",
 		children: [/* @__PURE__ */ jsxs("div", {
-			className: "flex items-center gap-2",
-			children: [/* @__PURE__ */ jsx("span", {
-				className: "text-sm text-muted-foreground",
-				children: "Rows per page"
-			}), /* @__PURE__ */ jsxs(Select, {
-				value: String(pagination.pageSize),
-				onValueChange: (value) => pagination.setPageSize(Number(value)),
-				children: [/* @__PURE__ */ jsx(SelectTrigger, {
-					className: "h-8 w-[70px]",
-					children: /* @__PURE__ */ jsx(SelectValue, { placeholder: String(pagination.pageSize) })
-				}), /* @__PURE__ */ jsx(SelectContent, {
-					side: "top",
-					children: pageSizes.map((size) => /* @__PURE__ */ jsx(SelectItem, {
-						value: String(size),
-						children: size
-					}, size))
+			className: "flex items-center gap-4",
+			children: [isClientMode && totalRows > 0 && /* @__PURE__ */ jsxs("span", {
+				className: "text-sm text-muted-foreground whitespace-nowrap",
+				children: [
+					"Showing",
+					" ",
+					startRow,
+					" ",
+					"to",
+					" ",
+					endRow,
+					" ",
+					"of",
+					" ",
+					totalRows,
+					" ",
+					"rows"
+				]
+			}), /* @__PURE__ */ jsxs("div", {
+				className: "flex items-center gap-2",
+				children: [/* @__PURE__ */ jsx("span", {
+					className: "text-sm text-muted-foreground whitespace-nowrap",
+					children: "Rows per page"
+				}), /* @__PURE__ */ jsxs(Select, {
+					value: String(pageSize),
+					onValueChange: (value) => setPageSize(Number(value)),
+					children: [/* @__PURE__ */ jsx(SelectTrigger, {
+						className: "h-8 w-[70px]",
+						children: /* @__PURE__ */ jsx(SelectValue, { placeholder: String(pageSize) })
+					}), /* @__PURE__ */ jsx(SelectContent, {
+						side: "top",
+						children: pageSizes.map((size) => /* @__PURE__ */ jsx(SelectItem, {
+							value: String(size),
+							children: size
+						}, size))
+					})]
 				})]
 			})]
 		}), /* @__PURE__ */ jsxs("div", {
-			className: "flex items-center gap-2",
+			className: "flex items-center gap-1",
 			children: [
-				mode === "client" && pagination.pageIndex !== void 0 && pagination.pageCount !== void 0 && /* @__PURE__ */ jsxs("span", {
-					className: "text-sm text-muted-foreground",
+				/* @__PURE__ */ jsx(Button, {
+					variant: "outline",
+					size: "icon",
+					className: "size-8",
+					onClick: prevPage,
+					disabled: !canPrevPage,
+					children: /* @__PURE__ */ jsx(ChevronLeft, { className: "size-4" })
+				}),
+				isClientMode && pageCount > 1 ? pageNumbers.map((page, index) => {
+					if (page === "...") return /* @__PURE__ */ jsx("span", {
+						className: "px-2 text-sm text-muted-foreground",
+						children: "..."
+					}, `ellipsis-${index}`);
+					const isActive = page === pageIndex + 1;
+					return /* @__PURE__ */ jsx(Button, {
+						variant: isActive ? "default" : "outline",
+						size: "sm",
+						className: cn("h-8 min-w-8 px-2", isActive && "font-semibold"),
+						onClick: () => setPageIndex(page - 1),
+						disabled: isActive,
+						children: page
+					}, page);
+				}) : !isClientMode && /* @__PURE__ */ jsxs("span", {
+					className: "px-2 text-sm text-muted-foreground",
 					children: [
 						"Page",
 						" ",
-						pagination.pageIndex + 1,
-						" ",
-						"of",
-						" ",
-						pagination.pageCount
+						pageIndex + 1
 					]
 				}),
 				/* @__PURE__ */ jsx(Button, {
 					variant: "outline",
-					size: "sm",
-					onClick: pagination.prevPage,
-					disabled: !pagination.canPrevPage,
-					children: /* @__PURE__ */ jsx(ChevronLeft, { className: "size-4" })
-				}),
-				/* @__PURE__ */ jsx(Button, {
-					variant: "outline",
-					size: "sm",
-					onClick: pagination.nextPage,
-					disabled: !pagination.canNextPage,
+					size: "icon",
+					className: "size-8",
+					onClick: nextPage,
+					disabled: !canNextPage,
 					children: /* @__PURE__ */ jsx(ChevronRight, { className: "size-4" })
 				})
 			]
@@ -421,7 +919,7 @@ function DataTableRowActions({ row, actions, isLoading = false, className }) {
 //#endregion
 //#region src/components/features/data-table/components/search.tsx
 function DataTableSearch({ placeholder = "Search...", debounceMs = DEFAULT_DEBOUNCE_MS, className }) {
-	const { search, setSearch } = useDataTableContext();
+	const { search, setSearch } = useDataTableSearch();
 	const [inputValue, setInputValue] = useState(search);
 	useEffect(() => {
 		setInputValue(search);
@@ -446,225 +944,32 @@ function DataTableSearch({ placeholder = "Search...", debounceMs = DEFAULT_DEBOU
 	});
 }
 
-//#endregion
-//#region src/components/features/data-table/hooks/use-inline-contents.ts
-function useInlineContents() {
-	const [inlineContents, setInlineContents] = useState([]);
-	return {
-		inlineContents,
-		registerInlineContent: useCallback((entry) => {
-			setInlineContents((prev) => {
-				const index = prev.findIndex((e) => e.id === entry.id);
-				if (index >= 0) {
-					const next = [...prev];
-					next[index] = entry;
-					return next;
-				}
-				return [...prev, entry];
-			});
-		}, []),
-		unregisterInlineContent: useCallback((id) => {
-			setInlineContents((prev) => prev.filter((e) => e.id !== id));
-		}, [])
-	};
-}
-
 //#endregion
 //#region src/components/features/data-table/core/client-provider.tsx
-function ClientProvider({ data, columns, sorting, setSorting, filters, setFilter, clearFilter, clearAllFilters, search, setSearch, clearSearch, searchableColumns, searchFn, rowSelection, setRowSelection, pagination, getRowId, enableRowSelection = false, className, children }) {
-	const columnFilters = useMemo(() => Object.entries(filters).map(([id, value]) => ({
-		id,
-		value
-	})), [filters]);
-	const arrayIncludesFilter = useMemo(() => (row, columnId, filterValue) => {
-		if (filterValue == null) return true;
-		if (Array.isArray(filterValue) && filterValue.length === 0) return true;
-		const cellValue = row.getValue(columnId);
-		if (Array.isArray(filterValue)) {
-			if (Array.isArray(cellValue)) return cellValue.some((v) => filterValue.includes(v));
-			return filterValue.includes(cellValue);
-		}
-		if (typeof filterValue === "string" && typeof cellValue === "string") return cellValue.toLowerCase().includes(filterValue.toLowerCase());
-		return cellValue === filterValue;
-	}, []);
-	const globalFilterFn = useMemo(() => {
-		if (searchFn) return (row, _columnId, filterValue) => searchFn(row.original, String(filterValue));
-		if (searchableColumns && searchableColumns.length > 0) return (row, _columnId, filterValue) => {
-			const query = String(filterValue).toLowerCase();
-			return searchableColumns.some((col) => {
-				const cellValue = row.getValue(col);
-				return cellValue != null && String(cellValue).toLowerCase().includes(query);
-			});
-		};
-	}, [searchFn, searchableColumns]);
-	const table = useReactTable({
-		data,
-		columns,
-		state: {
-			sorting,
-			rowSelection,
-			globalFilter: search,
-			columnFilters,
-			pagination: {
-				pageIndex: pagination.pageIndex,
-				pageSize: pagination.pageSize
-			}
-		},
-		filterFns: { arrayIncludes: arrayIncludesFilter },
-		defaultColumn: { filterFn: arrayIncludesFilter },
-		...globalFilterFn ? { globalFilterFn } : {},
-		onSortingChange: (updater) => {
-			setSorting(typeof updater === "function" ? updater(sorting) : updater);
-		},
-		onRowSelectionChange: (updater) => {
-			setRowSelection(typeof updater === "function" ? updater(rowSelection) : updater);
-		},
-		onPaginationChange: (updater) => {
-			const next = typeof updater === "function" ? updater({
-				pageIndex: pagination.pageIndex,
-				pageSize: pagination.pageSize
-			}) : updater;
-			pagination.setPageIndex(next.pageIndex);
-			pagination.setPageSize(next.pageSize);
-		},
-		getCoreRowModel: getCoreRowModel(),
-		getSortedRowModel: getSortedRowModel(),
-		getFilteredRowModel: getFilteredRowModel(),
-		getPaginationRowModel: getPaginationRowModel(),
-		getRowId,
-		enableRowSelection: !!enableRowSelection
-	});
-	const { inlineContents, registerInlineContent, unregisterInlineContent } = useInlineContents();
-	const paginationState = useMemo(() => ({
-		canNextPage: table.getCanNextPage(),
-		canPrevPage: table.getCanPreviousPage(),
-		nextPage: () => table.nextPage(),
-		prevPage: () => table.previousPage(),
-		pageIndex: pagination.pageIndex,
-		pageCount: table.getPageCount(),
-		setPageIndex: pagination.setPageIndex,
-		pageSize: pagination.pageSize,
-		setPageSize: pagination.setPageSize
-	}), [table, pagination]);
-	return /* @__PURE__ */ jsx(DataTableContext, {
-		value: useMemo(() => ({
-			table,
-			mode: "client",
-			sorting,
-			filters,
-			search,
-			rowSelection,
-			isLoading: false,
-			setSorting,
-			setFilter,
-			clearFilter,
-			clearAllFilters,
-			setSearch,
-			clearSearch,
-			setRowSelection,
-			pagination: paginationState,
-			inlineContents,
-			registerInlineContent,
-			unregisterInlineContent
-		}), [
-			table,
-			sorting,
-			filters,
-			search,
-			rowSelection,
-			setSorting,
-			setFilter,
-			clearFilter,
-			clearAllFilters,
-			setSearch,
-			clearSearch,
-			setRowSelection,
-			paginationState,
-			inlineContents,
-			registerInlineContent,
-			unregisterInlineContent
-		]),
-		children: /* @__PURE__ */ jsx("div", {
-			className,
-			children
+function ClientProvider({ store, table, className, children }) {
+	return /* @__PURE__ */ jsx(DataTableStoreContext, {
+		value: store,
+		children: /* @__PURE__ */ jsx(TableInstanceContext, {
+			value: table,
+			children: /* @__PURE__ */ jsx("div", {
+				className,
+				children
+			})
 		})
 	});
 }
 
 //#endregion
 //#region src/components/features/data-table/core/server-provider.tsx
-function ServerProvider({ data, columns, isLoading, sorting, setSorting, filters, setFilter, clearFilter, clearAllFilters, search, setSearch, clearSearch, rowSelection, setRowSelection, pagination, getRowId, enableRowSelection = false, className, children }) {
-	const table = useReactTable({
-		data,
-		columns,
-		state: {
-			sorting,
-			rowSelection
-		},
-		onSortingChange: (updater) => {
-			setSorting(typeof updater === "function" ? updater(sorting) : updater);
-		},
-		onRowSelectionChange: (updater) => {
-			setRowSelection(typeof updater === "function" ? updater(rowSelection) : updater);
-		},
-		getCoreRowModel: getCoreRowModel(),
-		getRowId,
-		enableRowSelection: !!enableRowSelection,
-		manualPagination: true,
-		manualSorting: true,
-		manualFiltering: true
-	});
-	const { inlineContents, registerInlineContent, unregisterInlineContent } = useInlineContents();
-	const paginationState = useMemo(() => ({
-		canNextPage: pagination.hasNextPage,
-		canPrevPage: pagination.hasPrevPage,
-		nextPage: pagination.nextPage,
-		prevPage: pagination.prevPage,
-		pageSize: pagination.limit,
-		setPageSize: pagination.setLimit
-	}), [pagination]);
-	return /* @__PURE__ */ jsx(DataTableContext, {
-		value: useMemo(() => ({
-			table,
-			mode: "server",
-			sorting,
-			filters,
-			search,
-			rowSelection,
-			isLoading,
-			setSorting,
-			setFilter,
-			clearFilter,
-			clearAllFilters,
-			setSearch,
-			clearSearch,
-			setRowSelection,
-			pagination: paginationState,
-			inlineContents,
-			registerInlineContent,
-			unregisterInlineContent
-		}), [
-			table,
-			sorting,
-			filters,
-			search,
-			rowSelection,
-			isLoading,
-			setSorting,
-			setFilter,
-			clearFilter,
-			clearAllFilters,
-			setSearch,
-			clearSearch,
-			setRowSelection,
-			paginationState,
-			inlineContents,
-			registerInlineContent,
-			unregisterInlineContent
-		]),
-		children: /* @__PURE__ */ jsx("div", {
-			className,
-			children
+function ServerProvider({ store, table, className, children }) {
+	return /* @__PURE__ */ jsx(DataTableStoreContext, {
+		value: store,
+		children: /* @__PURE__ */ jsx(TableInstanceContext, {
+			value: table,
+			children: /* @__PURE__ */ jsx("div", {
+				className,
+				children
+			})
 		})
 	});
 }
@@ -696,8 +1001,16 @@ function Badge({ className, variant, ...props }) {
 //#region src/components/features/data-table/filters/checkbox-filter.tsx
 const MAX_VISIBLE_BADGES = 2;
 function CheckboxFilter({ column, label, options, className, checkboxPopoverClassName }) {
-	const { filters, setFilter, clearFilter } = useDataTableContext();
+	const { filters, setFilter, clearFilter, registerFilter, unregisterFilter } = useDataTableFilters();
 	const [open, setOpen] = useState(false);
+	useEffect(() => {
+		registerFilter(column, "checkbox");
+		return () => unregisterFilter(column);
+	}, [
+		column,
+		registerFilter,
+		unregisterFilter
+	]);
 	const selectedValues = filters[column] ?? [];
 	const updateValues = (newValues) => {
 		if (newValues.length > 0) setFilter(column, newValues);
@@ -797,8 +1110,16 @@ function CheckboxFilter({ column, label, options, className, checkboxPopoverClas
 //#endregion
 //#region src/components/features/data-table/filters/date-picker-filter.tsx
 function DatePickerFilter({ column, label, className, datePickerPopoverClassName, disableFuture, disablePast, minDate, maxDate }) {
-	const { filters, setFilter, clearFilter } = useDataTableContext();
+	const { filters, setFilter, clearFilter, registerFilter, unregisterFilter } = useDataTableFilters();
 	const rawValue = filters[column];
+	useEffect(() => {
+		registerFilter(column, "date-gte");
+		return () => unregisterFilter(column);
+	}, [
+		column,
+		registerFilter,
+		unregisterFilter
+	]);
 	const dateRange = useMemo(() => {
 		const date = rawValue ? new Date(rawValue) : void 0;
 		return {
@@ -831,9 +1152,17 @@ function DatePickerFilter({ column, label, className, datePickerPopoverClassName
 //#endregion
 //#region src/components/features/data-table/filters/select-filter.tsx
 function SelectFilter({ column, label, options, placeholder, searchable = true, className, selectPopoverClassName }) {
-	const { filters, setFilter, clearFilter } = useDataTableContext();
+	const { filters, setFilter, clearFilter, registerFilter, unregisterFilter } = useDataTableFilters();
 	const [open, setOpen] = useState(false);
 	const value = filters[column];
+	useEffect(() => {
+		registerFilter(column, "select");
+		return () => unregisterFilter(column);
+	}, [
+		column,
+		registerFilter,
+		unregisterFilter
+	]);
 	const selectedOption = options.find((o) => o.value === value);
 	return /* @__PURE__ */ jsxs(Popover, {
 		open,
@@ -908,255 +1237,241 @@ const DataTable = {
 //#endregion
 //#region src/components/features/data-table/hooks/use-data-table-client.ts
 function useDataTableClient(options) {
-	const { data, columns, pageSize: initialPageSize = DEFAULT_PAGE_SIZE, getRowId, enableRowSelection = false, defaultSort = [], defaultFilters = {}, searchableColumns, searchFn, stateAdapter } = options;
-	const adapterState = useMemo(() => stateAdapter?.read() ?? {}, []);
-	const [sorting, setSorting] = useState(adapterState.sorting ?? defaultSort);
-	const [filters, setFilters] = useState(adapterState.filters ?? defaultFilters);
-	const [search, setSearch] = useState(adapterState.search ?? "");
-	const [rowSelection, setRowSelection] = useState({});
-	const [pageIndex, setPageIndex] = useState(adapterState.pageIndex ?? 0);
-	const [pageSize, setPageSize] = useState(adapterState.pageSize ?? initialPageSize);
-	const setFilter = useCallback((key, value) => {
-		setFilters((prev) => ({
-			...prev,
-			[key]: value
-		}));
-	}, []);
-	const clearFilter = useCallback((key) => {
-		setFilters((prev) => {
-			const { [key]: _, ...rest } = prev;
-			return rest;
-		});
-	}, []);
-	const clearAllFilters = useCallback(() => {
-		setFilters({});
-	}, []);
-	const clearSearch = useCallback(() => {
-		setSearch("");
-	}, []);
+	const { data, columns, pageSize, getRowId, enableRowSelection = false, defaultSort, defaultFilters, searchableColumns, searchFn, filterFns, stateAdapter } = options;
+	const store = useMemo(() => createDataTableStore({
+		data,
+		mode: "client",
+		defaultSort,
+		defaultFilters,
+		pageSize,
+		searchableColumns,
+		searchFn,
+		filterFns
+	}), []);
+	const isInitialRender = useRef(true);
 	useEffect(() => {
-		setRowSelection({});
-	}, [
-		sorting,
-		filters,
-		search,
-		pageIndex,
-		pageSize
-	]);
+		if (isInitialRender.current) {
+			isInitialRender.current = false;
+			return;
+		}
+		store.setData(data);
+	}, [data, store]);
+	const resolvedColumns = useMemo(() => enableRowSelection ? withSelectionColumn(columns, typeof enableRowSelection === "object" ? enableRowSelection : {}) : columns, [columns, enableRowSelection]);
+	const { filteredData, sorting, rowSelection, pageIndex, pageSize: storePageSize, filters, search } = useSyncExternalStore(store.subscribe, store.getSnapshot);
+	const table = useReactTable({
+		data: filteredData,
+		columns: resolvedColumns,
+		state: {
+			sorting,
+			rowSelection,
+			pagination: {
+				pageIndex,
+				pageSize: storePageSize
+			}
+		},
+		onSortingChange: (updater) => {
+			const next = typeof updater === "function" ? updater(sorting) : updater;
+			store.setSorting(next);
+		},
+		onRowSelectionChange: (updater) => {
+			const next = typeof updater === "function" ? updater(rowSelection) : updater;
+			store.setRowSelection(next);
+		},
+		onPaginationChange: (updater) => {
+			const next = typeof updater === "function" ? updater({
+				pageIndex,
+				pageSize: storePageSize
+			}) : updater;
+			store.setPageIndex(next.pageIndex);
+			store.setPageSize(next.pageSize);
+		},
+		getCoreRowModel: getCoreRowModel(),
+		getSortedRowModel: getSortedRowModel(),
+		getPaginationRowModel: getPaginationRowModel(),
+		getRowId,
+		enableRowSelection: !!enableRowSelection
+	});
+	const hydratedRef = useRef(false);
+	useEffect(() => {
+		if (stateAdapter && !hydratedRef.current) {
+			hydratedRef.current = true;
+			const persisted = stateAdapter.read();
+			if (persisted.sorting && persisted.sorting.length > 0) store.setSorting(persisted.sorting);
+			if (persisted.filters) {
+				for (const [key, value] of Object.entries(persisted.filters)) if (value != null) store.setFilter(key, value);
+			}
+			if (persisted.search) store.setSearch(persisted.search);
+			if (persisted.pageIndex != null && persisted.pageIndex > 0) store.setPageIndex(persisted.pageIndex);
+			if (persisted.pageSize != null) store.setPageSize(persisted.pageSize);
+		}
+	}, []);
+	const isFirstWrite = useRef(true);
 	useEffect(() => {
-		stateAdapter?.write({
+		if (!stateAdapter) return;
+		if (isFirstWrite.current) {
+			isFirstWrite.current = false;
+			return;
+		}
+		stateAdapter.write({
 			sorting,
 			filters,
 			search,
 			pageIndex,
-			pageSize
+			pageSize: storePageSize
 		});
 	}, [
-		stateAdapter,
 		sorting,
 		filters,
 		search,
 		pageIndex,
-		pageSize
+		storePageSize,
+		stateAdapter
 	]);
-	const pagination = useMemo(() => ({
-		pageIndex,
-		pageSize,
-		setPageIndex,
-		setPageSize
-	}), [pageIndex, pageSize]);
-	const selectionEnabled = !!enableRowSelection;
-	const selectionOptions = typeof enableRowSelection === "object" ? enableRowSelection : void 0;
 	return {
-		data,
-		columns: useMemo(() => selectionEnabled ? withSelectionColumn(columns, selectionOptions) : columns, [
-			selectionEnabled,
-			columns,
-			selectionOptions
-		]),
-		sorting,
-		setSorting,
-		filters,
-		setFilter,
-		clearFilter,
-		clearAllFilters,
-		search,
-		setSearch,
-		clearSearch,
-		rowSelection,
-		setRowSelection,
-		pagination,
-		getRowId,
-		enableRowSelection: selectionEnabled,
-		searchableColumns,
-		searchFn
+		store,
+		table
 	};
 }
 
 //#endregion
 //#region src/components/features/data-table/hooks/use-data-table-server.ts
 function useDataTableServer(options) {
-	const { columns, fetchFn, transform, limit: initialLimit = DEFAULT_PAGE_SIZE, getRowId, enableRowSelection = false, defaultSort = [], defaultFilters = {}, stateAdapter } = options;
-	const adapterState = useMemo(() => stateAdapter?.read() ?? {}, []);
-	const [data, setData] = useState([]);
-	const [isLoading, setIsLoading] = useState(true);
-	const [sorting, setSorting] = useState(adapterState.sorting ?? defaultSort);
-	const [filters, setFilters] = useState(adapterState.filters ?? defaultFilters);
-	const [search, setSearch] = useState(adapterState.search ?? "");
-	const [rowSelection, setRowSelection] = useState({});
-	const [limit, setLimit] = useState(adapterState.limit ?? initialLimit);
-	const [cursor, setCursor] = useState(void 0);
-	const [nextCursor, setNextCursor] = useState(void 0);
-	const [hasNextPage, setHasNextPage] = useState(false);
-	const [cursorHistory, setCursorHistory] = useState([]);
-	const fetchFnRef = useRef(fetchFn);
-	fetchFnRef.current = fetchFn;
+	const { columns, fetchFn, transform, limit = 20, getRowId, enableRowSelection = false, defaultSort, defaultFilters, stateAdapter } = options;
+	const fetchRef = useRef(fetchFn);
 	const transformRef = useRef(transform);
-	transformRef.current = transform;
-	const setFilter = useCallback((key, value) => {
-		setFilters((prev) => ({
-			...prev,
-			[key]: value
-		}));
-	}, []);
-	const clearFilter = useCallback((key) => {
-		setFilters((prev) => {
-			const { [key]: _, ...rest } = prev;
-			return rest;
-		});
-	}, []);
-	const clearAllFilters = useCallback(() => {
-		setFilters({});
-	}, []);
-	const clearSearch = useCallback(() => {
-		setSearch("");
-	}, []);
-	const resetPagination = useCallback(() => {
-		setCursor(void 0);
-		setNextCursor(void 0);
-		setCursorHistory([]);
-		setHasNextPage(false);
-		setRowSelection({});
-	}, []);
 	useEffect(() => {
-		resetPagination();
-	}, [
-		sorting,
-		filters,
-		search,
-		limit,
-		resetPagination
-	]);
+		fetchRef.current = fetchFn;
+	}, [fetchFn]);
+	useEffect(() => {
+		transformRef.current = transform;
+	}, [transform]);
+	const cursorMapRef = useRef(/* @__PURE__ */ new Map());
+	const [hasNextPage, setHasNextPage] = useState(false);
+	const store = useMemo(() => createDataTableStore({
+		data: [],
+		mode: "server",
+		defaultSort,
+		defaultFilters,
+		pageSize: limit
+	}), []);
+	const { sorting, filters, search, rowSelection, pageSize, pageIndex } = useSyncExternalStore(store.subscribe, store.getSnapshot);
 	useEffect(() => {
 		let cancelled = false;
-		setIsLoading(true);
-		fetchFnRef.current({
-			cursor,
-			limit,
+		store.setLoading(true);
+		const cursor = cursorMapRef.current.get(pageIndex);
+		fetchRef.current({
 			sorting,
 			filters,
-			search
+			search,
+			cursor,
+			limit: pageSize
 		}).then((response) => {
 			if (cancelled) return;
 			const result = transformRef.current(response);
-			setData(result.data);
-			setNextCursor(result.cursor);
+			store.setServerData(result.data);
+			store.setError(null);
+			if (result.nextCursor) cursorMapRef.current.set(pageIndex + 1, result.nextCursor);
 			setHasNextPage(result.hasNextPage);
-		}).catch(() => {
+		}).catch((error) => {
 			if (cancelled) return;
-			setData([]);
-			setNextCursor(void 0);
+			store.setServerData([]);
+			store.setError(error instanceof Error ? error : new Error(String(error)));
 			setHasNextPage(false);
 		}).finally(() => {
-			if (!cancelled) setIsLoading(false);
+			if (!cancelled) store.setLoading(false);
 		});
 		return () => {
 			cancelled = true;
 		};
 	}, [
-		cursor,
-		limit,
 		sorting,
 		filters,
-		search
+		search,
+		pageSize,
+		pageIndex,
+		store
 	]);
+	const prevQueryRef = useRef({
+		sorting,
+		filters,
+		search,
+		pageSize
+	});
 	useEffect(() => {
-		stateAdapter?.write({
+		const prev = prevQueryRef.current;
+		if (prev.sorting !== sorting || prev.filters !== filters || prev.search !== search || prev.pageSize !== pageSize) {
+			cursorMapRef.current = /* @__PURE__ */ new Map();
+			store.setPageIndex(0);
+			setHasNextPage(false);
+		}
+		prevQueryRef.current = {
 			sorting,
 			filters,
 			search,
-			limit
-		});
+			pageSize
+		};
 	}, [
-		stateAdapter,
 		sorting,
 		filters,
 		search,
-		limit
+		pageSize,
+		store
 	]);
-	const hasPrevPage = cursorHistory.length > 0;
-	const nextPage = useCallback(() => {
-		if (nextCursor && hasNextPage) {
-			setCursorHistory((prev) => [...prev, cursor ?? ""]);
-			setCursor(nextCursor);
-			setRowSelection({});
+	const resolvedColumns = useMemo(() => enableRowSelection ? withSelectionColumn(columns, typeof enableRowSelection === "object" ? enableRowSelection : {}) : columns, [columns, enableRowSelection]);
+	const table = useReactTable({
+		data: store.getSnapshot().data,
+		columns: resolvedColumns,
+		state: {
+			sorting,
+			rowSelection,
+			pagination: {
+				pageIndex,
+				pageSize
+			}
+		},
+		manualPagination: true,
+		manualSorting: true,
+		manualFiltering: true,
+		pageCount: hasNextPage ? pageIndex + 2 : pageIndex + 1,
+		getCoreRowModel: getCoreRowModel(),
+		getRowId,
+		enableRowSelection: !!enableRowSelection,
+		onSortingChange: (updater) => {
+			const next = typeof updater === "function" ? updater(sorting) : updater;
+			store.setSorting(next);
+		},
+		onRowSelectionChange: (updater) => {
+			const next = typeof updater === "function" ? updater(rowSelection) : updater;
+			store.setRowSelection(next);
+		},
+		onPaginationChange: (updater) => {
+			const next = typeof updater === "function" ? updater({
+				pageIndex,
+				pageSize
+			}) : updater;
+			if (next.pageIndex !== pageIndex) store.setPageIndex(next.pageIndex);
+			if (next.pageSize !== pageSize) store.setPageSize(next.pageSize);
 		}
-	}, [
-		nextCursor,
-		hasNextPage,
-		cursor
-	]);
-	const prevPage = useCallback(() => {
-		setCursorHistory((prev) => {
-			const newHistory = [...prev];
-			const previousCursor = newHistory.pop();
-			setCursor(previousCursor === "" ? void 0 : previousCursor);
-			return newHistory;
+	});
+	useEffect(() => {
+		if (stateAdapter) stateAdapter.write({
+			sorting,
+			filters,
+			search,
+			pageSize
 		});
-		setRowSelection({});
-	}, []);
-	const pagination = useMemo(() => ({
-		cursor,
-		limit,
-		hasNextPage,
-		hasPrevPage,
-		nextPage,
-		prevPage,
-		setLimit
-	}), [
-		cursor,
-		limit,
-		hasNextPage,
-		hasPrevPage,
-		nextPage,
-		prevPage
-	]);
-	const selectionEnabled = !!enableRowSelection;
-	const selectionOptions = typeof enableRowSelection === "object" ? enableRowSelection : void 0;
-	return {
-		data,
-		columns: useMemo(() => selectionEnabled ? withSelectionColumn(columns, selectionOptions) : columns, [
-			selectionEnabled,
-			columns,
-			selectionOptions
-		]),
-		isLoading,
+	}, [
 		sorting,
-		setSorting,
 		filters,
-		setFilter,
-		clearFilter,
-		clearAllFilters,
 		search,
-		setSearch,
-		clearSearch,
-		rowSelection,
-		setRowSelection,
-		pagination,
-		getRowId,
-		enableRowSelection: selectionEnabled
+		pageSize,
+		stateAdapter
+	]);
+	return {
+		store,
+		table
 	};
 }
 
 //#endregion
-export { DEFAULT_DEBOUNCE_MS, DEFAULT_LOADING_ROWS, DEFAULT_PAGE_SIZE, DEFAULT_PAGE_SIZES, DataTable, createSelectionColumn, useDataTableClient, useDataTableContext, useDataTableServer, useNuqsAdapter };
+export { DEFAULT_DEBOUNCE_MS, DEFAULT_LOADING_ROWS, DEFAULT_PAGE_SIZE, DEFAULT_PAGE_SIZES, DataTable, createDataTableStore, createSelectionColumn, useDataTableClient, useDataTableContext, useDataTableFilters, useDataTableInlineContents, useDataTableLoading, useDataTablePagination, useDataTableRows, useDataTableSearch, useDataTableSelection, useDataTableServer, useDataTableSorting, useNuqsAdapter };