@mui/x-data-grid 5.4.0 → 5.6.0

package/constants/localeTextConstants.js

@@ -0,0 +1,107 @@
+export const GRID_DEFAULT_LOCALE_TEXT = {
+  // Root
+  noRowsLabel: 'No rows',
+  noResultsOverlayLabel: 'No results found.',
+  errorOverlayDefaultLabel: 'An error occurred.',
+  // Density selector toolbar button text
+  toolbarDensity: 'Density',
+  toolbarDensityLabel: 'Density',
+  toolbarDensityCompact: 'Compact',
+  toolbarDensityStandard: 'Standard',
+  toolbarDensityComfortable: 'Comfortable',
+  // Columns selector toolbar button text
+  toolbarColumns: 'Columns',
+  toolbarColumnsLabel: 'Select columns',
+  // Filters toolbar button text
+  toolbarFilters: 'Filters',
+  toolbarFiltersLabel: 'Show filters',
+  toolbarFiltersTooltipHide: 'Hide filters',
+  toolbarFiltersTooltipShow: 'Show filters',
+  toolbarFiltersTooltipActive: count => count !== 1 ? `${count} active filters` : `${count} active filter`,
+  // Export selector toolbar button text
+  toolbarExport: 'Export',
+  toolbarExportLabel: 'Export',
+  toolbarExportCSV: 'Download as CSV',
+  toolbarExportPrint: 'Print',
+  // Columns panel text
+  columnsPanelTextFieldLabel: 'Find column',
+  columnsPanelTextFieldPlaceholder: 'Column title',
+  columnsPanelDragIconLabel: 'Reorder column',
+  columnsPanelShowAllButton: 'Show all',
+  columnsPanelHideAllButton: 'Hide all',
+  // Filter panel text
+  filterPanelAddFilter: 'Add filter',
+  filterPanelDeleteIconLabel: 'Delete',
+  filterPanelLinkOperator: 'Logic operator',
+  filterPanelOperators: 'Operator',
+  // TODO v6: rename to filterPanelOperator
+  filterPanelOperatorAnd: 'And',
+  filterPanelOperatorOr: 'Or',
+  filterPanelColumns: 'Columns',
+  filterPanelInputLabel: 'Value',
+  filterPanelInputPlaceholder: 'Filter value',
+  // Filter operators text
+  filterOperatorContains: 'contains',
+  filterOperatorEquals: 'equals',
+  filterOperatorStartsWith: 'starts with',
+  filterOperatorEndsWith: 'ends with',
+  filterOperatorIs: 'is',
+  filterOperatorNot: 'is not',
+  filterOperatorAfter: 'is after',
+  filterOperatorOnOrAfter: 'is on or after',
+  filterOperatorBefore: 'is before',
+  filterOperatorOnOrBefore: 'is on or before',
+  filterOperatorIsEmpty: 'is empty',
+  filterOperatorIsNotEmpty: 'is not empty',
+  filterOperatorIsAnyOf: 'is any of',
+  // Filter values text
+  filterValueAny: 'any',
+  filterValueTrue: 'true',
+  filterValueFalse: 'false',
+  // Column menu text
+  columnMenuLabel: 'Menu',
+  columnMenuShowColumns: 'Show columns',
+  columnMenuFilter: 'Filter',
+  columnMenuHideColumn: 'Hide',
+  columnMenuUnsort: 'Unsort',
+  columnMenuSortAsc: 'Sort by ASC',
+  columnMenuSortDesc: 'Sort by DESC',
+  // Column header text
+  columnHeaderFiltersTooltipActive: count => count !== 1 ? `${count} active filters` : `${count} active filter`,
+  columnHeaderFiltersLabel: 'Show filters',
+  columnHeaderSortIconLabel: 'Sort',
+  // Rows selected footer text
+  footerRowSelected: count => count !== 1 ? `${count.toLocaleString()} rows selected` : `${count.toLocaleString()} row selected`,
+  // Total row amount footer text
+  footerTotalRows: 'Total Rows:',
+  // Total visible row amount footer text
+  footerTotalVisibleRows: (visibleCount, totalCount) => `${visibleCount.toLocaleString()} of ${totalCount.toLocaleString()}`,
+  // Checkbox selection text
+  checkboxSelectionHeaderName: 'Checkbox selection',
+  checkboxSelectionSelectAllRows: 'Select all rows',
+  checkboxSelectionUnselectAllRows: 'Unselect all rows',
+  checkboxSelectionSelectRow: 'Select row',
+  checkboxSelectionUnselectRow: 'Unselect row',
+  // Boolean cell text
+  booleanCellTrueLabel: 'yes',
+  booleanCellFalseLabel: 'no',
+  // Actions cell more text
+  actionsCellMore: 'more',
+  // Column pinning text
+  pinToLeft: 'Pin to left',
+  pinToRight: 'Pin to right',
+  unpin: 'Unpin',
+  // Tree Data
+  treeDataGroupingHeaderName: 'Group',
+  treeDataExpand: 'see children',
+  treeDataCollapse: 'hide children',
+  // Grouping columns
+  groupingColumnHeaderName: 'Group',
+  groupColumn: name => `Group by ${name}`,
+  unGroupColumn: name => `Stop grouping by ${name}`,
+  // Master/detail
+  expandDetailPanel: 'Expand',
+  collapseDetailPanel: 'Collapse',
+  // Used core components translation keys
+  MuiTablePagination: {}
+};

package/constants/package.json

@@ -0,0 +1,6 @@
+{
+  "sideEffects": false,
+  "module": "./index.js",
+  "main": "../node/constants/index.js",
+  "types": "./index.d.ts"
+}

package/context/GridContextProvider.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+export declare const GridContextProvider: ({ apiRef, props, children }: {
+    apiRef: any;
+    props: any;
+    children: any;
+}) => JSX.Element;

package/context/GridContextProvider.js

@@ -0,0 +1,17 @@
+import * as React from 'react';
+import { GridApiContext } from '../components/GridApiContext';
+import { GridRootPropsContext } from './GridRootPropsContext';
+import { jsx as _jsx } from "react/jsx-runtime";
+export const GridContextProvider = ({
+  apiRef,
+  props,
+  children
+}) => {
+  return /*#__PURE__*/_jsx(GridRootPropsContext.Provider, {
+    value: props,
+    children: /*#__PURE__*/_jsx(GridApiContext.Provider, {
+      value: apiRef,
+      children: children
+    })
+  });
+};

package/context/GridRootPropsContext.d.ts

@@ -0,0 +1,3 @@
+import * as React from 'react';
+declare const GridRootPropsContext: React.Context<unknown>;
+export { GridRootPropsContext };

package/context/GridRootPropsContext.js

@@ -0,0 +1,8 @@
+import * as React from 'react';
+const GridRootPropsContext = /*#__PURE__*/React.createContext(undefined);
+
+if (process.env.NODE_ENV !== 'production') {
+  GridRootPropsContext.displayName = 'GridRootPropsContext';
+}
+
+export { GridRootPropsContext };

package/context/index.d.ts

@@ -0,0 +1 @@
+export * from './GridContextProvider';

package/context/index.js

@@ -0,0 +1 @@
+export * from './GridContextProvider';

package/context/package.json

@@ -0,0 +1,6 @@
+{
+  "sideEffects": false,
+  "module": "./index.js",
+  "main": "../node/context/index.js",
+  "types": "./index.d.ts"
+}

package/hooks/core/index.d.ts

@@ -0,0 +1 @@
+export type { GridPreProcessingGroupLookup } from './preProcessing';

package/hooks/core/index.js

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

package/hooks/core/preProcessing/gridPreProcessingApi.d.ts

@@ -0,0 +1,71 @@
+/// <reference types="react" />
+import { GridCellIndexCoordinates, GridScrollParams } from '../../../models';
+import { GridInitialStateCommunity } from '../../../models/gridStateCommunity';
+import { GridColDef } from '../../../models/colDef/gridColDef';
+import { GridRestoreStatePreProcessingContext, GridRestoreStatePreProcessingValue } from '../../features/statePersistence/gridStatePersistenceInterface';
+import { GridFilteringMethodCollection } from '../../features/filter/gridFilterState';
+import { GridSortingMethodCollection } from '../../features/sorting/gridSortingState';
+import { GridColumnsRawState } from '../../features/columns/gridColumnsInterfaces';
+import { GridRowEntry } from '../../../models/gridRows';
+export declare type PreProcessorCallback = (value: any, params?: any) => any;
+export declare type GridPreProcessingGroup = keyof GridPreProcessingGroupLookup;
+export interface GridPreProcessingGroupLookup {
+    hydrateColumns: {
+        value: Omit<GridColumnsRawState, 'columnVisibilityModel'>;
+    };
+    scrollToIndexes: {
+        value: Partial<GridScrollParams>;
+        context: Partial<GridCellIndexCoordinates>;
+    };
+    columnMenu: {
+        value: JSX.Element[];
+        context: GridColDef;
+    };
+    filteringMethod: {
+        value: GridFilteringMethodCollection;
+    };
+    sortingMethod: {
+        value: GridSortingMethodCollection;
+    };
+    exportState: {
+        value: GridInitialStateCommunity;
+    };
+    restoreState: {
+        value: GridRestoreStatePreProcessingValue;
+        context: GridRestoreStatePreProcessingContext<GridInitialStateCommunity>;
+    };
+    rowHeight: {
+        value: Record<string, number>;
+        context: GridRowEntry;
+    };
+}
+export declare type GridPreProcessor<P extends GridPreProcessingGroup> = (value: GridPreProcessingGroupLookup[P]['value'], context: GridPreProcessingGroupLookup[P] extends {
+    context: any;
+} ? GridPreProcessingGroupLookup[P]['context'] : undefined) => GridPreProcessingGroupLookup[P]['value'];
+declare type GridPreProcessorsApplierArg<P extends GridPreProcessingGroup, T extends {
+    value: any;
+}> = T extends {
+    context: any;
+} ? [P, T['value'], T['context']] : [P, T['value']];
+declare type GridPreProcessorsApplier = <P extends GridPreProcessingGroup>(...params: GridPreProcessorsApplierArg<P, GridPreProcessingGroupLookup[P]>) => GridPreProcessingGroupLookup[P]['value'];
+export interface GridPreProcessingApi {
+    /**
+     * Register a pre-processor and emit an event to notify the agents to re-apply the pre-processors.
+     * @param {GridPreProcessingGroup} group The name of the group to bind this pre-processor to.
+     * @param {number} id An unique and static identifier of the pre-processor.
+     * @param {PreProcessorCallback} callback The pre-processor to register.
+     * @returns {() => void} A function to unregister the pre-processor.
+     * @ignore - do not document.
+     */
+    unstable_registerPreProcessor: (group: GridPreProcessingGroup, id: string, callback: PreProcessorCallback) => () => void;
+    /**
+     * Apply on the value the pre-processors registered on the given group.
+     * @param {GridPreProcessingGroup} group The name of the processing group.
+     * @param {any} value The value to pass to the first pre-processor.
+     * @param {any} params Additional params to pass to the pre-processors.
+     * @returns {any} The value after passing through all pre-processors.
+     * @ignore - do not document.
+     */
+    unstable_applyPreProcessors: GridPreProcessorsApplier;
+}
+export {};

package/hooks/core/preProcessing/gridPreProcessingApi.js

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

package/hooks/core/preProcessing/index.d.ts

@@ -0,0 +1,3 @@
+export * from './gridPreProcessingApi';
+export * from './useGridPreProcessing';
+export * from './useGridRegisterPreProcessor';

package/hooks/core/preProcessing/index.js

@@ -0,0 +1,3 @@
+export * from './gridPreProcessingApi';
+export * from './useGridPreProcessing';
+export * from './useGridRegisterPreProcessor';

package/hooks/core/preProcessing/useGridPreProcessing.d.ts

@@ -0,0 +1,3 @@
+import * as React from 'react';
+import { GridApiCommunity } from '../../../models/api/gridApiCommunity';
+export declare const useGridPreProcessing: (apiRef: React.MutableRefObject<GridApiCommunity>) => void;

package/hooks/core/preProcessing/useGridPreProcessing.js

@@ -0,0 +1,49 @@
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+import _toPropertyKey from "@babel/runtime/helpers/esm/toPropertyKey";
+import _extends from "@babel/runtime/helpers/esm/extends";
+import * as React from 'react';
+import { useGridApiMethod } from '../../utils/useGridApiMethod';
+import { GridEvents } from '../../../models/events';
+export const useGridPreProcessing = apiRef => {
+  const preProcessorsRef = React.useRef({});
+  const registerPreProcessor = React.useCallback((group, id, callback) => {
+    if (!preProcessorsRef.current[group]) {
+      preProcessorsRef.current[group] = {};
+    }
+
+    const preProcessors = preProcessorsRef.current[group];
+    const oldCallback = preProcessors[id];
+
+    if (!oldCallback || oldCallback !== callback) {
+      preProcessorsRef.current[group] = _extends({}, preProcessors, {
+        [id]: callback
+      });
+      apiRef.current.publishEvent(GridEvents.preProcessorRegister, group);
+    }
+
+    return () => {
+      const _ref = preProcessorsRef.current[group],
+            otherProcessors = _objectWithoutPropertiesLoose(_ref, [id].map(_toPropertyKey));
+
+      preProcessorsRef.current[group] = otherProcessors;
+      apiRef.current.publishEvent(GridEvents.preProcessorUnregister, group);
+    };
+  }, [apiRef]);
+  const applyPreProcessors = React.useCallback((...args) => {
+    const [group, value, params] = args;
+
+    if (!preProcessorsRef.current[group]) {
+      return value;
+    }
+
+    const preProcessors = Object.values(preProcessorsRef.current[group]);
+    return preProcessors.reduce((acc, preProcessor) => {
+      return preProcessor(acc, params);
+    }, value);
+  }, []);
+  const preProcessingApi = {
+    unstable_registerPreProcessor: registerPreProcessor,
+    unstable_applyPreProcessors: applyPreProcessors
+  };
+  useGridApiMethod(apiRef, preProcessingApi, 'GridPreProcessing');
+};

package/hooks/core/preProcessing/useGridRegisterPreProcessor.d.ts

@@ -0,0 +1,4 @@
+import * as React from 'react';
+import { GridApiCommon } from '../../../models/api/gridApiCommon';
+import { GridPreProcessingGroup, PreProcessorCallback } from './gridPreProcessingApi';
+export declare const useGridRegisterPreProcessor: <Api extends GridApiCommon>(apiRef: React.MutableRefObject<Api>, group: GridPreProcessingGroup, callback: PreProcessorCallback) => void;

package/hooks/core/preProcessing/useGridRegisterPreProcessor.js

@@ -0,0 +1,27 @@
+import * as React from 'react';
+import { useFirstRender } from '../../utils/useFirstRender';
+export const useGridRegisterPreProcessor = (apiRef, group, callback) => {
+  const cleanup = React.useRef();
+  const id = React.useRef(`mui-${Math.round(Math.random() * 1e9)}`);
+  const registerPreProcessor = React.useCallback(() => {
+    cleanup.current = apiRef.current.unstable_registerPreProcessor(group, id.current, callback);
+  }, [apiRef, callback, group]);
+  useFirstRender(() => {
+    registerPreProcessor();
+  });
+  const isFirstRender = React.useRef(true);
+  React.useEffect(() => {
+    if (isFirstRender.current) {
+      isFirstRender.current = false;
+    } else {
+      registerPreProcessor();
+    }
+
+    return () => {
+      if (cleanup.current) {
+        cleanup.current();
+        cleanup.current = null;
+      }
+    };
+  }, [registerPreProcessor]);
+};

package/hooks/core/rowGroupsPreProcessing/gridRowGroupsPreProcessingApi.d.ts

@@ -0,0 +1,35 @@
+import { GridRowTreeConfig, GridRowId, GridRowsLookup } from '../../../models/gridRows';
+export interface GridRowGroupParams {
+    ids: GridRowId[];
+    idRowsLookup: GridRowsLookup;
+    previousTree: GridRowTreeConfig | null;
+}
+export interface GridRowGroupingResult {
+    /**
+     * Name of the algorithm used to group the rows
+     * It is useful to decide which filtering / sorting algorithm to apply, to avoid applying tree-data filtering on a grouping-by-column dataset for instance.
+     */
+    groupingName: string;
+    tree: GridRowTreeConfig;
+    treeDepth: number;
+    ids: GridRowId[];
+    idRowsLookup: GridRowsLookup;
+}
+export declare type GridRowGroupingPreProcessing = (params: GridRowGroupParams) => GridRowGroupingResult | null;
+export interface GridRowGroupsPreProcessingApi {
+    /**
+     * Register a column pre-processing and emit an event to re-apply the row grouping pre-processing.
+     * @param {string} processingName Name of the pre-processing. Used to clean the previous version of the pre-processing.
+     * @param {GridRowGroupingPreProcessing} columnsPreProcessing Pre-processing to register.
+     * @ignore - do not document.
+     */
+    unstable_registerRowGroupsBuilder: (processingName: string, groupingFunction: GridRowGroupingPreProcessing | null) => void;
+    /**
+     * Apply the first row grouping pre-processing that does not return null.
+     * @param {GridRowsLookup} rowsLookup. Lookup of the rows to group.
+     * @param {GridRowId[]} List of the rows IDs.
+     * @returns {GridRowGroupingResult} The grouped rows.
+     * @ignore - do not document.
+     */
+    unstable_groupRows: (params: GridRowGroupParams) => GridRowGroupingResult;
+}

package/hooks/core/rowGroupsPreProcessing/gridRowGroupsPreProcessingApi.js

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

package/hooks/core/rowGroupsPreProcessing/index.d.ts

@@ -0,0 +1,2 @@
+export * from './useGridRowGroupsPreProcessing';
+export * from './gridRowGroupsPreProcessingApi';

package/hooks/core/rowGroupsPreProcessing/index.js

@@ -0,0 +1,2 @@
+export * from './useGridRowGroupsPreProcessing';
+export * from './gridRowGroupsPreProcessingApi';

package/hooks/core/rowGroupsPreProcessing/useGridRowGroupsPreProcessing.d.ts

@@ -0,0 +1,3 @@
+import * as React from 'react';
+import { GridApiCommunity } from '../../../models/api/gridApiCommunity';
+export declare const useGridRowGroupsPreProcessing: (apiRef: React.MutableRefObject<GridApiCommunity>) => void;

package/hooks/core/rowGroupsPreProcessing/useGridRowGroupsPreProcessing.js

@@ -0,0 +1,72 @@
+import * as React from 'react';
+import { GridEvents } from '../../../models/events';
+import { useGridApiMethod } from '../../utils/useGridApiMethod';
+
+const getFlatRowTree = ({
+  ids,
+  idRowsLookup,
+  previousTree
+}) => {
+  const tree = {};
+
+  for (let i = 0; i < ids.length; i += 1) {
+    const rowId = ids[i];
+
+    if (previousTree && previousTree[rowId]) {
+      tree[rowId] = previousTree[rowId];
+    } else {
+      tree[rowId] = {
+        id: rowId,
+        depth: 0,
+        parent: null,
+        groupingKey: '',
+        groupingField: null
+      };
+    }
+  }
+
+  return {
+    groupingName: 'none',
+    tree,
+    treeDepth: 1,
+    idRowsLookup,
+    ids
+  };
+};
+
+export const useGridRowGroupsPreProcessing = apiRef => {
+  const rowGroupsPreProcessingRef = React.useRef(new Map());
+  const registerRowGroupsBuilder = React.useCallback((processingName, rowGroupingPreProcessing) => {
+    var _rowGroupsPreProcessi;
+
+    const rowGroupingPreProcessingBefore = (_rowGroupsPreProcessi = rowGroupsPreProcessingRef.current.get(processingName)) != null ? _rowGroupsPreProcessi : null;
+
+    if (rowGroupingPreProcessingBefore !== rowGroupingPreProcessing) {
+      rowGroupsPreProcessingRef.current.set(processingName, rowGroupingPreProcessing);
+      apiRef.current.publishEvent(GridEvents.rowGroupsPreProcessingChange);
+    }
+  }, [apiRef]);
+  const groupRows = React.useCallback((...params) => {
+    let response = null;
+    const preProcessingList = Array.from(rowGroupsPreProcessingRef.current.values());
+
+    while (!response && preProcessingList.length) {
+      const preProcessing = preProcessingList.shift();
+
+      if (preProcessing) {
+        response = preProcessing(...params);
+      }
+    }
+
+    if (!response) {
+      return getFlatRowTree(...params);
+    }
+
+    return response;
+  }, []);
+  const rowGroupsPreProcessingApi = {
+    unstable_registerRowGroupsBuilder: registerRowGroupsBuilder,
+    unstable_groupRows: groupRows
+  };
+  useGridApiMethod(apiRef, rowGroupsPreProcessingApi, 'GridRowGroupsPreProcessing');
+};

package/hooks/core/useGridApiInitialization.d.ts

@@ -0,0 +1,4 @@
+import * as React from 'react';
+import { DataGridProcessedProps } from '../../models/props/DataGridProps';
+import { GridApiCommon } from '../../models';
+export declare function useGridApiInitialization<Api extends GridApiCommon>(inputApiRef: React.MutableRefObject<Api> | undefined, props: Pick<DataGridProcessedProps, 'signature'>): React.MutableRefObject<Api>;

package/hooks/core/useGridApiInitialization.js

@@ -0,0 +1,60 @@
+import * as React from 'react';
+import { GridEvents } from '../../models/events';
+import { useGridApiMethod } from '../utils/useGridApiMethod';
+import { GridSignature } from '../utils/useGridApiEventHandler';
+import { EventManager } from '../../utils/EventManager';
+
+const isSyntheticEvent = event => {
+  return event.isPropagationStopped !== undefined;
+};
+
+let globalId = 0;
+export function useGridApiInitialization(inputApiRef, props) {
+  const apiRef = React.useRef();
+
+  if (!apiRef.current) {
+    apiRef.current = {
+      unstable_eventManager: new EventManager(),
+      state: {},
+      instanceId: globalId
+    };
+    globalId += 1;
+  }
+
+  React.useImperativeHandle(inputApiRef, () => apiRef.current, [apiRef]);
+  const publishEvent = React.useCallback((...args) => {
+    const [name, params, event = {}] = args;
+    event.defaultMuiPrevented = false;
+
+    if (isSyntheticEvent(event) && event.isPropagationStopped()) {
+      return;
+    }
+
+    const details = props.signature === GridSignature.DataGridPro ? {
+      api: apiRef.current
+    } : {};
+    apiRef.current.unstable_eventManager.emit(name, params, event, details);
+  }, [apiRef, props.signature]);
+  const subscribeEvent = React.useCallback((event, handler, options) => {
+    apiRef.current.unstable_eventManager.on(event, handler, options);
+    const api = apiRef.current;
+    return () => {
+      api.unstable_eventManager.removeListener(event, handler);
+    };
+  }, [apiRef]);
+  const showError = React.useCallback(args => {
+    apiRef.current.publishEvent(GridEvents.componentError, args);
+  }, [apiRef]);
+  useGridApiMethod(apiRef, {
+    subscribeEvent,
+    publishEvent,
+    showError
+  }, 'GridCoreApi');
+  React.useEffect(() => {
+    const api = apiRef.current;
+    return () => {
+      api.publishEvent(GridEvents.unmount);
+    };
+  }, [apiRef]);
+  return apiRef;
+}

package/hooks/core/useGridErrorHandler.d.ts

@@ -0,0 +1,4 @@
+import * as React from 'react';
+import { GridApiCommunity } from '../../models/api/gridApiCommunity';
+import { DataGridProcessedProps } from '../../models/props/DataGridProps';
+export declare function useGridErrorHandler(apiRef: React.MutableRefObject<GridApiCommunity>, props: Pick<DataGridProcessedProps, 'error'>): void;

package/hooks/core/useGridErrorHandler.js

@@ -0,0 +1,16 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import * as React from 'react';
+import { GridEvents } from '../../models/events';
+import { useGridApiEventHandler } from '../utils/useGridApiEventHandler';
+export function useGridErrorHandler(apiRef, props) {
+  const handleError = React.useCallback(args => {
+    // We are handling error here, to set up the handler as early as possible and be able to catch error thrown at init time.
+    apiRef.current.setState(state => _extends({}, state, {
+      error: args
+    }));
+  }, [apiRef]);
+  React.useEffect(() => {
+    handleError(props.error);
+  }, [handleError, props.error]);
+  useGridApiEventHandler(apiRef, GridEvents.componentError, handleError);
+}

package/hooks/core/useGridInitialization.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+import type { GridApiCommon } from '../../models/api/gridApiCommon';
+import { DataGridProcessedProps } from '../../models/props/DataGridProps';
+/**
+ * Initialize the technical pieces of the DataGrid (logger, state, ...) that any DataGrid implementation needs
+ */
+export declare const useGridInitialization: <Api extends GridApiCommon>(inputApiRef: React.MutableRefObject<Api> | undefined, props: Pick<DataGridProcessedProps, 'signature' | 'logger' | 'logLevel' | 'error' | 'localeText'>) => React.MutableRefObject<Api>;

package/hooks/core/useGridInitialization.js

@@ -0,0 +1,21 @@
+import { useGridLoggerFactory } from './useGridLoggerFactory';
+import { useGridApiInitialization } from './useGridApiInitialization';
+import { useGridErrorHandler } from './useGridErrorHandler';
+import { useGridLocaleText } from './useGridLocaleText';
+import { useGridPreProcessing } from './preProcessing';
+import { useGridRowGroupsPreProcessing } from './rowGroupsPreProcessing';
+import { useGridStateInitialization } from './useGridStateInitialization';
+/**
+ * Initialize the technical pieces of the DataGrid (logger, state, ...) that any DataGrid implementation needs
+ */
+
+export const useGridInitialization = (inputApiRef, props) => {
+  const apiRef = useGridApiInitialization(inputApiRef, props);
+  useGridLoggerFactory(apiRef, props);
+  useGridErrorHandler(apiRef, props);
+  useGridStateInitialization(apiRef, props);
+  useGridPreProcessing(apiRef);
+  useGridRowGroupsPreProcessing(apiRef);
+  useGridLocaleText(apiRef, props);
+  return apiRef;
+};

package/hooks/core/useGridLocaleText.d.ts

@@ -0,0 +1,4 @@
+import * as React from 'react';
+import { GridApiCommunity } from '../../models/api/gridApiCommunity';
+import { DataGridProcessedProps } from '../../models/props/DataGridProps';
+export declare const useGridLocaleText: (apiRef: React.MutableRefObject<GridApiCommunity>, props: Pick<DataGridProcessedProps, 'localeText'>) => void;

package/hooks/core/useGridLocaleText.js

@@ -0,0 +1,15 @@
+import * as React from 'react';
+import { useGridApiMethod } from '../utils/useGridApiMethod';
+export const useGridLocaleText = (apiRef, props) => {
+  const getLocaleText = React.useCallback(key => {
+    if (props.localeText[key] == null) {
+      throw new Error(`Missing translation for key ${key}.`);
+    }
+
+    return props.localeText[key];
+  }, [props.localeText]);
+  const localeTextApi = {
+    getLocaleText
+  };
+  useGridApiMethod(apiRef, localeTextApi, 'LocaleTextApi');
+};

package/hooks/core/useGridLoggerFactory.d.ts

@@ -0,0 +1,4 @@
+import * as React from 'react';
+import { GridApiCommunity } from '../../models/api/gridApiCommunity';
+import { DataGridProcessedProps } from '../../models/props/DataGridProps';
+export declare const useGridLoggerFactory: (apiRef: React.MutableRefObject<GridApiCommunity>, props: Pick<DataGridProcessedProps, 'logger' | 'logLevel'>) => void;