@opencorestack/opengridx 3.6.0 → 3.7.1

package/lib/types/slots.ts

@@ -0,0 +1,56 @@
+import type { GridToolbarProps } from '../components/Toolbar/GridToolbar';
+import type { PaginationProps } from '../components/Pagination/Pagination';
+import type { GridPaginationModel } from './dataSource';
+import type { GridAggregationModel, GridAggregationResult } from './grouping';
+import type { DataGridProps } from './props';
+import type { GridApi } from './api';
+
+/**
+ * Props the grid passes to `slots.toolbar`, before `slotProps.toolbar` is merged over them: the
+ * `GridToolbarProps` it controls (columns, models and their change handlers) plus `apiRef`.
+ * @since v3.0
+ */
+export interface GridToolbarSlotProps extends GridToolbarProps {
+  apiRef: React.MutableRefObject<GridApi>;
+}
+
+/**
+ * Props the grid passes to `slots.pagination`, before `slotProps.pagination` is merged over them.
+ * @since v3.0
+ */
+export type GridPaginationSlotProps = PaginationProps;
+
+/**
+ * Props of `slots.noRowsOverlay` and `slots.loadingOverlay`: the grid passes none of its own, only
+ * `slotProps.noRowsOverlay` / `slotProps.loadingOverlay`.
+ * @since v3.0
+ */
+export type GridOverlaySlotProps = Record<string, unknown>;
+
+/**
+ * Props the grid passes to `slots.footer`, before `slotProps.footer` is merged over them.
+ * @since v3.0
+ */
+export interface GridFooterSlotProps {
+  apiRef: React.MutableRefObject<GridApi>;
+  /** The active aggregation model (`{}` when none). */
+  aggregationModel: GridAggregationModel;
+  /** The grand-total aggregation result, or `null` when no aggregation is active. */
+  aggregationResult: GridAggregationResult | null;
+  /**
+   * The built-in pager's count: rows after filtering, pinned rows excluded (`rowCount` from the
+   * server in server pagination mode). Under tree data / row grouping: the filtered data rows.
+   */
+  rowCount: number;
+  /** Whether pagination is in effect (false under row grouping and infinite scroll). */
+  pagination: boolean;
+  paginationModel: GridPaginationModel;
+  pageSizeOptions: number[];
+  onPaginationModelChange: (model: GridPaginationModel) => void;
+}
+
+/** The `slots` prop of `DataGrid`: components that replace built-in parts of the grid. */
+export type GridSlots = NonNullable<DataGridProps['slots']>;
+
+/** The `slotProps` prop of `DataGrid`: props for each slot, keyed like `GridSlots`. */
+export type GridSlotProps = NonNullable<DataGridProps['slotProps']>;

package/lib/types/sorting.ts

@@ -0,0 +1,25 @@
+import type { GridRowId, GridRowModel, GridValidRowModel } from './rows';
+
+export type GridSortDirection = 'asc' | 'desc' | null;
+
+/**
+ * Parameters passed to `GridColDef.sortComparator` for each side of a comparison. For a row-grouping
+ * group row, `row` is the synthetic group row and `value` its grouping value.
+ * @since v3.1
+ */
+export interface GridSortCellParams<R extends GridValidRowModel = GridRowModel> {
+  id: GridRowId;
+  field: string;
+  row: R;
+  value: unknown;
+}
+
+export interface GridSortModel {
+  field: string;
+  sort: GridSortDirection;
+}
+
+export interface GridSortItem {
+  field: string;
+  sort: 'asc' | 'desc';
+}

package/lib/types/state.ts

@@ -0,0 +1,35 @@
+import type { GridRowId, GridRowModel, GridPinnedRows } from './rows';
+import type { GridColDef, GridColumnVisibilityModel, GridPinnedColumns } from './columns';
+
+export interface GridInternalState {
+  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>;
+  };
+  pagination: {
+    /** Server-reported total (dataSource responses); undefined until one arrives. */
+    rowCount?: number;
+  };
+  columns: {
+    all: GridColDef[];
+    lookup: Map<string, GridColDef>;
+    orderedFields: string[];
+    columnVisibilityModel: GridColumnVisibilityModel;
+  };
+  pinning: {
+    pinnedColumns: GridPinnedColumns;
+    pinnedRows: GridPinnedRows;
+  };
+  dimensions: {
+    rowHeight: number;
+    headerHeight: number;
+    viewportWidth: number;
+    viewportHeight: number;
+  };
+  dataSource: {
+    loading: boolean;
+    error: unknown;
+  };
+}

package/lib/utils/export/exportShared.ts

@@ -1,6 +1,6 @@
 import type { GridAggregationModel, GridColDef, GridGroupedExportRow, GridRowId, GridRowModel } from '../../types';
 import { computeAggregations, formatAggregateForColumn } from '../aggregation';
-import { formatValueByType } from '../values';
+import { formatValueByType, getCellValue } from '../values';
 import { isSystemField } from '../focus';
 
 /**
@@ -77,10 +77,12 @@ export function aggregationForExport<R extends GridRowModel>(
     return computeAggregations(exportedRows, aggregationModel, lookup, 'export');
 }
 
-/** The cell's raw value: `row[field]`, then the column's `valueGetter`. */
+/**
+ * The cell's raw value, read like the grid reads it (`getCellValue`): a `valueGetter` that throws
+ * exports as an empty value instead of aborting the export.
+ */
 export function getRawExportValue<R extends GridRowModel>(row: R, col: GridColDef<R>): unknown {
-    const value: unknown = (row as GridRowModel)[col.field];
-    return col.valueGetter ? col.valueGetter({ row, field: col.field, value }) : value;
+    return getCellValue(row, col.field, col);
 }
 
 /**
@@ -159,6 +161,22 @@ export function neutralizeFormula(text: string, fromNonText = false): string {
     return `'${text}`;
 }
 
+/**
+ * Text that reads as a formatted number (digits, signs, separators, brackets, %, currency symbols),
+ * which no spreadsheet runs as a formula. One character class: linear on any input.
+ */
+const NUMERIC_DISPLAY = /^[\d\s.,'%+\-()\p{Sc}]*$/u;
+
+/**
+ * Whether a data cell's text may skip formula escaping: the grid formatted a number, date or
+ * boolean itself, or a `valueFormatter` turned such a value into plain numeric text ("-$3").
+ * Anything else a formatter writes is escaped like text, since it may come from user data.
+ */
+export function isTrustedNonText(raw: unknown, text: string, hasFormatter: boolean): boolean {
+    if (!isNonTextValue(raw)) return false;
+    return !hasFormatter || NUMERIC_DISPLAY.test(text);
+}
+
 /** Whether a raw value is a number, bigint, boolean or Date, whose formatted text is not user-typed. */
 export function isNonTextValue(value: unknown): boolean {
     return typeof value === 'number' || typeof value === 'bigint' || typeof value === 'boolean' || value instanceof Date;

package/lib/utils/export/index.ts

@@ -10,6 +10,7 @@ import {
     getRawExportValue,
     hasSelection,
     isNonTextValue,
+    isTrustedNonText,
     neutralizeFormula,
     pickExportedAggregates,
     rowsForExport,
@@ -55,11 +56,14 @@ export interface CsvExportOptions<R extends GridValidRowModel = GridRowModel> {
 interface ExportCell {
     text: string;
     raw: unknown;
+    /** The text came from the grid's own formatting of a number, date or boolean (see `isTrustedNonText`). */
+    fromNonText: boolean;
 }
 
 function exportCell<R extends GridRowModel>(row: R, col: GridColDef<R>): ExportCell {
     const raw = getRawExportValue(row, col);
-    return { text: formatExportValue(row, col, raw), raw };
+    const text = formatExportValue(row, col, raw);
+    return { text, raw, fromNonText: isTrustedNonText(raw, text, !!col.valueFormatter) };
 }
 
 /** Aggregate text per export column for one subtotal / total record. */
@@ -111,7 +115,7 @@ export function exportToCsv<R extends GridRowModel>(
                 const row = entry.row as R;
                 const cells = exportColumns.map((col, i) => {
                     const cell = exportCell(row, col);
-                    const text = escapeFormulas ? neutralizeFormula(cell.text, isNonTextValue(cell.raw)) : cell.text;
+                    const text = escapeFormulas ? neutralizeFormula(cell.text, cell.fromNonText) : cell.text;
                     return escapeCSV((i === 0 ? indent : '') + text, delimiter);
                 });
                 csvContent += cells.join(delimiter) + '\n';
@@ -138,7 +142,7 @@ export function exportToCsv<R extends GridRowModel>(
         rowsToExport.forEach(row => {
             const values = exportColumns.map(col => {
                 const cell = exportCell(row, col);
-                return field(cell.text, isNonTextValue(cell.raw));
+                return field(cell.text, cell.fromNonText);
             });
             csvContent += values.join(delimiter) + '\n';
         });
@@ -255,7 +259,7 @@ export function exportToExcel<R extends GridRowModel>(
     html += '<tbody>';
 
     const dataCell = (cell: ExportCell, col: GridColDef<R>, prefix = ''): string => {
-        const content = prefix + cellText(cell.text, isNonTextValue(cell.raw));
+        const content = prefix + cellText(cell.text, cell.fromNonText);
         return isXlsTextCell(col, cell.raw) ? textTd(content) : `<td>${content}</td>`;
     };
 

package/lib/utils/filtering/index.ts

@@ -1,7 +1,7 @@
 
 import type { GridRowModel, GridFilterItem, GridFilterModel, GridFilterGroup, GridFilterOperator, GridColDef } from '../../types';
 import type { GridColumnLookup } from '../columnLookup';
-import { getCellValue, getFormattedValue, toLocalDateString, toLocalDayKey, toNumber } from '../values';
+import { getCellValue, formatValueByType, getFormattedValue, toLocalDateString, toLocalDayKey, toNumber } from '../values';
 
 /** Compares a cell value with the filter item's value. */
 export type GridFilterOperatorFn = (value: unknown, filterValue?: unknown) => boolean;
@@ -230,7 +230,13 @@ function getQuickFilterTexts(row: GridRowModel, columns: GridColumnLookup | unde
   for (const col of columns.quickFilterColumns) {
     const value = getCellValue(row, col.field, col);
     const formatted = getFormattedValue(row, col.field, value, col);
-    if (formatted != null && formatted !== '') texts.push(String(formatted).toLowerCase());
+    if (formatted != null && formatted !== '') {
+      texts.push(String(formatted).toLowerCase());
+    } else if (col.type === 'date' || col.type === 'boolean' || col.type === 'singleSelect') {
+      // Without a formatter the grid shows a locale date, Yes / No or the option label: search that too.
+      const shown = formatValueByType(value, col);
+      if (shown !== '') texts.push(shown.toLowerCase());
+    }
     pushSearchText(texts, value);
   }
   return texts;

package/lib/utils/parsing.ts

@@ -131,6 +131,19 @@ export function parseNumberText(text: string): GridParsedValue {
 
 const ISO_DATE_PREFIX = /^(\d{4}-\d{2}-\d{2})/;
 const pad2 = (n: number) => String(n).padStart(2, '0');
+/** Whether an ISO date-time string ends with `Z` or a `±hh:mm` / `±hhmm` offset. A loop, not a regex. */
+function hasZone(text: string): boolean {
+    const end = text.trimEnd();
+    if (end.endsWith('Z') || end.endsWith('z')) return true;
+    const tIndex = end.indexOf('T');
+    if (tIndex < 0) return false;
+    for (let i = end.length - 1; i > tIndex; i--) {
+        const ch = end[i];
+        if (ch === '+' || ch === '-') return true;
+        if (!(ch >= '0' && ch <= '9') && ch !== ':') return false;
+    }
+    return false;
+}
 const localDay = (date: Date) => `${date.getFullYear()}-${pad2(date.getMonth() + 1)}-${pad2(date.getDate())}`;
 
 /**
@@ -147,7 +160,17 @@ export function parseDateText(text: string, current?: unknown): GridParsedValue
     if (typeof current === 'number') return valid(date.getTime());
     if (typeof current === 'string') {
         const day = localDay(date);
-        return valid(ISO_DATE_PREFIX.test(current) && current.length > 10 ? day + current.slice(10) : day);
+        if (!ISO_DATE_PREFIX.test(current) || current.length <= 10) return valid(day);
+        // A zoned date-time ("…Z", "…+05:30") is shown as a local day: keep its local time of day on
+        // the pasted day and write UTC, or west of UTC the cell would show the day before.
+        const held = hasZone(current) ? new Date(current) : null;
+        if (held && !Number.isNaN(held.getTime())) {
+            return valid(new Date(
+                date.getFullYear(), date.getMonth(), date.getDate(),
+                held.getHours(), held.getMinutes(), held.getSeconds(), held.getMilliseconds(),
+            ).toISOString());
+        }
+        return valid(day + current.slice(10));
     }
     return valid(date);
 }

package/lib/utils/values.ts

@@ -132,6 +132,7 @@ export function toDate(value: unknown): Date | null {
             // Reject roll-overs such as 2024-02-31.
             if (date.getMonth() !== month || date.getDate() !== day) return null;
         } else {
+            if (!hasOnlyDateWords(trimmed)) return null;
             date = new Date(trimmed);
         }
     } else {
@@ -140,6 +141,36 @@ export function toDate(value: unknown): Date | null {
     return Number.isNaN(date.getTime()) ? null : date;
 }
 
+const DATE_WORDS = [
+    'january', 'february', 'march', 'april', 'may', 'june', 'july', 'august', 'september', 'october',
+    'november', 'december', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday',
+];
+const DATE_TOKENS = new Set(['t', 'z', 'am', 'pm', 'gmt', 'utc', 'sept']);
+
+function isDateWord(word: string): boolean {
+    if (DATE_TOKENS.has(word)) return true;
+    return word.length >= 3 && DATE_WORDS.some(name => name.startsWith(word));
+}
+
+/**
+ * Whether every run of letters in `text` is a month or weekday name (or abbreviation), or one of
+ * T, Z, AM, PM, GMT, UTC. `Date.parse` accepts free text such as "hello 5" (as a 2001 date in V8),
+ * which must not become a date. A loop, not a regex.
+ */
+function hasOnlyDateWords(text: string): boolean {
+    let word = '';
+    for (let i = 0; i <= text.length; i++) {
+        const ch = i < text.length ? text[i].toLowerCase() : '';
+        if (ch >= 'a' && ch <= 'z') {
+            word += ch;
+            continue;
+        }
+        if (word !== '' && !isDateWord(word)) return false;
+        word = '';
+    }
+    return true;
+}
+
 /** A sortable integer for the local calendar day of a date (YYYYMMDD), or null when unparsable. */
 export function toLocalDayKey(value: unknown): number | null {
     const date = toDate(value);

package/llms.txt

@@ -1,6 +1,6 @@
 # OpenGridX — AI Agent Context
 # Package: @opencorestack/opengridx
-# Version: 3.6.0
+# Version: 3.7.0
 # Docs: https://opencorestack.github.io/OpenGridX/
 # This file is machine-readable. AI developers: start here.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opencorestack/opengridx",
-  "version": "3.6.0",
+  "version": "3.7.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",
@@ -59,6 +59,7 @@
     "test:browser": "vitest run --project browser",
     "test:all": "vitest run",
     "test:smoke": "node scripts/smoke.mjs",
+    "test:demo": "npm run build && playwright test --config e2e/playwright.demo.config.ts",
     "bench": "node bench/run.mjs",
     "test:watch": "vitest --project unit",
     "coverage": "vitest run --coverage",
@@ -147,6 +148,7 @@
     "vitest": "^4.1.11"
   },
   "overrides": {
-    "uuid": "^11.1.1"
+    "uuid": "^11.1.1",
+    "source-map-js": "^1.2.2"
   }
 }