@mui/x-data-grid-pro 8.0.0-beta.3 → 8.1.0

package/modern/hooks/features/columnPinning/useGridColumnPinningPreProcessors.js

@@ -1,105 +0,0 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
-import * as React from 'react';
-import { useGridRegisterPipeProcessor, gridVisiblePinnedColumnDefinitionsSelector } from '@mui/x-data-grid/internals';
-export const useGridColumnPinningPreProcessors = (apiRef, props) => {
-  const {
-    disableColumnPinning
-  } = props;
-  const prevAllPinnedColumns = React.useRef([]);
-  const reorderPinnedColumns = React.useCallback(columnsState => {
-    if (columnsState.orderedFields.length === 0 || disableColumnPinning) {
-      return columnsState;
-    }
-
-    // HACK: This is a hack needed because the pipe processors aren't pure enough. What
-    // they should be is `gridState -> gridState` transformers, but they only transform a slice
-    // of the state, not the full state. So if they need access to other parts of the state (like
-    // the `state.columns.orderedFields` in this case), they might lag behind because the selectors
-    // are selecting the old state in `apiRef`, not the state being computed in the current pipe processor.
-    const savedState = apiRef.current.state;
-    apiRef.current.state = _extends({}, savedState, {
-      columns: columnsState
-    });
-    const visibleColumns = gridVisiblePinnedColumnDefinitionsSelector(apiRef);
-    apiRef.current.state = savedState;
-    // HACK: Ends here //
-
-    const leftPinnedColumns = visibleColumns.left.map(c => c.field);
-    const rightPinnedColumns = visibleColumns.right.map(c => c.field);
-    let newOrderedFields;
-    const allPinnedColumns = [...leftPinnedColumns, ...rightPinnedColumns];
-    const {
-      orderedFieldsBeforePinningColumns
-    } = apiRef.current.caches.columnPinning;
-    if (orderedFieldsBeforePinningColumns) {
-      newOrderedFields = new Array(columnsState.orderedFields.length).fill(null);
-      const newOrderedFieldsBeforePinningColumns = [...newOrderedFields];
-
-      // Contains the fields not added to the orderedFields array yet
-      const remainingFields = [...columnsState.orderedFields];
-
-      // First, we check if the column was unpinned since the last processing.
-      // If yes and it still exists, we move it back to the same position it was before pinning
-      prevAllPinnedColumns.current.forEach(field => {
-        if (!allPinnedColumns.includes(field) && columnsState.lookup[field]) {
-          // Get the position before pinning
-          const index = orderedFieldsBeforePinningColumns.indexOf(field);
-          newOrderedFields[index] = field;
-          newOrderedFieldsBeforePinningColumns[index] = field;
-          // This field was already consumed so we prevent from being added again
-          remainingFields.splice(remainingFields.indexOf(field), 1);
-        }
-      });
-
-      // For columns still pinned, we keep stored their original positions
-      allPinnedColumns.forEach(field => {
-        let index = orderedFieldsBeforePinningColumns.indexOf(field);
-        // If index = -1, the pinned field didn't exist in the last processing, it's possibly being added now
-        // If index >= newOrderedFieldsBeforePinningColumns.length, then one or more columns were removed
-        // In both cases, use the position from the columns array
-        // TODO: detect removed columns and decrease the positions after it
-        if (index === -1 || index >= newOrderedFieldsBeforePinningColumns.length) {
-          index = columnsState.orderedFields.indexOf(field);
-        }
-
-        // The fallback above may make the column to be inserted in a position already occupied
-        // In this case, put it in any empty slot available
-        if (newOrderedFieldsBeforePinningColumns[index] !== null) {
-          index = 0;
-          while (newOrderedFieldsBeforePinningColumns[index] !== null) {
-            index += 1;
-          }
-        }
-        newOrderedFields[index] = field;
-        newOrderedFieldsBeforePinningColumns[index] = field;
-        // This field was already consumed so we prevent from being added again
-        remainingFields.splice(remainingFields.indexOf(field), 1);
-      });
-
-      // The fields remaining are those that're neither pinnned nor were unpinned
-      // For these, we spread them across both arrays making sure to not override existing values
-      let i = 0;
-      remainingFields.forEach(field => {
-        while (newOrderedFieldsBeforePinningColumns[i] !== null) {
-          i += 1;
-        }
-        newOrderedFieldsBeforePinningColumns[i] = field;
-        newOrderedFields[i] = field;
-      });
-      apiRef.current.caches.columnPinning.orderedFieldsBeforePinningColumns = newOrderedFieldsBeforePinningColumns;
-    } else {
-      newOrderedFields = [...columnsState.orderedFields];
-      apiRef.current.caches.columnPinning.orderedFieldsBeforePinningColumns = [...columnsState.orderedFields];
-    }
-    prevAllPinnedColumns.current = allPinnedColumns;
-    const centerColumns = newOrderedFields.filter(field => {
-      return !leftPinnedColumns.includes(field) && !rightPinnedColumns.includes(field);
-    });
-    return _extends({}, columnsState, {
-      orderedFields: [...leftPinnedColumns, ...centerColumns, ...rightPinnedColumns]
-    });
-  }, [apiRef, disableColumnPinning]);
-  useGridRegisterPipeProcessor(apiRef, 'hydrateColumns', reorderPinnedColumns);
-  const isColumnPinned = React.useCallback((initialValue, field) => apiRef.current.isColumnPinned(field), [apiRef]);
-  useGridRegisterPipeProcessor(apiRef, 'isColumnPinned', isColumnPinned);
-};

package/modern/hooks/features/columnReorder/columnReorderInterfaces.d.ts

@@ -1,6 +0,0 @@
-export interface GridColumnReorderState {
-  dragCol: string;
-}
-export interface GridCanBeReorderedPreProcessingContext {
-  targetIndex: number;
-}

package/modern/hooks/features/columnReorder/columnReorderInterfaces.js

@@ -1 +0,0 @@
-export {};

package/modern/hooks/features/columnReorder/columnReorderSelector.d.ts

@@ -1,3 +0,0 @@
-import { GridStatePro } from "../../../models/gridStatePro.js";
-export declare const gridColumnReorderSelector: import("@mui/x-data-grid").OutputSelector<GridStatePro, unknown, import("./columnReorderInterfaces").GridColumnReorderState>;
-export declare const gridColumnReorderDragColSelector: import("@mui/x-data-grid").OutputSelector<GridStatePro, import("./columnReorderInterfaces").GridColumnReorderState, string>;

package/modern/hooks/features/columnReorder/columnReorderSelector.js

@@ -1,3 +0,0 @@
-import { createSelector, createRootSelector } from '@mui/x-data-grid/internals';
-export const gridColumnReorderSelector = createRootSelector(state => state.columnReorder);
-export const gridColumnReorderDragColSelector = createSelector(gridColumnReorderSelector, columnReorder => columnReorder.dragCol);

package/modern/hooks/features/columnReorder/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./columnReorderSelector.js";
-export type { GridColumnReorderState } from './columnReorderInterfaces';

package/modern/hooks/features/columnReorder/index.js

@@ -1,2 +0,0 @@
-export * from "./columnReorderSelector.js";
-export {};

package/modern/hooks/features/columnReorder/useGridColumnReorder.d.ts

@@ -1,9 +0,0 @@
-import { RefObject } from '@mui/x-internals/types';
-import { GridStateInitializer } from '@mui/x-data-grid/internals';
-import { GridPrivateApiPro } from "../../../models/gridApiPro.js";
-import { DataGridProProcessedProps } from "../../../models/dataGridProProps.js";
-export declare const columnReorderStateInitializer: GridStateInitializer;
-/**
- * @requires useGridColumns (method)
- */
-export declare const useGridColumnReorder: (apiRef: RefObject<GridPrivateApiPro>, props: Pick<DataGridProProcessedProps, "disableColumnReorder" | "keepColumnPositionIfDraggedOutside" | "classes" | "onColumnOrderChange">) => void;

package/modern/hooks/features/columnReorder/useGridColumnReorder.js

@@ -1,242 +0,0 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
-import * as React from 'react';
-import composeClasses from '@mui/utils/composeClasses';
-import { useRtl } from '@mui/system/RtlProvider';
-import { useGridEvent, getDataGridUtilityClass, useGridLogger, useGridEventPriority } from '@mui/x-data-grid';
-import { gridColumnReorderDragColSelector } from "./columnReorderSelector.js";
-const CURSOR_MOVE_DIRECTION_LEFT = 'left';
-const CURSOR_MOVE_DIRECTION_RIGHT = 'right';
-const getCursorMoveDirectionX = (currentCoordinates, nextCoordinates) => {
-  return currentCoordinates.x <= nextCoordinates.x ? CURSOR_MOVE_DIRECTION_RIGHT : CURSOR_MOVE_DIRECTION_LEFT;
-};
-const hasCursorPositionChanged = (currentCoordinates, nextCoordinates) => currentCoordinates.x !== nextCoordinates.x || currentCoordinates.y !== nextCoordinates.y;
-const useUtilityClasses = ownerState => {
-  const {
-    classes
-  } = ownerState;
-  const slots = {
-    columnHeaderDragging: ['columnHeader--dragging']
-  };
-  return composeClasses(slots, getDataGridUtilityClass, classes);
-};
-export const columnReorderStateInitializer = state => _extends({}, state, {
-  columnReorder: {
-    dragCol: ''
-  }
-});
-
-/**
- * @requires useGridColumns (method)
- */
-export const useGridColumnReorder = (apiRef, props) => {
-  const logger = useGridLogger(apiRef, 'useGridColumnReorder');
-  const dragColNode = React.useRef(null);
-  const cursorPosition = React.useRef({
-    x: 0,
-    y: 0
-  });
-  const originColumnIndex = React.useRef(null);
-  const forbiddenIndexes = React.useRef({});
-  const removeDnDStylesTimeout = React.useRef(undefined);
-  const ownerState = {
-    classes: props.classes
-  };
-  const classes = useUtilityClasses(ownerState);
-  const isRtl = useRtl();
-  React.useEffect(() => {
-    return () => {
-      clearTimeout(removeDnDStylesTimeout.current);
-    };
-  }, []);
-  const handleDragStart = React.useCallback((params, event) => {
-    if (props.disableColumnReorder || params.colDef.disableReorder) {
-      return;
-    }
-    logger.debug(`Start dragging col ${params.field}`);
-    // Prevent drag events propagation.
-    // For more information check here https://github.com/mui/mui-x/issues/2680.
-    event.stopPropagation();
-    dragColNode.current = event.currentTarget;
-    dragColNode.current.classList.add(classes.columnHeaderDragging);
-    if (event.dataTransfer) {
-      event.dataTransfer.effectAllowed = 'move';
-    }
-    apiRef.current.setState(state => _extends({}, state, {
-      columnReorder: _extends({}, state.columnReorder, {
-        dragCol: params.field
-      })
-    }));
-    removeDnDStylesTimeout.current = setTimeout(() => {
-      dragColNode.current.classList.remove(classes.columnHeaderDragging);
-    });
-    originColumnIndex.current = apiRef.current.getColumnIndex(params.field, false);
-    const draggingColumnGroupPath = apiRef.current.getColumnGroupPath(params.field);
-    const columnIndex = originColumnIndex.current;
-    const allColumns = apiRef.current.getAllColumns();
-    const groupsLookup = apiRef.current.getAllGroupDetails();
-    const getGroupPathFromColumnIndex = colIndex => {
-      const field = allColumns[colIndex].field;
-      return apiRef.current.getColumnGroupPath(field);
-    };
-
-    // The limitingGroupId is the id of the group from which the dragged column should not escape
-    let limitingGroupId = null;
-    draggingColumnGroupPath.forEach(groupId => {
-      if (!groupsLookup[groupId]?.freeReordering) {
-        // Only consider group that are made of more than one column
-        if (columnIndex > 0 && getGroupPathFromColumnIndex(columnIndex - 1).includes(groupId)) {
-          limitingGroupId = groupId;
-        } else if (columnIndex + 1 < allColumns.length && getGroupPathFromColumnIndex(columnIndex + 1).includes(groupId)) {
-          limitingGroupId = groupId;
-        }
-      }
-    });
-    forbiddenIndexes.current = {};
-    for (let indexToForbid = 0; indexToForbid < allColumns.length; indexToForbid += 1) {
-      const leftIndex = indexToForbid <= columnIndex ? indexToForbid - 1 : indexToForbid;
-      const rightIndex = indexToForbid < columnIndex ? indexToForbid : indexToForbid + 1;
-      if (limitingGroupId !== null) {
-        // verify this indexToForbid will be linked to the limiting group. Otherwise forbid it
-        let allowIndex = false;
-        if (leftIndex >= 0 && getGroupPathFromColumnIndex(leftIndex).includes(limitingGroupId)) {
-          allowIndex = true;
-        } else if (rightIndex < allColumns.length && getGroupPathFromColumnIndex(rightIndex).includes(limitingGroupId)) {
-          allowIndex = true;
-        }
-        if (!allowIndex) {
-          forbiddenIndexes.current[indexToForbid] = true;
-        }
-      }
-
-      // Verify we are not splitting another group
-      if (leftIndex >= 0 && rightIndex < allColumns.length) {
-        getGroupPathFromColumnIndex(rightIndex).forEach(groupId => {
-          if (getGroupPathFromColumnIndex(leftIndex).includes(groupId)) {
-            if (!draggingColumnGroupPath.includes(groupId)) {
-              // moving here split the group groupId in two distincts chunks
-              if (!groupsLookup[groupId]?.freeReordering) {
-                forbiddenIndexes.current[indexToForbid] = true;
-              }
-            }
-          }
-        });
-      }
-    }
-  }, [props.disableColumnReorder, classes.columnHeaderDragging, logger, apiRef]);
-  const handleDragEnter = React.useCallback((params, event) => {
-    event.preventDefault();
-    // Prevent drag events propagation.
-    // For more information check here https://github.com/mui/mui-x/issues/2680.
-    event.stopPropagation();
-  }, []);
-  const handleDragOver = React.useCallback((params, event) => {
-    const dragColField = gridColumnReorderDragColSelector(apiRef);
-    if (!dragColField) {
-      return;
-    }
-    logger.debug(`Dragging over col ${params.field}`);
-    event.preventDefault();
-    // Prevent drag events propagation.
-    // For more information check here https://github.com/mui/mui-x/issues/2680.
-    event.stopPropagation();
-    const coordinates = {
-      x: event.clientX,
-      y: event.clientY
-    };
-    if (params.field !== dragColField && hasCursorPositionChanged(cursorPosition.current, coordinates)) {
-      const targetColIndex = apiRef.current.getColumnIndex(params.field, false);
-      const targetColVisibleIndex = apiRef.current.getColumnIndex(params.field, true);
-      const targetCol = apiRef.current.getColumn(params.field);
-      const dragColIndex = apiRef.current.getColumnIndex(dragColField, false);
-      const visibleColumns = apiRef.current.getVisibleColumns();
-      const allColumns = apiRef.current.getAllColumns();
-      const cursorMoveDirectionX = getCursorMoveDirectionX(cursorPosition.current, coordinates);
-      const hasMovedLeft = cursorMoveDirectionX === CURSOR_MOVE_DIRECTION_LEFT && (isRtl ? dragColIndex < targetColIndex : targetColIndex < dragColIndex);
-      const hasMovedRight = cursorMoveDirectionX === CURSOR_MOVE_DIRECTION_RIGHT && (isRtl ? targetColIndex < dragColIndex : dragColIndex < targetColIndex);
-      if (hasMovedLeft || hasMovedRight) {
-        let canBeReordered;
-        let indexOffsetInHiddenColumns = 0;
-        if (!targetCol.disableReorder) {
-          canBeReordered = true;
-        } else if (hasMovedLeft) {
-          canBeReordered = targetColVisibleIndex > 0 && !visibleColumns[targetColVisibleIndex - 1].disableReorder;
-        } else {
-          canBeReordered = targetColVisibleIndex < visibleColumns.length - 1 && !visibleColumns[targetColVisibleIndex + 1].disableReorder;
-        }
-        if (forbiddenIndexes.current[targetColIndex]) {
-          let nextVisibleColumnField;
-          let indexWithOffset = targetColIndex + indexOffsetInHiddenColumns;
-          if (hasMovedLeft) {
-            nextVisibleColumnField = targetColVisibleIndex > 0 ? visibleColumns[targetColVisibleIndex - 1].field : null;
-            while (indexWithOffset > 0 && allColumns[indexWithOffset].field !== nextVisibleColumnField && forbiddenIndexes.current[indexWithOffset]) {
-              indexOffsetInHiddenColumns -= 1;
-              indexWithOffset = targetColIndex + indexOffsetInHiddenColumns;
-            }
-          } else {
-            nextVisibleColumnField = targetColVisibleIndex + 1 < visibleColumns.length ? visibleColumns[targetColVisibleIndex + 1].field : null;
-            while (indexWithOffset < allColumns.length - 1 && allColumns[indexWithOffset].field !== nextVisibleColumnField && forbiddenIndexes.current[indexWithOffset]) {
-              indexOffsetInHiddenColumns += 1;
-              indexWithOffset = targetColIndex + indexOffsetInHiddenColumns;
-            }
-          }
-          if (forbiddenIndexes.current[indexWithOffset] || allColumns[indexWithOffset].field === nextVisibleColumnField) {
-            // If we ended up on a visible column, or a forbidden one, we cannot do the reorder
-            canBeReordered = false;
-          }
-        }
-        const canBeReorderedProcessed = apiRef.current.unstable_applyPipeProcessors('canBeReordered', canBeReordered, {
-          targetIndex: targetColVisibleIndex
-        });
-        if (canBeReorderedProcessed) {
-          apiRef.current.setColumnIndex(dragColField, targetColIndex + indexOffsetInHiddenColumns);
-        }
-      }
-      cursorPosition.current = coordinates;
-    }
-  }, [apiRef, logger, isRtl]);
-  const handleDragEnd = React.useCallback((params, event) => {
-    const dragColField = gridColumnReorderDragColSelector(apiRef);
-    if (props.disableColumnReorder || !dragColField) {
-      return;
-    }
-    logger.debug('End dragging col');
-    event.preventDefault();
-    // Prevent drag events propagation.
-    // For more information check here https://github.com/mui/mui-x/issues/2680.
-    event.stopPropagation();
-    clearTimeout(removeDnDStylesTimeout.current);
-
-    // For more information check here https://github.com/mui/mui-x/issues/14678
-    if (dragColNode.current.classList.contains(classes.columnHeaderDragging)) {
-      dragColNode.current.classList.remove(classes.columnHeaderDragging);
-    }
-    dragColNode.current = null;
-
-    // Check if the column was dropped outside the grid.
-    if (event.dataTransfer.dropEffect === 'none' && !props.keepColumnPositionIfDraggedOutside) {
-      // Accessing params.field may contain the wrong field as header elements are reused
-      apiRef.current.setColumnIndex(dragColField, originColumnIndex.current);
-      originColumnIndex.current = null;
-    } else {
-      // Emit the columnOrderChange event only once when the reordering stops.
-      const columnOrderChangeParams = {
-        column: apiRef.current.getColumn(dragColField),
-        targetIndex: apiRef.current.getColumnIndexRelativeToVisibleColumns(dragColField),
-        oldIndex: originColumnIndex.current
-      };
-      apiRef.current.publishEvent('columnOrderChange', columnOrderChangeParams);
-    }
-    apiRef.current.setState(state => _extends({}, state, {
-      columnReorder: _extends({}, state.columnReorder, {
-        dragCol: ''
-      })
-    }));
-  }, [apiRef, props.disableColumnReorder, props.keepColumnPositionIfDraggedOutside, logger, classes.columnHeaderDragging]);
-  useGridEvent(apiRef, 'columnHeaderDragStart', handleDragStart);
-  useGridEvent(apiRef, 'columnHeaderDragEnter', handleDragEnter);
-  useGridEvent(apiRef, 'columnHeaderDragOver', handleDragOver);
-  useGridEvent(apiRef, 'columnHeaderDragEnd', handleDragEnd);
-  useGridEvent(apiRef, 'cellDragEnter', handleDragEnter);
-  useGridEvent(apiRef, 'cellDragOver', handleDragOver);
-  useGridEventPriority(apiRef, 'columnOrderChange', props.onColumnOrderChange);
-};

package/modern/hooks/features/dataSource/gridDataSourceSelector.d.ts

@@ -1,7 +0,0 @@
-import type { GridRowId } from '@mui/x-data-grid';
-import { GridStatePro } from "../../../models/gridStatePro.js";
-export declare const gridDataSourceStateSelector: import("@mui/x-data-grid").OutputSelector<GridStatePro, unknown, import("./models").GridDataSourceState>;
-export declare const gridDataSourceLoadingSelector: import("@mui/x-data-grid").OutputSelector<GridStatePro, import("./models").GridDataSourceState, Record<GridRowId, boolean>>;
-export declare const gridDataSourceLoadingIdSelector: import("@mui/x-data-grid").OutputSelector<GridStatePro, GridRowId, boolean>;
-export declare const gridDataSourceErrorsSelector: import("@mui/x-data-grid").OutputSelector<GridStatePro, import("./models").GridDataSourceState, Record<GridRowId, any>>;
-export declare const gridDataSourceErrorSelector: import("@mui/x-data-grid").OutputSelector<GridStatePro, GridRowId, any>;

package/modern/hooks/features/dataSource/gridDataSourceSelector.js

@@ -1,6 +0,0 @@
-import { createSelector, createRootSelector } from '@mui/x-data-grid/internals';
-export const gridDataSourceStateSelector = createRootSelector(state => state.dataSource);
-export const gridDataSourceLoadingSelector = createSelector(gridDataSourceStateSelector, dataSource => dataSource.loading);
-export const gridDataSourceLoadingIdSelector = createSelector(gridDataSourceStateSelector, (dataSource, id) => dataSource.loading[id] ?? false);
-export const gridDataSourceErrorsSelector = createSelector(gridDataSourceStateSelector, dataSource => dataSource.errors);
-export const gridDataSourceErrorSelector = createSelector(gridDataSourceStateSelector, (dataSource, id) => dataSource.errors[id]);

package/modern/hooks/features/dataSource/models.d.ts

@@ -1,75 +0,0 @@
-import type { GridValidRowModel, GridRowId, GridGetRowsResponse, GridDataSource, GridGetRowsParams } from '@mui/x-data-grid';
-import type { GridDataSourceApiBase } from '@mui/x-data-grid/internals';
-export interface GridDataSourceState {
-  loading: Record<GridRowId, boolean>;
-  errors: Record<GridRowId, any>;
-}
-export interface GridGetRowsResponsePro extends GridGetRowsResponse {}
-export interface GridGetRowsParamsPro extends GridGetRowsParams {
-  /**
-   * Array of keys returned by `getGroupKey` of all the parent rows until the row for which the data is requested
-   * `getGroupKey` prop must be implemented to use this.
-   * Useful for `treeData` and `rowGrouping` only.
-   */
-  groupKeys?: string[];
-}
-export interface GridDataSourcePro extends Omit<GridDataSource, 'getRows'> {
-  /**
-   * This method will be called when the grid needs to fetch some rows.
-   * @param {GridGetRowsParamsPro} params The parameters required to fetch the rows.
-   * @returns {Promise<GridGetRowsResponsePro>} A promise that resolves to the data of type [GridGetRowsResponsePro].
-   */
-  getRows(params: GridGetRowsParamsPro): Promise<GridGetRowsResponsePro>;
-  /**
-   * Used to group rows by their parent group. Replaces `getTreeDataPath` used in client side tree-data.
-   * @param {GridRowModel} row The row to get the group key of.
-   * @returns {string} The group key for the row.
-   */
-  getGroupKey?: (row: GridValidRowModel) => string;
-  /**
-   * Used to determine the number of children a row has on server.
-   * @param {GridRowModel} row The row to check the number of children.
-   * @returns {number} The number of children the row has.
-   * If the children count is not available for some reason, but there are some children, `getChildrenCount` should return `-1`.
-   */
-  getChildrenCount?: (row: GridValidRowModel) => number;
-}
-export interface GridDataSourceApiBasePro extends Omit<GridDataSourceApiBase, 'fetchRows'> {
-  /**
-   * Fetches the rows from the server.
-   * If no `parentId` option is provided, it fetches the root rows.
-   * Any missing parameter from `params` will be filled from the state (sorting, filtering, etc.).
-   * @param {GridRowId} parentId The id of the parent node (default: `GRID_ROOT_GROUP_ID`).
-   * @param {Partial<GridGetRowsParamsPro>} params Request parameters override.
-   */
-  fetchRows: (parentId?: GridRowId, params?: Partial<GridGetRowsParamsPro>) => void;
-  /**
-   * Set the loading state of a parent row.
-   * @param {string} parentId The id of the parent node.
-   * @param {boolean} loading The loading state to set.
-   */
-  setChildrenLoading: (parentId: GridRowId, loading: boolean) => void;
-  /**
-   * Set error occured while fetching the children of a row.
-   * @param {string} parentId The id of the parent node.
-   * @param {Error} error The error of type `Error` or `null`.
-   */
-  setChildrenFetchError: (parentId: GridRowId, error: Error | null) => void;
-}
-export interface GridDataSourceApiPro {
-  /**
-   * The data source API.
-   */
-  dataSource: GridDataSourceApiBasePro;
-}
-export interface GridDataSourcePrivateApiPro {
-  /**
-   * Initiates the fetch of the children of a row.
-   * @param {string} id The id of the group to be fetched.
-   */
-  fetchRowChildren: (id: GridRowId) => void;
-  /**
-   * Resets the data source state.
-   */
-  resetDataSourceState: () => void;
-}

package/modern/hooks/features/dataSource/models.js

@@ -1 +0,0 @@
-export {};

package/modern/hooks/features/dataSource/useGridDataSourceBasePro.d.ts

@@ -1,33 +0,0 @@
-import { RefObject } from '@mui/x-internals/types';
-import { GridRowId, GridDataSourceCacheDefaultConfig } from '@mui/x-data-grid';
-import { CacheChunkManager, DataSourceRowsUpdateStrategy } from '@mui/x-data-grid/internals';
-import { GridPrivateApiPro } from "../../../models/gridApiPro.js";
-import { DataGridProProcessedProps } from "../../../models/dataGridProProps.js";
-import { GridDataSourceApiPro, GridDataSourcePrivateApiPro } from "./models.js";
-export declare const INITIAL_STATE: {
-  loading: {};
-  errors: {};
-};
-export declare const useGridDataSourceBasePro: <Api extends GridPrivateApiPro>(apiRef: RefObject<Api>, props: DataGridProProcessedProps, options?: {
-  cacheOptions?: GridDataSourceCacheDefaultConfig;
-  fetchRowChildren?: (parentId: GridRowId) => void;
-}) => {
-  api: {
-    public: GridDataSourceApiPro;
-    private: GridDataSourcePrivateApiPro;
-  };
-  strategyProcessor: {
-    strategyName: DataSourceRowsUpdateStrategy;
-    group: "dataSourceRowsUpdate";
-    processor: import("@mui/x-data-grid/internals").GridStrategyProcessor<"dataSourceRowsUpdate">;
-  };
-  events: {
-    strategyAvailabilityChange: import("@mui/x-data-grid").GridEventListener<"strategyAvailabilityChange">;
-    sortModelChange: (params: unknown) => void;
-    filterModelChange: (params: unknown) => void;
-    paginationModelChange: (params: unknown) => void;
-  };
-  setStrategyAvailability: () => void;
-  cacheChunkManager: CacheChunkManager;
-  cache: import("@mui/x-data-grid").GridDataSourceCache;
-};