@jielga/tmdatagrid 2.1.0 → 2.1.2

package/src/core/labelsSv.ts

@@ -45,7 +45,7 @@ export const TMDATAGRID_LABELS_SV: TMDataGridLabels = {
   columnsShowHideAll: "Visa/dölj alla",
   columnsReset: "Återställ layout",
   columnsResetHint:
-    "Återställer kolumnernas synlighet, ordning, bredder, fästning och gruppering",
+    "Återställer kolumnernas synlighet, ordning, bredd, låsning och gruppering",
   rowNumberColumnLabel: "Radnummer",
   noRows: "Inga rader att visa",
 
@@ -70,16 +70,16 @@ export const TMDATAGRID_LABELS_SV: TMDataGridLabels = {
   sortAsc: "Sortera stigande",
   sortDesc: "Sortera fallande",
   filterMenuItem: "Filtrera",
-  groupBy: (column) => `Gruppera på ${column}`,
-  ungroup: (column) => `Avgruppera ${column}`,
+  groupBy: (column) => `Gruppera efter ${column}`,
+  ungroup: (column) => `Sluta gruppera efter ${column}`,
   expandAllGroups: "Expandera alla grupper",
   collapseAllGroups: "Fäll ihop alla grupper",
-  pinLeft: "Fäst till vänster",
-  pinRight: "Fäst till höger",
-  unpin: "Lossa",
+  pinLeft: "Lås till vänster",
+  pinRight: "Lås till höger",
+  unpin: "Lås upp",
   moveLeft: "Flytta åt vänster",
   moveRight: "Flytta åt höger",
-  autosizeColumn: "Anpassa kolumnbredd",
+  autosizeColumn: "Autopassa kolumnbredd",
   hideColumn: "Dölj kolumn",
   filterOn: (column) => `Filtrera på ${column}`,
   sortColumn: (column) => `Sortera ${column}`,
@@ -91,7 +91,7 @@ export const TMDATAGRID_LABELS_SV: TMDataGridLabels = {
     pageCount < 0 ? `Sida ${page}` : `Sida ${page} av ${pageCount}`,
   groupedAllRows: (total) => `Grupperad · alla ${total} rader`,
   pagingSuspendedHint:
-    "Sidindelningen är avstängd medan raderna är grupperade: hela trädet renderas och virtualiseras. Avgruppera för att bläddra igen.",
+    "Sidindelningen är avstängd medan raderna är grupperade, och alla rader visas. Sluta gruppera för att bläddra igen.",
   previousPage: "Föregående sida",
   nextPage: "Nästa sida",
 
@@ -107,11 +107,11 @@ export const TMDATAGRID_LABELS_SV: TMDataGridLabels = {
   cancelRowEdit: "Avbryt redigering",
   editRowErrors: "Åtgärda de markerade cellerna",
   saveAllEdits: (rows) => (rows === 1 ? "Spara 1 rad" : `Spara ${rows} rader`),
-  discardAllEdits: "Förkasta",
+  discardAllEdits: "Ångra alla",
   editRowsStillOpen: (rows) =>
     rows === 1 ? "1 rad redigeras fortfarande" : `${rows} rader redigeras fortfarande`,
   confirmNewRow: "Lägg till rad",
-  discardNewRow: "Släng ny rad",
+  discardNewRow: "Avbryt ny rad",
   deleteRow: "Ta bort rad",
   restoreRow: "Återställ rad",
   revertRow: "Ångra ändringar",
@@ -122,37 +122,37 @@ export const TMDATAGRID_LABELS_SV: TMDataGridLabels = {
   cellCount: (count) => (count === 1 ? "1 cell" : `${count} celler`),
   copy: "Kopiera",
   exportCells: "Exportera celler",
-  includeHeaders: "Inkludera rubriker",
+  includeHeaders: "Ta med rubriker",
 
   exportAll: "Exportera alla rader",
   exportSelected: (count) =>
-    count === 1 ? "Exportera 1 vald rad" : `Exportera ${count} valda rader`,
+    count === 1 ? "Exportera 1 markerad rad" : `Exportera ${count} markerade rader`,
   exportPickerTitle: (format) => `Exportera som ${format}`,
   exportPickerHint: (selected) =>
     selected === null
       ? "Välj kolumner att exportera"
       : selected === 1
-        ? "Välj kolumner att exportera för den valda raden"
-        : `Välj kolumner att exportera för de ${selected} valda raderna`,
+        ? "Välj kolumner att exportera för den markerade raden"
+        : `Välj kolumner att exportera för de ${selected} markerade raderna`,
   exportPickerConfirm: "Exportera",
   exportPickerCancel: "Avbryt",
-  exportPickerSelectAll: "Välj alla",
+  exportPickerSelectAll: "Markera alla",
   exportPickerCount: (checked, total) => `${checked} av ${total}`,
   exportPickerHidden: "Dold",
 
-  selectColumnLabel: "Kryssrutemarkering",
-  selectAllRows: "Välj alla rader",
-  selectRow: "Välj rad",
-  selectGroup: "Välj grupp",
+  selectColumnLabel: "Radmarkering",
+  selectAllRows: "Markera alla rader",
+  selectRow: "Markera rad",
+  selectGroup: "Markera grupp",
 
   detailsColumnLabel: "Detaljer",
   showDetails: "Visa detaljer",
   hideDetails: "Dölj detaljer",
-  expandAllDetails: "Expandera alla detaljer",
-  collapseAllDetails: "Fäll ihop alla detaljer",
+  expandAllDetails: "Visa alla detaljer",
+  collapseAllDetails: "Dölj alla detaljer",
 
   groupColumnLabel: "Grupp",
-  blankGroupValue: "(Tom)",
+  blankGroupValue: "(Tomt)",
   expandGroup: (label) => `Expandera ${label}`,
   collapseGroup: (label) => `Fäll ihop ${label}`,
 };

package/src/core/quickSearch.ts

@@ -5,6 +5,7 @@ import {
 } from "@tanstack/match-sorter-utils";
 import {
   createSortedRowModel,
+  type Column,
   type Row,
   type RowData,
   type RowModel,
@@ -22,6 +23,57 @@ export type TMDataGridQuickSearchMode = "fuzzy" | "contains";
  */
 export const FUZZY_FILTER_FN_NAME = "tmDataGridFuzzy";
 
+/**
+ * Which columns the quick search reads, per core row model: the answer only
+ * changes with the data, and the model's identity changes with the data.
+ */
+const searchableColumns = new WeakMap<object, Map<string, boolean>>();
+
+/**
+ * The grid's `getColumnCanGlobalFilter`: TanStack's own rule - a column takes
+ * part when its first non-empty value is a string or a number, or when it
+ * says `enableGlobalFilter: true` - computed once per data change.
+ *
+ * TanStack's default scans the rows for that first value on every call,
+ * building every cell of every row it passes, and the grid asks on every
+ * header render. A column empty in every row therefore cost a full scan per
+ * header per render. Here the scan reads values only, and its answer is kept
+ * until the data changes.
+ */
+export function columnCanQuickSearch<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+  TValue,
+>(column: Column<TFeatures, TData, TValue>): boolean {
+  const { enableGlobalFilter } = column.columnDef as {
+    enableGlobalFilter?: boolean;
+  };
+  if (enableGlobalFilter === true) return true;
+  // A display column has no value to search.
+  if (!column.accessorFn) return false;
+  // Off the table as a plain record, for the same generic-features reason as
+  // the options read in isRankingActive.
+  const model = (
+    column.table as unknown as { getCoreRowModel: () => RowModel<TFeatures, TData> }
+  ).getCoreRowModel();
+  let byColumn = searchableColumns.get(model);
+  if (byColumn === undefined) {
+    byColumn = new Map();
+    searchableColumns.set(model, byColumn);
+  }
+  const known = byColumn.get(column.id);
+  if (known !== undefined) return known;
+  let searchable = false;
+  for (const row of model.flatRows) {
+    const value = row.getValue(column.id);
+    if (value == null) continue;
+    searchable = typeof value === "string" || typeof value === "number";
+    break;
+  }
+  byColumn.set(column.id, searchable);
+  return searchable;
+}
+
 /** What {@link fuzzyGlobalFilterFn} records per column via `addMeta`. */
 type FuzzyFilterMeta = { fuzzyRank: RankingInfo };
 

package/src/useTMDataGrid.tsx

@@ -90,6 +90,7 @@ import {
   type TMDataGridFiltersSettings,
 } from "./core/filterSurface";
 import {
+  columnCanQuickSearch,
   createFuzzyRankedSortedRowModel,
   fuzzyGlobalFilterFn,
   type TMDataGridQuickSearchMode,
@@ -1082,19 +1083,6 @@ type TMDataGridColumnDef<TData extends RowData> = ColumnDef<
   unknown
 >;
 
-/**
- * Point every column at the operator-dispatching filter function, and take
- * grouping's aggregation defaults back off, unless the column opted into its
- * own. Anything the consumer set wins - it is spread over these.
- *
- * The aggregation pair needs explaining. TanStack's grouping feature hands
- * every column `aggregationFn: "auto"` and an `aggregatedCell` that stringifies
- * whatever comes out, so merely registering the feature would have every
- * numeric column silently sum itself and every date column show a range the
- * moment anything is grouped. That is a summary table, and "group by" is not a
- * request for one. Cleared here, so a grouped grid is a tree until a column
- * says otherwise - `aggregationFn: "sum"` on the column that wants it.
- */
 /**
  * Drops the control lanes' entries from a visibility map.
  *
@@ -1115,6 +1103,19 @@ function withoutControlColumnVisibility(
   return scrubbed;
 }
 
+/**
+ * Point every column at the operator-dispatching filter function, and take
+ * the aggregation defaults back off, unless the column opted into its own.
+ * Anything the consumer set wins - it is spread over these.
+ *
+ * The aggregation pair needs explaining. TanStack's row aggregation feature
+ * hands every column `aggregationFn: "auto"` and an `aggregatedCell` that
+ * stringifies whatever comes out, so merely registering the feature would have
+ * every numeric column silently sum itself and every date column show a range
+ * the moment anything is grouped. That is a summary table, and "group by" is
+ * not a request for one. Cleared here, so a grouped grid is a tree until a
+ * column says otherwise - `aggregationFn: "sum"` on the column that wants it.
+ */
 function withTMDataGridDefaults<TData extends RowData>(
   columns: ReadonlyArray<TMDataGridColumnDef<TData>>,
 ): Array<TMDataGridColumnDef<TData>> {
@@ -1238,7 +1239,6 @@ export function useTMDataGrid<TData extends RowData>({
     ],
   );
 
-  const pinningEnabled = options.enableColumnPinning !== false;
   const selectColumnEnabled = features.selectColumn;
   const groupColumnEnabled = features.grouping;
   // The lane that opens the panels. Nothing to switch on: a grid with no
@@ -1270,13 +1270,15 @@ export function useTMDataGrid<TData extends RowData>({
   // and re-applied on top of anything restored: a snapshot cannot unpin one,
   // and a snapshot taken before `detailsColumnPosition` changed cannot pin the
   // details lane to the edge it has since left.
+  //
+  // Not gated on `enableColumnPinning`: that switch takes pinning away from the
+  // user, not from the grid's own lanes, which hold the edges either way.
   const structuralPinning = (
     restored: Partial<ColumnPinningState> | undefined,
   ): ColumnPinningState => {
     const own = (ids: string[] | undefined) =>
       (ids ?? []).filter((id) => !isGeneratedColumn(id));
-    const lane = (enabled: boolean, id: string) =>
-      enabled && pinningEnabled ? [id] : [];
+    const lane = (enabled: boolean, id: string) => (enabled ? [id] : []);
     const detailsOn = (edge: "left" | "right") =>
       detailsColumnEnabled && detailsColumnPosition === edge;
     return {
@@ -1476,6 +1478,11 @@ export function useTMDataGrid<TData extends RowData>({
     edit.store,
     (state) => state.committedValues,
   );
+  // Subscribed for the re-render alone - the selection predicate below reads
+  // the marks live. TanStack 9.2 caches a group row's "all / some selected"
+  // on the predicate's identity, and only a render hands it a new one; without
+  // this a mark would leave the group's checkbox on its old answer.
+  useSelector(edit.store, (state) => state.deletedRowIds);
   const newRowsSticky = features.editNewRowsSticky;
   const editCreatedIds = useSelector(
     edit.store,
@@ -1577,6 +1584,9 @@ export function useTMDataGrid<TData extends RowData>({
       options.quickSearchMode === "contains"
         ? "includesString"
         : "tmDataGridFuzzy",
+    // Which columns the quick search reads - TanStack's rule, computed once
+    // per data change instead of once per call. See columnCanQuickSearch.
+    getColumnCanGlobalFilter: columnCanQuickSearch,
     // Grouping by a column takes it out of the grid, the way AG Grid does it:
     // its values have moved into the tree column, so leaving it in place would
     // show every row the same value it was grouped under. Overridable - pass
@@ -1620,11 +1630,17 @@ export function useTMDataGrid<TData extends RowData>({
     getRowId: shownGetRowId,
     // Row details ride on `expanded`, the same state the tree uses - but a data
     // row answers `getCanExpand()` false, since TanStack's fallback is
-    // `subRows.length > 0`. `() => true` is the right answer for a group row
-    // too, so nothing here has to tell the two apart, and a consumer passing
-    // their own predicate still wins.
-    ...(renderDetails !== undefined
-      ? { getRowCanExpand: options.getRowCanExpand ?? (() => true) }
+    // `subRows.length > 0`, so under `renderDetails` every row can expand.
+    // A consumer's own predicate decides the data rows, never a group row:
+    // TanStack builds a group row on its first child's record, and since 9.2
+    // `toggleExpanded` refuses a row that cannot expand - so a predicate
+    // rejecting that record would leave the group's chevron dead.
+    ...(renderDetails !== undefined || options.getRowCanExpand !== undefined
+      ? {
+          getRowCanExpand: (row: Row<TMDataGridFeatures, TData>) =>
+            row.getIsGrouped() ||
+            (options.getRowCanExpand?.(row) ?? true),
+        }
       : {}),
     // Always a predicate, never the passthrough: TanStack defaults the option
     // to `true` once the feature is registered, and the grid's default is off.