@opencorestack/opengridx 3.7.1 → 3.8.1

package/lib/types/rows.ts

@@ -5,8 +5,6 @@ export type GridRowId = string | number;
 export interface GridRowModel {
   /** Uniquely identifies the row. */
   id: GridRowId;
-  /** Internal: row is a skeleton placeholder during infinite-scroll loading. */
-  _isSkeleton?: boolean;
   /** Internal: server-reported child count for lazy-loaded tree nodes. */
   serverChildrenCount?: number;
   /** Any other dynamic row properties. */

package/lib/types/state.ts

@@ -2,11 +2,20 @@ import type { GridRowId, GridRowModel, GridPinnedRows } from './rows';
 import type { GridColDef, GridColumnVisibilityModel, GridPinnedColumns } from './columns';
 
 export interface GridInternalState {
+  /**
+   * The row store. Cell edits (`REPLACE_ROW` / `REPLACE_ROWS`) update `idRowsLookup`, `idByRow`
+   * and `indexById` IN PLACE and only replace `rows`: never rely on those maps changing identity
+   * to detect an edit; depend on `rows` (or `state.rows`) instead. `SET_ROWS` builds new maps.
+   */
   rows: {
     idRowsLookup: Map<GridRowId, GridRowModel>;
     allRows: GridRowId[];
     /** Row object → its getRowId() key. Rows are stored untouched, so this is how ids are resolved. */
     idByRow: Map<GridRowModel, GridRowId>;
+    /** The stored rows in `allRows` order. */
+    rows: GridRowModel[];
+    /** Row id → its index in `allRows` / `rows`. */
+    indexById: Map<GridRowId, number>;
   };
   pagination: {
     /** Server-reported total (dataSource responses); undefined until one arrives. */

package/lib/utils/cellSelection.ts

@@ -17,8 +17,6 @@ export function isRangeColumnField(field: string): boolean {
 export const isSameCoordinates = (a: GridCellCoordinates | null | undefined, b: GridCellCoordinates | null | undefined): boolean =>
     a === b || (!!a && !!b && a.id === b.id && a.field === b.field);
 
-export const isSingleCellRange = (range: GridCellRange): boolean => isSameCoordinates(range.anchor, range.head);
-
 /** A model holding the same range(s) as `b`. */
 export function isSameCellSelectionModel(a: GridCellSelectionModel, b: GridCellSelectionModel): boolean {
     if (a === b) return true;

package/lib/utils/editing/index.ts

@@ -20,7 +20,7 @@ export function resolveCellEditable<R extends GridRowModel>(
 ): boolean {
     const { row, field, value, colDef, rowIndex, colIndex, rowMeta } = params;
     if (!colDef.editable) return false;
-    if (rowMeta?.isGroupRow || row._isSkeleton) return false;
+    if (rowMeta?.isGroupRow) return false;
     if (!isCellEditable) return true;
     try {
         return Boolean(isCellEditable({ row, field, value, colDef, rowIndex, colIndex }));

package/lib/utils/editing/targets.ts

@@ -5,6 +5,7 @@ import { isSystemField } from '../focus';
 import { isSyntheticRowId } from '../syntheticRows';
 import { resolveCellEditable } from './index';
 import { getCellValue } from '../values';
+import { getRowIndex } from '../rowIndex';
 
 /**
  * Where batch edits (paste, range clear, undo/redo) land: the renderable rows and the range columns
@@ -26,9 +27,7 @@ export function buildEditTargetContext<R extends GridRowModel>(
     getRowId: (row: R) => GridRowId,
     navigationColumns: ReadonlyArray<GridColDef<R>>,
 ): GridEditTargetContext<R> {
-    const rowIds = rows.map(getRowId);
-    const rowIndexById = new Map<GridRowId, number>();
-    rowIds.forEach((id, index) => { if (!rowIndexById.has(id)) rowIndexById.set(id, index); });
+    const { rowIds, rowIndexById } = getRowIndex(rows, getRowId, 'renderable');
     const columns = navigationColumns.filter(c => isRangeColumnField(c.field));
     const colIndexByField = new Map<string, number>();
     columns.forEach((c, index) => { colIndexByField.set(c.field, index); });

package/lib/utils/filtering/filterInput.ts

@@ -0,0 +1,45 @@
+import type { GridColDef, GridFilterOperator } from '../../types';
+
+/**
+ * Helpers shared by the filter panel and the header filter row: both edit a filter item's value
+ * through a text box or a select of the column's `valueOptions`.
+ */
+
+/** One entry of a `valueOptions` select. `key` is the option's index, used as the `<option>` value. */
+export interface FilterValueOption {
+    key: string;
+    value: unknown;
+    label: string;
+}
+
+export function getFilterValueOptions(col: Pick<GridColDef, 'valueOptions'>): FilterValueOption[] {
+    return (col.valueOptions ?? []).map((option, index) => (
+        option !== null && typeof option === 'object'
+            ? { key: String(index), value: option.value, label: option.label }
+            : { key: String(index), value: option, label: String(option) }
+    ));
+}
+
+/**
+ * Whether a filter value selects this option: the same value, or the same text ignoring case (a
+ * value typed or restored from a URL is a string). A list matches by its first entry.
+ */
+export function matchesFilterValueOption(option: FilterValueOption, value: unknown): boolean {
+    const single = Array.isArray(value) ? value[0] : value;
+    if (Object.is(option.value, single)) return true;
+    return single != null && String(option.value).toLowerCase() === String(single).toLowerCase();
+}
+
+/** The item value for typed text. `isAnyOf` takes a comma-separated list. */
+export function filterValueFromInputText(text: string, operator: GridFilterOperator): unknown {
+    if (operator === 'isAnyOf') return text.split(',').map(part => part.trim()).filter(part => part !== '');
+    return text;
+}
+
+/** Equal filter values: the same value, dates at the same time, or lists of equal values. */
+export function isSameFilterValue(a: unknown, b: unknown): boolean {
+    if (Object.is(a, b)) return true;
+    if (a instanceof Date && b instanceof Date) return a.getTime() === b.getTime();
+    if (Array.isArray(a) && Array.isArray(b)) return a.length === b.length && a.every((v, i) => isSameFilterValue(v, b[i]));
+    return false;
+}

package/lib/utils/filtering/index.ts

@@ -362,19 +362,6 @@ export function applyQuickFilter<R extends GridRowModel>(
   return predicate ? predicate(row) : true;
 }
 
-/**
- * Check if a row matches the filter model. Compiles the model on every call: to test many rows,
- * build a predicate once with createRowFilter.
- */
-export function isRowMatchingFilter<R extends GridRowModel>(
-  row: R,
-  filterModel: GridFilterModel | GridFilterGroup,
-  columns?: GridColumnLookup
-): boolean {
-  const predicate = createRowFilter(filterModel, columns);
-  return predicate ? predicate(row) : true;
-}
-
 export function filterRows<R extends GridRowModel>(
   rows: R[],
   filterModel: GridFilterModel,
@@ -396,21 +383,6 @@ export function filterRows<R extends GridRowModel>(
   return rows.filter(row => predicate(row));
 }
 
-export function getDefaultOperator(type?: string): GridFilterOperator {
-  switch (type) {
-    case 'number':
-      return '=';
-    case 'date':
-      return 'is';
-    case 'boolean':
-      return 'is';
-    case 'singleSelect':
-      return 'isAnyOf';
-    default:
-      return 'contains';
-  }
-}
-
 export function getOperatorsForType(type?: string): GridFilterOperator[] {
   switch (type) {
     case 'number':

package/lib/utils/gridApiRows.ts

@@ -9,7 +9,7 @@ export interface CollectAllFilteredRowsParams<R extends GridRowModel> {
     /** Every unpinned row that passes the filter, sorted, across all pages. */
     sortedUnpinnedRows: R[];
     pinnedBottomRows: R[];
-    rowMetaMap: Map<GridRowId, GridRowMeta>;
+    rowMetaMap: ReadonlyMap<GridRowId, GridRowMeta>;
     getRowId: (row: GridRowModel) => GridRowId;
     /**
      * With a hierarchy: the rows that pass the filter (the set select-all and the footer use).

package/lib/utils/grouping/groupedExportRows.ts

@@ -16,7 +16,7 @@ export interface BuildGroupedExportRowsParams<R extends GridRowModel> {
      */
     rows: R[];
     getRowId: (row: R) => GridRowId;
-    rowMetaMap: Map<GridRowId, GridRowMeta>;
+    rowMetaMap: ReadonlyMap<GridRowId, GridRowMeta>;
     columns: GridColDef<R>[];
     aggregationModel: GridAggregationModel;
     /** The footer's grand total (already over the filtered data rows); omitted when null. */

package/lib/utils/grouping/layeredMap.ts

@@ -0,0 +1,52 @@
+/**
+ * A read-only view of two maps with disjoint keys, read as one: `top` first, then `base`. Row
+ * grouping keeps one entry per leaf row in `base` (built once per tree) and the group rows in
+ * `top` (rebuilt on every expand / collapse), so toggling a group at 1M rows does not copy a
+ * 1M-entry map. Iteration yields `base` entries, then `top` entries.
+ */
+export class LayeredMap<K, V> implements ReadonlyMap<K, V> {
+    private readonly base: ReadonlyMap<K, V>;
+    private readonly top: ReadonlyMap<K, V>;
+
+    constructor(base: ReadonlyMap<K, V>, top: ReadonlyMap<K, V>) {
+        this.base = base;
+        this.top = top;
+    }
+
+    get size(): number {
+        return this.base.size + this.top.size;
+    }
+
+    get(key: K): V | undefined {
+        const value = this.top.get(key);
+        return value !== undefined || this.top.has(key) ? value : this.base.get(key);
+    }
+
+    has(key: K): boolean {
+        return this.top.has(key) || this.base.has(key);
+    }
+
+    forEach(callback: (value: V, key: K, map: ReadonlyMap<K, V>) => void, thisArg?: unknown): void {
+        this.base.forEach((value, key) => callback.call(thisArg, value, key, this));
+        this.top.forEach((value, key) => callback.call(thisArg, value, key, this));
+    }
+
+    *entries(): MapIterator<[K, V]> {
+        yield* this.base.entries();
+        yield* this.top.entries();
+    }
+
+    *keys(): MapIterator<K> {
+        yield* this.base.keys();
+        yield* this.top.keys();
+    }
+
+    *values(): MapIterator<V> {
+        yield* this.base.values();
+        yield* this.top.values();
+    }
+
+    [Symbol.iterator](): MapIterator<[K, V]> {
+        return this.entries();
+    }
+}

package/lib/utils/pinning/index.ts

@@ -137,67 +137,6 @@ export function getPinnedEdgeFields<R extends GridRowModel = GridRowModel>(
     return { lastLeft, firstRight };
 }
 
-export function isColumnPinnable<R extends GridRowModel = GridRowModel>(
-    colDef: GridColDef<R>
-): boolean {
-    return colDef.pinnable !== false;
-}
-
-export function pinColumn(
-    field: string,
-    position: GridPinnedPosition,
-    currentPinning?: GridColumnPinning
-): GridColumnPinning {
-    const newPinning: GridColumnPinning = {
-        left: [...(currentPinning?.left || [])],
-        right: [...(currentPinning?.right || [])]
-    };
-
-    newPinning.left = (newPinning.left || []).filter(f => f !== field);
-    newPinning.right = (newPinning.right || []).filter(f => f !== field);
-
-    if (position === 'left') {
-        if (!newPinning.left) newPinning.left = [];
-        newPinning.left.push(field);
-    } else {
-        if (!newPinning.right) newPinning.right = [];
-        newPinning.right.push(field);
-    }
-
-    return newPinning;
-}
-
-export function unpinColumn(
-    field: string,
-    currentPinning?: GridColumnPinning
-): GridColumnPinning {
-    if (!currentPinning) return {};
-
-    return {
-        left: currentPinning.left?.filter(f => f !== field) || [],
-        right: currentPinning.right?.filter(f => f !== field) || []
-    };
-}
-
-export function getPinnedColumnsWidth(
-    columns: GridColDef[],
-    columnWidths: Record<string, number>,
-    position: GridPinnedPosition,
-    pinnedColumns?: GridColumnPinning
-): number {
-    if (!pinnedColumns) return 0;
-
-    const pinnedFields = position === 'left' ? pinnedColumns.left : pinnedColumns.right;
-    if (!pinnedFields) return 0;
-
-    return pinnedFields.reduce((total, field) => {
-        const col = columns.find(c => c.field === field);
-        if (!col) return total;
-
-        return total + getRenderedColumnWidth(col, columnWidths);
-    }, 0);
-}
-
 export function isRowPinned(
     rowId: GridRowId,
     pinnedRows?: GridRowPinning
@@ -263,52 +202,6 @@ export function getPinnedRowGroups<R extends GridRowModel = GridRowModel>(
     return { top, center, bottom };
 }
 
-export function pinRow(
-    rowId: GridRowId,
-    position: 'top' | 'bottom',
-    currentPinning?: GridRowPinning
-): GridRowPinning {
-    const newPinning: GridRowPinning = {
-        top: [...(currentPinning?.top || [])],
-        bottom: [...(currentPinning?.bottom || [])]
-    };
-
-    newPinning.top = (newPinning.top || []).filter(id => id !== rowId);
-    newPinning.bottom = (newPinning.bottom || []).filter(id => id !== rowId);
-
-    if (position === 'top') {
-        if (!newPinning.top) newPinning.top = [];
-        newPinning.top.push(rowId);
-    } else {
-        if (!newPinning.bottom) newPinning.bottom = [];
-        newPinning.bottom.push(rowId);
-    }
-
-    return newPinning;
-}
-
-export function unpinRow(
-    rowId: GridRowId,
-    currentPinning?: GridRowPinning
-): GridRowPinning {
-    if (!currentPinning) return {};
-
-    return {
-        top: currentPinning.top?.filter(id => id !== rowId) || [],
-        bottom: currentPinning.bottom?.filter(id => id !== rowId) || []
-    };
-}
-
-export function getPinnedRowsCount(
-    position: 'top' | 'bottom',
-    pinnedRows?: GridRowPinning
-): number {
-    if (!pinnedRows) return 0;
-
-    const pinnedIds = position === 'top' ? pinnedRows.top : pinnedRows.bottom;
-    return pinnedIds?.length || 0;
-}
-
 /**
  * The column pinning model after the column menu pins `field` to `side` (appended after the
  * columns already pinned there) or unpins it (`null`). The field is removed from the other side.

package/lib/utils/rowIndex.ts

@@ -0,0 +1,67 @@
+import type { GridRowId } from '../types';
+
+/** The ids of a row array in order, and each id's first index. */
+export interface GridRowIndex {
+    rowIds: GridRowId[];
+    rowIndexById: Map<GridRowId, number>;
+}
+
+interface CacheEntry {
+    rows: readonly object[];
+    value: GridRowIndex;
+}
+
+// Last result per id resolver and view. The grid's resolver keeps its identity while the row store
+// keeps its id maps (cell edits do), so the entry lives exactly as long as it can be reused.
+const cache = new WeakMap<(row: never) => GridRowId, Map<string, CacheEntry>>();
+
+function build<R extends object>(rows: readonly R[], getRowId: (row: R) => GridRowId): GridRowIndex {
+    const rowIds = new Array<GridRowId>(rows.length);
+    const rowIndexById = new Map<GridRowId, number>();
+    for (let index = 0; index < rows.length; index++) {
+        const id = getRowId(rows[index]);
+        rowIds[index] = id;
+        if (!rowIndexById.has(id)) rowIndexById.set(id, index);
+    }
+    return { rowIds, rowIndexById };
+}
+
+/**
+ * `rows.map(getRowId)` plus an id → first index map, reusing the previous result for the same
+ * resolver and `view` when the ids are unchanged position by position. A cell edit replaces row
+ * objects but never moves or re-keys rows, so after an edit only the replaced positions are
+ * resolved (a reference comparison per row instead of a map lookup per row, ~20× cheaper at 1M
+ * rows), and callers memoized on the returned object do not recompute. Treat the result as
+ * read-only: it may be shared.
+ */
+export function getRowIndex<R extends object>(
+    rows: readonly R[],
+    getRowId: (row: R) => GridRowId,
+    view: string,
+): GridRowIndex {
+    let byView = cache.get(getRowId);
+    const previous = byView?.get(view);
+    if (previous && previous.rows.length === rows.length) {
+        const prevRows = previous.rows as readonly R[];
+        const prevIds = previous.value.rowIds;
+        let same = true;
+        for (let index = 0; index < rows.length; index++) {
+            const row = rows[index];
+            if (row !== prevRows[index] && getRowId(row) !== prevIds[index]) {
+                same = false;
+                break;
+            }
+        }
+        if (same) {
+            previous.rows = rows;
+            return previous.value;
+        }
+    }
+    const value = build(rows, getRowId);
+    if (!byView) {
+        byView = new Map();
+        cache.set(getRowId, byView);
+    }
+    byView.set(view, { rows, value });
+    return value;
+}

package/lib/utils/sorting/index.ts

@@ -18,7 +18,8 @@ const RANK_STRING = 3;
 const RANK_OTHER = 4;
 
 /** A normalized sort value. null is the empty bucket (null, undefined, NaN, Invalid Date, unparsable). */
-type SortKey = { rank: number; num: number; str: string } | null;
+/** `big`: the exact value of a bigint key, whose `num` is only its nearest double. */
+type SortKey = { rank: number; num: number; str: string; big?: bigint } | null;
 
 function numberKey(rank: number, num: number): SortKey {
   return { rank, num, str: '' };
@@ -32,6 +33,7 @@ function numberKey(rank: number, num: number): SortKey {
 function toSortKey(value: unknown, type?: GridColDef['type']): SortKey {
   if (value == null) return null;
   if (type === 'number') {
+    if (typeof value === 'bigint') return { rank: RANK_NUMBER, num: Number(value), str: '', big: value };
     const n = toNumber(value);
     return n === null ? null : numberKey(RANK_NUMBER, n);
   }
@@ -43,7 +45,7 @@ function toSortKey(value: unknown, type?: GridColDef['type']): SortKey {
     case 'number':
       return Number.isNaN(value) ? null : numberKey(RANK_NUMBER, value);
     case 'bigint':
-      return numberKey(RANK_NUMBER, Number(value));
+      return { rank: RANK_NUMBER, num: Number(value), str: '', big: value };
     case 'boolean':
       return numberKey(RANK_BOOLEAN, value ? 1 : 0);
     case 'string':
@@ -65,9 +67,29 @@ function compareSortKeys(a: SortKey, b: SortKey): number {
   if (b === null) return -1;
   if (a.rank !== b.rank) return a.rank - b.rank;
   if (a.rank === RANK_STRING || a.rank === RANK_OTHER) return collator.compare(a.str, b.str);
-  return a.num < b.num ? -1 : a.num > b.num ? 1 : 0;
+  if (a.num !== b.num) return a.num < b.num ? -1 : 1;
+  // Number(bigint) rounds monotonically, so only equal doubles can hide an order between bigints.
+  return a.big !== undefined || b.big !== undefined ? compareExact(a.big ?? a.num, b.big ?? b.num) : 0;
 }
 
+/** Exact ascending comparison of numbers and bigints (no rounding of either). */
+function compareExact(a: number | bigint, b: number | bigint): number {
+  if (typeof a === 'number' && typeof b === 'number') return a < b ? -1 : a > b ? 1 : 0;
+  if (typeof a === 'bigint' && typeof b === 'bigint') return a < b ? -1 : a > b ? 1 : 0;
+  if (typeof a === 'number') return -compareExact(b, a);
+  // a is a bigint, b a number.
+  const n = b as number;
+  if (!Number.isFinite(n)) return n > 0 ? -1 : 1;
+  const floor = Math.floor(n);
+  const whole = BigInt(floor);
+  if (a < whole) return -1;
+  if (a > whole) return 1;
+  return n > floor ? -1 : 0;
+}
+
+const isUnsafeBigInt = (value: unknown): value is bigint =>
+  typeof value === 'bigint' && (value > BigInt(Number.MAX_SAFE_INTEGER) || value < BigInt(Number.MIN_SAFE_INTEGER));
+
 /** Reverse an ascending comparison for 'desc'. */
 export function applySortDirection(comparison: number, direction: 'asc' | 'desc'): number {
   if (comparison === 0) return 0;
@@ -115,36 +137,6 @@ export function callSortComparator(
 
 const defaultRowId = (row: GridRowModel): GridRowId => row.id;
 
-/**
- * Compare two rows by a sort model, reading cells through `valueGetter` and using each column's
- * `type` (or its `sortComparator`). Returns 0 when every key is equal.
- */
-export function compareRowsBySortModel(
-  a: GridRowModel,
-  b: GridRowModel,
-  sortModel: readonly GridSortItem[],
-  columns?: GridColumnLookup,
-  getRowId: (row: GridRowModel) => GridRowId = defaultRowId
-): number {
-  for (const sortItem of sortModel) {
-    const colDef = columns?.byField.get(sortItem.field);
-    const va = getCellValue(a, sortItem.field, colDef);
-    const vb = getCellValue(b, sortItem.field, colDef);
-    const comparison = colDef?.sortComparator
-      ? applySortDirection(
-          callSortComparator(
-            colDef.sortComparator,
-            { id: getRowId(a), field: sortItem.field, row: a, value: va },
-            { id: getRowId(b), field: sortItem.field, row: b, value: vb }
-          ),
-          sortItem.sort
-        )
-      : compareValues(va, vb, sortItem.sort, colDef?.type);
-    if (comparison !== 0) return comparison;
-  }
-  return 0;
-}
-
 export function sortRows<R extends GridRowModel>(
   rows: R[],
   sortModel: GridSortItem[],
@@ -230,6 +222,19 @@ function rankTexts(buckets: Map<string, number[]>, num: Float64Array): void {
   }
 }
 
+/** Replaces the numbers of a column holding unsafe bigints by their exact ascending position. */
+function rankNumbersExactly(group: Uint8Array, num: Float64Array, bigints: ReadonlyMap<number, bigint>): void {
+  const indices: number[] = [];
+  for (let i = 0; i < group.length; i++) if (group[i] === RANK_NUMBER) indices.push(i);
+  const exact = (i: number): number | bigint => bigints.get(i) ?? num[i];
+  indices.sort((ia, ib) => compareExact(exact(ia), exact(ib)));
+  let position = 0;
+  for (let k = 0; k < indices.length; k++) {
+    if (k > 0 && compareExact(exact(indices[k - 1]), exact(indices[k])) !== 0) position++;
+    num[indices[k]] = position;
+  }
+}
+
 function addToBucket(buckets: Map<string, number[]>, text: string, index: number): void {
   const bucket = buckets.get(text);
   if (bucket) bucket.push(index);
@@ -248,9 +253,12 @@ function encodeSortColumn(count: number, valueAt: (i: number) => unknown, typeAt
   const num = new Float64Array(count);
   const strings = new Map<string, number[]>();
   const others = new Map<string, number[]>();
+  // Bigints beyond 2^53 lose precision as doubles: if any appears, numbers are re-ranked exactly.
+  let bigints: Map<number, bigint> | null = null;
   for (let i = 0; i < count; i++) {
     const value = valueAt(i);
     const type = typeAt(i);
+    if (isUnsafeBigInt(value) && type !== 'date') (bigints ??= new Map()).set(i, value);
     if (typeof value === 'number' && type !== 'date') {
       // toSortKey for a number, without the allocation.
       if (Number.isNaN(value)) {
@@ -273,6 +281,7 @@ function encodeSortColumn(count: number, valueAt: (i: number) => unknown, typeAt
   }
   rankTexts(strings, num);
   rankTexts(others, num);
+  if (bigints) rankNumbersExactly(group, num, bigints);
   return { kind: 'encoded', group, num };
 }
 

package/lib/utils/values.ts

@@ -84,6 +84,8 @@ export function getFormattedValue<R extends GridRowModel>(
     }
 }
 
+const RADIX_PREFIX = /^[+-]?0[box]/i;
+
 /**
  * Coerce a cell or filter value to a number. Returns null for null/undefined, blank strings,
  * NaN and anything that does not parse, so an empty cell is never read as 0.
@@ -94,8 +96,10 @@ export function toNumber(value: unknown): number | null {
     if (typeof value === 'string') {
         const trimmed = value.trim();
         if (trimmed === '') return null;
+        // Number() also reads "0x10", "0b1", "0o7" and "Infinity", which nobody types as a number.
+        if (RADIX_PREFIX.test(trimmed)) return null;
         const n = Number(trimmed);
-        return Number.isNaN(n) ? null : n;
+        return Number.isFinite(n) ? n : null;
     }
     if (typeof value === 'boolean') return null;
     if (value instanceof Date) {

package/llms.txt

@@ -1,6 +1,6 @@
 # OpenGridX — AI Agent Context
 # Package: @opencorestack/opengridx
-# Version: 3.7.0
+# Version: 3.8.1
 # Docs: https://opencorestack.github.io/OpenGridX/
 # This file is machine-readable. AI developers: start here.
 
@@ -721,9 +721,13 @@ Arrows move between cells (skipping hidden columns); Home/End, Ctrl+Home/End, Pa
 13. **`valueFormatter` + `renderCell`**: `renderCell` receives `params.formattedValue` (v2.1+), so a custom renderer can reuse the formatter instead of duplicating it.
 14. **`slots.footer`** replaces the pagination area and receives `apiRef`, `aggregationModel`, `aggregationResult`, `rowCount` (filtered data rows excluding pinned rows in flat grids — data rows under tree data / grouping; the server total with `paginationMode="server"`), `pagination`, `paginationModel`, `pageSizeOptions` and `onPaginationModelChange`.
 15. **v3: no underscore row fields** — `params.row._hasChildren` / `_treeDepth` / … are `undefined` since 3.0.0; use `params.rowMeta?.hasChildren` etc. Under grouping and tree data `params.row` is the consumer's own object; never mutate it in render callbacks. Migration guide: `docs/migration/v2-to-v3.md`.
-16. **Row limit**: the scroll height is `rows × rowHeight` px and browsers cap element height (Chromium 33,554,432 px), so one scrolling grid reaches ~645,000 rows at 52 px. Page or stream beyond that.
+16. **Row limit**: the scroll height is `rows × rowHeight` px and browsers cap element height: Chromium and WebKit about 33.5M px (~645,000 rows at 52 px), Firefox about 17.9M px (~344,000 rows). Since 3.5.1 the grid caps its content height to the measured limit and warns in development, naming how many rows are reachable. Beyond that use a `dataSource` (server pages or infinite scroll) or pagination; `density="compact"` stretches each limit about 1.6×.
 17. **Server modes without dataSource**: with `paginationMode` / `sortingMode` / `filterMode` = `'server'` the grid shows `rows` as given (no slicing, sorting or filtering). Fetch from the change callbacks and control the models.
 18. **`valueFormatter` / `valueGetter` params are `unknown`-typed**: cast (`(value as number).toFixed(2)`) before calling methods, or TypeScript strict mode rejects it.
 19. **Inline `columns` are reused while shallow-equal**: a new array with the same column objects does not re-run filtering/sorting, but mutating a column object in place is not detected — pass new objects when a definition changes.
 20. **Next.js App Router**: render `<DataGrid>` from a `'use client'` file (column functions such as `valueFormatter` cannot cross from a Server Component) and import the stylesheet in `app/layout.tsx`. Rows fetched in a Server Component pass as props (serialisable data only). The ES bundle starts with `'use client'` (3.6+), so a Server Component may also render `<DataGrid>` with serialisable props. `next build` fails with `Can't resolve 'exceljs'` unless the optional peers are installed or aliased in `next.config.ts` (`turbopack.resolveAlias` to an empty module; webpack `resolve.alias[name] = false`). `@opencorestack/opengridx/ai` runs on the server too, but the validation brand is a Symbol that does not survive JSON: validate on the client (`createGridAiPromptHandler`). Guide: `docs/features/nextjs.md`.
-21. **Right-to-left**: wrap the grid in `dir="rtl"` (or set `document.dir`); no prop. Works without pinned columns (3.6+): column order, text alignment (`align: 'left'`/'right' = start/end), horizontal scrolling + column virtualization, ArrowLeft = next column, resize handle on the left edge, fill handle bottom-left, toolbar panels open rightwards. **Pinned columns are not supported in RTL** (they do not stick); do not pin in RTL grids. Guide: `docs/features/rtl.md`.
+21. **Right-to-left**: wrap the grid in `dir="rtl"` (or set `document.dir`); no prop. Works without pinned columns (3.6+): column order, text alignment (`align: 'left'`/'right' = start/end), horizontal scrolling + column virtualization, ArrowLeft = next column, resize handle on the left edge, fill handle bottom-left, toolbar panels open rightwards. Pinned columns work in RTL (3.6+): `pinnedColumns.left` / `right` are logical (inline start / end), so `left` sticks to the right edge in RTL. Guide: `docs/features/rtl.md`.
+22. **Rows are replaced, not mutated** (3.8+ relies on it): change a row by passing a new object (`rows.map(r => r.id === id ? { ...r, ...changes } : r)`). The quick filter caches each row object's searched text, and an in-place mutation keeps the old text. A `valueFormatter` that reads outside state needs new column definitions when that state changes.
+23. **Large grids (3.8+)**: committing an edit, paste, undo, redo or fill at 1,000,000 rows takes ~35–50 ms; expanding a group ~135 ms, collapsing ~1 ms; select-all ~270 ms (it builds the selection model array). Sorting is ~0.4–0.5 s at 1M rows.
+24. **Styling buttons inside the grid (3.8.1+)**: the grid's button reset sets `background` and `border` at zero specificity, so any class you put on a button inside the grid (custom toolbar slot, `renderCell`) wins without `!important`.
+25. **Quick filter text** (3.7.1+): besides the raw value and any `valueFormatter` text, `singleSelect` columns match their option label, `boolean` columns Yes / No, and `date` columns the locale date shown. Exports read values through the same `valueGetter` handling as the grid (a throw exports an empty cell), and CSV / HTML-Excel escape formula text from a `valueFormatter` unless it reads as a plain number.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opencorestack/opengridx",
-  "version": "3.7.1",
+  "version": "3.8.1",
   "description": "OpenGridX: High-performance React data infrastructure. Unlock advanced Row Grouping, Excel Export, and Column Pinning without the usual \"Pro\" gatekeeping. Built for speed, scale, and complete architectural freedom. Fully open, virtualization-ready, and feature-complete.",
   "type": "module",
   "main": "./dist/opengridx.umd.js",