@redis-ui/table 2.12.0 → 2.18.0

package/dist/node_modules/@tanstack/table-core/build/lib/index.js

@@ -8,9 +8,26 @@
    *
    * @license MIT
    */
+function createColumnHelper() {
+  return {
+    accessor: (accessor, column) => {
+      return typeof accessor === "function" ? {
+        ...column,
+        accessorFn: accessor
+      } : {
+        ...column,
+        accessorKey: accessor
+      };
+    },
+    display: (column) => column,
+    group: (column) => column
+  };
+}
 function functionalUpdate(updater, input) {
   return typeof updater === "function" ? updater(input) : updater;
 }
+function noop() {
+}
 function makeStateUpdater(key, instance) {
   return (updater) => {
     instance.setState((old) => {
@@ -425,7 +442,7 @@ const createRow = (table, id, original, rowIndex, depth, subRows, parentId) => {
       var _row$getValue;
       return (_row$getValue = row.getValue(columnId)) != null ? _row$getValue : table.options.renderFallbackValue;
     },
-    subRows: [],
+    subRows: subRows != null ? subRows : [],
     getLeafRows: () => flattenBy(row.subRows, (d) => d.subRows),
     getParentRow: () => row.parentId ? table.getRow(row.parentId, true) : void 0,
     getParentRows: () => {
@@ -1292,10 +1309,10 @@ function passiveEventSupported() {
         return false;
       }
     };
-    const noop = () => {
+    const noop2 = () => {
     };
-    window.addEventListener("test", noop, options);
-    window.removeEventListener("test", noop);
+    window.addEventListener("test", noop2, options);
+    window.removeEventListener("test", noop2);
   } catch (err) {
     supported = false;
   }
@@ -2651,6 +2668,339 @@ function expandRows(rowModel) {
     rowsById: rowModel.rowsById
   };
 }
+function getFacetedMinMaxValues() {
+  return (table, columnId) => memo(() => {
+    var _table$getColumn;
+    return [(_table$getColumn = table.getColumn(columnId)) == null ? void 0 : _table$getColumn.getFacetedRowModel()];
+  }, (facetedRowModel) => {
+    var _facetedRowModel$flat;
+    if (!facetedRowModel) return void 0;
+    const firstValue = (_facetedRowModel$flat = facetedRowModel.flatRows[0]) == null ? void 0 : _facetedRowModel$flat.getUniqueValues(columnId);
+    if (typeof firstValue === "undefined") {
+      return void 0;
+    }
+    let facetedMinMaxValues = [firstValue, firstValue];
+    for (let i = 0; i < facetedRowModel.flatRows.length; i++) {
+      const values = facetedRowModel.flatRows[i].getUniqueValues(columnId);
+      for (let j = 0; j < values.length; j++) {
+        const value = values[j];
+        if (value < facetedMinMaxValues[0]) {
+          facetedMinMaxValues[0] = value;
+        } else if (value > facetedMinMaxValues[1]) {
+          facetedMinMaxValues[1] = value;
+        }
+      }
+    }
+    return facetedMinMaxValues;
+  }, getMemoOptions(table.options, "debugTable", "getFacetedMinMaxValues"));
+}
+function filterRows(rows, filterRowImpl, table) {
+  if (table.options.filterFromLeafRows) {
+    return filterRowModelFromLeafs(rows, filterRowImpl, table);
+  }
+  return filterRowModelFromRoot(rows, filterRowImpl, table);
+}
+function filterRowModelFromLeafs(rowsToFilter, filterRow, table) {
+  var _table$options$maxLea;
+  const newFilteredFlatRows = [];
+  const newFilteredRowsById = {};
+  const maxDepth = (_table$options$maxLea = table.options.maxLeafRowFilterDepth) != null ? _table$options$maxLea : 100;
+  const recurseFilterRows = function(rowsToFilter2, depth) {
+    if (depth === void 0) {
+      depth = 0;
+    }
+    const rows = [];
+    for (let i = 0; i < rowsToFilter2.length; i++) {
+      var _row$subRows;
+      let row = rowsToFilter2[i];
+      const newRow = createRow(table, row.id, row.original, row.index, row.depth, void 0, row.parentId);
+      newRow.columnFilters = row.columnFilters;
+      if ((_row$subRows = row.subRows) != null && _row$subRows.length && depth < maxDepth) {
+        newRow.subRows = recurseFilterRows(row.subRows, depth + 1);
+        row = newRow;
+        if (filterRow(row) && !newRow.subRows.length) {
+          rows.push(row);
+          newFilteredRowsById[row.id] = row;
+          newFilteredFlatRows.push(row);
+          continue;
+        }
+        if (filterRow(row) || newRow.subRows.length) {
+          rows.push(row);
+          newFilteredRowsById[row.id] = row;
+          newFilteredFlatRows.push(row);
+          continue;
+        }
+      } else {
+        row = newRow;
+        if (filterRow(row)) {
+          rows.push(row);
+          newFilteredRowsById[row.id] = row;
+          newFilteredFlatRows.push(row);
+        }
+      }
+    }
+    return rows;
+  };
+  return {
+    rows: recurseFilterRows(rowsToFilter),
+    flatRows: newFilteredFlatRows,
+    rowsById: newFilteredRowsById
+  };
+}
+function filterRowModelFromRoot(rowsToFilter, filterRow, table) {
+  var _table$options$maxLea2;
+  const newFilteredFlatRows = [];
+  const newFilteredRowsById = {};
+  const maxDepth = (_table$options$maxLea2 = table.options.maxLeafRowFilterDepth) != null ? _table$options$maxLea2 : 100;
+  const recurseFilterRows = function(rowsToFilter2, depth) {
+    if (depth === void 0) {
+      depth = 0;
+    }
+    const rows = [];
+    for (let i = 0; i < rowsToFilter2.length; i++) {
+      let row = rowsToFilter2[i];
+      const pass = filterRow(row);
+      if (pass) {
+        var _row$subRows2;
+        if ((_row$subRows2 = row.subRows) != null && _row$subRows2.length && depth < maxDepth) {
+          const newRow = createRow(table, row.id, row.original, row.index, row.depth, void 0, row.parentId);
+          newRow.subRows = recurseFilterRows(row.subRows, depth + 1);
+          row = newRow;
+        }
+        rows.push(row);
+        newFilteredFlatRows.push(row);
+        newFilteredRowsById[row.id] = row;
+      }
+    }
+    return rows;
+  };
+  return {
+    rows: recurseFilterRows(rowsToFilter),
+    flatRows: newFilteredFlatRows,
+    rowsById: newFilteredRowsById
+  };
+}
+function getFacetedRowModel() {
+  return (table, columnId) => memo(() => [table.getPreFilteredRowModel(), table.getState().columnFilters, table.getState().globalFilter, table.getFilteredRowModel()], (preRowModel, columnFilters, globalFilter) => {
+    if (!preRowModel.rows.length || !(columnFilters != null && columnFilters.length) && !globalFilter) {
+      return preRowModel;
+    }
+    const filterableIds = [...columnFilters.map((d) => d.id).filter((d) => d !== columnId), globalFilter ? "__global__" : void 0].filter(Boolean);
+    const filterRowsImpl = (row) => {
+      for (let i = 0; i < filterableIds.length; i++) {
+        if (row.columnFilters[filterableIds[i]] === false) {
+          return false;
+        }
+      }
+      return true;
+    };
+    return filterRows(preRowModel.rows, filterRowsImpl, table);
+  }, getMemoOptions(table.options, "debugTable", "getFacetedRowModel"));
+}
+function getFacetedUniqueValues() {
+  return (table, columnId) => memo(() => {
+    var _table$getColumn;
+    return [(_table$getColumn = table.getColumn(columnId)) == null ? void 0 : _table$getColumn.getFacetedRowModel()];
+  }, (facetedRowModel) => {
+    if (!facetedRowModel) return /* @__PURE__ */ new Map();
+    let facetedUniqueValues = /* @__PURE__ */ new Map();
+    for (let i = 0; i < facetedRowModel.flatRows.length; i++) {
+      const values = facetedRowModel.flatRows[i].getUniqueValues(columnId);
+      for (let j = 0; j < values.length; j++) {
+        const value = values[j];
+        if (facetedUniqueValues.has(value)) {
+          var _facetedUniqueValues$;
+          facetedUniqueValues.set(value, ((_facetedUniqueValues$ = facetedUniqueValues.get(value)) != null ? _facetedUniqueValues$ : 0) + 1);
+        } else {
+          facetedUniqueValues.set(value, 1);
+        }
+      }
+    }
+    return facetedUniqueValues;
+  }, getMemoOptions(table.options, "debugTable", `getFacetedUniqueValues_${columnId}`));
+}
+function getFilteredRowModel() {
+  return (table) => memo(() => [table.getPreFilteredRowModel(), table.getState().columnFilters, table.getState().globalFilter], (rowModel, columnFilters, globalFilter) => {
+    if (!rowModel.rows.length || !(columnFilters != null && columnFilters.length) && !globalFilter) {
+      for (let i = 0; i < rowModel.flatRows.length; i++) {
+        rowModel.flatRows[i].columnFilters = {};
+        rowModel.flatRows[i].columnFiltersMeta = {};
+      }
+      return rowModel;
+    }
+    const resolvedColumnFilters = [];
+    const resolvedGlobalFilters = [];
+    (columnFilters != null ? columnFilters : []).forEach((d) => {
+      var _filterFn$resolveFilt;
+      const column = table.getColumn(d.id);
+      if (!column) {
+        return;
+      }
+      const filterFn = column.getFilterFn();
+      if (!filterFn) {
+        if (process.env.NODE_ENV !== "production") {
+          console.warn(`Could not find a valid 'column.filterFn' for column with the ID: ${column.id}.`);
+        }
+        return;
+      }
+      resolvedColumnFilters.push({
+        id: d.id,
+        filterFn,
+        resolvedValue: (_filterFn$resolveFilt = filterFn.resolveFilterValue == null ? void 0 : filterFn.resolveFilterValue(d.value)) != null ? _filterFn$resolveFilt : d.value
+      });
+    });
+    const filterableIds = (columnFilters != null ? columnFilters : []).map((d) => d.id);
+    const globalFilterFn = table.getGlobalFilterFn();
+    const globallyFilterableColumns = table.getAllLeafColumns().filter((column) => column.getCanGlobalFilter());
+    if (globalFilter && globalFilterFn && globallyFilterableColumns.length) {
+      filterableIds.push("__global__");
+      globallyFilterableColumns.forEach((column) => {
+        var _globalFilterFn$resol;
+        resolvedGlobalFilters.push({
+          id: column.id,
+          filterFn: globalFilterFn,
+          resolvedValue: (_globalFilterFn$resol = globalFilterFn.resolveFilterValue == null ? void 0 : globalFilterFn.resolveFilterValue(globalFilter)) != null ? _globalFilterFn$resol : globalFilter
+        });
+      });
+    }
+    let currentColumnFilter;
+    let currentGlobalFilter;
+    for (let j = 0; j < rowModel.flatRows.length; j++) {
+      const row = rowModel.flatRows[j];
+      row.columnFilters = {};
+      if (resolvedColumnFilters.length) {
+        for (let i = 0; i < resolvedColumnFilters.length; i++) {
+          currentColumnFilter = resolvedColumnFilters[i];
+          const id = currentColumnFilter.id;
+          row.columnFilters[id] = currentColumnFilter.filterFn(row, id, currentColumnFilter.resolvedValue, (filterMeta) => {
+            row.columnFiltersMeta[id] = filterMeta;
+          });
+        }
+      }
+      if (resolvedGlobalFilters.length) {
+        for (let i = 0; i < resolvedGlobalFilters.length; i++) {
+          currentGlobalFilter = resolvedGlobalFilters[i];
+          const id = currentGlobalFilter.id;
+          if (currentGlobalFilter.filterFn(row, id, currentGlobalFilter.resolvedValue, (filterMeta) => {
+            row.columnFiltersMeta[id] = filterMeta;
+          })) {
+            row.columnFilters.__global__ = true;
+            break;
+          }
+        }
+        if (row.columnFilters.__global__ !== true) {
+          row.columnFilters.__global__ = false;
+        }
+      }
+    }
+    const filterRowsImpl = (row) => {
+      for (let i = 0; i < filterableIds.length; i++) {
+        if (row.columnFilters[filterableIds[i]] === false) {
+          return false;
+        }
+      }
+      return true;
+    };
+    return filterRows(rowModel.rows, filterRowsImpl, table);
+  }, getMemoOptions(table.options, "debugTable", "getFilteredRowModel", () => table._autoResetPageIndex()));
+}
+function getGroupedRowModel() {
+  return (table) => memo(() => [table.getState().grouping, table.getPreGroupedRowModel()], (grouping, rowModel) => {
+    if (!rowModel.rows.length || !grouping.length) {
+      return rowModel;
+    }
+    const existingGrouping = grouping.filter((columnId) => table.getColumn(columnId));
+    const groupedFlatRows = [];
+    const groupedRowsById = {};
+    const groupUpRecursively = function(rows, depth, parentId) {
+      if (depth === void 0) {
+        depth = 0;
+      }
+      if (depth >= existingGrouping.length) {
+        return rows.map((row) => {
+          row.depth = depth;
+          groupedFlatRows.push(row);
+          groupedRowsById[row.id] = row;
+          if (row.subRows) {
+            row.subRows = groupUpRecursively(row.subRows, depth + 1, row.id);
+          }
+          return row;
+        });
+      }
+      const columnId = existingGrouping[depth];
+      const rowGroupsMap = groupBy(rows, columnId);
+      const aggregatedGroupedRows = Array.from(rowGroupsMap.entries()).map((_ref, index) => {
+        let [groupingValue, groupedRows2] = _ref;
+        let id = `${columnId}:${groupingValue}`;
+        id = parentId ? `${parentId}>${id}` : id;
+        const subRows = groupUpRecursively(groupedRows2, depth + 1, id);
+        const leafRows = depth ? flattenBy(groupedRows2, (row2) => row2.subRows) : groupedRows2;
+        const row = createRow(table, id, leafRows[0].original, index, depth, void 0, parentId);
+        Object.assign(row, {
+          groupingColumnId: columnId,
+          groupingValue,
+          subRows,
+          leafRows,
+          getValue: (columnId2) => {
+            if (existingGrouping.includes(columnId2)) {
+              if (row._valuesCache.hasOwnProperty(columnId2)) {
+                return row._valuesCache[columnId2];
+              }
+              if (groupedRows2[0]) {
+                var _groupedRows$0$getVal;
+                row._valuesCache[columnId2] = (_groupedRows$0$getVal = groupedRows2[0].getValue(columnId2)) != null ? _groupedRows$0$getVal : void 0;
+              }
+              return row._valuesCache[columnId2];
+            }
+            if (row._groupingValuesCache.hasOwnProperty(columnId2)) {
+              return row._groupingValuesCache[columnId2];
+            }
+            const column = table.getColumn(columnId2);
+            const aggregateFn = column == null ? void 0 : column.getAggregationFn();
+            if (aggregateFn) {
+              row._groupingValuesCache[columnId2] = aggregateFn(columnId2, leafRows, groupedRows2);
+              return row._groupingValuesCache[columnId2];
+            }
+          }
+        });
+        subRows.forEach((subRow) => {
+          groupedFlatRows.push(subRow);
+          groupedRowsById[subRow.id] = subRow;
+        });
+        return row;
+      });
+      return aggregatedGroupedRows;
+    };
+    const groupedRows = groupUpRecursively(rowModel.rows, 0);
+    groupedRows.forEach((subRow) => {
+      groupedFlatRows.push(subRow);
+      groupedRowsById[subRow.id] = subRow;
+    });
+    return {
+      rows: groupedRows,
+      flatRows: groupedFlatRows,
+      rowsById: groupedRowsById
+    };
+  }, getMemoOptions(table.options, "debugTable", "getGroupedRowModel", () => {
+    table._queue(() => {
+      table._autoResetExpanded();
+      table._autoResetPageIndex();
+    });
+  }));
+}
+function groupBy(rows, columnId) {
+  const groupMap = /* @__PURE__ */ new Map();
+  return rows.reduce((map, row) => {
+    const resKey = `${row.getGroupingValue(columnId)}`;
+    const previous = map.get(resKey);
+    if (!previous) {
+      map.set(resKey, [row]);
+    } else {
+      previous.push(row);
+    }
+    return map;
+  }, groupMap);
+}
 function getPaginationRowModel(opts) {
   return (table) => memo(() => [table.getState().pagination, table.getPrePaginationRowModel(), table.options.paginateExpandedRows ? void 0 : table.getState().expanded], (pagination, rowModel) => {
     if (!rowModel.rows.length) {
@@ -2789,6 +3139,7 @@ export {
   buildHeaderGroups,
   createCell,
   createColumn,
+  createColumnHelper,
   createRow,
   createTable,
   defaultColumnSizing,
@@ -2798,6 +3149,11 @@ export {
   functionalUpdate,
   getCoreRowModel,
   getExpandedRowModel,
+  getFacetedMinMaxValues,
+  getFacetedRowModel,
+  getFacetedUniqueValues,
+  getFilteredRowModel,
+  getGroupedRowModel,
   getMemoOptions,
   getPaginationRowModel,
   getSortedRowModel,
@@ -2807,6 +3163,7 @@ export {
   isSubRowSelected,
   makeStateUpdater,
   memo,
+  noop,
   orderColumns,
   passiveEventSupported,
   reSplitAlphaNumeric,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@redis-ui/table",
   "license": "UNLICENSED",
-  "version": "2.12.0",
+  "version": "2.18.0",
   "type": "module",
   "publishConfig": {
     "registry": "https://npm.pkg.github.com/"
@@ -31,10 +31,11 @@
     "styled-components": "^5.0.0"
   },
   "dependencies": {
-    "@redis-ui/components": "^39.11.0",
-    "@redis-ui/icons": "^6.1.0",
-    "@redis-ui/styles": "^12.5.0",
-    "@tanstack/react-table": "^8.9.8"
+    "@redis-ui/components": "^39.18.0",
+    "@redis-ui/icons": "^6.1.1",
+    "@redis-ui/styles": "^12.8.0",
+    "@tanstack/react-table": "^8.9.8",
+    "type-fest": "^3.13.1"
   },
   "devDependencies": {
     "@redislabsdev/eslint-config-redis-ui": "^2.0.0",

package/dist/Table/components/EmptyStateRow/EmptyStateRow.cjs

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const jsxRuntime = require("../../../node_modules/react/jsx-runtime.cjs");
-const TableHeaderCell_utils = require("../TableHeaderCell/TableHeaderCell.utils.cjs");
-const Table_style = require("../../Table.style.cjs");
-const EmptyStateRow = ({
-  table,
-  emptyState
-}) => jsxRuntime.jsxRuntimeExports.jsx(Table_style.TableBodyRow, {
-  "$stripedRows": false,
-  children: jsxRuntime.jsxRuntimeExports.jsx(Table_style.TableBodyCell, {
-    colSpan: TableHeaderCell_utils.normalizeCellSpan(table.getVisibleLeafColumns().length),
-    children: (emptyState == null ? void 0 : emptyState()) ?? "No data to display"
-  })
-});
-exports.EmptyStateRow = EmptyStateRow;

package/dist/Table/components/EmptyStateRow/EmptyStateRow.d.ts

@@ -1,8 +0,0 @@
-import { ReactNode } from 'react';
-import { Table } from '@tanstack/react-table';
-type EmptyStateRowProps<T extends object> = {
-    table: Table<T>;
-    emptyState?: () => ReactNode;
-};
-export declare const EmptyStateRow: <T extends object>({ table, emptyState }: EmptyStateRowProps<T>) => import("react/jsx-runtime").JSX.Element;
-export {};

package/dist/Table/components/EmptyStateRow/EmptyStateRow.js

@@ -1,16 +0,0 @@
-import { j as jsxRuntimeExports } from "../../../node_modules/react/jsx-runtime.js";
-import { normalizeCellSpan } from "../TableHeaderCell/TableHeaderCell.utils.js";
-import { TableBodyRow, TableBodyCell } from "../../Table.style.js";
-const EmptyStateRow = ({
-  table,
-  emptyState
-}) => jsxRuntimeExports.jsx(TableBodyRow, {
-  "$stripedRows": false,
-  children: jsxRuntimeExports.jsx(TableBodyCell, {
-    colSpan: normalizeCellSpan(table.getVisibleLeafColumns().length),
-    children: (emptyState == null ? void 0 : emptyState()) ?? "No data to display"
-  })
-});
-export {
-  EmptyStateRow
-};

package/dist/node_modules/@radix-ui/react-id/dist/index.cjs

@@ -1,32 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const React = require("react");
-const index = require("../../react-use-layout-effect/dist/index.cjs");
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
-  if (e) {
-    for (const k in e) {
-      if (k !== "default") {
-        const d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: () => e[k]
-        });
-      }
-    }
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-const React__namespace = /* @__PURE__ */ _interopNamespace(React);
-var useReactId = React__namespace["useId".toString()] || (() => void 0);
-var count = 0;
-function useId(deterministicId) {
-  const [id, setId] = React__namespace.useState(useReactId());
-  index.useLayoutEffect(() => {
-    setId((reactId) => reactId ?? String(count++));
-  }, [deterministicId]);
-  return id ? `radix-${id}` : "";
-}
-exports.useId = useId;

package/dist/node_modules/@radix-ui/react-id/dist/index.js

@@ -1,14 +0,0 @@
-import * as React from "react";
-import { useLayoutEffect as useLayoutEffect2 } from "../../react-use-layout-effect/dist/index.js";
-var useReactId = React["useId".toString()] || (() => void 0);
-var count = 0;
-function useId(deterministicId) {
-  const [id, setId] = React.useState(useReactId());
-  useLayoutEffect2(() => {
-    setId((reactId) => reactId ?? String(count++));
-  }, [deterministicId]);
-  return id ? `radix-${id}` : "";
-}
-export {
-  useId
-};

package/dist/node_modules/@radix-ui/react-use-layout-effect/dist/index.cjs

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const React = require("react");
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
-  if (e) {
-    for (const k in e) {
-      if (k !== "default") {
-        const d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: () => e[k]
-        });
-      }
-    }
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-const React__namespace = /* @__PURE__ */ _interopNamespace(React);
-var useLayoutEffect2 = Boolean(globalThis == null ? void 0 : globalThis.document) ? React__namespace.useLayoutEffect : () => {
-};
-exports.useLayoutEffect = useLayoutEffect2;

package/dist/node_modules/@radix-ui/react-use-layout-effect/dist/index.js

@@ -1,6 +0,0 @@
-import * as React from "react";
-var useLayoutEffect2 = Boolean(globalThis == null ? void 0 : globalThis.document) ? React.useLayoutEffect : () => {
-};
-export {
-  useLayoutEffect2 as useLayoutEffect
-};