@mui/x-data-grid 9.0.0-alpha.1 → 9.0.0-alpha.2

package/components/GridColumnUnsortedIcon.mjs

@@ -0,0 +1,17 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+const _excluded = ["sortingOrder"];
+import * as React from 'react';
+import { useGridRootProps } from "../hooks/utils/useGridRootProps.mjs";
+import { jsx as _jsx } from "react/jsx-runtime";
+export const GridColumnUnsortedIcon = /*#__PURE__*/React.memo(function GridColumnHeaderSortIcon(props) {
+  const {
+      sortingOrder
+    } = props,
+    other = _objectWithoutPropertiesLoose(props, _excluded);
+  const rootProps = useGridRootProps();
+  const [nextSortDirection] = sortingOrder;
+  const Icon = nextSortDirection === 'asc' ? rootProps.slots.columnSortedAscendingIcon : rootProps.slots.columnSortedDescendingIcon;
+  return Icon ? /*#__PURE__*/_jsx(Icon, _extends({}, other)) : null;
+});
+if (process.env.NODE_ENV !== "production") GridColumnUnsortedIcon.displayName = "GridColumnUnsortedIcon";

package/components/GridFooter.d.mts

@@ -0,0 +1,5 @@
+import { type GridFooterContainerProps } from "./containers/GridFooterContainer.mjs";
+declare const GridFooter: import("react").ForwardRefExoticComponent<GridFooterContainerProps> | import("react").ForwardRefExoticComponent<import("react").HTMLAttributes<HTMLDivElement> & {
+  sx?: import("@mui/system").SxProps<import("@mui/system").Theme>;
+} & import("react").RefAttributes<HTMLDivElement>>;
+export { GridFooter };

package/components/GridFooter.mjs

@@ -0,0 +1,42 @@
+'use client';
+
+import _extends from "@babel/runtime/helpers/esm/extends";
+import PropTypes from 'prop-types';
+import { forwardRef } from '@mui/x-internals/forwardRef';
+import { useGridSelector } from "../hooks/utils/useGridSelector.mjs";
+import { gridTopLevelRowCountSelector } from "../hooks/features/rows/gridRowsSelector.mjs";
+import { gridRowSelectionCountSelector } from "../hooks/features/rowSelection/gridRowSelectionSelector.mjs";
+import { gridFilteredTopLevelRowCountSelector } from "../hooks/features/filter/gridFilterSelector.mjs";
+import { useGridApiContext } from "../hooks/utils/useGridApiContext.mjs";
+import { GridSelectedRowCount } from "./GridSelectedRowCount.mjs";
+import { GridFooterContainer } from "./containers/GridFooterContainer.mjs";
+import { useGridRootProps } from "../hooks/utils/useGridRootProps.mjs";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+const GridFooter = forwardRef(function GridFooter(props, ref) {
+  const apiRef = useGridApiContext();
+  const rootProps = useGridRootProps();
+  const totalTopLevelRowCount = useGridSelector(apiRef, gridTopLevelRowCountSelector);
+  const selectedRowCount = useGridSelector(apiRef, gridRowSelectionCountSelector);
+  const visibleTopLevelRowCount = useGridSelector(apiRef, gridFilteredTopLevelRowCountSelector);
+  const selectedRowCountElement = !rootProps.hideFooterSelectedRowCount && selectedRowCount > 0 ? /*#__PURE__*/_jsx(GridSelectedRowCount, {
+    selectedRowCount: selectedRowCount
+  }) : /*#__PURE__*/_jsx("div", {});
+  const rowCountElement = !rootProps.hideFooterRowCount && !rootProps.pagination ? /*#__PURE__*/_jsx(rootProps.slots.footerRowCount, _extends({}, rootProps.slotProps?.footerRowCount, {
+    rowCount: totalTopLevelRowCount,
+    visibleRowCount: visibleTopLevelRowCount
+  })) : null;
+  const paginationElement = rootProps.pagination && !rootProps.hideFooterPagination && rootProps.slots.pagination && /*#__PURE__*/_jsx(rootProps.slots.pagination, _extends({}, rootProps.slotProps?.pagination));
+  return /*#__PURE__*/_jsxs(GridFooterContainer, _extends({}, props, {
+    ref: ref,
+    children: [selectedRowCountElement, rowCountElement, paginationElement]
+  }));
+});
+if (process.env.NODE_ENV !== "production") GridFooter.displayName = "GridFooter";
+process.env.NODE_ENV !== "production" ? GridFooter.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
+} : void 0;
+export { GridFooter };

package/components/GridHeader.mjs

@@ -0,0 +1,11 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import * as React from 'react';
+import { useGridRootProps } from "../hooks/utils/useGridRootProps.mjs";
+import { GridPreferencesPanel } from "./panel/GridPreferencesPanel.mjs";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+export function GridHeader() {
+  const rootProps = useGridRootProps();
+  return /*#__PURE__*/_jsxs(React.Fragment, {
+    children: [/*#__PURE__*/_jsx(GridPreferencesPanel, {}), rootProps.showToolbar && /*#__PURE__*/_jsx(rootProps.slots.toolbar, _extends({}, rootProps.slotProps?.toolbar))]
+  });
+}

package/components/GridHeaders.mjs

@@ -0,0 +1,49 @@
+'use client';
+
+import _extends from "@babel/runtime/helpers/esm/extends";
+import { fastMemo } from '@mui/x-internals/fastMemo';
+import { useGridPrivateApiContext } from "../hooks/utils/useGridPrivateApiContext.mjs";
+import { useGridSelector } from "../hooks/utils/useGridSelector.mjs";
+import { useGridRootProps } from "../hooks/utils/useGridRootProps.mjs";
+import { gridColumnVisibilityModelSelector, gridVisibleColumnDefinitionsSelector } from "../hooks/features/columns/gridColumnsSelector.mjs";
+import { gridFilterActiveItemsLookupSelector } from "../hooks/features/filter/gridFilterSelector.mjs";
+import { gridSortColumnLookupSelector } from "../hooks/features/sorting/gridSortingSelector.mjs";
+import { gridTabIndexColumnHeaderSelector, gridTabIndexCellSelector, gridFocusColumnHeaderSelector, gridTabIndexColumnGroupHeaderSelector, gridFocusColumnGroupHeaderSelector } from "../hooks/features/focus/gridFocusStateSelector.mjs";
+import { gridColumnGroupsHeaderMaxDepthSelector, gridColumnGroupsHeaderStructureSelector } from "../hooks/features/columnGrouping/gridColumnGroupsSelector.mjs";
+import { gridColumnMenuSelector } from "../hooks/features/columnMenu/columnMenuSelector.mjs";
+import { jsx as _jsx } from "react/jsx-runtime";
+function GridHeaders() {
+  const apiRef = useGridPrivateApiContext();
+  const rootProps = useGridRootProps();
+  const visibleColumns = useGridSelector(apiRef, gridVisibleColumnDefinitionsSelector);
+  const filterColumnLookup = useGridSelector(apiRef, gridFilterActiveItemsLookupSelector);
+  const sortColumnLookup = useGridSelector(apiRef, gridSortColumnLookupSelector);
+  const columnHeaderTabIndexState = useGridSelector(apiRef, gridTabIndexColumnHeaderSelector);
+  const hasNoCellTabIndexState = useGridSelector(apiRef, () => gridTabIndexCellSelector(apiRef) === null);
+  const columnGroupHeaderTabIndexState = useGridSelector(apiRef, gridTabIndexColumnGroupHeaderSelector);
+  const columnHeaderFocus = useGridSelector(apiRef, gridFocusColumnHeaderSelector);
+  const columnGroupHeaderFocus = useGridSelector(apiRef, gridFocusColumnGroupHeaderSelector);
+  const headerGroupingMaxDepth = useGridSelector(apiRef, gridColumnGroupsHeaderMaxDepthSelector);
+  const columnMenuState = useGridSelector(apiRef, gridColumnMenuSelector);
+  const columnVisibility = useGridSelector(apiRef, gridColumnVisibilityModelSelector);
+  const columnGroupsHeaderStructure = useGridSelector(apiRef, gridColumnGroupsHeaderStructureSelector);
+  const hasOtherElementInTabSequence = !(columnGroupHeaderTabIndexState === null && columnHeaderTabIndexState === null && hasNoCellTabIndexState);
+  const columnsContainerRef = apiRef.current.columnHeadersContainerRef;
+  return /*#__PURE__*/_jsx(rootProps.slots.columnHeaders, _extends({
+    ref: columnsContainerRef,
+    visibleColumns: visibleColumns,
+    filterColumnLookup: filterColumnLookup,
+    sortColumnLookup: sortColumnLookup,
+    columnHeaderTabIndexState: columnHeaderTabIndexState,
+    columnGroupHeaderTabIndexState: columnGroupHeaderTabIndexState,
+    columnHeaderFocus: columnHeaderFocus,
+    columnGroupHeaderFocus: columnGroupHeaderFocus,
+    headerGroupingMaxDepth: headerGroupingMaxDepth,
+    columnMenuState: columnMenuState,
+    columnVisibility: columnVisibility,
+    columnGroupsHeaderStructure: columnGroupsHeaderStructure,
+    hasOtherElementInTabSequence: hasOtherElementInTabSequence
+  }, rootProps.slotProps?.columnHeaders));
+}
+const MemoizedGridHeaders = fastMemo(GridHeaders);
+export { MemoizedGridHeaders as GridHeaders };

package/components/GridLoadingOverlay.d.mts

@@ -0,0 +1,17 @@
+import * as React from 'react';
+import { type GridOverlayProps } from "./containers/GridOverlay.mjs";
+import type { GridLoadingOverlayVariant } from "../hooks/features/overlays/gridOverlaysInterfaces.mjs";
+export interface GridLoadingOverlayProps extends GridOverlayProps {
+  /**
+   * The variant of the overlay.
+   * @default 'linear-progress'
+   */
+  variant?: GridLoadingOverlayVariant;
+  /**
+   * The variant of the overlay when no rows are displayed.
+   * @default 'skeleton'
+   */
+  noRowsVariant?: GridLoadingOverlayVariant;
+}
+declare const GridLoadingOverlay: React.ForwardRefExoticComponent<GridLoadingOverlayProps> | React.ForwardRefExoticComponent<GridLoadingOverlayProps & React.RefAttributes<HTMLDivElement>>;
+export { GridLoadingOverlay };

package/components/GridLoadingOverlay.mjs

@@ -0,0 +1,70 @@
+'use client';
+
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+const _excluded = ["variant", "noRowsVariant", "style"];
+import * as React from 'react';
+import PropTypes from 'prop-types';
+import { forwardRef } from '@mui/x-internals/forwardRef';
+import { useGridRootProps } from "../hooks/utils/useGridRootProps.mjs";
+import { GridOverlay } from "./containers/GridOverlay.mjs";
+import { GridSkeletonLoadingOverlay } from "./GridSkeletonLoadingOverlay.mjs";
+import { useGridApiContext } from "../hooks/utils/useGridApiContext.mjs";
+import { gridRowCountSelector, useGridSelector } from "../hooks/index.mjs";
+import { jsx as _jsx } from "react/jsx-runtime";
+const LOADING_VARIANTS = {
+  'circular-progress': {
+    component: rootProps => rootProps.slots.baseCircularProgress,
+    style: {}
+  },
+  'linear-progress': {
+    component: rootProps => rootProps.slots.baseLinearProgress,
+    style: {
+      display: 'block'
+    }
+  },
+  skeleton: {
+    component: () => GridSkeletonLoadingOverlay,
+    style: {
+      display: 'block'
+    }
+  }
+};
+const GridLoadingOverlay = forwardRef(function GridLoadingOverlay(props, ref) {
+  const {
+      variant = 'linear-progress',
+      noRowsVariant = 'skeleton',
+      style
+    } = props,
+    other = _objectWithoutPropertiesLoose(props, _excluded);
+  const apiRef = useGridApiContext();
+  const rootProps = useGridRootProps();
+  const rowsCount = useGridSelector(apiRef, gridRowCountSelector);
+  const activeVariant = LOADING_VARIANTS[rowsCount === 0 ? noRowsVariant : variant];
+  const Component = activeVariant.component(rootProps);
+  return /*#__PURE__*/_jsx(GridOverlay, _extends({
+    style: _extends({}, activeVariant.style, style)
+  }, other, {
+    ref: ref,
+    children: /*#__PURE__*/_jsx(Component, {})
+  }));
+});
+if (process.env.NODE_ENV !== "production") GridLoadingOverlay.displayName = "GridLoadingOverlay";
+process.env.NODE_ENV !== "production" ? GridLoadingOverlay.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  /**
+   * The variant of the overlay when no rows are displayed.
+   * @default 'skeleton'
+   */
+  noRowsVariant: PropTypes.oneOf(['circular-progress', 'linear-progress', 'skeleton']),
+  sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
+  /**
+   * The variant of the overlay.
+   * @default 'linear-progress'
+   */
+  variant: PropTypes.oneOf(['circular-progress', 'linear-progress', 'skeleton'])
+} : void 0;
+export { GridLoadingOverlay };

package/components/GridNoColumnsOverlay.d.mts

@@ -0,0 +1,5 @@
+import { type GridOverlayProps } from "./containers/GridOverlay.mjs";
+declare const GridNoColumnsOverlay: import("react").ForwardRefExoticComponent<GridOverlayProps> | import("react").ForwardRefExoticComponent<import("react").HTMLAttributes<HTMLDivElement> & {
+  sx?: import("@mui/system").SxProps<import("@mui/system").Theme>;
+} & import("react").RefAttributes<HTMLDivElement>>;
+export { GridNoColumnsOverlay };

package/components/GridNoColumnsOverlay.mjs

@@ -0,0 +1,38 @@
+'use client';
+
+import _extends from "@babel/runtime/helpers/esm/extends";
+import PropTypes from 'prop-types';
+import { forwardRef } from '@mui/x-internals/forwardRef';
+import { useGridRootProps } from "../hooks/utils/useGridRootProps.mjs";
+import { useGridApiContext } from "../hooks/utils/useGridApiContext.mjs";
+import { GridOverlay } from "./containers/GridOverlay.mjs";
+import { GridPreferencePanelsValue } from "../hooks/features/preferencesPanel/gridPreferencePanelsValue.mjs";
+import { gridColumnFieldsSelector, useGridSelector } from "../hooks/index.mjs";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+const GridNoColumnsOverlay = forwardRef(function GridNoColumnsOverlay(props, ref) {
+  const rootProps = useGridRootProps();
+  const apiRef = useGridApiContext();
+  const columns = useGridSelector(apiRef, gridColumnFieldsSelector);
+  const handleOpenManageColumns = () => {
+    apiRef.current.showPreferences(GridPreferencePanelsValue.columns);
+  };
+  const showManageColumnsButton = !rootProps.disableColumnSelector && columns.length > 0;
+  return /*#__PURE__*/_jsxs(GridOverlay, _extends({}, props, {
+    ref: ref,
+    children: [apiRef.current.getLocaleText('noColumnsOverlayLabel'), showManageColumnsButton && /*#__PURE__*/_jsx(rootProps.slots.baseButton, _extends({
+      size: "small"
+    }, rootProps.slotProps?.baseButton, {
+      onClick: handleOpenManageColumns,
+      children: apiRef.current.getLocaleText('noColumnsOverlayManageColumns')
+    }))]
+  }));
+});
+if (process.env.NODE_ENV !== "production") GridNoColumnsOverlay.displayName = "GridNoColumnsOverlay";
+process.env.NODE_ENV !== "production" ? GridNoColumnsOverlay.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
+} : void 0;
+export { GridNoColumnsOverlay };

package/components/GridNoResultsOverlay.d.mts

@@ -0,0 +1,4 @@
+import { type GridOverlayProps } from "./containers/GridOverlay.mjs";
+export declare const GridNoResultsOverlay: import("react").ForwardRefExoticComponent<GridOverlayProps> | import("react").ForwardRefExoticComponent<import("react").HTMLAttributes<HTMLDivElement> & {
+  sx?: import("@mui/system").SxProps<import("@mui/system").Theme>;
+} & import("react").RefAttributes<HTMLDivElement>>;

package/components/GridNoResultsOverlay.mjs

@@ -0,0 +1,16 @@
+'use client';
+
+import _extends from "@babel/runtime/helpers/esm/extends";
+import { forwardRef } from '@mui/x-internals/forwardRef';
+import { useGridApiContext } from "../hooks/utils/useGridApiContext.mjs";
+import { GridOverlay } from "./containers/GridOverlay.mjs";
+import { jsx as _jsx } from "react/jsx-runtime";
+export const GridNoResultsOverlay = forwardRef(function GridNoResultsOverlay(props, ref) {
+  const apiRef = useGridApiContext();
+  const noResultsOverlayLabel = apiRef.current.getLocaleText('noResultsOverlayLabel');
+  return /*#__PURE__*/_jsx(GridOverlay, _extends({}, props, {
+    ref: ref,
+    children: noResultsOverlayLabel
+  }));
+});
+if (process.env.NODE_ENV !== "production") GridNoResultsOverlay.displayName = "GridNoResultsOverlay";

package/components/GridNoRowsOverlay.d.mts

@@ -0,0 +1,5 @@
+import { type GridOverlayProps } from "./containers/GridOverlay.mjs";
+declare const GridNoRowsOverlay: import("react").ForwardRefExoticComponent<GridOverlayProps> | import("react").ForwardRefExoticComponent<import("react").HTMLAttributes<HTMLDivElement> & {
+  sx?: import("@mui/system").SxProps<import("@mui/system").Theme>;
+} & import("react").RefAttributes<HTMLDivElement>>;
+export { GridNoRowsOverlay };

package/components/GridNoRowsOverlay.mjs

@@ -0,0 +1,25 @@
+'use client';
+
+import _extends from "@babel/runtime/helpers/esm/extends";
+import PropTypes from 'prop-types';
+import { forwardRef } from '@mui/x-internals/forwardRef';
+import { useGridApiContext } from "../hooks/utils/useGridApiContext.mjs";
+import { GridOverlay } from "./containers/GridOverlay.mjs";
+import { jsx as _jsx } from "react/jsx-runtime";
+const GridNoRowsOverlay = forwardRef(function GridNoRowsOverlay(props, ref) {
+  const apiRef = useGridApiContext();
+  const noRowsLabel = apiRef.current.getLocaleText('noRowsLabel');
+  return /*#__PURE__*/_jsx(GridOverlay, _extends({}, props, {
+    ref: ref,
+    children: noRowsLabel
+  }));
+});
+if (process.env.NODE_ENV !== "production") GridNoRowsOverlay.displayName = "GridNoRowsOverlay";
+process.env.NODE_ENV !== "production" ? GridNoRowsOverlay.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])
+} : void 0;
+export { GridNoRowsOverlay };

package/components/GridPagination.mjs

@@ -0,0 +1,86 @@
+'use client';
+
+import _extends from "@babel/runtime/helpers/esm/extends";
+import * as React from 'react';
+import { styled } from '@mui/material/styles';
+import PropTypes from 'prop-types';
+import { NotRendered } from "../utils/assert.mjs";
+import { useGridSelector } from "../hooks/utils/useGridSelector.mjs";
+import { useGridApiContext } from "../hooks/utils/useGridApiContext.mjs";
+import { useGridRootProps } from "../hooks/utils/useGridRootProps.mjs";
+import { gridPaginationModelSelector, gridPaginationRowCountSelector, gridPageCountSelector } from "../hooks/features/pagination/gridPaginationSelector.mjs";
+import { jsx as _jsx } from "react/jsx-runtime";
+const GridPaginationRoot = styled(NotRendered, {
+  slot: 'internal'
+})({
+  maxHeight: 'calc(100% + 1px)',
+  // border width
+  flexGrow: 1
+});
+function GridPagination() {
+  const apiRef = useGridApiContext();
+  const rootProps = useGridRootProps();
+  const paginationModel = useGridSelector(apiRef, gridPaginationModelSelector);
+  const rowCount = useGridSelector(apiRef, gridPaginationRowCountSelector);
+  const pageCount = useGridSelector(apiRef, gridPageCountSelector);
+  const {
+    paginationMode,
+    loading
+  } = rootProps;
+  const unknownRowCount = rowCount == null || rowCount === -1;
+  const disabled = unknownRowCount && paginationMode === 'server' && loading;
+  const lastPage = React.useMemo(() => Math.max(0, pageCount - 1), [pageCount]);
+  const computedPage = React.useMemo(() => {
+    if (unknownRowCount) {
+      return paginationModel.page;
+    }
+    return paginationModel.page <= lastPage ? paginationModel.page : lastPage;
+  }, [lastPage, paginationModel.page, unknownRowCount]);
+  const handlePageSizeChange = React.useCallback(pageSize => {
+    apiRef.current.setPageSize(pageSize);
+  }, [apiRef]);
+  const handlePageChange = React.useCallback((_, page) => {
+    apiRef.current.setPage(page);
+  }, [apiRef]);
+  const isPageSizeIncludedInPageSizeOptions = pageSize => {
+    for (let i = 0; i < rootProps.pageSizeOptions.length; i += 1) {
+      const option = rootProps.pageSizeOptions[i];
+      if (typeof option === 'number') {
+        if (option === pageSize) {
+          return true;
+        }
+      } else if (option.value === pageSize) {
+        return true;
+      }
+    }
+    return false;
+  };
+  if (process.env.NODE_ENV !== 'production') {
+    // eslint-disable-next-line react-hooks/rules-of-hooks
+    const warnedOnceMissingInPageSizeOptions = React.useRef(false);
+    const pageSize = rootProps.paginationModel?.pageSize ?? paginationModel.pageSize;
+    if (!warnedOnceMissingInPageSizeOptions.current && !rootProps.autoPageSize && !isPageSizeIncludedInPageSizeOptions(pageSize)) {
+      console.warn([`MUI X: The page size \`${paginationModel.pageSize}\` is not present in the \`pageSizeOptions\`.`, `Add it to show the pagination select.`].join('\n'));
+      warnedOnceMissingInPageSizeOptions.current = true;
+    }
+  }
+  const pageSizeOptions = isPageSizeIncludedInPageSizeOptions(paginationModel.pageSize) ? rootProps.pageSizeOptions : [];
+  return /*#__PURE__*/_jsx(GridPaginationRoot, _extends({
+    as: rootProps.slots.basePagination,
+    count: rowCount ?? -1,
+    page: computedPage,
+    rowsPerPageOptions: pageSizeOptions,
+    rowsPerPage: paginationModel.pageSize,
+    onPageChange: handlePageChange,
+    onRowsPerPageChange: handlePageSizeChange,
+    disabled: disabled
+  }, rootProps.slotProps?.basePagination));
+}
+process.env.NODE_ENV !== "production" ? GridPagination.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  component: PropTypes.elementType
+} : void 0;
+export { GridPagination };

package/components/GridRow.d.mts

@@ -0,0 +1,39 @@
+import * as React from 'react';
+import type { GridRowId, GridRowModel } from "../models/gridRows.mjs";
+import type { GridPinnedColumns } from "../hooks/features/columns/index.mjs";
+import type { GridStateColDef } from "../models/colDef/gridColDef.mjs";
+export interface GridRowProps extends React.HTMLAttributes<HTMLDivElement> {
+  row: GridRowModel;
+  rowId: GridRowId;
+  selected: boolean;
+  /**
+   * Index of the row in the whole sorted and filtered dataset.
+   * If some rows above have expanded children, this index also take those children into account.
+   */
+  index: number;
+  rowHeight: number | 'auto';
+  offsetLeft: number;
+  columnsTotalWidth: number;
+  firstColumnIndex: number;
+  lastColumnIndex: number;
+  visibleColumns: GridStateColDef[];
+  pinnedColumns: GridPinnedColumns;
+  /**
+   * Determines which cell has focus.
+   * If `null`, no cell in this row has focus.
+   */
+  focusedColumnIndex: number | undefined;
+  isFirstVisible: boolean;
+  isLastVisible: boolean;
+  isNotVisible: boolean;
+  showBottomBorder: boolean;
+  scrollbarWidth: number;
+  gridHasFiller: boolean;
+  onClick?: React.MouseEventHandler<HTMLDivElement>;
+  onDoubleClick?: React.MouseEventHandler<HTMLDivElement>;
+  onMouseEnter?: React.MouseEventHandler<HTMLDivElement>;
+  onMouseLeave?: React.MouseEventHandler<HTMLDivElement>;
+  [x: `data-${string}`]: string;
+}
+declare const MemoizedGridRow: React.ForwardRefExoticComponent<GridRowProps> | React.ForwardRefExoticComponent<GridRowProps & React.RefAttributes<HTMLDivElement>>;
+export { MemoizedGridRow as GridRow };