@mui/x-data-grid 8.28.7 → 8.29.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mui/x-data-grid",
-  "version": "8.28.7",
+  "version": "8.29.0",
   "author": "MUI Team",
   "description": "The Community plan edition of the MUI X Data Grid components.",
   "license": "MIT",
@@ -42,8 +42,8 @@
     "clsx": "^2.1.1",
     "prop-types": "^15.8.1",
     "use-sync-external-store": "^1.6.0",
-    "@mui/x-internals": "8.26.0",
-    "@mui/x-virtualizer": "0.3.5"
+    "@mui/x-internals": "8.29.0",
+    "@mui/x-virtualizer": "0.4.0"
   },
   "peerDependencies": {
     "@emotion/react": "^11.9.0",
@@ -65,30 +65,205 @@
     "node": ">=14.0.0"
   },
   "type": "commonjs",
-  "main": "./index.js",
-  "types": "./index.d.ts",
   "exports": {
     "./package.json": "./package.json",
     ".": {
+      "import": {
+        "types": "./index.d.mts",
+        "default": "./index.mjs"
+      },
       "require": {
         "types": "./index.d.ts",
         "default": "./index.js"
       },
       "default": {
-        "types": "./esm/index.d.ts",
-        "default": "./esm/index.js"
+        "types": "./index.d.mts",
+        "default": "./index.mjs"
+      }
+    },
+    "./material": {
+      "import": {
+        "types": "./material/index.d.mts",
+        "default": "./material/index.mjs"
+      },
+      "require": {
+        "types": "./material/index.d.ts",
+        "default": "./material/index.js"
+      },
+      "default": {
+        "types": "./material/index.d.mts",
+        "default": "./material/index.mjs"
+      }
+    },
+    "./internals/demo": {
+      "import": {
+        "types": "./internals/demo/index.d.mts",
+        "default": "./internals/demo/index.mjs"
+      },
+      "require": {
+        "types": "./internals/demo/index.d.ts",
+        "default": "./internals/demo/index.js"
+      },
+      "default": {
+        "types": "./internals/demo/index.d.mts",
+        "default": "./internals/demo/index.mjs"
+      }
+    },
+    "./DataGrid": {
+      "import": {
+        "types": "./DataGrid/index.d.mts",
+        "default": "./DataGrid/index.mjs"
+      },
+      "require": {
+        "types": "./DataGrid/index.d.ts",
+        "default": "./DataGrid/index.js"
+      },
+      "default": {
+        "types": "./DataGrid/index.d.mts",
+        "default": "./DataGrid/index.mjs"
       }
     },
-    "./*": {
+    "./colDef": {
+      "import": {
+        "types": "./colDef/index.d.mts",
+        "default": "./colDef/index.mjs"
+      },
+      "require": {
+        "types": "./colDef/index.d.ts",
+        "default": "./colDef/index.js"
+      },
+      "default": {
+        "types": "./colDef/index.d.mts",
+        "default": "./colDef/index.mjs"
+      }
+    },
+    "./components": {
+      "import": {
+        "types": "./components/index.d.mts",
+        "default": "./components/index.mjs"
+      },
+      "require": {
+        "types": "./components/index.d.ts",
+        "default": "./components/index.js"
+      },
+      "default": {
+        "types": "./components/index.d.mts",
+        "default": "./components/index.mjs"
+      }
+    },
+    "./constants": {
+      "import": {
+        "types": "./constants/index.d.mts",
+        "default": "./constants/index.mjs"
+      },
+      "require": {
+        "types": "./constants/index.d.ts",
+        "default": "./constants/index.js"
+      },
+      "default": {
+        "types": "./constants/index.d.mts",
+        "default": "./constants/index.mjs"
+      }
+    },
+    "./context": {
+      "import": {
+        "types": "./context/index.d.mts",
+        "default": "./context/index.mjs"
+      },
       "require": {
-        "types": "./*/index.d.ts",
-        "default": "./*/index.js"
+        "types": "./context/index.d.ts",
+        "default": "./context/index.js"
       },
       "default": {
-        "types": "./esm/*/index.d.ts",
-        "default": "./esm/*/index.js"
+        "types": "./context/index.d.mts",
+        "default": "./context/index.mjs"
       }
     },
-    "./esm": null
-  }
+    "./hooks": {
+      "import": {
+        "types": "./hooks/index.d.mts",
+        "default": "./hooks/index.mjs"
+      },
+      "require": {
+        "types": "./hooks/index.d.ts",
+        "default": "./hooks/index.js"
+      },
+      "default": {
+        "types": "./hooks/index.d.mts",
+        "default": "./hooks/index.mjs"
+      }
+    },
+    "./internals": {
+      "import": {
+        "types": "./internals/index.d.mts",
+        "default": "./internals/index.mjs"
+      },
+      "require": {
+        "types": "./internals/index.d.ts",
+        "default": "./internals/index.js"
+      },
+      "default": {
+        "types": "./internals/index.d.mts",
+        "default": "./internals/index.mjs"
+      }
+    },
+    "./locales": {
+      "import": {
+        "types": "./locales/index.d.mts",
+        "default": "./locales/index.mjs"
+      },
+      "require": {
+        "types": "./locales/index.d.ts",
+        "default": "./locales/index.js"
+      },
+      "default": {
+        "types": "./locales/index.d.mts",
+        "default": "./locales/index.mjs"
+      }
+    },
+    "./models": {
+      "import": {
+        "types": "./models/index.d.mts",
+        "default": "./models/index.mjs"
+      },
+      "require": {
+        "types": "./models/index.d.ts",
+        "default": "./models/index.js"
+      },
+      "default": {
+        "types": "./models/index.d.mts",
+        "default": "./models/index.mjs"
+      }
+    },
+    "./themeAugmentation": {
+      "import": {
+        "types": "./themeAugmentation/index.d.mts",
+        "default": "./themeAugmentation/index.mjs"
+      },
+      "require": {
+        "types": "./themeAugmentation/index.d.ts",
+        "default": "./themeAugmentation/index.js"
+      },
+      "default": {
+        "types": "./themeAugmentation/index.d.mts",
+        "default": "./themeAugmentation/index.mjs"
+      }
+    },
+    "./utils": {
+      "import": {
+        "types": "./utils/index.d.mts",
+        "default": "./utils/index.mjs"
+      },
+      "require": {
+        "types": "./utils/index.d.ts",
+        "default": "./utils/index.js"
+      },
+      "default": {
+        "types": "./utils/index.d.mts",
+        "default": "./utils/index.mjs"
+      }
+    }
+  },
+  "main": "./index.js",
+  "types": "./index.d.ts"
 }

package/themeAugmentation/index.d.mts

@@ -0,0 +1,2 @@
+export * from "./overrides.mjs";
+export * from "./props.mjs";

package/themeAugmentation/index.mjs

@@ -0,0 +1,4 @@
+export * from "./overrides.mjs";
+export * from "./props.mjs";
+// TODO v5
+// export * from './components';

package/themeAugmentation/overrides.d.mts

@@ -0,0 +1,18 @@
+import type { GridClassKey } from "../constants/gridClasses.mjs";
+export interface DataGridComponentNameToClassKey {
+  MuiDataGrid: GridClassKey;
+}
+declare module '@mui/material/styles' {
+  interface ComponentNameToClassKey extends DataGridComponentNameToClassKey {}
+  interface PaletteDataGrid {
+    bg?: string;
+    headerBg?: string;
+    pinnedBg?: string;
+  }
+  interface CssVarsPalette {
+    DataGrid: PaletteDataGrid;
+  }
+  interface PaletteOptions {
+    DataGrid?: Partial<PaletteDataGrid>;
+  }
+}

package/themeAugmentation/props.d.mts

@@ -0,0 +1,15 @@
+import type { ComponentsOverrides, ComponentsProps } from '@mui/material/styles';
+import type { DataGridProps } from "../models/props/DataGridProps.mjs";
+export interface DataGridComponentsPropsList {
+  MuiDataGrid: DataGridProps;
+}
+export interface DataGridComponents<Theme = unknown> {
+  MuiDataGrid?: {
+    defaultProps?: ComponentsProps['MuiDataGrid'];
+    styleOverrides?: ComponentsOverrides<Theme>['MuiDataGrid'];
+  };
+}
+declare module '@mui/material/styles' {
+  interface ComponentsPropsList extends DataGridComponentsPropsList {}
+  interface Components<Theme = unknown> extends DataGridComponents<Theme> {}
+}

package/utils/cellBorderUtils.d.mts

@@ -0,0 +1,4 @@
+import type { DataGridProcessedProps } from "../models/props/DataGridProps.mjs";
+import { PinnedColumnPosition } from "../internals/constants.mjs";
+export declare const shouldCellShowRightBorder: (pinnedPosition: PinnedColumnPosition | undefined, indexInSection: number, sectionLength: number, showCellVerticalBorderRootProp: DataGridProcessedProps["showCellVerticalBorder"], gridHasFiller: boolean, pinnedColumnsSectionSeparatorRootProp: DataGridProcessedProps["pinnedColumnsSectionSeparator"]) => boolean;
+export declare const shouldCellShowLeftBorder: (pinnedPosition: PinnedColumnPosition | undefined, indexInSection: number, showCellVerticalBorderRootProp: DataGridProcessedProps["showCellVerticalBorder"], pinnedColumnsSectionSeparatorRootProp: DataGridProcessedProps["pinnedColumnsSectionSeparator"]) => boolean;

package/utils/cellBorderUtils.mjs

@@ -0,0 +1,24 @@
+import { PinnedColumnPosition } from "../internals/constants.mjs";
+export const shouldCellShowRightBorder = (pinnedPosition, indexInSection, sectionLength, showCellVerticalBorderRootProp, gridHasFiller, pinnedColumnsSectionSeparatorRootProp) => {
+  const isSectionLastCell = indexInSection === sectionLength - 1;
+  if (pinnedColumnsSectionSeparatorRootProp?.startsWith('border') && pinnedPosition === PinnedColumnPosition.LEFT && isSectionLastCell) {
+    return true;
+  }
+  if (showCellVerticalBorderRootProp) {
+    if (pinnedPosition === PinnedColumnPosition.LEFT) {
+      return true;
+    }
+    if (pinnedPosition === PinnedColumnPosition.RIGHT) {
+      return !isSectionLastCell;
+    }
+    // pinnedPosition === undefined, middle section
+    return !isSectionLastCell || gridHasFiller;
+  }
+  return false;
+};
+export const shouldCellShowLeftBorder = (pinnedPosition, indexInSection, showCellVerticalBorderRootProp, pinnedColumnsSectionSeparatorRootProp) => {
+  if (pinnedColumnsSectionSeparatorRootProp?.startsWith('border')) {
+    return pinnedPosition === PinnedColumnPosition.RIGHT && indexInSection === 0;
+  }
+  return showCellVerticalBorderRootProp && pinnedPosition === PinnedColumnPosition.RIGHT && indexInSection === 0;
+};

package/utils/cleanupTracking/FinalizationRegistryBasedCleanupTracking.d.mts

@@ -0,0 +1,7 @@
+import type { CleanupTracking, UnsubscribeFn, UnregisterToken } from "./CleanupTracking.mjs";
+export declare class FinalizationRegistryBasedCleanupTracking implements CleanupTracking {
+  registry: FinalizationRegistry<UnsubscribeFn>;
+  register(object: any, unsubscribe: UnsubscribeFn, unregisterToken: UnregisterToken): void;
+  unregister(unregisterToken: UnregisterToken): void;
+  reset(): void;
+}

package/utils/cleanupTracking/TimerBasedCleanupTracking.d.mts

@@ -0,0 +1,9 @@
+import type { CleanupTracking, UnregisterToken, UnsubscribeFn } from "./CleanupTracking.mjs";
+export declare class TimerBasedCleanupTracking implements CleanupTracking {
+  timeouts?: Map<number, number> | undefined;
+  cleanupTimeout: number;
+  constructor(timeout?: number);
+  register(object: any, unsubscribe: UnsubscribeFn, unregisterToken: UnregisterToken): void;
+  unregister(unregisterToken: UnregisterToken): void;
+  reset(): void;
+}

package/utils/composeGridClasses.d.mts

@@ -0,0 +1,3 @@
+import composeClasses from '@mui/utils/composeClasses';
+import type { DataGridProcessedProps } from "../models/props/DataGridProps.mjs";
+export declare function composeGridClasses(classes: DataGridProcessedProps['classes'], slots: Parameters<typeof composeClasses>[0]): Record<string, string>;

package/utils/composeGridClasses.mjs

@@ -0,0 +1,5 @@
+import composeClasses from '@mui/utils/composeClasses';
+import { getDataGridUtilityClass } from "../constants/gridClasses.mjs";
+export function composeGridClasses(classes, slots) {
+  return composeClasses(slots, getDataGridUtilityClass, classes);
+}

package/utils/css/context.mjs

@@ -0,0 +1,60 @@
+'use client';
+
+import * as React from 'react';
+import { useGridRootProps } from "../../hooks/utils/useGridRootProps.mjs";
+import { useGridConfiguration } from "../../hooks/utils/useGridConfiguration.mjs";
+import { jsx as _jsx } from "react/jsx-runtime";
+const CLASSNAME_PREFIX = 'MuiDataGridVariables';
+const CSSVariablesContext = /*#__PURE__*/React.createContext({
+  className: 'unset',
+  tag: /*#__PURE__*/_jsx("style", {
+    href: "/unset"
+  })
+});
+if (process.env.NODE_ENV !== "production") CSSVariablesContext.displayName = "CSSVariablesContext";
+export function useCSSVariablesClass() {
+  return React.useContext(CSSVariablesContext).className;
+}
+export function useCSSVariablesContext() {
+  return React.useContext(CSSVariablesContext);
+}
+export function GridPortalWrapper({
+  children
+}) {
+  const className = useCSSVariablesClass();
+  return /*#__PURE__*/_jsx("div", {
+    className: className,
+    children: children
+  });
+}
+export function GridCSSVariablesContext(props) {
+  const config = useGridConfiguration();
+  const rootProps = useGridRootProps();
+  const description = config.hooks.useCSSVariables();
+  const context = React.useMemo(() => {
+    const className = `${CLASSNAME_PREFIX}-${description.id}`;
+    const cssString = `.${className}{${variablesToString(description.variables)}}`;
+    const tag = /*#__PURE__*/_jsx("style", {
+      href: `/${className}`,
+      nonce: rootProps.nonce,
+      children: cssString
+    });
+    return {
+      className,
+      tag
+    };
+  }, [rootProps.nonce, description]);
+  return /*#__PURE__*/_jsx(CSSVariablesContext.Provider, {
+    value: context,
+    children: props.children
+  });
+}
+function variablesToString(variables) {
+  let output = '';
+  for (const key in variables) {
+    if (Object.hasOwn(variables, key) && variables[key] !== undefined) {
+      output += `${key}:${variables[key]};`;
+    }
+  }
+  return output;
+}

package/utils/domUtils.d.mts

@@ -0,0 +1,30 @@
+import { gridClasses } from "../constants/gridClasses.mjs";
+import type { GridPrivateApiCommunity } from "../models/api/gridApiCommunity.mjs";
+import type { GridRowId } from "../models/gridRows.mjs";
+export declare function isOverflown(element: Element): boolean;
+export declare function findParentElementFromClassName(elem: Element, className: string): Element | null;
+export declare function escapeOperandAttributeSelector(operand: string): string;
+export declare function getGridColumnHeaderElement(root: Element, field: string): HTMLDivElement | null;
+export declare function getGridRowElement(root: Element, id: GridRowId): HTMLDivElement | null;
+export declare function getGridCellElement(root: Element, {
+  id,
+  field
+}: {
+  id: GridRowId;
+  field: string;
+}): HTMLDivElement | null;
+export declare const getActiveElement: (root?: Document | ShadowRoot) => Element | null;
+export declare function isEventTargetInPortal(event: React.SyntheticEvent): boolean;
+export declare function getFieldFromHeaderElem(colCellEl: Element): string;
+export declare function findHeaderElementFromField(elem: Element, field: string): HTMLDivElement;
+export declare function getFieldsFromGroupHeaderElem(colCellEl: Element): string[];
+export declare function findGroupHeaderElementsFromField(elem: Element, field: string): Element[];
+export declare function findGridCellElementsFromCol(col: HTMLElement, api: GridPrivateApiCommunity): Element[];
+export declare function findGridElement(api: GridPrivateApiCommunity, klass: keyof typeof gridClasses): HTMLElement;
+export declare function findLeftPinnedCellsAfterCol(api: GridPrivateApiCommunity, col: HTMLElement, isRtl: boolean): HTMLElement[];
+export declare function findRightPinnedCellsBeforeCol(api: GridPrivateApiCommunity, col: HTMLElement, isRtl: boolean): HTMLElement[];
+export declare function findLeftPinnedHeadersAfterCol(api: GridPrivateApiCommunity, col: HTMLElement, isRtl: boolean): HTMLElement[];
+export declare function findRightPinnedHeadersBeforeCol(api: GridPrivateApiCommunity, col: HTMLElement, isRtl: boolean): HTMLElement[];
+export declare function findGridHeader(api: GridPrivateApiCommunity, field: string): Element | null;
+export declare function findGridHeaderFilter(api: GridPrivateApiCommunity, field: string): Element | null;
+export declare function findGridCells(api: GridPrivateApiCommunity, field: string): Element[];

package/utils/domUtils.mjs

@@ -0,0 +1,208 @@
+import { gridClasses } from "../constants/gridClasses.mjs";
+export function isOverflown(element) {
+  return element.scrollHeight > element.clientHeight || element.scrollWidth > element.clientWidth;
+}
+export function findParentElementFromClassName(elem, className) {
+  return elem.closest(`.${className}`);
+}
+
+// TODO, eventually replaces this function with CSS.escape, once available in jsdom, either added manually or built in
+// https://github.com/jsdom/jsdom/issues/1550#issuecomment-236734471
+export function escapeOperandAttributeSelector(operand) {
+  return operand.replace(/["\\]/g, '\\$&');
+}
+export function getGridColumnHeaderElement(root, field) {
+  return root.querySelector(`[role="columnheader"][data-field="${escapeOperandAttributeSelector(field)}"]`);
+}
+function getGridRowElementSelector(id) {
+  return `.${gridClasses.row}[data-id="${escapeOperandAttributeSelector(String(id))}"]`;
+}
+export function getGridRowElement(root, id) {
+  return root.querySelector(getGridRowElementSelector(id));
+}
+export function getGridCellElement(root, {
+  id,
+  field
+}) {
+  const rowSelector = getGridRowElementSelector(id);
+  const cellSelector = `.${gridClasses.cell}[data-field="${escapeOperandAttributeSelector(field)}"]`;
+  const selector = `${rowSelector} ${cellSelector}`;
+  return root.querySelector(selector);
+}
+
+// https://www.abeautifulsite.net/posts/finding-the-active-element-in-a-shadow-root/
+export const getActiveElement = (root = document) => {
+  const activeEl = root.activeElement;
+  if (!activeEl) {
+    return null;
+  }
+  if (activeEl.shadowRoot) {
+    return getActiveElement(activeEl.shadowRoot);
+  }
+  return activeEl;
+};
+export function isEventTargetInPortal(event) {
+  if (
+  // The target is not an element when triggered by a Select inside the cell
+  // See https://github.com/mui/material-ui/issues/10534
+  event.target.nodeType === 1 && !event.currentTarget.contains(event.target)) {
+    return true;
+  }
+  return false;
+}
+export function getFieldFromHeaderElem(colCellEl) {
+  return colCellEl.getAttribute('data-field');
+}
+export function findHeaderElementFromField(elem, field) {
+  return elem.querySelector(`[data-field="${escapeOperandAttributeSelector(field)}"]`);
+}
+export function getFieldsFromGroupHeaderElem(colCellEl) {
+  return colCellEl.getAttribute('data-fields').slice(2, -2).split('-|-');
+}
+export function findGroupHeaderElementsFromField(elem, field) {
+  return Array.from(elem.querySelectorAll(`[data-fields*="|-${escapeOperandAttributeSelector(field)}-|"]`) ?? []);
+}
+export function findGridCellElementsFromCol(col, api) {
+  const root = findParentElementFromClassName(col, gridClasses.root);
+  if (!root) {
+    throw new Error('MUI X: The root element is not found.');
+  }
+  const ariaColIndex = col.getAttribute('aria-colindex');
+  if (!ariaColIndex) {
+    return [];
+  }
+  const colIndex = Number(ariaColIndex) - 1;
+  const cells = [];
+  if (!api.virtualScrollerRef?.current) {
+    return [];
+  }
+  queryRows(api).forEach(rowElement => {
+    const rowId = rowElement.getAttribute('data-id');
+    if (!rowId) {
+      return;
+    }
+    let columnIndex = colIndex;
+    const cellColSpanInfo = api.unstable_getCellColSpanInfo(rowId, colIndex);
+    if (cellColSpanInfo && cellColSpanInfo.spannedByColSpan) {
+      columnIndex = cellColSpanInfo.leftVisibleCellIndex;
+    }
+    const cell = rowElement.querySelector(`[data-colindex="${columnIndex}"]`);
+    if (cell) {
+      cells.push(cell);
+    }
+  });
+  return cells;
+}
+export function findGridElement(api, klass) {
+  return api.rootElementRef.current.querySelector(`.${gridClasses[klass]}`);
+}
+const findPinnedCells = ({
+  api,
+  colIndex,
+  position,
+  filterFn
+}) => {
+  if (colIndex === null) {
+    return [];
+  }
+  const cells = [];
+  queryRows(api).forEach(rowElement => {
+    const rowId = rowElement.getAttribute('data-id');
+    if (!rowId) {
+      return;
+    }
+    rowElement.querySelectorAll(`.${gridClasses[position === 'left' ? 'cell--pinnedLeft' : 'cell--pinnedRight']}`).forEach(cell => {
+      const currentColIndex = parseCellColIndex(cell);
+      if (currentColIndex !== null && filterFn(currentColIndex)) {
+        cells.push(cell);
+      }
+    });
+  });
+  return cells;
+};
+export function findLeftPinnedCellsAfterCol(api, col, isRtl) {
+  const colIndex = parseCellColIndex(col);
+  return findPinnedCells({
+    api,
+    colIndex,
+    position: isRtl ? 'right' : 'left',
+    filterFn: index => isRtl ? index < colIndex : index > colIndex
+  });
+}
+export function findRightPinnedCellsBeforeCol(api, col, isRtl) {
+  const colIndex = parseCellColIndex(col);
+  return findPinnedCells({
+    api,
+    colIndex,
+    position: isRtl ? 'left' : 'right',
+    filterFn: index => isRtl ? index > colIndex : index < colIndex
+  });
+}
+const findPinnedHeaders = ({
+  api,
+  colIndex,
+  position,
+  filterFn
+}) => {
+  if (!api.columnHeadersContainerRef?.current) {
+    return [];
+  }
+  if (colIndex === null) {
+    return [];
+  }
+  const elements = [];
+  api.columnHeadersContainerRef.current.querySelectorAll(`.${gridClasses[position === 'left' ? 'columnHeader--pinnedLeft' : 'columnHeader--pinnedRight']}`).forEach(element => {
+    const currentColIndex = parseCellColIndex(element);
+    if (currentColIndex !== null && filterFn(currentColIndex, element)) {
+      elements.push(element);
+    }
+  });
+  return elements;
+};
+export function findLeftPinnedHeadersAfterCol(api, col, isRtl) {
+  const colIndex = parseCellColIndex(col);
+  return findPinnedHeaders({
+    api,
+    position: isRtl ? 'right' : 'left',
+    colIndex,
+    filterFn: index => isRtl ? index < colIndex : index > colIndex
+  });
+}
+export function findRightPinnedHeadersBeforeCol(api, col, isRtl) {
+  const colIndex = parseCellColIndex(col);
+  return findPinnedHeaders({
+    api,
+    position: isRtl ? 'left' : 'right',
+    colIndex,
+    filterFn: (index, element) => {
+      if (element.classList.contains(gridClasses['columnHeader--last'])) {
+        return false;
+      }
+      return isRtl ? index > colIndex : index < colIndex;
+    }
+  });
+}
+export function findGridHeader(api, field) {
+  const headers = api.columnHeadersContainerRef.current;
+  return headers.querySelector(`:scope > div > [data-field="${escapeOperandAttributeSelector(field)}"][role="columnheader"]`);
+}
+export function findGridHeaderFilter(api, field) {
+  const headers = api.columnHeadersContainerRef.current;
+  return headers.querySelector(`:scope > .${gridClasses.headerFilterRow} > [data-field="${escapeOperandAttributeSelector(field)}"]`);
+}
+export function findGridCells(api, field) {
+  const container = api.virtualScrollerRef.current;
+  return Array.from(container.querySelectorAll(`:scope > div > div > div > [data-field="${escapeOperandAttributeSelector(field)}"][role="gridcell"]`));
+}
+function queryRows(api) {
+  return api.virtualScrollerRef.current.querySelectorAll(
+  // Use > to ignore rows from nested Data Grids (for example in detail panel)
+  `:scope > div > div > .${gridClasses.row}`);
+}
+function parseCellColIndex(col) {
+  const ariaColIndex = col.getAttribute('aria-colindex');
+  if (!ariaColIndex) {
+    return null;
+  }
+  return Number(ariaColIndex) - 1;
+}

package/utils/exportAs.d.mts

@@ -0,0 +1,12 @@
+import type { GridExportExtension } from "../models/gridExport.mjs";
+/**
+ * I have hesitated to use https://github.com/eligrey/FileSaver.js.
+ * If we get bug reports that this project solves, we should consider using it.
+ *
+ * Related resources.
+ * https://blog.logrocket.com/programmatic-file-downloads-in-the-browser-9a5186298d5c/
+ * https://github.com/mbrn/filefy/blob/ec4ed0b7415d93be7158c23029f2ea1fa0b8e2d9/src/core/BaseBuilder.ts
+ * https://unpkg.com/browse/@progress/kendo-file-saver@1.0.7/dist/es/save-as.js
+ * https://github.com/ag-grid/ag-grid/blob/9565c219b6210aa85fa833c929d0728f9d163a91/community-modules/csv-export/src/csvExport/downloader.ts
+ */
+export declare function exportAs<ExtraExtensions extends string>(blob: Blob, extension?: GridExportExtension | ExtraExtensions, filename?: string): void;

package/utils/getGridLocalization.d.mts

@@ -0,0 +1,11 @@
+import type { GridLocaleText } from "../models/api/gridLocaleTextApi.mjs";
+export interface Localization {
+  components: {
+    MuiDataGrid: {
+      defaultProps: {
+        localeText: Partial<GridLocaleText>;
+      };
+    };
+  };
+}
+export declare const getGridLocalization: (gridTranslations: Partial<GridLocaleText>) => Localization;

package/utils/getPublicApiRef.d.mts

@@ -0,0 +1,3 @@
+import type { RefObject } from '@mui/x-internals/types';
+import type { GridPrivateApiCommunity } from "../models/api/gridApiCommunity.mjs";
+export declare function getPublicApiRef<PrivateApi extends GridPrivateApiCommunity>(apiRef: RefObject<PrivateApi>): RefObject<ReturnType<PrivateApi["getPublicApi"]>>;