@mui/x-data-grid 8.28.6 → 8.29.0

package/hooks/core/pipeProcessing/useGridPipeProcessing.mjs

@@ -0,0 +1,124 @@
+'use client';
+
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+import _toPropertyKey from "@babel/runtime/helpers/esm/toPropertyKey";
+import * as React from 'react';
+import { useGridApiMethod } from "../../utils/useGridApiMethod.mjs";
+/**
+ * Implement the Pipeline Pattern
+ *
+ * More information and detailed example in (TODO add link to technical doc when ready)
+ *
+ * Some plugins contains custom logic to enrich data provided by other plugins or components.
+ * For instance, the row grouping plugin needs to add / remove the grouping columns when the grid columns are updated.
+ *
+ * =====================================================================================================================
+ *
+ * The plugin containing the custom logic must use:
+ *
+ * - `useGridRegisterPipeProcessor` to register their processor.
+ *
+ * - `apiRef.current.requestPipeProcessorsApplication` to imperatively re-apply a group.
+ *   This method should be used in last resort.
+ *   Most of the time, the application should be triggered by an update on the deps of the processor.
+ *
+ * =====================================================================================================================
+ *
+ * The plugin or component that needs to enrich its data must use:
+ *
+ * - `apiRef.current.unstable_applyPipeProcessors` to run in chain all the processors of a given group.
+ *
+ * - `useGridRegisterPipeApplier` to re-apply the whole pipe when requested.
+ *   The applier will be called when:
+ *   * a processor is registered.
+ *   * `apiRef.current.requestPipeProcessorsApplication` is called for the given group.
+ */
+export const useGridPipeProcessing = apiRef => {
+  const cache = React.useRef({});
+  const isRunning = React.useRef(false);
+  const runAppliers = React.useCallback(groupCache => {
+    if (isRunning.current || !groupCache) {
+      return;
+    }
+    isRunning.current = true;
+    Object.values(groupCache.appliers).forEach(callback => {
+      callback();
+    });
+    isRunning.current = false;
+  }, []);
+  const registerPipeProcessor = React.useCallback((group, id, processor) => {
+    if (!cache.current[group]) {
+      cache.current[group] = {
+        processors: new Map(),
+        processorsAsArray: [],
+        appliers: {},
+        processorsUpdated: false
+      };
+    }
+    const groupCache = cache.current[group];
+    const oldProcessor = groupCache.processors.get(id);
+    if (oldProcessor !== processor) {
+      groupCache.processors.set(id, processor);
+      groupCache.processorsAsArray = Array.from(cache.current[group].processors.values()).filter(processorValue => processorValue !== null);
+      groupCache.processorsUpdated = true;
+    }
+    return () => {
+      cache.current[group].processors.set(id, null);
+      cache.current[group].processorsAsArray = Array.from(cache.current[group].processors.values()).filter(processorValue => processorValue !== null);
+    };
+  }, []);
+  const registerPipeApplier = React.useCallback((group, id, applier) => {
+    if (!cache.current[group]) {
+      cache.current[group] = {
+        processors: new Map(),
+        processorsAsArray: [],
+        appliers: {},
+        processorsUpdated: false
+      };
+    }
+    cache.current[group].appliers[id] = applier;
+    return () => {
+      const _appliers = cache.current[group].appliers,
+        otherAppliers = _objectWithoutPropertiesLoose(_appliers, [id].map(_toPropertyKey));
+      cache.current[group].appliers = otherAppliers;
+    };
+  }, []);
+  const requestPipeProcessorsApplication = React.useCallback(group => {
+    runAppliers(cache.current[group]);
+  }, [runAppliers]);
+  const runAppliersForPendingProcessors = React.useCallback(() => {
+    for (const group in cache.current) {
+      if (!Object.prototype.hasOwnProperty.call(cache.current, group)) {
+        continue;
+      }
+      const groupCache = cache.current[group];
+      if (groupCache.processorsUpdated) {
+        groupCache.processorsUpdated = false;
+        runAppliers(groupCache);
+      }
+    }
+  }, [runAppliers]);
+  const applyPipeProcessors = React.useCallback((...args) => {
+    const [group, value, context] = args;
+    if (!cache.current[group]) {
+      return value;
+    }
+    const processors = cache.current[group].processorsAsArray;
+    let result = value;
+    for (let i = 0; i < processors.length; i += 1) {
+      result = processors[i](result, context);
+    }
+    return result;
+  }, []);
+  const preProcessingPrivateApi = {
+    registerPipeProcessor,
+    registerPipeApplier,
+    requestPipeProcessorsApplication,
+    runAppliersForPendingProcessors
+  };
+  const preProcessingPublicApi = {
+    unstable_applyPipeProcessors: applyPipeProcessors
+  };
+  useGridApiMethod(apiRef, preProcessingPrivateApi, 'private');
+  useGridApiMethod(apiRef, preProcessingPublicApi, 'public');
+};

package/hooks/core/pipeProcessing/useGridRegisterPipeApplier.d.mts

@@ -0,0 +1,4 @@
+import type { RefObject } from '@mui/x-internals/types';
+import type { GridPrivateApiCommon } from "../../../models/api/gridApiCommon.mjs";
+import type { GridPipeProcessorGroup } from "./gridPipeProcessingApi.mjs";
+export declare const useGridRegisterPipeApplier: <PrivateApi extends GridPrivateApiCommon, G extends GridPipeProcessorGroup>(apiRef: RefObject<PrivateApi>, group: G, callback: () => void) => void;

package/hooks/core/pipeProcessing/useGridRegisterPipeApplier.mjs

@@ -0,0 +1,28 @@
+'use client';
+
+import * as React from 'react';
+import { useFirstRender } from "../../utils/useFirstRender.mjs";
+export const useGridRegisterPipeApplier = (apiRef, group, callback) => {
+  const cleanup = React.useRef(null);
+  const id = React.useRef(`mui-${Math.round(Math.random() * 1e9)}`);
+  const registerPreProcessor = React.useCallback(() => {
+    cleanup.current = apiRef.current.registerPipeApplier(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/pipeProcessing/useGridRegisterPipeProcessor.d.mts

@@ -0,0 +1,4 @@
+import type { RefObject } from '@mui/x-internals/types';
+import type { GridPrivateApiCommon } from "../../../models/api/gridApiCommon.mjs";
+import type { GridPipeProcessorGroup, GridPipeProcessor } from "./gridPipeProcessingApi.mjs";
+export declare const useGridRegisterPipeProcessor: <PrivateApi extends GridPrivateApiCommon, G extends GridPipeProcessorGroup>(apiRef: RefObject<PrivateApi>, group: G, callback: GridPipeProcessor<G>, enabled?: boolean) => void;

package/hooks/core/pipeProcessing/useGridRegisterPipeProcessor.mjs

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

package/hooks/core/strategyProcessing/gridStrategyProcessingApi.d.mts

@@ -0,0 +1,81 @@
+import type { GridRowTreeCreationParams, GridRowTreeCreationValue, GridRowsState } from "../../features/rows/gridRowsInterfaces.mjs";
+import type { GridFilteringMethodParams, GridFilteringMethodValue, GridFilterState, GridVisibleRowsLookupState } from "../../features/filter/gridFilterState.mjs";
+import type { GridSortingMethodParams, GridSortingMethodValue } from "../../features/sorting/gridSortingState.mjs";
+import type { GridGetRowsParams, GridGetRowsResponse, GridGetRowsOptions } from "../../../models/gridDataSource.mjs";
+export type GridStrategyProcessorName = keyof GridStrategyProcessingLookup;
+export declare enum GridStrategyGroup {
+  DataSource = "dataSource",
+  RowTree = "rowTree",
+}
+export type GridStrategyGroupValue = `${GridStrategyGroup}`;
+export interface GridStrategyProcessingLookup {
+  dataSourceRowsUpdate: {
+    group: GridStrategyGroup.DataSource;
+    params: {
+      response: GridGetRowsResponse;
+      fetchParams: GridGetRowsParams;
+      options: GridGetRowsOptions;
+    } | {
+      error: Error;
+      fetchParams: GridGetRowsParams;
+      options: GridGetRowsOptions;
+    };
+    value: void;
+  };
+  rowTreeCreation: {
+    group: GridStrategyGroup.RowTree;
+    params: GridRowTreeCreationParams;
+    value: GridRowTreeCreationValue;
+  };
+  filtering: {
+    group: GridStrategyGroup.RowTree;
+    params: GridFilteringMethodParams;
+    value: GridFilteringMethodValue;
+  };
+  sorting: {
+    group: GridStrategyGroup.RowTree;
+    params: GridSortingMethodParams;
+    value: GridSortingMethodValue;
+  };
+  visibleRowsLookupCreation: {
+    group: GridStrategyGroup.RowTree;
+    params: {
+      tree: GridRowsState['tree'];
+      filteredRowsLookup: GridFilterState['filteredRowsLookup'];
+    };
+    value: GridVisibleRowsLookupState;
+  };
+}
+export type GridStrategyProcessor<P extends GridStrategyProcessorName> = (params: GridStrategyProcessingLookup[P]['params']) => GridStrategyProcessingLookup[P]['value'];
+export interface GridStrategyProcessingApi {
+  /**
+   * Registers a strategy processor.
+   * If the strategy is active, it emits an event to notify the agents to re-apply the processor.
+   * @template P
+   * @param {string} strategyName The name of the strategy on which this processor should be applied.
+   * @param {GridStrategyProcessorName} processorName The name of the processor.
+   * @param {GridStrategyProcessor<P>} processor The processor to register.
+   * @returns {() => void} A function to unregister the processor.
+   */
+  registerStrategyProcessor: <P extends GridStrategyProcessorName>(strategyName: string, processorName: P, processor: GridStrategyProcessor<P>) => () => void;
+  /**
+   * Set a callback to know if a strategy is available.
+   * @param {GridStrategyGroupValue} strategyGroup The group for which we set strategy availability.
+   * @param {string} strategyName The name of the strategy.
+   * @param {boolean} callback A callback to know if this strategy is available.
+   */
+  setStrategyAvailability: (strategyGroup: GridStrategyGroupValue, strategyName: string, callback: () => boolean) => void;
+  /**
+   * Returns the name of the active strategy of a given strategy group
+   * @param {GridStrategyGroupValue} strategyGroup The group from which we want the active strategy.
+   * @returns {string} The name of the active strategy.
+   */
+  getActiveStrategy: (strategyGroup: GridStrategyGroupValue) => string;
+  /**
+   * Run the processor registered for the active strategy.
+   * @param {GridStrategyProcessorName} processorName The name of the processor to run.
+   * @param {GridStrategyProcessingLookup[P]['params']} params Additional params to pass to the processor.
+   * @returns {GridStrategyProcessingLookup[P]['value']} The value returned by the processor.
+   */
+  applyStrategyProcessor: <P extends GridStrategyProcessorName>(processorName: P, params: GridStrategyProcessingLookup[P]['params']) => GridStrategyProcessingLookup[P]['value'];
+}

package/hooks/core/strategyProcessing/index.d.mts

@@ -0,0 +1,3 @@
+export * from "./gridStrategyProcessingApi.mjs";
+export * from "./useGridRegisterStrategyProcessor.mjs";
+export * from "./useGridStrategyProcessing.mjs";

package/hooks/core/strategyProcessing/index.mjs

@@ -0,0 +1,3 @@
+export * from "./gridStrategyProcessingApi.mjs";
+export * from "./useGridRegisterStrategyProcessor.mjs";
+export * from "./useGridStrategyProcessing.mjs";

package/hooks/core/strategyProcessing/useGridRegisterStrategyProcessor.d.mts

@@ -0,0 +1,4 @@
+import type { RefObject } from '@mui/x-internals/types';
+import type { GridPrivateApiCommon } from "../../../models/api/gridApiCommon.mjs";
+import type { GridStrategyProcessorName, GridStrategyProcessor } from "./gridStrategyProcessingApi.mjs";
+export declare const useGridRegisterStrategyProcessor: <Api extends GridPrivateApiCommon, G extends GridStrategyProcessorName>(apiRef: RefObject<Api>, strategyName: string, group: G, processor: GridStrategyProcessor<G>) => void;

package/hooks/core/strategyProcessing/useGridRegisterStrategyProcessor.mjs

@@ -0,0 +1,20 @@
+'use client';
+
+import * as React from 'react';
+import { useFirstRender } from "../../utils/useFirstRender.mjs";
+export const useGridRegisterStrategyProcessor = (apiRef, strategyName, group, processor) => {
+  const registerPreProcessor = React.useCallback(() => {
+    apiRef.current.registerStrategyProcessor(strategyName, group, processor);
+  }, [apiRef, processor, group, strategyName]);
+  useFirstRender(() => {
+    registerPreProcessor();
+  });
+  const isFirstRender = React.useRef(true);
+  React.useEffect(() => {
+    if (isFirstRender.current) {
+      isFirstRender.current = false;
+    } else {
+      registerPreProcessor();
+    }
+  }, [registerPreProcessor]);
+};

package/hooks/core/strategyProcessing/useGridStrategyProcessing.d.mts

@@ -0,0 +1,43 @@
+import type { RefObject } from '@mui/x-internals/types';
+import type { GridPrivateApiCommon } from "../../../models/api/gridApiCommon.mjs";
+import { type GridStrategyProcessorName, type GridStrategyGroupValue } from "./gridStrategyProcessingApi.mjs";
+export declare const GRID_DEFAULT_STRATEGY = "none";
+export declare const GRID_STRATEGIES_PROCESSORS: { [P in GridStrategyProcessorName]: GridStrategyGroupValue };
+/**
+ * Implements a variant of the Strategy Pattern (see https://en.wikipedia.org/wiki/Strategy_pattern)
+ *
+ * More information and detailed example in (TODO add link to technical doc when ready)
+ *
+ * Some plugins contains custom logic that must only be applied if the right strategy is active.
+ * For instance, the row grouping plugin has a custom filtering algorithm.
+ * This algorithm must be applied by the filtering plugin if the row grouping is the current way of grouping rows,
+ * but not if the tree data is the current way of grouping rows.
+ *
+ * =====================================================================================================================
+ *
+ * The plugin containing the custom logic must use:
+ *
+ * - `useGridRegisterStrategyProcessor` to register their processor.
+ *   When the processor of the active strategy changes, it will fire `"activeStrategyProcessorChange"` to re-apply the processor.
+ *
+ * - `apiRef.current.setStrategyAvailability` to tell if their strategy can be used.
+ *
+ * =====================================================================================================================
+ *
+ * The plugin or component that needs to apply the custom logic of the current strategy must use:
+ *
+ * - `apiRef.current.applyStrategyProcessor` to run the processor of the active strategy for a given processor name.
+ *
+ * - the "strategyAvailabilityChange" event to update something when the active strategy changes.
+ *    Warning: Be careful not to apply the processor several times.
+ *    For instance "rowsSet" is fired by `useGridRows` whenever the active strategy changes.
+ *    So listening to both would most likely run your logic twice.
+ *
+ * - The "activeStrategyProcessorChange" event to update something when the processor of the active strategy changes.
+ *
+ * =====================================================================================================================
+ *
+ * Each processor name is part of a strategy group which can only have one active strategy at the time.
+ * There are two active groups named `rowTree` and `dataSource`.
+ */
+export declare const useGridStrategyProcessing: (apiRef: RefObject<GridPrivateApiCommon>) => void;

package/hooks/core/strategyProcessing/useGridStrategyProcessing.mjs

@@ -0,0 +1,112 @@
+'use client';
+
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+import _toPropertyKey from "@babel/runtime/helpers/esm/toPropertyKey";
+import * as React from 'react';
+import { GridStrategyGroup } from "./gridStrategyProcessingApi.mjs";
+import { useGridApiMethod } from "../../utils/useGridApiMethod.mjs";
+export const GRID_DEFAULT_STRATEGY = 'none';
+export const GRID_STRATEGIES_PROCESSORS = {
+  dataSourceRowsUpdate: GridStrategyGroup.DataSource,
+  rowTreeCreation: GridStrategyGroup.RowTree,
+  filtering: GridStrategyGroup.RowTree,
+  sorting: GridStrategyGroup.RowTree,
+  visibleRowsLookupCreation: GridStrategyGroup.RowTree
+};
+/**
+ * Implements a variant of the Strategy Pattern (see https://en.wikipedia.org/wiki/Strategy_pattern)
+ *
+ * More information and detailed example in (TODO add link to technical doc when ready)
+ *
+ * Some plugins contains custom logic that must only be applied if the right strategy is active.
+ * For instance, the row grouping plugin has a custom filtering algorithm.
+ * This algorithm must be applied by the filtering plugin if the row grouping is the current way of grouping rows,
+ * but not if the tree data is the current way of grouping rows.
+ *
+ * =====================================================================================================================
+ *
+ * The plugin containing the custom logic must use:
+ *
+ * - `useGridRegisterStrategyProcessor` to register their processor.
+ *   When the processor of the active strategy changes, it will fire `"activeStrategyProcessorChange"` to re-apply the processor.
+ *
+ * - `apiRef.current.setStrategyAvailability` to tell if their strategy can be used.
+ *
+ * =====================================================================================================================
+ *
+ * The plugin or component that needs to apply the custom logic of the current strategy must use:
+ *
+ * - `apiRef.current.applyStrategyProcessor` to run the processor of the active strategy for a given processor name.
+ *
+ * - the "strategyAvailabilityChange" event to update something when the active strategy changes.
+ *    Warning: Be careful not to apply the processor several times.
+ *    For instance "rowsSet" is fired by `useGridRows` whenever the active strategy changes.
+ *    So listening to both would most likely run your logic twice.
+ *
+ * - The "activeStrategyProcessorChange" event to update something when the processor of the active strategy changes.
+ *
+ * =====================================================================================================================
+ *
+ * Each processor name is part of a strategy group which can only have one active strategy at the time.
+ * There are two active groups named `rowTree` and `dataSource`.
+ */
+export const useGridStrategyProcessing = apiRef => {
+  const availableStrategies = React.useRef(new Map());
+  const strategiesCache = React.useRef({});
+  const registerStrategyProcessor = React.useCallback((strategyName, processorName, processor) => {
+    const cleanup = () => {
+      const _ref = strategiesCache.current[processorName],
+        otherProcessors = _objectWithoutPropertiesLoose(_ref, [strategyName].map(_toPropertyKey));
+      strategiesCache.current[processorName] = otherProcessors;
+    };
+    if (!strategiesCache.current[processorName]) {
+      strategiesCache.current[processorName] = {};
+    }
+    const groupPreProcessors = strategiesCache.current[processorName];
+    const previousProcessor = groupPreProcessors[strategyName];
+    groupPreProcessors[strategyName] = processor;
+    if (!previousProcessor || previousProcessor === processor) {
+      return cleanup;
+    }
+    if (strategyName === apiRef.current.getActiveStrategy(GRID_STRATEGIES_PROCESSORS[processorName])) {
+      apiRef.current.publishEvent('activeStrategyProcessorChange', processorName);
+    }
+    return cleanup;
+  }, [apiRef]);
+  const applyStrategyProcessor = React.useCallback((processorName, params) => {
+    const activeStrategy = apiRef.current.getActiveStrategy(GRID_STRATEGIES_PROCESSORS[processorName]);
+    if (activeStrategy == null) {
+      throw new Error("Can't apply a strategy processor before defining an active strategy");
+    }
+    const groupCache = strategiesCache.current[processorName];
+    if (!groupCache || !groupCache[activeStrategy]) {
+      throw new Error(`No processor found for processor "${processorName}" on strategy "${activeStrategy}"`);
+    }
+    const processor = groupCache[activeStrategy];
+    return processor(params);
+  }, [apiRef]);
+  const getActiveStrategy = React.useCallback(strategyGroup => {
+    const strategyEntries = Array.from(availableStrategies.current.entries());
+    const availableStrategyEntry = strategyEntries.find(([, strategy]) => {
+      if (strategy.group !== strategyGroup) {
+        return false;
+      }
+      return strategy.isAvailable();
+    });
+    return availableStrategyEntry?.[0] ?? GRID_DEFAULT_STRATEGY;
+  }, []);
+  const setStrategyAvailability = React.useCallback((strategyGroup, strategyName, isAvailable) => {
+    availableStrategies.current.set(strategyName, {
+      group: strategyGroup,
+      isAvailable
+    });
+    apiRef.current.publishEvent('strategyAvailabilityChange');
+  }, [apiRef]);
+  const strategyProcessingApi = {
+    registerStrategyProcessor,
+    applyStrategyProcessor,
+    getActiveStrategy,
+    setStrategyAvailability
+  };
+  useGridApiMethod(apiRef, strategyProcessingApi, 'private');
+};

package/hooks/core/useGridApiInitialization.d.mts

@@ -0,0 +1,5 @@
+import type { RefObject } from '@mui/x-internals/types';
+import type { DataGridProcessedProps } from "../../models/props/DataGridProps.mjs";
+import type { GridApiCommon, GridPrivateApiCommon } from "../../models/api/gridApiCommon.mjs";
+export declare function unwrapPrivateAPI<PrivateApi extends GridPrivateApiCommon, Api extends GridApiCommon>(publicApi: Api): PrivateApi;
+export declare function useGridApiInitialization<PrivateApi extends GridPrivateApiCommon, Api extends GridApiCommon>(inputApiRef: RefObject<Api | null> | undefined, props: Pick<DataGridProcessedProps, 'signature'>): RefObject<PrivateApi>;

package/hooks/core/useGridApiInitialization.mjs

@@ -0,0 +1,114 @@
+'use client';
+
+import * as React from 'react';
+import { EventManager } from '@mui/x-internals/EventManager';
+import { Store } from '@mui/x-internals/store';
+import { useGridApiMethod } from "../utils/useGridApiMethod.mjs";
+import { GridSignature } from "../../constants/signature.mjs";
+const SYMBOL_API_PRIVATE = Symbol('mui.api_private');
+const isSyntheticEvent = event => {
+  return event.isPropagationStopped !== undefined;
+};
+export function unwrapPrivateAPI(publicApi) {
+  return publicApi[SYMBOL_API_PRIVATE];
+}
+let globalId = 0;
+function createPrivateAPI(publicApiRef) {
+  const existingPrivateApi = publicApiRef.current?.[SYMBOL_API_PRIVATE];
+  if (existingPrivateApi) {
+    return existingPrivateApi;
+  }
+  const state = {};
+  const privateApi = {
+    state,
+    store: Store.create(state),
+    instanceId: {
+      id: globalId
+    }
+  };
+  globalId += 1;
+  privateApi.getPublicApi = () => publicApiRef.current;
+  privateApi.register = (visibility, methods) => {
+    Object.keys(methods).forEach(methodName => {
+      const method = methods[methodName];
+      const currentPrivateMethod = privateApi[methodName];
+      if (currentPrivateMethod?.spying === true) {
+        currentPrivateMethod.target = method;
+      } else {
+        privateApi[methodName] = method;
+      }
+      if (visibility === 'public') {
+        const publicApi = publicApiRef.current;
+        const currentPublicMethod = publicApi[methodName];
+        if (currentPublicMethod?.spying === true) {
+          currentPublicMethod.target = method;
+        } else {
+          publicApi[methodName] = method;
+        }
+      }
+    });
+  };
+  privateApi.register('private', {
+    caches: {},
+    eventManager: new EventManager()
+  });
+  return privateApi;
+}
+function createPublicAPI(privateApiRef) {
+  const publicApi = {
+    get state() {
+      return privateApiRef.current.state;
+    },
+    get store() {
+      return privateApiRef.current.store;
+    },
+    get instanceId() {
+      return privateApiRef.current.instanceId;
+    },
+    [SYMBOL_API_PRIVATE]: privateApiRef.current
+  };
+  return publicApi;
+}
+export function useGridApiInitialization(inputApiRef, props) {
+  const publicApiRef = React.useRef(null);
+  const privateApiRef = React.useRef(null);
+  if (!privateApiRef.current) {
+    privateApiRef.current = createPrivateAPI(publicApiRef);
+  }
+  if (!publicApiRef.current) {
+    publicApiRef.current = createPublicAPI(privateApiRef);
+  }
+  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 || props.signature === GridSignature.DataGridPremium ? {
+      api: privateApiRef.current.getPublicApi()
+    } : {};
+    privateApiRef.current.eventManager.emit(name, params, event, details);
+  }, [privateApiRef, props.signature]);
+  const subscribeEvent = React.useCallback((event, handler, options) => {
+    privateApiRef.current.eventManager.on(event, handler, options);
+    const api = privateApiRef.current;
+    return () => {
+      api.eventManager.removeListener(event, handler);
+    };
+  }, [privateApiRef]);
+  useGridApiMethod(privateApiRef, {
+    subscribeEvent,
+    publishEvent
+  }, 'public');
+  if (inputApiRef && !inputApiRef.current?.state) {
+    inputApiRef.current = publicApiRef.current;
+  }
+  React.useImperativeHandle(inputApiRef, () => publicApiRef.current, [publicApiRef]);
+  React.useEffect(() => {
+    const api = privateApiRef.current;
+    return () => {
+      api.publishEvent('unmount');
+    };
+  }, [privateApiRef]);
+  return privateApiRef;
+}

package/hooks/core/useGridInitialization.d.mts

@@ -0,0 +1,7 @@
+import type { RefObject } from '@mui/x-internals/types';
+import type { GridPrivateApiCommon } from "../../models/api/gridApiCommon.mjs";
+import type { DataGridProcessedProps } from "../../models/props/DataGridProps.mjs";
+/**
+ * Initialize the technical pieces of the DataGrid (logger, state, ...) that any DataGrid implementation needs
+ */
+export declare const useGridInitialization: <PrivateApi extends GridPrivateApiCommon>(privateApiRef: RefObject<PrivateApi>, props: DataGridProcessedProps) => void;

package/hooks/core/useGridInitialization.mjs

@@ -0,0 +1,25 @@
+import { useGridRefs } from "./useGridRefs.mjs";
+import { useGridIsRtl } from "./useGridIsRtl.mjs";
+import { useGridLoggerFactory } from "./useGridLoggerFactory.mjs";
+import { useGridLocaleText } from "./useGridLocaleText.mjs";
+import { useGridPipeProcessing } from "./pipeProcessing/index.mjs";
+import { useGridStrategyProcessing } from "./strategyProcessing/index.mjs";
+import { useGridStateInitialization } from "./useGridStateInitialization.mjs";
+import { useGridProps } from "./useGridProps.mjs";
+
+/**
+ * Initialize the technical pieces of the DataGrid (logger, state, ...) that any DataGrid implementation needs
+ */
+export const useGridInitialization = (privateApiRef, props) => {
+  useGridRefs(privateApiRef);
+  useGridProps(privateApiRef, props);
+  useGridIsRtl(privateApiRef);
+  useGridLoggerFactory(privateApiRef, props);
+  useGridStateInitialization(privateApiRef);
+  useGridPipeProcessing(privateApiRef);
+  useGridStrategyProcessing(privateApiRef);
+  useGridLocaleText(privateApiRef, props);
+  privateApiRef.current.register('private', {
+    rootProps: props
+  });
+};

package/hooks/core/useGridIsRtl.d.mts

@@ -0,0 +1,3 @@
+import type { RefObject } from '@mui/x-internals/types';
+import type { GridPrivateApiCommon } from "../../models/api/gridApiCommon.mjs";
+export declare const useGridIsRtl: (apiRef: RefObject<GridPrivateApiCommon>) => void;

package/hooks/core/useGridLocaleText.d.mts

@@ -0,0 +1,4 @@
+import type { RefObject } from '@mui/x-internals/types';
+import type { GridPrivateApiCommon } from "../../models/api/gridApiCommon.mjs";
+import type { DataGridProcessedProps } from "../../models/props/DataGridProps.mjs";
+export declare const useGridLocaleText: (apiRef: RefObject<GridPrivateApiCommon>, props: Pick<DataGridProcessedProps, "localeText">) => void;

package/hooks/core/useGridLoggerFactory.d.mts

@@ -0,0 +1,4 @@
+import type { RefObject } from '@mui/x-internals/types';
+import type { GridPrivateApiCommon } from "../../models/api/gridApiCommon.mjs";
+import type { DataGridProcessedProps } from "../../models/props/DataGridProps.mjs";
+export declare const useGridLoggerFactory: (apiRef: RefObject<GridPrivateApiCommon>, props: Pick<DataGridProcessedProps, "logger" | "logLevel">) => void;