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

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

@@ -12,7 +12,7 @@ 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; }
 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) {
@@ -28,7 +28,7 @@ const useTreeViewKeyboardNavigation = ({
   state
 }) => {
   const theme = (0, _styles.useTheme)();
-  const isRtl = theme.direction === 'rtl';
+  const isRTL = theme.direction === 'rtl';
   const firstCharMap = React.useRef({});
   const hasFirstCharMapBeenUpdatedImperatively = React.useRef(false);
   const updateFirstCharMap = (0, _useEventCallback.default)(callback => {
@@ -52,32 +52,7 @@ const useTreeViewKeyboardNavigation = ({
   (0, _useTreeView.populateInstance)(instance, {
     updateFirstCharMap
   });
-  const handleNextArrow = event => {
-    if (state.focusedNodeId != null && instance.isNodeExpandable(state.focusedNodeId)) {
-      if (instance.isNodeExpanded(state.focusedNodeId)) {
-        instance.focusNode(event, (0, _useTreeView.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();
@@ -108,41 +83,35 @@ 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((0, _useTreeView.getNextNode)(instance, id))) {
-      instance.selectRange(event, {
-        end: (0, _useTreeView.getNextNode)(instance, id),
-        current: id
-      }, true);
-    }
-  };
-  const selectPreviousNode = (event, nodeId) => {
-    if (!instance.isNodeDisabled((0, _useTreeView.getPreviousNode)(instance, nodeId))) {
-      instance.selectRange(event, {
-        end: (0, _useTreeView.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 => {
     otherHandlers.onKeyDown?.(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
@@ -152,85 +121,158 @@ 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 = (0, _useTreeView.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, (0, _useTreeView.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 = (0, _useTreeView.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, (0, _useTreeView.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, (0, _useTreeView.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, (0, _useTreeView.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, (0, _useTreeView.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, (0, _useTreeView.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, (0, _useTreeView.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: (0, _useTreeView.getFirstNode)(instance),
             end: (0, _useTreeView.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 {
@@ -239,4 +281,5 @@ const useTreeViewKeyboardNavigation = ({
     })
   };
 };
-exports.useTreeViewKeyboardNavigation = useTreeViewKeyboardNavigation;
+exports.useTreeViewKeyboardNavigation = useTreeViewKeyboardNavigation;
+useTreeViewKeyboardNavigation.params = {};

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

@@ -22,11 +22,11 @@ const updateState = ({
   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'));
+      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: 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'));
+      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,
@@ -131,4 +131,11 @@ useTreeViewNodes.getInitialState = params => updateState({
   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

@@ -189,4 +189,12 @@ useTreeViewSelection.getDefaultizedParams = params => (0, _extends2.default)({},
   disableSelection: params.disableSelection ?? false,
   multiSelect: params.multiSelect ?? false,
   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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mui/x-tree-view",
-  "version": "7.0.0-alpha.7",
+  "version": "7.0.0-alpha.8",
   "description": "The community edition of the tree view components (MUI X).",
   "author": "MUI Team",
   "main": "./node/index.js",