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

package/modern/package.json

@@ -0,0 +1 @@
+{"type":"module","sideEffects":false}

package/modern/themeAugmentation/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./overrides.js";
+export * from "./props.js";

package/modern/themeAugmentation/overrides.d.ts

@@ -0,0 +1,18 @@
+import { GridClassKey } from "../constants/gridClasses.js";
+export interface DataGridComponentNameToClassKey {
+  MuiDataGrid: GridClassKey;
+}
+declare module '@mui/material/styles' {
+  interface ComponentNameToClassKey extends DataGridComponentNameToClassKey {}
+  interface PaletteDataGrid {
+    bg?: string;
+    headerBg?: string;
+    pinnedBg?: string;
+  }
+  interface CssVarsPalette {
+    DataGrid: PaletteDataGrid;
+  }
+  interface PaletteOptions {
+    DataGrid?: Partial<PaletteDataGrid>;
+  }
+}

package/modern/themeAugmentation/props.d.ts

@@ -0,0 +1,15 @@
+import { ComponentsOverrides, ComponentsProps } from '@mui/material/styles';
+import { DataGridProps } from "../models/props/DataGridProps.js";
+export interface DataGridComponentsPropsList {
+  MuiDataGrid: DataGridProps;
+}
+export interface DataGridComponents<Theme = unknown> {
+  MuiDataGrid?: {
+    defaultProps?: ComponentsProps['MuiDataGrid'];
+    styleOverrides?: ComponentsOverrides<Theme>['MuiDataGrid'];
+  };
+}
+declare module '@mui/material/styles' {
+  interface ComponentsPropsList extends DataGridComponentsPropsList {}
+  interface Components<Theme = unknown> extends DataGridComponents<Theme> {}
+}

package/modern/utils/ResizeObserver.d.ts

@@ -0,0 +1,4 @@
+/**
+ * HACK: Minimal shim to get jsdom to work.
+ */
+export declare const ResizeObserver: typeof globalThis.ResizeObserver;

package/modern/utils/Store.d.ts

@@ -0,0 +1,11 @@
+type Listener<T> = (value: T) => void;
+export declare class Store<T> {
+  value: T;
+  listeners: Set<Listener<T>>;
+  static create<T>(value: T): Store<T>;
+  constructor(value: T);
+  subscribe: (fn: Listener<T>) => () => void;
+  getSnapshot: () => T;
+  update: (value: T) => void;
+}
+export {};

package/modern/utils/assert.d.ts

@@ -0,0 +1,2 @@
+import * as React from 'react';
+export declare function NotRendered<T>(_props: T): React.ReactNode;

package/modern/utils/assert.js

@@ -0,0 +1,3 @@
+export function NotRendered(_props) {
+  throw new Error('Failed assertion: should not be rendered');
+}

package/modern/utils/cellBorderUtils.d.ts

@@ -0,0 +1,3 @@
+import { PinnedColumnPosition } from "../internals/constants.js";
+export declare const shouldCellShowRightBorder: (pinnedPosition: PinnedColumnPosition | undefined, indexInSection: number, sectionLength: number, showCellVerticalBorderRootProp: boolean, gridHasFiller: boolean) => boolean;
+export declare const shouldCellShowLeftBorder: (pinnedPosition: PinnedColumnPosition | undefined, indexInSection: number) => boolean;

package/modern/utils/cleanupTracking/CleanupTracking.d.ts

@@ -0,0 +1,9 @@
+export type UnregisterToken = {
+  cleanupToken: number;
+};
+export type UnsubscribeFn = () => void;
+export interface CleanupTracking {
+  register(object: any, unsubscribe: UnsubscribeFn, unregisterToken: UnregisterToken): void;
+  unregister(unregisterToken: UnregisterToken): void;
+  reset(): void;
+}

package/modern/utils/cleanupTracking/FinalizationRegistryBasedCleanupTracking.d.ts

@@ -0,0 +1,7 @@
+import { CleanupTracking, UnsubscribeFn, UnregisterToken } from "./CleanupTracking.js";
+export declare class FinalizationRegistryBasedCleanupTracking implements CleanupTracking {
+  registry: FinalizationRegistry<UnsubscribeFn>;
+  register(object: any, unsubscribe: UnsubscribeFn, unregisterToken: UnregisterToken): void;
+  unregister(unregisterToken: UnregisterToken): void;
+  reset(): void;
+}

package/modern/utils/cleanupTracking/TimerBasedCleanupTracking.d.ts

@@ -0,0 +1,9 @@
+import { CleanupTracking, UnregisterToken, UnsubscribeFn } from "./CleanupTracking.js";
+export declare class TimerBasedCleanupTracking implements CleanupTracking {
+  timeouts?: Map<number, NodeJS.Timeout> | undefined;
+  cleanupTimeout: number;
+  constructor(timeout?: number);
+  register(object: any, unsubscribe: UnsubscribeFn, unregisterToken: UnregisterToken): void;
+  unregister(unregisterToken: UnregisterToken): void;
+  reset(): void;
+}

package/modern/utils/composeGridClasses.d.ts

@@ -0,0 +1,3 @@
+import { unstable_composeClasses as composeClasses } from '@mui/utils';
+import type { DataGridProcessedProps } from '../models/props/DataGridProps';
+export declare function composeGridClasses(classes: DataGridProcessedProps['classes'], slots: Parameters<typeof composeClasses>[0]): Record<string, string>;

package/modern/utils/createControllablePromise.d.ts

@@ -0,0 +1,5 @@
+export type ControllablePromise<T = unknown> = Promise<T> & {
+  resolve: T extends unknown ? (value?: T) => void : (value: T) => void;
+  reject: (reason?: any) => void;
+};
+export declare function createControllablePromise(): ControllablePromise<unknown>;

package/modern/utils/createSelector.d.ts

@@ -0,0 +1,23 @@
+import { RefObject } from '@mui/x-internals/types';
+import { Selector, SelectorResultArray } from 'reselect';
+export interface OutputSelector<State, Args, Result> {
+  (apiRef: RefObject<{
+    state: State;
+  } | null>, args?: Args): Result;
+}
+type StateFromSelector<T> = T extends ((first: infer F, ...args: any[]) => any) ? F extends RefObject<{
+  state: infer F2;
+} | null> ? F2 : F : never;
+type StateFromSelectorList<Selectors extends readonly any[]> = Selectors extends [f: infer F, ...other: infer R] ? StateFromSelector<F> extends StateFromSelectorList<R> ? StateFromSelector<F> : StateFromSelectorList<R> : {};
+type SelectorResultArrayWithArgs<Selectors extends ReadonlyArray<Selector<any>>, Args> = [...SelectorResultArray<Selectors>, Args];
+type SelectorArgs<Selectors extends ReadonlyArray<Selector<any>>, Args, Result> = [selectors: [...Selectors], combiner: (...args: SelectorResultArrayWithArgs<Selectors, Args>) => Result] | [...Selectors, (...args: SelectorResultArrayWithArgs<Selectors, Args>) => Result];
+type CreateSelectorFunction = <Selectors extends ReadonlyArray<Selector<any>>, Args, Result>(...items: SelectorArgs<Selectors, Args, Result>) => OutputSelector<StateFromSelectorList<Selectors>, Args, Result>;
+export declare const createSelector: CreateSelectorFunction;
+/**
+ * Used to create the root selector for a feature. It assumes that the state is already initialized
+ * and strips from the types the possibility of `apiRef` being `null`.
+ * Users are warned about this in our documentation https://mui.com/x/react-data-grid/state/#direct-selector-access
+ */
+export declare const createRootSelector: <State, Args, Result>(fn: (state: State, args: Args) => Result) => OutputSelector<State, Args, Result>;
+export declare const createSelectorMemoized: CreateSelectorFunction;
+export {};

package/modern/utils/createSelector.js

@@ -1,20 +1,15 @@
 import { lruMemoize, createSelectorCreator } from 'reselect';
-import { warnOnce } from '@mui/x-internals/warning';
 import { argsEqual } from "../hooks/utils/useGridSelector.js";
+import { weakMapMemoize as customWeakMapMemoize } from "./weakMapMemoize.js";
 const reselectCreateSelector = createSelectorCreator({
   memoize: lruMemoize,
   memoizeOptions: {
     maxSize: 1,
     equalityCheck: Object.is
-  }
+  },
+  argsMemoize: customWeakMapMemoize
 });
 const cache = new WeakMap();
-function checkIsAPIRef(value) {
-  return 'current' in value && 'instanceId' in value.current;
-}
-const DEFAULT_INSTANCE_ID = {
-  id: 'default'
-};
 export const createSelector = (a, b, c, d, e, f, ...other) => {
   if (other.length > 0) {
     throw new Error('Unsupported number of selectors');
@@ -23,89 +18,68 @@ export const createSelector = (a, b, c, d, e, f, ...other) => {
 
   // eslint-disable-next-line id-denylist
   if (a && b && c && d && e && f) {
-    selector = (stateOrApiRef, args, instanceIdParam) => {
-      const isAPIRef = checkIsAPIRef(stateOrApiRef);
-      const instanceId = instanceIdParam ?? (isAPIRef ? stateOrApiRef.current.instanceId : DEFAULT_INSTANCE_ID);
-      const state = isAPIRef ? stateOrApiRef.current.state : stateOrApiRef;
-      const va = a(state, args, instanceId);
-      const vb = b(state, args, instanceId);
-      const vc = c(state, args, instanceId);
-      const vd = d(state, args, instanceId);
-      const ve = e(state, args, instanceId);
+    selector = (apiRef, args) => {
+      const va = a(apiRef, args);
+      const vb = b(apiRef, args);
+      const vc = c(apiRef, args);
+      const vd = d(apiRef, args);
+      const ve = e(apiRef, args);
       return f(va, vb, vc, vd, ve, args);
     };
     // eslint-disable-next-line id-denylist
   } else if (a && b && c && d && e) {
-    selector = (stateOrApiRef, args, instanceIdParam) => {
-      const isAPIRef = checkIsAPIRef(stateOrApiRef);
-      const instanceId = instanceIdParam ?? (isAPIRef ? stateOrApiRef.current.instanceId : DEFAULT_INSTANCE_ID);
-      const state = isAPIRef ? stateOrApiRef.current.state : stateOrApiRef;
-      const va = a(state, args, instanceId);
-      const vb = b(state, args, instanceId);
-      const vc = c(state, args, instanceId);
-      const vd = d(state, args, instanceId);
+    selector = (apiRef, args) => {
+      const va = a(apiRef, args);
+      const vb = b(apiRef, args);
+      const vc = c(apiRef, args);
+      const vd = d(apiRef, args);
       return e(va, vb, vc, vd, args);
     };
   } else if (a && b && c && d) {
-    selector = (stateOrApiRef, args, instanceIdParam) => {
-      const isAPIRef = checkIsAPIRef(stateOrApiRef);
-      const instanceId = instanceIdParam ?? (isAPIRef ? stateOrApiRef.current.instanceId : DEFAULT_INSTANCE_ID);
-      const state = isAPIRef ? stateOrApiRef.current.state : stateOrApiRef;
-      const va = a(state, args, instanceId);
-      const vb = b(state, args, instanceId);
-      const vc = c(state, args, instanceId);
+    selector = (apiRef, args) => {
+      const va = a(apiRef, args);
+      const vb = b(apiRef, args);
+      const vc = c(apiRef, args);
       return d(va, vb, vc, args);
     };
   } else if (a && b && c) {
-    selector = (stateOrApiRef, args, instanceIdParam) => {
-      const isAPIRef = checkIsAPIRef(stateOrApiRef);
-      const instanceId = instanceIdParam ?? (isAPIRef ? stateOrApiRef.current.instanceId : DEFAULT_INSTANCE_ID);
-      const state = isAPIRef ? stateOrApiRef.current.state : stateOrApiRef;
-      const va = a(state, args, instanceId);
-      const vb = b(state, args, instanceId);
+    selector = (apiRef, args) => {
+      const va = a(apiRef, args);
+      const vb = b(apiRef, args);
       return c(va, vb, args);
     };
   } else if (a && b) {
-    selector = (stateOrApiRef, args, instanceIdParam) => {
-      const isAPIRef = checkIsAPIRef(stateOrApiRef);
-      const instanceId = instanceIdParam ?? (isAPIRef ? stateOrApiRef.current.instanceId : DEFAULT_INSTANCE_ID);
-      const state = isAPIRef ? stateOrApiRef.current.state : stateOrApiRef;
-      const va = a(state, args, instanceId);
+    selector = (apiRef, args) => {
+      const va = a(apiRef, args);
       return b(va, args);
     };
   } else {
     throw new Error('Missing arguments');
   }
-
-  // We use this property to detect if the selector was created with createSelector
-  // or it's only a simple function the receives the state and returns part of it.
-  selector.acceptsApiRef = true;
   return selector;
 };
+
+/**
+ * Used to create the root selector for a feature. It assumes that the state is already initialized
+ * and strips from the types the possibility of `apiRef` being `null`.
+ * Users are warned about this in our documentation https://mui.com/x/react-data-grid/state/#direct-selector-access
+ */
+export const createRootSelector = fn => (apiRef, args) => fn(apiRef.current.state, args);
 export const createSelectorMemoized = (...args) => {
-  const selector = (stateOrApiRef, selectorArgs, instanceId) => {
-    const isAPIRef = checkIsAPIRef(stateOrApiRef);
-    const cacheKey = isAPIRef ? stateOrApiRef.current.instanceId : instanceId ?? DEFAULT_INSTANCE_ID;
-    const state = isAPIRef ? stateOrApiRef.current.state : stateOrApiRef;
-    if (process.env.NODE_ENV !== 'production') {
-      if (cacheKey.id === 'default') {
-        warnOnce(['MUI X: A selector was called without passing the instance ID, which may impact the performance of the grid.', 'To fix, call it with `apiRef`, for example `mySelector(apiRef)`, or pass the instance ID explicitly, for example `mySelector(state, args, apiRef.current.instanceId)`.']);
-      }
-    }
+  const selector = (apiRef, selectorArgs) => {
+    const cacheKey = apiRef.current.instanceId;
     const cacheArgsInit = cache.get(cacheKey);
     const cacheArgs = cacheArgsInit ?? new Map();
-    const cacheFn = cacheArgs?.get(args);
+    const cacheFn = cacheArgs.get(args);
     if (cacheArgs && cacheFn) {
       if (!argsEqual(cacheFn.selectorArgs, selectorArgs)) {
         const reselectArgs = selectorArgs !== undefined ? [...args.slice(0, args.length - 1), () => selectorArgs, args[args.length - 1]] : args;
         const fn = reselectCreateSelector(...reselectArgs);
         fn.selectorArgs = selectorArgs;
         cacheArgs.set(args, fn);
-        return fn(state, selectorArgs, cacheKey);
+        return fn(apiRef, selectorArgs);
       }
-      // We pass the cache key because the called selector might have as
-      // dependency another selector created with this `createSelector`.
-      return cacheFn(state, selectorArgs, cacheKey);
+      return cacheFn(apiRef, selectorArgs);
     }
     const reselectArgs = selectorArgs !== undefined ? [...args.slice(0, args.length - 1), () => selectorArgs, args[args.length - 1]] : args;
     const fn = reselectCreateSelector(...reselectArgs);
@@ -114,11 +88,7 @@ export const createSelectorMemoized = (...args) => {
       cache.set(cacheKey, cacheArgs);
     }
     cacheArgs.set(args, fn);
-    return fn(state, selectorArgs, cacheKey);
+    return fn(apiRef, selectorArgs);
   };
-
-  // We use this property to detect if the selector was created with createSelector
-  // or it's only a simple function the receives the state and returns part of it.
-  selector.acceptsApiRef = true;
   return selector;
 };

package/modern/utils/css/context.d.ts

@@ -0,0 +1,14 @@
+import * as React from 'react';
+export declare function useCSSVariablesClass(): string;
+export declare function useCSSVariablesContext(): {
+  className: string;
+  tag: React.JSX.Element;
+};
+export declare function GridPortalWrapper({
+  children
+}: {
+  children: React.ReactNode;
+}): React.JSX.Element;
+export declare function GridCSSVariablesContext(props: {
+  children: any;
+}): React.JSX.Element;

package/modern/utils/css/context.js

@@ -0,0 +1,54 @@
+import * as React from 'react';
+import { useGridConfiguration } from "../../hooks/utils/useGridConfiguration.js";
+import { jsx as _jsx } from "react/jsx-runtime";
+const CLASSNAME_PREFIX = 'MuiDataGridVariables';
+const CSSVariablesContext = /*#__PURE__*/React.createContext({
+  className: 'unset',
+  tag: /*#__PURE__*/_jsx("style", {
+    href: "/unset"
+  })
+});
+export function useCSSVariablesClass() {
+  return React.useContext(CSSVariablesContext).className;
+}
+export function useCSSVariablesContext() {
+  return React.useContext(CSSVariablesContext);
+}
+export function GridPortalWrapper({
+  children
+}) {
+  const className = useCSSVariablesClass();
+  return /*#__PURE__*/_jsx("div", {
+    className: className,
+    children: children
+  });
+}
+export function GridCSSVariablesContext(props) {
+  const config = useGridConfiguration();
+  const description = config.hooks.useCSSVariables();
+  const context = React.useMemo(() => {
+    const className = `${CLASSNAME_PREFIX}-${description.id}`;
+    const cssString = `.${className}{${variablesToString(description.variables)}}`;
+    const tag = /*#__PURE__*/_jsx("style", {
+      href: `/${className}`,
+      children: cssString
+    });
+    return {
+      className,
+      tag
+    };
+  }, [description]);
+  return /*#__PURE__*/_jsx(CSSVariablesContext.Provider, {
+    value: context,
+    children: props.children
+  });
+}
+function variablesToString(variables) {
+  let output = '';
+  for (const key in variables) {
+    if (Object.hasOwn(variables, key)) {
+      output += `${key}:${variables[key]};`;
+    }
+  }
+  return output;
+}

package/modern/utils/doesSupportPreventScroll.d.ts

@@ -0,0 +1 @@
+export declare function doesSupportPreventScroll(): boolean;

package/modern/utils/domUtils.d.ts

@@ -0,0 +1,29 @@
+import { gridClasses } from "../constants/gridClasses.js";
+import type { GridPrivateApiCommunity } from '../models/api/gridApiCommunity';
+import type { GridRowId } from '../models/gridRows';
+export declare function isOverflown(element: Element): boolean;
+export declare function findParentElementFromClassName(elem: Element, className: string): Element | null;
+export declare function escapeOperandAttributeSelector(operand: string): string;
+export declare function getGridColumnHeaderElement(root: Element, field: string): HTMLDivElement | null;
+export declare function getGridRowElement(root: Element, id: GridRowId): HTMLDivElement | null;
+export declare function getGridCellElement(root: Element, {
+  id,
+  field
+}: {
+  id: GridRowId;
+  field: string;
+}): HTMLDivElement | null;
+export declare const getActiveElement: (root?: Document | ShadowRoot) => Element | null;
+export declare function isEventTargetInPortal(event: React.SyntheticEvent): boolean;
+export declare function getFieldFromHeaderElem(colCellEl: Element): string;
+export declare function findHeaderElementFromField(elem: Element, field: string): HTMLDivElement;
+export declare function getFieldsFromGroupHeaderElem(colCellEl: Element): string[];
+export declare function findGroupHeaderElementsFromField(elem: Element, field: string): Element[];
+export declare function findGridCellElementsFromCol(col: HTMLElement, api: GridPrivateApiCommunity): Element[];
+export declare function findGridElement(api: GridPrivateApiCommunity, klass: keyof typeof gridClasses): HTMLElement;
+export declare function findLeftPinnedCellsAfterCol(api: GridPrivateApiCommunity, col: HTMLElement, isRtl: boolean): HTMLElement[];
+export declare function findRightPinnedCellsBeforeCol(api: GridPrivateApiCommunity, col: HTMLElement, isRtl: boolean): HTMLElement[];
+export declare function findLeftPinnedHeadersAfterCol(api: GridPrivateApiCommunity, col: HTMLElement, isRtl: boolean): HTMLElement[];
+export declare function findRightPinnedHeadersBeforeCol(api: GridPrivateApiCommunity, col: HTMLElement, isRtl: boolean): HTMLElement[];
+export declare function findGridHeader(api: GridPrivateApiCommunity, field: string): Element | null;
+export declare function findGridCells(api: GridPrivateApiCommunity, field: string): Element[];

package/modern/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/modern/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/modern/utils/getGridLocalization.js

@@ -1,11 +1,8 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
-export const getGridLocalization = (gridTranslations, coreTranslations) => ({
+export const getGridLocalization = gridTranslations => ({
   components: {
     MuiDataGrid: {
       defaultProps: {
-        localeText: _extends({}, gridTranslations, {
-          MuiTablePagination: coreTranslations?.components?.MuiTablePagination?.defaultProps || {}
-        })
+        localeText: gridTranslations
       }
     }
   }

package/modern/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/modern/utils/index.d.ts

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

package/modern/utils/index.js

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

package/modern/utils/isJSDOM.d.ts

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

package/modern/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/modern/utils/platform.d.ts

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

package/modern/utils/roundToDecimalPlaces.d.ts

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

package/modern/utils/roundToDecimalPlaces.js

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

package/modern/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/modern/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/modern/utils/weakMapMemoize.d.ts

@@ -0,0 +1,20 @@
+type AnyNonNullishValue = NonNullable<unknown>;
+type Simplify<T> = T extends AnyFunction ? T : { [KeyType in keyof T]: T[KeyType] } & AnyNonNullishValue;
+type EqualityFn<T = any> = (a: T, b: T) => boolean;
+type DefaultMemoizeFields = {
+  clearCache: () => void;
+  resultsCount: () => number;
+  resetResultsCount: () => void;
+};
+type AnyFunction = (...args: any[]) => any;
+interface WeakMapMemoizeOptions<Result = any> {
+  resultEqualityCheck?: EqualityFn<Result>;
+}
+/**
+ * Inspired by the `weakMapMemoize` function from the `reselect` library.
+ *
+ * @see {@link https://github.com/reduxjs/reselect/blob/1c3fc05f041d32cd69c11a7f7deccf0bce6f4598/src/weakMapMemoize.ts `original source code`}
+ * @see {@link https://reselect.js.org/api/weakMapMemoize `weakMapMemoize api docs`}
+ */
+export declare function weakMapMemoize<Func extends AnyFunction>(func: Func, options?: WeakMapMemoizeOptions<ReturnType<Func>>): Func & Simplify<DefaultMemoizeFields>;
+export {};