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

package/internals/plugins/useTreeViewExpansion/useTreeViewExpansion.js

@@ -8,8 +8,8 @@ export 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 => {
     var _instance$getNode;
     return !!((_instance$getNode = instance.getNode(nodeId)) != null && _instance$getNode.expandable);
@@ -18,27 +18,36 @@ export const useTreeViewExpansion = ({
     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);
     }
   };
   populateInstance(instance, {
@@ -49,15 +58,15 @@ export const useTreeViewExpansion = ({
   });
 };
 useTreeViewExpansion.models = {
-  expanded: {
-    controlledProp: 'expanded',
-    defaultProp: 'defaultExpanded'
+  expandedNodes: {
+    controlledProp: 'expandedNodes',
+    defaultProp: 'defaultExpandedNodes'
   }
 };
-const DEFAULT_EXPANDED = [];
+const DEFAULT_EXPANDED_NODES = [];
 useTreeViewExpansion.getDefaultizedParams = params => {
   var _params$defaultExpand;
   return _extends({}, params, {
-    defaultExpanded: (_params$defaultExpand = params.defaultExpanded) != null ? _params$defaultExpand : DEFAULT_EXPANDED
+    defaultExpandedNodes: (_params$defaultExpand = params.defaultExpandedNodes) != null ? _params$defaultExpand : DEFAULT_EXPANDED_NODES
   });
 };

package/internals/plugins/useTreeViewExpansion/useTreeViewExpansion.types.d.ts

@@ -12,21 +12,28 @@ export interface UseTreeViewExpansionParameters {
      * Expanded node ids.
      * Used when the item's expansion is controlled.
      */
-    expanded?: string[];
+    expandedNodes?: string[];
     /**
      * Expanded node ids.
      * Used when the item's expansion is not controlled.
      * @default []
      */
-    defaultExpanded?: string[];
+    defaultExpandedNodes?: string[];
     /**
      * Callback fired when tree items are expanded/collapsed.
      * @param {React.SyntheticEvent} event The event source of the callback.
      * @param {array} nodeIds The ids of the expanded nodes.
      */
-    onNodeToggle?: (event: React.SyntheticEvent, nodeIds: string[]) => void;
+    onExpandedNodesChange?: (event: React.SyntheticEvent, nodeIds: string[]) => void;
+    /**
+     * Callback fired when a tree item is expanded or collapsed.
+     * @param {React.SyntheticEvent} event The event source of the callback.
+     * @param {array} nodeId The nodeId of the modified node.
+     * @param {array} isExpanded `true` if the node has just been expanded, `false` if it has just been collapsed.
+     */
+    onNodeExpansionToggle?: (event: React.SyntheticEvent, nodeId: string, isExpanded: boolean) => void;
 }
-export type UseTreeViewExpansionDefaultizedParameters = DefaultizedProps<UseTreeViewExpansionParameters, 'defaultExpanded'>;
-export type UseTreeViewExpansionSignature = TreeViewPluginSignature<UseTreeViewExpansionParameters, UseTreeViewExpansionDefaultizedParameters, UseTreeViewExpansionInstance, {}, {}, 'expanded', [
+export type UseTreeViewExpansionDefaultizedParameters = DefaultizedProps<UseTreeViewExpansionParameters, 'defaultExpandedNodes'>;
+export type UseTreeViewExpansionSignature = TreeViewPluginSignature<UseTreeViewExpansionParameters, UseTreeViewExpansionDefaultizedParameters, UseTreeViewExpansionInstance, {}, {}, 'expandedNodes', [
     UseTreeViewNodesSignature
 ]>;

package/internals/plugins/useTreeViewFocus/useTreeViewFocus.js

@@ -27,9 +27,16 @@ export const useTreeViewFocus = ({
       }
     }
   });
+  const focusRoot = useEventCallback(() => {
+    var _rootRef$current;
+    (_rootRef$current = rootRef.current) == null || _rootRef$current.focus({
+      preventScroll: true
+    });
+  });
   populateInstance(instance, {
     isNodeFocused,
-    focusNode
+    focusNode,
+    focusRoot
   });
   useInstanceEventHandler(instance, 'removeNode', ({
     id
@@ -52,10 +59,10 @@ export 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];
@@ -69,7 +76,7 @@ export 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/internals/plugins/useTreeViewFocus/useTreeViewFocus.types.d.ts

@@ -1,11 +1,13 @@
 import * as React from 'react';
 import { TreeViewPluginSignature } from '../../models';
+import { UseTreeViewIdSignature } from '../useTreeViewId/useTreeViewId.types';
 import type { UseTreeViewNodesSignature } from '../useTreeViewNodes';
 import type { UseTreeViewSelectionSignature } from '../useTreeViewSelection';
 import { UseTreeViewExpansionSignature } from '../useTreeViewExpansion';
 export interface UseTreeViewFocusInstance {
     isNodeFocused: (nodeId: string) => boolean;
     focusNode: (event: React.SyntheticEvent, nodeId: string | null) => void;
+    focusRoot: () => void;
 }
 export interface UseTreeViewFocusParameters {
     /**
@@ -21,7 +23,8 @@ export interface UseTreeViewFocusState {
     focusedNodeId: string | null;
 }
 export type UseTreeViewFocusSignature = TreeViewPluginSignature<UseTreeViewFocusParameters, UseTreeViewFocusParameters, UseTreeViewFocusInstance, {}, UseTreeViewFocusState, never, [
+    UseTreeViewIdSignature,
     UseTreeViewNodesSignature,
-    UseTreeViewSelectionSignature<any>,
+    UseTreeViewSelectionSignature,
     UseTreeViewExpansionSignature
 ]>;

package/internals/plugins/useTreeViewId/index.d.ts

@@ -0,0 +1,2 @@
+export { useTreeViewId } from './useTreeViewId';
+export type { UseTreeViewIdSignature, UseTreeViewIdParameters, UseTreeViewIdDefaultizedParameters, } from './useTreeViewId.types';

package/internals/plugins/useTreeViewId/index.js

@@ -0,0 +1 @@
+export { useTreeViewId } from './useTreeViewId';

package/internals/plugins/useTreeViewId/useTreeViewId.d.ts

@@ -0,0 +1,3 @@
+import { TreeViewPlugin } from '../../models';
+import { UseTreeViewIdSignature } from './useTreeViewId.types';
+export declare const useTreeViewId: TreeViewPlugin<UseTreeViewIdSignature>;

package/internals/plugins/useTreeViewId/useTreeViewId.js

@@ -0,0 +1,18 @@
+import * as React from 'react';
+import useId from '@mui/utils/useId';
+import { populateInstance } from '../../useTreeView/useTreeView.utils';
+export const useTreeViewId = ({
+  instance,
+  params
+}) => {
+  const treeId = useId(params.id);
+  const getTreeItemId = React.useCallback((nodeId, idAttribute) => idAttribute != null ? idAttribute : `${treeId}-${nodeId}`, [treeId]);
+  populateInstance(instance, {
+    getTreeItemId
+  });
+  return {
+    getRootProps: () => ({
+      id: treeId
+    })
+  };
+};

package/internals/plugins/useTreeViewId/useTreeViewId.types.d.ts

@@ -0,0 +1,17 @@
+import { TreeViewPluginSignature } from '../../models';
+export interface UseTreeViewIdInstance {
+    getTreeItemId: (nodeId: string, idAttribute: string | undefined) => string;
+}
+export interface UseTreeViewIdParameters {
+    /**
+     * This prop is used to help implement the accessibility logic.
+     * If you don't provide this prop. It falls back to a randomly generated id.
+     */
+    id?: string;
+}
+export type UseTreeViewIdDefaultizedParameters = UseTreeViewIdParameters;
+export interface UseTreeViewIdState {
+    focusedNodeId: string | null;
+}
+export type UseTreeViewIdSignature = TreeViewPluginSignature<UseTreeViewIdParameters, UseTreeViewIdDefaultizedParameters, UseTreeViewIdInstance, {}, UseTreeViewIdState, never, [
+]>;

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

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

package/internals/plugins/useTreeViewJSXNodes/index.d.ts

@@ -0,0 +1,2 @@
+export { useTreeViewJSXNodes } from './useTreeViewJSXNodes';
+export type { UseTreeViewJSXNodesSignature, UseTreeViewNodesParameters, UseTreeViewNodesDefaultizedParameters, } from './useTreeViewJSXNodes.types';

package/internals/plugins/useTreeViewJSXNodes/index.js

@@ -0,0 +1 @@
+export { useTreeViewJSXNodes } from './useTreeViewJSXNodes';

package/internals/plugins/useTreeViewJSXNodes/useTreeViewJSXNodes.d.ts

@@ -0,0 +1,3 @@
+import { TreeViewPlugin } from '../../models';
+import { UseTreeViewJSXNodesSignature } from './useTreeViewJSXNodes.types';
+export declare const useTreeViewJSXNodes: TreeViewPlugin<UseTreeViewJSXNodesSignature>;

package/internals/plugins/useTreeViewJSXNodes/useTreeViewJSXNodes.js

@@ -0,0 +1,114 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import * as React from 'react';
+import useEventCallback from '@mui/utils/useEventCallback';
+import useForkRef from '@mui/utils/useForkRef';
+import { populateInstance } from '../../useTreeView/useTreeView.utils';
+import { publishTreeViewEvent } from '../../utils/publishTreeViewEvent';
+import { useTreeViewContext } from '../../TreeViewProvider/useTreeViewContext';
+import { DescendantProvider, useDescendant } from '../../TreeViewProvider/DescendantProvider';
+import { jsx as _jsx } from "react/jsx-runtime";
+export const useTreeViewJSXNodes = ({
+  instance,
+  setState
+}) => {
+  const insertJSXNode = useEventCallback(node => {
+    setState(prevState => _extends({}, prevState, {
+      nodeMap: _extends({}, prevState.nodeMap, {
+        [node.id]: node
+      })
+    }));
+  });
+  const removeJSXNode = useEventCallback(nodeId => {
+    setState(prevState => {
+      const newMap = _extends({}, prevState.nodeMap);
+      delete newMap[nodeId];
+      return _extends({}, prevState, {
+        nodeMap: newMap
+      });
+    });
+    publishTreeViewEvent(instance, 'removeNode', {
+      id: nodeId
+    });
+  });
+  const mapFirstCharFromJSX = useEventCallback((nodeId, firstChar) => {
+    instance.updateFirstCharMap(firstCharMap => {
+      firstCharMap[nodeId] = firstChar;
+      return firstCharMap;
+    });
+    return () => {
+      instance.updateFirstCharMap(firstCharMap => {
+        const newMap = _extends({}, firstCharMap);
+        delete newMap[nodeId];
+        return newMap;
+      });
+    };
+  });
+  populateInstance(instance, {
+    insertJSXNode,
+    removeJSXNode,
+    mapFirstCharFromJSX
+  });
+};
+const useTreeViewJSXNodesItemPlugin = ({
+  props,
+  ref
+}) => {
+  const {
+    children,
+    disabled = false,
+    label,
+    nodeId,
+    id,
+    ContentProps: inContentProps
+  } = props;
+  const {
+    instance
+  } = useTreeViewContext();
+  const expandable = Boolean(Array.isArray(children) ? children.length : children);
+  const [treeItemElement, setTreeItemElement] = React.useState(null);
+  const contentRef = React.useRef(null);
+  const handleRef = useForkRef(setTreeItemElement, ref);
+  const descendant = React.useMemo(() => ({
+    element: treeItemElement,
+    id: nodeId
+  }), [nodeId, treeItemElement]);
+  const {
+    index,
+    parentId
+  } = 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) {
+      var _contentRef$current$t, _contentRef$current;
+      return instance.mapFirstCharFromJSX(nodeId, ((_contentRef$current$t = (_contentRef$current = contentRef.current) == null ? void 0 : _contentRef$current.textContent) != null ? _contentRef$current$t : '').substring(0, 1).toLowerCase());
+    }
+    return undefined;
+  }, [instance, nodeId, label]);
+  return {
+    props: _extends({}, props, {
+      ContentProps: _extends({}, inContentProps, {
+        ref: contentRef
+      })
+    }),
+    ref: handleRef,
+    wrapItem: item => /*#__PURE__*/_jsx(DescendantProvider, {
+      id: nodeId,
+      children: item
+    })
+  };
+};
+useTreeViewJSXNodes.itemPlugin = useTreeViewJSXNodesItemPlugin;

package/internals/plugins/useTreeViewJSXNodes/useTreeViewJSXNodes.types.d.ts

@@ -0,0 +1,16 @@
+import { TreeViewNode, TreeViewPluginSignature } from '../../models';
+import { UseTreeViewNodesSignature } from '../useTreeViewNodes';
+import { UseTreeViewKeyboardNavigationSignature } from '../useTreeViewKeyboardNavigation';
+export interface UseTreeViewNodesInstance {
+    insertJSXNode: (node: TreeViewNode) => void;
+    removeJSXNode: (nodeId: string) => void;
+    mapFirstCharFromJSX: (nodeId: string, firstChar: string) => () => void;
+}
+export interface UseTreeViewNodesParameters {
+}
+export interface UseTreeViewNodesDefaultizedParameters {
+}
+export type UseTreeViewJSXNodesSignature = TreeViewPluginSignature<UseTreeViewNodesParameters, UseTreeViewNodesDefaultizedParameters, UseTreeViewNodesInstance, {}, {}, never, [
+    UseTreeViewNodesSignature,
+    UseTreeViewKeyboardNavigationSignature
+]>;

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

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

package/internals/plugins/useTreeViewKeyboardNavigation/useTreeViewKeyboardNavigation.js

@@ -1,4 +1,3 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
 import * as React from 'react';
 import { useTheme } from '@mui/material/styles';
 import useEventCallback from '@mui/utils/useEventCallback';
@@ -22,16 +21,28 @@ export const useTreeViewKeyboardNavigation = ({
   const theme = useTheme();
   const isRtl = theme.direction === 'rtl';
   const firstCharMap = React.useRef({});
-  const mapFirstChar = useEventCallback((nodeId, firstChar) => {
-    firstCharMap.current[nodeId] = firstChar;
-    return () => {
-      const newMap = _extends({}, firstCharMap.current);
-      delete newMap[nodeId];
-      firstCharMap.current = newMap;
-    };
+  const hasFirstCharMapBeenUpdatedImperatively = React.useRef(false);
+  const updateFirstCharMap = useEventCallback(callback => {
+    hasFirstCharMapBeenUpdatedImperatively.current = true;
+    firstCharMap.current = callback(firstCharMap.current);
   });
+  React.useEffect(() => {
+    if (hasFirstCharMapBeenUpdatedImperatively.current) {
+      return;
+    }
+    const newFirstCharMap = {};
+    const processItem = item => {
+      var _item$children;
+      const getItemId = params.getItemId;
+      const nodeId = getItemId ? getItemId(item) : item.id;
+      newFirstCharMap[nodeId] = instance.getNode(nodeId).label.substring(0, 1).toLowerCase();
+      (_item$children = item.children) == null || _item$children.forEach(processItem);
+    };
+    params.items.forEach(processItem);
+    firstCharMap.current = newFirstCharMap;
+  }, [params.items, params.getItemId, instance]);
   populateInstance(instance, {
-    mapFirstChar
+    updateFirstCharMap
   });
   const handleNextArrow = event => {
     if (state.focusedNodeId != null && instance.isNodeExpandable(state.focusedNodeId)) {

package/internals/plugins/useTreeViewKeyboardNavigation/useTreeViewKeyboardNavigation.types.d.ts

@@ -4,11 +4,14 @@ import { UseTreeViewSelectionSignature } from '../useTreeViewSelection';
 import { UseTreeViewFocusSignature } from '../useTreeViewFocus';
 import { UseTreeViewExpansionSignature } from '../useTreeViewExpansion';
 export interface UseTreeViewKeyboardNavigationInstance {
-    mapFirstChar: (nodeId: string, firstChar: string) => () => void;
+    updateFirstCharMap: (updater: (map: TreeViewFirstCharMap) => TreeViewFirstCharMap) => void;
 }
 export type UseTreeViewKeyboardNavigationSignature = TreeViewPluginSignature<{}, {}, UseTreeViewKeyboardNavigationInstance, {}, {}, never, [
     UseTreeViewNodesSignature,
-    UseTreeViewSelectionSignature<any>,
+    UseTreeViewSelectionSignature,
     UseTreeViewFocusSignature,
     UseTreeViewExpansionSignature
 ]>;
+export type TreeViewFirstCharMap = {
+    [nodeId: string]: string;
+};

package/internals/plugins/useTreeViewNodes/useTreeViewNodes.js

@@ -3,23 +3,50 @@ import * as React from 'react';
 import useEventCallback from '@mui/utils/useEventCallback';
 import { populateInstance } from '../../useTreeView/useTreeView.utils';
 import { publishTreeViewEvent } from '../../utils/publishTreeViewEvent';
+const updateState = ({
+  items,
+  isItemDisabled,
+  getItemLabel,
+  getItemId
+}) => {
+  const nodeMap = {};
+  const processItem = (item, index, parentId) => {
+    var _item$children, _item$children2;
+    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 = item.children) != null && _item$children.length),
+      disabled: isItemDisabled ? isItemDisabled(item) : false
+    };
+    return {
+      id,
+      children: (_item$children2 = item.children) == null ? void 0 : _item$children2.map((child, childIndex) => processItem(child, childIndex, id))
+    };
+  };
+  const nodeTree = items.map((item, itemIndex) => processItem(item, itemIndex, null));
+  return {
+    nodeMap,
+    nodeTree
+  };
+};
 export 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 = _extends({}, nodeMap.current);
-    delete newMap[nodeId];
-    nodeMap.current = newMap;
-    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;
@@ -41,7 +68,7 @@ export const useTreeViewNodes = ({
     }
     return false;
   }, [instance]);
-  const getChildrenIds = useEventCallback(nodeId => Object.values(nodeMap.current).filter(node => node.parentId === nodeId).sort((a, b) => a.index - b.index).map(child => child.id));
+  const getChildrenIds = useEventCallback(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) {
@@ -49,12 +76,50 @@ export 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]) {
+          publishTreeViewEvent(instance, 'removeNode', {
+            id: node.id
+          });
+        }
+      });
+      return _extends({}, prevState, newState);
+    });
+  }, [instance, setState, params.items, params.isItemDisabled, params.getItemId, params.getItemLabel]);
+  const getNodesToRender = useEventCallback(() => {
+    const getPropsFromNodeId = ({
+      id,
+      children
+    }) => {
+      const node = state.nodeMap[id];
+      return {
+        label: node.label,
+        nodeId: node.id,
+        id: node.idAttribute,
+        children: children == null ? void 0 : children.map(getPropsFromNodeId)
+      };
+    };
+    return state.nodeTree.map(getPropsFromNodeId);
+  });
   populateInstance(instance, {
     getNode,
-    updateNode: insertNode,
-    removeNode,
+    getNodesToRender,
     getChildrenIds,
     getNavigableChildrenIds,
     isNodeDisabled
   });
-};
+};
+useTreeViewNodes.getInitialState = params => updateState({
+  items: params.items,
+  isItemDisabled: params.isItemDisabled,
+  getItemId: params.getItemId,
+  getItemLabel: params.getItemLabel
+});

package/internals/plugins/useTreeViewNodes/useTreeViewNodes.types.d.ts

@@ -1,20 +1,52 @@
 import { TreeViewNode, DefaultizedProps, TreeViewPluginSignature } from '../../models';
+import { TreeViewItemId } from '../../../models';
+interface TreeViewNodeProps {
+    label: string;
+    nodeId: string;
+    id: string | undefined;
+    children?: TreeViewNodeProps[];
+}
 export interface UseTreeViewNodesInstance {
     getNode: (nodeId: string) => TreeViewNode;
-    updateNode: (node: TreeViewNode) => void;
-    removeNode: (nodeId: string) => void;
+    getNodesToRender: () => TreeViewNodeProps[];
     getChildrenIds: (nodeId: string | null) => string[];
     getNavigableChildrenIds: (nodeId: string | null) => string[];
     isNodeDisabled: (nodeId: string | null) => nodeId is string;
 }
-export interface UseTreeViewNodesParameters {
+export interface UseTreeViewNodesParameters<R extends {}> {
     /**
      * If `true`, will allow focus on disabled items.
      * @default false
      */
     disabledItemsFocusable?: boolean;
+    items: readonly R[];
+    /**
+     * Used to determine if a given item should be disabled.
+     * @template R
+     * @param {R} item The item to check.
+     * @returns {boolean} `true` if the item should be disabled.
+     */
+    isItemDisabled?: (item: R) => boolean;
+    /**
+     * Used to determine the string label for a given item.
+     *
+     * @template R
+     * @param {R} item The item to check.
+     * @returns {string} The label of the item.
+     * @default `(item) => item.label`
+     */
+    getItemLabel?: (item: R) => string;
+    /**
+     * Used to determine the string label for a given item.
+     *
+     * @template R
+     * @param {R} item The item to check.
+     * @returns {string} The id of the item.
+     * @default `(item) => item.id`
+     */
+    getItemId?: (item: R) => TreeViewItemId;
 }
-export type UseTreeViewNodesDefaultizedParameters = DefaultizedProps<UseTreeViewNodesParameters, 'disabledItemsFocusable'>;
+export type UseTreeViewNodesDefaultizedParameters<R extends {}> = DefaultizedProps<UseTreeViewNodesParameters<R>, 'disabledItemsFocusable'>;
 interface UseTreeViewNodesEventLookup {
     removeNode: {
         params: {
@@ -22,6 +54,17 @@ interface UseTreeViewNodesEventLookup {
         };
     };
 }
-export type UseTreeViewNodesSignature = TreeViewPluginSignature<UseTreeViewNodesParameters, UseTreeViewNodesDefaultizedParameters, UseTreeViewNodesInstance, UseTreeViewNodesEventLookup, {}, never, [
+export interface TreeViewNodeIdAndChildren {
+    id: TreeViewItemId;
+    children?: TreeViewNodeIdAndChildren[];
+}
+export interface UseTreeViewNodesState {
+    nodeTree: TreeViewNodeIdAndChildren[];
+    nodeMap: TreeViewNodeMap;
+}
+export type UseTreeViewNodesSignature = TreeViewPluginSignature<UseTreeViewNodesParameters<any>, UseTreeViewNodesDefaultizedParameters<any>, UseTreeViewNodesInstance, UseTreeViewNodesEventLookup, UseTreeViewNodesState, never, [
 ]>;
+export type TreeViewNodeMap = {
+    [nodeId: string]: TreeViewNode;
+};
 export {};

package/internals/plugins/useTreeViewSelection/useTreeViewSelection.d.ts

@@ -1,3 +1,3 @@
 import { TreeViewPlugin } from '../../models';
 import { UseTreeViewSelectionSignature } from './useTreeViewSelection.types';
-export declare const useTreeViewSelection: TreeViewPlugin<UseTreeViewSelectionSignature<any>>;
+export declare const useTreeViewSelection: TreeViewPlugin<UseTreeViewSelectionSignature>;