@mui/x-data-grid 7.0.0-beta.2 → 7.0.0-beta.4

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

@@ -1,26 +0,0 @@
-import * as React from 'react';
-import { useFirstRender } from '../../utils/useFirstRender';
-export var useGridRegisterPipeApplier = function useGridRegisterPipeApplier(apiRef, group, callback) {
-  var cleanup = React.useRef();
-  var id = React.useRef("mui-".concat(Math.round(Math.random() * 1e9)));
-  var registerPreProcessor = React.useCallback(function () {
-    cleanup.current = apiRef.current.registerPipeApplier(group, id.current, callback);
-  }, [apiRef, callback, group]);
-  useFirstRender(function () {
-    registerPreProcessor();
-  });
-  var isFirstRender = React.useRef(true);
-  React.useEffect(function () {
-    if (isFirstRender.current) {
-      isFirstRender.current = false;
-    } else {
-      registerPreProcessor();
-    }
-    return function () {
-      if (cleanup.current) {
-        cleanup.current();
-        cleanup.current = null;
-      }
-    };
-  }, [registerPreProcessor]);
-};

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

@@ -1,26 +0,0 @@
-import * as React from 'react';
-import { useFirstRender } from '../../utils/useFirstRender';
-export var useGridRegisterPipeProcessor = function useGridRegisterPipeProcessor(apiRef, group, callback) {
-  var cleanup = React.useRef();
-  var id = React.useRef("mui-".concat(Math.round(Math.random() * 1e9)));
-  var registerPreProcessor = React.useCallback(function () {
-    cleanup.current = apiRef.current.registerPipeProcessor(group, id.current, callback);
-  }, [apiRef, callback, group]);
-  useFirstRender(function () {
-    registerPreProcessor();
-  });
-  var isFirstRender = React.useRef(true);
-  React.useEffect(function () {
-    if (isFirstRender.current) {
-      isFirstRender.current = false;
-    } else {
-      registerPreProcessor();
-    }
-    return function () {
-      if (cleanup.current) {
-        cleanup.current();
-        cleanup.current = null;
-      }
-    };
-  }, [registerPreProcessor]);
-};

package/legacy/hooks/core/strategyProcessing/gridStrategyProcessingApi.js

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

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

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

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

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

package/legacy/hooks/core/strategyProcessing/useGridStrategyProcessing.js

@@ -1,116 +0,0 @@
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
-import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
-import _toPropertyKey from "@babel/runtime/helpers/esm/toPropertyKey";
-import * as React from 'react';
-import { useGridApiMethod } from '../../utils/useGridApiMethod';
-export var GRID_DEFAULT_STRATEGY = 'none';
-export var GRID_STRATEGIES_PROCESSORS = {
-  rowTreeCreation: 'rowTree',
-  filtering: 'rowTree',
-  sorting: 'rowTree',
-  visibleRowsLookupCreation: '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.
- * For now, there is only one strategy group named `rowTree` which customize
- * - row tree creation algorithm.
- * - sorting algorithm.
- * - filtering algorithm.
- */
-export var useGridStrategyProcessing = function useGridStrategyProcessing(apiRef) {
-  var availableStrategies = React.useRef(new Map());
-  var strategiesCache = React.useRef({});
-  var registerStrategyProcessor = React.useCallback(function (strategyName, processorName, processor) {
-    var cleanup = function cleanup() {
-      var _ref = strategiesCache.current[processorName],
-        removedPreProcessor = _ref[strategyName],
-        otherProcessors = _objectWithoutProperties(_ref, [strategyName].map(_toPropertyKey));
-      strategiesCache.current[processorName] = otherProcessors;
-    };
-    if (!strategiesCache.current[processorName]) {
-      strategiesCache.current[processorName] = {};
-    }
-    var groupPreProcessors = strategiesCache.current[processorName];
-    var 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]);
-  var applyStrategyProcessor = React.useCallback(function (processorName, params) {
-    var 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");
-    }
-    var groupCache = strategiesCache.current[processorName];
-    if (!groupCache || !groupCache[activeStrategy]) {
-      throw new Error("No processor found for processor \"".concat(processorName, "\" on strategy \"").concat(activeStrategy, "\""));
-    }
-    var processor = groupCache[activeStrategy];
-    return processor(params);
-  }, [apiRef]);
-  var getActiveStrategy = React.useCallback(function (strategyGroup) {
-    var _availableStrategyEnt;
-    var strategyEntries = Array.from(availableStrategies.current.entries());
-    var availableStrategyEntry = strategyEntries.find(function (_ref2) {
-      var _ref3 = _slicedToArray(_ref2, 2),
-        strategy = _ref3[1];
-      if (strategy.group !== strategyGroup) {
-        return false;
-      }
-      return strategy.isAvailable();
-    });
-    return (_availableStrategyEnt = availableStrategyEntry == null ? void 0 : availableStrategyEntry[0]) != null ? _availableStrategyEnt : GRID_DEFAULT_STRATEGY;
-  }, []);
-  var setStrategyAvailability = React.useCallback(function (strategyGroup, strategyName, isAvailable) {
-    availableStrategies.current.set(strategyName, {
-      group: strategyGroup,
-      isAvailable: isAvailable
-    });
-    apiRef.current.publishEvent('strategyAvailabilityChange');
-  }, [apiRef]);
-  var strategyProcessingApi = {
-    registerStrategyProcessor: registerStrategyProcessor,
-    applyStrategyProcessor: applyStrategyProcessor,
-    getActiveStrategy: getActiveStrategy,
-    setStrategyAvailability: setStrategyAvailability
-  };
-  useGridApiMethod(apiRef, strategyProcessingApi, 'private');
-};

package/legacy/hooks/core/useGridApiInitialization.js

@@ -1,124 +0,0 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import * as React from 'react';
-import { Store } from '../../utils/Store';
-import { useGridApiMethod } from '../utils/useGridApiMethod';
-import { GridSignature } from '../utils/useGridApiEventHandler';
-import { EventManager } from '../../utils/EventManager';
-var SYMBOL_API_PRIVATE = Symbol('mui.api_private');
-var isSyntheticEvent = function isSyntheticEvent(event) {
-  return event.isPropagationStopped !== undefined;
-};
-export function unwrapPrivateAPI(publicApi) {
-  return publicApi[SYMBOL_API_PRIVATE];
-}
-var globalId = 0;
-function createPrivateAPI(publicApiRef) {
-  var _publicApiRef$current;
-  var existingPrivateApi = (_publicApiRef$current = publicApiRef.current) == null ? void 0 : _publicApiRef$current[SYMBOL_API_PRIVATE];
-  if (existingPrivateApi) {
-    return existingPrivateApi;
-  }
-  var state = {};
-  var privateApi = {
-    state: state,
-    store: Store.create(state),
-    instanceId: {
-      id: globalId
-    }
-  };
-  globalId += 1;
-  privateApi.getPublicApi = function () {
-    return publicApiRef.current;
-  };
-  privateApi.register = function (visibility, methods) {
-    Object.keys(methods).forEach(function (methodName) {
-      var method = methods[methodName];
-      var currentPrivateMethod = privateApi[methodName];
-      if ((currentPrivateMethod == null ? void 0 : currentPrivateMethod.spying) === true) {
-        currentPrivateMethod.target = method;
-      } else {
-        privateApi[methodName] = method;
-      }
-      if (visibility === 'public') {
-        var publicApi = publicApiRef.current;
-        var currentPublicMethod = publicApi[methodName];
-        if ((currentPublicMethod == null ? void 0 : currentPublicMethod.spying) === true) {
-          currentPublicMethod.target = method;
-        } else {
-          publicApi[methodName] = method;
-        }
-      }
-    });
-  };
-  privateApi.register('private', {
-    caches: {},
-    eventManager: new EventManager()
-  });
-  return privateApi;
-}
-function createPublicAPI(privateApiRef) {
-  var publicApi = _defineProperty({
-    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) {
-  var _inputApiRef$current;
-  var publicApiRef = React.useRef();
-  var privateApiRef = React.useRef();
-  if (!privateApiRef.current) {
-    privateApiRef.current = createPrivateAPI(publicApiRef);
-  }
-  if (!publicApiRef.current) {
-    publicApiRef.current = createPublicAPI(privateApiRef);
-  }
-  var publishEvent = React.useCallback(function () {
-    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-      args[_key] = arguments[_key];
-    }
-    var name = args[0],
-      params = args[1],
-      _args$ = args[2],
-      event = _args$ === void 0 ? {} : _args$;
-    event.defaultMuiPrevented = false;
-    if (isSyntheticEvent(event) && event.isPropagationStopped()) {
-      return;
-    }
-    var details = props.signature === GridSignature.DataGridPro ? {
-      api: privateApiRef.current.getPublicApi()
-    } : {};
-    privateApiRef.current.eventManager.emit(name, params, event, details);
-  }, [privateApiRef, props.signature]);
-  var subscribeEvent = React.useCallback(function (event, handler, options) {
-    privateApiRef.current.eventManager.on(event, handler, options);
-    var api = privateApiRef.current;
-    return function () {
-      api.eventManager.removeListener(event, handler);
-    };
-  }, [privateApiRef]);
-  useGridApiMethod(privateApiRef, {
-    subscribeEvent: subscribeEvent,
-    publishEvent: publishEvent
-  }, 'public');
-  if (inputApiRef && !((_inputApiRef$current = inputApiRef.current) != null && _inputApiRef$current.state)) {
-    inputApiRef.current = publicApiRef.current;
-  }
-  React.useImperativeHandle(inputApiRef, function () {
-    return publicApiRef.current;
-  }, [publicApiRef]);
-  React.useEffect(function () {
-    var api = privateApiRef.current;
-    return function () {
-      api.publishEvent('unmount');
-    };
-  }, [privateApiRef]);
-  return privateApiRef;
-}

package/legacy/hooks/core/useGridInitialization.js

@@ -1,26 +0,0 @@
-import { useGridRefs } from './useGridRefs';
-import { useGridTheme } from './useGridTheme';
-import { useGridLoggerFactory } from './useGridLoggerFactory';
-import { useGridApiInitialization } from './useGridApiInitialization';
-import { useGridLocaleText } from './useGridLocaleText';
-import { useGridPipeProcessing } from './pipeProcessing';
-import { useGridStrategyProcessing } from './strategyProcessing';
-import { useGridStateInitialization } from './useGridStateInitialization';
-
-/**
- * Initialize the technical pieces of the DataGrid (logger, state, ...) that any DataGrid implementation needs
- */
-export var useGridInitialization = function useGridInitialization(inputApiRef, props) {
-  var privateApiRef = useGridApiInitialization(inputApiRef, props);
-  useGridRefs(privateApiRef);
-  useGridTheme(privateApiRef);
-  useGridLoggerFactory(privateApiRef, props);
-  useGridStateInitialization(privateApiRef, props);
-  useGridPipeProcessing(privateApiRef);
-  useGridStrategyProcessing(privateApiRef);
-  useGridLocaleText(privateApiRef, props);
-  privateApiRef.current.register('private', {
-    rootProps: props
-  });
-  return privateApiRef;
-};

package/legacy/hooks/core/useGridLocaleText.js

@@ -1,12 +0,0 @@
-import * as React from 'react';
-export var useGridLocaleText = function useGridLocaleText(apiRef, props) {
-  var getLocaleText = React.useCallback(function (key) {
-    if (props.localeText[key] == null) {
-      throw new Error("Missing translation for key ".concat(key, "."));
-    }
-    return props.localeText[key];
-  }, [props.localeText]);
-  apiRef.current.register('public', {
-    getLocaleText: getLocaleText
-  });
-};

package/legacy/hooks/core/useGridLoggerFactory.js

@@ -1,51 +0,0 @@
-import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
-import * as React from 'react';
-import { localStorageAvailable } from '../../utils/utils';
-import { useGridApiMethod } from '../utils';
-var forceDebug = localStorageAvailable() && window.localStorage.getItem('DEBUG') != null;
-var noop = function noop() {};
-var noopLogger = {
-  debug: noop,
-  info: noop,
-  warn: noop,
-  error: noop
-};
-var LOG_LEVELS = ['debug', 'info', 'warn', 'error'];
-function getAppender(name, logLevel) {
-  var appender = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : console;
-  var minLogLevelIdx = LOG_LEVELS.indexOf(logLevel);
-  if (minLogLevelIdx === -1) {
-    throw new Error("MUI X: Log level ".concat(logLevel, " not recognized."));
-  }
-  var logger = LOG_LEVELS.reduce(function (loggerObj, method, idx) {
-    if (idx >= minLogLevelIdx) {
-      loggerObj[method] = function () {
-        var _ref;
-        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-          args[_key] = arguments[_key];
-        }
-        var message = args[0],
-          other = args.slice(1);
-        (_ref = appender)[method].apply(_ref, ["MUI X: ".concat(name, " - ").concat(message)].concat(_toConsumableArray(other)));
-      };
-    } else {
-      loggerObj[method] = noop;
-    }
-    return loggerObj;
-  }, {});
-  return logger;
-}
-export var useGridLoggerFactory = function useGridLoggerFactory(apiRef, props) {
-  var getLogger = React.useCallback(function (name) {
-    if (forceDebug) {
-      return getAppender(name, 'debug', props.logger);
-    }
-    if (!props.logLevel) {
-      return noopLogger;
-    }
-    return getAppender(name, props.logLevel.toString(), props.logger);
-  }, [props.logLevel, props.logger]);
-  useGridApiMethod(apiRef, {
-    getLogger: getLogger
-  }, 'private');
-};

package/legacy/hooks/core/useGridRefs.js

@@ -1,13 +0,0 @@
-import * as React from 'react';
-export var useGridRefs = function useGridRefs(apiRef) {
-  var rootElementRef = React.useRef(null);
-  var mainElementRef = React.useRef(null);
-  var virtualScrollerRef = React.useRef(null);
-  apiRef.current.register('public', {
-    rootElementRef: rootElementRef
-  });
-  apiRef.current.register('private', {
-    mainElementRef: mainElementRef,
-    virtualScrollerRef: virtualScrollerRef
-  });
-};

package/legacy/hooks/core/useGridStateInitialization.js

@@ -1,106 +0,0 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import _extends from "@babel/runtime/helpers/esm/extends";
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
-import * as React from 'react';
-import { GridSignature } from '../utils/useGridApiEventHandler';
-import { useGridApiMethod } from '../utils';
-import { isFunction } from '../../utils/utils';
-export var useGridStateInitialization = function useGridStateInitialization(apiRef, props) {
-  var controlStateMapRef = React.useRef({});
-  var _React$useState = React.useState(),
-    _React$useState2 = _slicedToArray(_React$useState, 2),
-    rawForceUpdate = _React$useState2[1];
-  var registerControlState = React.useCallback(function (controlStateItem) {
-    controlStateMapRef.current[controlStateItem.stateId] = controlStateItem;
-  }, []);
-  var setState = React.useCallback(function (state, reason) {
-    var newState;
-    if (isFunction(state)) {
-      newState = state(apiRef.current.state);
-    } else {
-      newState = state;
-    }
-    if (apiRef.current.state === newState) {
-      return false;
-    }
-    var ignoreSetState = false;
-
-    // Apply the control state constraints
-    var updatedControlStateIds = [];
-    Object.keys(controlStateMapRef.current).forEach(function (stateId) {
-      var controlState = controlStateMapRef.current[stateId];
-      var oldSubState = controlState.stateSelector(apiRef.current.state, apiRef.current.instanceId);
-      var newSubState = controlState.stateSelector(newState, apiRef.current.instanceId);
-      if (newSubState === oldSubState) {
-        return;
-      }
-      updatedControlStateIds.push({
-        stateId: controlState.stateId,
-        hasPropChanged: newSubState !== controlState.propModel
-      });
-
-      // The state is controlled, the prop should always win
-      if (controlState.propModel !== undefined && newSubState !== controlState.propModel) {
-        ignoreSetState = true;
-      }
-    });
-    if (updatedControlStateIds.length > 1) {
-      // Each hook modify its own state, and it should not leak
-      // Events are here to forward to other hooks and apply changes.
-      // You are trying to update several states in a no isolated way.
-      throw new Error("You're not allowed to update several sub-state in one transaction. You already updated ".concat(updatedControlStateIds[0].stateId, ", therefore, you're not allowed to update ").concat(updatedControlStateIds.map(function (el) {
-        return el.stateId;
-      }).join(', '), " in the same transaction."));
-    }
-    if (!ignoreSetState) {
-      // We always assign it as we mutate rows for perf reason.
-      apiRef.current.state = newState;
-      if (apiRef.current.publishEvent) {
-        apiRef.current.publishEvent('stateChange', newState);
-      }
-      apiRef.current.store.update(newState);
-    }
-    if (updatedControlStateIds.length === 1) {
-      var _updatedControlStateI = updatedControlStateIds[0],
-        stateId = _updatedControlStateI.stateId,
-        hasPropChanged = _updatedControlStateI.hasPropChanged;
-      var controlState = controlStateMapRef.current[stateId];
-      var model = controlState.stateSelector(newState, apiRef.current.instanceId);
-      if (controlState.propOnChange && hasPropChanged) {
-        var details = props.signature === GridSignature.DataGridPro ? {
-          api: apiRef.current,
-          reason: reason
-        } : {
-          reason: reason
-        };
-        controlState.propOnChange(model, details);
-      }
-      if (!ignoreSetState) {
-        apiRef.current.publishEvent(controlState.changeEvent, model, {
-          reason: reason
-        });
-      }
-    }
-    return !ignoreSetState;
-  }, [apiRef, props.signature]);
-  var updateControlState = React.useCallback(function (key, state, reason) {
-    return apiRef.current.setState(function (previousState) {
-      return _extends({}, previousState, _defineProperty({}, key, state(previousState[key])));
-    }, reason);
-  }, [apiRef]);
-  var forceUpdate = React.useCallback(function () {
-    return rawForceUpdate(function () {
-      return apiRef.current.state;
-    });
-  }, [apiRef]);
-  var publicStateApi = {
-    setState: setState,
-    forceUpdate: forceUpdate
-  };
-  var privateStateApi = {
-    updateControlState: updateControlState,
-    registerControlState: registerControlState
-  };
-  useGridApiMethod(apiRef, publicStateApi, 'public');
-  useGridApiMethod(apiRef, privateStateApi, 'private');
-};

package/legacy/hooks/core/useGridTheme.js

@@ -1,21 +0,0 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
-import * as React from 'react';
-import { useTheme } from '@mui/material/styles';
-export var useGridTheme = function useGridTheme(apiRef) {
-  var theme = useTheme();
-  if (!apiRef.current.state.theme) {
-    apiRef.current.state.theme = theme;
-  }
-  var isFirstEffect = React.useRef(true);
-  React.useEffect(function () {
-    if (isFirstEffect.current) {
-      isFirstEffect.current = false;
-    } else {
-      apiRef.current.setState(function (state) {
-        return _extends({}, state, {
-          theme: theme
-        });
-      });
-    }
-  }, [apiRef, theme]);
-};

package/legacy/hooks/features/clipboard/useGridClipboard.js

@@ -1,92 +0,0 @@
-import _typeof from "@babel/runtime/helpers/esm/typeof";
-import * as React from 'react';
-import { useGridApiOptionHandler, useGridNativeEventListener } from '../../utils';
-import { gridFocusCellSelector } from '../focus/gridFocusStateSelector';
-import { serializeCellValue } from '../export/serializers/csvSerializer';
-function writeToClipboardPolyfill(data) {
-  var span = document.createElement('span');
-  span.style.whiteSpace = 'pre';
-  span.style.userSelect = 'all';
-  span.style.opacity = '0px';
-  span.textContent = data;
-  document.body.appendChild(span);
-  var range = document.createRange();
-  range.selectNode(span);
-  var selection = window.getSelection();
-  selection.removeAllRanges();
-  selection.addRange(range);
-  try {
-    document.execCommand('copy');
-  } finally {
-    document.body.removeChild(span);
-  }
-}
-function copyToClipboard(data) {
-  if (navigator.clipboard) {
-    navigator.clipboard.writeText(data).catch(function () {
-      writeToClipboardPolyfill(data);
-    });
-  } else {
-    writeToClipboardPolyfill(data);
-  }
-}
-function hasNativeSelection(element) {
-  var _window$getSelection;
-  // When getSelection is called on an <iframe> that is not displayed Firefox will return null.
-  if ((_window$getSelection = window.getSelection()) != null && _window$getSelection.toString()) {
-    return true;
-  }
-
-  // window.getSelection() returns an empty string in Firefox for selections inside a form element.
-  // See: https://bugzilla.mozilla.org/show_bug.cgi?id=85686.
-  // Instead, we can use element.selectionStart that is only defined on form elements.
-  if (element && (element.selectionEnd || 0) - (element.selectionStart || 0) > 0) {
-    return true;
-  }
-  return false;
-}
-
-/**
- * @requires useGridCsvExport (method)
- * @requires useGridSelection (method)
- */
-export var useGridClipboard = function useGridClipboard(apiRef, props) {
-  var ignoreValueFormatterProp = props.ignoreValueFormatterDuringExport;
-  var ignoreValueFormatter = (_typeof(ignoreValueFormatterProp) === 'object' ? ignoreValueFormatterProp == null ? void 0 : ignoreValueFormatterProp.clipboardExport : ignoreValueFormatterProp) || false;
-  var clipboardCopyCellDelimiter = props.clipboardCopyCellDelimiter;
-  var handleCopy = React.useCallback(function (event) {
-    if (!((event.ctrlKey || event.metaKey) && event.key === 'c')) {
-      return;
-    }
-
-    // Do nothing if there's a native selection
-    if (hasNativeSelection(event.target)) {
-      return;
-    }
-    var textToCopy = '';
-    var selectedRows = apiRef.current.getSelectedRows();
-    if (selectedRows.size > 0) {
-      textToCopy = apiRef.current.getDataAsCsv({
-        includeHeaders: false,
-        // TODO: make it configurable
-        delimiter: clipboardCopyCellDelimiter
-      });
-    } else {
-      var focusedCell = gridFocusCellSelector(apiRef);
-      if (focusedCell) {
-        var cellParams = apiRef.current.getCellParams(focusedCell.id, focusedCell.field);
-        textToCopy = serializeCellValue(cellParams, {
-          delimiterCharacter: clipboardCopyCellDelimiter,
-          ignoreValueFormatter: ignoreValueFormatter
-        });
-      }
-    }
-    textToCopy = apiRef.current.unstable_applyPipeProcessors('clipboardCopy', textToCopy);
-    if (textToCopy) {
-      copyToClipboard(textToCopy);
-      apiRef.current.publishEvent('clipboardCopy', textToCopy);
-    }
-  }, [apiRef, ignoreValueFormatter, clipboardCopyCellDelimiter]);
-  useGridNativeEventListener(apiRef, apiRef.current.rootElementRef, 'keydown', handleCopy);
-  useGridApiOptionHandler(apiRef, 'clipboardCopy', props.onClipboardCopy);
-};

package/legacy/hooks/features/columnGrouping/gridColumnGroupsInterfaces.js

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