@hexclave/dashboard-ui-components 1.0.0

package/dist/esm/components/data-grid/state.js

@@ -0,0 +1,187 @@
+import { DEFAULT_COL_WIDTH, clampColumnWidth } from "./data-grid-sizing.js";
+import { stringCompare } from "@hexclave/shared/dist/utils/strings";
+
+//#region src/components/data-grid/state.ts
+/**
+* Build the initial `DataGridState` for a set of columns. Pass this as the
+* lazy initializer to `useState` — never hand-assemble the state object.
+*
+* ```tsx
+* const [gridState, setGridState] = React.useState(() =>
+*   createDefaultDataGridState(columns)
+* );
+* ```
+*/
+function createDefaultDataGridState(columns) {
+	const columnWidths = {};
+	const columnOrder = [];
+	for (const col of columns) {
+		columnWidths[col.id] = clampColumnWidth(col, col.width ?? DEFAULT_COL_WIDTH);
+		columnOrder.push(col.id);
+	}
+	return {
+		sorting: [],
+		columnVisibility: {},
+		columnWidths,
+		columnPinning: {
+			left: [],
+			right: []
+		},
+		columnOrder,
+		pagination: {
+			pageIndex: 0,
+			pageSize: 50
+		},
+		selection: {
+			selectedIds: /* @__PURE__ */ new Set(),
+			anchorId: null
+		},
+		dateDisplay: "relative",
+		quickSearch: ""
+	};
+}
+function resolveColumnValue(col, row) {
+	if (typeof col.accessor === "function") return col.accessor(row);
+	return row[col.accessor ?? col.id];
+}
+function defaultComparator(a, b) {
+	if (a == null && b == null) return 0;
+	if (a == null) return -1;
+	if (b == null) return 1;
+	if (typeof a === "number" && typeof b === "number") return a - b;
+	if (a instanceof Date && b instanceof Date) return a.getTime() - b.getTime();
+	return stringCompare(String(a), String(b));
+}
+function buildRowComparator(sortModel, columns) {
+	if (sortModel.length === 0) return null;
+	const colMap = new Map(columns.map((c) => [c.id, c]));
+	return (a, b) => {
+		for (const { columnId, direction } of sortModel) {
+			const col = colMap.get(columnId);
+			if (!col) continue;
+			const va = resolveColumnValue(col, a);
+			const vb = resolveColumnValue(col, b);
+			const cmp = col.sortComparator ? col.sortComparator(va, vb) : defaultComparator(va, vb);
+			if (cmp !== 0) return direction === "asc" ? cmp : -cmp;
+		}
+		return 0;
+	};
+}
+function paginateRows(rows, pagination) {
+	const start = pagination.pageIndex * pagination.pageSize;
+	return rows.slice(start, start + pagination.pageSize);
+}
+/** Default row matcher: case-insensitive substring across every column. */
+function defaultMatchRow(row, query, columns) {
+	for (const col of columns) {
+		const v = resolveColumnValue(col, row);
+		if (v == null) continue;
+		if (String(v).toLowerCase().includes(query)) return true;
+	}
+	return false;
+}
+function applyQuickSearch(rows, query, columns, matchRow = defaultMatchRow) {
+	const trimmed = query.trim().toLowerCase();
+	if (!trimmed) return rows;
+	return rows.filter((r) => matchRow(r, trimmed, columns));
+}
+function defaultParseDate(value) {
+	if (value == null) return null;
+	if (value instanceof Date) return isNaN(value.getTime()) ? null : value;
+	if (typeof value === "number" || typeof value === "string") {
+		const d = new Date(value);
+		return isNaN(d.getTime()) ? null : d;
+	}
+	return null;
+}
+const DIVISIONS = [
+	{
+		amount: 60,
+		unit: "second"
+	},
+	{
+		amount: 60,
+		unit: "minute"
+	},
+	{
+		amount: 24,
+		unit: "hour"
+	},
+	{
+		amount: 7,
+		unit: "day"
+	},
+	{
+		amount: 4.34524,
+		unit: "week"
+	},
+	{
+		amount: 12,
+		unit: "month"
+	},
+	{
+		amount: Number.POSITIVE_INFINITY,
+		unit: "year"
+	}
+];
+const relativeTimeFormatterCache = /* @__PURE__ */ new Map();
+function getRelativeTimeFormatter(locale) {
+	const key = locale ?? "__default__";
+	let cached = relativeTimeFormatterCache.get(key);
+	if (cached == null) {
+		cached = new Intl.RelativeTimeFormat(locale, { numeric: "auto" });
+		relativeTimeFormatterCache.set(key, cached);
+	}
+	return cached;
+}
+function defaultFormatRelative(date) {
+	const rtf = getRelativeTimeFormatter();
+	let duration = (date.getTime() - Date.now()) / 1e3;
+	for (const div of DIVISIONS) {
+		if (Math.abs(duration) < div.amount) return rtf.format(Math.round(duration), div.unit);
+		duration /= div.amount;
+	}
+	return rtf.format(Math.round(duration), "year");
+}
+function defaultFormatAbsolute(date) {
+	return date.toLocaleString();
+}
+function formatGridDate(value, mode, opts) {
+	const date = (opts?.parseValue ?? defaultParseDate)(value);
+	if (!date) return {
+		display: null,
+		tooltip: null
+	};
+	const relative = opts?.dateFormat?.relative ?? defaultFormatRelative;
+	const tooltip = (opts?.dateFormat?.absolute ?? defaultFormatAbsolute)(date);
+	return {
+		display: mode === "relative" ? relative(date) : tooltip,
+		tooltip
+	};
+}
+function exportToCsv(rows, columns, filename) {
+	const header = columns.map((col) => typeof col.header === "string" ? col.header : col.id);
+	const csvRows = rows.map((row) => columns.map((col) => {
+		const val = resolveColumnValue(col, row);
+		const formatted = col.formatValue ? String(col.formatValue(val, row) ?? "") : String(val ?? "");
+		if (formatted.includes(",") || formatted.includes("\"") || formatted.includes("\n")) return `"${formatted.replace(/"/g, "\"\"")}"`;
+		return formatted;
+	}));
+	const csvContent = "" + [header.join(","), ...csvRows.map((row) => row.join(","))].join("\n");
+	const blob = new Blob([csvContent], { type: "text/csv;charset=utf-8;" });
+	const url = URL.createObjectURL(blob);
+	const link = document.createElement("a");
+	link.href = url;
+	link.download = `${filename}.csv`;
+	document.body.appendChild(link);
+	try {
+		link.click();
+	} finally {
+		link.remove();
+		URL.revokeObjectURL(url);
+	}
+}
+
+//#endregion
+export { applyQuickSearch, buildRowComparator, createDefaultDataGridState, defaultFormatAbsolute, defaultFormatRelative, defaultMatchRow, defaultParseDate, exportToCsv, formatGridDate, paginateRows, resolveColumnValue };
+//# sourceMappingURL=state.js.map

package/dist/esm/components/data-grid/state.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.js","names":[],"sources":["../../../../src/components/data-grid/state.ts"],"sourcesContent":["import { stringCompare } from \"@stackframe/stack-shared/dist/utils/strings\";\nimport { clampColumnWidth, DEFAULT_COL_WIDTH } from \"./data-grid-sizing\";\nimport type {\n  DataGridColumnDef,\n  DataGridDateDisplay,\n  DataGridDateFormat,\n  DataGridPaginationModel,\n  DataGridSortModel,\n  DataGridState,\n} from \"./types\";\n\n/**\n * Build the initial `DataGridState` for a set of columns. Pass this as the\n * lazy initializer to `useState` — never hand-assemble the state object.\n *\n * ```tsx\n * const [gridState, setGridState] = React.useState(() =>\n *   createDefaultDataGridState(columns)\n * );\n * ```\n */\nexport function createDefaultDataGridState(\n  columns: readonly DataGridColumnDef<any>[],\n): DataGridState {\n  const columnWidths: Record<string, number> = {};\n  const columnOrder: string[] = [];\n\n  for (const col of columns) {\n    columnWidths[col.id] = clampColumnWidth(col, col.width ?? DEFAULT_COL_WIDTH);\n    columnOrder.push(col.id);\n  }\n\n  return {\n    sorting: [],\n    columnVisibility: {},\n    columnWidths,\n    columnPinning: { left: [], right: [] },\n    columnOrder,\n    pagination: { pageIndex: 0, pageSize: 50 },\n    selection: { selectedIds: new Set(), anchorId: null },\n    dateDisplay: \"relative\",\n    quickSearch: \"\",\n  };\n}\n\n// ─── Column value resolution ─────────────────────────────────────────\n\nexport function resolveColumnValue<TRow>(\n  col: DataGridColumnDef<TRow>,\n  row: TRow,\n): unknown {\n  if (typeof col.accessor === \"function\") return col.accessor(row);\n  const key = (col.accessor ?? col.id) as keyof TRow;\n  return row[key];\n}\n\n// ─── Default sort comparator (used by client-mode useDataSource) ────\n\nfunction defaultComparator(a: unknown, b: unknown): number {\n  if (a == null && b == null) return 0;\n  if (a == null) return -1;\n  if (b == null) return 1;\n  if (typeof a === \"number\" && typeof b === \"number\") return a - b;\n  if (a instanceof Date && b instanceof Date) return a.getTime() - b.getTime();\n  return stringCompare(String(a), String(b));\n}\n\nexport function buildRowComparator<TRow>(\n  sortModel: DataGridSortModel,\n  columns: readonly DataGridColumnDef<TRow>[],\n): ((a: TRow, b: TRow) => number) | null {\n  if (sortModel.length === 0) return null;\n  const colMap = new Map(columns.map((c) => [c.id, c]));\n  return (a, b) => {\n    for (const { columnId, direction } of sortModel) {\n      const col = colMap.get(columnId);\n      if (!col) continue;\n      const va = resolveColumnValue(col, a);\n      const vb = resolveColumnValue(col, b);\n      const cmp = col.sortComparator ? col.sortComparator(va, vb) : defaultComparator(va, vb);\n      if (cmp !== 0) return direction === \"asc\" ? cmp : -cmp;\n    }\n    return 0;\n  };\n}\n\n// ─── Pagination ──────────────────────────────────────────────────────\n\nexport function paginateRows<TRow>(\n  rows: readonly TRow[],\n  pagination: DataGridPaginationModel,\n): TRow[] {\n  const start = pagination.pageIndex * pagination.pageSize;\n  return rows.slice(start, start + pagination.pageSize) as TRow[];\n}\n\n// ─── Quick search ────────────────────────────────────────────────────\n\n/** Default row matcher: case-insensitive substring across every column. */\nexport function defaultMatchRow<TRow>(\n  row: TRow,\n  query: string,\n  columns: readonly DataGridColumnDef<TRow>[],\n): boolean {\n  for (const col of columns) {\n    const v = resolveColumnValue(col, row);\n    if (v == null) continue;\n    if (String(v).toLowerCase().includes(query)) return true;\n  }\n  return false;\n}\n\nexport function applyQuickSearch<TRow>(\n  rows: readonly TRow[],\n  query: string,\n  columns: readonly DataGridColumnDef<TRow>[],\n  matchRow: (\n    row: TRow,\n    query: string,\n    columns: readonly DataGridColumnDef<TRow>[],\n  ) => boolean = defaultMatchRow,\n): readonly TRow[] {\n  const trimmed = query.trim().toLowerCase();\n  if (!trimmed) return rows;\n  return rows.filter((r) => matchRow(r, trimmed, columns));\n}\n\n// ─── Date helpers ────────────────────────────────────────────────────\n\nexport function defaultParseDate(value: unknown): Date | null {\n  if (value == null) return null;\n  if (value instanceof Date) return isNaN(value.getTime()) ? null : value;\n  if (typeof value === \"number\" || typeof value === \"string\") {\n    const d = new Date(value);\n    return isNaN(d.getTime()) ? null : d;\n  }\n  return null;\n}\n\nconst DIVISIONS: Array<{ amount: number; unit: Intl.RelativeTimeFormatUnit }> = [\n  { amount: 60, unit: \"second\" },\n  { amount: 60, unit: \"minute\" },\n  { amount: 24, unit: \"hour\" },\n  { amount: 7, unit: \"day\" },\n  { amount: 4.34524, unit: \"week\" },\n  { amount: 12, unit: \"month\" },\n  { amount: Number.POSITIVE_INFINITY, unit: \"year\" },\n];\n\nconst relativeTimeFormatterCache = new Map<string, Intl.RelativeTimeFormat>();\nfunction getRelativeTimeFormatter(locale?: string): Intl.RelativeTimeFormat {\n  const key = locale ?? \"__default__\";\n  let cached = relativeTimeFormatterCache.get(key);\n  if (cached == null) {\n    cached = new Intl.RelativeTimeFormat(locale, { numeric: \"auto\" });\n    relativeTimeFormatterCache.set(key, cached);\n  }\n  return cached;\n}\n\nexport function defaultFormatRelative(date: Date): string {\n  const rtf = getRelativeTimeFormatter();\n  // Wall-clock comparison to \"now\" (e.g. \"5 minutes ago\"). performance.now()\n  // would be wrong here — it's a monotonic timer, not a wall-clock instant.\n  let duration = (date.getTime() - Date.now()) / 1000;\n  for (const div of DIVISIONS) {\n    if (Math.abs(duration) < div.amount) return rtf.format(Math.round(duration), div.unit);\n    duration /= div.amount;\n  }\n  return rtf.format(Math.round(duration), \"year\");\n}\n\nexport function defaultFormatAbsolute(date: Date): string {\n  return date.toLocaleString();\n}\n\nexport function formatGridDate(\n  value: unknown,\n  mode: DataGridDateDisplay,\n  opts?: {\n    parseValue?: (value: unknown) => Date | null;\n    dateFormat?: DataGridDateFormat;\n  },\n): { display: string | null; tooltip: string | null } {\n  const parse = opts?.parseValue ?? defaultParseDate;\n  const date = parse(value);\n  if (!date) return { display: null, tooltip: null };\n  const relative = opts?.dateFormat?.relative ?? defaultFormatRelative;\n  const absolute = opts?.dateFormat?.absolute ?? defaultFormatAbsolute;\n  const tooltip = absolute(date);\n  const display = mode === \"relative\" ? relative(date) : tooltip;\n  return { display, tooltip };\n}\n\n// ─── CSV Export ──────────────────────────────────────────────────────\n\nexport function exportToCsv<TRow>(\n  rows: readonly TRow[],\n  columns: readonly DataGridColumnDef<TRow>[],\n  filename: string,\n): void {\n  const header = columns.map((col) =>\n    typeof col.header === \"string\" ? col.header : col.id,\n  );\n  const csvRows = rows.map((row) =>\n    columns.map((col) => {\n      const val = resolveColumnValue(col, row);\n      const formatted = col.formatValue\n        ? String((col.formatValue(val, row) as string | null | undefined) ?? \"\")\n        : String(val ?? \"\");\n      if (formatted.includes(\",\") || formatted.includes('\"') || formatted.includes(\"\\n\")) {\n        return `\"${formatted.replace(/\"/g, '\"\"')}\"`;\n      }\n      return formatted;\n    }),\n  );\n  // UTF-8 BOM so Excel opens the CSV as UTF-8.\n  const csvContent = \"\\uFEFF\" + [\n    header.join(\",\"),\n    ...csvRows.map((row) => row.join(\",\")),\n  ].join(\"\\n\");\n\n  const blob = new Blob([csvContent], { type: \"text/csv;charset=utf-8;\" });\n  const url = URL.createObjectURL(blob);\n  const link = document.createElement(\"a\");\n  link.href = url;\n  link.download = `${filename}.csv`;\n  document.body.appendChild(link);\n  try {\n    link.click();\n  } finally {\n    link.remove();\n    URL.revokeObjectURL(url);\n  }\n}\n"],"mappings":"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"}

package/dist/esm/components/data-grid/strings.d.ts

@@ -0,0 +1,8 @@
+import { DataGridStrings } from "./types";
+
+//#region src/components/data-grid/strings.d.ts
+declare const DATA_GRID_DEFAULT_STRINGS: DataGridStrings;
+declare function resolveDataGridStrings(override: Partial<DataGridStrings> | undefined): DataGridStrings;
+//#endregion
+export { DATA_GRID_DEFAULT_STRINGS, resolveDataGridStrings };
+//# sourceMappingURL=strings.d.ts.map

package/dist/esm/components/data-grid/strings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strings.d.ts","names":[],"sources":["../../../../src/components/data-grid/strings.ts"],"mappings":";;;cAEa,yBAAA,EAA2B,eAAA;AAAA,iBAqCxB,sBAAA,CACd,QAAA,EAAU,OAAA,CAAQ,eAAA,gBACjB,eAAA"}

package/dist/esm/components/data-grid/strings.js

@@ -0,0 +1,39 @@
+//#region src/components/data-grid/strings.ts
+const DATA_GRID_DEFAULT_STRINGS = {
+	searchPlaceholder: "Search…",
+	columns: "Columns",
+	export: "Export",
+	density: "Density",
+	showAll: "Show all",
+	hideAll: "Hide all",
+	resetColumns: "Reset",
+	dateFormat: "Date format",
+	dateFormatRelative: "Relative",
+	dateFormatAbsolute: "Absolute",
+	rowsSelected: (count) => `${count} row${count === 1 ? "" : "s"} selected`,
+	rowsPerPage: "Rows per page",
+	pageOf: (page, total) => `${page} of ${total}`,
+	noData: "No data",
+	loading: "Loading…",
+	loadingMore: "Loading more…",
+	exportCsv: "Export CSV",
+	exportCopied: "Copied!",
+	sortAsc: "Sort ascending",
+	sortDesc: "Sort descending",
+	unsort: "Remove sort",
+	pinLeft: "Pin left",
+	pinRight: "Pin right",
+	unpin: "Unpin",
+	hideColumn: "Hide column"
+};
+function resolveDataGridStrings(override) {
+	if (!override) return DATA_GRID_DEFAULT_STRINGS;
+	return {
+		...DATA_GRID_DEFAULT_STRINGS,
+		...override
+	};
+}
+
+//#endregion
+export { DATA_GRID_DEFAULT_STRINGS, resolveDataGridStrings };
+//# sourceMappingURL=strings.js.map

package/dist/esm/components/data-grid/strings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"strings.js","names":[],"sources":["../../../../src/components/data-grid/strings.ts"],"sourcesContent":["import type { DataGridStrings } from \"./types\";\n\nexport const DATA_GRID_DEFAULT_STRINGS: DataGridStrings = {\n  // toolbar\n  searchPlaceholder: \"Search\\u2026\",\n  columns: \"Columns\",\n  export: \"Export\",\n  density: \"Density\",\n  // column manager\n  showAll: \"Show all\",\n  hideAll: \"Hide all\",\n  resetColumns: \"Reset\",\n  // date display\n  dateFormat: \"Date format\",\n  dateFormatRelative: \"Relative\",\n  dateFormatAbsolute: \"Absolute\",\n  // selection\n  rowsSelected: (count) => `${count} row${count === 1 ? \"\" : \"s\"} selected`,\n  // pagination\n  rowsPerPage: \"Rows per page\",\n  pageOf: (page, total) => `${page} of ${total}`,\n  // empty / loading\n  noData: \"No data\",\n  loading: \"Loading\\u2026\",\n  loadingMore: \"Loading more\\u2026\",\n  // export\n  exportCsv: \"Export CSV\",\n  exportCopied: \"Copied!\",\n  // sort\n  sortAsc: \"Sort ascending\",\n  sortDesc: \"Sort descending\",\n  unsort: \"Remove sort\",\n  // misc\n  pinLeft: \"Pin left\",\n  pinRight: \"Pin right\",\n  unpin: \"Unpin\",\n  hideColumn: \"Hide column\",\n};\n\nexport function resolveDataGridStrings(\n  override: Partial<DataGridStrings> | undefined,\n): DataGridStrings {\n  if (!override) return DATA_GRID_DEFAULT_STRINGS;\n  return { ...DATA_GRID_DEFAULT_STRINGS, ...override };\n}\n"],"mappings":";AAEA,MAAa,4BAA6C;CAExD,mBAAmB;CACnB,SAAS;CACT,QAAQ;CACR,SAAS;CAET,SAAS;CACT,SAAS;CACT,cAAc;CAEd,YAAY;CACZ,oBAAoB;CACpB,oBAAoB;CAEpB,eAAe,UAAU,GAAG,MAAM,MAAM,UAAU,IAAI,KAAK,IAAI;CAE/D,aAAa;CACb,SAAS,MAAM,UAAU,GAAG,KAAK,MAAM;CAEvC,QAAQ;CACR,SAAS;CACT,aAAa;CAEb,WAAW;CACX,cAAc;CAEd,SAAS;CACT,UAAU;CACV,QAAQ;CAER,SAAS;CACT,UAAU;CACV,OAAO;CACP,YAAY;CACb;AAED,SAAgB,uBACd,UACiB;AACjB,KAAI,CAAC,SAAU,QAAO;AACtB,QAAO;EAAE,GAAG;EAA2B,GAAG;EAAU"}

package/dist/esm/components/data-grid/types.d.ts

@@ -0,0 +1,278 @@
+import { ReactNode } from "react";
+
+//#region src/components/data-grid/types.d.ts
+/** Every row must be uniquely identifiable. The grid resolves identity
+ * through the top-level `getRowId` prop. */
+type RowId = string;
+type DataGridColumnType = "string" | "number" | "date" | "dateTime" | "boolean" | "singleSelect" | "custom";
+type DataGridColumnAlign = "left" | "center" | "right";
+type DataGridColumnPin = "left" | "right" | false;
+/** How `date` / `dateTime` cells render their value. `"relative"` shows
+ * "1 day ago"–style text with the full datetime in a tooltip; `"absolute"`
+ * shows the full datetime inline. */
+type DataGridDateDisplay = "relative" | "absolute";
+/** Per-column overrides for how a `date` / `dateTime` cell is formatted.
+ * If either function is omitted the grid falls back to its default
+ * (Intl.RelativeTimeFormat + `toLocaleString()`). */
+type DataGridDateFormat = {
+  relative?: (date: Date) => string;
+  absolute?: (date: Date) => string;
+};
+/** Context passed to `renderCell`. */
+type DataGridCellContext<TRow> = {
+  row: TRow;
+  rowId: RowId;
+  rowIndex: number;
+  value: unknown;
+  columnId: string;
+  isSelected: boolean;
+  /** Current date display mode — consumers writing custom `renderCell`
+   * for `date` / `dateTime` columns should branch on this to match the
+   * grid's built-in behaviour. */
+  dateDisplay: DataGridDateDisplay;
+};
+/** Context passed to `renderHeader`. */
+type DataGridHeaderContext<TRow> = {
+  columnId: string;
+  columnDef: DataGridColumnDef<TRow>;
+  isSorted: false | "asc" | "desc";
+  sortIndex: number | null;
+};
+/** A single column's full configuration. Generic over the row type. */
+type DataGridColumnDef<TRow> = {
+  /** Unique identifier for this column. */id: string; /** Display label. If a function is given it receives the header context. */
+  header: string | ((ctx: DataGridHeaderContext<TRow>) => ReactNode);
+  /** Accessor — either a key of TRow or a function. If omitted, `id` is
+   * used as the key. */
+  accessor?: keyof TRow | ((row: TRow) => unknown); /** Custom cell renderer. Falls back to plain text of the resolved value. */
+  renderCell?: (ctx: DataGridCellContext<TRow>) => ReactNode; /** Initial width in pixels. Defaults to 150. */
+  width?: number; /** Minimum width during resize. Defaults to 50. */
+  minWidth?: number; /** Maximum width during resize. Defaults to 800. */
+  maxWidth?: number;
+  /** Flex grow factor. When set, remaining space is distributed among flex
+   * columns proportionally. */
+  flex?: number;
+  sortable?: boolean;
+  resizable?: boolean;
+  hideable?: boolean; /** Pin position. Defaults to `false` (unpinned). */
+  pin?: DataGridColumnPin;
+  align?: DataGridColumnAlign; /** Column type affects default sorting. */
+  type?: DataGridColumnType; /** For `singleSelect` type — available value options. */
+  valueOptions?: readonly DataGridSelectOption[];
+  /** How cell content handles overflow.
+   * - `"truncate"` (default): single-line with text-overflow ellipsis.
+   * - `"wrap"`: content wraps naturally. When combined with
+   *   `rowHeight="auto"` on the grid, the row grows to fit. With a
+   *   fixed `rowHeight`, wrapped content is clipped at the row boundary. */
+  cellOverflow?: "truncate" | "wrap";
+  /** Custom sort comparator. Receives two resolved cell values.
+   * Return negative if a < b, positive if a > b, 0 if equal. */
+  sortComparator?: (a: unknown, b: unknown) => number;
+  /** Format a cell value to a plain string — used for export and
+   * clipboard copy. Defaults to `String(value)`. */
+  formatValue?: (value: unknown, row: TRow) => string;
+  /** Parse a raw cell value into a `Date`. Only consulted when `type` is
+   * `"date"` or `"dateTime"`. Defaults to `new Date(value)` with graceful
+   * handling of `null` / `undefined` / invalid dates. Override for
+   * non-standard formats (e.g. ClickHouse's space-separated UTC strings). */
+  parseValue?: (value: unknown) => Date | null; /** Per-column override for the relative / absolute date formatters. */
+  dateFormat?: DataGridDateFormat; /** Fired when a cell in this column is clicked. */
+  onCellClick?: (ctx: DataGridCellContext<TRow>, event: React.MouseEvent) => void; /** Fired when a cell in this column is double-clicked. */
+  onCellDoubleClick?: (ctx: DataGridCellContext<TRow>, event: React.MouseEvent) => void;
+};
+type DataGridSelectOption = {
+  value: string;
+  label: string;
+};
+type DataGridSortItem = {
+  columnId: string;
+  direction: "asc" | "desc";
+};
+type DataGridSortModel = readonly DataGridSortItem[];
+type DataGridSelectionMode = "none" | "single" | "multiple";
+type DataGridSelectionModel = {
+  selectedIds: ReadonlySet<RowId>; /** Tracks the last-clicked row for shift-range selection. */
+  anchorId: RowId | null;
+};
+type DataGridColumnVisibility = Record<string, boolean>;
+type DataGridColumnPinning = {
+  left: readonly string[];
+  right: readonly string[];
+};
+/** UI display mode — "paginated" shows page controls, "infinite" shows scroll sentinel. */
+type DataGridPaginationMode = "paginated" | "infinite";
+/** Data-fetching strategy used by `useDataSource`. */
+type DataGridDataPaginationMode = "client" | "server" | "infinite";
+type DataGridPaginationModel = {
+  pageIndex: number;
+  pageSize: number;
+};
+type DataGridState = {
+  sorting: DataGridSortModel;
+  columnVisibility: DataGridColumnVisibility;
+  columnWidths: Record<string, number>;
+  columnPinning: DataGridColumnPinning;
+  columnOrder: readonly string[];
+  pagination: DataGridPaginationModel;
+  selection: DataGridSelectionModel;
+  /** How `date` / `dateTime` columns render. Defaults to `"relative"`
+   * via `createDefaultDataGridState`. Toggled from the Columns popover
+   * whenever the grid has at least one date column. */
+  dateDisplay: DataGridDateDisplay;
+  /** Current quick-search text. Written by the built-in search input in
+   * the toolbar. `useDataSource` in client mode auto-filters by this
+   * value (via `applyQuickSearch`); in async mode it's passed through
+   * to the generator as `params.quickSearch`, where the consumer owns
+   * the "how do I match?" decision (typically by modifying the backend
+   * query). Defaults to `""`. */
+  quickSearch: string;
+};
+/** Params sent to the async data source on each fetch. */
+type DataGridFetchParams = {
+  sorting: DataGridSortModel;
+  pagination: DataGridPaginationModel;
+  /** Current quick-search text. Passed through from `state.quickSearch`
+   * so the async generator can fold it into its query (e.g. a SQL WHERE
+   * clause). Empty string when the search box is empty. A change in
+   * this value triggers a refetch, same mechanism as sorting. */
+  quickSearch: string; /** For cursor-based: the last row of the previous page. */
+  cursor: unknown;
+};
+/** Return type from a data source fetch. */
+type DataGridFetchResult<TRow> = {
+  rows: TRow[]; /** Total row count if known. `-1` or `undefined` for unknown (infinite). */
+  totalRowCount?: number; /** Cursor for the next page (for cursor-based pagination). */
+  nextCursor?: unknown; /** If `false`, there are no more pages. */
+  hasMore?: boolean;
+};
+/** An async-generator data source yields pages of rows. The generator
+ * receives fetch params as its argument and yields pages. Yielding
+ * allows the grid to display partial results during loading. */
+type DataGridDataSource<TRow> = (params: DataGridFetchParams) => AsyncGenerator<DataGridFetchResult<TRow>, void, undefined>;
+type DataGridCallbacks<TRow> = {
+  onRowClick?: (row: TRow, rowId: RowId, event: React.MouseEvent) => void;
+  onRowDoubleClick?: (row: TRow, rowId: RowId, event: React.MouseEvent) => void;
+  onCellClick?: (row: TRow, columnId: string, value: unknown, event: React.MouseEvent) => void;
+  /**
+   * Fires when the selection set changes. **Page-scoped:** the header "select
+   * all" checkbox and `selectedRows` only cover the rows currently rendered
+   * (the visible page in paginated mode, or the loaded prefix in infinite
+   * mode). The grid does not load other pages to satisfy the selection — if
+   * you need cross-page selection, drive `selectedIds` from your own state
+   * and load all rows you care about up-front.
+   */
+  onSelectionChange?: (selectedIds: ReadonlySet<RowId>, selectedRows: TRow[]) => void;
+  onSortChange?: (model: DataGridSortModel) => void;
+  onColumnResize?: (columnId: string, width: number) => void;
+  onColumnVisibilityChange?: (model: DataGridColumnVisibility) => void;
+};
+type DataGridProps<TRow> = {
+  /** Column definitions. */columns: readonly DataGridColumnDef<TRow>[];
+  /** The rows to display. The consumer is responsible for sorting
+   *  and paginating before passing them in. */
+  rows: readonly TRow[]; /** Extract a unique identifier from each row. */
+  getRowId: (row: TRow) => RowId; /** Total row count across all pages (used for pagination UI). */
+  totalRowCount?: number; /** True while the initial data load is in progress (shows skeleton). */
+  isLoading?: boolean; /** True during a background refetch (shows subtle indicator, keeps rows). */
+  isRefetching?: boolean; /** Whether more rows can be loaded (shows infinite scroll sentinel). */
+  hasMore?: boolean; /** True while loading the next page of infinite scroll. */
+  isLoadingMore?: boolean; /** Called when the infinite scroll sentinel becomes visible. */
+  onLoadMore?: () => void;
+  state: DataGridState;
+  onChange: React.Dispatch<React.SetStateAction<DataGridState>>;
+  /** UI mode for pagination. "paginated" shows page controls in the
+   *  footer. "infinite" shows a scroll sentinel instead. Defaults to
+   *  "paginated". */
+  paginationMode?: "paginated" | "infinite"; /** Selection behaviour. Defaults to "none". */
+  selectionMode?: DataGridSelectionMode; /** Whether columns can be resized by dragging. Defaults to true. */
+  resizable?: boolean;
+  /** Row height in pixels, or `"auto"` for dynamic measurement.
+   *
+   * - **number** (default `44`): every row is exactly this tall.
+   *   Fast and predictable; content that overflows is clipped.
+   * - **`"auto"`**: each row is measured by the browser after render
+   *   and the virtualizer adjusts positions accordingly. Columns
+   *   with `cellOverflow: "wrap"` will push the row taller; columns
+   *   with `cellOverflow: "truncate"` (or the default) stay
+   *   single-line. Use `estimatedRowHeight` to reduce scroll-jank
+   *   when rows haven't been measured yet. */
+  rowHeight?: number | "auto";
+  /** Estimated row height used by the virtualizer when
+   *  `rowHeight="auto"`. Better estimates = less scroll-position
+   *  jank before rows are measured. Defaults to 44. Ignored when
+   *  `rowHeight` is a number. */
+  estimatedRowHeight?: number; /** Header row height in pixels. Defaults to 44. */
+  headerHeight?: number; /** Number of rows to render outside the visible area. Defaults to 5. */
+  overscan?: number; /** Grid max height. If omitted, grid takes available space (when `fillHeight`). */
+  maxHeight?: number | string;
+  /**
+   * When `true` (default), the grid uses `h-full` and the row area scrolls inside the grid.
+   * When `false`, the grid is only as tall as toolbar + header + rows (`h-auto`), so sibling
+   * content (e.g. metadata) sits directly under the table without a large empty gap.
+   */
+  fillHeight?: boolean; /** Top offset for the sticky toolbar + header (px or CSS string). */
+  stickyTop?: number | string;
+} & DataGridCallbacks<TRow> & {
+  /** Custom toolbar renderer. When `false`, toolbar is hidden entirely. */toolbar?: false | ((ctx: DataGridToolbarContext<TRow>) => ReactNode);
+  /** Extra content rendered inside the default toolbar row, to the left of
+   *  the built-in columns / export actions. Use this to slot in
+   *  refresh buttons, custom toggles, row counts, etc. without giving up
+   *  the built-in actions. Ignored if a custom `toolbar` render function
+   *  is provided — that function owns the entire row. */
+  toolbarExtra?: ReactNode | ((ctx: DataGridToolbarContext<TRow>) => ReactNode); /** Custom empty state. Defaults to a centered "No data" message. */
+  emptyState?: ReactNode; /** Custom loading state. Defaults to skeleton rows. */
+  loadingState?: ReactNode; /** Custom footer. When `false`, footer is hidden. */
+  footer?: false | ((ctx: DataGridFooterContext<TRow>) => ReactNode); /** Extra content rendered to the right of the default footer info. */
+  footerExtra?: ReactNode | ((ctx: DataGridFooterContext<TRow>) => ReactNode); /** Filename stem for CSV export (without extension). */
+  exportFilename?: string; /** i18n overrides. */
+  strings?: Partial<DataGridStrings>;
+  className?: string;
+};
+type DataGridToolbarContext<TRow> = {
+  state: DataGridState;
+  onChange: React.Dispatch<React.SetStateAction<DataGridState>>;
+  columns: readonly DataGridColumnDef<TRow>[];
+  visibleColumns: readonly DataGridColumnDef<TRow>[];
+  totalRowCount: number | undefined;
+  selectedRowCount: number;
+  strings: DataGridStrings; /** Trigger a CSV export. */
+  exportCsv: () => void;
+};
+type DataGridFooterContext<TRow> = {
+  state: DataGridState;
+  totalRowCount: number | undefined;
+  visibleRowCount: number;
+  selectedRowCount: number;
+  paginationMode: DataGridPaginationMode;
+  strings: DataGridStrings;
+};
+type DataGridStrings = {
+  searchPlaceholder: string;
+  columns: string;
+  export: string;
+  density: string;
+  showAll: string;
+  hideAll: string;
+  resetColumns: string;
+  dateFormat: string;
+  dateFormatRelative: string;
+  dateFormatAbsolute: string;
+  rowsSelected: (count: number) => string;
+  rowsPerPage: string;
+  pageOf: (page: number, total: number) => string;
+  noData: string;
+  loading: string;
+  loadingMore: string;
+  exportCsv: string;
+  exportCopied: string;
+  sortAsc: string;
+  sortDesc: string;
+  unsort: string;
+  pinLeft: string;
+  pinRight: string;
+  unpin: string;
+  hideColumn: string;
+};
+//#endregion
+export { DataGridCallbacks, DataGridCellContext, DataGridColumnAlign, DataGridColumnDef, DataGridColumnPin, DataGridColumnPinning, DataGridColumnType, DataGridColumnVisibility, DataGridDataPaginationMode, DataGridDataSource, DataGridDateDisplay, DataGridDateFormat, DataGridFetchParams, DataGridFetchResult, DataGridFooterContext, DataGridHeaderContext, DataGridPaginationMode, DataGridPaginationModel, DataGridProps, DataGridSelectOption, DataGridSelectionMode, DataGridSelectionModel, DataGridSortItem, DataGridSortModel, DataGridState, DataGridStrings, DataGridToolbarContext, RowId };
+//# sourceMappingURL=types.d.ts.map

package/dist/esm/components/data-grid/types.d.ts.map

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

package/dist/esm/components/data-grid/types.js

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

package/dist/esm/components/data-grid/use-data-source.d.ts

@@ -0,0 +1,85 @@
+import { DataGridColumnDef, DataGridDataPaginationMode, DataGridDataSource, DataGridPaginationModel, DataGridSortModel, RowId } from "./types";
+
+//#region src/components/data-grid/use-data-source.d.ts
+type UseDataSourceResult<TRow> = {
+  /** All rows currently loaded (for infinite mode, the accumulated set). */rows: readonly TRow[]; /** Total row count if known. */
+  totalRowCount: number | undefined; /** Whether the initial load is in progress (no data at all yet). */
+  isLoading: boolean; /** Whether a background refetch is happening (data already shown). */
+  isRefetching: boolean; /** Whether more rows are being fetched (infinite scroll). */
+  isLoadingMore: boolean; /** Request the next page (infinite scroll). */
+  loadMore: () => void; /** Whether there are more pages to load. */
+  hasMore: boolean; /** Reload from scratch. */
+  reload: () => void;
+  /**
+   * Error from the most recent async fetch, if any. Consumers should render
+   * an error UI and offer a `reload()` button when this is non-null. Client
+   * mode never sets this (no fetching). Cleared on next successful fetch.
+   */
+  error: Error | null;
+};
+/**
+ * Hook that processes raw data through the grid's sort/pagination state
+ * and returns the `rows` slice ready to pass to `DataGrid`. This is the
+ * only correct way to feed client-side data into a grid.
+ *
+ * Two modes, picked by which prop you pass:
+ * - `data: TRow[]` → client-side mode. In-memory sort + paginate.
+ * - `dataSource: (params) => AsyncGenerator` → server / infinite mode.
+ *   The generator yields pages as you scroll or change pages.
+ *
+ * ```tsx
+ * // Client-side (most common):
+ * const gridData = useDataSource({
+ *   data: users,
+ *   columns,
+ *   getRowId: (row) => row.id,
+ *   sorting: gridState.sorting,
+ *   quickSearch: gridState.quickSearch,
+ *   pagination: gridState.pagination,
+ *   paginationMode: "client",
+ * });
+ *
+ * <DataGrid
+ *   columns={columns}
+ *   rows={gridData.rows}
+ *   totalRowCount={gridData.totalRowCount}
+ *   isLoading={gridData.isLoading}
+ *   state={gridState}
+ *   onChange={setGridState}
+ *   getRowId={(row) => row.id}
+ * />
+ * ```
+ *
+ * Rules:
+ * - Call this hook unconditionally at the top level, before any early return.
+ * - `rows` on `DataGrid` must ALWAYS be `gridData.rows`, never your raw array.
+ * - For server or infinite pagination, use `dataSource` — see the
+ *   `DataGridDataSource` type for the generator signature.
+ *
+ * Quick search:
+ * - Client mode (`data` prop): the hook auto-filters rows via
+ *   `applyQuickSearch` using a default case-insensitive substring match
+ *   across every column. Override with `matchRow` for custom matching
+ *   (fuzzy, weighted, field-specific, etc.).
+ * - Async mode (`dataSource` prop): the hook passes `quickSearch` into
+ *   `params.quickSearch` and re-runs the generator whenever the search
+ *   string changes. The consumer owns the matching logic (typically by
+ *   folding it into a backend query). The grid performs NO client-side
+ *   filtering in async mode.
+ */
+declare function useDataSource<TRow>(opts: {
+  data?: readonly TRow[];
+  dataSource?: DataGridDataSource<TRow>;
+  columns: readonly DataGridColumnDef<TRow>[];
+  getRowId: (row: TRow) => RowId;
+  sorting: DataGridSortModel; /** Current quick-search text, typically `gridState.quickSearch`. */
+  quickSearch: string;
+  /** Override the default client-mode matcher. Ignored in async mode
+   * (there the generator is the matcher). */
+  matchRow?: (row: TRow, query: string, columns: readonly DataGridColumnDef<TRow>[]) => boolean;
+  pagination: DataGridPaginationModel;
+  paginationMode: DataGridDataPaginationMode;
+}): UseDataSourceResult<TRow>;
+//#endregion
+export { UseDataSourceResult, useDataSource };
+//# sourceMappingURL=use-data-source.d.ts.map

package/dist/esm/components/data-grid/use-data-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-data-source.d.ts","names":[],"sources":["../../../../src/components/data-grid/use-data-source.ts"],"mappings":";;;KAiBY,mBAAA;4EAEV,IAAA,WAAe,IAAA,IAFc;EAI7B,aAAA,sBAkBY;EAhBZ,SAAA,WAJA;EAMA,YAAA,WAJA;EAMA,aAAA,WAFA;EAIA,QAAA;EAEA,OAAA,WAEA;EAAA,MAAA;EAMO;;;AAkST;;EAlSE,KAAA,EAAO,KAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkSO,aAAA,MAAA,CAAoB,IAAA;EAClC,IAAA,YAAgB,IAAA;EAChB,UAAA,GAAa,kBAAA,CAAmB,IAAA;EAChC,OAAA,WAAkB,iBAAA,CAAkB,IAAA;EACpC,QAAA,GAAW,GAAA,EAAK,IAAA,KAAS,KAAA;EACzB,OAAA,EAAS,iBAAA;EAET,WAAA;;;EAGA,QAAA,IACE,GAAA,EAAK,IAAA,EACL,KAAA,UACA,OAAA,WAAkB,iBAAA,CAAkB,IAAA;EAEtC,UAAA,EAAY,uBAAA;EACZ,cAAA,EAAgB,0BAAA;AAAA,IACd,mBAAA,CAAoB,IAAA"}