@maanlamp/react-web-ui 0.0.0-stage → 0.1.1

package/dist/data-table/data-table.js

@@ -0,0 +1,309 @@
+import SvgChevronLeft from "../vendor/@material-design-icons/svg/outlined/chevron_left.js";
+import SvgChevronRight from "../vendor/@material-design-icons/svg/outlined/chevron_right.js";
+import { Button } from "../components/button/button.js";
+import { Select } from "../components/select-field/select.js";
+import { DataTableContent } from "./data-table-content.js";
+import { DataTableContext, useDataTable } from "./data-table-context.js";
+import { DataTableSelectionBar } from "./data-table-selection.js";
+import { PAGE_SIZE_OPTIONS } from "./table-features.js";
+import data_table_module_default from "./data-table.module.js";
+import { c } from "react/compiler-runtime";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { clsx } from "clsx";
+// src/data-table/data-table.tsx
+var Root = (t0) => {
+	const $ = c(14);
+	const { table, selection, status, isFetching: t1, onRetry, children, className } = t0;
+	const isFetching = t1 === void 0 ? false : t1;
+	let t2;
+	if ($[0] !== isFetching || $[1] !== onRetry || $[2] !== selection || $[3] !== status || $[4] !== table) {
+		t2 = {
+			table,
+			selection,
+			status,
+			isFetching,
+			onRetry
+		};
+		$[0] = isFetching;
+		$[1] = onRetry;
+		$[2] = selection;
+		$[3] = status;
+		$[4] = table;
+		$[5] = t2;
+	} else t2 = $[5];
+	let t3;
+	if ($[6] !== className) {
+		t3 = clsx(data_table_module_default.root, className);
+		$[6] = className;
+		$[7] = t3;
+	} else t3 = $[7];
+	let t4;
+	if ($[8] !== children || $[9] !== t3) {
+		t4 = /* @__PURE__ */ jsx("div", {
+			className: t3,
+			children
+		});
+		$[8] = children;
+		$[9] = t3;
+		$[10] = t4;
+	} else t4 = $[10];
+	let t5;
+	if ($[11] !== t2 || $[12] !== t4) {
+		t5 = /* @__PURE__ */ jsx(DataTableContext, {
+			value: t2,
+			children: t4
+		});
+		$[11] = t2;
+		$[12] = t4;
+		$[13] = t5;
+	} else t5 = $[13];
+	return t5;
+};
+/** Layout slot above the table for search, filters and actions. */
+var Toolbar = (t0) => {
+	const $ = c(5);
+	const { children, className } = t0;
+	let t1;
+	if ($[0] !== className) {
+		t1 = clsx(data_table_module_default.toolbar, className);
+		$[0] = className;
+		$[1] = t1;
+	} else t1 = $[1];
+	let t2;
+	if ($[2] !== children || $[3] !== t1) {
+		t2 = /* @__PURE__ */ jsx("div", {
+			className: t1,
+			children
+		});
+		$[2] = children;
+		$[3] = t1;
+		$[4] = t2;
+	} else t2 = $[4];
+	return t2;
+};
+/**
+* Prev/next + page-size controls driven by the instance's pagination API
+* (built with `manualPagination` + server `rowCount`). The page sizes come
+* from the table's `meta.pageSizeOptions`, and picking one returns to the
+* first page.
+*/
+var Pagination = (t0) => {
+	const $ = c(47);
+	const { pageSizeLabel, pageStatusLabel, previousPageLabel, nextPageLabel, className } = t0;
+	const { table } = useDataTable();
+	const { pageIndex, pageSize } = table.state.pagination;
+	let t1;
+	if ($[0] !== table) {
+		t1 = table.getPageCount();
+		$[0] = table;
+		$[1] = t1;
+	} else t1 = $[1];
+	const pageCount = Math.max(t1, 1);
+	const t2 = table.options.meta?.pageSizeOptions ?? PAGE_SIZE_OPTIONS;
+	let t3;
+	if ($[2] !== t2) {
+		t3 = t2.map(_temp);
+		$[2] = t2;
+		$[3] = t3;
+	} else t3 = $[3];
+	const sizeOptions = t3;
+	let t4;
+	if ($[4] !== className) {
+		t4 = clsx(data_table_module_default.pagination, className);
+		$[4] = className;
+		$[5] = t4;
+	} else t4 = $[5];
+	const t5 = String(pageSize);
+	let t6;
+	if ($[6] !== table) {
+		t6 = (next) => {
+			table.setPagination({
+				pageIndex: 0,
+				pageSize: Number(next)
+			});
+		};
+		$[6] = table;
+		$[7] = t6;
+	} else t6 = $[7];
+	let t7;
+	if ($[8] !== pageSizeLabel) {
+		t7 = /* @__PURE__ */ jsx(Select.Label, { children: pageSizeLabel });
+		$[8] = pageSizeLabel;
+		$[9] = t7;
+	} else t7 = $[9];
+	let t8;
+	if ($[10] === Symbol.for("react.memo_cache_sentinel")) {
+		t8 = /* @__PURE__ */ jsx(Select.Trigger, { className: data_table_module_default.pageSizeSelect });
+		$[10] = t8;
+	} else t8 = $[10];
+	let t9;
+	if ($[11] === Symbol.for("react.memo_cache_sentinel")) {
+		t9 = /* @__PURE__ */ jsx(Select.Portal, { children: /* @__PURE__ */ jsx(Select.Positioner, { children: /* @__PURE__ */ jsx(Select.Popup, { children: /* @__PURE__ */ jsx(Select.List, { children: /* @__PURE__ */ jsx(Select.Items, {}) }) }) }) });
+		$[11] = t9;
+	} else t9 = $[11];
+	let t10;
+	if ($[12] !== t7) {
+		t10 = /* @__PURE__ */ jsxs("div", {
+			className: data_table_module_default.pageSize,
+			children: [
+				t7,
+				t8,
+				t9
+			]
+		});
+		$[12] = t7;
+		$[13] = t10;
+	} else t10 = $[13];
+	let t11;
+	if ($[14] !== sizeOptions || $[15] !== t10 || $[16] !== t5 || $[17] !== t6) {
+		t11 = /* @__PURE__ */ jsx(Select.Root, {
+			options: sizeOptions,
+			value: t5,
+			onValueChange: t6,
+			children: t10
+		});
+		$[14] = sizeOptions;
+		$[15] = t10;
+		$[16] = t5;
+		$[17] = t6;
+		$[18] = t11;
+	} else t11 = $[18];
+	const t12 = pageIndex + 1;
+	let t13;
+	if ($[19] !== pageCount || $[20] !== pageStatusLabel || $[21] !== t12) {
+		t13 = pageStatusLabel(t12, pageCount);
+		$[19] = pageCount;
+		$[20] = pageStatusLabel;
+		$[21] = t12;
+		$[22] = t13;
+	} else t13 = $[22];
+	let t14;
+	if ($[23] !== t13) {
+		t14 = /* @__PURE__ */ jsx("span", {
+			className: data_table_module_default.pageStatus,
+			"aria-live": "polite",
+			children: t13
+		});
+		$[23] = t13;
+		$[24] = t14;
+	} else t14 = $[24];
+	let t15;
+	if ($[25] !== table) {
+		t15 = table.getCanPreviousPage();
+		$[25] = table;
+		$[26] = t15;
+	} else t15 = $[26];
+	const t16 = !t15;
+	let t17;
+	if ($[27] !== table) {
+		t17 = () => {
+			table.previousPage();
+		};
+		$[27] = table;
+		$[28] = t17;
+	} else t17 = $[28];
+	let t18;
+	if ($[29] !== previousPageLabel || $[30] !== t16 || $[31] !== t17) {
+		t18 = /* @__PURE__ */ jsx(Button, {
+			variant: "tertiary",
+			iconOnly: true,
+			icon: SvgChevronLeft,
+			label: previousPageLabel,
+			disabled: t16,
+			onClick: t17
+		});
+		$[29] = previousPageLabel;
+		$[30] = t16;
+		$[31] = t17;
+		$[32] = t18;
+	} else t18 = $[32];
+	let t19;
+	if ($[33] !== table) {
+		t19 = table.getCanNextPage();
+		$[33] = table;
+		$[34] = t19;
+	} else t19 = $[34];
+	const t20 = !t19;
+	let t21;
+	if ($[35] !== table) {
+		t21 = () => {
+			table.nextPage();
+		};
+		$[35] = table;
+		$[36] = t21;
+	} else t21 = $[36];
+	let t22;
+	if ($[37] !== nextPageLabel || $[38] !== t20 || $[39] !== t21) {
+		t22 = /* @__PURE__ */ jsx(Button, {
+			variant: "tertiary",
+			iconOnly: true,
+			icon: SvgChevronRight,
+			label: nextPageLabel,
+			disabled: t20,
+			onClick: t21
+		});
+		$[37] = nextPageLabel;
+		$[38] = t20;
+		$[39] = t21;
+		$[40] = t22;
+	} else t22 = $[40];
+	let t23;
+	if ($[41] !== t11 || $[42] !== t14 || $[43] !== t18 || $[44] !== t22 || $[45] !== t4) {
+		t23 = /* @__PURE__ */ jsxs("div", {
+			className: t4,
+			children: [
+				t11,
+				t14,
+				t18,
+				t22
+			]
+		});
+		$[41] = t11;
+		$[42] = t14;
+		$[43] = t18;
+		$[44] = t22;
+		$[45] = t4;
+		$[46] = t23;
+	} else t23 = $[46];
+	return t23;
+};
+/**
+* Composite data table over a TanStack Table instance. `Root` holds the
+* instance and the injected query state in context; the parts lay it out:
+* `Toolbar`, `SelectionBar`, `Content` and `Pagination`. A nested sub-table
+* gets its own `DataTable.Root`, with its own instance and context.
+*
+* @example
+* <DataTable.Root table={table} status={query.status} isFetching={query.isFetching}>
+* 	<DataTable.Toolbar>
+* 		<FilterBar.Root filters={filters}>…</FilterBar.Root>
+* 	</DataTable.Toolbar>
+* 	<DataTable.Content
+* 		emptyState="No declarations yet."
+* 		errorState="The declarations could not be loaded."
+* 		loadingState="Loading declarations"
+* 		slowLabel="This is taking longer than usual."
+* 		retryLabel="Try again"
+* 	/>
+* 	<DataTable.Pagination
+* 		pageSizeLabel="Rows per page"
+* 		pageStatusLabel={(page, count) => `Page ${page} of ${count}`}
+* 		previousPageLabel="Previous page"
+* 		nextPageLabel="Next page"
+* 	/>
+* </DataTable.Root>
+*/
+var DataTable = {
+	Root,
+	Toolbar,
+	Content: DataTableContent,
+	Pagination,
+	SelectionBar: DataTableSelectionBar
+};
+function _temp(size) {
+	return {
+		value: String(size),
+		label: String(size)
+	};
+}
+export { DataTable };

package/dist/data-table/data-table.module.js

@@ -0,0 +1,74 @@
+import './data-table.css';// src/data-table/data-table.module.scss
+var root = "_root_1322g_3";
+var toolbar = "_toolbar_1322g_77";
+var scrollFrame = "_scrollFrame_1322g_84";
+var stale = "_stale_1322g_92";
+var staleOverlay = "_staleOverlay_1322g_98";
+var contentWrap = "_contentWrap_1322g_101";
+var th = "_th_1322g_132";
+var edgeStart = "_edgeStart_1322g_1";
+var edgeEnd = "_edgeEnd_1322g_1";
+var refreshFailed = "_refreshFailed_1322g_165";
+var table = "_table_1322g_177";
+var thead = "_thead_1322g_185";
+var sortToggle = "_sortToggle_1322g_200";
+var sortIconIdle = "_sortIconIdle_1322g_251";
+var td = "_td_1322g_255";
+var row = "_row_1322g_280";
+var subRow = "_subRow_1322g_302";
+var skeletonBar = "_skeletonBar_1322g_311";
+var busyCaption = "_busyCaption_1322g_314";
+var stateCell = "_stateCell_1322g_322";
+var errorState = "_errorState_1322g_327";
+var pagination = "_pagination_1322g_330";
+var pageSize = "_pageSize_1322g_338";
+var pageSizeSelect = "_pageSizeSelect_1322g_343";
+var selectionContainer = "_selectionContainer_1322g_346";
+var selectionBar = "_selectionBar_1322g_350";
+var selectionSummary = "_selectionSummary_1322g_420";
+var selectionTotal = "_selectionTotal_1322g_435";
+var selectionCount = "_selectionCount_1322g_436";
+var selectionMeasure = "_selectionMeasure_1322g_437";
+var selectionStatus = "_selectionStatus_1322g_469";
+var selectionActions = "_selectionActions_1322g_477";
+var selectionSelectAll = "_selectionSelectAll_1322g_507";
+var selectionBulk = "_selectionBulk_1322g_510";
+var pageStatus = "_pageStatus_1322g_527";
+var data_table_module_default = {
+	root,
+	toolbar,
+	scrollFrame,
+	stale,
+	staleOverlay,
+	contentWrap,
+	th,
+	edgeStart,
+	edgeEnd,
+	refreshFailed,
+	table,
+	thead,
+	sortToggle,
+	sortIconIdle,
+	td,
+	row,
+	subRow,
+	skeletonBar,
+	busyCaption,
+	stateCell,
+	errorState,
+	pagination,
+	pageSize,
+	pageSizeSelect,
+	selectionContainer,
+	selectionBar,
+	selectionSummary,
+	selectionTotal,
+	selectionCount,
+	selectionMeasure,
+	selectionStatus,
+	selectionActions,
+	selectionSelectAll,
+	selectionBulk,
+	pageStatus
+};
+export { busyCaption, contentWrap, data_table_module_default as default, edgeEnd, edgeStart, errorState, pageSize, pageSizeSelect, pageStatus, pagination, refreshFailed, root, row, scrollFrame, selectionActions, selectionBar, selectionBulk, selectionContainer, selectionCount, selectionMeasure, selectionSelectAll, selectionStatus, selectionSummary, selectionTotal, skeletonBar, sortIconIdle, sortToggle, stale, staleOverlay, stateCell, subRow, table, td, th, thead, toolbar };

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

@@ -0,0 +1,7 @@
+export * from "./data-table.tsx";
+export type { DataTableContentProps } from "./data-table-content.tsx";
+export { type DataTableState, useDataTable, } from "./data-table-context.tsx";
+export { type DataTableSelectionBarProps, type SelectionColumnOptions, selectionColumn, } from "./data-table-selection.tsx";
+export type { QueryStatus } from "./resolve-view.ts";
+export * from "./table-features.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/data-table/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/data-table/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,YAAY,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AACtE,OAAO,EACN,KAAK,cAAc,EACnB,YAAY,GACZ,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACN,KAAK,0BAA0B,EAC/B,KAAK,sBAAsB,EAC3B,eAAe,GACf,MAAM,4BAA4B,CAAC;AACpC,YAAY,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,cAAc,qBAAqB,CAAC"}

package/dist/data-table/index.js

@@ -0,0 +1,5 @@
+import { DataTable } from "./data-table.js";
+import { useDataTable } from "./data-table-context.js";
+import { selectionColumn } from "./data-table-selection.js";
+import { EMPTY_ROWS, PAGE_SIZE_OPTIONS, dataTableFeatures } from "./table-features.js";
+export { DataTable, EMPTY_ROWS, PAGE_SIZE_OPTIONS, dataTableFeatures, selectionColumn, useDataTable };

package/dist/data-table/resolve-view.d.ts

@@ -0,0 +1,32 @@
+/** The lifecycle status of the injected query, mirroring TanStack Query. */
+export type QueryStatus = "pending" | "error" | "success";
+/** Which body state `DataTable.Content` should render. */
+export type TableView = "loading" | "error" | "empty" | "ready";
+export type ResolvedView = Readonly<{
+    view: TableView;
+    /**
+     * True when rendered rows are from a previous successful fetch while a
+     * background refetch is in flight. Drives the subtle "stale" affordance.
+     */
+    stale: boolean;
+    /**
+     * True when the fetch failed but earlier rows are still on screen, so the
+     * failure is reported alongside them instead of replacing the body.
+     */
+    refreshFailed: boolean;
+}>;
+/**
+ * Maps an injected query state to the single body view `DataTable.Content`
+ * renders. Rows never unmount once they are on screen: a failure with rows
+ * still present stays on the `"ready"` body and reports `refreshFailed`.
+ *
+ * @example
+ * resolveView({ status: "success", isFetching: true, hasRows: true });
+ * // => { view: "ready", stale: true, refreshFailed: false }
+ */
+export declare const resolveView: ({ status, isFetching, hasRows, }: Readonly<{
+    status: QueryStatus;
+    isFetching: boolean;
+    hasRows: boolean;
+}>) => ResolvedView;
+//# sourceMappingURL=resolve-view.d.ts.map

package/dist/data-table/resolve-view.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-view.d.ts","sourceRoot":"","sources":["../../src/data-table/resolve-view.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAC5E,MAAM,MAAM,WAAW,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,CAAC;AAE1D,0DAA0D;AAC1D,MAAM,MAAM,SAAS,GAClB,SAAS,GACT,OAAO,GACP,OAAO,GACP,OAAO,CAAC;AAEX,MAAM,MAAM,YAAY,GAAG,QAAQ,CAAC;IACnC,IAAI,EAAE,SAAS,CAAC;IAChB;;;OAGG;IACH,KAAK,EAAE,OAAO,CAAC;IACf;;;OAGG;IACH,aAAa,EAAE,OAAO,CAAC;CACvB,CAAC,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,WAAW,qCAIrB,QAAQ,CAAC;IACX,MAAM,EAAE,WAAW,CAAC;IACpB,UAAU,EAAE,OAAO,CAAC;IACpB,OAAO,EAAE,OAAO,CAAC;CACjB,CAAC,KAAG,YA6BJ,CAAC"}

package/dist/data-table/resolve-view.js

@@ -0,0 +1,37 @@
+// src/data-table/resolve-view.ts
+/**
+* Maps an injected query state to the single body view `DataTable.Content`
+* renders. Rows never unmount once they are on screen: a failure with rows
+* still present stays on the `"ready"` body and reports `refreshFailed`.
+*
+* @example
+* resolveView({ status: "success", isFetching: true, hasRows: true });
+* // => { view: "ready", stale: true, refreshFailed: false }
+*/
+var resolveView = ({ status, isFetching, hasRows }) => {
+	if (status === "error") return hasRows ? {
+		view: "ready",
+		stale: false,
+		refreshFailed: true
+	} : {
+		view: "error",
+		stale: false,
+		refreshFailed: false
+	};
+	if (status === "pending") return {
+		view: "loading",
+		stale: false,
+		refreshFailed: false
+	};
+	if (!hasRows) return {
+		view: "empty",
+		stale: false,
+		refreshFailed: false
+	};
+	return {
+		view: "ready",
+		stale: isFetching,
+		refreshFailed: false
+	};
+};
+export { resolveView };

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

@@ -0,0 +1,70 @@
+import { rowExpandingFeature, rowPaginationFeature, rowSelectionFeature, rowSortingFeature } from "@tanstack/react-table";
+import type { ReactNode } from "react";
+/** Per-column options a `DataTable` reads from a column definition's `meta`. */
+export type DataTableColumnMeta = Readonly<{
+    /**
+     * Collapse the column to its content width rather than letting it take a
+     * share of the free space. For icon-button and control columns.
+     */
+    fit?: boolean;
+    /**
+     * This column holds quantities — amounts, counts, measures — and is
+     * end-aligned, with its unit named in the header. Not for codes or dates.
+     */
+    numeric?: boolean;
+    /**
+     * Pin this column to an edge of the scroll container, so it stays put while
+     * the rest of the table scrolls sideways. At most two per edge, and each
+     * edge's columns must be adjacent and sit at that edge of the column list.
+     */
+    sticky?: "start" | "end";
+    /**
+     * What this column draws in a placeholder row while the first page loads.
+     * Every other column falls back to a skeleton bar.
+     */
+    placeholderCell?: () => ReactNode;
+}>;
+/** The page sizes a table offers, as a list that is never empty. */
+export type PageSizeOptions = readonly [
+    number,
+    ...number[]
+];
+/**
+ * The page sizes a table offers when it names none of its own.
+ *
+ * @example
+ * pageSizeOptions: PAGE_SIZE_OPTIONS, // 10, 25, 50, 100
+ */
+export declare const PAGE_SIZE_OPTIONS: PageSizeOptions;
+/** Per-table options a `DataTable` reads from a table's `meta`. */
+export type DataTableMeta = Readonly<{
+    /** The page sizes the pagination control offers. */
+    pageSizeOptions?: PageSizeOptions;
+}>;
+/** The TanStack Table features a `DataTable` instance registers. */
+export type DataTableFeatures = Readonly<{
+    rowSortingFeature: typeof rowSortingFeature;
+    rowPaginationFeature: typeof rowPaginationFeature;
+    rowExpandingFeature: typeof rowExpandingFeature;
+    rowSelectionFeature: typeof rowSelectionFeature;
+    tableMeta: DataTableMeta;
+    columnMeta: DataTableColumnMeta;
+}>;
+/**
+ * The feature set a `DataTable` instance registers. No row-model slots:
+ * sorting and pagination are server-owned and expansion drives the table's
+ * own sub-row rendering.
+ *
+ * @example
+ * const table = useTable<DataTableFeatures, Row>({ features: dataTableFeatures, columns, data });
+ */
+export declare const dataTableFeatures: DataTableFeatures;
+/**
+ * A frozen empty rows array. Pass it as the `data` default when building the
+ * table instance, so an undefined query result never mints a new array.
+ *
+ * @example
+ * data: query.data?.items ?? EMPTY_ROWS,
+ */
+export declare const EMPTY_ROWS: never[];
+//# sourceMappingURL=table-features.d.ts.map

package/dist/data-table/table-features.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table-features.d.ts","sourceRoot":"","sources":["../../src/data-table/table-features.ts"],"names":[],"mappings":"AAAA,OAAO,EAEN,mBAAmB,EACnB,oBAAoB,EACpB,mBAAmB,EACnB,iBAAiB,EAEjB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAEvC,gFAAgF;AAChF,MAAM,MAAM,mBAAmB,GAAG,QAAQ,CAAC;IAC1C;;;OAGG;IACH,GAAG,CAAC,EAAE,OAAO,CAAC;IACd;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;;OAIG;IACH,MAAM,CAAC,EAAE,OAAO,GAAG,KAAK,CAAC;IACzB;;;OAGG;IACH,eAAe,CAAC,EAAE,MAAM,SAAS,CAAC;CAClC,CAAC,CAAC;AAEH,oEAAoE;AACpE,MAAM,MAAM,eAAe,GAAG,SAAS;IACtC,MAAM;IACN,GAAG,MAAM,EAAE;CACX,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,EAAE,eAE/B,CAAC;AAEF,mEAAmE;AACnE,MAAM,MAAM,aAAa,GAAG,QAAQ,CAAC;IACpC,oDAAoD;IACpD,eAAe,CAAC,EAAE,eAAe,CAAC;CAClC,CAAC,CAAC;AAEH,oEAAoE;AACpE,MAAM,MAAM,iBAAiB,GAAG,QAAQ,CAAC;IACxC,iBAAiB,EAAE,OAAO,iBAAiB,CAAC;IAC5C,oBAAoB,EAAE,OAAO,oBAAoB,CAAC;IAClD,mBAAmB,EAAE,OAAO,mBAAmB,CAAC;IAChD,mBAAmB,EAAE,OAAO,mBAAmB,CAAC;IAChD,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,mBAAmB,CAAC;CAChC,CAAC,CAAC;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,EAAE,iBAQ7B,CAAC;AAKJ;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,EAAE,KAAK,EAAc,CAAC"}

package/dist/data-table/table-features.js

@@ -0,0 +1,41 @@
+import { metaHelper, rowExpandingFeature, rowPaginationFeature, rowSelectionFeature, rowSortingFeature, tableFeatures } from "@tanstack/react-table";
+// src/data-table/table-features.ts
+/**
+* The page sizes a table offers when it names none of its own.
+*
+* @example
+* pageSizeOptions: PAGE_SIZE_OPTIONS, // 10, 25, 50, 100
+*/
+var PAGE_SIZE_OPTIONS = [
+	10,
+	25,
+	50,
+	100
+];
+/**
+* The feature set a `DataTable` instance registers. No row-model slots:
+* sorting and pagination are server-owned and expansion drives the table's
+* own sub-row rendering.
+*
+* @example
+* const table = useTable<DataTableFeatures, Row>({ features: dataTableFeatures, columns, data });
+*/
+var dataTableFeatures = tableFeatures({
+	rowSortingFeature,
+	rowPaginationFeature,
+	rowExpandingFeature,
+	rowSelectionFeature,
+	tableMeta: metaHelper(),
+	columnMeta: metaHelper()
+});
+var emptyRows = [];
+Object.freeze(emptyRows);
+/**
+* A frozen empty rows array. Pass it as the `data` default when building the
+* table instance, so an undefined query result never mints a new array.
+*
+* @example
+* data: query.data?.items ?? EMPTY_ROWS,
+*/
+var EMPTY_ROWS = emptyRows;
+export { EMPTY_ROWS, PAGE_SIZE_OPTIONS, dataTableFeatures };

package/dist/data-table/use-sticky-offsets.d.ts

@@ -0,0 +1,22 @@
+import { type RefObject } from "react";
+/**
+ * Publishes the measured geometry of a table's pinned columns as custom
+ * properties on the element the returned ref is attached to: one
+ * `--table-sticky-inset-{n}` per column pinned to the start and one
+ * `--table-sticky-end-{n}` per column pinned to the end, each holding
+ * everything between it and its edge, plus `--table-sticky-total` and
+ * `--table-sticky-end-total` for each group as a whole, and
+ * `--table-scrollbar-block` / `--table-scrollbar-inline` for the space the
+ * scroller's own scrollbars take. Widths are measured off the header cells of
+ * the frame's own table and re-measured on resize.
+ *
+ * @param pinnedColumnKey - The pinned column ids joined into one string; a
+ * changed pinned set re-runs the measurement.
+ * @returns Ref for the non-scrolling frame around the table.
+ *
+ * @example
+ * const frameRef = useStickyOffsets(pinnedIds.join(","));
+ * // <div ref={frameRef}> … <td style={{ insetInlineStart: "var(--table-sticky-inset-0)" }} />
+ */
+export declare const useStickyOffsets: (pinnedColumnKey: string) => RefObject<HTMLDivElement | null>;
+//# sourceMappingURL=use-sticky-offsets.d.ts.map

package/dist/data-table/use-sticky-offsets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-sticky-offsets.d.ts","sourceRoot":"","sources":["../../src/data-table/use-sticky-offsets.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,KAAK,SAAS,EAGd,MAAM,OAAO,CAAC;AAUf;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,gBAAgB,oBACX,MAAM,KACrB,SAAS,CAAC,cAAc,GAAG,IAAI,CAkGjC,CAAC"}