wip:milestone 0 fixes

control-plane-ui/node_modules/@mui/x-data-grid/node/hooks/utils/index.js

@@ -0,0 +1,75 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  useGridSelector: true
+};
+Object.defineProperty(exports, "useGridSelector", {
+  enumerable: true,
+  get: function () {
+    return _useGridSelector.useGridSelector;
+  }
+});
+var _useGridApiEventHandler = require("./useGridApiEventHandler");
+Object.keys(_useGridApiEventHandler).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _useGridApiEventHandler[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _useGridApiEventHandler[key];
+    }
+  });
+});
+var _useGridApiMethod = require("./useGridApiMethod");
+Object.keys(_useGridApiMethod).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _useGridApiMethod[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _useGridApiMethod[key];
+    }
+  });
+});
+var _useGridLogger = require("./useGridLogger");
+Object.keys(_useGridLogger).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _useGridLogger[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _useGridLogger[key];
+    }
+  });
+});
+var _useGridSelector = require("./useGridSelector");
+var _useGridNativeEventListener = require("./useGridNativeEventListener");
+Object.keys(_useGridNativeEventListener).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _useGridNativeEventListener[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _useGridNativeEventListener[key];
+    }
+  });
+});
+var _useFirstRender = require("./useFirstRender");
+Object.keys(_useFirstRender).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _useFirstRender[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _useFirstRender[key];
+    }
+  });
+});

control-plane-ui/node_modules/@mui/x-data-grid/node/hooks/utils/useFirstRender.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useFirstRender = void 0;
+var React = _interopRequireWildcard(require("react"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+const useFirstRender = callback => {
+  const isFirstRender = React.useRef(true);
+  if (isFirstRender.current) {
+    isFirstRender.current = false;
+    callback();
+  }
+};
+exports.useFirstRender = useFirstRender;

control-plane-ui/node_modules/@mui/x-data-grid/node/hooks/utils/useGridApiContext.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useGridApiContext = useGridApiContext;
+var React = _interopRequireWildcard(require("react"));
+var _GridApiContext = require("../../components/GridApiContext");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function useGridApiContext() {
+  const apiRef = React.useContext(_GridApiContext.GridApiContext);
+  if (apiRef === undefined) {
+    throw new Error(['MUI: Could not find the data grid context.', 'It looks like you rendered your component outside of a DataGrid, DataGridPro or DataGridPremium parent component.', 'This can also happen if you are bundling multiple versions of the data grid.'].join('\n'));
+  }
+  return apiRef;
+}

control-plane-ui/node_modules/@mui/x-data-grid/node/hooks/utils/useGridApiEventHandler.js

@@ -0,0 +1,106 @@
+"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(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+/**
+ * Signal to the underlying logic what version of the public component API
+ * of the data grid is exposed.
+ */
+var GridSignature = exports.GridSignature = /*#__PURE__*/function (GridSignature) {
+  GridSignature["DataGrid"] = "DataGrid";
+  GridSignature["DataGridPro"] = "DataGridPro";
+  return GridSignature;
+}(GridSignature || {});
+// We use class to make it easier to detect in heap snapshots by name
+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(registryContainer) {
+  let cleanupTokensCounter = 0;
+  return function useGridApiEventHandler(apiRef, eventName, handler, options) {
+    if (registryContainer.registry === null) {
+      registryContainer.registry = typeof FinalizationRegistry !== 'undefined' ? new _FinalizationRegistryBasedCleanupTracking.FinalizationRegistryBasedCleanupTracking() : new _TimerBasedCleanupTracking.TimerBasedCleanupTracking();
+    }
+    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) {
+          handlerRef.current?.(params, event, details);
+        }
+      };
+      subscription.current = apiRef.current.subscribeEvent(eventName, enhancedHandler, options);
+      cleanupTokensCounter += 1;
+      cleanupTokenRef.current = {
+        cleanupToken: cleanupTokensCounter
+      };
+      registryContainer.registry.register(objectRetainedByReact,
+      // The callback below will be called once this reference stops being retained
+      () => {
+        subscription.current?.();
+        subscription.current = null;
+        cleanupTokenRef.current = null;
+      }, cleanupTokenRef.current);
+    } else if (!handlerRef.current && subscription.current) {
+      subscription.current();
+      subscription.current = null;
+      if (cleanupTokenRef.current) {
+        registryContainer.registry.unregister(cleanupTokenRef.current);
+        cleanupTokenRef.current = null;
+      }
+    }
+    React.useEffect(() => {
+      if (!subscription.current && handlerRef.current) {
+        const enhancedHandler = (params, event, details) => {
+          if (!event.defaultMuiPrevented) {
+            handlerRef.current?.(params, event, details);
+          }
+        };
+        subscription.current = apiRef.current.subscribeEvent(eventName, enhancedHandler, options);
+      }
+      if (cleanupTokenRef.current && registryContainer.registry) {
+        // If the effect was called, it means that this render was committed
+        // so we can trust the cleanup function to remove the listener.
+        registryContainer.registry.unregister(cleanupTokenRef.current);
+        cleanupTokenRef.current = null;
+      }
+      return () => {
+        subscription.current?.();
+        subscription.current = null;
+      };
+    }, [apiRef, eventName, options]);
+  };
+}
+const registryContainer = {
+  registry: null
+};
+
+// TODO: move to @mui/x-data-grid/internals
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const unstable_resetCleanupTracking = () => {
+  registryContainer.registry?.reset();
+  registryContainer.registry = null;
+};
+exports.unstable_resetCleanupTracking = unstable_resetCleanupTracking;
+const useGridApiEventHandler = exports.useGridApiEventHandler = createUseGridApiEventHandler(registryContainer);
+const optionsSubscriberOptions = {
+  isFirst: true
+};
+function useGridApiOptionHandler(apiRef, eventName, handler) {
+  // Validate that only one per event name?
+  useGridApiEventHandler(apiRef, eventName, handler, optionsSubscriberOptions);
+}

control-plane-ui/node_modules/@mui/x-data-grid/node/hooks/utils/useGridApiMethod.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useGridApiMethod = useGridApiMethod;
+var React = _interopRequireWildcard(require("react"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function useGridApiMethod(privateApiRef, apiMethods, visibility) {
+  const isFirstRender = React.useRef(true);
+  React.useEffect(() => {
+    isFirstRender.current = false;
+    privateApiRef.current.register(visibility, apiMethods);
+  }, [privateApiRef, visibility, apiMethods]);
+  if (isFirstRender.current) {
+    privateApiRef.current.register(visibility, apiMethods);
+  }
+}

control-plane-ui/node_modules/@mui/x-data-grid/node/hooks/utils/useGridApiRef.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useGridApiRef = void 0;
+var React = _interopRequireWildcard(require("react"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+/**
+ * Hook that instantiate a [[GridApiRef]].
+ */
+const useGridApiRef = () => React.useRef({});
+exports.useGridApiRef = useGridApiRef;

control-plane-ui/node_modules/@mui/x-data-grid/node/hooks/utils/useGridAriaAttributes.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useGridAriaAttributes = void 0;
+var _gridColumnsSelector = require("../features/columns/gridColumnsSelector");
+var _useGridSelector = require("./useGridSelector");
+var _useGridRootProps = require("./useGridRootProps");
+var _gridColumnGroupsSelector = require("../features/columnGrouping/gridColumnGroupsSelector");
+var _gridRowsSelector = require("../features/rows/gridRowsSelector");
+var _useGridPrivateApiContext = require("./useGridPrivateApiContext");
+const useGridAriaAttributes = () => {
+  const apiRef = (0, _useGridPrivateApiContext.useGridPrivateApiContext)();
+  const rootProps = (0, _useGridRootProps.useGridRootProps)();
+  const visibleColumns = (0, _useGridSelector.useGridSelector)(apiRef, _gridColumnsSelector.gridVisibleColumnDefinitionsSelector);
+  const totalRowCount = (0, _useGridSelector.useGridSelector)(apiRef, _gridRowsSelector.gridRowCountSelector);
+  const headerGroupingMaxDepth = (0, _useGridSelector.useGridSelector)(apiRef, _gridColumnGroupsSelector.gridColumnGroupsHeaderMaxDepthSelector);
+  const pinnedRowsCount = (0, _useGridSelector.useGridSelector)(apiRef, _gridRowsSelector.gridPinnedRowsCountSelector);
+  let role = 'grid';
+  if (rootProps.experimentalFeatures?.ariaV7 && rootProps.treeData) {
+    role = 'treegrid';
+  }
+  return {
+    role,
+    'aria-colcount': visibleColumns.length,
+    'aria-rowcount': headerGroupingMaxDepth + 1 + pinnedRowsCount + totalRowCount,
+    'aria-multiselectable': !rootProps.disableMultipleRowSelection
+  };
+};
+exports.useGridAriaAttributes = useGridAriaAttributes;

control-plane-ui/node_modules/@mui/x-data-grid/node/hooks/utils/useGridInitializeState.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useGridInitializeState = void 0;
+var React = _interopRequireWildcard(require("react"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+const useGridInitializeState = (initializer, privateApiRef, props) => {
+  const isInitialized = React.useRef(false);
+  if (!isInitialized.current) {
+    privateApiRef.current.state = initializer(privateApiRef.current.state, props, privateApiRef);
+    isInitialized.current = true;
+  }
+};
+exports.useGridInitializeState = useGridInitializeState;

control-plane-ui/node_modules/@mui/x-data-grid/node/hooks/utils/useGridLogger.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useGridLogger = useGridLogger;
+var React = _interopRequireWildcard(require("react"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function useGridLogger(privateApiRef, name) {
+  const logger = React.useRef(null);
+  if (logger.current) {
+    return logger.current;
+  }
+  const newLogger = privateApiRef.current.getLogger(name);
+  logger.current = newLogger;
+  return newLogger;
+}

control-plane-ui/node_modules/@mui/x-data-grid/node/hooks/utils/useGridNativeEventListener.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useGridNativeEventListener = void 0;
+var React = _interopRequireWildcard(require("react"));
+var _utils = require("../../utils/utils");
+var _useGridLogger = require("./useGridLogger");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+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(event => {
+    return handlerRef.current && handlerRef.current(event);
+  }, []);
+  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 && 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('unmount', unsubscribe);
+    }
+  }, [ref, wrapHandler, eventName, added, logger, options, apiRef]);
+};
+exports.useGridNativeEventListener = useGridNativeEventListener;

control-plane-ui/node_modules/@mui/x-data-grid/node/hooks/utils/useGridPrivateApiContext.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.GridPrivateApiContext = void 0;
+exports.useGridPrivateApiContext = useGridPrivateApiContext;
+var React = _interopRequireWildcard(require("react"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+const GridPrivateApiContext = exports.GridPrivateApiContext = /*#__PURE__*/React.createContext(undefined);
+if (process.env.NODE_ENV !== 'production') {
+  GridPrivateApiContext.displayName = 'GridPrivateApiContext';
+}
+function useGridPrivateApiContext() {
+  const privateApiRef = React.useContext(GridPrivateApiContext);
+  if (privateApiRef === undefined) {
+    throw new Error(['MUI: Could not find the data grid private context.', 'It looks like you rendered your component outside of a DataGrid, DataGridPro or DataGridPremium parent component.', 'This can also happen if you are bundling multiple versions of the data grid.'].join('\n'));
+  }
+  return privateApiRef;
+}

control-plane-ui/node_modules/@mui/x-data-grid/node/hooks/utils/useGridRootProps.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useGridRootProps = void 0;
+var React = _interopRequireWildcard(require("react"));
+var _GridRootPropsContext = require("../../context/GridRootPropsContext");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+const useGridRootProps = () => {
+  const contextValue = React.useContext(_GridRootPropsContext.GridRootPropsContext);
+  if (!contextValue) {
+    throw new Error('MUI: useGridRootProps should only be used inside the DataGrid, DataGridPro or DataGridPremium component.');
+  }
+  return contextValue;
+};
+exports.useGridRootProps = useGridRootProps;

control-plane-ui/node_modules/@mui/x-data-grid/node/hooks/utils/useGridSelector.js

@@ -0,0 +1,56 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useGridSelector = exports.objectShallowCompare = void 0;
+var React = _interopRequireWildcard(require("react"));
+var _useLazyRef = require("./useLazyRef");
+var _useOnMount = require("./useOnMount");
+var _warning = require("../../utils/warning");
+var _fastObjectShallowCompare = require("../../utils/fastObjectShallowCompare");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+const stateNotInitializedWarning = (0, _warning.buildWarning)(['MUI: `useGridSelector` has been called before the initialization of the state.', 'This hook can only be used inside the context of the grid.']);
+function isOutputSelector(selector) {
+  return selector.acceptsApiRef;
+}
+function applySelector(apiRef, selector) {
+  if (isOutputSelector(selector)) {
+    return selector(apiRef);
+  }
+  return selector(apiRef.current.state);
+}
+const defaultCompare = Object.is;
+const objectShallowCompare = exports.objectShallowCompare = _fastObjectShallowCompare.fastObjectShallowCompare;
+const createRefs = () => ({
+  state: null,
+  equals: null,
+  selector: null
+});
+const useGridSelector = (apiRef, selector, equals = defaultCompare) => {
+  if (process.env.NODE_ENV !== 'production') {
+    if (!apiRef.current.state) {
+      stateNotInitializedWarning();
+    }
+  }
+  const refs = (0, _useLazyRef.useLazyRef)(createRefs);
+  const didInit = refs.current.selector !== null;
+  const [state, setState] = React.useState(
+  // We don't use an initialization function to avoid allocations
+  didInit ? null : applySelector(apiRef, selector));
+  refs.current.state = state;
+  refs.current.equals = equals;
+  refs.current.selector = selector;
+  (0, _useOnMount.useOnMount)(() => {
+    return apiRef.current.store.subscribe(() => {
+      const newState = applySelector(apiRef, refs.current.selector);
+      if (!refs.current.equals(refs.current.state, newState)) {
+        refs.current.state = newState;
+        setState(newState);
+      }
+    });
+  });
+  return state;
+};
+exports.useGridSelector = useGridSelector;

control-plane-ui/node_modules/@mui/x-data-grid/node/hooks/utils/useGridVisibleRows.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useGridVisibleRows = exports.getVisibleRows = void 0;
+var React = _interopRequireWildcard(require("react"));
+var _gridPaginationSelector = require("../features/pagination/gridPaginationSelector");
+var _gridFilterSelector = require("../features/filter/gridFilterSelector");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+const getVisibleRows = (apiRef, props) => {
+  let rows;
+  let range;
+  if (props.pagination && props.paginationMode === 'client') {
+    range = (0, _gridPaginationSelector.gridPaginationRowRangeSelector)(apiRef);
+    rows = (0, _gridPaginationSelector.gridPaginatedVisibleSortedGridRowEntriesSelector)(apiRef);
+  } else {
+    rows = (0, _gridFilterSelector.gridExpandedSortedRowEntriesSelector)(apiRef);
+    if (rows.length === 0) {
+      range = null;
+    } else {
+      range = {
+        firstRowIndex: 0,
+        lastRowIndex: rows.length - 1
+      };
+    }
+  }
+  return {
+    rows,
+    range
+  };
+};
+
+/**
+ * Computes the list of rows that are reachable by scroll.
+ * Depending on whether pagination is enabled, it will return the rows in the current page.
+ * - If the pagination is disabled or in server mode, it equals all the visible rows.
+ * - If the row tree has several layers, it contains up to `state.pageSize` top level rows and all their descendants.
+ * - If the row tree is flat, it only contains up to `state.pageSize` rows.
+ */
+exports.getVisibleRows = getVisibleRows;
+const useGridVisibleRows = (apiRef, props) => {
+  const response = getVisibleRows(apiRef, props);
+  return React.useMemo(() => ({
+    rows: response.rows,
+    range: response.range
+  }), [response.rows, response.range]);
+};
+exports.useGridVisibleRows = useGridVisibleRows;

control-plane-ui/node_modules/@mui/x-data-grid/node/hooks/utils/useLazyRef.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useLazyRef = useLazyRef;
+var React = _interopRequireWildcard(require("react"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+const UNINITIALIZED = {};
+
+// See https://github.com/facebook/react/issues/14490 for when to use this.
+function useLazyRef(init, initArg) {
+  const ref = React.useRef(UNINITIALIZED);
+  if (ref.current === UNINITIALIZED) {
+    ref.current = init(initArg);
+  }
+  return ref;
+}

control-plane-ui/node_modules/@mui/x-data-grid/node/hooks/utils/useOnMount.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useOnMount = useOnMount;
+var React = _interopRequireWildcard(require("react"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+const EMPTY = [];
+function useOnMount(fn) {
+  /* eslint-disable react-hooks/exhaustive-deps */
+  React.useEffect(fn, EMPTY);
+  /* eslint-enable react-hooks/exhaustive-deps */
+}

control-plane-ui/node_modules/@mui/x-data-grid/node/hooks/utils/useTimeout.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useTimeout = useTimeout;
+var _useLazyRef = require("./useLazyRef");
+var _useOnMount = require("./useOnMount");
+class Timeout {
+  constructor() {
+    this.currentId = 0;
+    this.clear = () => {
+      if (this.currentId !== 0) {
+        clearTimeout(this.currentId);
+        this.currentId = 0;
+      }
+    };
+    this.disposeEffect = () => {
+      return this.clear;
+    };
+  }
+  static create() {
+    return new Timeout();
+  }
+  start(delay, fn) {
+    this.clear();
+    this.currentId = setTimeout(fn, delay);
+  }
+}
+function useTimeout() {
+  const timeout = (0, _useLazyRef.useLazyRef)(Timeout.create).current;
+  (0, _useOnMount.useOnMount)(timeout.disposeEffect);
+  return timeout;
+}