@siyahi/ui 0.0.0-stage → 0.1.0-next.3

package/dist/components/registry/niko-table/hooks/use-generated-options.js

@@ -0,0 +1,144 @@
+import { formatLabel } from "../lib/format.js";
+import { FILTER_VARIANTS } from "../lib/constants.js";
+import { getFilteredRowsExcludingColumn } from "../lib/filter-rows.js";
+import * as React$1 from "react";
+//#region src/components/registry/niko-table/hooks/use-generated-options.ts
+/**
+* Generate a map of options for select/multiSelect columns based on table data.
+* Uses either filtered rows (dynamicCounts) or all core rows.
+*/
+function useGeneratedOptions(table, config = {}) {
+	const { showCounts = true, dynamicCounts = true, limitToFilteredRows = true, includeColumns, excludeColumns, limitPerColumn, mergeStrategy } = config;
+	const state = table.state;
+	const columnFilters = state.columnFilters;
+	const globalFilter = state.globalFilter;
+	const columns = React$1.useMemo(() => table.getAllColumns(), [table, table.options.columns]);
+	const coreRows = table.getCoreRowModel().rows;
+	const includeKey = includeColumns?.join(",") ?? "";
+	const excludeKey = excludeColumns?.join(",") ?? "";
+	return React$1.useMemo(() => {
+		const result = {};
+		for (const column of columns) {
+			const meta = column.columnDef.meta ?? {};
+			const variant = meta.variant ?? FILTER_VARIANTS.TEXT;
+			if (variant !== FILTER_VARIANTS.SELECT && variant !== FILTER_VARIANTS.MULTI_SELECT) continue;
+			const colId = column.id;
+			if (includeColumns && !includeColumns.includes(colId)) continue;
+			if (excludeColumns && excludeColumns.includes(colId)) continue;
+			const colAutoOptions = meta.autoOptions ?? true;
+			const colShowCounts = meta.showCounts ?? showCounts;
+			const colDynamicCounts = meta.dynamicCounts ?? dynamicCounts;
+			const colMerge = meta.mergeStrategy ?? mergeStrategy;
+			const colAutoOptionsFormat = meta.autoOptionsFormat ?? true;
+			const colFormatOptionLabel = meta.formatOptionLabel;
+			if (!colAutoOptions) {
+				result[column.id] = meta.options ?? [];
+				continue;
+			}
+			const filteredRowsExcl = limitToFilteredRows || colDynamicCounts ? getFilteredRowsExcludingColumn(table, coreRows, colId, columnFilters, globalFilter) : coreRows;
+			const optionSourceRows = limitToFilteredRows ? filteredRowsExcl : coreRows;
+			const countSourceRows = colDynamicCounts ? filteredRowsExcl : coreRows;
+			if (meta.options && meta.options.length > 0 && colMerge === "augment") {
+				const countMap = /* @__PURE__ */ new Map();
+				for (const row of countSourceRows) {
+					const raw = row.getValue(colId);
+					const values = Array.isArray(raw) ? raw : [raw];
+					for (const v of values) {
+						if (v === null || v === void 0) continue;
+						const str = String(v);
+						if (str.trim() === "") continue;
+						countMap.set(str, (countMap.get(str) ?? 0) + 1);
+					}
+				}
+				let filteredStaticOptions = meta.options;
+				if (limitToFilteredRows) {
+					const occurrenceMap = /* @__PURE__ */ new Map();
+					for (const row of optionSourceRows) {
+						const raw = row.getValue(colId);
+						const values = Array.isArray(raw) ? raw : [raw];
+						for (const v of values) {
+							if (v == null) continue;
+							occurrenceMap.set(String(v), true);
+						}
+					}
+					filteredStaticOptions = meta.options.filter((opt) => occurrenceMap.has(opt.value));
+				}
+				result[colId] = filteredStaticOptions.map((opt) => ({
+					...opt,
+					count: colShowCounts ? countMap.get(opt.value) ?? 0 : void 0
+				}));
+				continue;
+			}
+			const optionValues = /* @__PURE__ */ new Set();
+			for (const row of optionSourceRows) {
+				const raw = row.getValue(colId);
+				const values = Array.isArray(raw) ? raw : [raw];
+				for (const v of values) {
+					if (v === null || v === void 0) continue;
+					const str = String(v);
+					if (str.trim() === "") continue;
+					optionValues.add(str);
+				}
+			}
+			if (optionValues.size === 0) {
+				result[colId] = [];
+				continue;
+			}
+			const counts = /* @__PURE__ */ new Map();
+			for (const row of countSourceRows) {
+				const raw = row.getValue(colId);
+				const values = Array.isArray(raw) ? raw : [raw];
+				for (const v of values) {
+					if (v === null || v === void 0) continue;
+					const str = String(v);
+					if (str.trim() === "") continue;
+					if (optionValues.has(str)) counts.set(str, (counts.get(str) ?? 0) + 1);
+				}
+			}
+			const options = Array.from(optionValues).map((value) => ({
+				value,
+				label: colFormatOptionLabel ? colFormatOptionLabel(value) : colAutoOptionsFormat ? formatLabel(value) : value,
+				count: colShowCounts ? counts.get(value) ?? 0 : void 0
+			})).sort((a, b) => a.label.localeCompare(b.label));
+			const finalOptions = typeof limitPerColumn === "number" && limitPerColumn > 0 ? options.slice(0, limitPerColumn) : options;
+			if (meta.options && meta.options.length > 0 && (!colMerge || colMerge === "preserve")) {
+				if (limitToFilteredRows) {
+					const availableOptions = /* @__PURE__ */ new Set();
+					for (const row of optionSourceRows) {
+						const raw = row.getValue(colId);
+						const values = Array.isArray(raw) ? raw : [raw];
+						for (const v of values) if (v != null) availableOptions.add(String(v));
+					}
+					result[colId] = meta.options.filter((opt) => availableOptions.has(opt.value));
+				} else result[colId] = meta.options;
+				continue;
+			}
+			result[colId] = finalOptions;
+		}
+		return result;
+	}, [
+		columns,
+		coreRows,
+		table,
+		dynamicCounts,
+		showCounts,
+		includeKey,
+		excludeKey,
+		limitPerColumn,
+		mergeStrategy,
+		limitToFilteredRows,
+		columnFilters,
+		globalFilter
+	]);
+}
+/**
+* Convenience: generate options only for a specific column id
+*/
+function useGeneratedOptionsForColumn(table, columnId, config) {
+	return useGeneratedOptions(table, {
+		...config,
+		includeColumns: [columnId]
+	})[columnId] ?? [];
+}
+//#endregion
+export { useGeneratedOptions, useGeneratedOptionsForColumn };

package/dist/components/registry/niko-table/lib/build-faceted-options.d.ts

@@ -0,0 +1,59 @@
+import { DataTableInstance, DataTableRow, Option } from "../types/index.js";
+import { RowData } from "@tanstack/react-table";
+//#region src/components/registry/niko-table/lib/build-faceted-options.d.ts
+export interface BuildFacetedOptionsConfig {
+  /**
+   * If provided, these options are the source of truth and the returned list
+   * is a subset of them (optionally narrowed by `limitToFilteredRows` and
+   * enriched with live counts).
+   *
+   * If omitted, options are derived from the rows themselves — useful for
+   * columns that are not declared as `select`/`multiSelect` variants but are
+   * still being used with a faceted filter (boolean, text, etc.).
+   */
+  staticOptions?: Option[];
+  /**
+   * Narrow the returned options to values that exist in rows passing every
+   * *other* active filter (the current column's own filter is excluded).
+   */
+  limitToFilteredRows: boolean;
+  /**
+   * Compute counts against filtered rows (again, excluding the current
+   * column's filter) rather than against the full core row model.
+   */
+  dynamicCounts: boolean;
+  /**
+   * When false, `count` is stripped from the output for a consistent shape.
+   */
+  showCounts: boolean;
+  /**
+   * When deriving options from rows, run labels through `formatLabel` (title
+   * case etc.). Ignored when `staticOptions` is provided — callers' labels
+   * are always preserved as-is.
+   */
+  autoOptionsFormat: boolean;
+  /**
+   * Optional per-column label formatter. Wins over `autoOptionsFormat` when
+   * present. Receives the stringified row value, returns the display label.
+   * Ignored when `staticOptions` is provided.
+   */
+  formatOptionLabel?: (value: string) => string;
+}
+/**
+ * Pure builder for the option list surfaced by a faceted filter. Handles
+ * both explicit `staticOptions` (narrow + enrich with counts) and
+ * row-derived options. Plain function (not a hook) so the wrapper can
+ * gate it behind a single `useMemo`.
+ */
+export declare function buildFacetedOptions<TData extends RowData>(table: DataTableInstance<TData>, coreRows: DataTableRow<TData>[], accessorKey: string, columnFilters: Array<{
+  id: string;
+  value: unknown;
+}>, globalFilter: unknown, config: BuildFacetedOptionsConfig): Option[];
+/**
+ * Extract the set of selected values from a single column's filter value,
+ * tolerating every shape it can take: the `ExtendedColumnFilter` object written
+ * by the faceted control and the advanced menu (`{ value: string | string[] }`),
+ * and the legacy bare array / scalar.
+ */
+export declare function extractFilterSelectedValues(rawValue: unknown): Set<string>;
+//#endregion

package/dist/components/registry/niko-table/lib/build-faceted-options.js

@@ -0,0 +1,82 @@
+import { formatLabel } from "./format.js";
+import { getFilteredRowsExcludingColumn } from "./filter-rows.js";
+//#region src/components/registry/niko-table/lib/build-faceted-options.ts
+/**
+* Pure builder for the option list surfaced by a faceted filter. Handles
+* both explicit `staticOptions` (narrow + enrich with counts) and
+* row-derived options. Plain function (not a hook) so the wrapper can
+* gate it behind a single `useMemo`.
+*/
+function buildFacetedOptions(table, coreRows, accessorKey, columnFilters, globalFilter, config) {
+	const { staticOptions, limitToFilteredRows, dynamicCounts, showCounts, autoOptionsFormat, formatOptionLabel } = config;
+	if (staticOptions && !limitToFilteredRows && !showCounts) return staticOptions.map((opt) => ({
+		...opt,
+		count: void 0
+	}));
+	const filteredRows = limitToFilteredRows || dynamicCounts ? getFilteredRowsExcludingColumn(table, coreRows, accessorKey, columnFilters, globalFilter) : coreRows;
+	const optionRows = limitToFilteredRows ? filteredRows : coreRows;
+	const countRows = dynamicCounts ? filteredRows : coreRows;
+	const availableValues = collectRowValues(optionRows, accessorKey);
+	const selectedValues = getSelectedValues(columnFilters, accessorKey);
+	const keepValue = (value) => availableValues.has(value) || selectedValues.has(value);
+	let baseOptions;
+	if (staticOptions) baseOptions = limitToFilteredRows ? staticOptions.filter((opt) => keepValue(opt.value)) : staticOptions;
+	else {
+		const optionValues = limitToFilteredRows ? /* @__PURE__ */ new Set([...availableValues, ...selectedValues]) : availableValues;
+		baseOptions = Array.from(optionValues).map((value) => ({
+			value,
+			label: formatOptionLabel ? formatOptionLabel(value) : autoOptionsFormat ? formatLabel(value) : value
+		})).sort((a, b) => a.label.localeCompare(b.label));
+	}
+	if (!showCounts) return baseOptions.map((opt) => ({
+		...opt,
+		count: void 0
+	}));
+	const targetValues = new Set(baseOptions.map((opt) => opt.value));
+	const valueCounts = /* @__PURE__ */ new Map();
+	for (const row of countRows) {
+		const raw = row.getValue(accessorKey);
+		const values = Array.isArray(raw) ? raw : [raw];
+		for (const v of values) {
+			if (v == null) continue;
+			const str = String(v);
+			if (!str) continue;
+			if (targetValues.has(str)) valueCounts.set(str, (valueCounts.get(str) ?? 0) + 1);
+		}
+	}
+	return baseOptions.map((opt) => ({
+		...opt,
+		count: opt.count ?? valueCounts.get(opt.value) ?? 0
+	}));
+}
+/**
+* Extract the set of selected values from a single column's filter value,
+* tolerating every shape it can take: the `ExtendedColumnFilter` object written
+* by the faceted control and the advanced menu (`{ value: string | string[] }`),
+* and the legacy bare array / scalar.
+*/
+function extractFilterSelectedValues(rawValue) {
+	let raw = rawValue;
+	if (raw && typeof raw === "object" && !Array.isArray(raw) && "value" in raw) raw = raw.value;
+	if (raw == null || raw === "") return /* @__PURE__ */ new Set();
+	return new Set((Array.isArray(raw) ? raw : [raw]).filter((v) => v != null && v !== "").map(String));
+}
+function getSelectedValues(columnFilters, accessorKey) {
+	const entry = columnFilters.find((filter) => filter.id === accessorKey);
+	return entry ? extractFilterSelectedValues(entry.value) : /* @__PURE__ */ new Set();
+}
+function collectRowValues(rows, accessorKey) {
+	const set = /* @__PURE__ */ new Set();
+	for (const row of rows) {
+		const raw = row.getValue(accessorKey);
+		const values = Array.isArray(raw) ? raw : [raw];
+		for (const v of values) {
+			if (v == null) continue;
+			const str = String(v);
+			if (str) set.add(str);
+		}
+	}
+	return set;
+}
+//#endregion
+export { buildFacetedOptions, extractFilterSelectedValues };

package/dist/components/registry/niko-table/lib/column-resize-handle.d.ts

@@ -0,0 +1,33 @@
+import { DEFAULT_MAX_COLUMN_SIZE, DEFAULT_MIN_COLUMN_SIZE } from "./constants.js";
+import { DataTableHeader } from "../types/index.js";
+import * as React$1 from "react";
+import { RowData } from "@tanstack/react-table";
+//#region src/components/registry/niko-table/lib/column-resize-handle.d.ts
+/**
+ * Drag-to-resize / double-click-to-autosize grip on a header's right edge.
+ * Keyboard-operable (WAI-ARIA window-splitter): focusable, Arrow Left/Right
+ * nudge the width (Shift = larger step), Enter autosizes; exposes
+ * `aria-value*`.
+ */
+export interface DataTableColumnResizeHandleProps<TData extends RowData> {
+  header: DataTableHeader<TData, unknown>;
+  /**
+   * This column is currently the flex (fill) column. Flex columns have no width
+   * TanStack can drive, so they resize through a custom pointer drag that starts
+   * from the rendered width (no jump) and, on release, writes an explicit width
+   * — which pins the column and hands the fill to the next eligible column.
+   */
+  isFlex?: boolean;
+  /**
+   * Drive the resize preview line during a flex drag (from the DataTable
+   * context). Passed `{ resizingColumnId, deltaOffset }` while dragging, `null`
+   * on release.
+   */
+  setResizePreview?: (info: {
+    resizingColumnId: string | null;
+    deltaOffset: number;
+  } | null) => void;
+}
+export declare function DataTableColumnResizeHandle<TData extends RowData>({ header, isFlex, setResizePreview }: DataTableColumnResizeHandleProps<TData>): React$1.JSX.Element;
+//#endregion
+export { DEFAULT_MAX_COLUMN_SIZE, DEFAULT_MIN_COLUMN_SIZE };

package/dist/components/registry/niko-table/lib/column-resize-handle.js

@@ -0,0 +1,175 @@
+"use client";
+import { cn } from "../../../../lib/utils.js";
+import { DEFAULT_MAX_COLUMN_SIZE, DEFAULT_MIN_COLUMN_SIZE } from "./constants.js";
+import * as React$1 from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/components/registry/niko-table/lib/column-resize-handle.tsx
+/**
+* niko-table — created by Semir N. (Semkoo, https://github.com/Semkoo) with AI assistance.
+*
+* Before reporting anything: please check the changelog first.
+*  - In-repo: ./CHANGELOG.md
+*  - Docs site: https://niko-table.com/changelog
+*
+* Found a bug or have a fix? Open an issue or PR on GitHub so other
+* users (and future LLMs reading this code) benefit:
+* https://github.com/Semkoo/niko-table-registry
+*/
+/**
+* Drag-to-resize / double-click-to-autosize grip used by DataTableHeader and
+* DataTableVirtualizedHeader when `enableColumnResizing` is on. Lives in core
+* so both bodies can import it without pulling the opt-in marker package.
+*/
+/** Room for cell chrome the text measurement doesn't cover. */
+const AUTOSIZE_CELL_PADDING = 24;
+const AUTOSIZE_HEADER_CHROME = 52;
+/** Keyboard resize step (px); the larger step applies while Shift is held. */
+const KEYBOARD_RESIZE_STEP = 8;
+const KEYBOARD_RESIZE_STEP_LARGE = 40;
+/**
+* Tightest width that fits every TEXT node in an element. Uses a DOM Range
+* so `w-full` + `truncate` wrappers — whose `scrollWidth` echoes the current
+* cell width — don't hide the natural content width. Autosize can grow AND
+* shrink to fit.
+*/
+function widestTextWidth(el) {
+	const range = document.createRange();
+	const walker = document.createTreeWalker(el, NodeFilter.SHOW_TEXT);
+	let max = 0;
+	for (let n = walker.nextNode(); n; n = walker.nextNode()) {
+		if (!n.textContent || n.textContent.trim() === "") continue;
+		range.selectNodeContents(n);
+		max = Math.max(max, range.getBoundingClientRect().width);
+	}
+	return max;
+}
+/**
+* Autosize a column to fit its content — measures the widest rendered
+* cell/header text (mounted cells only — for virtualized tables, what's on
+* screen) and sets that column's size.
+*/
+function autosizeColumn(header, handle) {
+	const root = handle.closest("[data-slot=\"table\"]");
+	if (!root) return;
+	const cells = root.querySelectorAll(`[data-col-id="${CSS.escape(header.column.id)}"]`);
+	let content = 0;
+	cells.forEach((c) => {
+		const chrome = c.getAttribute("data-slot") === "table-head" ? AUTOSIZE_HEADER_CHROME : AUTOSIZE_CELL_PADDING;
+		content = Math.max(content, widestTextWidth(c) + chrome);
+	});
+	if (content <= 0) return;
+	const def = header.column.columnDef;
+	const width = Math.min(Math.max(Math.ceil(content), def.minSize ?? 40), def.maxSize ?? 1e3);
+	header.getContext().table.setColumnSizing((prev) => ({
+		...prev,
+		[header.column.id]: width
+	}));
+}
+function DataTableColumnResizeHandle({ header, isFlex = false, setResizePreview }) {
+	const isResizing = header.column.getIsResizing();
+	const resize = header.getResizeHandler();
+	const def = header.column.columnDef;
+	const min = def.minSize ?? 40;
+	const max = def.maxSize ?? 1e3;
+	const [focusedWidth, setFocusedWidth] = React$1.useState(null);
+	const hasExplicitWidth = header.getContext().table.atoms.columnSizing?.get()?.[header.column.id] != null;
+	const ariaValueNow = Math.round(hasExplicitWidth ? header.column.getSize() : focusedWidth ?? header.column.getSize());
+	const nudge = (delta, fallbackWidth) => {
+		header.getContext().table.setColumnSizing((prev) => {
+			const current = prev[header.column.id] ?? fallbackWidth ?? header.column.getSize();
+			const next = Math.min(Math.max(current + delta, min), max);
+			return {
+				...prev,
+				[header.column.id]: next
+			};
+		});
+	};
+	const flexDragTeardownRef = React$1.useRef(null);
+	React$1.useEffect(() => () => flexDragTeardownRef.current?.(), []);
+	const startFlexResize = (startClientX, handleEl) => {
+		const thEl = handleEl?.closest("[data-col-id]");
+		if (!thEl || !setResizePreview) return;
+		const startWidth = thEl.getBoundingClientRect().width;
+		const id = header.column.id;
+		setResizePreview({
+			resizingColumnId: id,
+			deltaOffset: 0
+		});
+		const onMove = (ev) => {
+			setResizePreview({
+				resizingColumnId: id,
+				deltaOffset: ev.clientX - startClientX
+			});
+		};
+		const teardown = () => {
+			flexDragTeardownRef.current = null;
+			window.removeEventListener("pointermove", onMove);
+			window.removeEventListener("pointerup", onUp);
+			window.removeEventListener("pointercancel", onCancel);
+			setResizePreview(null);
+		};
+		flexDragTeardownRef.current = teardown;
+		const onUp = (ev) => {
+			const next = Math.min(Math.max(startWidth + (ev.clientX - startClientX), min), max);
+			header.getContext().table.setColumnSizing((prev) => ({
+				...prev,
+				[id]: next
+			}));
+			teardown();
+		};
+		const onCancel = () => teardown();
+		window.addEventListener("pointermove", onMove);
+		window.addEventListener("pointerup", onUp);
+		window.addEventListener("pointercancel", onCancel);
+	};
+	return /* @__PURE__ */ jsx("div", {
+		"data-slot": "column-resize-handle",
+		role: "separator",
+		"aria-orientation": "vertical",
+		"aria-label": "Resize column (arrow keys, or double-click to fit)",
+		"aria-valuenow": ariaValueNow,
+		"aria-valuemin": min,
+		"aria-valuemax": Math.max(max, ariaValueNow),
+		tabIndex: 0,
+		onFocus: (e) => {
+			const width = e.currentTarget.closest("[data-col-id]")?.getBoundingClientRect().width;
+			setFocusedWidth(width ?? null);
+		},
+		onBlur: () => setFocusedWidth(null),
+		onMouseDown: (e) => {
+			e.stopPropagation();
+			if (!isFlex) resize(e);
+		},
+		onTouchStart: (e) => {
+			e.stopPropagation();
+			if (!isFlex) resize(e);
+		},
+		onDoubleClick: (e) => autosizeColumn(header, e.currentTarget),
+		onClick: (e) => e.stopPropagation(),
+		onPointerDown: (e) => {
+			e.stopPropagation();
+			if (isFlex) {
+				e.preventDefault();
+				startFlexResize(e.clientX, e.currentTarget);
+			}
+		},
+		onKeyDown: (e) => {
+			const step = e.shiftKey ? KEYBOARD_RESIZE_STEP_LARGE : KEYBOARD_RESIZE_STEP;
+			const fallbackWidth = isFlex ? e.currentTarget.closest("[data-col-id]")?.getBoundingClientRect().width : void 0;
+			if (e.key === "ArrowLeft") {
+				e.preventDefault();
+				nudge(-step, fallbackWidth);
+			} else if (e.key === "ArrowRight") {
+				e.preventDefault();
+				nudge(step, fallbackWidth);
+			} else if (e.key === "Enter") {
+				e.preventDefault();
+				autosizeColumn(header, e.currentTarget);
+			}
+		},
+		className: "group/resize absolute top-0 right-0 z-10 flex h-full w-2 cursor-col-resize touch-none justify-end outline-none select-none",
+		children: /* @__PURE__ */ jsx("div", { className: cn("my-1.5 w-px rounded bg-border opacity-0 transition-all", "group-hover/resize:my-0 group-hover/resize:w-0.5 group-hover/resize:bg-primary group-hover/resize:opacity-100", "group-focus-visible/resize:my-0 group-focus-visible/resize:w-0.5 group-focus-visible/resize:bg-primary group-focus-visible/resize:opacity-100", isResizing && "my-0 w-0.5 bg-primary opacity-100") })
+	});
+}
+//#endregion
+export { DEFAULT_MAX_COLUMN_SIZE, DEFAULT_MIN_COLUMN_SIZE, DataTableColumnResizeHandle };

package/dist/components/registry/niko-table/lib/constants.d.ts

@@ -0,0 +1,128 @@
+//#region src/components/registry/niko-table/lib/constants.d.ts
+export declare const JOIN_OPERATORS: {
+  /** Logical AND (all filters must match) */
+  readonly AND: "and";
+  /** Logical OR (any filter can match) */
+  readonly OR: "or";
+  /** Mixed logic (combination of AND/OR) */
+  readonly MIXED: "mixed";
+};
+/**
+ * Filter operator constants defining the comparison logic.
+ * Naming follows SQL/PostgREST standards (ilike, eq, ne, etc.).
+ */
+export declare const FILTER_OPERATORS: {
+  /** SQL ILIKE (Case-insensitive search) */
+  readonly ILIKE: "ilike";
+  /** SQL NOT ILIKE */
+  readonly NOT_ILIKE: "not.ilike";
+  /** SQL EQUAL (=) */
+  readonly EQ: "eq";
+  /** SQL NOT EQUAL (!=) */
+  readonly NEQ: "neq";
+  /** SQL IN (one of) */
+  readonly IN: "in";
+  /** SQL NOT IN (none of) */
+  readonly NOT_IN: "not.in";
+  /** Value is null or empty string */
+  readonly EMPTY: "empty";
+  /** Value is not null and not empty string */
+  readonly NOT_EMPTY: "not.empty";
+  /** SQL LESS THAN (<) */
+  readonly LT: "lt";
+  /** SQL LESS THAN OR EQUAL (<=) */
+  readonly LTE: "lte";
+  /** SQL GREATER THAN (>) */
+  readonly GT: "gt";
+  /** SQL GREATER THAN OR EQUAL (>=) */
+  readonly GTE: "gte";
+  /** SQL BETWEEN (range) */
+  readonly BETWEEN: "between";
+  /** Relative date calculation (e.g., "today", "last-7-days") */
+  readonly RELATIVE: "relative";
+};
+/**
+ * Filter variant constants defining the UI control type.
+ */
+export declare const FILTER_VARIANTS: {
+  /** Standard text input */
+  readonly TEXT: "text";
+  /** Numeric input */
+  readonly NUMBER: "number";
+  /** Two-value range input */
+  readonly RANGE: "range";
+  /** Single date picker */
+  readonly DATE: "date";
+  /** Date range picker */
+  readonly DATE_RANGE: "dateRange";
+  /** Single select dropdown */
+  readonly SELECT: "select";
+  /** Multi-select dropdown */
+  readonly MULTI_SELECT: "multiSelect";
+  /** Checkbox or toggle */
+  readonly BOOLEAN: "boolean";
+};
+/** Join operators for combining multiple filters */
+export type JoinOperator = (typeof JOIN_OPERATORS)[keyof typeof JOIN_OPERATORS];
+/** Filter operators supported by the data table */
+export type FilterOperator = (typeof FILTER_OPERATORS)[keyof typeof FILTER_OPERATORS];
+/** Filter variants supported by the data table (UI control type) */
+export type FilterVariant = (typeof FILTER_VARIANTS)[keyof typeof FILTER_VARIANTS];
+/** Global default values */
+export declare const DEFAULT_VALUES: {
+  readonly JOIN_OPERATOR: "and";
+  readonly PAGE_SIZE: 10;
+  readonly PAGE_INDEX: 0;
+};
+/** System column IDs - used for smart pinning and feature detection */
+export declare const SYSTEM_COLUMN_IDS: {
+  /** Row selection checkbox column */
+  readonly SELECT: "select";
+  /** Row expand/collapse column */
+  readonly EXPAND: "expand";
+  /** Row actions column (edit, delete, etc.) */
+  readonly ACTIONS: "actions";
+};
+/** Array of all system column IDs for filtering */
+export declare const SYSTEM_COLUMN_ID_LIST: string[];
+/** UI-related constraints and settings */
+export declare const UI_CONSTANTS: {
+  /** Max characters allowed for a filter ID */
+  readonly FILTER_ID_MAX_LENGTH: 100;
+  /** Default max height for scrollable filter popovers */
+  readonly MAX_FILTER_DISPLAY_HEIGHT: 300;
+  /** Default debounce delay in milliseconds for search inputs */
+  readonly DEBOUNCE_DELAY: 300;
+};
+/** Default keyboard shortcut key mappings */
+export declare const KEYBOARD_SHORTCUTS: {
+  /** Open/Toggle filter menu */
+  readonly FILTER_TOGGLE: "f";
+  /** Remove active filter (usually combined with Shift) */
+  readonly FILTER_REMOVE: "f";
+  /** Close active UI elements */
+  readonly ESCAPE: "escape";
+  /** Confirm or submit active action */
+  readonly ENTER: "enter";
+  /** Remove character or navigate back */
+  readonly BACKSPACE: "backspace";
+  /** Item deletion */
+  readonly DELETE: "delete";
+};
+/**
+ * Default column width bounds when a column omits `minSize` / `maxSize`.
+ * Shared by `DataTableRoot` (defaultColumn) and the resize handle clamp —
+ * keep these in constants so root does not import the resize-handle module.
+ */
+export declare const DEFAULT_MIN_COLUMN_SIZE = 40;
+export declare const DEFAULT_MAX_COLUMN_SIZE = 1000;
+/** Standard internalized error messages */
+export declare const ERROR_MESSAGES: {
+  /** Thrown when using the old global operator pattern */
+  readonly DEPRECATED_GLOBAL_JOIN_OPERATOR: "Global join operator is deprecated. Use individual filter join operators.";
+  /** General configuration error */
+  readonly INVALID_FILTER_CONFIGURATION: "Invalid filter configuration provided.";
+  /** Thrown when mandatory metadata is missing from columns */
+  readonly MISSING_COLUMN_META: "Column metadata is required for filtering.";
+};
+//#endregion