@mui/x-data-grid-pro 5.5.1 → 5.7.0

package/utils/releaseInfo.d.ts

@@ -0,0 +1 @@
+export declare const getReleaseInfo: () => any;

package/utils/releaseInfo.js

@@ -0,0 +1,15 @@
+import { ponyfillGlobal } from '@mui/utils';
+export const getReleaseInfo = () => {
+  const releaseInfo = "MTY0ODA5MDgwMDAwMA==";
+
+  if (process.env.NODE_ENV !== 'production') {
+    // A simple hack to set the value in the test environment (has no build step).
+    // eslint-disable-next-line no-useless-concat
+    if (releaseInfo === '__RELEASE' + '_INFO__') {
+      // eslint-disable-next-line no-underscore-dangle
+      return ponyfillGlobal.__MUI_RELEASE_INFO__;
+    }
+  }
+
+  return releaseInfo;
+};

package/utils/tree/buildRowTree.d.ts

@@ -0,0 +1,47 @@
+import { GridRowTreeNodeConfig, GridRowId, GridKeyValue } from '@mui/x-data-grid';
+import { GridRowTreeCreationParams, GridRowTreeCreationValue } from '@mui/x-data-grid/internals';
+export interface BuildRowTreeGroupingCriteria {
+    field: string | null;
+    key: GridKeyValue;
+}
+interface BuildRowTreeParams extends GridRowTreeCreationParams {
+    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) => GridRowTreeCreationValue;
+export {};

package/utils/tree/buildRowTree.js

@@ -0,0 +1,179 @@
+import _extends from "@babel/runtime/helpers/esm/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,
+ }
+ ```
+ */
+export 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 = _extends({}, 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 = _extends({}, tempNode, {
+      children: tempNode.children ? Object.values(tempNode.children) : undefined
+    });
+
+    const node = _extends({}, 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
+  };
+};

package/utils/tree/sortRowTree.d.ts

@@ -0,0 +1,10 @@
+import { GridRowId, GridRowTreeConfig } from '@mui/x-data-grid';
+import { GridSortingModelApplier } from '@mui/x-data-grid/internals';
+interface SortRowTreeParams {
+    rowIds: GridRowId[];
+    rowTree: GridRowTreeConfig;
+    disableChildrenSorting: boolean;
+    sortRowList: GridSortingModelApplier | null;
+}
+export declare const sortRowTree: (params: SortRowTreeParams) => GridRowId[];
+export {};

package/utils/tree/sortRowTree.js

@@ -0,0 +1,60 @@
+export 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;
+};

package/LICENSE

@@ -1,12 +0,0 @@
-Commercial License
-
-Copyright (c) 2020 Material-UI SAS
-
-MUI X Pro (https://mui.com/pricing/) is commercial software. You must purchase
-a license and agree to the End User License Agreement (EULA: https://mui.com/x/license/)
-to be able to use the software.
-
-Commercial licenses can be obtained at https://mui.com/store/items/material-ui-pro/.
-You are free to install and try the software without a license key as long as it
-is not used for the development of a feature intended for production use. You can
-find more details under the "Evaluation (trial) licenses" section of the EULA.