@redsift/table-pro 12.5.4

package/index.js

@@ -0,0 +1,721 @@
+import { o as operatorList, D as DOES_NOT_CONTAIN, a as DOES_NOT_EQUAL, b as DOES_NOT_START_WITH, c as DOES_NOT_END_WITH, I as IS_ANY_OF, d as IS_NOT_ANY_OF, C as CONTAINS_ANY_OF, e as DOES_NOT_CONTAIN_ANY_OF, S as STARTS_WITH_ANY_OF, f as DOES_NOT_START_WITH_ANY_OF, E as ENDS_WITH_ANY_OF, g as DOES_NOT_END_WITH_ANY_OF, h as IS_BETWEEN, i as IS_WITH_SELECT, j as IS_NOT_WITH_SELECT, k as IS_ANY_OF_WITH_SELECT, l as IS_NOT_ANY_OF_WITH_SELECT, A as ARRAY_IS_EMPTY, m as ARRAY_IS_NOT_EMPTY, H as HAS_WITH_SELECT, n as DOES_NOT_HAVE_WITH_SELECT, p as HAS_ANY_OF_WITH_SELECT, q as HAS_ALL_OF_WITH_SELECT, r as DOES_NOT_HAVE_ANY_OF_WITH_SELECT, s as HAS_ONLY_WITH_SELECT, t as HAS, u as DOES_NOT_HAVE, v as HAS_ANY_OF, w as HAS_ALL_OF, x as DOES_NOT_HAVE_ANY_OF, y as HAS_ONLY } from './_internal/StatefulDataGrid2.js';
+export { A as ARRAY_IS_EMPTY, m as ARRAY_IS_NOT_EMPTY, W as CATEGORIES, U as COLUMN_ORDER_MODEL_KEY, C as CONTAINS_ANY_OF, T as DENSITY_MODEL_KEY, Q as DIMENSION_MODEL_KEY, D as DOES_NOT_CONTAIN, e as DOES_NOT_CONTAIN_ANY_OF, c as DOES_NOT_END_WITH, g as DOES_NOT_END_WITH_ANY_OF, a as DOES_NOT_EQUAL, u as DOES_NOT_HAVE, x as DOES_NOT_HAVE_ANY_OF, r as DOES_NOT_HAVE_ANY_OF_WITH_SELECT, n as DOES_NOT_HAVE_WITH_SELECT, b as DOES_NOT_START_WITH, f as DOES_NOT_START_WITH_ANY_OF, E as ENDS_WITH_ANY_OF, M as FILTER_MODEL_KEY, R as FILTER_SEARCH_KEY, t as HAS, w as HAS_ALL_OF, q as HAS_ALL_OF_WITH_SELECT, v as HAS_ANY_OF, p as HAS_ANY_OF_WITH_SELECT, y as HAS_ONLY, s as HAS_ONLY_WITH_SELECT, H as HAS_WITH_SELECT, B as IS, I as IS_ANY_OF, k as IS_ANY_OF_WITH_SELECT, h as IS_BETWEEN, F as IS_NOT, d as IS_NOT_ANY_OF, l as IS_NOT_ANY_OF_WITH_SELECT, j as IS_NOT_WITH_SELECT, i as IS_WITH_SELECT, P as PAGINATION_MODEL_KEY, O as PINNED_COLUMNS, N as SORT_MODEL_KEY, S as STARTS_WITH_ANY_OF, av as StatefulDataGrid, V as VISIBILITY_MODEL_KEY, au as areFilterModelsEquivalent, a3 as areSearchStringsEqual, a2 as buildQueryParamsString, X as buildStorageKey, Z as clearAllVersionStorage, Y as clearPreviousVersionStorage, a0 as convertFromDisplayFormat, $ as convertToDisplayFormat, a4 as decodeValue, a5 as encodeValue, ap as getColumnOrderFromString, ah as getColumnVisibilityFromString, a1 as getDecodedSearchFromUrl, am as getDensityFromString, ao as getDensityModel, ab as getFilterModelFromString, ar as getFinalSearch, z as getGridNumericOperators, J as getGridStringArrayOperators, K as getGridStringArrayOperatorsWithSelect, L as getGridStringArrayOperatorsWithSelectOnStringArrayColumns, G as getGridStringOperators, as as getModelsParsedOrUpdateLocalStorage, af as getPaginationFromString, aj as getPinnedColumnsFromString, aq as getSearchParamsFromColumnOrder, ai as getSearchParamsFromColumnVisibility, an as getSearchParamsFromDensity, ac as getSearchParamsFromFilterModel, ag as getSearchParamsFromPagination, ak as getSearchParamsFromPinnedColumns, ae as getSearchParamsFromSorting, al as getSearchParamsFromTab, ad as getSortingFromString, a9 as isOperatorValueValid, aa as isValueValid, a8 as numberOperatorDecoder, a7 as numberOperatorEncoder, o as operatorList, _ as resetStatefulDataGridState, at as updateUrl, a6 as urlSearchParamsToString } from './_internal/StatefulDataGrid2.js';
+import { GRID_DETAIL_PANEL_TOGGLE_COL_DEF, GridFilterInputMultipleValue, GridFilterInputMultipleSingleSelect, getGridDateOperators, getGridStringOperators, getGridNumericOperators } from '@mui/x-data-grid-pro';
+export { getGridBooleanOperators, getGridDateOperators, getGridSingleSelectOperators } from '@mui/x-data-grid-pro';
+import { _ as _objectSpread2 } from './_internal/_rollupPluginBabelHelpers.js';
+import * as React from 'react';
+import { useState, useRef, useEffect, useCallback, useMemo } from 'react';
+import Box from '@mui/material/Box';
+import TextField from '@mui/material/TextField';
+import { Icon } from '@redsift/design-system';
+import { mdiSync } from '@redsift/icons';
+export { D as DEFAULT_OPERATORS, G as GridToolbarFilterSemanticField, g as getCompletion } from './_internal/GridToolbarFilterSemanticField2.js';
+export { C as ControlledPagination, E as EMPTY_ROW_SELECTION_MODEL, S as ServerSideControlledPagination, c as createRowSelectionModel, f as fixServerSideHeaderCheckboxSelection, b as getSelectableRowIdsInPage, a as getSelectedIds, g as getSelectionCount, i as isRowSelected, n as normalizeRowSelectionModel, o as onServerSideSelectionStatusChange } from './_internal/ServerSideControlledPagination.js';
+export { B as BaseButton, a as BaseCheckbox, b as BaseIcon, c as BaseIconButton, m as muiIconToDSIcon } from './_internal/BaseIconButton.js';
+export { B as BaseTextField } from './_internal/BaseTextField.js';
+export { D as DataGrid } from './_internal/DataGrid2.js';
+export { T as TextCell } from './_internal/TextCell2.js';
+export { T as Toolbar } from './_internal/Toolbar2.js';
+export { T as ToolbarWrapper } from './_internal/ToolbarWrapper2.js';
+
+// Don't use a spread operator there or it will break the build due to MUI internal components
+const DETAIL_PANEL_TOGGLE_COL_DEF = GRID_DETAIL_PANEL_TOGGLE_COL_DEF;
+DETAIL_PANEL_TOGGLE_COL_DEF.type = 'actions';
+
+const isAnyOfIOperator = {
+  label: 'is any of (case-insensitive)',
+  value: 'isAnyOfI',
+  getApplyFilterFn: filterItem => {
+    if (!filterItem.field || !filterItem.value || !filterItem.operator) {
+      return null;
+    }
+    const lowerCaseFilterValues = filterItem.value.map(v => String(v).toLowerCase());
+    return value => {
+      if (filterItem.value.length === 0) {
+        return true;
+      }
+      if (value == null) {
+        return false;
+      }
+      const paramValues = Array.isArray(value) ? value : [value];
+      for (const paramValue of paramValues) {
+        if (lowerCaseFilterValues.includes(String(paramValue).toLowerCase())) {
+          return true;
+        }
+      }
+      return false;
+    };
+  },
+  InputComponent: GridFilterInputMultipleValue
+};
+const IS_ANY_OF_I = isAnyOfIOperator;
+const IS_ANY_OF_I_WITH_SELECT = _objectSpread2(_objectSpread2({}, IS_ANY_OF_I), {}, {
+  InputComponent: GridFilterInputMultipleSingleSelect
+});
+
+const SUBMIT_FILTER_STROKE_TIME = 500;
+const InputDateInterval = props => {
+  var _item$value, _filterValueState$, _filterValueState$2;
+  const {
+    item,
+    applyValue,
+    focusElementRef = null
+  } = props;
+  const filterTimeout = React.useRef();
+  const [filterValueState, setFilterValueState] = React.useState((_item$value = item.value) !== null && _item$value !== void 0 ? _item$value : ['', '']);
+  const [applying, setIsApplying] = React.useState(false);
+  React.useEffect(() => {
+    return () => {
+      clearTimeout(filterTimeout.current);
+    };
+  }, []);
+  React.useEffect(() => {
+    var _item$value2;
+    const itemValue = (_item$value2 = item.value) !== null && _item$value2 !== void 0 ? _item$value2 : ['', ''];
+    setFilterValueState(itemValue);
+  }, [item.value]);
+  const updateFilterValue = (from, to) => {
+    clearTimeout(filterTimeout.current);
+    setFilterValueState([from, to]);
+    setIsApplying(true);
+    filterTimeout.current = setTimeout(() => {
+      setIsApplying(false);
+      applyValue(_objectSpread2(_objectSpread2({}, item), {}, {
+        value: [from, to]
+      }));
+    }, SUBMIT_FILTER_STROKE_TIME);
+  };
+  const handleFromChange = event => {
+    const newFrom = event.target.value;
+    updateFilterValue(newFrom, filterValueState[1]);
+  };
+  const handleToChange = event => {
+    const newTo = event.target.value;
+    updateFilterValue(filterValueState[0], newTo);
+  };
+  return /*#__PURE__*/React.createElement(Box, {
+    sx: {
+      display: 'inline-flex',
+      flexDirection: 'row',
+      alignItems: 'end',
+      height: 48,
+      pl: '20px'
+    }
+  }, /*#__PURE__*/React.createElement(TextField, {
+    name: "date-from-input",
+    placeholder: "From",
+    label: "From",
+    variant: "standard",
+    value: (_filterValueState$ = filterValueState[0]) !== null && _filterValueState$ !== void 0 ? _filterValueState$ : '',
+    onChange: handleFromChange,
+    type: "date",
+    inputRef: focusElementRef,
+    sx: {
+      mr: 2
+    },
+    InputLabelProps: {
+      shrink: true
+    }
+  }), /*#__PURE__*/React.createElement(TextField, {
+    name: "date-to-input",
+    placeholder: "To",
+    label: "To",
+    variant: "standard",
+    value: (_filterValueState$2 = filterValueState[1]) !== null && _filterValueState$2 !== void 0 ? _filterValueState$2 : '',
+    onChange: handleToChange,
+    type: "date",
+    InputProps: applying ? {
+      endAdornment: /*#__PURE__*/React.createElement(Icon, {
+        icon: mdiSync
+      })
+    } : {},
+    InputLabelProps: {
+      shrink: true
+    }
+  }));
+};
+
+const isBetweenOperator = {
+  label: 'is between',
+  value: 'isBetween',
+  getApplyFilterFn: filterItem => {
+    if (!filterItem.field || !filterItem.value || !filterItem.operator) {
+      return null;
+    }
+    if (!Array.isArray(filterItem.value) || filterItem.value.length !== 2) {
+      return null;
+    }
+    if (!filterItem.value[0] || !filterItem.value[1]) {
+      return null;
+    }
+
+    // Parse as local time (not UTC) since the date input produces YYYY-MM-DD
+    // strings representing dates in the user's local timezone.
+    const [fromYear, fromMonth, fromDay] = filterItem.value[0].split('-').map(Number);
+    const [toYear, toMonth, toDay] = filterItem.value[1].split('-').map(Number);
+    const fromTime = new Date(fromYear, fromMonth - 1, fromDay).getTime();
+    // Set upper bound to end-of-day so dateTime values later that day are included.
+    const toTime = new Date(toYear, toMonth - 1, toDay, 23, 59, 59, 999).getTime();
+    if (isNaN(fromTime) || isNaN(toTime)) {
+      return null;
+    }
+    return value => {
+      if (value == null) {
+        return false;
+      }
+      const cellTime = value instanceof Date ? value.getTime() : new Date(value).getTime();
+      if (isNaN(cellTime)) {
+        return false;
+      }
+      return cellTime >= fromTime && cellTime <= toTime;
+    };
+  },
+  InputComponent: InputDateInterval
+};
+const DATE_IS_BETWEEN = isBetweenOperator;
+
+const getGridDateOperatorsExtended = function () {
+  let showTime = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+  return [...getGridDateOperators(showTime), DATE_IS_BETWEEN];
+};
+
+const lowercaseValue = value => {
+  if (typeof value === 'string') {
+    return value.toLowerCase();
+  }
+  if (Array.isArray(value)) {
+    return value.map(lowercaseValue);
+  }
+  return value;
+};
+
+/**
+ * Wraps a filter operator's `getApplyFilterFn` to lowercase both the cell value
+ * and the filter value before comparison, making the operator case-insensitive.
+ *
+ * Only affects string-based values — numbers, dates, and booleans pass through unchanged.
+ */
+const wrapCaseInsensitive = operator => {
+  const originalGetApplyFilterFn = operator.getApplyFilterFn;
+  return _objectSpread2(_objectSpread2({}, operator), {}, {
+    getApplyFilterFn: (filterItem, column) => {
+      const caseInsensitiveFilterItem = _objectSpread2(_objectSpread2({}, filterItem), {}, {
+        value: lowercaseValue(filterItem.value)
+      });
+      const originalFn = originalGetApplyFilterFn(caseInsensitiveFilterItem, column);
+      if (!originalFn) {
+        return null;
+      }
+      return (value, row, column, apiRef) => {
+        const lowercasedValue = lowercaseValue(value);
+        return originalFn(lowercasedValue, row, column, apiRef);
+      };
+    }
+  });
+};
+
+/**
+ * Applies case-insensitive wrapping to an array of filter operators.
+ */
+const makeCaseInsensitive = operators => {
+  return operators.map(wrapCaseInsensitive);
+};
+
+const getRsStringColumnType = () => {
+  return {
+    type: 'string',
+    filterOperators: operatorList.rsString
+  };
+};
+const getRsNumberColumnType = () => {
+  return {
+    type: 'number',
+    filterOperators: operatorList.rsNumber
+  };
+};
+const getRsSingleSelectColumnType = () => {
+  return {
+    type: 'singleSelect',
+    filterOperators: operatorList.rsSingleSelect
+  };
+};
+const getRsSingleSelectWithShortOperatorListColumnType = () => {
+  return {
+    type: 'singleSelect',
+    filterOperators: operatorList.rsSingleSelectWithShortOperatorList
+  };
+};
+const getRsMultipleSelectColumnType = () => {
+  return {
+    type: 'singleSelect',
+    filterOperators: operatorList.rsMultipleSelect
+  };
+};
+const getRsMultipleSelectWithShortOperatorListColumnType = () => {
+  return {
+    type: 'singleSelect',
+    filterOperators: operatorList.rsMultipleSelectWithShortOperatorList
+  };
+};
+const customColumnTypes = {
+  rsString: getRsStringColumnType(),
+  rsNumber: getRsNumberColumnType(),
+  rsSingleSelect: getRsSingleSelectColumnType(),
+  rsSingleSelectWithShortOperatorList: getRsSingleSelectWithShortOperatorListColumnType(),
+  rsMultipleSelect: getRsMultipleSelectColumnType(),
+  rsMultipleSelectWithShortOperatorList: getRsMultipleSelectWithShortOperatorListColumnType()
+};
+
+// ---------------------------------------------------------------------------
+// Operator name unions (for typed `exclude`)
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// Column type
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// Options: discriminated union (built-in vs override)
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// Full & compact operator lists
+// ---------------------------------------------------------------------------
+const getStringOperatorsFull = () => [...getGridStringOperators().filter(op => !['isAnyOf'].includes(op.value)), DOES_NOT_CONTAIN, DOES_NOT_EQUAL, DOES_NOT_START_WITH, DOES_NOT_END_WITH, IS_ANY_OF, IS_NOT_ANY_OF, CONTAINS_ANY_OF, DOES_NOT_CONTAIN_ANY_OF, STARTS_WITH_ANY_OF, DOES_NOT_START_WITH_ANY_OF, ENDS_WITH_ANY_OF, DOES_NOT_END_WITH_ANY_OF];
+const getStringOperatorsCompact = () => [...getGridStringOperators().filter(op => !['isAnyOf', 'startsWith', 'endsWith'].includes(op.value)), DOES_NOT_CONTAIN, DOES_NOT_EQUAL, IS_ANY_OF];
+const getNumberOperatorsFull = () => [...getGridNumericOperators(), IS_BETWEEN];
+const getNumberOperatorsCompact = () => getGridNumericOperators();
+const getDateOperatorsFull = showTime => [...getGridDateOperators(showTime), DATE_IS_BETWEEN];
+const getDateOperatorsCompact = showTime => getGridDateOperators(showTime);
+const getSingleSelectOperatorsFull = () => [IS_WITH_SELECT, IS_NOT_WITH_SELECT, IS_ANY_OF_WITH_SELECT, IS_NOT_ANY_OF_WITH_SELECT, ARRAY_IS_EMPTY, ARRAY_IS_NOT_EMPTY];
+const getSingleSelectOperatorsCompact = () => [IS_WITH_SELECT, IS_NOT_WITH_SELECT, IS_ANY_OF_WITH_SELECT];
+const getMultiSelectOperatorsFull = () => [HAS_WITH_SELECT, DOES_NOT_HAVE_WITH_SELECT, HAS_ANY_OF_WITH_SELECT, HAS_ALL_OF_WITH_SELECT, DOES_NOT_HAVE_ANY_OF_WITH_SELECT, HAS_ONLY_WITH_SELECT, ARRAY_IS_EMPTY, ARRAY_IS_NOT_EMPTY];
+const getMultiSelectOperatorsCompact = () => [HAS_WITH_SELECT, DOES_NOT_HAVE_WITH_SELECT, HAS_ANY_OF_WITH_SELECT];
+const getTagsOperatorsFull = () => [HAS, DOES_NOT_HAVE, HAS_ANY_OF, HAS_ALL_OF, DOES_NOT_HAVE_ANY_OF, HAS_ONLY, CONTAINS_ANY_OF, DOES_NOT_CONTAIN_ANY_OF, ARRAY_IS_EMPTY, ARRAY_IS_NOT_EMPTY];
+const getTagsOperatorsCompact = () => [HAS, DOES_NOT_HAVE, HAS_ANY_OF];
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+const isOverrideOptions = options => {
+  return options && 'operators' in options;
+};
+const arraySortComparator = (a, b) => {
+  const arrA = Array.isArray(a) ? a : [];
+  const arrB = Array.isArray(b) ? b : [];
+  if (arrA.length !== arrB.length) {
+    return arrA.length - arrB.length;
+  }
+  const strA = arrA.map(String).sort().join(',');
+  const strB = arrB.map(String).sort().join(',');
+  return strA.localeCompare(strB);
+};
+const arrayValueFormatter = value => {
+  if (Array.isArray(value)) {
+    return value.map(String).join(', ');
+  }
+  return value != null ? String(value) : '';
+};
+
+// ---------------------------------------------------------------------------
+// Operator type strings that support case-insensitive wrapping
+// ---------------------------------------------------------------------------
+
+const CASE_INSENSITIVE_TYPES = ['string', 'singleSelect', 'tags'];
+
+// ---------------------------------------------------------------------------
+// createColumn()
+// ---------------------------------------------------------------------------
+
+/**
+ * Creates a column configuration with the appropriate MUI type and filter operators
+ * for the given column type. Spread the result into your column definition.
+ *
+ * @example
+ * ```tsx
+ * const columns = [
+ *   { ...createColumn('string'), field: 'name', headerName: 'Name' },
+ *   { ...createColumn('number'), field: 'price', headerName: 'Price' },
+ *   { ...createColumn('singleSelect', { compact: true }), field: 'status', valueOptions: ['active', 'inactive'] },
+ *   { ...createColumn('multiSelect'), field: 'tags', valueOptions: ['a', 'b', 'c'] },
+ *   { ...createColumn('tags'), field: 'labels', headerName: 'Labels' },
+ * ];
+ * ```
+ */
+function createColumn(type, options) {
+  var _builtInOpts$compact, _builtInOpts$caseSens;
+  // Override mode: consumer provides full operator list
+  if (options && isOverrideOptions(options)) {
+    const result = {
+      type: getMuiType(type),
+      filterOperators: options.operators
+    };
+    if (type === 'multiSelect' || type === 'tags') {
+      result.sortComparator = arraySortComparator;
+      result.valueFormatter = arrayValueFormatter;
+    }
+    return result;
+  }
+
+  // Built-in mode
+  const builtInOpts = options !== null && options !== void 0 ? options : {};
+  const compact = (_builtInOpts$compact = builtInOpts.compact) !== null && _builtInOpts$compact !== void 0 ? _builtInOpts$compact : false;
+  const caseSensitive = (_builtInOpts$caseSens = builtInOpts.caseSensitive) !== null && _builtInOpts$caseSens !== void 0 ? _builtInOpts$caseSens : false;
+  let operators = getOperatorsForType(type, compact);
+
+  // Apply exclude
+  if (builtInOpts.exclude && builtInOpts.exclude.length > 0) {
+    const excludeSet = new Set(builtInOpts.exclude);
+    operators = operators.filter(op => !excludeSet.has(op.value));
+  }
+
+  // Apply case-insensitive wrapping
+  if (!caseSensitive && CASE_INSENSITIVE_TYPES.includes(type)) {
+    operators = makeCaseInsensitive(operators);
+  }
+
+  // Apply extend
+  if (builtInOpts.extend && builtInOpts.extend.length > 0) {
+    operators = [...operators, ...builtInOpts.extend];
+  }
+  const result = {
+    type: getMuiType(type),
+    filterOperators: operators
+  };
+  if (type === 'multiSelect' || type === 'tags') {
+    result.sortComparator = arraySortComparator;
+    result.valueFormatter = arrayValueFormatter;
+  }
+  return result;
+}
+function getMuiType(type) {
+  switch (type) {
+    case 'multiSelect':
+    case 'singleSelect':
+      return 'singleSelect';
+    case 'tags':
+      return 'string';
+    default:
+      return type;
+  }
+}
+function getOperatorsForType(type, compact) {
+  switch (type) {
+    case 'string':
+      return compact ? getStringOperatorsCompact() : getStringOperatorsFull();
+    case 'number':
+      return compact ? getNumberOperatorsCompact() : getNumberOperatorsFull();
+    case 'date':
+      return compact ? getDateOperatorsCompact(false) : getDateOperatorsFull(false);
+    case 'dateTime':
+      return compact ? getDateOperatorsCompact(true) : getDateOperatorsFull(true);
+    case 'singleSelect':
+      return compact ? getSingleSelectOperatorsCompact() : getSingleSelectOperatorsFull();
+    case 'multiSelect':
+      return compact ? getMultiSelectOperatorsCompact() : getMultiSelectOperatorsFull();
+    case 'tags':
+      return compact ? getTagsOperatorsCompact() : getTagsOperatorsFull();
+  }
+}
+
+/**
+ * A React Router v5 / connected-react-router adapter for `StatefulDataGrid.useRouter`.
+ *
+ * Defers `history.replace` via `queueMicrotask` to avoid the
+ * "Cannot update during an existing state transition" warning
+ * that connected-react-router triggers when the grid synchronises
+ * URL state during render.
+ *
+ * Also coalesces multiple `historyReplace` calls within the same microtask
+ * by computing per-call deltas against the captured `search` snapshot and
+ * merging them into the live URL. This prevents handler stomping when the
+ * grid fires several model-change handlers in the same render (e.g. a
+ * pivot change re-emits a synthetic column-visibility change alongside a
+ * filter change): without coalescing, each handler would compute a full
+ * new search from the same captured snapshot, and the second
+ * `history.replace` would clobber the first — dropping any keys (such as
+ * the filter just typed) that the second handler didn't know about.
+ *
+ * @example
+ * ```tsx
+ * import { createReactRouterV5Adapter } from '@redsift/table-pro';
+ *
+ * const useRouter = createReactRouterV5Adapter(history);
+ *
+ * <StatefulDataGrid useRouter={useRouter} … />
+ * ```
+ */
+
+/** Minimal subset of React Router v5 `history` used by the adapter. */
+
+/**
+ * Create a `useRouter` hook compatible with `StatefulDataGrid` from a
+ * React Router v5 `history` object.
+ */
+const createReactRouterV5Adapter = history => {
+  // Module-instance state shared across all `historyReplace` calls scheduled
+  // within the same microtask. Each `useRouter()` invocation captures its own
+  // `search` snapshot for delta computation; `pending` accumulates the deltas
+  // and is flushed once per microtask onto the live URL.
+  let pending = null;
+  let flushScheduled = false;
+  const scheduleFlush = () => {
+    if (flushScheduled) return;
+    flushScheduled = true;
+    queueMicrotask(() => {
+      flushScheduled = false;
+      const flush = pending;
+      pending = null;
+      if (flush === null) return;
+      const serialized = flush.toString();
+      const nextSearch = serialized ? `?${serialized}` : '';
+      if (nextSearch === history.location.search) return;
+      history.replace({
+        pathname: history.location.pathname,
+        search: nextSearch
+      });
+    });
+  };
+  return () => {
+    // Capture the search snapshot AT THE TIME useRouter() is called. The
+    // grid hands this string to its change handlers, which build a complete
+    // new search string from it. Diffing the handler's `newSearch` against
+    // this captured snapshot tells us which keys the handler intentionally
+    // changed (vs. which are stale passthrough from sibling handlers' models).
+    const captured = history.location.search.replace(/^\?/, '');
+    const capturedParams = new URLSearchParams(captured);
+    const capturedKeys = new Set(capturedParams.keys());
+    return {
+      pathname: history.location.pathname,
+      search: captured,
+      historyReplace: newSearch => {
+        const newParams = new URLSearchParams(newSearch);
+        const newKeys = new Set(newParams.keys());
+
+        // Lazy-init `pending` from the LIVE URL — not the captured snapshot —
+        // so deltas from earlier microtask-scheduled calls (which may have
+        // already been flushed, or were scheduled by a previous render and
+        // are now reflected in the live URL) are preserved.
+        if (pending === null) {
+          pending = new URLSearchParams(history.location.search.replace(/^\?/, ''));
+        }
+
+        // Apply only keys this handler actually changed. A handler builds a
+        // complete new search from a captured snapshot, but only some keys
+        // reflect its intent — the rest are passthrough of the snapshot.
+        // When two handlers fire in the same render and one was triggered
+        // by a model the other doesn't care about, passthrough keys would
+        // otherwise stomp pending state from earlier handlers.
+        for (const key of newKeys) {
+          const newValues = newParams.getAll(key);
+          const capturedValues = capturedParams.getAll(key);
+          const unchanged = newValues.length === capturedValues.length && newValues.every((v, i) => v === capturedValues[i]);
+          if (unchanged) continue;
+          pending.delete(key);
+          for (const value of newValues) {
+            pending.append(key, value);
+          }
+        }
+        // Keys that were in the captured snapshot but absent from newSearch
+        // were intentionally removed by this handler.
+        for (const key of capturedKeys) {
+          if (!newKeys.has(key)) pending.delete(key);
+        }
+        scheduleFlush();
+      }
+    };
+  };
+};
+
+const EMPTY_FILTER_MODEL = {
+  items: []
+};
+const sameItems = (a, b) => JSON.stringify(a.items) === JSON.stringify(b.items);
+const filterOutField = (model, field) => model.items.filter(item => item.field !== field);
+const nextItemId = (() => {
+  let id = 1;
+  return () => id++;
+})();
+
+/**
+ * Bridge a DataGrid `filterModel` and the DataCards that drive (and reflect) it.
+ *
+ * Without this hook, every drilldowned datagrid page hand-rolls the same plumbing:
+ * derive selections from `filterModel`, write them back via raw `setFilterModel`
+ * mutations, debounce panel changes, and track which fields the panel "owns" so
+ * cards don't fight the panel for control. SOFA-6 shipped this logic ad hoc and
+ * got it wrong (no debounce, prop-drilled state, no panel/card reconciliation).
+ *
+ * @example
+ * const filter = useLinkedFilterModel();
+ *
+ * <DataCard.Listbox
+ *   values={filter.getSelected('Category')}
+ *   onChange={(values) => filter.setMultiSelect('Category', values)}
+ *   isDisabled={filter.isFieldExternallyControlled('Category')}
+ * >
+ *   {…}
+ * </DataCard.Listbox>
+ *
+ * <DataGrid filterModel={filter.filterModel} onFilterModelChange={filter.onFilterModelChange} />
+ */
+function useLinkedFilterModel() {
+  let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  const {
+    initialFilterModel = EMPTY_FILTER_MODEL,
+    debounceMs = 300,
+    onChange
+  } = options;
+  const [filterModel, setFilterModel] = useState(initialFilterModel);
+
+  // Fields whose current filter was set by setMultiSelect / setBoolean (not the panel).
+  const cardOwnedFields = useRef(new Set());
+  // Marks the next onFilterModelChange as originating from a card setter so we skip debouncing.
+  const skipNextDebounce = useRef(false);
+  const debounceTimer = useRef(null);
+  const onChangeRef = useRef(onChange);
+  useEffect(() => {
+    onChangeRef.current = onChange;
+  }, [onChange]);
+  useEffect(() => {
+    return () => {
+      if (debounceTimer.current) clearTimeout(debounceTimer.current);
+    };
+  }, []);
+  const commit = useCallback(next => {
+    setFilterModel(prev => {
+      var _onChangeRef$current;
+      if (sameItems(prev, next)) return prev;
+      (_onChangeRef$current = onChangeRef.current) === null || _onChangeRef$current === void 0 ? void 0 : _onChangeRef$current.call(onChangeRef, next);
+      return next;
+    });
+  }, []);
+  const onFilterModelChange = useCallback(model => {
+    if (skipNextDebounce.current) {
+      skipNextDebounce.current = false;
+      // If the incoming model matches the current state, this is a DataGrid echo
+      // of a card setter — commit (no-op) and preserve card ownership.
+      if (sameItems(filterModel, model)) {
+        commit(model);
+        return;
+      }
+      // Otherwise a real panel change arrived — fall through to ownership logic.
+    }
+
+    // Panel change — drop card ownership for fields the panel now controls / has cleared,
+    // then debounce the commit.
+    const panelFields = new Set(model.items.map(item => item.field));
+    for (const field of Array.from(cardOwnedFields.current)) {
+      if (!panelFields.has(field)) cardOwnedFields.current.delete(field);
+    }
+    // If the panel touched a field the card previously owned, transfer ownership to the panel.
+    for (const field of panelFields) {
+      cardOwnedFields.current.delete(field);
+    }
+    if (debounceMs <= 0) {
+      commit(model);
+      return;
+    }
+    if (debounceTimer.current) clearTimeout(debounceTimer.current);
+    debounceTimer.current = setTimeout(() => {
+      debounceTimer.current = null;
+      commit(model);
+    }, debounceMs);
+  }, [commit, debounceMs, filterModel]);
+  const getSelected = useCallback(field => {
+    const item = filterModel.items.find(i => i.field === field);
+    if (!item || item.value === undefined || item.value === null) return [];
+    if (item.operator === 'isAnyOf' || item.operator === 'hasAnyOf') {
+      return Array.isArray(item.value) ? item.value : [String(item.value)];
+    }
+    return [];
+  }, [filterModel]);
+  const getValue = useCallback(field => {
+    var _filterModel$items$fi;
+    return (_filterModel$items$fi = filterModel.items.find(i => i.field === field)) === null || _filterModel$items$fi === void 0 ? void 0 : _filterModel$items$fi.value;
+  }, [filterModel]);
+  const setMultiSelect = useCallback(function (field, values) {
+    let operator = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'isAnyOf';
+    skipNextDebounce.current = true;
+    setFilterModel(prev => {
+      var _onChangeRef$current2;
+      const items = filterOutField(prev, field);
+      if (values.length > 0) {
+        items.push({
+          field,
+          id: nextItemId(),
+          operator,
+          value: values
+        });
+        cardOwnedFields.current.add(field);
+      } else {
+        cardOwnedFields.current.delete(field);
+      }
+      const next = _objectSpread2(_objectSpread2({}, prev), {}, {
+        items
+      });
+      if (sameItems(prev, next)) return prev;
+      (_onChangeRef$current2 = onChangeRef.current) === null || _onChangeRef$current2 === void 0 ? void 0 : _onChangeRef$current2.call(onChangeRef, next);
+      return next;
+    });
+  }, []);
+  const setBoolean = useCallback((field, value) => {
+    skipNextDebounce.current = true;
+    setFilterModel(prev => {
+      var _onChangeRef$current3;
+      const items = filterOutField(prev, field);
+      if (value !== null) {
+        items.push({
+          field,
+          id: nextItemId(),
+          operator: 'is',
+          value: String(value)
+        });
+        cardOwnedFields.current.add(field);
+      } else {
+        cardOwnedFields.current.delete(field);
+      }
+      const next = _objectSpread2(_objectSpread2({}, prev), {}, {
+        items
+      });
+      if (sameItems(prev, next)) return prev;
+      (_onChangeRef$current3 = onChangeRef.current) === null || _onChangeRef$current3 === void 0 ? void 0 : _onChangeRef$current3.call(onChangeRef, next);
+      return next;
+    });
+  }, []);
+  const clearField = useCallback(field => {
+    skipNextDebounce.current = true;
+    setFilterModel(prev => {
+      var _onChangeRef$current4;
+      const items = filterOutField(prev, field);
+      cardOwnedFields.current.delete(field);
+      const next = _objectSpread2(_objectSpread2({}, prev), {}, {
+        items
+      });
+      if (sameItems(prev, next)) return prev;
+      (_onChangeRef$current4 = onChangeRef.current) === null || _onChangeRef$current4 === void 0 ? void 0 : _onChangeRef$current4.call(onChangeRef, next);
+      return next;
+    });
+  }, []);
+  const reset = useCallback(() => {
+    skipNextDebounce.current = true;
+    cardOwnedFields.current.clear();
+    commit(initialFilterModel);
+  }, [commit, initialFilterModel]);
+  const isFieldExternallyControlled = useCallback(field => {
+    const hasFilter = filterModel.items.some(item => item.field === field);
+    return hasFilter && !cardOwnedFields.current.has(field);
+  }, [filterModel]);
+  return useMemo(() => ({
+    filterModel,
+    onFilterModelChange,
+    getSelected,
+    getValue,
+    setMultiSelect,
+    setBoolean,
+    clearField,
+    reset,
+    isFieldExternallyControlled
+  }), [filterModel, onFilterModelChange, getSelected, getValue, setMultiSelect, setBoolean, clearField, reset, isFieldExternallyControlled]);
+}
+
+export { DATE_IS_BETWEEN, DETAIL_PANEL_TOGGLE_COL_DEF, IS_ANY_OF_I, IS_ANY_OF_I_WITH_SELECT, createColumn, createReactRouterV5Adapter, customColumnTypes, getGridDateOperatorsExtended, getRsMultipleSelectColumnType, getRsMultipleSelectWithShortOperatorListColumnType, getRsNumberColumnType, getRsSingleSelectColumnType, getRsSingleSelectWithShortOperatorListColumnType, getRsStringColumnType, makeCaseInsensitive, useLinkedFilterModel, wrapCaseInsensitive };
+//# sourceMappingURL=index.js.map