@mui/x-data-grid 5.4.0 → 5.6.0

package/node/hooks/core/preProcessing/useGridPreProcessing.js

@@ -0,0 +1,69 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useGridPreProcessing = void 0;
+
+var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
+
+var _toPropertyKey2 = _interopRequireDefault(require("@babel/runtime/helpers/toPropertyKey"));
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var React = _interopRequireWildcard(require("react"));
+
+var _useGridApiMethod = require("../../utils/useGridApiMethod");
+
+var _events = require("../../../models/events");
+
+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 useGridPreProcessing = apiRef => {
+  const preProcessorsRef = React.useRef({});
+  const registerPreProcessor = React.useCallback((group, id, callback) => {
+    if (!preProcessorsRef.current[group]) {
+      preProcessorsRef.current[group] = {};
+    }
+
+    const preProcessors = preProcessorsRef.current[group];
+    const oldCallback = preProcessors[id];
+
+    if (!oldCallback || oldCallback !== callback) {
+      preProcessorsRef.current[group] = (0, _extends2.default)({}, preProcessors, {
+        [id]: callback
+      });
+      apiRef.current.publishEvent(_events.GridEvents.preProcessorRegister, group);
+    }
+
+    return () => {
+      const _ref = preProcessorsRef.current[group],
+            otherProcessors = (0, _objectWithoutPropertiesLoose2.default)(_ref, [id].map(_toPropertyKey2.default));
+      preProcessorsRef.current[group] = otherProcessors;
+      apiRef.current.publishEvent(_events.GridEvents.preProcessorUnregister, group);
+    };
+  }, [apiRef]);
+  const applyPreProcessors = React.useCallback((...args) => {
+    const [group, value, params] = args;
+
+    if (!preProcessorsRef.current[group]) {
+      return value;
+    }
+
+    const preProcessors = Object.values(preProcessorsRef.current[group]);
+    return preProcessors.reduce((acc, preProcessor) => {
+      return preProcessor(acc, params);
+    }, value);
+  }, []);
+  const preProcessingApi = {
+    unstable_registerPreProcessor: registerPreProcessor,
+    unstable_applyPreProcessors: applyPreProcessors
+  };
+  (0, _useGridApiMethod.useGridApiMethod)(apiRef, preProcessingApi, 'GridPreProcessing');
+};
+
+exports.useGridPreProcessing = useGridPreProcessing;

package/node/hooks/core/preProcessing/useGridRegisterPreProcessor.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useGridRegisterPreProcessor = void 0;
+
+var React = _interopRequireWildcard(require("react"));
+
+var _useFirstRender = require("../../utils/useFirstRender");
+
+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 useGridRegisterPreProcessor = (apiRef, group, callback) => {
+  const cleanup = React.useRef();
+  const id = React.useRef(`mui-${Math.round(Math.random() * 1e9)}`);
+  const registerPreProcessor = React.useCallback(() => {
+    cleanup.current = apiRef.current.unstable_registerPreProcessor(group, id.current, callback);
+  }, [apiRef, callback, group]);
+  (0, _useFirstRender.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]);
+};
+
+exports.useGridRegisterPreProcessor = useGridRegisterPreProcessor;

package/node/hooks/core/rowGroupsPreProcessing/gridRowGroupsPreProcessingApi.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/node/hooks/core/rowGroupsPreProcessing/index.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _useGridRowGroupsPreProcessing = require("./useGridRowGroupsPreProcessing");
+
+Object.keys(_useGridRowGroupsPreProcessing).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _useGridRowGroupsPreProcessing[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _useGridRowGroupsPreProcessing[key];
+    }
+  });
+});
+
+var _gridRowGroupsPreProcessingApi = require("./gridRowGroupsPreProcessingApi");
+
+Object.keys(_gridRowGroupsPreProcessingApi).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _gridRowGroupsPreProcessingApi[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _gridRowGroupsPreProcessingApi[key];
+    }
+  });
+});

package/node/hooks/core/rowGroupsPreProcessing/useGridRowGroupsPreProcessing.js

@@ -0,0 +1,87 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useGridRowGroupsPreProcessing = void 0;
+
+var React = _interopRequireWildcard(require("react"));
+
+var _events = require("../../../models/events");
+
+var _useGridApiMethod = require("../../utils/useGridApiMethod");
+
+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 getFlatRowTree = ({
+  ids,
+  idRowsLookup,
+  previousTree
+}) => {
+  const tree = {};
+
+  for (let i = 0; i < ids.length; i += 1) {
+    const rowId = ids[i];
+
+    if (previousTree && previousTree[rowId]) {
+      tree[rowId] = previousTree[rowId];
+    } else {
+      tree[rowId] = {
+        id: rowId,
+        depth: 0,
+        parent: null,
+        groupingKey: '',
+        groupingField: null
+      };
+    }
+  }
+
+  return {
+    groupingName: 'none',
+    tree,
+    treeDepth: 1,
+    idRowsLookup,
+    ids
+  };
+};
+
+const useGridRowGroupsPreProcessing = apiRef => {
+  const rowGroupsPreProcessingRef = React.useRef(new Map());
+  const registerRowGroupsBuilder = React.useCallback((processingName, rowGroupingPreProcessing) => {
+    var _rowGroupsPreProcessi;
+
+    const rowGroupingPreProcessingBefore = (_rowGroupsPreProcessi = rowGroupsPreProcessingRef.current.get(processingName)) != null ? _rowGroupsPreProcessi : null;
+
+    if (rowGroupingPreProcessingBefore !== rowGroupingPreProcessing) {
+      rowGroupsPreProcessingRef.current.set(processingName, rowGroupingPreProcessing);
+      apiRef.current.publishEvent(_events.GridEvents.rowGroupsPreProcessingChange);
+    }
+  }, [apiRef]);
+  const groupRows = React.useCallback((...params) => {
+    let response = null;
+    const preProcessingList = Array.from(rowGroupsPreProcessingRef.current.values());
+
+    while (!response && preProcessingList.length) {
+      const preProcessing = preProcessingList.shift();
+
+      if (preProcessing) {
+        response = preProcessing(...params);
+      }
+    }
+
+    if (!response) {
+      return getFlatRowTree(...params);
+    }
+
+    return response;
+  }, []);
+  const rowGroupsPreProcessingApi = {
+    unstable_registerRowGroupsBuilder: registerRowGroupsBuilder,
+    unstable_groupRows: groupRows
+  };
+  (0, _useGridApiMethod.useGridApiMethod)(apiRef, rowGroupsPreProcessingApi, 'GridRowGroupsPreProcessing');
+};
+
+exports.useGridRowGroupsPreProcessing = useGridRowGroupsPreProcessing;

package/node/hooks/core/useGridApiInitialization.js

@@ -0,0 +1,76 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useGridApiInitialization = useGridApiInitialization;
+
+var React = _interopRequireWildcard(require("react"));
+
+var _events = require("../../models/events");
+
+var _useGridApiMethod = require("../utils/useGridApiMethod");
+
+var _useGridApiEventHandler = require("../utils/useGridApiEventHandler");
+
+var _EventManager = require("../../utils/EventManager");
+
+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 isSyntheticEvent = event => {
+  return event.isPropagationStopped !== undefined;
+};
+
+let globalId = 0;
+
+function useGridApiInitialization(inputApiRef, props) {
+  const apiRef = React.useRef();
+
+  if (!apiRef.current) {
+    apiRef.current = {
+      unstable_eventManager: new _EventManager.EventManager(),
+      state: {},
+      instanceId: globalId
+    };
+    globalId += 1;
+  }
+
+  React.useImperativeHandle(inputApiRef, () => apiRef.current, [apiRef]);
+  const publishEvent = React.useCallback((...args) => {
+    const [name, params, event = {}] = args;
+    event.defaultMuiPrevented = false;
+
+    if (isSyntheticEvent(event) && event.isPropagationStopped()) {
+      return;
+    }
+
+    const details = props.signature === _useGridApiEventHandler.GridSignature.DataGridPro ? {
+      api: apiRef.current
+    } : {};
+    apiRef.current.unstable_eventManager.emit(name, params, event, details);
+  }, [apiRef, props.signature]);
+  const subscribeEvent = React.useCallback((event, handler, options) => {
+    apiRef.current.unstable_eventManager.on(event, handler, options);
+    const api = apiRef.current;
+    return () => {
+      api.unstable_eventManager.removeListener(event, handler);
+    };
+  }, [apiRef]);
+  const showError = React.useCallback(args => {
+    apiRef.current.publishEvent(_events.GridEvents.componentError, args);
+  }, [apiRef]);
+  (0, _useGridApiMethod.useGridApiMethod)(apiRef, {
+    subscribeEvent,
+    publishEvent,
+    showError
+  }, 'GridCoreApi');
+  React.useEffect(() => {
+    const api = apiRef.current;
+    return () => {
+      api.publishEvent(_events.GridEvents.unmount);
+    };
+  }, [apiRef]);
+  return apiRef;
+}

package/node/hooks/core/useGridErrorHandler.js

@@ -0,0 +1,33 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useGridErrorHandler = useGridErrorHandler;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var React = _interopRequireWildcard(require("react"));
+
+var _events = require("../../models/events");
+
+var _useGridApiEventHandler = require("../utils/useGridApiEventHandler");
+
+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 useGridErrorHandler(apiRef, props) {
+  const handleError = React.useCallback(args => {
+    // We are handling error here, to set up the handler as early as possible and be able to catch error thrown at init time.
+    apiRef.current.setState(state => (0, _extends2.default)({}, state, {
+      error: args
+    }));
+  }, [apiRef]);
+  React.useEffect(() => {
+    handleError(props.error);
+  }, [handleError, props.error]);
+  (0, _useGridApiEventHandler.useGridApiEventHandler)(apiRef, _events.GridEvents.componentError, handleError);
+}

package/node/hooks/core/useGridInitialization.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useGridInitialization = void 0;
+
+var _useGridLoggerFactory = require("./useGridLoggerFactory");
+
+var _useGridApiInitialization = require("./useGridApiInitialization");
+
+var _useGridErrorHandler = require("./useGridErrorHandler");
+
+var _useGridLocaleText = require("./useGridLocaleText");
+
+var _preProcessing = require("./preProcessing");
+
+var _rowGroupsPreProcessing = require("./rowGroupsPreProcessing");
+
+var _useGridStateInitialization = require("./useGridStateInitialization");
+
+/**
+ * Initialize the technical pieces of the DataGrid (logger, state, ...) that any DataGrid implementation needs
+ */
+const useGridInitialization = (inputApiRef, props) => {
+  const apiRef = (0, _useGridApiInitialization.useGridApiInitialization)(inputApiRef, props);
+  (0, _useGridLoggerFactory.useGridLoggerFactory)(apiRef, props);
+  (0, _useGridErrorHandler.useGridErrorHandler)(apiRef, props);
+  (0, _useGridStateInitialization.useGridStateInitialization)(apiRef, props);
+  (0, _preProcessing.useGridPreProcessing)(apiRef);
+  (0, _rowGroupsPreProcessing.useGridRowGroupsPreProcessing)(apiRef);
+  (0, _useGridLocaleText.useGridLocaleText)(apiRef, props);
+  return apiRef;
+};
+
+exports.useGridInitialization = useGridInitialization;

package/node/hooks/core/useGridLocaleText.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useGridLocaleText = void 0;
+
+var React = _interopRequireWildcard(require("react"));
+
+var _useGridApiMethod = require("../utils/useGridApiMethod");
+
+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 useGridLocaleText = (apiRef, props) => {
+  const getLocaleText = React.useCallback(key => {
+    if (props.localeText[key] == null) {
+      throw new Error(`Missing translation for key ${key}.`);
+    }
+
+    return props.localeText[key];
+  }, [props.localeText]);
+  const localeTextApi = {
+    getLocaleText
+  };
+  (0, _useGridApiMethod.useGridApiMethod)(apiRef, localeTextApi, 'LocaleTextApi');
+};
+
+exports.useGridLocaleText = useGridLocaleText;

package/node/hooks/core/useGridLoggerFactory.js

@@ -0,0 +1,64 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useGridLoggerFactory = void 0;
+
+var React = _interopRequireWildcard(require("react"));
+
+var _utils = require("../../utils/utils");
+
+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 forceDebug = (0, _utils.localStorageAvailable)() && window.localStorage.getItem('DEBUG') != null;
+
+const noop = () => {};
+
+const noopLogger = {
+  debug: noop,
+  info: noop,
+  warn: noop,
+  error: noop
+};
+const LOG_LEVELS = ['debug', 'info', 'warn', 'error'];
+
+function getAppender(name, logLevel, appender = console) {
+  const minLogLevelIdx = LOG_LEVELS.indexOf(logLevel);
+
+  if (minLogLevelIdx === -1) {
+    throw new Error(`MUI: Log level ${logLevel} not recognized.`);
+  }
+
+  const logger = LOG_LEVELS.reduce((loggerObj, method, idx) => {
+    if (idx >= minLogLevelIdx) {
+      loggerObj[method] = (...args) => {
+        const [message, ...other] = args;
+        appender[method](`MUI: ${name} - ${message}`, ...other);
+      };
+    } else {
+      loggerObj[method] = noop;
+    }
+
+    return loggerObj;
+  }, {});
+  return logger;
+}
+
+const useGridLoggerFactory = (apiRef, props) => {
+  apiRef.current.getLogger = React.useCallback(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]);
+};
+
+exports.useGridLoggerFactory = useGridLoggerFactory;

package/node/hooks/core/useGridStateInitialization.js

@@ -0,0 +1,124 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useGridStateInitialization = void 0;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
+
+var React = _interopRequireWildcard(require("react"));
+
+var _useGridApiEventHandler = require("../utils/useGridApiEventHandler");
+
+var _events = require("../../models/events");
+
+var _utils = require("../utils");
+
+var _utils2 = require("../../utils/utils");
+
+const _excluded = ["stateId"];
+
+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 useGridStateInitialization = (apiRef, props) => {
+  const controlStateMapRef = React.useRef({});
+  const [, rawForceUpdate] = React.useState();
+  const updateControlState = React.useCallback(controlStateItem => {
+    const {
+      stateId
+    } = controlStateItem,
+          others = (0, _objectWithoutPropertiesLoose2.default)(controlStateItem, _excluded);
+    controlStateMapRef.current[stateId] = (0, _extends2.default)({}, others, {
+      stateId
+    });
+  }, []);
+  const setState = React.useCallback(state => {
+    let newState;
+
+    if ((0, _utils2.isFunction)(state)) {
+      newState = state(apiRef.current.state);
+    } else {
+      newState = state;
+    }
+
+    if (apiRef.current.state === newState) {
+      return false;
+    }
+
+    let ignoreSetState = false; // Apply the control state constraints
+
+    const updatedControlStateIds = [];
+    Object.keys(controlStateMapRef.current).forEach(stateId => {
+      const controlState = controlStateMapRef.current[stateId];
+      const oldSubState = controlState.stateSelector(apiRef.current.state, apiRef.current.instanceId);
+      const 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 ${updatedControlStateIds[0].stateId}, therefore, you're not allowed to update ${updatedControlStateIds.map(el => 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(_events.GridEvents.stateChange, newState);
+      }
+    }
+
+    if (updatedControlStateIds.length === 1) {
+      const {
+        stateId,
+        hasPropChanged
+      } = updatedControlStateIds[0];
+      const controlState = controlStateMapRef.current[stateId];
+      const model = controlState.stateSelector(newState, apiRef.current.instanceId);
+
+      if (controlState.propOnChange && hasPropChanged) {
+        const details = props.signature === _useGridApiEventHandler.GridSignature.DataGridPro ? {
+          api: apiRef.current
+        } : {};
+        controlState.propOnChange(model, details);
+      }
+
+      if (!ignoreSetState) {
+        apiRef.current.publishEvent(controlState.changeEvent, model);
+      }
+    }
+
+    return !ignoreSetState;
+  }, [apiRef, props.signature]);
+  const forceUpdate = React.useCallback(() => rawForceUpdate(() => apiRef.current.state), [apiRef]);
+  const stateApi = {
+    setState,
+    forceUpdate,
+    unstable_updateControlState: updateControlState
+  };
+  (0, _utils.useGridApiMethod)(apiRef, stateApi, 'GridStateApi');
+};
+
+exports.useGridStateInitialization = useGridStateInitialization;