@opencorestack/opengridx 1.0.6 → 1.1.0

package/lib/hooks/core/useGridKeyboardNavigation.test.ts

@@ -0,0 +1,176 @@
+import { describe, it, expect, vi } from 'vitest';
+import { renderHook, act } from '@testing-library/react';
+import React from 'react';
+import { useGridKeyboardNavigation } from './useGridKeyboardNavigation';
+
+// Helper: build a minimal React.KeyboardEvent mock
+function keyEvent(key: string): React.KeyboardEvent {
+    return {
+        key,
+        preventDefault: vi.fn(),
+        stopPropagation: vi.fn(),
+        nativeEvent: new KeyboardEvent('keydown', { key }),
+        isDefaultPrevented: () => false,
+        isPropagationStopped: () => false,
+        persist: vi.fn(),
+        bubbles: true,
+        cancelable: true,
+        defaultPrevented: false,
+        eventPhase: 0,
+        isTrusted: false,
+        timeStamp: 0,
+        type: 'keydown',
+        currentTarget: null,
+        target: null,
+        shiftKey: false,
+        ctrlKey: false,
+        metaKey: false,
+        altKey: false,
+    } as unknown as React.KeyboardEvent;
+}
+
+const ROWS = [
+    { id: 1, name: 'Alice' },
+    { id: 2, name: 'Bob' },
+    { id: 3, name: 'Carol' },
+];
+
+const NAV_COLS = [
+    { field: 'name' },
+    { field: 'age' },
+];
+
+const MOCK_EDITING = {
+    editingCell: null,
+    startCellEdit: vi.fn(),
+    stopCellEdit: vi.fn(),
+};
+
+const MOCK_VIRTUALIZATION = {
+    cumulativeHeights: [52, 104, 156],
+    pinnedTopHeight: 0,
+    columnMetrics: null,
+};
+
+const BASE_PARAMS = {
+    allRenderableRows: ROWS,
+    navigationColumns: NAV_COLS,
+    checkboxSelection: false,
+    selectedRowIds: new Set<number | string>(),
+    handleSelectionChange: vi.fn(),
+    handleDetailPanelToggle: vi.fn(),
+    editingHandlers: MOCK_EDITING,
+    setKeyboardMode: vi.fn(),
+    sortModel: [],
+    handleSort: vi.fn(),
+    isCellEditable: undefined,
+    pagination: false,
+    pageSize: 100,
+    virtualization: MOCK_VIRTUALIZATION,
+    viewportRef: { current: null } as React.RefObject<HTMLDivElement | null>,
+};
+
+describe('useGridKeyboardNavigation — arrow keys', () => {
+    it('ArrowDown moves focusedCell to the next row', () => {
+        const { result } = renderHook(() => useGridKeyboardNavigation(BASE_PARAMS));
+        act(() => { result.current.setFocusedCell({ id: 1, field: 'name' }); });
+        act(() => { result.current.handleKeyDown(keyEvent('ArrowDown')); });
+        expect(result.current.focusedCell).toEqual({ id: 2, field: 'name' });
+    });
+
+    it('ArrowUp at header row does not move above it', () => {
+        const { result } = renderHook(() => useGridKeyboardNavigation(BASE_PARAMS));
+        // HEADER is the topmost position; ArrowUp from there should not move
+        act(() => { result.current.setFocusedCell({ id: 'HEADER', field: 'name' }); });
+        act(() => { result.current.handleKeyDown(keyEvent('ArrowUp')); });
+        expect(result.current.focusedCell?.id).toBe('HEADER');
+    });
+
+    it('ArrowDown at last row — no change', () => {
+        const { result } = renderHook(() => useGridKeyboardNavigation(BASE_PARAMS));
+        // ROWS has 3 entries; last row id is 3
+        const lastRow = ROWS[ROWS.length - 1];
+        act(() => { result.current.setFocusedCell({ id: lastRow.id, field: 'name' }); });
+        act(() => { result.current.handleKeyDown(keyEvent('ArrowDown')); });
+        expect(result.current.focusedCell?.id).toBe(lastRow.id);
+    });
+
+    it('ArrowRight moves focusedCell to next column', () => {
+        const { result } = renderHook(() => useGridKeyboardNavigation(BASE_PARAMS));
+        act(() => { result.current.setFocusedCell({ id: 1, field: 'name' }); });
+        act(() => { result.current.handleKeyDown(keyEvent('ArrowRight')); });
+        expect(result.current.focusedCell?.field).toBe('age');
+    });
+
+    it('ArrowLeft at header first column does not move left', () => {
+        const { result } = renderHook(() => useGridKeyboardNavigation(BASE_PARAMS));
+        // HEADER + first col is the leftmost position; wrap-left would require r=-2 which is out of bounds
+        act(() => { result.current.setFocusedCell({ id: 'HEADER', field: 'name' }); });
+        act(() => { result.current.handleKeyDown(keyEvent('ArrowLeft')); });
+        expect(result.current.focusedCell?.field).toBe('name');
+    });
+});
+
+describe('useGridKeyboardNavigation — Home / End', () => {
+    it('Home moves to first column', () => {
+        const { result } = renderHook(() => useGridKeyboardNavigation(BASE_PARAMS));
+        act(() => { result.current.setFocusedCell({ id: 1, field: 'age' }); });
+        act(() => { result.current.handleKeyDown(keyEvent('Home')); });
+        expect(result.current.focusedCell?.field).toBe('name');
+    });
+
+    it('End moves to last column', () => {
+        const { result } = renderHook(() => useGridKeyboardNavigation(BASE_PARAMS));
+        act(() => { result.current.setFocusedCell({ id: 1, field: 'name' }); });
+        act(() => { result.current.handleKeyDown(keyEvent('End')); });
+        expect(result.current.focusedCell?.field).toBe('age');
+    });
+});
+
+describe('useGridKeyboardNavigation — editing', () => {
+    it('Enter calls startCellEdit on an editable cell', () => {
+        const startCellEdit = vi.fn();
+        const params = {
+            ...BASE_PARAMS,
+            editingHandlers: { ...MOCK_EDITING, startCellEdit },
+            navigationColumns: [{ field: 'name', editable: true }],
+        };
+        const { result } = renderHook(() => useGridKeyboardNavigation(params));
+        act(() => { result.current.setFocusedCell({ id: 1, field: 'name' }); });
+        act(() => { result.current.handleKeyDown(keyEvent('Enter')); });
+        expect(startCellEdit).toHaveBeenCalledWith(
+            expect.objectContaining({ id: 1, field: 'name' })
+        );
+    });
+
+    it('Escape calls stopCellEdit with cancel=true when editing', () => {
+        const stopCellEdit = vi.fn();
+        const params = {
+            ...BASE_PARAMS,
+            editingHandlers: {
+                editingCell: { id: 1, field: 'name', value: 'Alice' },
+                startCellEdit: vi.fn(),
+                stopCellEdit,
+            },
+        };
+        const { result } = renderHook(() => useGridKeyboardNavigation(params));
+        act(() => { result.current.setFocusedCell({ id: 1, field: 'name' }); });
+        act(() => { result.current.handleKeyDown(keyEvent('Escape')); });
+        expect(stopCellEdit).toHaveBeenCalledWith({ cancel: true });
+    });
+});
+
+describe('useGridKeyboardNavigation — selection', () => {
+    it('Space toggles checkbox selection on focused row', () => {
+        const handleSelectionChange = vi.fn();
+        const { result } = renderHook(() => useGridKeyboardNavigation({
+            ...BASE_PARAMS,
+            checkboxSelection: true,
+            handleSelectionChange,
+        }));
+        // Space only fires handleSelectionChange when field === '__checkbox_col__'
+        act(() => { result.current.setFocusedCell({ id: 2, field: '__checkbox_col__' }); });
+        act(() => { result.current.handleKeyDown(keyEvent(' ')); });
+        expect(handleSelectionChange).toHaveBeenCalledWith(2, true);
+    });
+});

package/lib/hooks/core/useGridRowPipeline.test.ts

@@ -0,0 +1,117 @@
+import { describe, it, expect } from 'vitest';
+import { renderHook } from '@testing-library/react';
+import { useGridRowPipeline } from './useGridRowPipeline';
+
+const DEFAULT_PAGINATION = { page: 0, pageSize: 3 };
+
+const ROWS = [
+    { id: 1, name: 'Alice', age: 30 },
+    { id: 2, name: 'Bob', age: 25 },
+    { id: 3, name: 'Carol', age: 35 },
+    { id: 4, name: 'Dan', age: 28 },
+    { id: 5, name: 'Eve', age: 22 },
+];
+
+const BASE_PARAMS = {
+    effectiveRows: ROWS,
+    activeHierarchyHandlers: null,
+    filterMode: 'client',
+    filterModel: { items: [] },
+    sortModel: [],
+    sortingMode: 'client',
+    pagination: false,
+    paginationMode: 'client',
+    effectivePaginationModel: DEFAULT_PAGINATION,
+    isLoading: false,
+    pageSize: 3,
+};
+
+describe('useGridRowPipeline — filtering', () => {
+    it('passes all rows through when filterModel is empty', () => {
+        const { result } = renderHook(() => useGridRowPipeline(BASE_PARAMS));
+        expect(result.current.filteredRows).toHaveLength(5);
+    });
+
+    it('filters rows by string contains operator', () => {
+        const { result } = renderHook(() => useGridRowPipeline({
+            ...BASE_PARAMS,
+            filterModel: { items: [{ id: 'f1', field: 'name', operator: 'contains' as const, value: 'al' }] },
+        }));
+        // 'Alice' contains 'al' (case-insensitive); 'Carol' does not ('car-o-l')
+        expect(result.current.filteredRows.map(r => r.id)).toEqual([1]);
+    });
+
+    it('filterMode=server passes rows through unfiltered', () => {
+        const { result } = renderHook(() => useGridRowPipeline({
+            ...BASE_PARAMS,
+            filterMode: 'server',
+            // dataSource required: hook only bypasses filtering when both filterMode=server AND dataSource are set
+            dataSource: {} as never,
+            filterModel: { items: [{ id: 'f1', field: 'name', operator: 'contains' as const, value: 'Alice' }] },
+        }));
+        expect(result.current.filteredRows).toHaveLength(5);
+    });
+});
+
+describe('useGridRowPipeline — sorting', () => {
+    it('sorts rows ascending by field', () => {
+        const { result } = renderHook(() => useGridRowPipeline({
+            ...BASE_PARAMS,
+            sortModel: [{ field: 'age', sort: 'asc' }],
+        }));
+        const ages = result.current.sortedUnpinnedRows.map(r => r.age);
+        expect(ages).toEqual([22, 25, 28, 30, 35]);
+    });
+
+    it('sorts rows descending by field', () => {
+        const { result } = renderHook(() => useGridRowPipeline({
+            ...BASE_PARAMS,
+            sortModel: [{ field: 'age', sort: 'desc' }],
+        }));
+        const ages = result.current.sortedUnpinnedRows.map(r => r.age);
+        expect(ages).toEqual([35, 30, 28, 25, 22]);
+    });
+
+    it('sortingMode=server passes rows through unsorted', () => {
+        const { result } = renderHook(() => useGridRowPipeline({
+            ...BASE_PARAMS,
+            sortingMode: 'server',
+            // dataSource required: hook only bypasses sorting when both sortingMode=server AND dataSource are set
+            dataSource: {} as never,
+            sortModel: [{ field: 'age', sort: 'asc' }],
+        }));
+        // Rows stay in original order
+        expect(result.current.sortedUnpinnedRows.map(r => r.id)).toEqual([1, 2, 3, 4, 5]);
+    });
+});
+
+describe('useGridRowPipeline — pagination', () => {
+    it('returns first pageSize rows on page 0', () => {
+        const { result } = renderHook(() => useGridRowPipeline({
+            ...BASE_PARAMS,
+            pagination: true,
+            effectivePaginationModel: { page: 0, pageSize: 3 },
+        }));
+        expect(result.current.paginatedUnpinnedRows.map(r => r.id)).toEqual([1, 2, 3]);
+    });
+
+    it('returns correct offset slice on page 1', () => {
+        const { result } = renderHook(() => useGridRowPipeline({
+            ...BASE_PARAMS,
+            pagination: true,
+            effectivePaginationModel: { page: 1, pageSize: 3 },
+        }));
+        expect(result.current.paginatedUnpinnedRows.map(r => r.id)).toEqual([4, 5]);
+    });
+
+    it('paginationMode=server returns all rows unsliced', () => {
+        const { result } = renderHook(() => useGridRowPipeline({
+            ...BASE_PARAMS,
+            pagination: true,
+            paginationMode: 'server',
+            dataSource: {} as never,
+            effectivePaginationModel: { page: 0, pageSize: 2 },
+        }));
+        expect(result.current.paginatedUnpinnedRows).toHaveLength(5);
+    });
+});

package/lib/hooks/useRowGrouping.test.ts

@@ -0,0 +1,84 @@
+import { describe, it, expect } from 'vitest';
+import { renderHook } from '@testing-library/react';
+import { useRowGrouping } from './useRowGrouping';
+
+const ROWS = [
+    { id: 1, dept: 'Engineering', name: 'Alice' },
+    { id: 2, dept: 'Engineering', name: 'Bob' },
+    { id: 3, dept: 'HR', name: 'Carol' },
+];
+
+const GET_ROW_ID = (row: { id: number }) => row.id;
+const GROUPING_MODEL = ['dept'];
+const AGGREGATION_MODEL = {};
+
+const BASE_PARAMS = {
+    rows: ROWS,
+    getRowId: GET_ROW_ID,
+    rowGroupingModel: GROUPING_MODEL,
+    aggregationModel: AGGREGATION_MODEL,
+};
+
+describe('useRowGrouping — rowMetaMap', () => {
+    it('includes treeDepth for group rows', () => {
+        const { result } = renderHook(() => useRowGrouping(BASE_PARAMS));
+        const map = result.current.rowMetaMap;
+        // Group rows are at depth 0 (top-level)
+        let foundGroupAtDepth0 = false;
+        map.forEach((meta, _id) => {
+            if (meta.isGroupRow) {
+                expect(meta.treeDepth).toBe(0);
+                foundGroupAtDepth0 = true;
+            }
+        });
+        expect(foundGroupAtDepth0).toBe(true);
+    });
+
+    it('includes treeDepth for leaf rows', () => {
+        const { result } = renderHook(() => useRowGrouping(BASE_PARAMS));
+        const map = result.current.rowMetaMap;
+        // Leaf rows (original rows) are at depth 1 (under the group)
+        let foundLeafAtDepth1 = false;
+        map.forEach((meta, _id) => {
+            if (!meta.isGroupRow) {
+                expect(meta.treeDepth).toBe(1);
+                foundLeafAtDepth1 = true;
+            }
+        });
+        expect(foundLeafAtDepth1).toBe(true);
+    });
+
+    it('sets isGroupRow true for group rows and false for leaves', () => {
+        const { result } = renderHook(() => useRowGrouping(BASE_PARAMS));
+        const map = result.current.rowMetaMap;
+        // Leaf rows have numeric ids (1, 2, 3)
+        expect(map.get(1)?.isGroupRow).toBe(false);
+        expect(map.get(2)?.isGroupRow).toBe(false);
+        expect(map.get(3)?.isGroupRow).toBe(false);
+        // Group rows use auto-generated string ids
+        let groupCount = 0;
+        map.forEach((meta) => {
+            if (meta.isGroupRow) groupCount++;
+        });
+        // Two groups: Engineering and HR
+        expect(groupCount).toBe(2);
+    });
+
+    it('includes all rows (group + leaf) in the map', () => {
+        const { result } = renderHook(() => useRowGrouping(BASE_PARAMS));
+        const map = result.current.rowMetaMap;
+        // 3 leaf rows + 2 group rows = 5 entries
+        expect(map.size).toBe(5);
+    });
+
+    it('has hasChildren true for group rows and false for leaf rows', () => {
+        const { result } = renderHook(() => useRowGrouping(BASE_PARAMS));
+        const map = result.current.rowMetaMap;
+        expect(map.get(1)?.hasChildren).toBe(false);
+        map.forEach((meta) => {
+            if (meta.isGroupRow) {
+                expect(meta.hasChildren).toBe(true);
+            }
+        });
+    });
+});

package/lib/hooks/useRowGrouping.ts

@@ -1,12 +1,13 @@
 import { useState, useMemo, useEffect, useCallback } from 'react';
-import type { 
-    GridRowModel, 
-    GridRowId, 
-    GridRowGroupingModel, 
-    GridAggregationModel, 
+import type {
+    GridRowModel,
+    GridRowId,
+    GridRowGroupingModel,
+    GridAggregationModel,
     GridTreeNode,
     GridFilterModel,
-    GridSortItem
+    GridSortItem,
+    GridRowMeta
 } from '../types';
 import { isRowMatchingFilter } from '../utils/filtering';
 import { compareValues } from '../utils/sorting';
@@ -27,12 +28,18 @@ const defaultGetAggregationPosition = (groupNode: GridTreeNode | null): 'inline'
     return groupNode?.depth === -1 ? 'footer' : 'inline';
 };
 
+// Stable empty defaults — module-level constants prevent new object identity
+// on every render, which would otherwise invalidate useMemo deps and cause
+// infinite re-render loops when callers omit optional params.
+const EMPTY_ROW_GROUPING_MODEL: GridRowGroupingModel = [];
+const EMPTY_AGGREGATION_MODEL: GridAggregationModel = {};
+
 export function useRowGrouping<R extends GridRowModel>(params: UseRowGroupingParams<R>) {
-    const { 
-        rows, 
-        getRowId, 
-        rowGroupingModel = [], 
-        aggregationModel = {}, 
+    const {
+        rows,
+        getRowId,
+        rowGroupingModel = EMPTY_ROW_GROUPING_MODEL,
+        aggregationModel = EMPTY_AGGREGATION_MODEL,
         defaultGroupingExpansionDepth = 0,
         filterModel,
         sortModel,
@@ -291,12 +298,30 @@ export function useRowGrouping<R extends GridRowModel>(params: UseRowGroupingPar
 
     const getNode = useCallback((id: GridRowId) => treeNodes.get(id), [treeNodes]);
 
+    const rowMetaMap = useMemo<Map<GridRowId, GridRowMeta>>(() => {
+        const map = new Map<GridRowId, GridRowMeta>();
+        treeNodes.forEach((node, id) => {
+            const isGroup = Boolean(node.children && node.children.length > 0);
+            map.set(id, {
+                hasChildren: isGroup,
+                treeDepth: node.depth,
+                groupingField: node.groupingField,
+                groupingValue: node.groupingValue,
+                descendantCount: node.descendantCount,
+                isGroupRow: isGroup,
+                isExpanded: isGroup ? expandedGroupIds.has(id) : undefined,
+            });
+        });
+        return map;
+    }, [treeNodes, expandedGroupIds]);
+
     return useMemo(() => ({
         treeNodes,
         groupingRows,
         toggleExpansion,
         isGroupExpanded,
         getVisibleRows,
-        getNode
-    }), [treeNodes, groupingRows, toggleExpansion, isGroupExpanded, getVisibleRows, getNode]);
+        getNode,
+        rowMetaMap,
+    }), [treeNodes, groupingRows, toggleExpansion, isGroupExpanded, getVisibleRows, getNode, rowMetaMap]);
 }

package/lib/hooks/useTreeData.ts

@@ -1,5 +1,6 @@
 import { useMemo, useState, useCallback, useEffect } from 'react';
 import { GridRowModel, GridRowId, GridTreeNode, GridFilterModel, GridSortItem } from '../types';
+import type { GridRowMeta } from '../types';
 import { isRowMatchingFilter } from '../utils/filtering';
 import { compareValues } from '../utils/sorting';
 
@@ -311,6 +312,24 @@ export function useTreeData<R extends GridRowModel>(props: UseTreeDataProps<R>)
         return path;
     }, [treeNodes]);
 
+    const rowMetaMap = useMemo<Map<GridRowId, GridRowMeta>>(() => {
+        const map = new Map<GridRowId, GridRowMeta>();
+        const groupRowIds = new Set(groupingRows.map(r => r.id));
+        treeNodes.forEach((node, id) => {
+            map.set(id, {
+                hasChildren: Boolean(
+                    (node.children && node.children.length > 0) ||
+                    (node.serverChildrenCount && node.serverChildrenCount > 0)
+                ),
+                treeDepth: node.depth,
+                descendantCount: node.children ? node.children.length : undefined,
+                isGroupRow: groupRowIds.has(id),
+                isExpanded: expandedGroupIds.has(id),
+            });
+        });
+        return map;
+    }, [treeNodes, groupingRows, expandedGroupIds]);
+
     return useMemo(() => ({
         treeNodes,
         groupingRows,
@@ -318,6 +337,7 @@ export function useTreeData<R extends GridRowModel>(props: UseTreeDataProps<R>)
         isGroupExpanded,
         getVisibleRows,
         getNode,
-        getNodePath
-    }), [treeNodes, groupingRows, toggleExpansion, isGroupExpanded, getVisibleRows, getNode, getNodePath]);
+        getNodePath,
+        rowMetaMap,
+    }), [treeNodes, groupingRows, toggleExpansion, isGroupExpanded, getVisibleRows, getNode, getNodePath, rowMetaMap]);
 }

package/lib/index.ts

@@ -103,4 +103,6 @@ export type {
     GridApi,
     GridTreeNode,
     GridDetailPanelParams,
+    GridRowMeta,
+    GridLocaleText,
 } from './types';

package/lib/types/index.ts

@@ -7,26 +7,33 @@ export type GridRowId = string | number;
 export interface GridRowModel {
   /** Uniquely identifies the row. */
   id: GridRowId;
-  /** Internal: row has child nodes (tree data / row grouping). */
-  _hasChildren?: boolean;
   /** Internal: row is a skeleton placeholder during infinite-scroll loading. */
   _isSkeleton?: boolean;
-  /** Internal: depth in the tree or grouping hierarchy. */
-  _treeDepth?: number;
-  /** Internal: whether the group/tree node is currently expanded. */
-  _isExpanded?: boolean;
-  /** Internal: field used for grouping at this level. */
-  _groupingField?: string;
-  /** Internal: grouping field value at this level. */
-  _groupingValue?: unknown;
-  /** Internal: total descendant count for tree/grouping nodes. */
-  _descendantCount?: number;
   /** Internal: server-reported child count for lazy-loaded tree nodes. */
   serverChildrenCount?: number;
   /** Any other dynamic row properties. */
   [key: string]: unknown;
 }
 
+/**
+ * Internal hierarchy metadata for a row. Exposed via `params.rowMeta` in `renderCell`.
+ * Not present (`undefined`) for flat rows with no active tree-data or row-grouping.
+ *
+ * @since v1.1 — replaces the `_hasChildren` / `_treeDepth` / `_groupingField` etc.
+ * properties that were previously (and incorrectly) typed on `GridRowModel`.
+ * Those underscore fields remain on the row object at runtime in v1.1 for
+ * backward compatibility; they will be removed from the runtime in v2.0.
+ */
+export interface GridRowMeta {
+    hasChildren?: boolean;
+    treeDepth?: number;
+    groupingField?: string;
+    groupingValue?: unknown;
+    descendantCount?: number;
+    isExpanded?: boolean;
+    isGroupRow?: boolean;
+}
+
 export type GridAlignment = 'left' | 'center' | 'right';
 
 /** Represents a row node in the grid's hierarchical tree structure. */
@@ -231,6 +238,11 @@ export interface GridRenderCellParams<R extends GridRowModel = GridRowModel> {
   rowIndex: number;
   /** The index of the column. */
   colIndex: number;
+  /**
+   * Hierarchy metadata for this row. `undefined` for flat rows (no tree-data or row-grouping active).
+   * @since v1.1
+   */
+  rowMeta?: GridRowMeta;
 }
 
 export interface GridRenderHeaderParams {
@@ -463,6 +475,18 @@ export interface GridRowScrollEndParams {
   viewportHeight: number;
 }
 
+/** Overrideable user-visible strings for internationalisation. All fields are optional; defaults match the built-in English strings. */
+export interface GridLocaleText {
+    /** Label before the rows-per-page select. Default: `"Rows per page:"` */
+    paginationRowsPerPage?: string;
+    /** Range label. Receives (from, to, count). Default: `` (f, t, c) => `${f}–${t} of ${c}` `` */
+    paginationOf?: (from: number, to: number, count: number) => string;
+    /** Page counter label. Receives (page, pageCount). Default: `` (p, pc) => `Page ${p} of ${pc}` `` */
+    paginationPage?: (page: number, pageCount: number) => string;
+    /** Empty-state label. When set, overrides the `noRowsLabel` prop on DataGrid. Default: `"No Data"` */
+    noRowsLabel?: string;
+}
+
 /**
  * Main properties for the DataGrid component.
  */
@@ -555,6 +579,8 @@ export interface DataGridProps<R extends GridRowModel = GridRowModel> {
   ariaLabel?: string;
   /** Message displayed when there are no rows to show. */
   noRowsLabel?: string;
+  /** Overrides for user-visible strings (i18n). All fields are optional. */
+  localeText?: GridLocaleText;
 
   /** Advanced: The starting internal state of the grid. */
   initialState?: import('../state/types').GridInitialState;

package/package.json

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