@mui/x-data-grid 5.4.0 → 5.6.0

package/node/hooks/utils/useGridApiEventHandler.js

@@ -0,0 +1,123 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.GridSignature = void 0;
+exports.createUseGridApiEventHandler = createUseGridApiEventHandler;
+exports.useGridApiEventHandler = exports.unstable_resetCleanupTracking = void 0;
+exports.useGridApiOptionHandler = useGridApiOptionHandler;
+
+var React = _interopRequireWildcard(require("react"));
+
+var _TimerBasedCleanupTracking = require("../../utils/cleanupTracking/TimerBasedCleanupTracking");
+
+var _FinalizationRegistryBasedCleanupTracking = require("../../utils/cleanupTracking/FinalizationRegistryBasedCleanupTracking");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+/**
+ * Signal to the underlying logic what version of the public component API
+ * of the data grid is exposed.
+ */
+var GridSignature; // We use class to make it easier to detect in heap snapshots by name
+
+exports.GridSignature = GridSignature;
+
+(function (GridSignature) {
+  GridSignature["DataGrid"] = "DataGrid";
+  GridSignature["DataGridPro"] = "DataGridPro";
+})(GridSignature || (exports.GridSignature = GridSignature = {}));
+
+class ObjectToBeRetainedByReact {} // Based on https://github.com/Bnaya/use-dispose-uncommitted/blob/main/src/finalization-registry-based-impl.ts
+// Check https://github.com/facebook/react/issues/15317 to get more information
+
+
+function createUseGridApiEventHandler(registry) {
+  let cleanupTokensCounter = 0;
+  return function useGridApiEventHandler(apiRef, eventName, handler, options) {
+    const [objectRetainedByReact] = React.useState(new ObjectToBeRetainedByReact());
+    const subscription = React.useRef(null);
+    const handlerRef = React.useRef();
+    handlerRef.current = handler;
+    const cleanupTokenRef = React.useRef(null);
+
+    if (!subscription.current && handlerRef.current) {
+      const enhancedHandler = (params, event, details) => {
+        if (!event.defaultMuiPrevented) {
+          var _handlerRef$current;
+
+          (_handlerRef$current = handlerRef.current) == null ? void 0 : _handlerRef$current.call(handlerRef, params, event, details);
+        }
+      };
+
+      subscription.current = apiRef.current.subscribeEvent(eventName, enhancedHandler, options);
+      cleanupTokensCounter += 1;
+      cleanupTokenRef.current = {
+        cleanupToken: cleanupTokensCounter
+      };
+      registry.register(objectRetainedByReact, // The callback below will be called once this reference stops being retained
+      () => {
+        var _subscription$current;
+
+        (_subscription$current = subscription.current) == null ? void 0 : _subscription$current.call(subscription);
+        subscription.current = null;
+        cleanupTokenRef.current = null;
+      }, cleanupTokenRef.current);
+    } else if (!handlerRef.current && subscription.current) {
+      subscription.current();
+      subscription.current = null;
+
+      if (cleanupTokenRef.current) {
+        registry.unregister(cleanupTokenRef.current);
+        cleanupTokenRef.current = null;
+      }
+    }
+
+    React.useEffect(() => {
+      if (!subscription.current && handlerRef.current) {
+        const enhancedHandler = (params, event, details) => {
+          if (!event.defaultMuiPrevented) {
+            var _handlerRef$current2;
+
+            (_handlerRef$current2 = handlerRef.current) == null ? void 0 : _handlerRef$current2.call(handlerRef, params, event, details);
+          }
+        };
+
+        subscription.current = apiRef.current.subscribeEvent(eventName, enhancedHandler, options);
+      }
+
+      if (cleanupTokenRef.current && registry) {
+        // If the effect was called, it means that this render was committed
+        // so we can trust the cleanup function to remove the listener.
+        registry.unregister(cleanupTokenRef.current);
+        cleanupTokenRef.current = null;
+      }
+
+      return () => {
+        var _subscription$current2;
+
+        (_subscription$current2 = subscription.current) == null ? void 0 : _subscription$current2.call(subscription);
+        subscription.current = null;
+      };
+    }, [apiRef, eventName, options]);
+  };
+}
+
+const registry = typeof FinalizationRegistry !== 'undefined' ? new _FinalizationRegistryBasedCleanupTracking.FinalizationRegistryBasedCleanupTracking() : new _TimerBasedCleanupTracking.TimerBasedCleanupTracking(); // eslint-disable-next-line @typescript-eslint/naming-convention
+
+const unstable_resetCleanupTracking = () => registry.reset();
+
+exports.unstable_resetCleanupTracking = unstable_resetCleanupTracking;
+const useGridApiEventHandler = createUseGridApiEventHandler(registry);
+exports.useGridApiEventHandler = useGridApiEventHandler;
+const optionsSubscriberOptions = {
+  isFirst: true
+};
+
+function useGridApiOptionHandler(apiRef, eventName, handler) {
+  // Validate that only one per event name?
+  useGridApiEventHandler(apiRef, eventName, handler, optionsSubscriberOptions);
+}

package/node/hooks/utils/useGridApiMethod.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useGridApiMethod = useGridApiMethod;
+
+var React = _interopRequireWildcard(require("react"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function useGridApiMethod(apiRef, apiMethods, // TODO: Remove `apiName
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+apiName) {
+  const apiMethodsRef = React.useRef(apiMethods);
+  const [apiMethodsNames] = React.useState(Object.keys(apiMethods));
+  const installMethods = React.useCallback(() => {
+    if (!apiRef.current) {
+      return;
+    }
+
+    apiMethodsNames.forEach(methodName => {
+      if (!apiRef.current.hasOwnProperty(methodName)) {
+        apiRef.current[methodName] = (...args) => apiMethodsRef.current[methodName](...args);
+      }
+    });
+  }, [apiMethodsNames, apiRef]);
+  React.useEffect(() => {
+    apiMethodsRef.current = apiMethods;
+  }, [apiMethods]);
+  React.useEffect(() => {
+    installMethods();
+  }, [installMethods]);
+  installMethods();
+}

package/node/hooks/utils/useGridApiRef.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useGridApiRef = void 0;
+
+var React = _interopRequireWildcard(require("react"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+/**
+ * Hook that instantiate a [[GridApiRef]].
+ */
+const useGridApiRef = () => React.useRef({});
+
+exports.useGridApiRef = useGridApiRef;

package/node/hooks/utils/useGridInitializeState.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useGridInitializeState = void 0;
+
+var React = _interopRequireWildcard(require("react"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+const useGridInitializeState = (initializer, apiRef, props) => {
+  const isInitialized = React.useRef(false);
+
+  if (!isInitialized.current) {
+    apiRef.current.state = initializer(apiRef.current.state, props, apiRef);
+    isInitialized.current = true;
+  }
+};
+
+exports.useGridInitializeState = useGridInitializeState;

package/node/hooks/utils/useGridLogger.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useGridLogger = useGridLogger;
+
+var React = _interopRequireWildcard(require("react"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function useGridLogger(apiRef, name) {
+  const logger = React.useRef(null);
+
+  if (logger.current) {
+    return logger.current;
+  }
+
+  const newLogger = apiRef.current.getLogger(name);
+  logger.current = newLogger;
+  return newLogger;
+}

package/node/hooks/utils/useGridNativeEventListener.js

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useGridNativeEventListener = void 0;
+
+var React = _interopRequireWildcard(require("react"));
+
+var _events = require("../../models/events");
+
+var _utils = require("../../utils/utils");
+
+var _useGridLogger = require("./useGridLogger");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+const useGridNativeEventListener = (apiRef, ref, eventName, handler, options) => {
+  const logger = (0, _useGridLogger.useGridLogger)(apiRef, 'useNativeEventListener');
+  const [added, setAdded] = React.useState(false);
+  const handlerRef = React.useRef(handler);
+  const wrapHandler = React.useCallback(args => {
+    return handlerRef.current && handlerRef.current(args);
+  }, []);
+  React.useEffect(() => {
+    handlerRef.current = handler;
+  }, [handler]);
+  React.useEffect(() => {
+    let targetElement;
+
+    if ((0, _utils.isFunction)(ref)) {
+      targetElement = ref();
+    } else {
+      targetElement = ref && ref.current ? ref.current : null;
+    }
+
+    if (targetElement && wrapHandler && eventName && !added) {
+      logger.debug(`Binding native ${eventName} event`);
+      targetElement.addEventListener(eventName, wrapHandler, options);
+      const boundElem = targetElement;
+      setAdded(true);
+
+      const unsubscribe = () => {
+        logger.debug(`Clearing native ${eventName} event`);
+        boundElem.removeEventListener(eventName, wrapHandler, options);
+      };
+
+      apiRef.current.subscribeEvent(_events.GridEvents.unmount, unsubscribe);
+    }
+  }, [ref, wrapHandler, eventName, added, logger, options, apiRef]);
+};
+
+exports.useGridNativeEventListener = useGridNativeEventListener;

package/node/hooks/utils/useGridRootProps.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useGridRootProps = void 0;
+
+var React = _interopRequireWildcard(require("react"));
+
+var _GridRootPropsContext = require("../../context/GridRootPropsContext");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+const useGridRootProps = () => {
+  const contextValue = React.useContext(_GridRootPropsContext.GridRootPropsContext);
+
+  if (!contextValue) {
+    throw new Error('MUI: useGridRootProps should only be used inside the DataGrid/DataGridPro component.');
+  }
+
+  return contextValue;
+};
+
+exports.useGridRootProps = useGridRootProps;

package/node/hooks/utils/useGridScrollFn.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useGridScrollFn = useGridScrollFn;
+
+var React = _interopRequireWildcard(require("react"));
+
+var _useGridLogger = require("./useGridLogger");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function useGridScrollFn(apiRef, renderingZoneElementRef, columnHeadersElementRef) {
+  const logger = (0, _useGridLogger.useGridLogger)(apiRef, 'useGridScrollFn');
+  const previousValue = React.useRef();
+  const scrollTo = React.useCallback(v => {
+    var _previousValue$curren;
+
+    if (v.left === ((_previousValue$curren = previousValue.current) == null ? void 0 : _previousValue$curren.left) && v.top === previousValue.current.top) {
+      return;
+    }
+
+    if (renderingZoneElementRef && renderingZoneElementRef.current) {
+      logger.debug(`Moving ${renderingZoneElementRef.current.className} to: ${v.left}-${v.top}`); // Force the creation of a layer, avoid paint when changing the transform value.
+
+      renderingZoneElementRef.current.style.transform = `translate3d(${-v.left}px, ${-v.top}px, 0px)`;
+      columnHeadersElementRef.current.style.transform = `translate3d(${-v.left}px, 0px, 0px)`;
+      previousValue.current = v;
+    }
+  }, [renderingZoneElementRef, logger, columnHeadersElementRef]);
+  return [scrollTo];
+}

package/node/hooks/utils/useGridSelector.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useGridSelector = void 0;
+let warnedOnceStateNotInitialized = false;
+
+function isOutputSelector(selector) {
+  return selector.cache;
+}
+
+const useGridSelector = (apiRef, selector) => {
+  if (process.env.NODE_ENV !== 'production') {
+    if (!warnedOnceStateNotInitialized && !apiRef.current.state) {
+      warnedOnceStateNotInitialized = true;
+      console.warn(['MUI: `useGridSelector` has been called before the initialization of the state.', 'This hook can only be used inside the context of the grid.'].join('\n'));
+    }
+  }
+
+  if (isOutputSelector(selector)) {
+    return selector(apiRef);
+  }
+
+  return selector(apiRef.current.state);
+};
+
+exports.useGridSelector = useGridSelector;

package/node/hooks/utils/useGridState.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useGridState = void 0;
+
+/**
+ * @deprecated Use `apiRef.current.state`, `apiRef.current.setState` and `apiRef.current.forceUpdate` instead.
+ */
+const useGridState = apiRef => [apiRef.current.state, apiRef.current.setState, apiRef.current.forceUpdate];
+
+exports.useGridState = useGridState;

package/node/hooks/utils/useGridStateInit.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useGridStateInit = void 0;
+
+var React = _interopRequireWildcard(require("react"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+const useGridStateInit = (apiRef, callback) => {
+  const isInitialized = React.useRef(false);
+
+  if (!isInitialized.current) {
+    apiRef.current.state = callback(apiRef.current.state);
+    isInitialized.current = true;
+  }
+};
+
+exports.useGridStateInit = useGridStateInit;

package/node/index.js

@@ -0,0 +1,165 @@
+/** @license MUI v5.6.0
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  useGridApiContext: true,
+  useGridApiRef: true,
+  useGridRootProps: true
+};
+Object.defineProperty(exports, "useGridApiContext", {
+  enumerable: true,
+  get: function () {
+    return _useGridApiContext.useGridApiContext;
+  }
+});
+Object.defineProperty(exports, "useGridApiRef", {
+  enumerable: true,
+  get: function () {
+    return _useGridApiRef.useGridApiRef;
+  }
+});
+Object.defineProperty(exports, "useGridRootProps", {
+  enumerable: true,
+  get: function () {
+    return _useGridRootProps.useGridRootProps;
+  }
+});
+
+var _useGridApiContext = require("./hooks/utils/useGridApiContext");
+
+var _useGridApiRef = require("./hooks/utils/useGridApiRef");
+
+var _useGridRootProps = require("./hooks/utils/useGridRootProps");
+
+var _DataGrid = require("./DataGrid");
+
+Object.keys(_DataGrid).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _DataGrid[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _DataGrid[key];
+    }
+  });
+});
+
+var _components = require("./components");
+
+Object.keys(_components).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _components[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _components[key];
+    }
+  });
+});
+
+var _constants = require("./constants");
+
+Object.keys(_constants).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _constants[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _constants[key];
+    }
+  });
+});
+
+var _hooks = require("./hooks");
+
+Object.keys(_hooks).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _hooks[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _hooks[key];
+    }
+  });
+});
+
+var _locales = require("./locales");
+
+Object.keys(_locales).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _locales[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _locales[key];
+    }
+  });
+});
+
+var _models = require("./models");
+
+Object.keys(_models).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _models[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _models[key];
+    }
+  });
+});
+
+var _context = require("./context");
+
+Object.keys(_context).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _context[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _context[key];
+    }
+  });
+});
+
+var _colDef = require("./colDef");
+
+Object.keys(_colDef).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _colDef[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _colDef[key];
+    }
+  });
+});
+
+var _utils = require("./utils");
+
+Object.keys(_utils).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _utils[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _utils[key];
+    }
+  });
+});