@cube-dev/ui-kit 0.182.0 → 0.183.0

package/dist/components/data/TableBase/use-scrollability.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-scrollability.js","names":[],"sources":["../../../../src/components/data/TableBase/use-scrollability.ts"],"sourcesContent":["import { useLayoutEffect, useState } from 'react';\n\nexport interface CubeScrollability {\n  x: boolean;\n  y: boolean;\n}\n\nconst NONE: CubeScrollability = { x: false, y: false };\n\n/**\n * Whether the scroller can actually scroll, per axis.\n *\n * This exists for `overscroll-behavior`. `contain` is what stops a horizontal\n * swipe at the scroll edge from triggering browser back-navigation, but Chrome\n * applies it to any element with `overflow: auto` — including one whose content\n * fits. The wheel event is then swallowed by a scroller with nothing to scroll,\n * and the page behind it will not move. So the containment has to be scoped to\n * the axis that is genuinely scrollable, which means measuring.\n *\n * Both the scroller and its content are observed: the scroller's own box does\n * not change when rows are added, so observing it alone would miss a table that\n * grew past its container.\n */\nexport function useScrollability(\n  element: HTMLElement | null,\n): CubeScrollability {\n  const [state, setState] = useState<CubeScrollability>(NONE);\n\n  useLayoutEffect(() => {\n    // Matches `useContainerWidth`: a scroller handed over by a callback ref can\n    // be null, and `observe` throws on anything that is not an Element.\n    if (!element || !(element instanceof Element)) {\n      setState(NONE);\n\n      return;\n    }\n\n    const measure = () => {\n      // A 1px tolerance: sub-pixel layout regularly leaves `scrollHeight` a\n      // fraction above `clientHeight` on a table that visibly does not scroll,\n      // and trapping the wheel over that fraction is the exact bug this avoids.\n      const next = {\n        x: element.scrollWidth - element.clientWidth > 1,\n        y: element.scrollHeight - element.clientHeight > 1,\n      };\n\n      setState((current) =>\n        current.x === next.x && current.y === next.y ? current : next,\n      );\n    };\n\n    measure();\n\n    const observer = new ResizeObserver(measure);\n\n    observer.observe(element);\n\n    const content = element.firstElementChild;\n\n    if (content) observer.observe(content);\n\n    return () => observer.disconnect();\n  }, [element]);\n\n  return state;\n}\n"],"mappings":";;;;AAOA,MAAM,OAA0B;CAAE,GAAG;CAAO,GAAG;CAAO;;;;;;;;;;;;;;;AAgBtD,SAAgB,iBACd,SACmB;CACnB,MAAM,CAAC,OAAO,YAAY,SAA4B,KAAK;AAE3D,uBAAsB;AAGpB,MAAI,CAAC,WAAW,EAAE,mBAAmB,UAAU;AAC7C,YAAS,KAAK;AAEd;;EAGF,MAAM,gBAAgB;GAIpB,MAAM,OAAO;IACX,GAAG,QAAQ,cAAc,QAAQ,cAAc;IAC/C,GAAG,QAAQ,eAAe,QAAQ,eAAe;IAClD;AAED,aAAU,YACR,QAAQ,MAAM,KAAK,KAAK,QAAQ,MAAM,KAAK,IAAI,UAAU,KAC1D;;AAGH,WAAS;EAET,MAAM,WAAW,IAAI,eAAe,QAAQ;AAE5C,WAAS,QAAQ,QAAQ;EAEzB,MAAM,UAAU,QAAQ;AAExB,MAAI,QAAS,UAAS,QAAQ,QAAQ;AAEtC,eAAa,SAAS,YAAY;IACjC,CAAC,QAAQ,CAAC;AAEb,QAAO"}
+{"version":3,"file":"use-scrollability.js","names":["useLayoutEffect","useState","CubeScrollability","x","y","NONE","useScrollability","element","$","_c","state","setState","t0","t1","Element","measure","next","scrollWidth","clientWidth","scrollHeight","clientHeight","current","observer","ResizeObserver","observe","content","firstElementChild","disconnect"],"sources":["../../../../src/components/data/TableBase/use-scrollability.ts"],"sourcesContent":["import { useLayoutEffect, useState } from 'react';\n\nexport interface CubeScrollability {\n  x: boolean;\n  y: boolean;\n}\n\nconst NONE: CubeScrollability = { x: false, y: false };\n\n/**\n * Whether the scroller can actually scroll, per axis.\n *\n * This exists for `overscroll-behavior`. `contain` is what stops a horizontal\n * swipe at the scroll edge from triggering browser back-navigation, but Chrome\n * applies it to any element with `overflow: auto` — including one whose content\n * fits. The wheel event is then swallowed by a scroller with nothing to scroll,\n * and the page behind it will not move. So the containment has to be scoped to\n * the axis that is genuinely scrollable, which means measuring.\n *\n * Both the scroller and its content are observed: the scroller's own box does\n * not change when rows are added, so observing it alone would miss a table that\n * grew past its container.\n */\nexport function useScrollability(\n  element: HTMLElement | null,\n): CubeScrollability {\n  const [state, setState] = useState<CubeScrollability>(NONE);\n\n  useLayoutEffect(() => {\n    // Matches `useContainerWidth`: a scroller handed over by a callback ref can\n    // be null, and `observe` throws on anything that is not an Element.\n    if (!element || !(element instanceof Element)) {\n      setState(NONE);\n\n      return;\n    }\n\n    const measure = () => {\n      // A 1px tolerance: sub-pixel layout regularly leaves `scrollHeight` a\n      // fraction above `clientHeight` on a table that visibly does not scroll,\n      // and trapping the wheel over that fraction is the exact bug this avoids.\n      const next = {\n        x: element.scrollWidth - element.clientWidth > 1,\n        y: element.scrollHeight - element.clientHeight > 1,\n      };\n\n      setState((current) =>\n        current.x === next.x && current.y === next.y ? current : next,\n      );\n    };\n\n    measure();\n\n    const observer = new ResizeObserver(measure);\n\n    observer.observe(element);\n\n    const content = element.firstElementChild;\n\n    if (content) observer.observe(content);\n\n    return () => observer.disconnect();\n  }, [element]);\n\n  return state;\n}\n"],"mappings":";;;;;AAOA,MAAMK,OAA0B;CAAEF,GAAG;CAAOC,GAAG;CAAO;;;;;;;;;;;;;;;AAgBtD,SAAOE,iBAAAC,SAAA;CAAA,MAAAC,IAAAC,EAAA,EAAA;CAGL,MAAA,CAAAC,OAAAC,YAA0BV,SAA4BI,KAAK;CAAC,IAAAO;CAAA,IAAAC;AAAA,KAAAL,EAAA,OAAAD,SAAA;AAE5CK,aAAA;AAGd,OAAI,CAACL,WAAD,EAAcA,mBAAmBO,UAAQ;AAC3CH,aAASN,KAAK;AAAA;;GAKhB,MAAAU,gBAAgB;IAId,MAAAC,OAAa;KAAAb,GACRI,QAAOU,cAAeV,QAAOW,cAAe;KAACd,GAC7CG,QAAOY,eAAgBZ,QAAOa,eAAgB;KAClD;AAEDT,cAASU,YACPA,QAAOlB,MAAOa,KAAIb,KAAMkB,QAAOjB,MAAOY,KAAIZ,IAA1CiB,UAAAL,KACD;;AAGHD,YAAS;GAET,MAAAO,WAAiB,IAAIC,eAAeR,QAAQ;AAE5CO,YAAQE,QAASjB,QAAQ;GAEzB,MAAAkB,UAAgBlB,QAAOmB;AAEvB,OAAID,QAASH,UAAQE,QAASC,QAAQ;AAAC,gBAE1BH,SAAQK,YAAa;;AACjCd,OAAA,CAACN,QAAQ;AAAAC,IAAA,KAAAD;AAAAC,IAAA,KAAAI;AAAAJ,IAAA,KAAAK;QAAA;AAAAD,OAAAJ,EAAA;AAAAK,OAAAL,EAAA;;AAlCZR,iBAAgBY,IAkCbC,GAAU;AAAA,QAENH"}

package/dist/components/data/TableBase/use-table-columns.js

@@ -1,5 +1,5 @@
-/** @license MIT | @cube-dev/ui-kit v0.182.0 | Cube Dev Team */
-import { useMemo } from "react";
+/** @license MIT | @cube-dev/ui-kit v0.183.0 | Cube Dev Team */
+import { c } from "react-compiler-runtime";
 
 //#region src/components/data/TableBase/use-table-columns.ts
 /** @default when a column declares neither `width` nor `minWidth`. */
@@ -76,111 +76,181 @@ function clamp(value, min, max) {
 * settles. When even the minimums do not fit, every column takes its minimum
 * and the table scrolls horizontally.
 */
-function useTableColumns({ columns, containerWidth, columnWidths, leadingColumns, trailingColumns }) {
-	return useMemo(() => {
+function useTableColumns(t0) {
+	const $ = c(16);
+	const { columns, containerWidth, columnWidths, leadingColumns, trailingColumns } = t0;
+	let isOverflowing;
+	let out;
+	let pinnedEndWidth;
+	let pinnedStartWidth;
+	let t1;
+	if ($[0] !== columnWidths || $[1] !== columns || $[2] !== containerWidth || $[3] !== leadingColumns || $[4] !== trailingColumns) {
 		const visible = [
 			...leadingColumns ?? [],
 			...columns,
 			...trailingColumns ?? []
-		].filter((column) => !column.isHidden);
+		].filter(_temp);
 		const ordered = [
-			...visible.filter((c) => c.pin === "start"),
-			...visible.filter((c) => !c.pin),
-			...visible.filter((c) => c.pin === "end")
+			...visible.filter(_temp2),
+			...visible.filter(_temp3),
+			...visible.filter(_temp4)
 		];
-		const structuralKeys = new Set([...leadingColumns ?? [], ...trailingColumns ?? []].map((c) => c.key));
-		const specs = ordered.map((column) => {
-			const isStructural = structuralKeys.has(column.key);
-			const explicit = columnWidths?.[column.key] ?? column.width;
-			const minWidth = column.minWidth ?? (explicit != null ? explicit : isStructural ? 0 : DEFAULT_MIN_WIDTH);
+		const structuralKeys = new Set([...leadingColumns ?? [], ...trailingColumns ?? []].map(_temp5));
+		const specs = ordered.map((column_0) => {
+			const isStructural = structuralKeys.has(column_0.key);
+			const explicit = columnWidths?.[column_0.key] ?? column_0.width;
+			const minWidth = column_0.minWidth ?? (explicit != null ? explicit : isStructural ? 0 : DEFAULT_MIN_WIDTH);
 			return {
-				column,
+				column: column_0,
 				isStructural,
 				fixed: explicit ?? null,
 				minWidth,
-				maxWidth: column.maxWidth ?? null,
-				flex: explicit != null ? null : column.flex ?? 1
+				maxWidth: column_0.maxWidth ?? null,
+				flex: explicit != null ? null : column_0.flex ?? 1
 			};
 		});
 		const resolved = /* @__PURE__ */ new Map();
-		let isOverflowing = false;
+		isOverflowing = false;
 		if (containerWidth != null && containerWidth > 0) {
-			const fixedTotal = specs.reduce((sum, s) => sum + (s.fixed ?? 0), 0);
-			const flexSpecs = specs.filter((s) => s.fixed == null);
-			if (specs.reduce((sum, s) => sum + (s.fixed ?? s.minWidth), 0) > containerWidth) {
+			const fixedTotal = specs.reduce(_temp6, 0);
+			const flexSpecs = specs.filter(_temp7);
+			if (specs.reduce(_temp8, 0) > containerWidth) {
 				isOverflowing = true;
 				for (const spec of specs) resolved.set(spec.column.key, spec.fixed ?? spec.minWidth);
 			} else {
 				let remaining = containerWidth - fixedTotal;
 				let pool = flexSpecs;
 				while (pool.length > 0) {
-					const totalFlex = pool.reduce((sum, s) => sum + (s.flex ?? 1), 0);
+					const totalFlex = pool.reduce(_temp9, 0);
 					const nextPool = [];
 					let consumed = 0;
-					for (const spec of pool) {
-						const ideal = remaining * (spec.flex ?? 1) / (totalFlex || 1);
-						const clamped = clamp(ideal, spec.minWidth, spec.maxWidth);
+					for (const spec_0 of pool) {
+						const ideal = remaining * (spec_0.flex ?? 1) / (totalFlex || 1);
+						const clamped = clamp(ideal, spec_0.minWidth, spec_0.maxWidth);
 						if (clamped !== ideal) {
-							resolved.set(spec.column.key, clamped);
-							consumed += clamped;
-						} else nextPool.push(spec);
+							resolved.set(spec_0.column.key, clamped);
+							consumed = consumed + clamped;
+						} else nextPool.push(spec_0);
 					}
 					if (nextPool.length === pool.length) {
-						const totalLeft = nextPool.reduce((sum, s) => sum + (s.flex ?? 1), 0);
-						for (const spec of nextPool) resolved.set(spec.column.key, remaining * (spec.flex ?? 1) / (totalLeft || 1));
+						const totalLeft = nextPool.reduce(_temp0, 0);
+						for (const spec_1 of nextPool) resolved.set(spec_1.column.key, remaining * (spec_1.flex ?? 1) / (totalLeft || 1));
 						break;
 					}
-					remaining -= consumed;
+					remaining = remaining - consumed;
 					pool = nextPool;
 				}
-				for (const spec of specs) if (spec.fixed != null) resolved.set(spec.column.key, spec.fixed);
+				for (const spec_2 of specs) if (spec_2.fixed != null) resolved.set(spec_2.column.key, spec_2.fixed);
 			}
 		}
-		let pinnedStartWidth = 0;
-		let pinnedEndWidth = 0;
-		const out = specs.map((spec, index) => ({
-			...spec.column,
+		pinnedStartWidth = 0;
+		pinnedEndWidth = 0;
+		out = specs.map((spec_3, index) => ({
+			...spec_3.column,
 			index,
 			ariaColIndex: index + 1,
-			width: resolved.get(spec.column.key) ?? null,
-			minWidth: spec.minWidth,
-			maxWidth: spec.maxWidth,
-			flex: spec.flex,
-			align: spec.column.align ?? "start",
+			width: resolved.get(spec_3.column.key) ?? null,
+			minWidth: spec_3.minWidth,
+			maxWidth: spec_3.maxWidth,
+			flex: spec_3.flex,
+			align: spec_3.column.align ?? "start",
 			pinOffset: null,
 			isPinEdge: false,
-			isStructural: spec.isStructural
+			isStructural: spec_3.isStructural
 		}));
-		for (const column of out) {
-			if (column.pin !== "start") continue;
-			column.pinOffset = pinnedStartWidth;
-			pinnedStartWidth += column.width ?? column.minWidth;
+		for (const column_1 of out) {
+			if (column_1.pin !== "start") continue;
+			column_1.pinOffset = pinnedStartWidth;
+			pinnedStartWidth = pinnedStartWidth + (column_1.width ?? column_1.minWidth);
 		}
 		for (let i = out.length - 1; i >= 0; i--) {
-			const column = out[i];
-			if (column.pin !== "end") continue;
-			column.pinOffset = pinnedEndWidth;
-			pinnedEndWidth += column.width ?? column.minWidth;
+			const column_2 = out[i];
+			if (column_2.pin !== "end") continue;
+			column_2.pinOffset = pinnedEndWidth;
+			pinnedEndWidth = pinnedEndWidth + (column_2.width ?? column_2.minWidth);
 		}
-		const lastPinnedStart = out.filter((c) => c.pin === "start").at(-1);
-		const firstPinnedEnd = out.find((c) => c.pin === "end");
+		const lastPinnedStart = out.filter(_temp1).at(-1);
+		const firstPinnedEnd = out.find(_temp10);
 		if (lastPinnedStart) lastPinnedStart.isPinEdge = true;
 		if (firstPinnedEnd) firstPinnedEnd.isPinEdge = true;
-		const totalWidth = out.every((c) => c.width != null) ? out.reduce((sum, c) => sum + (c.width ?? 0), 0) : null;
-		return {
+		t1 = out.every(_temp11) ? out.reduce(_temp12, 0) : null;
+		$[0] = columnWidths;
+		$[1] = columns;
+		$[2] = containerWidth;
+		$[3] = leadingColumns;
+		$[4] = trailingColumns;
+		$[5] = isOverflowing;
+		$[6] = out;
+		$[7] = pinnedEndWidth;
+		$[8] = pinnedStartWidth;
+		$[9] = t1;
+	} else {
+		isOverflowing = $[5];
+		out = $[6];
+		pinnedEndWidth = $[7];
+		pinnedStartWidth = $[8];
+		t1 = $[9];
+	}
+	const totalWidth = t1;
+	let t2;
+	if ($[10] !== isOverflowing || $[11] !== out || $[12] !== pinnedEndWidth || $[13] !== pinnedStartWidth || $[14] !== totalWidth) {
+		t2 = {
 			columns: out,
 			pinnedStartWidth,
 			pinnedEndWidth,
 			totalWidth,
 			isOverflowing
 		};
-	}, [
-		columns,
-		containerWidth,
-		columnWidths,
-		leadingColumns,
-		trailingColumns
-	]);
+		$[10] = isOverflowing;
+		$[11] = out;
+		$[12] = pinnedEndWidth;
+		$[13] = pinnedStartWidth;
+		$[14] = totalWidth;
+		$[15] = t2;
+	} else t2 = $[15];
+	return t2;
+}
+function _temp12(sum_3, c_5) {
+	return sum_3 + (c_5.width ?? 0);
+}
+function _temp11(c_6) {
+	return c_6.width != null;
+}
+function _temp10(c_4) {
+	return c_4.pin === "end";
+}
+function _temp1(c_3) {
+	return c_3.pin === "start";
+}
+function _temp0(sum_2, s_3) {
+	return sum_2 + (s_3.flex ?? 1);
+}
+function _temp9(sum_1, s_2) {
+	return sum_1 + (s_2.flex ?? 1);
+}
+function _temp8(sum_0, s_1) {
+	return sum_0 + (s_1.fixed ?? s_1.minWidth);
+}
+function _temp7(s_0) {
+	return s_0.fixed == null;
+}
+function _temp6(sum, s) {
+	return sum + (s.fixed ?? 0);
+}
+function _temp5(c_2) {
+	return c_2.key;
+}
+function _temp4(c_1) {
+	return c_1.pin === "end";
+}
+function _temp3(c_0) {
+	return !c_0.pin;
+}
+function _temp2(c) {
+	return c.pin === "start";
+}
+function _temp(column) {
+	return !column.isHidden;
 }
 
 //#endregion

package/dist/components/data/TableBase/use-table-columns.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-table-columns.js","names":[],"sources":["../../../../src/components/data/TableBase/use-table-columns.ts"],"sourcesContent":["import { useMemo } from 'react';\n\nimport type {\n  CubeResolvedColumn,\n  CubeTableColumn,\n  CubeTableColumnLayout,\n} from './types';\n\n/** @default when a column declares neither `width` nor `minWidth`. */\nexport const DEFAULT_MIN_WIDTH = 150;\n\n/**\n * Every column's current width, so a resize can change exactly one of them.\n *\n * A column with no explicit width is `flex: 1` and shares the leftover (see the\n * spec builder below). Making only the DRAGGED column fixed leaves every other\n * one in the flex pool, re-splitting a leftover that just changed — so one\n * divider moved all of them, including columns to the LEFT of the handle, which\n * cannot be what dragging a right edge means. Measured before this existed:\n * dragging column B by +8px took 3px off A, C and D each.\n *\n * Freezing first means a drag changes one width. Columns after it are pushed\n * along, which is what being after it means, and the table grows or shrinks\n * rather than the neighbours absorbing the difference.\n *\n * Structural columns are skipped — they are sized by the table, not the user.\n */\nexport function freezeColumnWidths<T>(\n  layout: CubeTableColumnLayout<T> | null,\n  base: Record<string, number>,\n): Record<string, number> {\n  return (layout?.columns ?? []).reduce<Record<string, number>>(\n    (widths, column) => {\n      if (!column.isStructural && column.width != null) {\n        widths[column.key] = Math.round(column.width);\n      }\n\n      return widths;\n    },\n    { ...base },\n  );\n}\n\n/**\n * Reads `key` as a data path. A plain key is a single property lookup; dots\n * walk nested objects (`'owner.name'`). Anything richer belongs in `getValue`.\n */\nexport function readPath(row: any, path: string): unknown {\n  if (row == null) return undefined;\n  if (!path.includes('.')) return row[path];\n\n  let current: any = row;\n\n  for (const part of path.split('.')) {\n    if (current == null) return undefined;\n    current = current[part];\n  }\n\n  return current;\n}\n\n/** Only the value-pipeline members, so both raw and resolved columns fit. */\ntype ValueColumn<T> = Pick<CubeTableColumn<T>, 'key' | 'getValue' | 'format'>;\n\nexport function getColumnValue<T>(\n  column: ValueColumn<T>,\n  row: T,\n  rowIndex: number,\n): unknown {\n  return column.getValue\n    ? column.getValue(row, rowIndex)\n    : readPath(row, column.key);\n}\n\n/**\n * Display text for a cell — what client sort, client search and TSV copy all\n * operate on. Deliberately NOT the rendered output: `render` may return\n * arbitrary React, and stringifying that is how cloud's filter ended up\n * matching `\"[object Object]\"` against the query `\"object\"`.\n *\n * Returns `null` when the column cannot produce text, so callers can skip it\n * rather than coerce a non-primitive.\n */\nexport function getColumnText<T>(\n  column: ValueColumn<T>,\n  row: T,\n  rowIndex: number,\n): string | null {\n  const value = getColumnValue(column, row, rowIndex);\n\n  if (column.format) return column.format(value, row, rowIndex);\n  if (value == null) return '';\n\n  const type = typeof value;\n\n  if (type === 'string') return value as string;\n  if (type === 'number' || type === 'boolean' || type === 'bigint') {\n    return String(value);\n  }\n  if (value instanceof Date) return value.toISOString();\n\n  return null;\n}\n\nfunction clamp(value: number, min: number, max: number | null): number {\n  return Math.min(Math.max(value, min), max ?? Number.POSITIVE_INFINITY);\n}\n\nexport interface UseTableColumnsOptions<T> {\n  columns: CubeTableColumn<T>[];\n  /** Content-box width of the scroller, or `null` before the first measure. */\n  containerWidth: number | null;\n  /** User-resized widths, keyed by column key. Wins over `column.width`. */\n  columnWidths?: Record<string, number>;\n  /** Extra leading columns owned by the table (selection, drag handle). */\n  leadingColumns?: CubeTableColumn<T>[];\n  /** Extra trailing columns owned by the table (row menu). */\n  trailingColumns?: CubeTableColumn<T>[];\n}\n\n/**\n * Normalizes the public column list into resolved leaves: visual order, ARIA\n * indices, pixel widths, and sticky offsets for pinned columns.\n *\n * Width resolution mirrors ag-grid's `fitGridWidth`: fixed columns take their\n * width, the remainder is split across flex columns by weight, and each result\n * is clamped to `[minWidth, maxWidth]`. Clamping perturbs the sum, so the\n * residual is redistributed across the still-unclamped columns until it\n * settles. When even the minimums do not fit, every column takes its minimum\n * and the table scrolls horizontally.\n */\nexport function useTableColumns<T>({\n  columns,\n  containerWidth,\n  columnWidths,\n  leadingColumns,\n  trailingColumns,\n}: UseTableColumnsOptions<T>): CubeTableColumnLayout<T> {\n  return useMemo(() => {\n    const visible = [\n      ...(leadingColumns ?? []),\n      ...columns,\n      ...(trailingColumns ?? []),\n    ].filter((column) => !column.isHidden);\n\n    // Pinned columns lead and trail regardless of their position in the source\n    // array, so `aria-colindex` and DOM order agree and nothing needs CSS\n    // `order:` to be reshuffled.\n    const ordered = [\n      ...visible.filter((c) => c.pin === 'start'),\n      ...visible.filter((c) => !c.pin),\n      ...visible.filter((c) => c.pin === 'end'),\n    ];\n\n    const structuralKeys = new Set(\n      [...(leadingColumns ?? []), ...(trailingColumns ?? [])].map((c) => c.key),\n    );\n\n    const specs = ordered.map((column) => {\n      const isStructural = structuralKeys.has(column.key);\n      const explicit = columnWidths?.[column.key] ?? column.width;\n      const minWidth =\n        column.minWidth ??\n        (explicit != null ? explicit : isStructural ? 0 : DEFAULT_MIN_WIDTH);\n\n      return {\n        column,\n        isStructural,\n        fixed: explicit ?? null,\n        minWidth,\n        maxWidth: column.maxWidth ?? null,\n        flex: explicit != null ? null : column.flex ?? 1,\n      };\n    });\n\n    const resolved = new Map<string, number>();\n    let isOverflowing = false;\n\n    if (containerWidth != null && containerWidth > 0) {\n      const fixedTotal = specs.reduce((sum, s) => sum + (s.fixed ?? 0), 0);\n      const flexSpecs = specs.filter((s) => s.fixed == null);\n      const minTotal = specs.reduce(\n        (sum, s) => sum + (s.fixed ?? s.minWidth),\n        0,\n      );\n\n      if (minTotal > containerWidth) {\n        isOverflowing = true;\n        for (const spec of specs) {\n          resolved.set(spec.column.key, spec.fixed ?? spec.minWidth);\n        }\n      } else {\n        let remaining = containerWidth - fixedTotal;\n        let pool = flexSpecs;\n\n        // Each pass assigns proportional widths, freezes whatever hit a bound,\n        // and re-splits the leftover among the rest.\n        while (pool.length > 0) {\n          const totalFlex = pool.reduce((sum, s) => sum + (s.flex ?? 1), 0);\n          const nextPool: typeof pool = [];\n          let consumed = 0;\n\n          for (const spec of pool) {\n            const ideal = (remaining * (spec.flex ?? 1)) / (totalFlex || 1);\n            const clamped = clamp(ideal, spec.minWidth, spec.maxWidth);\n\n            if (clamped !== ideal) {\n              resolved.set(spec.column.key, clamped);\n              consumed += clamped;\n            } else {\n              nextPool.push(spec);\n            }\n          }\n\n          if (nextPool.length === pool.length) {\n            // Nothing was clamped this pass — the proportional split stands.\n            const totalLeft = nextPool.reduce(\n              (sum, s) => sum + (s.flex ?? 1),\n              0,\n            );\n            for (const spec of nextPool) {\n              resolved.set(\n                spec.column.key,\n                (remaining * (spec.flex ?? 1)) / (totalLeft || 1),\n              );\n            }\n            break;\n          }\n\n          remaining -= consumed;\n          pool = nextPool;\n        }\n\n        for (const spec of specs) {\n          if (spec.fixed != null) resolved.set(spec.column.key, spec.fixed);\n        }\n      }\n    }\n\n    let pinnedStartWidth = 0;\n    let pinnedEndWidth = 0;\n\n    const out: CubeResolvedColumn<T>[] = specs.map((spec, index) => ({\n      ...spec.column,\n      index,\n      ariaColIndex: index + 1,\n      width: resolved.get(spec.column.key) ?? null,\n      minWidth: spec.minWidth,\n      maxWidth: spec.maxWidth,\n      flex: spec.flex,\n      align: spec.column.align ?? 'start',\n      pinOffset: null,\n      isPinEdge: false,\n      isStructural: spec.isStructural,\n    }));\n\n    // Sticky offsets accumulate inwards from each edge.\n    for (const column of out) {\n      if (column.pin !== 'start') continue;\n      column.pinOffset = pinnedStartWidth;\n      pinnedStartWidth += column.width ?? column.minWidth;\n    }\n\n    for (let i = out.length - 1; i >= 0; i--) {\n      const column = out[i];\n      if (column.pin !== 'end') continue;\n      column.pinOffset = pinnedEndWidth;\n      pinnedEndWidth += column.width ?? column.minWidth;\n    }\n\n    const lastPinnedStart = out.filter((c) => c.pin === 'start').at(-1);\n    const firstPinnedEnd = out.find((c) => c.pin === 'end');\n\n    if (lastPinnedStart) lastPinnedStart.isPinEdge = true;\n    if (firstPinnedEnd) firstPinnedEnd.isPinEdge = true;\n\n    const totalWidth = out.every((c) => c.width != null)\n      ? out.reduce((sum, c) => sum + (c.width ?? 0), 0)\n      : null;\n\n    return {\n      columns: out,\n      pinnedStartWidth,\n      pinnedEndWidth,\n      totalWidth,\n      isOverflowing,\n    };\n  }, [columns, containerWidth, columnWidths, leadingColumns, trailingColumns]);\n}\n"],"mappings":"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"}
+{"version":3,"file":"use-table-columns.js","names":["useMemo","CubeResolvedColumn","CubeTableColumn","CubeTableColumnLayout","DEFAULT_MIN_WIDTH","freezeColumnWidths","layout","T","base","Record","columns","reduce","widths","column","isStructural","width","key","Math","round","readPath","row","path","undefined","includes","current","part","split","ValueColumn","Pick","getColumnValue","rowIndex","getValue","getColumnText","value","format","type","String","Date","toISOString","clamp","min","max","Number","POSITIVE_INFINITY","UseTableColumnsOptions","containerWidth","columnWidths","leadingColumns","trailingColumns","useTableColumns","t0","$","_c","isOverflowing","out","pinnedEndWidth","pinnedStartWidth","t1","visible","filter","_temp","ordered","_temp2","_temp3","_temp4","structuralKeys","Set","map","_temp5","specs","column_0","has","explicit","minWidth","fixed","maxWidth","flex","resolved","Map","fixedTotal","_temp6","flexSpecs","_temp7","minTotal","_temp8","spec","set","remaining","pool","length","totalFlex","_temp9","nextPool","consumed","spec_0","ideal","clamped","push","totalLeft","_temp0","spec_1","spec_2","spec_3","index","ariaColIndex","get","align","pinOffset","isPinEdge","column_1","pin","i","column_2","lastPinnedStart","_temp1","at","firstPinnedEnd","find","_temp10","every","_temp11","_temp12","totalWidth","t2","sum_3","c_5","sum","c","c_6","c_4","c_3","sum_2","s_3","s","sum_1","s_2","sum_0","s_1","s_0","c_2","c_1","c_0","isHidden"],"sources":["../../../../src/components/data/TableBase/use-table-columns.ts"],"sourcesContent":["import { useMemo } from 'react';\n\nimport type {\n  CubeResolvedColumn,\n  CubeTableColumn,\n  CubeTableColumnLayout,\n} from './types';\n\n/** @default when a column declares neither `width` nor `minWidth`. */\nexport const DEFAULT_MIN_WIDTH = 150;\n\n/**\n * Every column's current width, so a resize can change exactly one of them.\n *\n * A column with no explicit width is `flex: 1` and shares the leftover (see the\n * spec builder below). Making only the DRAGGED column fixed leaves every other\n * one in the flex pool, re-splitting a leftover that just changed — so one\n * divider moved all of them, including columns to the LEFT of the handle, which\n * cannot be what dragging a right edge means. Measured before this existed:\n * dragging column B by +8px took 3px off A, C and D each.\n *\n * Freezing first means a drag changes one width. Columns after it are pushed\n * along, which is what being after it means, and the table grows or shrinks\n * rather than the neighbours absorbing the difference.\n *\n * Structural columns are skipped — they are sized by the table, not the user.\n */\nexport function freezeColumnWidths<T>(\n  layout: CubeTableColumnLayout<T> | null,\n  base: Record<string, number>,\n): Record<string, number> {\n  return (layout?.columns ?? []).reduce<Record<string, number>>(\n    (widths, column) => {\n      if (!column.isStructural && column.width != null) {\n        widths[column.key] = Math.round(column.width);\n      }\n\n      return widths;\n    },\n    { ...base },\n  );\n}\n\n/**\n * Reads `key` as a data path. A plain key is a single property lookup; dots\n * walk nested objects (`'owner.name'`). Anything richer belongs in `getValue`.\n */\nexport function readPath(row: any, path: string): unknown {\n  if (row == null) return undefined;\n  if (!path.includes('.')) return row[path];\n\n  let current: any = row;\n\n  for (const part of path.split('.')) {\n    if (current == null) return undefined;\n    current = current[part];\n  }\n\n  return current;\n}\n\n/** Only the value-pipeline members, so both raw and resolved columns fit. */\ntype ValueColumn<T> = Pick<CubeTableColumn<T>, 'key' | 'getValue' | 'format'>;\n\nexport function getColumnValue<T>(\n  column: ValueColumn<T>,\n  row: T,\n  rowIndex: number,\n): unknown {\n  return column.getValue\n    ? column.getValue(row, rowIndex)\n    : readPath(row, column.key);\n}\n\n/**\n * Display text for a cell — what client sort, client search and TSV copy all\n * operate on. Deliberately NOT the rendered output: `render` may return\n * arbitrary React, and stringifying that is how cloud's filter ended up\n * matching `\"[object Object]\"` against the query `\"object\"`.\n *\n * Returns `null` when the column cannot produce text, so callers can skip it\n * rather than coerce a non-primitive.\n */\nexport function getColumnText<T>(\n  column: ValueColumn<T>,\n  row: T,\n  rowIndex: number,\n): string | null {\n  const value = getColumnValue(column, row, rowIndex);\n\n  if (column.format) return column.format(value, row, rowIndex);\n  if (value == null) return '';\n\n  const type = typeof value;\n\n  if (type === 'string') return value as string;\n  if (type === 'number' || type === 'boolean' || type === 'bigint') {\n    return String(value);\n  }\n  if (value instanceof Date) return value.toISOString();\n\n  return null;\n}\n\nfunction clamp(value: number, min: number, max: number | null): number {\n  return Math.min(Math.max(value, min), max ?? Number.POSITIVE_INFINITY);\n}\n\nexport interface UseTableColumnsOptions<T> {\n  columns: CubeTableColumn<T>[];\n  /** Content-box width of the scroller, or `null` before the first measure. */\n  containerWidth: number | null;\n  /** User-resized widths, keyed by column key. Wins over `column.width`. */\n  columnWidths?: Record<string, number>;\n  /** Extra leading columns owned by the table (selection, drag handle). */\n  leadingColumns?: CubeTableColumn<T>[];\n  /** Extra trailing columns owned by the table (row menu). */\n  trailingColumns?: CubeTableColumn<T>[];\n}\n\n/**\n * Normalizes the public column list into resolved leaves: visual order, ARIA\n * indices, pixel widths, and sticky offsets for pinned columns.\n *\n * Width resolution mirrors ag-grid's `fitGridWidth`: fixed columns take their\n * width, the remainder is split across flex columns by weight, and each result\n * is clamped to `[minWidth, maxWidth]`. Clamping perturbs the sum, so the\n * residual is redistributed across the still-unclamped columns until it\n * settles. When even the minimums do not fit, every column takes its minimum\n * and the table scrolls horizontally.\n */\nexport function useTableColumns<T>({\n  columns,\n  containerWidth,\n  columnWidths,\n  leadingColumns,\n  trailingColumns,\n}: UseTableColumnsOptions<T>): CubeTableColumnLayout<T> {\n  return useMemo(() => {\n    const visible = [\n      ...(leadingColumns ?? []),\n      ...columns,\n      ...(trailingColumns ?? []),\n    ].filter((column) => !column.isHidden);\n\n    // Pinned columns lead and trail regardless of their position in the source\n    // array, so `aria-colindex` and DOM order agree and nothing needs CSS\n    // `order:` to be reshuffled.\n    const ordered = [\n      ...visible.filter((c) => c.pin === 'start'),\n      ...visible.filter((c) => !c.pin),\n      ...visible.filter((c) => c.pin === 'end'),\n    ];\n\n    const structuralKeys = new Set(\n      [...(leadingColumns ?? []), ...(trailingColumns ?? [])].map((c) => c.key),\n    );\n\n    const specs = ordered.map((column) => {\n      const isStructural = structuralKeys.has(column.key);\n      const explicit = columnWidths?.[column.key] ?? column.width;\n      const minWidth =\n        column.minWidth ??\n        (explicit != null ? explicit : isStructural ? 0 : DEFAULT_MIN_WIDTH);\n\n      return {\n        column,\n        isStructural,\n        fixed: explicit ?? null,\n        minWidth,\n        maxWidth: column.maxWidth ?? null,\n        flex: explicit != null ? null : column.flex ?? 1,\n      };\n    });\n\n    const resolved = new Map<string, number>();\n    let isOverflowing = false;\n\n    if (containerWidth != null && containerWidth > 0) {\n      const fixedTotal = specs.reduce((sum, s) => sum + (s.fixed ?? 0), 0);\n      const flexSpecs = specs.filter((s) => s.fixed == null);\n      const minTotal = specs.reduce(\n        (sum, s) => sum + (s.fixed ?? s.minWidth),\n        0,\n      );\n\n      if (minTotal > containerWidth) {\n        isOverflowing = true;\n        for (const spec of specs) {\n          resolved.set(spec.column.key, spec.fixed ?? spec.minWidth);\n        }\n      } else {\n        let remaining = containerWidth - fixedTotal;\n        let pool = flexSpecs;\n\n        // Each pass assigns proportional widths, freezes whatever hit a bound,\n        // and re-splits the leftover among the rest.\n        while (pool.length > 0) {\n          const totalFlex = pool.reduce((sum, s) => sum + (s.flex ?? 1), 0);\n          const nextPool: typeof pool = [];\n          let consumed = 0;\n\n          for (const spec of pool) {\n            const ideal = (remaining * (spec.flex ?? 1)) / (totalFlex || 1);\n            const clamped = clamp(ideal, spec.minWidth, spec.maxWidth);\n\n            if (clamped !== ideal) {\n              resolved.set(spec.column.key, clamped);\n              consumed += clamped;\n            } else {\n              nextPool.push(spec);\n            }\n          }\n\n          if (nextPool.length === pool.length) {\n            // Nothing was clamped this pass — the proportional split stands.\n            const totalLeft = nextPool.reduce(\n              (sum, s) => sum + (s.flex ?? 1),\n              0,\n            );\n            for (const spec of nextPool) {\n              resolved.set(\n                spec.column.key,\n                (remaining * (spec.flex ?? 1)) / (totalLeft || 1),\n              );\n            }\n            break;\n          }\n\n          remaining -= consumed;\n          pool = nextPool;\n        }\n\n        for (const spec of specs) {\n          if (spec.fixed != null) resolved.set(spec.column.key, spec.fixed);\n        }\n      }\n    }\n\n    let pinnedStartWidth = 0;\n    let pinnedEndWidth = 0;\n\n    const out: CubeResolvedColumn<T>[] = specs.map((spec, index) => ({\n      ...spec.column,\n      index,\n      ariaColIndex: index + 1,\n      width: resolved.get(spec.column.key) ?? null,\n      minWidth: spec.minWidth,\n      maxWidth: spec.maxWidth,\n      flex: spec.flex,\n      align: spec.column.align ?? 'start',\n      pinOffset: null,\n      isPinEdge: false,\n      isStructural: spec.isStructural,\n    }));\n\n    // Sticky offsets accumulate inwards from each edge.\n    for (const column of out) {\n      if (column.pin !== 'start') continue;\n      column.pinOffset = pinnedStartWidth;\n      pinnedStartWidth += column.width ?? column.minWidth;\n    }\n\n    for (let i = out.length - 1; i >= 0; i--) {\n      const column = out[i];\n      if (column.pin !== 'end') continue;\n      column.pinOffset = pinnedEndWidth;\n      pinnedEndWidth += column.width ?? column.minWidth;\n    }\n\n    const lastPinnedStart = out.filter((c) => c.pin === 'start').at(-1);\n    const firstPinnedEnd = out.find((c) => c.pin === 'end');\n\n    if (lastPinnedStart) lastPinnedStart.isPinEdge = true;\n    if (firstPinnedEnd) firstPinnedEnd.isPinEdge = true;\n\n    const totalWidth = out.every((c) => c.width != null)\n      ? out.reduce((sum, c) => sum + (c.width ?? 0), 0)\n      : null;\n\n    return {\n      columns: out,\n      pinnedStartWidth,\n      pinnedEndWidth,\n      totalWidth,\n      isOverflowing,\n    };\n  }, [columns, containerWidth, columnWidths, leadingColumns, trailingColumns]);\n}\n"],"mappings":"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"}

package/dist/components/data/TableBase/use-table-search.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.182.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.183.0 | Cube Dev Team */
 import { useEvent } from "../../../_internal/hooks/use-event.js";
 import { useDebouncedValue } from "../../../_internal/hooks/use-debounced-value.js";
 import { getColumnText } from "./use-table-columns.js";

package/dist/components/data/TableBase/use-table-search.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-table-search.js","names":[],"sources":["../../../../src/components/data/TableBase/use-table-search.ts"],"sourcesContent":["import { useControlledState } from '@react-stately/utils';\nimport { useEffect, useMemo, useRef, useState } from 'react';\n\nimport { useDebouncedValue, useEvent } from '../../../_internal/hooks';\n\nimport { getColumnText } from './use-table-columns';\n\nimport type { CubeTableColumn } from './types';\n\nexport type CubeTableSearchMode = 'client' | 'server';\n\nexport interface UseTableSearchOptions<T> {\n  columns: CubeTableColumn<T>[];\n  rows: readonly T[];\n  /** @default 'client' */\n  mode?: CubeTableSearchMode;\n  value?: string;\n  defaultValue?: string;\n  onChange?: (value: string) => void;\n  /** Debounces the filter AND the callback, in both modes. @default 500 */\n  delay?: number;\n  /** Replaces the default matcher in client mode. */\n  filter?: (row: T, query: string) => boolean;\n}\n\nexport interface UseTableSearchResult<T> {\n  /** The immediate term — what the input shows. */\n  searchValue: string;\n  setSearchValue: (value: string) => void;\n  /** The debounced term — what the filter and the callback act on. */\n  query: string;\n  /** Filtered in client mode; the original array otherwise. */\n  searchedRows: readonly T[];\n  /** `true` when a non-empty term is narrowing the data. */\n  isFiltered: boolean;\n}\n\n/**\n * Default matcher: a case-insensitive substring test against each searchable\n * column's **display text**.\n *\n * Deliberately not the raw value. Cloud's filter tested\n * `String(row[column.key])`, which meant a column rendering `owner.profile.name`\n * was unsearchable, and an object-valued column stringified to\n * `\"[object Object]\"` — so the query \"object\" matched every row with a nested\n * value. `getColumnText` returns `null` for anything it cannot honestly turn\n * into text, and those columns are skipped rather than coerced.\n */\nexport function matchesTableSearch<T>(\n  columns: CubeTableColumn<T>[],\n  row: T,\n  rowIndex: number,\n  query: string,\n): boolean {\n  return columns.some((column) => {\n    if (column.isSearchable === false) return false;\n\n    const text = getColumnText(column, row, rowIndex);\n\n    return text != null && text.toLowerCase().includes(query);\n  });\n}\n\nexport function useTableSearch<T>({\n  columns,\n  rows,\n  mode = 'client',\n  value,\n  defaultValue,\n  onChange,\n  delay = 500,\n  filter,\n}: UseTableSearchOptions<T>): UseTableSearchResult<T> {\n  const [committed, setCommitted] = useControlledState<string>(\n    value as string,\n    defaultValue ?? '',\n    onChange as (v: string) => void,\n  );\n\n  // What the input shows, updated on every keystroke. The committed value —\n  // the one `onChange` reports and the filter runs on — trails it by `delay`.\n  //\n  // Two separate values rather than one, because `useControlledState` calls\n  // `onChange` the moment it is set: routing keystrokes straight into it fired\n  // a request per character in `searchMode=\"server\"`, which is the thing the\n  // debounce exists to prevent. Debouncing the input itself instead would make\n  // typing lag, so the split is the point.\n  const [draft, setDraft] = useState(committed);\n  const debounced = useDebouncedValue(draft, delay);\n\n  // What we last pushed outward, so the sync below can tell a genuine external\n  // change from the echo of our own debounce.\n  const pushedRef = useRef(committed);\n\n  // A controlled `searchValue` changing from OUTSIDE — a cleared filter, a\n  // restored URL — wins over whatever is half-typed.\n  //\n  // The echo has to be filtered out or this reverts the input mid-word: with a\n  // short delay the debounce commits letter 1 while letter 2 is already typed,\n  // and syncing unconditionally puts letter 1 back. At `searchDelay={0}` that\n  // happens on every keystroke and nothing longer than one character can ever\n  // be typed.\n  useEffect(() => {\n    if (committed === pushedRef.current) return;\n\n    pushedRef.current = committed;\n    setDraft(committed);\n  }, [committed]);\n\n  useEffect(() => {\n    if (debounced === pushedRef.current) return;\n\n    pushedRef.current = debounced;\n    setCommitted(debounced);\n    // `committed` is deliberately not a dependency: reacting to it here would\n    // fight the effect above and push a stale draft back out.\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [debounced]);\n\n  const searchValue = draft;\n  const query = debounced.trim().toLowerCase();\n\n  const setSearchValue = useEvent((next: string) => setDraft(next));\n\n  const searchedRows = useMemo(() => {\n    if (mode !== 'client' || !query) return rows;\n\n    return rows.filter((row, index) =>\n      filter\n        ? filter(row, query)\n        : matchesTableSearch(columns, row, index, query),\n    );\n  }, [mode, query, rows, columns, filter]);\n\n  return {\n    searchValue,\n    setSearchValue,\n    query,\n    searchedRows,\n    isFiltered: query.length > 0,\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAgDA,SAAgB,mBACd,SACA,KACA,UACA,OACS;AACT,QAAO,QAAQ,MAAM,WAAW;AAC9B,MAAI,OAAO,iBAAiB,MAAO,QAAO;EAE1C,MAAM,OAAO,cAAc,QAAQ,KAAK,SAAS;AAEjD,SAAO,QAAQ,QAAQ,KAAK,aAAa,CAAC,SAAS,MAAM;GACzD;;AAGJ,SAAgB,eAAkB,EAChC,SACA,MACA,OAAO,UACP,OACA,cACA,UACA,QAAQ,KACR,UACoD;CACpD,MAAM,CAAC,WAAW,gBAAgB,mBAChC,OACA,gBAAgB,IAChB,SACD;CAUD,MAAM,CAAC,OAAO,YAAY,SAAS,UAAU;CAC7C,MAAM,YAAY,kBAAkB,OAAO,MAAM;CAIjD,MAAM,YAAY,OAAO,UAAU;AAUnC,iBAAgB;AACd,MAAI,cAAc,UAAU,QAAS;AAErC,YAAU,UAAU;AACpB,WAAS,UAAU;IAClB,CAAC,UAAU,CAAC;AAEf,iBAAgB;AACd,MAAI,cAAc,UAAU,QAAS;AAErC,YAAU,UAAU;AACpB,eAAa,UAAU;IAItB,CAAC,UAAU,CAAC;CAEf,MAAM,cAAc;CACpB,MAAM,QAAQ,UAAU,MAAM,CAAC,aAAa;AAc5C,QAAO;EACL;EACA,gBAdqB,UAAU,SAAiB,SAAS,KAAK,CAAC;EAe/D;EACA,cAdmB,cAAc;AACjC,OAAI,SAAS,YAAY,CAAC,MAAO,QAAO;AAExC,UAAO,KAAK,QAAQ,KAAK,UACvB,SACI,OAAO,KAAK,MAAM,GAClB,mBAAmB,SAAS,KAAK,OAAO,MAAM,CACnD;KACA;GAAC;GAAM;GAAO;GAAM;GAAS;GAAO,CAAC;EAOtC,YAAY,MAAM,SAAS;EAC5B"}
+{"version":3,"file":"use-table-search.js","names":["useControlledState","useEffect","useMemo","useRef","useState","useDebouncedValue","useEvent","getColumnText","CubeTableColumn","CubeTableSearchMode","UseTableSearchOptions","columns","T","rows","mode","value","defaultValue","onChange","delay","filter","row","query","UseTableSearchResult","searchValue","setSearchValue","searchedRows","isFiltered","matchesTableSearch","rowIndex","some","column","isSearchable","text","toLowerCase","includes","useTableSearch","committed","setCommitted","v","draft","setDraft","debounced","pushedRef","current","trim","next","index","length"],"sources":["../../../../src/components/data/TableBase/use-table-search.ts"],"sourcesContent":["import { useControlledState } from '@react-stately/utils';\nimport { useEffect, useMemo, useRef, useState } from 'react';\n\nimport { useDebouncedValue, useEvent } from '../../../_internal/hooks';\n\nimport { getColumnText } from './use-table-columns';\n\nimport type { CubeTableColumn } from './types';\n\nexport type CubeTableSearchMode = 'client' | 'server';\n\nexport interface UseTableSearchOptions<T> {\n  columns: CubeTableColumn<T>[];\n  rows: readonly T[];\n  /** @default 'client' */\n  mode?: CubeTableSearchMode;\n  value?: string;\n  defaultValue?: string;\n  onChange?: (value: string) => void;\n  /** Debounces the filter AND the callback, in both modes. @default 500 */\n  delay?: number;\n  /** Replaces the default matcher in client mode. */\n  filter?: (row: T, query: string) => boolean;\n}\n\nexport interface UseTableSearchResult<T> {\n  /** The immediate term — what the input shows. */\n  searchValue: string;\n  setSearchValue: (value: string) => void;\n  /** The debounced term — what the filter and the callback act on. */\n  query: string;\n  /** Filtered in client mode; the original array otherwise. */\n  searchedRows: readonly T[];\n  /** `true` when a non-empty term is narrowing the data. */\n  isFiltered: boolean;\n}\n\n/**\n * Default matcher: a case-insensitive substring test against each searchable\n * column's **display text**.\n *\n * Deliberately not the raw value. Cloud's filter tested\n * `String(row[column.key])`, which meant a column rendering `owner.profile.name`\n * was unsearchable, and an object-valued column stringified to\n * `\"[object Object]\"` — so the query \"object\" matched every row with a nested\n * value. `getColumnText` returns `null` for anything it cannot honestly turn\n * into text, and those columns are skipped rather than coerced.\n */\nexport function matchesTableSearch<T>(\n  columns: CubeTableColumn<T>[],\n  row: T,\n  rowIndex: number,\n  query: string,\n): boolean {\n  return columns.some((column) => {\n    if (column.isSearchable === false) return false;\n\n    const text = getColumnText(column, row, rowIndex);\n\n    return text != null && text.toLowerCase().includes(query);\n  });\n}\n\nexport function useTableSearch<T>({\n  columns,\n  rows,\n  mode = 'client',\n  value,\n  defaultValue,\n  onChange,\n  delay = 500,\n  filter,\n}: UseTableSearchOptions<T>): UseTableSearchResult<T> {\n  const [committed, setCommitted] = useControlledState<string>(\n    value as string,\n    defaultValue ?? '',\n    onChange as (v: string) => void,\n  );\n\n  // What the input shows, updated on every keystroke. The committed value —\n  // the one `onChange` reports and the filter runs on — trails it by `delay`.\n  //\n  // Two separate values rather than one, because `useControlledState` calls\n  // `onChange` the moment it is set: routing keystrokes straight into it fired\n  // a request per character in `searchMode=\"server\"`, which is the thing the\n  // debounce exists to prevent. Debouncing the input itself instead would make\n  // typing lag, so the split is the point.\n  const [draft, setDraft] = useState(committed);\n  const debounced = useDebouncedValue(draft, delay);\n\n  // What we last pushed outward, so the sync below can tell a genuine external\n  // change from the echo of our own debounce.\n  const pushedRef = useRef(committed);\n\n  // A controlled `searchValue` changing from OUTSIDE — a cleared filter, a\n  // restored URL — wins over whatever is half-typed.\n  //\n  // The echo has to be filtered out or this reverts the input mid-word: with a\n  // short delay the debounce commits letter 1 while letter 2 is already typed,\n  // and syncing unconditionally puts letter 1 back. At `searchDelay={0}` that\n  // happens on every keystroke and nothing longer than one character can ever\n  // be typed.\n  useEffect(() => {\n    if (committed === pushedRef.current) return;\n\n    pushedRef.current = committed;\n    setDraft(committed);\n  }, [committed]);\n\n  useEffect(() => {\n    if (debounced === pushedRef.current) return;\n\n    pushedRef.current = debounced;\n    setCommitted(debounced);\n    // `committed` is deliberately not a dependency: reacting to it here would\n    // fight the effect above and push a stale draft back out.\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [debounced]);\n\n  const searchValue = draft;\n  const query = debounced.trim().toLowerCase();\n\n  const setSearchValue = useEvent((next: string) => setDraft(next));\n\n  const searchedRows = useMemo(() => {\n    if (mode !== 'client' || !query) return rows;\n\n    return rows.filter((row, index) =>\n      filter\n        ? filter(row, query)\n        : matchesTableSearch(columns, row, index, query),\n    );\n  }, [mode, query, rows, columns, filter]);\n\n  return {\n    searchValue,\n    setSearchValue,\n    query,\n    searchedRows,\n    isFiltered: query.length > 0,\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAgDA,SAAgB2B,mBACdhB,SACAS,KACAQ,UACAP,OACS;AACT,QAAOV,QAAQkB,MAAMC,WAAW;AAC9B,MAAIA,OAAOC,iBAAiB,MAAO,QAAO;EAE1C,MAAMC,OAAOzB,cAAcuB,QAAQV,KAAKQ,SAAS;AAEjD,SAAOI,QAAQ,QAAQA,KAAKC,aAAa,CAACC,SAASb,MAAM;GACzD;;AAGJ,SAAgBc,eAAkB,EAChCxB,SACAE,MACAC,OAAO,UACPC,OACAC,cACAC,UACAC,QAAQ,KACRC,UACoD;CACpD,MAAM,CAACiB,WAAWC,gBAAgBrC,mBAChCe,OACAC,gBAAgB,IAChBC,SACD;CAUD,MAAM,CAACsB,OAAOC,YAAYpC,SAASgC,UAAU;CAC7C,MAAMK,YAAYpC,kBAAkBkC,OAAOrB,MAAM;CAIjD,MAAMwB,YAAYvC,OAAOiC,UAAU;AAUnCnC,iBAAgB;AACd,MAAImC,cAAcM,UAAUC,QAAS;AAErCD,YAAUC,UAAUP;AACpBI,WAASJ,UAAU;IAClB,CAACA,UAAU,CAAC;AAEfnC,iBAAgB;AACd,MAAIwC,cAAcC,UAAUC,QAAS;AAErCD,YAAUC,UAAUF;AACpBJ,eAAaI,UAAU;IAItB,CAACA,UAAU,CAAC;CAEf,MAAMlB,cAAcgB;CACpB,MAAMlB,QAAQoB,UAAUG,MAAM,CAACX,aAAa;AAc5C,QAAO;EACLV;EACAC,gBAdqBlB,UAAUuC,SAAiBL,SAASK,KAAK,CAAC;EAe/DxB;EACAI,cAdmBvB,cAAc;AACjC,OAAIY,SAAS,YAAY,CAACO,MAAO,QAAOR;AAExC,UAAOA,KAAKM,QAAQC,KAAK0B,UACvB3B,SACIA,OAAOC,KAAKC,MAAM,GAClBM,mBAAmBhB,SAASS,KAAK0B,OAAOzB,MAC9C,CAAC;KACA;GAACP;GAAMO;GAAOR;GAAMF;GAASQ;GAAO,CAAC;EAOtCO,YAAYL,MAAM0B,SAAS;EAC5B"}

package/dist/components/data/TableBase/use-table-selection.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.182.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.183.0 | Cube Dev Team */
 import { useEvent } from "../../../_internal/hooks/use-event.js";
 import { RowCollection } from "./RowCollection.js";
 import { useCallback, useMemo, useRef } from "react";
@@ -105,7 +105,7 @@ function useTableSelection(options) {
 		filteredRowKeys,
 		getRowKey
 	]);
-	const visibleGetRowKey = useCallback((row, index) => rowKeys?.[index] ?? getRowKey(row, index), [rowKeys, getRowKey]);
+	const visibleGetRowKey = useCallback((row_0, index_0) => rowKeys?.[index_0] ?? getRowKey(row_0, index_0), [rowKeys, getRowKey]);
 	const collection = useMemo(() => new RowCollection(rows, visibleGetRowKey, unselectableKeys), [
 		rows,
 		visibleGetRowKey,
@@ -113,8 +113,8 @@ function useTableSelection(options) {
 	]);
 	const rowByKey = useMemo(() => {
 		const map = /* @__PURE__ */ new Map();
-		filteredRows.forEach((row, index) => map.set(filteredRowKeys?.[index] ?? getRowKey(row, index), row));
-		rows.forEach((row, index) => map.set(rowKeys?.[index] ?? getRowKey(row, index), row));
+		filteredRows.forEach((row_1, index_1) => map.set(filteredRowKeys?.[index_1] ?? getRowKey(row_1, index_1), row_1));
+		rows.forEach((row_2, index_2) => map.set(rowKeys?.[index_2] ?? getRowKey(row_2, index_2), row_2));
 		return map;
 	}, [
 		rows,
@@ -143,14 +143,14 @@ function useTableSelection(options) {
 	*/
 	const anchorRef = useRef(null);
 	const extentRef = useRef(null);
-	const handleSelectionChange = useEvent((keys) => {
+	const handleSelectionChange = useEvent((keys_0) => {
 		if (!onSelectionChange) return;
-		if (keys === "all") {
+		if (keys_0 === "all") {
 			onSelectionChange("all", [...rowByKeyRef.current.values()]);
 			return;
 		}
-		const list = [...keys];
-		onSelectionChange(list, list.map((key) => rowByKeyRef.current.get(key)).filter((row) => row !== void 0));
+		const list = [...keys_0];
+		onSelectionChange(list, list.map((key) => rowByKeyRef.current.get(key)).filter((row_3) => row_3 !== void 0));
 	});
 	const state = useMultipleSelectionState({
 		selectionMode,
@@ -166,14 +166,14 @@ function useTableSelection(options) {
 	const isCascade = tree?.behavior === "cascade" && selectionMode === "multiple";
 	const derivedSelection = useMemo(() => {
 		if (isAll) return {
-			checked: new Set([...rowByKey.keys()].filter((key) => !unselectableKeys.has(key))),
+			checked: new Set([...rowByKey.keys()].filter((key_0) => !unselectableKeys.has(key_0))),
 			indeterminate: /* @__PURE__ */ new Set()
 		};
 		if (!isCascade || !tree) return {
 			checked: new Set(selectedKeys),
 			indeterminate: /* @__PURE__ */ new Set()
 		};
-		return deriveTreeSelection(selectedKeys, tree.rootKeys, tree.childrenOf, (key) => !unselectableKeys.has(key));
+		return deriveTreeSelection(selectedKeys, tree.rootKeys, tree.childrenOf, (key_1) => !unselectableKeys.has(key_1));
 	}, [
 		isAll,
 		isCascade,
@@ -182,19 +182,19 @@ function useTableSelection(options) {
 		rowByKey,
 		unselectableKeys
 	]);
-	const canSelect = useCallback((key) => isEnabled && !unselectableKeys.has(key), [isEnabled, unselectableKeys]);
-	const isSelected = useCallback((key) => isAll ? canSelect(key) : derivedSelection.checked.has(key), [
+	const canSelect = useCallback((key_2) => isEnabled && !unselectableKeys.has(key_2), [isEnabled, unselectableKeys]);
+	const isSelected = useCallback((key_3) => isAll ? canSelect(key_3) : derivedSelection.checked.has(key_3), [
 		isAll,
 		derivedSelection,
 		canSelect
 	]);
-	const isIndeterminate = useCallback((key) => derivedSelection.indeterminate.has(key), [derivedSelection]);
+	const isIndeterminate = useCallback((key_4) => derivedSelection.indeterminate.has(key_4), [derivedSelection]);
 	/** Keys the header checkbox acts on, which is what `selectAllMode` decides. */
 	const scopeKeys = useMemo(() => {
 		if (!isEnabled || selectionMode === "single") return [];
 		const source = selectAllMode === "page" ? pageRows : filteredRows;
 		const sourceKeys = selectAllMode === "page" ? pageRowKeys : filteredRowKeys;
-		return source.map((row, index) => sourceKeys?.[index] ?? getRowKey(row, index)).filter((key) => !unselectableKeys.has(key));
+		return source.map((row_4, index_3) => sourceKeys?.[index_3] ?? getRowKey(row_4, index_3)).filter((key_5) => !unselectableKeys.has(key_5));
 	}, [
 		isEnabled,
 		selectionMode,
@@ -211,7 +211,7 @@ function useTableSelection(options) {
 		if (!scopeKeys.length) return "none";
 		const set = derivedSelection.checked;
 		let count = 0;
-		for (const key of scopeKeys) if (set.has(key)) count++;
+		for (const key_6 of scopeKeys) if (set.has(key_6)) count++;
 		return count === 0 ? "none" : count === scopeKeys.length ? "all" : "some";
 	}, [
 		isAll,
@@ -230,8 +230,8 @@ function useTableSelection(options) {
 			return;
 		}
 		const next = new Set(isAll ? [] : derivedSelection.checked);
-		scopeKeys.forEach((key) => next.add(key));
-		state.setSelectedKeys(isCascade && tree ? deriveTreeSelection(next, tree.rootKeys, tree.childrenOf, (key) => !unselectableKeys.has(key)).checked : next);
+		scopeKeys.forEach((key_7) => next.add(key_7));
+		state.setSelectedKeys(isCascade && tree ? deriveTreeSelection(next, tree.rootKeys, tree.childrenOf, (key_8) => !unselectableKeys.has(key_8)).checked : next);
 	});
 	const clearSelection = useEvent(() => {
 		anchorRef.current = null;
@@ -258,51 +258,51 @@ function useTableSelection(options) {
 		for (let i = lo; i <= hi; i++) range.push(all[i]);
 		return range;
 	}, [collection]);
-	const toggleRow = useEvent((key) => {
-		if (!canSelect(key)) return;
+	const toggleRow = useEvent((key_9) => {
+		if (!canSelect(key_9)) return;
 		if (selectionMode === "single") {
-			state.setSelectedKeys(isSelected(key) ? /* @__PURE__ */ new Set() : new Set([key]));
+			state.setSelectedKeys(isSelected(key_9) ? /* @__PURE__ */ new Set() : new Set([key_9]));
 			return;
 		}
-		const applyCascade = (set, target, value) => {
+		const applyCascade = (set_0, target, value) => {
 			if (!canSelect(target)) return;
-			if (value) set.add(target);
+			if (value) set_0.add(target);
 			else {
-				set.delete(target);
+				set_0.delete(target);
 				if (isCascade && tree) {
 					let parent = tree.parentOf.get(target);
 					while (parent != null) {
-						set.delete(parent);
+						set_0.delete(parent);
 						parent = tree.parentOf.get(parent);
 					}
 				}
 			}
 			if (!isCascade || !tree) return;
-			(tree.childrenOf.get(target) ?? []).forEach((child) => applyCascade(set, child, value));
+			(tree.childrenOf.get(target) ?? []).forEach((child) => applyCascade(set_0, child, value));
 		};
-		const normalizeCascade = (set) => isCascade && tree ? deriveTreeSelection(set, tree.rootKeys, tree.childrenOf, (candidate) => !unselectableKeys.has(candidate)).checked : set;
+		const normalizeCascade = (set_1) => isCascade && tree ? deriveTreeSelection(set_1, tree.rootKeys, tree.childrenOf, (candidate) => !unselectableKeys.has(candidate)).checked : set_1;
 		const anchor = anchorRef.current;
 		if (shiftRef.current && anchor != null && collection.indexOf(anchor) >= 0) {
-			const next = new Set(isAll ? scopeKeys : derivedSelection.checked);
-			if (extentRef.current != null) keysBetween(anchor, extentRef.current).forEach((k) => applyCascade(next, k, false));
-			keysBetween(anchor, key).forEach((k) => {
-				applyCascade(next, k, true);
+			const next_0 = new Set(isAll ? scopeKeys : derivedSelection.checked);
+			if (extentRef.current != null) keysBetween(anchor, extentRef.current).forEach((k) => applyCascade(next_0, k, false));
+			keysBetween(anchor, key_9).forEach((k_0) => {
+				applyCascade(next_0, k_0, true);
 			});
-			extentRef.current = key;
-			state.setSelectedKeys(normalizeCascade(next));
+			extentRef.current = key_9;
+			state.setSelectedKeys(normalizeCascade(next_0));
 			return;
 		}
-		anchorRef.current = key;
+		anchorRef.current = key_9;
 		extentRef.current = null;
 		if (isCascade) {
-			const next = new Set(derivedSelection.checked);
-			applyCascade(next, key, !derivedSelection.checked.has(key));
-			state.setSelectedKeys(normalizeCascade(next));
-		} else selectionManager.toggleSelection(key);
+			const next_1 = new Set(derivedSelection.checked);
+			applyCascade(next_1, key_9, !derivedSelection.checked.has(key_9));
+			state.setSelectedKeys(normalizeCascade(next_1));
+		} else selectionManager.toggleSelection(key_9);
 	});
 	const selectedRows = useMemo(() => {
 		if (isAll) return [...rowByKey.values()];
-		return [...derivedSelection.checked].map((key) => rowByKey.get(key)).filter((row) => row !== void 0);
+		return [...derivedSelection.checked].map((key_10) => rowByKey.get(key_10)).filter((row_5) => row_5 !== void 0);
 	}, [
 		isAll,
 		derivedSelection,
@@ -316,7 +316,7 @@ function useTableSelection(options) {
 		isSelected,
 		isIndeterminate,
 		canSelect,
-		isRowDisabled: useCallback((key) => hardDisabledKeys.has(key), [hardDisabledKeys]),
+		isRowDisabled: useCallback((key_11) => hardDisabledKeys.has(key_11), [hardDisabledKeys]),
 		toggleRow,
 		captureShift,
 		selectAllState,