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

package/modern/hooks/core/pipeProcessing/useGridPipeProcessing.js

@@ -1,107 +0,0 @@
-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.js";
-/**
- * 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: {}
-      };
-    }
-    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());
-      runAppliers(groupCache);
-    }
-    return () => {
-      cache.current[group].processors.delete(id);
-      cache.current[group].processorsAsArray = Array.from(cache.current[group].processors.values());
-    };
-  }, [runAppliers]);
-  const registerPipeApplier = React.useCallback((group, id, applier) => {
-    if (!cache.current[group]) {
-      cache.current[group] = {
-        processors: new Map(),
-        processorsAsArray: [],
-        appliers: {}
-      };
-    }
-    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 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
-  };
-  const preProcessingPublicApi = {
-    unstable_applyPipeProcessors: applyPipeProcessors
-  };
-  useGridApiMethod(apiRef, preProcessingPrivateApi, 'private');
-  useGridApiMethod(apiRef, preProcessingPublicApi, 'public');
-};

package/modern/hooks/core/pipeProcessing/useGridRegisterPipeApplier.d.ts

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

package/modern/hooks/core/pipeProcessing/useGridRegisterPipeApplier.js

@@ -1,26 +0,0 @@
-import * as React from 'react';
-import { useFirstRender } from "../../utils/useFirstRender.js";
-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/modern/hooks/core/pipeProcessing/useGridRegisterPipeProcessor.d.ts

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

package/modern/hooks/core/pipeProcessing/useGridRegisterPipeProcessor.js

@@ -1,28 +0,0 @@
-import * as React from 'react';
-import { useFirstRender } from "../../utils/useFirstRender.js";
-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/modern/hooks/core/strategyProcessing/gridStrategyProcessingApi.d.ts

@@ -1,79 +0,0 @@
-import { GridRowTreeCreationParams, GridRowTreeCreationValue, GridRowsState } from "../../features/rows/gridRowsInterfaces.js";
-import { GridFilteringMethodParams, GridFilteringMethodValue, GridFilterState, GridVisibleRowsLookupState } from "../../features/filter/gridFilterState.js";
-import { GridSortingMethodParams, GridSortingMethodValue } from "../../features/sorting/gridSortingState.js";
-import { GridGetRowsParams, GridGetRowsResponse } from "../../../models/gridDataSource.js";
-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;
-    } | {
-      error: Error;
-      fetchParams: GridGetRowsParams;
-    };
-    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/modern/hooks/core/strategyProcessing/gridStrategyProcessingApi.js

@@ -1,5 +0,0 @@
-export let GridStrategyGroup = /*#__PURE__*/function (GridStrategyGroup) {
-  GridStrategyGroup["DataSource"] = "dataSource";
-  GridStrategyGroup["RowTree"] = "rowTree";
-  return GridStrategyGroup;
-}({});

package/modern/hooks/core/strategyProcessing/index.d.ts

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

package/modern/hooks/core/strategyProcessing/index.js

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

package/modern/hooks/core/strategyProcessing/useGridRegisterStrategyProcessor.d.ts

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

package/modern/hooks/core/strategyProcessing/useGridRegisterStrategyProcessor.js

@@ -1,18 +0,0 @@
-import * as React from 'react';
-import { useFirstRender } from "../../utils/useFirstRender.js";
-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/modern/hooks/core/strategyProcessing/useGridStrategyProcessing.d.ts

@@ -1,43 +0,0 @@
-import { RefObject } from '@mui/x-internals/types';
-import { GridPrivateApiCommon } from "../../../models/api/gridApiCommon.js";
-import { GridStrategyProcessorName, GridStrategyGroupValue } from "./gridStrategyProcessingApi.js";
-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/modern/hooks/core/strategyProcessing/useGridStrategyProcessing.js

@@ -1,110 +0,0 @@
-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.js";
-import { useGridApiMethod } from "../../utils/useGridApiMethod.js";
-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/modern/hooks/core/useGridApiInitialization.d.ts

@@ -1,5 +0,0 @@
-import { RefObject } from '@mui/x-internals/types';
-import { DataGridProcessedProps } from "../../models/props/DataGridProps.js";
-import type { GridApiCommon, GridPrivateApiCommon } from '../../models/api/gridApiCommon';
-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/modern/hooks/core/useGridApiInitialization.js

@@ -1,112 +0,0 @@
-import * as React from 'react';
-import { EventManager } from '@mui/x-internals/EventManager';
-import { Store } from "../../utils/Store.js";
-import { useGridApiMethod } from "../utils/useGridApiMethod.js";
-import { GridSignature } from "../../constants/signature.js";
-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/modern/hooks/core/useGridInitialization.d.ts

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

package/modern/hooks/core/useGridInitialization.js

@@ -1,28 +0,0 @@
-import { useGridRefs } from "./useGridRefs.js";
-import { useGridIsRtl } from "./useGridIsRtl.js";
-import { useGridLoggerFactory } from "./useGridLoggerFactory.js";
-import { useGridApiInitialization } from "./useGridApiInitialization.js";
-import { useGridLocaleText } from "./useGridLocaleText.js";
-import { useGridPipeProcessing } from "./pipeProcessing/index.js";
-import { useGridStrategyProcessing } from "./strategyProcessing/index.js";
-import { useGridStateInitialization } from "./useGridStateInitialization.js";
-import { useGridProps } from "./useGridProps.js";
-
-/**
- * Initialize the technical pieces of the DataGrid (logger, state, ...) that any DataGrid implementation needs
- */
-export const useGridInitialization = (inputApiRef, props) => {
-  const privateApiRef = useGridApiInitialization(inputApiRef, 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
-  });
-  return privateApiRef;
-};

package/modern/hooks/core/useGridIsRtl.d.ts

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

package/modern/hooks/core/useGridIsRtl.js

@@ -1,19 +0,0 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
-import * as React from 'react';
-import { useRtl } from '@mui/system/RtlProvider';
-export const useGridIsRtl = apiRef => {
-  const isRtl = useRtl();
-  if (apiRef.current.state.isRtl === undefined) {
-    apiRef.current.state.isRtl = isRtl;
-  }
-  const isFirstEffect = React.useRef(true);
-  React.useEffect(() => {
-    if (isFirstEffect.current) {
-      isFirstEffect.current = false;
-    } else {
-      apiRef.current.setState(state => _extends({}, state, {
-        isRtl
-      }));
-    }
-  }, [apiRef, isRtl]);
-};

package/modern/hooks/core/useGridLocaleText.d.ts

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

package/modern/hooks/core/useGridLocaleText.js

@@ -1,12 +0,0 @@
-import * as React from 'react';
-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]);
-  apiRef.current.register('public', {
-    getLocaleText
-  });
-};

package/modern/hooks/core/useGridLoggerFactory.d.ts

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