@mui/x-tree-view 7.0.0-alpha.1 → 7.0.0-alpha.8

package/node/internals/plugins/useTreeViewNodes/useTreeViewNodes.js

@@ -12,23 +12,49 @@ var _useTreeView = require("../../useTreeView/useTreeView.utils");
 var _publishTreeViewEvent = require("../../utils/publishTreeViewEvent");
 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 updateState = ({
+  items,
+  isItemDisabled,
+  getItemLabel,
+  getItemId
+}) => {
+  const nodeMap = {};
+  const processItem = (item, index, parentId) => {
+    const id = getItemId ? getItemId(item) : item.id;
+    if (id == null) {
+      throw new Error(['MUI X: The Tree View component requires all items to have a unique `id` property.', 'Alternatively, you can use the `getItemId` prop to specify a custom id for each item.', 'An item was provided without id in the `items` prop:', JSON.stringify(item)].join('\n'));
+    }
+    const label = getItemLabel ? getItemLabel(item) : item.label;
+    if (label == null) {
+      throw new Error(['MUI X: The Tree View component requires all items to have a `label` property.', 'Alternatively, you can use the `getItemLabel` prop to specify a custom label for each item.', 'An item was provided without label in the `items` prop:', JSON.stringify(item)].join('\n'));
+    }
+    nodeMap[id] = {
+      id,
+      label,
+      index,
+      parentId,
+      idAttribute: id,
+      expandable: !!item.children?.length,
+      disabled: isItemDisabled ? isItemDisabled(item) : false
+    };
+    return {
+      id,
+      children: item.children?.map((child, childIndex) => processItem(child, childIndex, id))
+    };
+  };
+  const nodeTree = items.map((item, itemIndex) => processItem(item, itemIndex, null));
+  return {
+    nodeMap,
+    nodeTree
+  };
+};
 const useTreeViewNodes = ({
   instance,
-  params
+  params,
+  state,
+  setState
 }) => {
-  const nodeMap = React.useRef({});
-  const getNode = React.useCallback(nodeId => nodeMap.current[nodeId], []);
-  const insertNode = React.useCallback(node => {
-    nodeMap.current[node.id] = node;
-  }, []);
-  const removeNode = React.useCallback(nodeId => {
-    const newMap = (0, _extends2.default)({}, nodeMap.current);
-    delete newMap[nodeId];
-    nodeMap.current = newMap;
-    (0, _publishTreeViewEvent.publishTreeViewEvent)(instance, 'removeNode', {
-      id: nodeId
-    });
-  }, [instance]);
+  const getNode = React.useCallback(nodeId => state.nodeMap[nodeId], [state.nodeMap]);
   const isNodeDisabled = React.useCallback(nodeId => {
     if (nodeId == null) {
       return false;
@@ -50,7 +76,7 @@ const useTreeViewNodes = ({
     }
     return false;
   }, [instance]);
-  const getChildrenIds = (0, _useEventCallback.default)(nodeId => Object.values(nodeMap.current).filter(node => node.parentId === nodeId).sort((a, b) => a.index - b.index).map(child => child.id));
+  const getChildrenIds = (0, _useEventCallback.default)(nodeId => Object.values(state.nodeMap).filter(node => node.parentId === nodeId).sort((a, b) => a.index - b.index).map(child => child.id));
   const getNavigableChildrenIds = nodeId => {
     let childrenIds = instance.getChildrenIds(nodeId);
     if (!params.disabledItemsFocusable) {
@@ -58,13 +84,58 @@ const useTreeViewNodes = ({
     }
     return childrenIds;
   };
+  React.useEffect(() => {
+    setState(prevState => {
+      const newState = updateState({
+        items: params.items,
+        isItemDisabled: params.isItemDisabled,
+        getItemId: params.getItemId,
+        getItemLabel: params.getItemLabel
+      });
+      Object.values(prevState.nodeMap).forEach(node => {
+        if (!newState.nodeMap[node.id]) {
+          (0, _publishTreeViewEvent.publishTreeViewEvent)(instance, 'removeNode', {
+            id: node.id
+          });
+        }
+      });
+      return (0, _extends2.default)({}, prevState, newState);
+    });
+  }, [instance, setState, params.items, params.isItemDisabled, params.getItemId, params.getItemLabel]);
+  const getNodesToRender = (0, _useEventCallback.default)(() => {
+    const getPropsFromNodeId = ({
+      id,
+      children
+    }) => {
+      const node = state.nodeMap[id];
+      return {
+        label: node.label,
+        nodeId: node.id,
+        id: node.idAttribute,
+        children: children?.map(getPropsFromNodeId)
+      };
+    };
+    return state.nodeTree.map(getPropsFromNodeId);
+  });
   (0, _useTreeView.populateInstance)(instance, {
     getNode,
-    updateNode: insertNode,
-    removeNode,
+    getNodesToRender,
     getChildrenIds,
     getNavigableChildrenIds,
     isNodeDisabled
   });
 };
-exports.useTreeViewNodes = useTreeViewNodes;
+exports.useTreeViewNodes = useTreeViewNodes;
+useTreeViewNodes.getInitialState = params => updateState({
+  items: params.items,
+  isItemDisabled: params.isItemDisabled,
+  getItemId: params.getItemId,
+  getItemLabel: params.getItemLabel
+});
+useTreeViewNodes.params = {
+  disabledItemsFocusable: true,
+  items: true,
+  isItemDisabled: true,
+  getItemLabel: true,
+  getItemId: true
+};

package/node/internals/plugins/useTreeViewSelection/useTreeViewSelection.js

@@ -19,30 +19,49 @@ const useTreeViewSelection = ({
   const lastSelectedNode = React.useRef(null);
   const lastSelectionWasRange = React.useRef(false);
   const currentRangeSelection = React.useRef([]);
-  const isNodeSelected = nodeId => Array.isArray(models.selected.value) ? models.selected.value.indexOf(nodeId) !== -1 : models.selected.value === nodeId;
+  const isNodeSelected = nodeId => Array.isArray(models.selectedNodes.value) ? models.selectedNodes.value.indexOf(nodeId) !== -1 : models.selectedNodes.value === nodeId;
+  const setSelectedNodes = (event, newSelectedNodes) => {
+    if (params.onNodeSelectionToggle) {
+      if (params.multiSelect) {
+        const addedNodes = newSelectedNodes.filter(nodeId => !instance.isNodeSelected(nodeId));
+        const removedNodes = models.selectedNodes.value.filter(nodeId => !newSelectedNodes.includes(nodeId));
+        addedNodes.forEach(nodeId => {
+          params.onNodeSelectionToggle(event, nodeId, true);
+        });
+        removedNodes.forEach(nodeId => {
+          params.onNodeSelectionToggle(event, nodeId, false);
+        });
+      } else if (newSelectedNodes !== models.selectedNodes.value) {
+        if (models.selectedNodes.value != null) {
+          params.onNodeSelectionToggle(event, models.selectedNodes.value, false);
+        }
+        if (newSelectedNodes != null) {
+          params.onNodeSelectionToggle(event, newSelectedNodes, true);
+        }
+      }
+    }
+    if (params.onSelectedNodesChange) {
+      params.onSelectedNodesChange(event, newSelectedNodes);
+    }
+    models.selectedNodes.setValue(newSelectedNodes);
+  };
   const selectNode = (event, nodeId, multiple = false) => {
     if (params.disableSelection) {
       return;
     }
     if (multiple) {
-      if (Array.isArray(models.selected.value)) {
+      if (Array.isArray(models.selectedNodes.value)) {
         let newSelected;
-        if (models.selected.value.indexOf(nodeId) !== -1) {
-          newSelected = models.selected.value.filter(id => id !== nodeId);
+        if (models.selectedNodes.value.indexOf(nodeId) !== -1) {
+          newSelected = models.selectedNodes.value.filter(id => id !== nodeId);
         } else {
-          newSelected = [nodeId].concat(models.selected.value);
+          newSelected = [nodeId].concat(models.selectedNodes.value);
         }
-        if (params.onNodeSelect) {
-          params.onNodeSelect(event, newSelected);
-        }
-        models.selected.setValue(newSelected);
+        setSelectedNodes(event, newSelected);
       }
     } else {
       const newSelected = params.multiSelect ? [nodeId] : nodeId;
-      if (params.onNodeSelect) {
-        params.onNodeSelect(event, newSelected);
-      }
-      models.selected.setValue(newSelected);
+      setSelectedNodes(event, newSelected);
     }
     lastSelectedNode.current = nodeId;
     lastSelectionWasRange.current = false;
@@ -59,7 +78,7 @@ const useTreeViewSelection = ({
     return nodes;
   };
   const handleRangeArrowSelect = (event, nodes) => {
-    let base = models.selected.value.slice();
+    let base = models.selectedNodes.value.slice();
     const {
       start,
       next,
@@ -83,13 +102,10 @@ const useTreeViewSelection = ({
       base.push(next);
       currentRangeSelection.current.push(current, next);
     }
-    if (params.onNodeSelect) {
-      params.onNodeSelect(event, base);
-    }
-    models.selected.setValue(base);
+    setSelectedNodes(event, base);
   };
   const handleRangeSelect = (event, nodes) => {
-    let base = models.selected.value.slice();
+    let base = models.selectedNodes.value.slice();
     const {
       start,
       end
@@ -103,10 +119,7 @@ const useTreeViewSelection = ({
     currentRangeSelection.current = range;
     let newSelected = base.concat(range);
     newSelected = newSelected.filter((id, i) => newSelected.indexOf(id) === i);
-    if (params.onNodeSelect) {
-      params.onNodeSelect(event, newSelected);
-    }
-    models.selected.setValue(newSelected);
+    setSelectedNodes(event, newSelected);
   };
   const selectRange = (event, nodes, stacked = false) => {
     if (params.disableSelection) {
@@ -166,14 +179,22 @@ const useTreeViewSelection = ({
 };
 exports.useTreeViewSelection = useTreeViewSelection;
 useTreeViewSelection.models = {
-  selected: {
-    controlledProp: 'selected',
-    defaultProp: 'defaultSelected'
+  selectedNodes: {
+    controlledProp: 'selectedNodes',
+    defaultProp: 'defaultSelectedNodes'
   }
 };
-const DEFAULT_SELECTED = [];
+const DEFAULT_SELECTED_NODES = [];
 useTreeViewSelection.getDefaultizedParams = params => (0, _extends2.default)({}, params, {
   disableSelection: params.disableSelection ?? false,
   multiSelect: params.multiSelect ?? false,
-  defaultSelected: params.defaultSelected ?? (params.multiSelect ? DEFAULT_SELECTED : null)
-});
+  defaultSelectedNodes: params.defaultSelectedNodes ?? (params.multiSelect ? DEFAULT_SELECTED_NODES : null)
+});
+useTreeViewSelection.params = {
+  disableSelection: true,
+  multiSelect: true,
+  defaultSelectedNodes: true,
+  selectedNodes: true,
+  onSelectedNodesChange: true,
+  onNodeSelectionToggle: true
+};

package/node/internals/useTreeView/useTreeView.js

@@ -8,7 +8,6 @@ exports.useTreeView = void 0;
 var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
 var React = _interopRequireWildcard(require("react"));
 var _useForkRef = _interopRequireDefault(require("@mui/utils/useForkRef"));
-var _TreeViewContext = require("../TreeViewProvider/TreeViewContext");
 var _useTreeViewModels = require("./useTreeViewModels");
 var _corePlugins = require("../corePlugins");
 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); }
@@ -36,7 +35,7 @@ const useTreeView = inParams => {
     return temp;
   });
   const rootPropsGetters = [];
-  let contextValue = _TreeViewContext.DEFAULT_TREE_VIEW_CONTEXT_VALUE;
+  let contextValue = {};
   const runPlugin = plugin => {
     const pluginResponse = plugin({
       instance,
@@ -54,6 +53,43 @@ const useTreeView = inParams => {
     }
   };
   plugins.forEach(runPlugin);
+  contextValue.runItemPlugins = ({
+    props,
+    ref
+  }) => {
+    let finalProps = props;
+    let finalRef = ref;
+    const itemWrappers = [];
+    plugins.forEach(plugin => {
+      if (!plugin.itemPlugin) {
+        return;
+      }
+      const itemPluginResponse = plugin.itemPlugin({
+        props: finalProps,
+        ref: finalRef
+      });
+      if (itemPluginResponse?.props) {
+        finalProps = itemPluginResponse.props;
+      }
+      if (itemPluginResponse?.ref) {
+        finalRef = itemPluginResponse.ref;
+      }
+      if (itemPluginResponse?.wrapItem) {
+        itemWrappers.push(itemPluginResponse.wrapItem);
+      }
+    });
+    return {
+      props: finalProps,
+      ref: finalRef,
+      wrapItem: children => {
+        let finalChildren = children;
+        itemWrappers.forEach(itemWrapper => {
+          finalChildren = itemWrapper(finalChildren);
+        });
+        return finalChildren;
+      }
+    };
+  };
   const getRootProps = (otherHandlers = {}) => {
     const rootProps = (0, _extends2.default)({
       role: 'tree',
@@ -69,7 +105,8 @@ const useTreeView = inParams => {
   return {
     getRootProps,
     rootRef: handleRootRef,
-    contextValue
+    contextValue,
+    instance: instance
   };
 };
 exports.useTreeView = useTreeView;

package/node/internals/useTreeView/useTreeViewModels.js

@@ -53,7 +53,7 @@ const useTreeViewModels = (plugins, props) => {
       const defaultProp = props[model.defaultProp];
       React.useEffect(() => {
         if (model.isControlled !== (controlled !== undefined)) {
-          console.error([`MUI: A component is changing the ${model.isControlled ? '' : 'un'}controlled ${modelName} state of TreeView to be ${model.isControlled ? 'un' : ''}controlled.`, 'Elements should not switch from uncontrolled to controlled (or vice versa).', `Decide between using a controlled or uncontrolled ${modelName} ` + 'element for the lifetime of the component.', "The nature of the state is determined during the first render. It's considered controlled if the value is not `undefined`.", 'More info: https://fb.me/react-controlled-components'].join('\n'));
+          console.error([`MUI X: A component is changing the ${model.isControlled ? '' : 'un'}controlled ${modelName} state of TreeView to be ${model.isControlled ? 'un' : ''}controlled.`, 'Elements should not switch from uncontrolled to controlled (or vice versa).', `Decide between using a controlled or uncontrolled ${modelName} ` + 'element for the lifetime of the component.', "The nature of the state is determined during the first render. It's considered controlled if the value is not `undefined`.", 'More info: https://fb.me/react-controlled-components'].join('\n'));
         }
       }, [controlled]);
       const {
@@ -61,7 +61,7 @@ const useTreeViewModels = (plugins, props) => {
       } = React.useRef(defaultProp);
       React.useEffect(() => {
         if (!model.isControlled && defaultValue !== defaultProp) {
-          console.error([`MUI: A component is changing the default ${modelName} state of an uncontrolled TreeView after being initialized. ` + `To suppress this warning opt to use a controlled TreeView.`].join('\n'));
+          console.error([`MUI X: A component is changing the default ${modelName} state of an uncontrolled TreeView after being initialized. ` + `To suppress this warning opt to use a controlled TreeView.`].join('\n'));
         }
       }, [JSON.stringify(defaultValue)]);
     });

package/node/internals/utils/extractPluginParamsFromProps.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.extractPluginParamsFromProps = void 0;
+const extractPluginParamsFromProps = ({
+  props,
+  plugins,
+  rootRef
+}) => {
+  const paramsLookup = {};
+  plugins.forEach(plugin => {
+    Object.assign(paramsLookup, plugin.params);
+  });
+  const pluginParams = {
+    plugins,
+    rootRef
+  };
+  const otherProps = {};
+  Object.keys(props).forEach(propName => {
+    const prop = props[propName];
+    if (paramsLookup[propName]) {
+      pluginParams[propName] = prop;
+    } else {
+      otherProps[propName] = prop;
+    }
+  });
+  return {
+    pluginParams,
+    otherProps
+  };
+};
+exports.extractPluginParamsFromProps = extractPluginParamsFromProps;

package/node/internals/utils/warning.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buildWarning = void 0;
+const buildWarning = (message, gravity = 'warning') => {
+  let alreadyWarned = false;
+  const cleanMessage = Array.isArray(message) ? message.join('\n') : message;
+  return () => {
+    if (!alreadyWarned) {
+      alreadyWarned = true;
+      if (gravity === 'error') {
+        console.error(cleanMessage);
+      } else {
+        console.warn(cleanMessage);
+      }
+    }
+  };
+};
+exports.buildWarning = buildWarning;

package/node/models/index.js

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

package/node/models/items.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mui/x-tree-view",
-  "version": "7.0.0-alpha.1",
+  "version": "7.0.0-alpha.8",
   "description": "The community edition of the tree view components (MUI X).",
   "author": "MUI Team",
   "main": "./node/index.js",
@@ -11,7 +11,7 @@
   "homepage": "https://mui.com/x/react-tree-view/",
   "funding": {
     "type": "opencollective",
-    "url": "https://opencollective.com/mui"
+    "url": "https://opencollective.com/mui-org"
   },
   "sideEffects": false,
   "publishConfig": {
@@ -21,6 +21,7 @@
     "react",
     "react-component",
     "mui",
+    "mui-x",
     "material-ui",
     "material design",
     "treeview"
@@ -31,10 +32,11 @@
     "directory": "packages/x-tree-view"
   },
   "dependencies": {
-    "@babel/runtime": "^7.23.2",
-    "@mui/base": "^5.0.0-beta.22",
-    "@mui/utils": "^5.14.16",
-    "@types/react-transition-group": "^4.4.8",
+    "@babel/runtime": "^7.23.7",
+    "@mui/base": "^5.0.0-beta.29",
+    "@mui/system": "^5.15.2",
+    "@mui/utils": "^5.15.2",
+    "@types/react-transition-group": "^4.4.10",
     "clsx": "^2.0.0",
     "prop-types": "^15.8.1",
     "react-transition-group": "^4.4.5"
@@ -43,7 +45,6 @@
     "@emotion/react": "^11.9.0",
     "@emotion/styled": "^11.8.1",
     "@mui/material": "^5.8.6",
-    "@mui/system": "^5.8.0",
     "react": "^17.0.0 || ^18.0.0",
     "react-dom": "^17.0.0 || ^18.0.0"
   },

package/themeAugmentation/components.d.ts

@@ -1,16 +1,26 @@
 import { ComponentsProps, ComponentsOverrides, ComponentsVariants } from '@mui/material/styles';
 
 export interface TreeViewComponents<Theme = unknown> {
-  MuiTreeItem?: {
-    defaultProps?: ComponentsProps['MuiTreeItem'];
-    styleOverrides?: ComponentsOverrides<Theme>['MuiTreeItem'];
-    variants?: ComponentsVariants['MuiTreeItem'];
+  MuiSimpleTreeView?: {
+    defaultProps?: ComponentsProps['MuiSimpleTreeView'];
+    styleOverrides?: ComponentsOverrides<Theme>['MuiSimpleTreeView'];
+    variants?: ComponentsVariants['MuiSimpleTreeView'];
+  };
+  MuiRichTreeView?: {
+    defaultProps?: ComponentsProps['MuiRichTreeView'];
+    styleOverrides?: ComponentsOverrides<Theme>['MuiRichTreeView'];
+    variants?: ComponentsVariants['MuiRichTreeView'];
   };
   MuiTreeView?: {
     defaultProps?: ComponentsProps['MuiTreeView'];
     styleOverrides?: ComponentsOverrides<Theme>['MuiTreeView'];
     variants?: ComponentsVariants['MuiTreeView'];
   };
+  MuiTreeItem?: {
+    defaultProps?: ComponentsProps['MuiTreeItem'];
+    styleOverrides?: ComponentsOverrides<Theme>['MuiTreeItem'];
+    variants?: ComponentsVariants['MuiTreeItem'];
+  };
 }
 
 declare module '@mui/material/styles' {

package/themeAugmentation/overrides.d.ts

@@ -1,14 +1,18 @@
-import { TreeItemClassKey } from '../TreeItem';
+import { RichTreeViewClassKey } from '../RichTreeView';
+import { SimpleTreeViewClassKey } from '../SimpleTreeView';
 import { TreeViewClassKey } from '../TreeView';
+import { TreeItemClassKey } from '../TreeItem';
 
 // prettier-ignore
-export interface PickersComponentNameToClassKey {
-  MuiTreeItem: TreeItemClassKey;
+export interface TreeViewComponentNameToClassKey {
+  MuiSimpleTreeView: SimpleTreeViewClassKey;
+  MuiRichTreeView: RichTreeViewClassKey;
   MuiTreeView: TreeViewClassKey;
+  MuiTreeItem: TreeItemClassKey;
 }
 
 declare module '@mui/material/styles' {
-  interface ComponentNameToClassKey extends PickersComponentNameToClassKey {}
+  interface ComponentNameToClassKey extends TreeViewComponentNameToClassKey {}
 }
 
 // disable automatic export

package/themeAugmentation/props.d.ts

@@ -1,13 +1,17 @@
 import { TreeItemProps } from '../TreeItem';
 import { TreeViewProps } from '../TreeView';
+import { SimpleTreeViewProps } from '../SimpleTreeView';
+import { RichTreeViewProps } from '../RichTreeView';
 
-export interface PickersComponentsPropsList {
-  MuiTreeItem: TreeItemProps;
+export interface TreeViewComponentsPropsList {
+  MuiSimpleTreeView: SimpleTreeViewProps<any>;
+  MuiRichTreeView: RichTreeViewProps<any, any>;
   MuiTreeView: TreeViewProps<any>;
+  MuiTreeItem: TreeItemProps;
 }
 
 declare module '@mui/material/styles' {
-  interface ComponentsPropsList extends PickersComponentsPropsList {}
+  interface ComponentsPropsList extends TreeViewComponentsPropsList {}
 }
 
 // disable automatic export