@mui/x-data-grid 8.0.0-alpha.9 → 8.0.0-beta.0

package/esm/utils/domUtils.js

@@ -0,0 +1,204 @@
+import { gridClasses } from "../constants/gridClasses.js";
+export function isOverflown(element) {
+  return element.scrollHeight > element.clientHeight || element.scrollWidth > element.clientWidth;
+}
+export function findParentElementFromClassName(elem, className) {
+  return elem.closest(`.${className}`);
+}
+
+// TODO, eventually replaces this function with CSS.escape, once available in jsdom, either added manually or built in
+// https://github.com/jsdom/jsdom/issues/1550#issuecomment-236734471
+export function escapeOperandAttributeSelector(operand) {
+  return operand.replace(/["\\]/g, '\\$&');
+}
+export function getGridColumnHeaderElement(root, field) {
+  return root.querySelector(`[role="columnheader"][data-field="${escapeOperandAttributeSelector(field)}"]`);
+}
+function getGridRowElementSelector(id) {
+  return `.${gridClasses.row}[data-id="${escapeOperandAttributeSelector(String(id))}"]`;
+}
+export function getGridRowElement(root, id) {
+  return root.querySelector(getGridRowElementSelector(id));
+}
+export function getGridCellElement(root, {
+  id,
+  field
+}) {
+  const rowSelector = getGridRowElementSelector(id);
+  const cellSelector = `.${gridClasses.cell}[data-field="${escapeOperandAttributeSelector(field)}"]`;
+  const selector = `${rowSelector} ${cellSelector}`;
+  return root.querySelector(selector);
+}
+
+// https://www.abeautifulsite.net/posts/finding-the-active-element-in-a-shadow-root/
+export const getActiveElement = (root = document) => {
+  const activeEl = root.activeElement;
+  if (!activeEl) {
+    return null;
+  }
+  if (activeEl.shadowRoot) {
+    return getActiveElement(activeEl.shadowRoot);
+  }
+  return activeEl;
+};
+export function isEventTargetInPortal(event) {
+  if (
+  // The target is not an element when triggered by a Select inside the cell
+  // See https://github.com/mui/material-ui/issues/10534
+  event.target.nodeType === 1 && !event.currentTarget.contains(event.target)) {
+    return true;
+  }
+  return false;
+}
+export function getFieldFromHeaderElem(colCellEl) {
+  return colCellEl.getAttribute('data-field');
+}
+export function findHeaderElementFromField(elem, field) {
+  return elem.querySelector(`[data-field="${escapeOperandAttributeSelector(field)}"]`);
+}
+export function getFieldsFromGroupHeaderElem(colCellEl) {
+  return colCellEl.getAttribute('data-fields').slice(2, -2).split('-|-');
+}
+export function findGroupHeaderElementsFromField(elem, field) {
+  return Array.from(elem.querySelectorAll(`[data-fields*="|-${escapeOperandAttributeSelector(field)}-|"]`) ?? []);
+}
+export function findGridCellElementsFromCol(col, api) {
+  const root = findParentElementFromClassName(col, gridClasses.root);
+  if (!root) {
+    throw new Error('MUI X: The root element is not found.');
+  }
+  const ariaColIndex = col.getAttribute('aria-colindex');
+  if (!ariaColIndex) {
+    return [];
+  }
+  const colIndex = Number(ariaColIndex) - 1;
+  const cells = [];
+  if (!api.virtualScrollerRef?.current) {
+    return [];
+  }
+  queryRows(api).forEach(rowElement => {
+    const rowId = rowElement.getAttribute('data-id');
+    if (!rowId) {
+      return;
+    }
+    let columnIndex = colIndex;
+    const cellColSpanInfo = api.unstable_getCellColSpanInfo(rowId, colIndex);
+    if (cellColSpanInfo && cellColSpanInfo.spannedByColSpan) {
+      columnIndex = cellColSpanInfo.leftVisibleCellIndex;
+    }
+    const cell = rowElement.querySelector(`[data-colindex="${columnIndex}"]`);
+    if (cell) {
+      cells.push(cell);
+    }
+  });
+  return cells;
+}
+export function findGridElement(api, klass) {
+  return api.rootElementRef.current.querySelector(`.${gridClasses[klass]}`);
+}
+const findPinnedCells = ({
+  api,
+  colIndex,
+  position,
+  filterFn
+}) => {
+  if (colIndex === null) {
+    return [];
+  }
+  const cells = [];
+  queryRows(api).forEach(rowElement => {
+    const rowId = rowElement.getAttribute('data-id');
+    if (!rowId) {
+      return;
+    }
+    rowElement.querySelectorAll(`.${gridClasses[position === 'left' ? 'cell--pinnedLeft' : 'cell--pinnedRight']}`).forEach(cell => {
+      const currentColIndex = parseCellColIndex(cell);
+      if (currentColIndex !== null && filterFn(currentColIndex)) {
+        cells.push(cell);
+      }
+    });
+  });
+  return cells;
+};
+export function findLeftPinnedCellsAfterCol(api, col, isRtl) {
+  const colIndex = parseCellColIndex(col);
+  return findPinnedCells({
+    api,
+    colIndex,
+    position: isRtl ? 'right' : 'left',
+    filterFn: index => isRtl ? index < colIndex : index > colIndex
+  });
+}
+export function findRightPinnedCellsBeforeCol(api, col, isRtl) {
+  const colIndex = parseCellColIndex(col);
+  return findPinnedCells({
+    api,
+    colIndex,
+    position: isRtl ? 'left' : 'right',
+    filterFn: index => isRtl ? index > colIndex : index < colIndex
+  });
+}
+const findPinnedHeaders = ({
+  api,
+  colIndex,
+  position,
+  filterFn
+}) => {
+  if (!api.columnHeadersContainerRef?.current) {
+    return [];
+  }
+  if (colIndex === null) {
+    return [];
+  }
+  const elements = [];
+  api.columnHeadersContainerRef.current.querySelectorAll(`.${gridClasses[position === 'left' ? 'columnHeader--pinnedLeft' : 'columnHeader--pinnedRight']}`).forEach(element => {
+    const currentColIndex = parseCellColIndex(element);
+    if (currentColIndex !== null && filterFn(currentColIndex, element)) {
+      elements.push(element);
+    }
+  });
+  return elements;
+};
+export function findLeftPinnedHeadersAfterCol(api, col, isRtl) {
+  const colIndex = parseCellColIndex(col);
+  return findPinnedHeaders({
+    api,
+    position: isRtl ? 'right' : 'left',
+    colIndex,
+    filterFn: index => isRtl ? index < colIndex : index > colIndex
+  });
+}
+export function findRightPinnedHeadersBeforeCol(api, col, isRtl) {
+  const colIndex = parseCellColIndex(col);
+  return findPinnedHeaders({
+    api,
+    position: isRtl ? 'left' : 'right',
+    colIndex,
+    filterFn: (index, element) => {
+      if (element.classList.contains(gridClasses['columnHeader--last'])) {
+        return false;
+      }
+      return isRtl ? index > colIndex : index < colIndex;
+    }
+  });
+}
+export function findGridHeader(api, field) {
+  const headers = api.columnHeadersContainerRef.current;
+  return headers.querySelector(`:scope > div > [data-field="${escapeOperandAttributeSelector(field)}"][role="columnheader"]`);
+}
+export function findGridCells(api, field) {
+  const container = api.virtualScrollerRef.current;
+  return Array.from(container.querySelectorAll(`:scope > div > div > div > [data-field="${escapeOperandAttributeSelector(field)}"][role="gridcell"]`));
+}
+function queryRows(api) {
+  return api.virtualScrollerRef.current.querySelectorAll(
+  // Use > to ignore rows from nested Data Grids (for example in detail panel)
+  `:scope > div > div > .${gridClasses.row}`);
+}
+function parseCellColIndex(col) {
+  const ariaColIndex = col.getAttribute('aria-colindex');
+  if (!ariaColIndex) {
+    return null;
+  }
+  return Number(ariaColIndex) - 1;
+}

package/esm/utils/exportAs.d.ts

@@ -0,0 +1,12 @@
+import { GridExportExtension } from "../models/gridExport.js";
+/**
+ * I have hesitated to use https://github.com/eligrey/FileSaver.js.
+ * If we get bug reports that this project solves, we should consider using it.
+ *
+ * Related resources.
+ * https://blog.logrocket.com/programmatic-file-downloads-in-the-browser-9a5186298d5c/
+ * https://github.com/mbrn/filefy/blob/ec4ed0b7415d93be7158c23029f2ea1fa0b8e2d9/src/core/BaseBuilder.ts
+ * https://unpkg.com/browse/@progress/kendo-file-saver@1.0.7/dist/es/save-as.js
+ * https://github.com/ag-grid/ag-grid/blob/9565c219b6210aa85fa833c929d0728f9d163a91/community-modules/csv-export/src/csvExport/downloader.ts
+ */
+export declare function exportAs<ExtraExtensions extends string>(blob: Blob, extension?: GridExportExtension | ExtraExtensions, filename?: string): void;

package/esm/utils/exportAs.js

@@ -0,0 +1,38 @@
+/**
+ * I have hesitated to use https://github.com/eligrey/FileSaver.js.
+ * If we get bug reports that this project solves, we should consider using it.
+ *
+ * Related resources.
+ * https://blog.logrocket.com/programmatic-file-downloads-in-the-browser-9a5186298d5c/
+ * https://github.com/mbrn/filefy/blob/ec4ed0b7415d93be7158c23029f2ea1fa0b8e2d9/src/core/BaseBuilder.ts
+ * https://unpkg.com/browse/@progress/kendo-file-saver@1.0.7/dist/es/save-as.js
+ * https://github.com/ag-grid/ag-grid/blob/9565c219b6210aa85fa833c929d0728f9d163a91/community-modules/csv-export/src/csvExport/downloader.ts
+ */
+
+export function exportAs(blob, extension = 'csv', filename = document.title || 'untitled') {
+  const fullName = `${filename}.${extension}`;
+
+  // Test download attribute first
+  // https://github.com/eligrey/FileSaver.js/issues/193
+  if ('download' in HTMLAnchorElement.prototype) {
+    // Create an object URL for the blob object
+    const url = URL.createObjectURL(blob);
+
+    // Create a new anchor element
+    const a = document.createElement('a');
+    a.href = url;
+    a.download = fullName;
+
+    // Programmatically trigger a click on the anchor element
+    // Useful if you want the download to happen automatically
+    // Without attaching the anchor element to the DOM
+    a.click();
+
+    // https://github.com/eligrey/FileSaver.js/issues/205
+    setTimeout(() => {
+      URL.revokeObjectURL(url);
+    });
+    return;
+  }
+  throw new Error('MUI X: exportAs not supported.');
+}

package/esm/utils/getGridLocalization.d.ts

@@ -0,0 +1,11 @@
+import type { GridLocaleText } from '../models/api/gridLocaleTextApi';
+export interface Localization {
+  components: {
+    MuiDataGrid: {
+      defaultProps: {
+        localeText: Partial<GridLocaleText>;
+      };
+    };
+  };
+}
+export declare const getGridLocalization: (gridTranslations: Partial<GridLocaleText>) => Localization;

package/esm/utils/getGridLocalization.js

@@ -0,0 +1,9 @@
+export const getGridLocalization = gridTranslations => ({
+  components: {
+    MuiDataGrid: {
+      defaultProps: {
+        localeText: gridTranslations
+      }
+    }
+  }
+});

package/esm/utils/getPublicApiRef.d.ts

@@ -0,0 +1,3 @@
+import { RefObject } from '@mui/x-internals/types';
+import type { GridPrivateApiCommunity } from '../models/api/gridApiCommunity';
+export declare function getPublicApiRef<PrivateApi extends GridPrivateApiCommunity>(apiRef: RefObject<PrivateApi>): RefObject<ReturnType<PrivateApi["getPublicApi"]>>;

package/esm/utils/getPublicApiRef.js

@@ -0,0 +1,5 @@
+export function getPublicApiRef(apiRef) {
+  return {
+    current: apiRef.current.getPublicApi()
+  };
+}

package/esm/utils/index.d.ts

@@ -0,0 +1,2 @@
+export type { OutputSelector } from './createSelector';
+export { GridPortalWrapper } from "./css/context.js";

package/esm/utils/index.js

@@ -0,0 +1 @@
+export { GridPortalWrapper } from "./css/context.js";

package/esm/utils/isJSDOM.d.ts

@@ -0,0 +1 @@
+export declare const isJSDOM: boolean;

package/esm/utils/isJSDOM.js

@@ -0,0 +1 @@
+export const isJSDOM = typeof window !== 'undefined' && /jsdom|HappyDOM/.test(window.navigator.userAgent);

package/esm/utils/keyboardUtils.d.ts

@@ -0,0 +1,14 @@
+import * as React from 'react';
+export declare function isPrintableKey(event: React.KeyboardEvent<HTMLElement>): boolean;
+export declare const GRID_MULTIPLE_SELECTION_KEYS: string[];
+export declare const GRID_CELL_EXIT_EDIT_MODE_KEYS: string[];
+export declare const GRID_CELL_EDIT_COMMIT_KEYS: string[];
+export declare const isMultipleKey: (key: string) => boolean;
+export declare const isCellEnterEditModeKeys: (event: React.KeyboardEvent<HTMLElement>) => boolean;
+export declare const isCellExitEditModeKeys: (key: string) => boolean;
+export declare const isCellEditCommitKeys: (key: string) => boolean;
+export declare const isNavigationKey: (key: string) => boolean;
+export declare const isKeyboardEvent: (event: any) => event is React.KeyboardEvent<HTMLElement>;
+export declare const isHideMenuKey: (key: React.KeyboardEvent["key"]) => key is "Escape" | "Tab";
+export declare function isPasteShortcut(event: React.KeyboardEvent): boolean;
+export declare function isCopyShortcut(event: KeyboardEvent): boolean;

package/esm/utils/keyboardUtils.js

@@ -0,0 +1,37 @@
+// Non printable keys have a name, for example "ArrowRight", see the whole list:
+// https://developer.mozilla.org/en-US/docs/Web/API/UI_Events/Keyboard_event_key_values
+// So event.key.length === 1 is often enough.
+//
+// However, we also need to ignore shortcuts, for example: select all:
+// - Windows: Ctrl+A, event.ctrlKey is true
+// - macOS: ⌘ Command+A, event.metaKey is true
+export function isPrintableKey(event) {
+  return event.key.length === 1 && !event.ctrlKey && !event.metaKey;
+}
+export const GRID_MULTIPLE_SELECTION_KEYS = ['Meta', 'Control', 'Shift'];
+export const GRID_CELL_EXIT_EDIT_MODE_KEYS = ['Enter', 'Escape', 'Tab'];
+export const GRID_CELL_EDIT_COMMIT_KEYS = ['Enter', 'Tab'];
+export const isMultipleKey = key => GRID_MULTIPLE_SELECTION_KEYS.indexOf(key) > -1;
+export const isCellEnterEditModeKeys = event => isPrintableKey(event) || event.key === 'Enter' || event.key === 'Backspace' || event.key === 'Delete';
+export const isCellExitEditModeKeys = key => GRID_CELL_EXIT_EDIT_MODE_KEYS.indexOf(key) > -1;
+export const isCellEditCommitKeys = key => GRID_CELL_EDIT_COMMIT_KEYS.indexOf(key) > -1;
+export const isNavigationKey = key => key.indexOf('Arrow') === 0 || key.indexOf('Page') === 0 || key === ' ' || key === 'Home' || key === 'End';
+export const isKeyboardEvent = event => !!event.key;
+export const isHideMenuKey = key => key === 'Tab' || key === 'Escape';
+
+// In theory, on macOS, ctrl + v doesn't trigger a paste, so the function should return false.
+// However, maybe it's overkill to fix, so let's be lazy.
+export function isPasteShortcut(event) {
+  return (event.ctrlKey || event.metaKey) &&
+  // We can't use event.code === 'KeyV' as event.code assumes a QWERTY keyboard layout,
+  // for example, it would be another letter on a Dvorak physical keyboard.
+  // We can't use event.key === 'v' as event.key is not stable with key modifiers and keyboard layouts,
+  // for example, it would be ה on a Hebrew keyboard layout.
+  // https://github.com/w3c/uievents/issues/377 could be a long-term solution
+  String.fromCharCode(event.keyCode) === 'V' && !event.shiftKey && !event.altKey;
+}
+
+// Checks if the keyboard event corresponds to the copy shortcut (CTRL+C or CMD+C) across different localization keyboards.
+export function isCopyShortcut(event) {
+  return (event.ctrlKey || event.metaKey) && String.fromCharCode(event.keyCode) === 'C' && !event.shiftKey && !event.altKey;
+}

package/esm/utils/platform.d.ts

@@ -0,0 +1 @@
+export declare const isFirefox: boolean;

package/esm/utils/platform.js

@@ -0,0 +1,2 @@
+const userAgent = typeof navigator !== 'undefined' ? navigator.userAgent.toLowerCase() : 'empty';
+export const isFirefox = userAgent.includes('firefox');

package/esm/utils/roundToDecimalPlaces.d.ts

@@ -0,0 +1 @@
+export declare function roundToDecimalPlaces(value: number, decimals: number): number;

package/esm/utils/roundToDecimalPlaces.js

@@ -0,0 +1,3 @@
+export function roundToDecimalPlaces(value, decimals) {
+  return Math.round(value * 10 ** decimals) / 10 ** decimals;
+}

package/esm/utils/rtlFlipSide.d.ts

@@ -0,0 +1,2 @@
+import { PinnedColumnPosition } from "../internals/constants.js";
+export declare const rtlFlipSide: (position: PinnedColumnPosition | undefined, isRtl: boolean) => "left" | "right" | undefined;

package/esm/utils/rtlFlipSide.js

@@ -0,0 +1,22 @@
+import { PinnedColumnPosition } from "../internals/constants.js";
+export const rtlFlipSide = (position, isRtl) => {
+  if (!position) {
+    return undefined;
+  }
+  if (!isRtl) {
+    if (position === PinnedColumnPosition.LEFT) {
+      return 'left';
+    }
+    if (position === PinnedColumnPosition.RIGHT) {
+      return 'right';
+    }
+  } else {
+    if (position === PinnedColumnPosition.LEFT) {
+      return 'right';
+    }
+    if (position === PinnedColumnPosition.RIGHT) {
+      return 'left';
+    }
+  }
+  return undefined;
+};

package/esm/utils/utils.d.ts

@@ -0,0 +1,57 @@
+export declare function isNumber(value: unknown): value is number;
+export declare function isFunction(value: any): value is Function;
+export declare function isObject<TObject = Record<PropertyKey, any>>(value: unknown): value is TObject;
+export declare function localStorageAvailable(): boolean;
+export declare function escapeRegExp(value: string): string;
+/**
+ * Follows the CSS specification behavior for min and max
+ * If min > max, then the min have priority
+ */
+export declare const clamp: (value: number, min: number, max: number) => number;
+/**
+ * Create an array containing the range [from, to[
+ */
+export declare function range(from: number, to: number): number[];
+/**
+ * Based on `fast-deep-equal`
+ *
+ * MIT License
+ *
+ * Copyright (c) 2017 Evgeny Poberezkin
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ * We only type the public interface to avoid dozens of `as` in the function.
+ */
+export declare function isDeepEqual<T>(actual: any, expected: T): actual is T;
+/**
+ * Create a random number generator from a seed. The seed
+ * ensures that the random number generator produces the
+ * same sequence of 'random' numbers on every render. It
+ * returns a function that generates a random number between
+ * a specified min and max.
+ */
+export declare function createRandomNumberGenerator(seed: number): (min: number, max: number) => number;
+export declare function deepClone(obj: Record<string, any>): any;
+/**
+ * Mark a value as used so eslint doesn't complain. Use this instead
+ * of a `eslint-disable-next-line react-hooks/exhaustive-deps` because
+ * that hint disables checks on all values instead of just one.
+ */
+export declare function eslintUseValue(_: any): void;
+export declare const runIf: (condition: boolean, fn: Function) => (params: unknown) => void;

package/esm/utils/utils.js

@@ -0,0 +1,204 @@
+export function isNumber(value) {
+  return typeof value === 'number' && !Number.isNaN(value);
+}
+export function isFunction(value) {
+  return typeof value === 'function';
+}
+export function isObject(value) {
+  return typeof value === 'object' && value !== null;
+}
+export function localStorageAvailable() {
+  try {
+    // Incognito mode might reject access to the localStorage for security reasons.
+    // window isn't defined on Node.js
+    // https://stackoverflow.com/questions/16427636/check-if-localstorage-is-available
+    const key = '__some_random_key_you_are_not_going_to_use__';
+    window.localStorage.setItem(key, key);
+    window.localStorage.removeItem(key);
+    return true;
+  } catch (err) {
+    return false;
+  }
+}
+export function escapeRegExp(value) {
+  return value.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
+}
+
+/**
+ * Follows the CSS specification behavior for min and max
+ * If min > max, then the min have priority
+ */
+export const clamp = (value, min, max) => Math.max(min, Math.min(max, value));
+
+/**
+ * Create an array containing the range [from, to[
+ */
+export function range(from, to) {
+  return Array.from({
+    length: to - from
+  }).map((_, i) => from + i);
+}
+
+/**
+ * Based on `fast-deep-equal`
+ *
+ * MIT License
+ *
+ * Copyright (c) 2017 Evgeny Poberezkin
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ * We only type the public interface to avoid dozens of `as` in the function.
+ */
+
+export function isDeepEqual(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (a && b && typeof a === 'object' && typeof b === 'object') {
+    if (a.constructor !== b.constructor) {
+      return false;
+    }
+    if (Array.isArray(a)) {
+      const length = a.length;
+      if (length !== b.length) {
+        return false;
+      }
+      for (let i = 0; i < length; i += 1) {
+        if (!isDeepEqual(a[i], b[i])) {
+          return false;
+        }
+      }
+      return true;
+    }
+    if (a instanceof Map && b instanceof Map) {
+      if (a.size !== b.size) {
+        return false;
+      }
+      const entriesA = Array.from(a.entries());
+      for (let i = 0; i < entriesA.length; i += 1) {
+        if (!b.has(entriesA[i][0])) {
+          return false;
+        }
+      }
+      for (let i = 0; i < entriesA.length; i += 1) {
+        const entryA = entriesA[i];
+        if (!isDeepEqual(entryA[1], b.get(entryA[0]))) {
+          return false;
+        }
+      }
+      return true;
+    }
+    if (a instanceof Set && b instanceof Set) {
+      if (a.size !== b.size) {
+        return false;
+      }
+      const entries = Array.from(a.entries());
+      for (let i = 0; i < entries.length; i += 1) {
+        if (!b.has(entries[i][0])) {
+          return false;
+        }
+      }
+      return true;
+    }
+    if (ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {
+      const length = a.length;
+      if (length !== b.length) {
+        return false;
+      }
+      for (let i = 0; i < length; i += 1) {
+        if (a[i] !== b[i]) {
+          return false;
+        }
+      }
+      return true;
+    }
+    if (a.constructor === RegExp) {
+      return a.source === b.source && a.flags === b.flags;
+    }
+    if (a.valueOf !== Object.prototype.valueOf) {
+      return a.valueOf() === b.valueOf();
+    }
+    if (a.toString !== Object.prototype.toString) {
+      return a.toString() === b.toString();
+    }
+    const keys = Object.keys(a);
+    const length = keys.length;
+    if (length !== Object.keys(b).length) {
+      return false;
+    }
+    for (let i = 0; i < length; i += 1) {
+      if (!Object.prototype.hasOwnProperty.call(b, keys[i])) {
+        return false;
+      }
+    }
+    for (let i = 0; i < length; i += 1) {
+      const key = keys[i];
+      if (!isDeepEqual(a[key], b[key])) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  // true if both NaN, false otherwise
+  // eslint-disable-next-line no-self-compare
+  return a !== a && b !== b;
+}
+
+// Pseudo random number. See https://stackoverflow.com/a/47593316
+function mulberry32(a) {
+  return () => {
+    /* eslint-disable */
+    let t = a += 0x6d2b79f5;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+    /* eslint-enable */
+  };
+}
+
+/**
+ * Create a random number generator from a seed. The seed
+ * ensures that the random number generator produces the
+ * same sequence of 'random' numbers on every render. It
+ * returns a function that generates a random number between
+ * a specified min and max.
+ */
+export function createRandomNumberGenerator(seed) {
+  const random = mulberry32(seed);
+  return (min, max) => min + (max - min) * random();
+}
+export function deepClone(obj) {
+  if (typeof structuredClone === 'function') {
+    return structuredClone(obj);
+  }
+  return JSON.parse(JSON.stringify(obj));
+}
+
+/**
+ * Mark a value as used so eslint doesn't complain. Use this instead
+ * of a `eslint-disable-next-line react-hooks/exhaustive-deps` because
+ * that hint disables checks on all values instead of just one.
+ */
+export function eslintUseValue(_) {}
+export const runIf = (condition, fn) => params => {
+  if (condition) {
+    fn(params);
+  }
+};