@opencorestack/opengridx 3.7.1 → 3.8.1

package/lib/hooks/core/useGridFillHandle.ts

@@ -47,7 +47,7 @@ export interface UseGridFillHandleParams<R extends GridRowModel> {
     navigationColumns: ReadonlyArray<GridColDef<R>>;
     columnIndexMap: Map<string, number>;
     isCellEditable?: (params: GridCellParams<R>) => boolean;
-    rowMetaMap: Map<GridRowId, GridRowMeta>;
+    rowMetaMap: ReadonlyMap<GridRowId, GridRowMeta>;
     getSpanOrigin?: (rowId: GridRowId, field: string) => { rowId: GridRowId; field: string } | null;
     batchEdit: UseGridBatchEditReturn<R>;
     onFill?: (result: GridFillResult) => void;

package/lib/hooks/core/useGridHierarchy.ts

@@ -3,7 +3,7 @@ import { useTreeData } from '../useTreeData';
 import { useRowGrouping, type UseRowGroupingParams } from '../useRowGrouping';
 import type { GridRowGroupingModel, GridRowId, GridRowMeta, GridRowModel } from '../../types';
 
-const EMPTY_ROW_META_MAP: Map<GridRowId, GridRowMeta> = new Map();
+const EMPTY_ROW_META_MAP: ReadonlyMap<GridRowId, GridRowMeta> = new Map();
 
 export interface UseGridHierarchyParams<R extends GridRowModel> extends Pick<
     UseRowGroupingParams<R>,
@@ -71,7 +71,7 @@ export function useGridHierarchy<R extends GridRowModel>(params: UseGridHierarch
 
     const activeHierarchyHandlers = isTreeData ? treeDataHandlers : (isRowGrouping ? rowGroupingHandlers : null);
 
-    const rowMetaMap = useMemo<Map<GridRowId, GridRowMeta>>(() => {
+    const rowMetaMap = useMemo<ReadonlyMap<GridRowId, GridRowMeta>>(() => {
         if (isTreeData) return treeDataHandlers.rowMetaMap;
         if (isRowGrouping) return rowGroupingHandlers.rowMetaMap;
         return EMPTY_ROW_META_MAP;

package/lib/hooks/core/useGridKeyboardNavigation.ts

@@ -71,7 +71,7 @@ export interface UseGridKeyboardNavigationParams<R extends GridRowModel> {
     /** Resolves a row's id (getRowId); defaults to `row.id`. */
     getRowId?: (row: R) => GridRowId;
     /** Hierarchy metadata. Synthetic group rows are never edited or selected from the keyboard. */
-    rowMetaMap?: Map<GridRowId, GridRowMeta>;
+    rowMetaMap?: ReadonlyMap<GridRowId, GridRowMeta>;
     /** Enter on a non-editable cell: the same handler a row click runs. */
     onRowActivate?: (params: GridRowParams<R>) => void;
     /**

package/lib/hooks/core/useGridLiveRowSelection.ts

@@ -37,13 +37,20 @@ export function useGridLiveRowSelection(params: UseGridLiveRowSelectionParams):
 
     const liveRowIds = useMemo(() => {
         if (!enabled || selectedRowIds.size === 0) return selectedRowIds;
+        // Check first, copy only when something is stale: select-all at 1M rows selects 1M ids.
         let stale = false;
+        for (const id of selectedRowIds) {
+            if (!rowsLookup.has(id) && !rowMetaMap.has(id)) {
+                stale = true;
+                break;
+            }
+        }
+        if (!stale) return selectedRowIds;
         const live = new Set<GridRowId>();
         for (const id of selectedRowIds) {
             if (rowsLookup.has(id) || rowMetaMap.has(id)) live.add(id);
-            else stale = true;
         }
-        return stale ? live : selectedRowIds;
+        return live;
     }, [enabled, selectedRowIds, rowsLookup, rowMetaMap]);
 
     // Latest callback, so an inline onRowSelectionModelChange does not report again on every render.

package/lib/hooks/core/useGridRangeEditing.ts

@@ -29,7 +29,7 @@ export interface UseGridRangeEditingParams<R extends GridRowModel> {
     navigationColumns: GridColDef<R>[];
     columnIndexMap: Map<string, number>;
     isCellEditable?: (params: GridCellParams<R>) => boolean;
-    rowMetaMap: Map<GridRowId, GridRowMeta>;
+    rowMetaMap: ReadonlyMap<GridRowId, GridRowMeta>;
     getSpanOrigin?: (rowId: GridRowId, field: string) => { rowId: GridRowId; field: string } | null;
     isEditing: boolean;
     batchEdit: UseGridBatchEditReturn<R>;

package/lib/hooks/core/useGridRowInteractions.ts

@@ -3,6 +3,7 @@ import { useGridRowSelection, type UseGridRowSelectionReturn } from './useGridRo
 import { PIVOT_GRAND_TOTAL_ID } from '../../utils/pivot';
 import { isSyntheticRowId } from '../../utils/syntheticRows';
 import type { GridRowId, GridRowMeta, GridRowModel, GridRowParams } from '../../types';
+import { getRowIndex } from '../../utils/rowIndex';
 
 export interface UseGridRowInteractionsParams<R extends GridRowModel> {
     /** Data rows that pass the filter (pinned included, synthetic group rows excluded). */
@@ -14,7 +15,7 @@ export interface UseGridRowInteractionsParams<R extends GridRowModel> {
     disableMultipleRowSelection: boolean;
     disableRowSelectionOnClick: boolean;
     isHierarchyEnabled: boolean;
-    rowMetaMap: Map<GridRowId, GridRowMeta>;
+    rowMetaMap: ReadonlyMap<GridRowId, GridRowMeta>;
     /** The active tree-data / row-grouping handlers, if any. */
     activeHierarchyHandlers: { toggleExpansion: (id: GridRowId) => void } | null;
     onRowClick: ((params: GridRowParams<R>) => void) | undefined;
@@ -41,7 +42,7 @@ export function useGridRowInteractions<R extends GridRowModel>(
     // filter: never rows hidden by it, synthetic group rows, the pivot grand total, or stale
     // ids in the selection.
     const selectableRowIds = useMemo(() => {
-        const ids = dataRows.map(getRowId);
+        const { rowIds: ids } = getRowIndex(dataRows, getRowId, 'data');
         return isPivotActive ? ids.filter(id => id !== PIVOT_GRAND_TOTAL_ID) : ids;
     }, [dataRows, getRowId, isPivotActive]);
     const rowSelection = useGridRowSelection({

package/lib/hooks/features/useGridSpanning.ts

@@ -63,7 +63,7 @@ export interface UseGridSpanningParams<R extends GridRowModel> {
     rightPinnedColumns: GridColDef<R>[];
     /** Rows whose detail panel is expanded. A row span ends at such a row, above its panel. */
     expandedRowIds?: Set<GridRowId>;
-    rowMetaMap?: Map<GridRowId, GridRowMeta>;
+    rowMetaMap?: ReadonlyMap<GridRowId, GridRowMeta>;
     /** Resolves a row's id (the grid's getRowId); span caches are keyed by it. Defaults to `row.id`. */
     getRowId?: (row: R) => GridRowId;
 }
@@ -246,7 +246,7 @@ export function useGridSpanning<R extends GridRowModel>(params: UseGridSpanningP
 interface SectionContext<R extends GridRowModel> {
     spanColumns: { columns: SpanColumn<R>[]; leftCount: number; unpinnedCount: number };
     expandedRowIds?: Set<GridRowId>;
-    rowMetaMap?: Map<GridRowId, GridRowMeta>;
+    rowMetaMap?: ReadonlyMap<GridRowId, GridRowMeta>;
     getRowId: (row: R) => GridRowId;
     warned: Set<string>;
     out: SpanComputation;
@@ -356,7 +356,7 @@ function computeSection<R extends GridRowModel>(
 
     for (let r = 0; r < rows.length; r++) {
         const row = rows[r];
-        if (!row || row._isSkeleton) continue;
+        if (!row) continue;
         // Synthetic rows hold no data of their own: they are never a span origin (spans from above
         // already end before them).
         if (isSyntheticRowId(getRowId(row), rowMetaMap)) continue;
@@ -390,7 +390,7 @@ function buildParams<R extends GridRowModel>(
     colDef: GridColDef<R>,
     rowIndex: number,
     colIndex: number,
-    rowMetaMap: Map<GridRowId, GridRowMeta> | undefined,
+    rowMetaMap: ReadonlyMap<GridRowId, GridRowMeta> | undefined,
     warned: Set<string>,
 ): GridRenderCellParams<R> {
     const raw = row[colDef.field as keyof R];

package/lib/hooks/useRowGrouping.ts

@@ -15,6 +15,7 @@ import { sortItemsBySortModel, type GridSortValue } from '../utils/sorting';
 import { callSafely, getCellValue } from '../utils/values';
 import type { GridColumnLookup } from '../utils/columnLookup';
 import { computeAggregations } from '../utils/aggregation';
+import { LayeredMap } from '../utils/grouping/layeredMap';
 
 /** Where a group's aggregates are shown: on the group row, on a subtotal row after its children, or not at all. */
 export type GridGroupAggregationPosition = 'inline' | 'footer' | null;
@@ -436,16 +437,24 @@ export function useRowGrouping<R extends GridRowModel>(params: UseRowGroupingPar
 
     const getNode = useCallback((id: GridRowId) => treeNodes.get(id), [treeNodes]);
 
-    const rowMetaMap = useMemo<Map<GridRowId, GridRowMeta>>(() => {
+    // Leaf entries do not depend on expansion: built once per tree, so expanding or collapsing a
+    // group rebuilds only the group entries (a LayeredMap reads both without copying).
+    const leafMetaMap = useMemo<Map<GridRowId, GridRowMeta>>(() => {
         const map = new Map<GridRowId, GridRowMeta>();
         treeNodes.forEach((node, id) => {
-            const variants = groupRowVariants.get(id);
-            if (!variants) {
-                // One object per row (not shared per depth): `params.rowMeta` is public, and a consumer that
-                // writes to it must not change other rows.
-                map.set(id, { hasChildren: false, treeDepth: node.depth, isGroupRow: false });
-                return;
-            }
+            if (groupRowVariants.has(id)) return;
+            // One object per row (not shared per depth): `params.rowMeta` is public, and a consumer that
+            // writes to it must not change other rows.
+            map.set(id, { hasChildren: false, treeDepth: node.depth, isGroupRow: false });
+        });
+        return map;
+    }, [treeNodes, groupRowVariants]);
+
+    const rowMetaMap = useMemo<ReadonlyMap<GridRowId, GridRowMeta>>(() => {
+        const map = new Map<GridRowId, GridRowMeta>();
+        groupRowVariants.forEach((variants, id) => {
+            const node = treeNodes.get(id);
+            if (!node) return;
             const groupMeta: GridRowMeta = {
                 hasChildren: true,
                 treeDepth: node.depth,
@@ -467,8 +476,8 @@ export function useRowGrouping<R extends GridRowModel>(params: UseRowGroupingPar
                 });
             }
         });
-        return map;
-    }, [treeNodes, groupRowVariants, expandedGroupIds, aggregationPositions]);
+        return new LayeredMap(leafMetaMap, map);
+    }, [leafMetaMap, treeNodes, groupRowVariants, expandedGroupIds, aggregationPositions]);
 
     return useMemo(() => ({
         treeNodes,

package/lib/hooks/useRowReorder.ts

@@ -11,6 +11,11 @@ export interface UseRowReorderProps<R extends GridRowModel = GridRowModel> {
      */
     rows: R[];
     getRowId?: (row: R) => GridRowId;
+    /**
+     * Row id → index in `rows`, when the caller already has it (the grid's row store does). Saves
+     * a pass over every row each time `rows` changes, such as after every cell edit.
+     */
+    indexById?: ReadonlyMap<GridRowId, number>;
     rowReordering?: boolean;
 }
 
@@ -28,16 +33,17 @@ export interface UseRowReorderReturn {
 export function useRowReorder<R extends GridRowModel = GridRowModel>(
     props: UseRowReorderProps<R>
 ): UseRowReorderReturn {
-    const { onRowOrderChange, rows, getRowId, rowReordering = false } = props;
+    const { onRowOrderChange, rows, getRowId, indexById: givenIndexById, rowReordering = false } = props;
     const [draggedRowId, setDraggedRowId] = useState<GridRowId | null>(null);
     const [dragOverRowId, setDragOverRowId] = useState<GridRowId | null>(null);
     const detachDragEndRef = useRef<() => void>(() => {});
 
-    const indexById = useMemo(() => {
+    const indexById = useMemo<ReadonlyMap<GridRowId, number>>(() => {
+        if (givenIndexById) return givenIndexById;
         const map = new Map<GridRowId, number>();
         rows.forEach((row, index) => map.set(getRowId ? getRowId(row) : row.id, index));
         return map;
-    }, [rows, getRowId]);
+    }, [givenIndexById, rows, getRowId]);
 
     const canReorderRow = useCallback((id: GridRowId) => indexById.has(id), [indexById]);
 

package/lib/styles/base/reset.css

@@ -5,18 +5,17 @@
 :where([class*="ogx"], [class*="ogx"] *)::after {
   box-sizing: border-box;
 }
-.ogx--dragging {
-  user-select: none;
-  -webkit-user-select: none;
-  -moz-user-select: none;
-  -ms-user-select: none;
-}
+
 .ogx *:focus {
   outline: none;
 }
-.ogx button:not(.ogx-menu-item) {
+/* Background and border at zero specificity: a component's own button class (.ogx-button--contained,
+   the AI panel's suggestions, …) must win over this reset. Font and cursor keep their old weight. */
+:where(.ogx button:not(.ogx-menu-item)) {
   background: none;
   border: none;
+}
+.ogx button:not(.ogx-menu-item) {
   cursor: pointer;
   font-family: inherit;
   font-size: inherit;