@mui/x-data-grid-pro 5.4.0 → 5.6.0

package/node/themeAugmentation/index.js

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

package/node/themeAugmentation/overrides.js

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

package/node/themeAugmentation/props.js

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

package/node/typeOverloads/modules.js

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

package/node/typeOverloads/reexports.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "useGridApiContext", {
+  enumerable: true,
+  get: function () {
+    return _useGridApiContext.useGridApiContext;
+  }
+});
+Object.defineProperty(exports, "useGridApiRef", {
+  enumerable: true,
+  get: function () {
+    return _useGridApiRef.useGridApiRef;
+  }
+});
+Object.defineProperty(exports, "useGridRootProps", {
+  enumerable: true,
+  get: function () {
+    return _useGridRootProps.useGridRootProps;
+  }
+});
+
+var _useGridApiContext = require("../hooks/utils/useGridApiContext");
+
+var _useGridApiRef = require("../hooks/utils/useGridApiRef");
+
+var _useGridRootProps = require("../hooks/utils/useGridRootProps");

package/node/utils/domUtils.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.findGridCellElementsFromCol = findGridCellElementsFromCol;
+exports.findHeaderElementFromField = findHeaderElementFromField;
+exports.getFieldFromHeaderElem = getFieldFromHeaderElem;
+
+var _xDataGrid = require("@mui/x-data-grid");
+
+var _internals = require("@mui/x-data-grid/internals");
+
+function getFieldFromHeaderElem(colCellEl) {
+  return colCellEl.getAttribute('data-field');
+}
+
+function findHeaderElementFromField(elem, field) {
+  return elem.querySelector(`[data-field="${field}"]`);
+}
+
+function findGridCellElementsFromCol(col) {
+  const field = col.getAttribute('data-field');
+  const root = (0, _internals.findParentElementFromClassName)(col, 'MuiDataGrid-root');
+
+  if (!root) {
+    throw new Error('MUI: The root element is not found.');
+  }
+
+  const cells = root.querySelectorAll(`.${_xDataGrid.gridClasses.cell}[data-field="${field}"]`);
+  return cells;
+}

package/node/utils/tree/buildRowTree.js

@@ -0,0 +1,185 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buildRowTree = void 0;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+/**
+ * Transform a list of rows into a tree structure where each row references its parent and children.
+ * If a row have a parent which does not exist in the input rows, creates an auto generated row
+ *
+ ```
+ params = {
+   ids: [0, 1, 2],
+   idRowsLookup: { 0: {...}, 1: {...}, 2: {...} },
+   rows: [
+     { id: 0, path: ['A'] },
+     { id: 1, path: ['B', 'A'] },
+     { id: 2, path: ['B', 'A', 'A'] }
+   ],
+   defaultGroupingExpansionDepth: 0,
+ }
+ Returns:
+ {
+   ids: [0, 1, 2, 'auto-generated-row-B'],
+   idRowsLookup: { 0: {...}, 1: {...}, 2: {...}, 'auto-generated-row-B': {} },
+   tree: {
+     '0': { id: 0, parent: null, childrenExpanded: false, depth: 0, groupingKey: 'A' },
+     'auto-generated-row-B': { id: 'auto-generated-row-B', parent: null, childrenExpanded: false, depth: 0, groupingKey: 'B' },
+     '1': { id: 1, parent: 'auto-generated-row-B', childrenExpanded: false, depth: 1, groupingKey: 'A' },
+     '2': { id: 2, parent: 1, childrenExpanded: false, depth: 2, groupingKey: 'A' },
+   },
+   treeDepth: 3,
+ }
+ ```
+ */
+const buildRowTree = params => {
+  // During the build, we store the children as a Record to avoid linear complexity when checking if a children is already defined.
+  const tempTree = {};
+  let treeDepth = 1;
+  const ids = [...params.ids];
+  const idRowsLookup = (0, _extends2.default)({}, params.idRowsLookup);
+  const groupingCriteriaToIdTree = {};
+
+  const isGroupExpandedByDefault = node => {
+    var _params$previousTree, _params$previousTree$;
+
+    const previousExpansion = (_params$previousTree = params.previousTree) == null ? void 0 : (_params$previousTree$ = _params$previousTree[node.id]) == null ? void 0 : _params$previousTree$.childrenExpanded;
+
+    if (previousExpansion != null) {
+      return previousExpansion;
+    }
+
+    if (!node.children || !node.children.length) {
+      return undefined;
+    }
+
+    if (params.isGroupExpandedByDefault) {
+      return params.isGroupExpandedByDefault(node);
+    }
+
+    return params.defaultGroupingExpansionDepth === -1 || params.defaultGroupingExpansionDepth > node.depth;
+  };
+
+  for (let i = 0; i < params.rows.length; i += 1) {
+    const row = params.rows[i];
+    let keyToIdSubTree = groupingCriteriaToIdTree;
+    let parentNode = null;
+
+    for (let depth = 0; depth < row.path.length; depth += 1) {
+      const {
+        key,
+        field: rawField
+      } = row.path[depth];
+      const field = rawField != null ? rawField : '__no_field__';
+      let nodeId;
+      let fieldSubTree = keyToIdSubTree[field];
+
+      if (!fieldSubTree) {
+        fieldSubTree = {};
+        keyToIdSubTree[field] = fieldSubTree;
+      }
+
+      let keyConfig = fieldSubTree[key.toString()];
+
+      if (keyConfig) {
+        if (depth === row.path.length - 1) {
+          var _params$onDuplicatePa;
+
+          (_params$onDuplicatePa = params.onDuplicatePath) == null ? void 0 : _params$onDuplicatePa.call(params, keyConfig.id, row.id, row.path);
+        }
+
+        nodeId = keyConfig.id;
+      } else {
+        if (depth === row.path.length - 1) {
+          nodeId = row.id;
+        } else {
+          nodeId = `auto-generated-row-${row.path.map(groupingCriteria => `${groupingCriteria.field}/${groupingCriteria.key}`).slice(0, depth + 1).join('-')}`;
+        }
+
+        keyConfig = {
+          id: nodeId,
+          children: {}
+        };
+        fieldSubTree[key.toString()] = keyConfig;
+      }
+
+      keyToIdSubTree = keyConfig.children;
+
+      if (!tempTree[nodeId]) {
+        var _parentNode$id, _parentNode;
+
+        const isAutoGenerated = depth < row.path.length - 1;
+        const node = {
+          id: nodeId,
+          isAutoGenerated,
+          parent: (_parentNode$id = (_parentNode = parentNode) == null ? void 0 : _parentNode.id) != null ? _parentNode$id : null,
+          groupingKey: key,
+          groupingField: rawField,
+          depth
+        };
+
+        if (isAutoGenerated) {
+          idRowsLookup[nodeId] = {};
+          ids.push(nodeId);
+        }
+
+        tempTree[nodeId] = node;
+      }
+
+      if (parentNode != null) {
+        if (!parentNode.children) {
+          parentNode.children = {};
+        }
+
+        parentNode.children[nodeId] = nodeId;
+      }
+
+      parentNode = tempTree[nodeId];
+    }
+
+    treeDepth = Math.max(treeDepth, row.path.length);
+  }
+
+  const tree = {};
+
+  for (let i = 0; i < ids.length; i += 1) {
+    var _params$previousTree2, _previousNode$childre, _node$children, _previousNode$childre2;
+
+    const rowId = ids[i];
+    const tempNode = tempTree[rowId];
+    const nodeWithoutChildrenExpansion = (0, _extends2.default)({}, tempNode, {
+      children: tempNode.children ? Object.values(tempNode.children) : undefined
+    });
+    const node = (0, _extends2.default)({}, nodeWithoutChildrenExpansion, {
+      childrenExpanded: isGroupExpandedByDefault(nodeWithoutChildrenExpansion)
+    });
+    const previousNode = (_params$previousTree2 = params.previousTree) == null ? void 0 : _params$previousTree2[node.id];
+    const shouldReUsePreviousNode = previousNode && previousNode.isAutoGenerated === node.isAutoGenerated && previousNode.parent === node.parent && previousNode.groupingKey === node.groupingKey && previousNode.groupingField === node.groupingField && previousNode.depth === node.depth && previousNode.childrenExpanded === node.childrenExpanded && ((_previousNode$childre = previousNode.children) == null ? void 0 : _previousNode$childre.length) === ((_node$children = node.children) == null ? void 0 : _node$children.length) && ((_previousNode$childre2 = previousNode.children) == null ? void 0 : _previousNode$childre2.every((childId, index) => {
+      var _node$children2;
+
+      return ((_node$children2 = node.children) == null ? void 0 : _node$children2[index]) === childId;
+    }));
+
+    if (shouldReUsePreviousNode) {
+      tree[rowId] = previousNode;
+    } else {
+      tree[rowId] = node;
+    }
+  }
+
+  return {
+    tree,
+    treeDepth,
+    ids,
+    idRowsLookup,
+    groupingName: params.groupingName
+  };
+};
+
+exports.buildRowTree = buildRowTree;

package/node/utils/tree/sortRowTree.js

@@ -0,0 +1,69 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.sortRowTree = void 0;
+
+const sortRowTree = params => {
+  const {
+    rowIds,
+    rowTree,
+    disableChildrenSorting,
+    sortRowList
+  } = params;
+  let sortedRows = []; // Group the rows by parent
+
+  const groupedByParentRows = new Map([[null, []]]);
+
+  for (let i = 0; i < rowIds.length; i += 1) {
+    const rowId = rowIds[i];
+    const node = rowTree[rowId];
+    let group = groupedByParentRows.get(node.parent);
+
+    if (!group) {
+      group = [];
+      groupedByParentRows.set(node.parent, group);
+    }
+
+    group.push(node);
+  } // Apply the sorting to each list of children
+
+
+  const sortedGroupedByParentRows = new Map();
+  groupedByParentRows.forEach((rowList, parent) => {
+    if (rowList.length === 0) {
+      sortedGroupedByParentRows.set(parent, []);
+    } else {
+      const depth = rowList[0].depth;
+
+      if (depth > 0 && disableChildrenSorting) {
+        sortedGroupedByParentRows.set(parent, rowList.map(row => row.id));
+      } else if (!sortRowList) {
+        sortedGroupedByParentRows.set(parent, rowList.map(row => row.id));
+      } else {
+        sortedGroupedByParentRows.set(parent, sortRowList(rowList));
+      }
+    }
+  }); // Flatten the sorted lists to have children just after their parent
+
+  const insertRowListIntoSortedRows = (startIndex, rowList) => {
+    sortedRows = [...sortedRows.slice(0, startIndex), ...rowList, ...sortedRows.slice(startIndex)];
+    let treeSize = 0;
+    rowList.forEach(rowId => {
+      treeSize += 1;
+      const children = sortedGroupedByParentRows.get(rowId);
+
+      if (children != null && children.length) {
+        const subTreeSize = insertRowListIntoSortedRows(startIndex + treeSize, children);
+        treeSize += subTreeSize;
+      }
+    });
+    return treeSize;
+  };
+
+  insertRowListIntoSortedRows(0, sortedGroupedByParentRows.get(null));
+  return sortedRows;
+};
+
+exports.sortRowTree = sortRowTree;

package/package.json

@@ -1,14 +1,12 @@
 {
   "name": "@mui/x-data-grid-pro",
-  "version": "5.4.0",
+  "version": "5.6.0",
   "description": "The commercial edition of the data grid component (MUI X).",
   "author": "MUI Team",
-  "main": "index-cjs.js",
-  "module": "index-esm.js",
-  "types": "x-data-grid-pro.d.ts",
-  "license": "See LICENSE file",
+  "main": "./node/index.js",
+  "license": "SEE LICENSE IN LICENSE.txt",
   "bugs": {
-    "url": "https://github.com/mui-org/material-ui-x/issues"
+    "url": "https://github.com/mui/mui-x/issues"
   },
   "homepage": "https://mui.com/components/data-grid/",
   "sideEffects": false,
@@ -27,18 +25,15 @@
     "datagrid",
     "data-grid"
   ],
-  "scripts": {
-    "typescript": "tsc -p tsconfig.json",
-    "build": "cd ../ && rollup --config rollup.x-data-grid-pro.config.js"
-  },
   "repository": {
     "type": "git",
-    "url": "https://github.com/mui-org/material-ui-x.git",
+    "url": "https://github.com/mui/mui-x.git",
     "directory": "packages/grid/x-data-grid-pro"
   },
   "dependencies": {
-    "@mui/utils": "^5.3.0",
-    "@mui/x-license-pro": "5.4.0",
+    "@mui/utils": "^5.4.2",
+    "@mui/x-data-grid": "5.6.0",
+    "@mui/x-license-pro": "5.6.0",
     "clsx": "^1.0.4",
     "prop-types": "^15.8.1",
     "reselect": "^4.1.5"
@@ -53,5 +48,8 @@
   ],
   "engines": {
     "node": ">=12.0.0"
-  }
+  },
+  "private": false,
+  "module": "./index.js",
+  "types": "./index.d.ts"
 }

package/themeAugmentation/index.d.ts

@@ -1,2 +1,2 @@
-export * from './overrides';
-export * from './props';
+export * from './overrides';
+export * from './props';

package/themeAugmentation/index.js

@@ -0,0 +1,3 @@
+export * from './overrides';
+export * from './props'; // TODO v5
+// export * from './components';

package/themeAugmentation/overrides.d.ts

@@ -1,8 +1,8 @@
-import { GridClassKey } from '../../../_modules_/grid/gridClasses';
-export interface DataGridProComponentNameToClassKey {
-    MuiDataGrid: GridClassKey;
-}
-declare module '@mui/material/styles/overrides' {
-    interface ComponentNameToClassKey extends DataGridProComponentNameToClassKey {
-    }
-}
+import { GridClassKey } from '@mui/x-data-grid';
+export interface DataGridProComponentNameToClassKey {
+    MuiDataGrid: GridClassKey;
+}
+declare module '@mui/material/styles/overrides' {
+    interface ComponentNameToClassKey extends DataGridProComponentNameToClassKey {
+    }
+}

package/themeAugmentation/overrides.js

@@ -0,0 +1 @@
+export {};

package/themeAugmentation/package.json

@@ -0,0 +1,6 @@
+{
+  "sideEffects": false,
+  "module": "./index.js",
+  "main": "../node/themeAugmentation/index.js",
+  "types": "./index.d.ts"
+}

package/themeAugmentation/props.d.ts

@@ -1,19 +1,19 @@
-import { ComponentsOverrides, ComponentsProps } from '@mui/material/styles';
-import { DataGridProProps } from '../../../_modules_/grid/models/props/DataGridProProps';
-export interface DataGridProComponentsPropsList {
-    MuiDataGrid: DataGridProProps;
-}
-export interface DataGridProComponents {
-    MuiDataGrid?: {
-        defaultProps?: ComponentsProps['MuiDataGrid'];
-        styleOverrides?: ComponentsOverrides['MuiDataGrid'];
-    };
-}
-declare module '@mui/material/styles' {
-    interface ComponentsPropsList extends DataGridProComponentsPropsList {
-    }
-}
-declare module '@mui/material/styles/components' {
-    interface Components extends DataGridProComponents {
-    }
-}
+import { ComponentsOverrides, ComponentsProps } from '@mui/material/styles';
+import { DataGridProProps } from '../models/dataGridProProps';
+export interface DataGridProComponentsPropsList {
+    MuiDataGrid: DataGridProProps;
+}
+export interface DataGridProComponents {
+    MuiDataGrid?: {
+        defaultProps?: ComponentsProps['MuiDataGrid'];
+        styleOverrides?: ComponentsOverrides['MuiDataGrid'];
+    };
+}
+declare module '@mui/material/styles' {
+    interface ComponentsPropsList extends DataGridProComponentsPropsList {
+    }
+}
+declare module '@mui/material/styles/components' {
+    interface Components extends DataGridProComponents {
+    }
+}

package/themeAugmentation/props.js

@@ -0,0 +1 @@
+export {};

package/typeOverloads/modules.d.ts

@@ -0,0 +1,41 @@
+import { GridKeyValue } from '@mui/x-data-grid';
+import type { GridRowScrollEndParams, GridGroupingValueGetterParams } from '../models';
+import type { GridPinnedColumns, GridRowGroupingModel } from '../hooks';
+import type { GridCanBeReorderedPreProcessingContext } from '../hooks/features/columnReorder/columnReorderInterfaces';
+export interface GridControlledStateEventLookupPro {
+    rowGroupingModelChange: {
+        params: GridRowGroupingModel;
+    };
+    pinnedColumnsChange: {
+        params: GridPinnedColumns;
+    };
+}
+export interface GridEventLookupPro {
+    rowsScrollEnd: {
+        params: GridRowScrollEndParams;
+    };
+}
+export interface GridPreProcessingGroupLookupPro {
+    canBeReordered: {
+        value: boolean;
+        context: GridCanBeReorderedPreProcessingContext;
+    };
+}
+export interface GridColDefPro {
+    /**
+     * Function that transforms a complex cell value into a key that be used for grouping the rows.
+     * @param {GridGroupingValueGetterParams} params Object containing parameters for the getter.
+     * @returns {GridKeyValue | null | undefined} The cell key.
+     */
+    groupingValueGetter?: (params: GridGroupingValueGetterParams) => GridKeyValue | null | undefined;
+}
+declare module '@mui/x-data-grid' {
+    interface GridColDef extends GridColDefPro {
+    }
+    interface GridEventLookup extends GridEventLookupPro {
+    }
+    interface GridControlledStateEventLookup extends GridControlledStateEventLookupPro {
+    }
+    interface GridPreProcessingGroupLookup extends GridPreProcessingGroupLookupPro {
+    }
+}

package/typeOverloads/modules.js

@@ -0,0 +1 @@
+export {};

package/typeOverloads/reexports.d.ts

@@ -0,0 +1,22 @@
+import * as React from 'react';
+import type { GridApiPro } from '../models/gridApiPro';
+import { GridInitialStatePro, GridStatePro } from '../models/gridStatePro';
+export { useGridApiContext } from '../hooks/utils/useGridApiContext';
+export { useGridApiRef } from '../hooks/utils/useGridApiRef';
+export { useGridRootProps } from '../hooks/utils/useGridRootProps';
+/**
+ * The full grid API.
+ */
+export declare type GridApi = GridApiPro;
+/**
+ * @deprecated Use `React.MutableRefObject<GridApi>` instead
+ */
+export declare type GridApiRef = React.MutableRefObject<GridApiPro>;
+/**
+ * The state of `DataGridPro`.
+ */
+export declare type GridState = GridStatePro;
+/**
+ * The initial state of `DataGridPro`.
+ */
+export declare type GridInitialState = GridInitialStatePro;

package/typeOverloads/reexports.js

@@ -0,0 +1,6 @@
+export { useGridApiContext } from '../hooks/utils/useGridApiContext';
+export { useGridApiRef } from '../hooks/utils/useGridApiRef';
+export { useGridRootProps } from '../hooks/utils/useGridRootProps';
+/**
+ * The full grid API.
+ */

package/utils/domUtils.d.ts

@@ -0,0 +1,3 @@
+export declare function getFieldFromHeaderElem(colCellEl: Element): string;
+export declare function findHeaderElementFromField(elem: Element, field: string): Element | null;
+export declare function findGridCellElementsFromCol(col: HTMLElement): NodeListOf<Element> | null;

package/utils/domUtils.js

@@ -0,0 +1,19 @@
+import { gridClasses } from '@mui/x-data-grid';
+import { findParentElementFromClassName } from '@mui/x-data-grid/internals';
+export function getFieldFromHeaderElem(colCellEl) {
+  return colCellEl.getAttribute('data-field');
+}
+export function findHeaderElementFromField(elem, field) {
+  return elem.querySelector(`[data-field="${field}"]`);
+}
+export function findGridCellElementsFromCol(col) {
+  const field = col.getAttribute('data-field');
+  const root = findParentElementFromClassName(col, 'MuiDataGrid-root');
+
+  if (!root) {
+    throw new Error('MUI: The root element is not found.');
+  }
+
+  const cells = root.querySelectorAll(`.${gridClasses.cell}[data-field="${field}"]`);
+  return cells;
+}

package/utils/tree/buildRowTree.d.ts

@@ -0,0 +1,47 @@
+import { GridRowTreeNodeConfig, GridRowId, GridKeyValue } from '@mui/x-data-grid';
+import { GridRowGroupParams, GridRowGroupingResult } from '@mui/x-data-grid/internals';
+export interface BuildRowTreeGroupingCriteria {
+    field: string | null;
+    key: GridKeyValue;
+}
+interface BuildRowTreeParams extends GridRowGroupParams {
+    rows: {
+        id: GridRowId;
+        path: BuildRowTreeGroupingCriteria[];
+    }[];
+    defaultGroupingExpansionDepth: number;
+    isGroupExpandedByDefault?: (node: GridRowTreeNodeConfig) => boolean;
+    groupingName: string;
+    onDuplicatePath?: (firstId: GridRowId, secondId: GridRowId, path: BuildRowTreeGroupingCriteria[]) => void;
+}
+/**
+ * Transform a list of rows into a tree structure where each row references its parent and children.
+ * If a row have a parent which does not exist in the input rows, creates an auto generated row
+ *
+ ```
+ params = {
+   ids: [0, 1, 2],
+   idRowsLookup: { 0: {...}, 1: {...}, 2: {...} },
+   rows: [
+     { id: 0, path: ['A'] },
+     { id: 1, path: ['B', 'A'] },
+     { id: 2, path: ['B', 'A', 'A'] }
+   ],
+   defaultGroupingExpansionDepth: 0,
+ }
+ Returns:
+ {
+   ids: [0, 1, 2, 'auto-generated-row-B'],
+   idRowsLookup: { 0: {...}, 1: {...}, 2: {...}, 'auto-generated-row-B': {} },
+   tree: {
+     '0': { id: 0, parent: null, childrenExpanded: false, depth: 0, groupingKey: 'A' },
+     'auto-generated-row-B': { id: 'auto-generated-row-B', parent: null, childrenExpanded: false, depth: 0, groupingKey: 'B' },
+     '1': { id: 1, parent: 'auto-generated-row-B', childrenExpanded: false, depth: 1, groupingKey: 'A' },
+     '2': { id: 2, parent: 1, childrenExpanded: false, depth: 2, groupingKey: 'A' },
+   },
+   treeDepth: 3,
+ }
+ ```
+ */
+export declare const buildRowTree: (params: BuildRowTreeParams) => GridRowGroupingResult;
+export {};