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

package/internals/plugins/useTreeViewJSXNodes/useTreeViewJSXNodes.js

@@ -0,0 +1,115 @@
+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;
+useTreeViewJSXNodes.params = {};

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,10 +1,9 @@
-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';
 import { getFirstNode, getLastNode, getNextNode, getPreviousNode, populateInstance } from '../../useTreeView/useTreeView.utils';
 function isPrintableCharacter(string) {
-  return string && string.length === 1 && string.match(/\S/);
+  return !!string && string.length === 1 && !!string.match(/\S/);
 }
 function findNextFirstChar(firstChars, startIndex, char) {
   for (let i = startIndex; i < firstChars.length; i += 1) {
@@ -20,45 +19,32 @@ export const useTreeViewKeyboardNavigation = ({
   state
 }) => {
   const theme = useTheme();
-  const isRtl = theme.direction === 'rtl';
+  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)) {
-      if (instance.isNodeExpanded(state.focusedNodeId)) {
-        instance.focusNode(event, getNextNode(instance, state.focusedNodeId));
-      } else if (!instance.isNodeDisabled(state.focusedNodeId)) {
-        instance.toggleNodeExpansion(event, state.focusedNodeId);
-      }
-    }
-    return true;
-  };
-  const handlePreviousArrow = event => {
-    if (state.focusedNodeId == null) {
-      return false;
-    }
-    if (instance.isNodeExpanded(state.focusedNodeId) && !instance.isNodeDisabled(state.focusedNodeId)) {
-      instance.toggleNodeExpansion(event, state.focusedNodeId);
-      return true;
-    }
-    const parent = instance.getNode(state.focusedNodeId).parentId;
-    if (parent) {
-      instance.focusNode(event, parent);
-      return true;
-    }
-    return false;
-  };
-  const focusByFirstCharacter = (event, nodeId, firstChar) => {
+  const getFirstMatchingNode = (nodeId, firstChar) => {
     let start;
     let index;
     const lowercaseChar = firstChar.toLowerCase();
@@ -89,42 +75,36 @@ export const useTreeViewKeyboardNavigation = ({
       index = findNextFirstChar(firstChars, 0, lowercaseChar);
     }
 
-    // If match was found...
+    // If a match was found...
     if (index > -1) {
-      instance.focusNode(event, firstCharIds[index]);
-    }
-  };
-  const selectNextNode = (event, id) => {
-    if (!instance.isNodeDisabled(getNextNode(instance, id))) {
-      instance.selectRange(event, {
-        end: getNextNode(instance, id),
-        current: id
-      }, true);
-    }
-  };
-  const selectPreviousNode = (event, nodeId) => {
-    if (!instance.isNodeDisabled(getPreviousNode(instance, nodeId))) {
-      instance.selectRange(event, {
-        end: getPreviousNode(instance, nodeId),
-        current: nodeId
-      }, true);
+      return firstCharIds[index];
     }
+    return null;
   };
+  const canToggleNodeSelection = nodeId => !params.disableSelection && !instance.isNodeDisabled(nodeId);
+  const canToggleNodeExpansion = nodeId => !instance.isNodeDisabled(nodeId) && instance.isNodeExpandable(nodeId);
+
+  // ARIA specification: https://www.w3.org/WAI/ARIA/apg/patterns/treeview/#keyboardinteraction
   const createHandleKeyDown = otherHandlers => event => {
     var _otherHandlers$onKeyD;
     (_otherHandlers$onKeyD = otherHandlers.onKeyDown) == null || _otherHandlers$onKeyD.call(otherHandlers, event);
-    let flag = false;
-    const key = event.key;
+    if (event.defaultMuiPrevented) {
+      return;
+    }
 
     // If the tree is empty there will be no focused node
     if (event.altKey || event.currentTarget !== event.target || state.focusedNodeId == null) {
       return;
     }
     const ctrlPressed = event.ctrlKey || event.metaKey;
-    switch (key) {
-      case ' ':
-        if (!params.disableSelection && !instance.isNodeDisabled(state.focusedNodeId)) {
-          flag = true;
+    const key = event.key;
+
+    // eslint-disable-next-line default-case
+    switch (true) {
+      // Select the node when pressing "Space"
+      case key === ' ' && canToggleNodeSelection(state.focusedNodeId):
+        {
+          event.preventDefault();
           if (params.multiSelect && event.shiftKey) {
             instance.selectRange(event, {
               end: state.focusedNodeId
@@ -134,85 +114,158 @@ export const useTreeViewKeyboardNavigation = ({
           } else {
             instance.selectNode(event, state.focusedNodeId);
           }
+          break;
         }
-        event.stopPropagation();
-        break;
-      case 'Enter':
-        if (!instance.isNodeDisabled(state.focusedNodeId)) {
-          if (instance.isNodeExpandable(state.focusedNodeId)) {
+
+      // If the focused node has children, we expand it.
+      // If the focused node has no children, we select it.
+      case key === 'Enter':
+        {
+          if (canToggleNodeExpansion(state.focusedNodeId)) {
             instance.toggleNodeExpansion(event, state.focusedNodeId);
-            flag = true;
-          } else if (!params.disableSelection) {
-            flag = true;
+            event.preventDefault();
+          } else if (canToggleNodeSelection(state.focusedNodeId)) {
             if (params.multiSelect) {
+              event.preventDefault();
               instance.selectNode(event, state.focusedNodeId, true);
-            } else {
+            } else if (!instance.isNodeSelected(state.focusedNodeId)) {
               instance.selectNode(event, state.focusedNodeId);
+              event.preventDefault();
             }
           }
+          break;
         }
-        event.stopPropagation();
-        break;
-      case 'ArrowDown':
-        if (params.multiSelect && event.shiftKey && !params.disableSelection) {
-          selectNextNode(event, state.focusedNodeId);
+
+      // Focus the next focusable node
+      case key === 'ArrowDown':
+        {
+          const nextNode = getNextNode(instance, state.focusedNodeId);
+          if (nextNode) {
+            event.preventDefault();
+            instance.focusNode(event, nextNode);
+
+            // Multi select behavior when pressing Shift + ArrowDown
+            // Toggles the selection state of the next node
+            if (params.multiSelect && event.shiftKey && canToggleNodeSelection(nextNode)) {
+              instance.selectRange(event, {
+                end: nextNode,
+                current: state.focusedNodeId
+              }, true);
+            }
+          }
+          break;
         }
-        instance.focusNode(event, getNextNode(instance, state.focusedNodeId));
-        flag = true;
-        break;
-      case 'ArrowUp':
-        if (params.multiSelect && event.shiftKey && !params.disableSelection) {
-          selectPreviousNode(event, state.focusedNodeId);
+
+      // Focuses the previous focusable node
+      case key === 'ArrowUp':
+        {
+          const previousNode = getPreviousNode(instance, state.focusedNodeId);
+          if (previousNode) {
+            event.preventDefault();
+            instance.focusNode(event, previousNode);
+
+            // Multi select behavior when pressing Shift + ArrowUp
+            // Toggles the selection state of the previous node
+            if (params.multiSelect && event.shiftKey && canToggleNodeSelection(previousNode)) {
+              instance.selectRange(event, {
+                end: previousNode,
+                current: state.focusedNodeId
+              }, true);
+            }
+          }
+          break;
         }
-        instance.focusNode(event, getPreviousNode(instance, state.focusedNodeId));
-        flag = true;
-        break;
-      case 'ArrowRight':
-        if (isRtl) {
-          flag = handlePreviousArrow(event);
-        } else {
-          flag = handleNextArrow(event);
+
+      // If the focused node is expanded, we move the focus to its first child
+      // If the focused node is collapsed and has children, we expand it
+      case key === 'ArrowRight' && !isRTL || key === 'ArrowLeft' && isRTL:
+        {
+          if (instance.isNodeExpanded(state.focusedNodeId)) {
+            instance.focusNode(event, getNextNode(instance, state.focusedNodeId));
+            event.preventDefault();
+          } else if (canToggleNodeExpansion(state.focusedNodeId)) {
+            instance.toggleNodeExpansion(event, state.focusedNodeId);
+            event.preventDefault();
+          }
+          break;
         }
-        break;
-      case 'ArrowLeft':
-        if (isRtl) {
-          flag = handleNextArrow(event);
-        } else {
-          flag = handlePreviousArrow(event);
+
+      // If the focused node is expanded, we collapse it
+      // If the focused node is collapsed and has a parent, we move the focus to this parent
+      case key === 'ArrowLeft' && !isRTL || key === 'ArrowRight' && isRTL:
+        {
+          if (canToggleNodeExpansion(state.focusedNodeId) && instance.isNodeExpanded(state.focusedNodeId)) {
+            instance.toggleNodeExpansion(event, state.focusedNodeId);
+            event.preventDefault();
+          } else {
+            const parent = instance.getNode(state.focusedNodeId).parentId;
+            if (parent) {
+              instance.focusNode(event, parent);
+              event.preventDefault();
+            }
+          }
+          break;
         }
-        break;
-      case 'Home':
-        if (params.multiSelect && ctrlPressed && event.shiftKey && !params.disableSelection && !instance.isNodeDisabled(state.focusedNodeId)) {
-          instance.rangeSelectToFirst(event, state.focusedNodeId);
+
+      // Focuses the first node in the tree
+      case key === 'Home':
+        {
+          instance.focusNode(event, getFirstNode(instance));
+
+          // Multi select behavior when pressing Ctrl + Shift + Home
+          // Selects the focused node and all nodes up to the first node.
+          if (canToggleNodeSelection(state.focusedNodeId) && params.multiSelect && ctrlPressed && event.shiftKey) {
+            instance.rangeSelectToFirst(event, state.focusedNodeId);
+          }
+          event.preventDefault();
+          break;
         }
-        instance.focusNode(event, getFirstNode(instance));
-        flag = true;
-        break;
-      case 'End':
-        if (params.multiSelect && ctrlPressed && event.shiftKey && !params.disableSelection && !instance.isNodeDisabled(state.focusedNodeId)) {
-          instance.rangeSelectToLast(event, state.focusedNodeId);
+
+      // Focuses the last node in the tree
+      case key === 'End':
+        {
+          instance.focusNode(event, getLastNode(instance));
+
+          // Multi select behavior when pressing Ctrl + Shirt + End
+          // Selects the focused node and all the nodes down to the last node.
+          if (canToggleNodeSelection(state.focusedNodeId) && params.multiSelect && ctrlPressed && event.shiftKey) {
+            instance.rangeSelectToLast(event, state.focusedNodeId);
+          }
+          event.preventDefault();
+          break;
         }
-        instance.focusNode(event, getLastNode(instance));
-        flag = true;
-        break;
-      default:
-        if (key === '*') {
+
+      // Expand all siblings that are at the same level as the focused node
+      case key === '*':
+        {
           instance.expandAllSiblings(event, state.focusedNodeId);
-          flag = true;
-        } else if (params.multiSelect && ctrlPressed && key.toLowerCase() === 'a' && !params.disableSelection) {
+          event.preventDefault();
+          break;
+        }
+
+      // Multi select behavior when pressing Ctrl + a
+      // Selects all the nodes
+      case key === 'a' && ctrlPressed && params.multiSelect && !params.disableSelection:
+        {
           instance.selectRange(event, {
             start: getFirstNode(instance),
             end: getLastNode(instance)
           });
-          flag = true;
-        } else if (!ctrlPressed && !event.shiftKey && isPrintableCharacter(key)) {
-          focusByFirstCharacter(event, state.focusedNodeId, key);
-          flag = true;
+          event.preventDefault();
+          break;
+        }
+
+      // Type-ahead
+      // TODO: Support typing multiple characters
+      case !ctrlPressed && !event.shiftKey && isPrintableCharacter(key):
+        {
+          const matchingNode = getFirstMatchingNode(state.focusedNodeId, key);
+          if (matchingNode != null) {
+            instance.focusNode(event, matchingNode);
+            event.preventDefault();
+          }
+          break;
         }
-    }
-    if (flag) {
-      event.preventDefault();
-      event.stopPropagation();
     }
   };
   return {
@@ -220,4 +273,5 @@ export const useTreeViewKeyboardNavigation = ({
       onKeyDown: createHandleKeyDown(otherHandlers)
     })
   };
-};
+};
+useTreeViewKeyboardNavigation.params = {};

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 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 = 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,57 @@ 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
+});
+useTreeViewNodes.params = {
+  disabledItemsFocusable: true,
+  items: true,
+  isItemDisabled: true,
+  getItemLabel: true,
+  getItemId: true
 };