@opencorestack/opengridx 3.8.0 → 3.9.0

package/lib/utils/gridLocale.ts

@@ -0,0 +1,241 @@
+import type { GridFilterOperator, GridLocaleText } from '../types';
+import { HEADER_FILTER_OPERATOR_LABELS } from './headerFilters';
+import { defaultCellSelectionAnnouncement } from './cellSelection';
+
+/** `localeText` keys that hold a lookup record; the resolved locale has a function for each. */
+type GridLocaleRecordKey = 'headerFilterOperators' | 'filterPanelOperators' | 'toolbarAggregationFunctions' | 'pivotAggregationFunctions';
+type GridLocaleScalarKey = Exclude<keyof GridLocaleText, GridLocaleRecordKey>;
+
+/** Every `localeText` string with its English default filled in. */
+export type GridLocaleScalars = Required<Pick<GridLocaleText, GridLocaleScalarKey>>;
+
+/** The grid's resolved strings: every key of `GridLocaleText`, lookup records turned into functions. */
+export interface ResolvedGridLocale extends GridLocaleScalars {
+    /** Operator name in the header filter row. */
+    headerFilterOperator: (operator: GridFilterOperator) => string;
+    /** Operator name in the filter panel's operator select. */
+    filterPanelOperator: (operator: GridFilterOperator) => string;
+    /** Aggregation function name in the toolbar's summaries panel. */
+    toolbarAggregationFunction: (fn: string) => string;
+    /** Aggregation function name in the pivot panel. */
+    pivotAggregationFunction: (fn: string) => string;
+}
+
+const plural = (count: number, one: string, many: string) => (count === 1 ? one : many);
+
+/** The built-in English strings. */
+export const GRID_LOCALE_EN: GridLocaleScalars = {
+    paginationRowsPerPage: 'Rows per page:',
+    paginationOf: (from, to, count) => (count === 0 ? `0 of ${count}` : `${from}–${to} of ${count}`),
+    paginationPage: (page, pageCount) => `Page ${page} of ${pageCount}`,
+    noRowsLabel: 'No Data',
+    cellSelectionAnnouncement: defaultCellSelectionAnnouncement,
+    aiAssistantButton: 'Ask AI',
+    headerFilterCustom: 'Custom filter',
+    headerFilterCustomTooltip: 'Set in the filter panel',
+    headerFilterCellLabel: h => `Filter ${h}`,
+    headerFilterValueLabel: h => `Filter value for ${h}`,
+    headerFilterOperatorButtonLabel: (h, op) => `Filter operator for ${h}: ${op}`,
+    headerFilterOperatorMenuLabel: h => `Filter operator for ${h}`,
+    headerFilterClearLabel: h => `Clear filter for ${h}`,
+    headerFilterClearTooltip: 'Clear',
+    headerFilterAny: 'Any',
+    headerFilterTrue: 'Yes',
+    headerFilterFalse: 'No',
+
+    gridLabel: 'Data grid',
+    listViewLabel: 'Data grid list view',
+    listViewItemCount: n => `${n} ${plural(n, 'item', 'items')}`,
+    listViewPage: (p, pc) => `page ${p} of ${pc}`,
+    listViewSelectedCount: n => `${n} selected`,
+    loadingLabel: 'Loading data',
+    liveRegionLoading: 'Loading data...',
+    liveRegionError: m => `Error: ${m}`,
+    liveRegionRowsFound: n => `${n} ${plural(n, 'row', 'rows')} found`,
+    errorOverlayTitle: 'Oops! Something went wrong',
+    errorOverlayRetry: 'Retry',
+    aggregationFooterLabel: 'Aggregation totals',
+    cellErrorLabel: field => `Error in cell: ${field}`,
+    cellErrorTooltip: 'Render error',
+
+    headerRowReorderLabel: 'Row reorder handle',
+    headerRowReorderTooltip: 'Drag to reorder rows',
+    headerDetailPanelLabel: 'Expand row details',
+    headerSelectAllLabel: 'Select all rows',
+    headerDeselectAllLabel: 'Deselect all rows',
+    headerSortDescription: (d, p, n) => `Sorted ${d === 'asc' ? 'ascending' : 'descending'}, sort priority ${p} of ${n}`,
+    headerColumnMenuButtonLabel: h => `Open column menu for ${h}`,
+    headerColumnResizeLabel: f => `Resize ${f} column`,
+    headerFilterNoFilterLabel: h => `No filter for ${h}`,
+
+    rowSelectLabel: id => `Select row ${id}`,
+    rowDeselectLabel: id => `Deselect row ${id}`,
+    rowReorderLabel: 'Drag to reorder row',
+    rowDetailPanelExpandLabel: 'Expand row details',
+    rowDetailPanelCollapseLabel: 'Collapse row details',
+    rowExpandLabel: 'Expand row',
+    rowCollapseLabel: 'Collapse row',
+
+    columnMenuLabel: h => `Column options for ${h}`,
+    columnMenuSortAscending: 'Sort Ascending',
+    columnMenuSortDescending: 'Sort Descending',
+    columnMenuUnsort: 'Unsort',
+    columnMenuPinColumn: 'Pin column',
+    columnMenuPinLeft: 'Pin to Left',
+    columnMenuPinLeftLabel: 'Pin to left',
+    columnMenuPinRight: 'Pin to Right',
+    columnMenuPinRightLabel: 'Pin to right',
+    columnMenuUnpin: 'Unpin',
+    columnMenuUnpinLabel: 'Unpin column',
+    columnMenuHideColumn: 'Hide Column',
+    columnMenuHideColumnLabel: h => `Hide ${h} column`,
+    columnMenuManageColumns: 'Manage columns',
+    columnMenuManageColumnsLabel: 'Manage all columns',
+
+    columnsPanelSearchPlaceholder: 'Search',
+    columnsPanelDragToReorder: 'Drag to reorder',
+    columnsPanelShowHideAll: 'Show/Hide All',
+    columnsPanelReset: 'Reset',
+    columnsPanelClose: 'Close',
+
+    filterPanelValueLabel: h => `Filter value for ${h}`,
+    filterPanelOperatorLabel: h => `Filter operator for ${h}`,
+    filterPanelClearLabel: h => `Clear filter for ${h}`,
+    filterPanelClearTooltip: 'Clear',
+    filterPanelAny: 'Any',
+    filterPanelTrue: 'true',
+    filterPanelFalse: 'false',
+    filterPanelNumberPlaceholder: 'Number…',
+    filterPanelValuePlaceholder: 'Value…',
+    filterPanelMatch: 'Match:',
+    filterPanelAnd: 'ALL (AND)',
+    filterPanelOr: 'ANY (OR)',
+    filterPanelHiddenConditions: n => (n === 1
+        ? '1 more condition (a filter group or a second condition on a column) is applied and not shown here.'
+        : `${n} more conditions (filter groups or further conditions on a column) are applied and not shown here.`),
+    filterPanelNoColumns: 'No filterable columns.',
+
+    toolbarLabel: 'Grid toolbar',
+    toolbarSearchPlaceholder: 'Search...',
+    toolbarSearchLabel: 'Global Search',
+    toolbarSearchClear: 'Clear search',
+    toolbarColumns: 'Columns',
+    toolbarColumnsLabel: 'Manage columns',
+    toolbarColumnsPanelLabel: 'Column visibility',
+    toolbarFilters: 'Filters',
+    toolbarFiltersLabel: 'Advanced filters',
+    toolbarFiltersActive: 'Filters active',
+    toolbarFiltersClearAll: 'Clear all',
+    toolbarFiltersClearAllTooltip: 'Clear all filters',
+    toolbarFiltersClose: 'Close',
+    toolbarFiltersCloseTooltip: 'Close filters',
+    toolbarFiltersCloseLabel: 'Close filters panel',
+    toolbarPivot: 'Pivot',
+    toolbarPivotLabel: 'Configure pivot',
+    toolbarPivotActive: 'Pivot active',
+    toolbarSummaries: 'Summaries',
+    toolbarSummariesLabel: 'Configure summaries',
+    toolbarSummariesActive: n => `${n} active summaries`,
+    toolbarSummariesPanelLabel: 'Summaries configuration',
+    toolbarSummariesClearAll: 'Clear all',
+    toolbarSummariesClearAllTooltip: 'Clear all summaries',
+    toolbarSummariesEmpty: 'No aggregable columns.',
+    toolbarSummariesEmptyHintBefore: 'Set',
+    toolbarSummariesEmptyHintAfter: 'on a column to enable.',
+
+    pivotPanelLabel: 'Pivot configuration',
+    pivotMode: 'Pivot Mode',
+    pivotReset: 'Reset',
+    pivotResetTooltip: 'Reset pivot',
+    pivotRowFields: 'Row Fields',
+    pivotColumnFields: 'Column Fields',
+    pivotValueFields: 'Value Fields (aggregated)',
+    pivotRowFieldsPlaceholder: 'Add fields here — each becomes a row label',
+    pivotColumnFieldsPlaceholder: 'Add fields here — unique values become column headers',
+    pivotValueFieldsPlaceholder: 'Add numeric fields here — values are aggregated',
+    pivotRemoveTooltip: h => `Remove ${h}`,
+    pivotRemoveRowLabel: h => `Remove ${h} from Row Fields`,
+    pivotRemoveColumnLabel: h => `Remove ${h} from Column Fields`,
+    pivotRemoveValueLabel: (h, fn) => `Remove ${h} (${fn}) from Value Fields`,
+    pivotAggregationTooltip: 'Aggregation function',
+    pivotAggregationLabel: h => `Aggregation function for ${h}`,
+    pivotAvailableFields: 'Available Fields',
+    pivotAllFieldsInUse: 'All fields are in use.',
+    pivotAddRow: 'Row',
+    pivotAddColumn: 'Col',
+    pivotAddValue: 'Val',
+    pivotAddRowTooltip: 'Add to Row Fields',
+    pivotAddColumnTooltip: 'Add to Column Fields',
+    pivotAddValueTooltip: 'Add to Value Fields',
+    pivotAddRowLabel: h => `Add ${h} to Row Fields`,
+    pivotAddColumnLabel: h => `Add ${h} to Column Fields`,
+    pivotAddValueLabel: h => `Add ${h} to Value Fields`,
+
+    aiAssistantTitle: 'Ask AI',
+    aiAssistantClose: 'Close',
+    aiAssistantPromptLabel: 'Prompt',
+    aiAssistantPlaceholder: 'Ask about this table…',
+    aiAssistantStartDictation: 'Dictate a prompt',
+    aiAssistantStopDictation: 'Stop dictation',
+    aiAssistantAsk: 'Ask',
+    aiAssistantStop: 'Stop',
+    aiAssistantSuggestions: 'Suggestions',
+    aiAssistantAppliedChanges: 'Applied changes',
+    aiAssistantRemoveChange: label => `Remove ${label}`,
+    aiAssistantUndo: 'Undo',
+    aiAssistantIgnored: 'Ignored',
+    aiAssistantIgnoredItem: m => `Ignored: ${m}`,
+    aiAssistantEarlier: 'Earlier',
+    aiAssistantThinking: 'Thinking…',
+    aiAssistantStopped: 'Stopped',
+    aiAssistantUndone: 'Undone',
+    aiAssistantChangeRemoved: 'Change removed',
+    aiAssistantApplied: (count, ignored) => {
+        const applied = count === 0 ? 'No changes' : `Applied ${count} ${plural(count, 'change', 'changes')}`;
+        return ignored > 0 ? `${applied}, ${ignored} ignored` : applied;
+    },
+    aiAssistantNotValidated: 'The reply was not validated',
+    aiAssistantFailed: m => `The assistant could not answer: ${m}`,
+    aiAssistantUnknownError: 'Unknown error',
+
+    paginationLabel: 'Pagination',
+    paginationFirstPageLabel: 'Go to first page',
+    paginationFirstPageTooltip: 'First page',
+    paginationPreviousPageLabel: 'Go to previous page',
+    paginationPreviousPageTooltip: 'Previous page',
+    paginationNextPageLabel: 'Go to next page',
+    paginationNextPageTooltip: 'Next page',
+    paginationLastPageLabel: 'Go to last page',
+    paginationLastPageTooltip: 'Last page',
+
+    cellSelectionStatsCount: 'Count',
+    cellSelectionStatsSum: 'Sum',
+    cellSelectionStatsAverage: 'Average',
+};
+
+const SCALAR_KEYS = Object.keys(GRID_LOCALE_EN) as GridLocaleScalarKey[];
+
+function pickScalar<K extends GridLocaleScalarKey>(target: GridLocaleScalars, localeText: GridLocaleText, key: K): void {
+    const value = localeText[key];
+    if (value !== undefined) target[key] = value as GridLocaleScalars[K];
+}
+
+/**
+ * Fills every string `localeText` leaves out with its English default. Pure; memoise the result
+ * per `localeText` object.
+ */
+export function resolveGridLocale(localeText?: GridLocaleText): ResolvedGridLocale {
+    const scalars: GridLocaleScalars = { ...GRID_LOCALE_EN };
+    if (localeText) SCALAR_KEYS.forEach(key => pickScalar(scalars, localeText, key));
+    const headerFilterOperators = localeText?.headerFilterOperators;
+    const filterPanelOperators = localeText?.filterPanelOperators;
+    const toolbarFunctions = localeText?.toolbarAggregationFunctions;
+    const pivotFunctions = localeText?.pivotAggregationFunctions;
+    return {
+        ...scalars,
+        headerFilterOperator: op => headerFilterOperators?.[op] ?? HEADER_FILTER_OPERATOR_LABELS[op] ?? op,
+        filterPanelOperator: op => filterPanelOperators?.[op] ?? op,
+        toolbarAggregationFunction: fn => toolbarFunctions?.[fn] ?? fn,
+        pivotAggregationFunction: fn => pivotFunctions?.[fn] ?? fn.toUpperCase(),
+    };
+}

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/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.9.0
 # Docs: https://opencorestack.github.io/OpenGridX/
 # This file is machine-readable. AI developers: start here.
 
@@ -721,9 +721,15 @@ 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.
+26. **localeText covers every UI string (3.9+)**: ~200 optional keys (column menu, toolbar, filter / columns / pivot panels, AI panel, pagination, row and header checkboxes, overlays, announcements), English by default. An inline object of strings is fine; define function entries (`rowSelectLabel: id => …`) outside the render so rows stay memoised. Components used outside a grid show English.
+27. **Theme keys added in 3.9**: `grid.checkboxCheckedBackground`, `checkboxCheckmark`, `expandIconColor`, `expandIconHoverColor`; `overlays.itemIndicatorColor` (menu selection dot), `itemSelectedIcon`, `iconColor`, `sectionLabelText`, `dividerColor`. The demo's Theme Builder edits all of them.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opencorestack/opengridx",
-  "version": "3.8.0",
+  "version": "3.9.0",
   "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",