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

package/node/internals/corePlugins/corePlugins.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.TREE_VIEW_CORE_PLUGINS = void 0;
 var _useTreeViewInstanceEvents = require("./useTreeViewInstanceEvents");
 /**
- * Internal plugins that creates the tools used by the other plugins.
+ * Internal plugins that create the tools used by the other plugins.
  * These plugins are used by the tree view components.
  */
 const TREE_VIEW_CORE_PLUGINS = exports.TREE_VIEW_CORE_PLUGINS = [_useTreeViewInstanceEvents.useTreeViewInstanceEvents];

package/node/internals/corePlugins/useTreeViewInstanceEvents/useTreeViewInstanceEvents.js

@@ -12,12 +12,6 @@ function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e;
 const isSyntheticEvent = event => {
   return event.isPropagationStopped !== undefined;
 };
-
-/**
- * Plugin responsible for the registration of the nodes defined as JSX children of the TreeView.
- * When we will have both a SimpleTreeView using JSX children and a TreeView using a data prop,
- * this plugin will only be used by SimpleTreeView.
- */
 const useTreeViewInstanceEvents = ({
   instance
 }) => {

package/node/internals/hooks/useLazyRef.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useLazyRef = useLazyRef;
+var React = _interopRequireWildcard(require("react"));
+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 UNINITIALIZED = {};
+
+// See https://github.com/facebook/react/issues/14490 for when to use this.
+function useLazyRef(init, initArg) {
+  const ref = React.useRef(UNINITIALIZED);
+  if (ref.current === UNINITIALIZED) {
+    ref.current = init(initArg);
+  }
+  return ref;
+}

package/node/internals/hooks/useOnMount.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useOnMount = useOnMount;
+var React = _interopRequireWildcard(require("react"));
+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 EMPTY = [];
+function useOnMount(fn) {
+  /* eslint-disable react-hooks/exhaustive-deps */
+  React.useEffect(fn, EMPTY);
+  /* eslint-enable react-hooks/exhaustive-deps */
+}

package/node/internals/hooks/useTimeout.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useTimeout = useTimeout;
+var _useLazyRef = require("./useLazyRef");
+var _useOnMount = require("./useOnMount");
+class Timeout {
+  constructor() {
+    this.currentId = 0;
+    this.clear = () => {
+      if (this.currentId !== 0) {
+        clearTimeout(this.currentId);
+        this.currentId = 0;
+      }
+    };
+    this.disposeEffect = () => {
+      return this.clear;
+    };
+  }
+  static create() {
+    return new Timeout();
+  }
+  start(delay, fn) {
+    this.clear();
+    this.currentId = setTimeout(fn, delay);
+  }
+}
+function useTimeout() {
+  const timeout = (0, _useLazyRef.useLazyRef)(Timeout.create).current;
+  (0, _useOnMount.useOnMount)(timeout.disposeEffect);
+  return timeout;
+}

package/node/internals/plugins/defaultPlugins.js

@@ -4,12 +4,13 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.DEFAULT_TREE_VIEW_PLUGINS = void 0;
+var _useTreeViewId = require("./useTreeViewId");
 var _useTreeViewNodes = require("./useTreeViewNodes");
 var _useTreeViewExpansion = require("./useTreeViewExpansion");
 var _useTreeViewSelection = require("./useTreeViewSelection");
 var _useTreeViewFocus = require("./useTreeViewFocus");
 var _useTreeViewKeyboardNavigation = require("./useTreeViewKeyboardNavigation");
 var _useTreeViewContextValueBuilder = require("./useTreeViewContextValueBuilder");
-const DEFAULT_TREE_VIEW_PLUGINS = exports.DEFAULT_TREE_VIEW_PLUGINS = [_useTreeViewNodes.useTreeViewNodes, _useTreeViewExpansion.useTreeViewExpansion, _useTreeViewSelection.useTreeViewSelection, _useTreeViewFocus.useTreeViewFocus, _useTreeViewKeyboardNavigation.useTreeViewKeyboardNavigation, _useTreeViewContextValueBuilder.useTreeViewContextValueBuilder];
+const DEFAULT_TREE_VIEW_PLUGINS = exports.DEFAULT_TREE_VIEW_PLUGINS = [_useTreeViewId.useTreeViewId, _useTreeViewNodes.useTreeViewNodes, _useTreeViewExpansion.useTreeViewExpansion, _useTreeViewSelection.useTreeViewSelection, _useTreeViewFocus.useTreeViewFocus, _useTreeViewKeyboardNavigation.useTreeViewKeyboardNavigation, _useTreeViewContextValueBuilder.useTreeViewContextValueBuilder];
 
 // We can't infer this type from the plugin, otherwise we would lose the generics.

package/node/internals/plugins/useTreeViewContextValueBuilder/useTreeViewContextValueBuilder.js

@@ -1,24 +1,25 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.useTreeViewContextValueBuilder = void 0;
-var _useId = _interopRequireDefault(require("@mui/utils/useId"));
 const useTreeViewContextValueBuilder = ({
   instance,
   params
 }) => {
-  const treeId = (0, _useId.default)(params.id);
   return {
-    getRootProps: () => ({
-      id: treeId
-    }),
     contextValue: {
-      treeId,
       instance: instance,
       multiSelect: params.multiSelect,
+      runItemPlugins: ({
+        props,
+        ref
+      }) => ({
+        props,
+        ref,
+        wrapItem: children => children
+      }),
       disabledItemsFocusable: params.disabledItemsFocusable,
       icons: {
         defaultCollapseIcon: params.defaultCollapseIcon,

package/node/internals/plugins/useTreeViewExpansion/useTreeViewExpansion.js

@@ -17,34 +17,43 @@ const useTreeViewExpansion = ({
   models
 }) => {
   const isNodeExpanded = React.useCallback(nodeId => {
-    return Array.isArray(models.expanded.value) ? models.expanded.value.indexOf(nodeId) !== -1 : false;
-  }, [models.expanded.value]);
+    return Array.isArray(models.expandedNodes.value) ? models.expandedNodes.value.indexOf(nodeId) !== -1 : false;
+  }, [models.expandedNodes.value]);
   const isNodeExpandable = React.useCallback(nodeId => !!instance.getNode(nodeId)?.expandable, [instance]);
   const toggleNodeExpansion = (0, _useEventCallback.default)((event, nodeId) => {
     if (nodeId == null) {
       return;
     }
+    const isExpandedBefore = models.expandedNodes.value.indexOf(nodeId) !== -1;
     let newExpanded;
-    if (models.expanded.value.indexOf(nodeId) !== -1) {
-      newExpanded = models.expanded.value.filter(id => id !== nodeId);
+    if (isExpandedBefore) {
+      newExpanded = models.expandedNodes.value.filter(id => id !== nodeId);
     } else {
-      newExpanded = [nodeId].concat(models.expanded.value);
+      newExpanded = [nodeId].concat(models.expandedNodes.value);
     }
-    if (params.onNodeToggle) {
-      params.onNodeToggle(event, newExpanded);
+    if (params.onNodeExpansionToggle) {
+      params.onNodeExpansionToggle(event, nodeId, !isExpandedBefore);
     }
-    models.expanded.setValue(newExpanded);
+    if (params.onExpandedNodesChange) {
+      params.onExpandedNodesChange(event, newExpanded);
+    }
+    models.expandedNodes.setValue(newExpanded);
   });
   const expandAllSiblings = (event, nodeId) => {
     const node = instance.getNode(nodeId);
     const siblings = instance.getChildrenIds(node.parentId);
     const diff = siblings.filter(child => instance.isNodeExpandable(child) && !instance.isNodeExpanded(child));
-    const newExpanded = models.expanded.value.concat(diff);
+    const newExpanded = models.expandedNodes.value.concat(diff);
     if (diff.length > 0) {
-      models.expanded.setValue(newExpanded);
-      if (params.onNodeToggle) {
-        params.onNodeToggle(event, newExpanded);
+      if (params.onNodeExpansionToggle) {
+        diff.forEach(newlyExpandedNodeId => {
+          params.onNodeExpansionToggle(event, newlyExpandedNodeId, true);
+        });
+      }
+      if (params.onExpandedNodesChange) {
+        params.onExpandedNodesChange(event, newExpanded);
       }
+      models.expandedNodes.setValue(newExpanded);
     }
   };
   (0, _useTreeView.populateInstance)(instance, {
@@ -56,12 +65,12 @@ const useTreeViewExpansion = ({
 };
 exports.useTreeViewExpansion = useTreeViewExpansion;
 useTreeViewExpansion.models = {
-  expanded: {
-    controlledProp: 'expanded',
-    defaultProp: 'defaultExpanded'
+  expandedNodes: {
+    controlledProp: 'expandedNodes',
+    defaultProp: 'defaultExpandedNodes'
   }
 };
-const DEFAULT_EXPANDED = [];
+const DEFAULT_EXPANDED_NODES = [];
 useTreeViewExpansion.getDefaultizedParams = params => (0, _extends2.default)({}, params, {
-  defaultExpanded: params.defaultExpanded ?? DEFAULT_EXPANDED
+  defaultExpandedNodes: params.defaultExpandedNodes ?? DEFAULT_EXPANDED_NODES
 });

package/node/internals/plugins/useTreeViewFocus/useTreeViewFocus.js

@@ -36,9 +36,15 @@ const useTreeViewFocus = ({
       }
     }
   });
+  const focusRoot = (0, _useEventCallback.default)(() => {
+    rootRef.current?.focus({
+      preventScroll: true
+    });
+  });
   (0, _useTreeView.populateInstance)(instance, {
     isNodeFocused,
-    focusNode
+    focusNode,
+    focusRoot
   });
   (0, _useInstanceEventHandler.useInstanceEventHandler)(instance, 'removeNode', ({
     id
@@ -60,10 +66,10 @@ const useTreeViewFocus = ({
         return node && (node.parentId == null || instance.isNodeExpanded(node.parentId));
       };
       let nodeToFocusId;
-      if (Array.isArray(models.selected.value)) {
-        nodeToFocusId = models.selected.value.find(isNodeVisible);
-      } else if (models.selected.value != null && isNodeVisible(models.selected.value)) {
-        nodeToFocusId = models.selected.value;
+      if (Array.isArray(models.selectedNodes.value)) {
+        nodeToFocusId = models.selectedNodes.value.find(isNodeVisible);
+      } else if (models.selectedNodes.value != null && isNodeVisible(models.selectedNodes.value)) {
+        nodeToFocusId = models.selectedNodes.value;
       }
       if (nodeToFocusId == null) {
         nodeToFocusId = instance.getNavigableChildrenIds(null)[0];
@@ -76,7 +82,7 @@ const useTreeViewFocus = ({
     setFocusedNodeId(null);
   };
   const focusedNode = instance.getNode(state.focusedNodeId);
-  const activeDescendant = focusedNode ? focusedNode.idAttribute : null;
+  const activeDescendant = focusedNode ? instance.getTreeItemId(focusedNode.id, focusedNode.idAttribute) : null;
   return {
     getRootProps: otherHandlers => ({
       onFocus: createHandleFocus(otherHandlers),

package/node/internals/plugins/useTreeViewId/index.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "useTreeViewId", {
+  enumerable: true,
+  get: function () {
+    return _useTreeViewId.useTreeViewId;
+  }
+});
+var _useTreeViewId = require("./useTreeViewId");

package/node/internals/plugins/useTreeViewId/useTreeViewId.js

@@ -0,0 +1,28 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useTreeViewId = void 0;
+var React = _interopRequireWildcard(require("react"));
+var _useId = _interopRequireDefault(require("@mui/utils/useId"));
+var _useTreeView = require("../../useTreeView/useTreeView.utils");
+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 useTreeViewId = ({
+  instance,
+  params
+}) => {
+  const treeId = (0, _useId.default)(params.id);
+  const getTreeItemId = React.useCallback((nodeId, idAttribute) => idAttribute ?? `${treeId}-${nodeId}`, [treeId]);
+  (0, _useTreeView.populateInstance)(instance, {
+    getTreeItemId
+  });
+  return {
+    getRootProps: () => ({
+      id: treeId
+    })
+  };
+};
+exports.useTreeViewId = useTreeViewId;

package/node/internals/plugins/useTreeViewId/useTreeViewId.types.js

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

package/node/internals/plugins/useTreeViewJSXNodes/index.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "useTreeViewJSXNodes", {
+  enumerable: true,
+  get: function () {
+    return _useTreeViewJSXNodes.useTreeViewJSXNodes;
+  }
+});
+var _useTreeViewJSXNodes = require("./useTreeViewJSXNodes");

package/node/internals/plugins/useTreeViewJSXNodes/useTreeViewJSXNodes.js

@@ -0,0 +1,123 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useTreeViewJSXNodes = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var React = _interopRequireWildcard(require("react"));
+var _useEventCallback = _interopRequireDefault(require("@mui/utils/useEventCallback"));
+var _useForkRef = _interopRequireDefault(require("@mui/utils/useForkRef"));
+var _useTreeView = require("../../useTreeView/useTreeView.utils");
+var _publishTreeViewEvent = require("../../utils/publishTreeViewEvent");
+var _useTreeViewContext = require("../../TreeViewProvider/useTreeViewContext");
+var _DescendantProvider = require("../../TreeViewProvider/DescendantProvider");
+var _jsxRuntime = require("react/jsx-runtime");
+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 useTreeViewJSXNodes = ({
+  instance,
+  setState
+}) => {
+  const insertJSXNode = (0, _useEventCallback.default)(node => {
+    setState(prevState => (0, _extends2.default)({}, prevState, {
+      nodeMap: (0, _extends2.default)({}, prevState.nodeMap, {
+        [node.id]: node
+      })
+    }));
+  });
+  const removeJSXNode = (0, _useEventCallback.default)(nodeId => {
+    setState(prevState => {
+      const newMap = (0, _extends2.default)({}, prevState.nodeMap);
+      delete newMap[nodeId];
+      return (0, _extends2.default)({}, prevState, {
+        nodeMap: newMap
+      });
+    });
+    (0, _publishTreeViewEvent.publishTreeViewEvent)(instance, 'removeNode', {
+      id: nodeId
+    });
+  });
+  const mapFirstCharFromJSX = (0, _useEventCallback.default)((nodeId, firstChar) => {
+    instance.updateFirstCharMap(firstCharMap => {
+      firstCharMap[nodeId] = firstChar;
+      return firstCharMap;
+    });
+    return () => {
+      instance.updateFirstCharMap(firstCharMap => {
+        const newMap = (0, _extends2.default)({}, firstCharMap);
+        delete newMap[nodeId];
+        return newMap;
+      });
+    };
+  });
+  (0, _useTreeView.populateInstance)(instance, {
+    insertJSXNode,
+    removeJSXNode,
+    mapFirstCharFromJSX
+  });
+};
+exports.useTreeViewJSXNodes = useTreeViewJSXNodes;
+const useTreeViewJSXNodesItemPlugin = ({
+  props,
+  ref
+}) => {
+  const {
+    children,
+    disabled = false,
+    label,
+    nodeId,
+    id,
+    ContentProps: inContentProps
+  } = props;
+  const {
+    instance
+  } = (0, _useTreeViewContext.useTreeViewContext)();
+  const expandable = Boolean(Array.isArray(children) ? children.length : children);
+  const [treeItemElement, setTreeItemElement] = React.useState(null);
+  const contentRef = React.useRef(null);
+  const handleRef = (0, _useForkRef.default)(setTreeItemElement, ref);
+  const descendant = React.useMemo(() => ({
+    element: treeItemElement,
+    id: nodeId
+  }), [nodeId, treeItemElement]);
+  const {
+    index,
+    parentId
+  } = (0, _DescendantProvider.useDescendant)(descendant);
+  React.useEffect(() => {
+    // On the first render a node's index will be -1. We want to wait for the real index.
+    if (instance && index !== -1) {
+      instance.insertJSXNode({
+        id: nodeId,
+        idAttribute: id,
+        index,
+        parentId,
+        expandable,
+        disabled
+      });
+      return () => instance.removeJSXNode(nodeId);
+    }
+    return undefined;
+  }, [instance, parentId, index, nodeId, expandable, disabled, id]);
+  React.useEffect(() => {
+    if (instance && label) {
+      return instance.mapFirstCharFromJSX(nodeId, (contentRef.current?.textContent ?? '').substring(0, 1).toLowerCase());
+    }
+    return undefined;
+  }, [instance, nodeId, label]);
+  return {
+    props: (0, _extends2.default)({}, props, {
+      ContentProps: (0, _extends2.default)({}, inContentProps, {
+        ref: contentRef
+      })
+    }),
+    ref: handleRef,
+    wrapItem: item => /*#__PURE__*/(0, _jsxRuntime.jsx)(_DescendantProvider.DescendantProvider, {
+      id: nodeId,
+      children: item
+    })
+  };
+};
+useTreeViewJSXNodes.itemPlugin = useTreeViewJSXNodesItemPlugin;

package/node/internals/plugins/useTreeViewJSXNodes/useTreeViewJSXNodes.types.js

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

package/node/internals/plugins/useTreeViewKeyboardNavigation/useTreeViewKeyboardNavigation.js

@@ -5,7 +5,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.useTreeViewKeyboardNavigation = void 0;
-var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
 var React = _interopRequireWildcard(require("react"));
 var _styles = require("@mui/material/styles");
 var _useEventCallback = _interopRequireDefault(require("@mui/utils/useEventCallback"));
@@ -31,16 +30,27 @@ const useTreeViewKeyboardNavigation = ({
   const theme = (0, _styles.useTheme)();
   const isRtl = theme.direction === 'rtl';
   const firstCharMap = React.useRef({});
-  const mapFirstChar = (0, _useEventCallback.default)((nodeId, firstChar) => {
-    firstCharMap.current[nodeId] = firstChar;
-    return () => {
-      const newMap = (0, _extends2.default)({}, firstCharMap.current);
-      delete newMap[nodeId];
-      firstCharMap.current = newMap;
-    };
+  const hasFirstCharMapBeenUpdatedImperatively = React.useRef(false);
+  const updateFirstCharMap = (0, _useEventCallback.default)(callback => {
+    hasFirstCharMapBeenUpdatedImperatively.current = true;
+    firstCharMap.current = callback(firstCharMap.current);
   });
+  React.useEffect(() => {
+    if (hasFirstCharMapBeenUpdatedImperatively.current) {
+      return;
+    }
+    const newFirstCharMap = {};
+    const processItem = item => {
+      const getItemId = params.getItemId;
+      const nodeId = getItemId ? getItemId(item) : item.id;
+      newFirstCharMap[nodeId] = instance.getNode(nodeId).label.substring(0, 1).toLowerCase();
+      item.children?.forEach(processItem);
+    };
+    params.items.forEach(processItem);
+    firstCharMap.current = newFirstCharMap;
+  }, [params.items, params.getItemId, instance]);
   (0, _useTreeView.populateInstance)(instance, {
-    mapFirstChar
+    updateFirstCharMap
   });
   const handleNextArrow = event => {
     if (state.focusedNodeId != null && instance.isNodeExpandable(state.focusedNodeId)) {

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: 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: 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,51 @@ 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
+});