@mui/x-tree-view-pro 7.12.0

package/build/node/internals/plugins/useTreeViewItemsReordering/useTreeViewItemsReordering.itemPlugin.js

@@ -0,0 +1,138 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useTreeViewItemsReorderingItemPlugin = exports.isAndroid = void 0;
+var React = _interopRequireWildcard(require("react"));
+var _internals = require("@mui/x-tree-view/internals");
+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 && {}.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 isAndroid = () => navigator.userAgent.toLowerCase().includes('android');
+exports.isAndroid = isAndroid;
+const useTreeViewItemsReorderingItemPlugin = ({
+  props
+}) => {
+  const {
+    itemsReordering,
+    instance
+  } = (0, _internals.useTreeViewContext)();
+  const {
+    itemId
+  } = props;
+  const validActionsRef = React.useRef(null);
+  return {
+    propsEnhancers: {
+      root: ({
+        rootRefObject,
+        contentRefObject,
+        externalEventHandlers
+      }) => {
+        const draggable = instance.canItemBeDragged(itemId);
+        if (!draggable) {
+          return {};
+        }
+        const handleDragStart = event => {
+          externalEventHandlers.onDragStart?.(event);
+          if (event.defaultMuiPrevented || event.defaultPrevented) {
+            return;
+          }
+
+          // We don't use `event.currentTarget` here.
+          // This is to allow people to pass `onDragStart` to another element than the root.
+          if ((0, _internals.isTargetInDescendants)(event.target, rootRefObject.current)) {
+            return;
+          }
+
+          // Comment to show the children in the drag preview
+          // TODO: Improve the customization of the drag preview
+          event.dataTransfer.effectAllowed = 'move';
+          event.dataTransfer.setDragImage(contentRefObject.current, 0, 0);
+          const {
+            types
+          } = event.dataTransfer;
+          if (isAndroid() && !types.includes('text/plain') && !types.includes('text/uri-list')) {
+            event.dataTransfer.setData('text/plain', 'android-fallback');
+          }
+
+          // iOS requires a media type to be defined
+          event.dataTransfer.setData('application/mui-x', '');
+          instance.startDraggingItem(itemId);
+        };
+        const handleRootDragOver = event => {
+          externalEventHandlers.onDragOver?.(event);
+          if (event.defaultMuiPrevented) {
+            return;
+          }
+          event.preventDefault();
+        };
+        const handleRootDragEnd = event => {
+          externalEventHandlers.onDragEnd?.(event);
+          if (event.defaultMuiPrevented) {
+            return;
+          }
+          instance.stopDraggingItem(itemId);
+        };
+        return {
+          draggable: true,
+          onDragStart: handleDragStart,
+          onDragOver: handleRootDragOver,
+          onDragEnd: handleRootDragEnd
+        };
+      },
+      content: ({
+        externalEventHandlers,
+        contentRefObject
+      }) => {
+        const currentDrag = itemsReordering.currentDrag;
+        if (!currentDrag || currentDrag.draggedItemId === itemId) {
+          return {};
+        }
+        const handleDragOver = event => {
+          externalEventHandlers.onDragOver?.(event);
+          if (event.defaultMuiPrevented || validActionsRef.current == null) {
+            return;
+          }
+          const rect = event.target.getBoundingClientRect();
+          const y = event.clientY - rect.top;
+          const x = event.clientX - rect.left;
+          instance.setDragTargetItem({
+            itemId,
+            validActions: validActionsRef.current,
+            targetHeight: rect.height,
+            cursorY: y,
+            cursorX: x,
+            contentElement: contentRefObject.current
+          });
+        };
+        const handleDragEnter = event => {
+          externalEventHandlers.onDragEnter?.(event);
+          if (event.defaultMuiPrevented) {
+            return;
+          }
+          validActionsRef.current = instance.getDroppingTargetValidActions(itemId);
+        };
+        return {
+          onDragEnter: handleDragEnter,
+          onDragOver: handleDragOver
+        };
+      },
+      dragAndDropOverlay: () => {
+        const currentDrag = itemsReordering.currentDrag;
+        if (!currentDrag || currentDrag.targetItemId !== itemId || currentDrag.action == null) {
+          return {};
+        }
+        const targetDepth = currentDrag.newPosition?.parentId == null ? 0 :
+        // The depth is always defined because drag&drop is only usable with Rich Tree View components.
+        instance.getItemMeta(currentDrag.newPosition.parentId).depth + 1;
+        return {
+          action: currentDrag.action,
+          style: {
+            '--TreeView-targetDepth': targetDepth
+          }
+        };
+      }
+    }
+  };
+};
+exports.useTreeViewItemsReorderingItemPlugin = useTreeViewItemsReorderingItemPlugin;

package/build/node/internals/plugins/useTreeViewItemsReordering/useTreeViewItemsReordering.js

@@ -0,0 +1,203 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useTreeViewItemsReordering = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var React = _interopRequireWildcard(require("react"));
+var _internals = require("@mui/x-tree-view/internals");
+var _useTreeViewItemsReordering = require("./useTreeViewItemsReordering.utils");
+var _useTreeViewItemsReordering2 = require("./useTreeViewItemsReordering.itemPlugin");
+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 && {}.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 useTreeViewItemsReordering = ({
+  params,
+  instance,
+  state,
+  setState,
+  experimentalFeatures
+}) => {
+  const isItemsReorderingEnabled = params.itemsReordering && !!experimentalFeatures?.itemsReordering;
+  if (process.env.NODE_ENV !== 'production') {
+    if (params.itemsReordering && (!experimentalFeatures?.indentationAtItemLevel || !experimentalFeatures?.itemsReordering)) {
+      (0, _internals.warnOnce)(['MUI X: The items reordering feature requires the `indentationAtItemLevel` and `itemsReordering` experimental features to be enabled.', 'You can do it by passing `experimentalFeatures={{ indentationAtItemLevel: true, itemsReordering: true }}` to the `RichTreeViewPro` component.', 'Check the documentation for more details: https://mui.com/x/react-tree-view/rich-tree-view/items/']);
+    }
+  }
+  const canItemBeDragged = React.useCallback(itemId => {
+    if (!isItemsReorderingEnabled) {
+      return false;
+    }
+    const isItemReorderable = params.isItemReorderable;
+    if (isItemReorderable) {
+      return isItemReorderable(itemId);
+    }
+    return true;
+  }, [isItemsReorderingEnabled, params.isItemReorderable]);
+  const getDroppingTargetValidActions = React.useCallback(itemId => {
+    if (!state.itemsReordering) {
+      throw new Error('There is no ongoing reordering.');
+    }
+    if (itemId === state.itemsReordering.draggedItemId) {
+      return {};
+    }
+    const canMoveItemToNewPosition = params.canMoveItemToNewPosition;
+    const targetItemMeta = instance.getItemMeta(itemId);
+    const targetItemIndex = instance.getItemIndex(targetItemMeta.id);
+    const draggedItemMeta = instance.getItemMeta(state.itemsReordering.draggedItemId);
+    const draggedItemIndex = instance.getItemIndex(draggedItemMeta.id);
+    const oldPosition = {
+      parentId: draggedItemMeta.parentId,
+      index: draggedItemIndex
+    };
+    const checkIfPositionIsValid = positionAfterAction => {
+      let isValid;
+      // If the new position is equal to the old one, we don't want to show any dropping UI.
+      if (positionAfterAction.parentId === oldPosition.parentId && positionAfterAction.index === oldPosition.index) {
+        isValid = false;
+      } else if (canMoveItemToNewPosition) {
+        isValid = canMoveItemToNewPosition({
+          itemId,
+          oldPosition,
+          newPosition: positionAfterAction
+        });
+      } else {
+        isValid = true;
+      }
+      return isValid;
+    };
+    const positionsAfterAction = {
+      'make-child': {
+        parentId: targetItemMeta.id,
+        index: 0
+      },
+      'reorder-above': {
+        parentId: targetItemMeta.parentId,
+        index: targetItemMeta.parentId === draggedItemMeta.parentId && targetItemIndex > draggedItemIndex ? targetItemIndex - 1 : targetItemIndex
+      },
+      'reorder-below': targetItemMeta.expandable ? null : {
+        parentId: targetItemMeta.parentId,
+        index: targetItemMeta.parentId === draggedItemMeta.parentId && targetItemIndex > draggedItemIndex ? targetItemIndex : targetItemIndex + 1
+      },
+      'move-to-parent': targetItemMeta.parentId == null ? null : {
+        parentId: targetItemMeta.parentId,
+        index: instance.getItemOrderedChildrenIds(targetItemMeta.parentId).length
+      }
+    };
+    const validActions = {};
+    Object.keys(positionsAfterAction).forEach(action => {
+      const positionAfterAction = positionsAfterAction[action];
+      if (positionAfterAction != null && checkIfPositionIsValid(positionAfterAction)) {
+        validActions[action] = positionAfterAction;
+      }
+    });
+    return validActions;
+  }, [instance, state.itemsReordering, params.canMoveItemToNewPosition]);
+  const startDraggingItem = React.useCallback(itemId => {
+    setState(prevState => (0, _extends2.default)({}, prevState, {
+      itemsReordering: {
+        targetItemId: itemId,
+        draggedItemId: itemId,
+        action: null,
+        newPosition: null
+      }
+    }));
+  }, [setState]);
+  const stopDraggingItem = React.useCallback(itemId => {
+    if (state.itemsReordering == null || state.itemsReordering.draggedItemId !== itemId) {
+      return;
+    }
+    if (state.itemsReordering.draggedItemId === state.itemsReordering.targetItemId || state.itemsReordering.action == null || state.itemsReordering.newPosition == null) {
+      setState(prevState => (0, _extends2.default)({}, prevState, {
+        itemsReordering: null
+      }));
+      return;
+    }
+    const draggedItemMeta = instance.getItemMeta(state.itemsReordering.draggedItemId);
+    const oldPosition = {
+      parentId: draggedItemMeta.parentId,
+      index: instance.getItemIndex(draggedItemMeta.id)
+    };
+    const newPosition = state.itemsReordering.newPosition;
+    setState(prevState => (0, _extends2.default)({}, prevState, {
+      itemsReordering: null,
+      items: (0, _useTreeViewItemsReordering.moveItemInTree)({
+        itemToMoveId: itemId,
+        newPosition,
+        oldPosition,
+        prevState: prevState.items
+      })
+    }));
+    const onItemPositionChange = params.onItemPositionChange;
+    onItemPositionChange?.({
+      itemId,
+      newPosition,
+      oldPosition
+    });
+  }, [setState, state.itemsReordering, instance, params.onItemPositionChange]);
+  const setDragTargetItem = React.useCallback(({
+    itemId,
+    validActions,
+    targetHeight,
+    cursorY,
+    cursorX,
+    contentElement
+  }) => {
+    setState(prevState => {
+      const prevSubState = prevState.itemsReordering;
+      if (prevSubState == null || (0, _useTreeViewItemsReordering.isAncestor)(instance, itemId, prevSubState.draggedItemId)) {
+        return prevState;
+      }
+      const action = (0, _useTreeViewItemsReordering.chooseActionToApply)({
+        itemChildrenIndentation: params.itemChildrenIndentation,
+        validActions,
+        targetHeight,
+        targetDepth: prevState.items.itemMetaMap[itemId].depth,
+        cursorY,
+        cursorX,
+        contentElement
+      });
+      const newPosition = action == null ? null : validActions[action];
+      if (prevSubState.targetItemId === itemId && prevSubState.action === action && prevSubState.newPosition?.parentId === newPosition?.parentId && prevSubState.newPosition?.index === newPosition?.index) {
+        return prevState;
+      }
+      return (0, _extends2.default)({}, prevState, {
+        itemsReordering: (0, _extends2.default)({}, prevSubState, {
+          targetItemId: itemId,
+          newPosition,
+          action
+        })
+      });
+    });
+  }, [instance, setState, params.itemChildrenIndentation]);
+  return {
+    instance: {
+      canItemBeDragged,
+      getDroppingTargetValidActions,
+      startDraggingItem,
+      stopDraggingItem,
+      setDragTargetItem
+    },
+    contextValue: {
+      itemsReordering: {
+        enabled: isItemsReorderingEnabled,
+        currentDrag: state.itemsReordering
+      }
+    }
+  };
+};
+exports.useTreeViewItemsReordering = useTreeViewItemsReordering;
+useTreeViewItemsReordering.itemPlugin = _useTreeViewItemsReordering2.useTreeViewItemsReorderingItemPlugin;
+useTreeViewItemsReordering.getDefaultizedParams = params => (0, _extends2.default)({}, params, {
+  itemsReordering: params.itemsReordering ?? false
+});
+useTreeViewItemsReordering.getInitialState = () => ({
+  itemsReordering: null
+});
+useTreeViewItemsReordering.params = {
+  itemsReordering: true,
+  isItemReorderable: true,
+  canMoveItemToNewPosition: true,
+  onItemPositionChange: true
+};

package/build/node/internals/plugins/useTreeViewItemsReordering/useTreeViewItemsReordering.types.js

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

package/build/node/internals/plugins/useTreeViewItemsReordering/useTreeViewItemsReordering.utils.js

@@ -0,0 +1,160 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.moveItemInTree = exports.isAncestor = exports.chooseActionToApply = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _internals = require("@mui/x-tree-view/internals");
+/**
+ * Checks if the item with the id itemIdB is an ancestor of the item with the id itemIdA.
+ */
+const isAncestor = (instance, itemIdA, itemIdB) => {
+  const itemMetaA = instance.getItemMeta(itemIdA);
+  if (itemMetaA.parentId === itemIdB) {
+    return true;
+  }
+  if (itemMetaA.parentId == null) {
+    return false;
+  }
+  return isAncestor(instance, itemMetaA.parentId, itemIdB);
+};
+
+/**
+ * Transforms a CSS string `itemChildrenIndentation` into a number representing the indentation in number.
+ * @param {string | null} itemChildrenIndentation The indentation as passed to the `itemChildrenIndentation` prop.
+ * @param {HTMLElement} contentElement The DOM element to which the indentation will be applied.
+ */
+exports.isAncestor = isAncestor;
+const parseItemChildrenIndentation = (itemChildrenIndentation, contentElement) => {
+  if (typeof itemChildrenIndentation === 'number') {
+    return itemChildrenIndentation;
+  }
+  const pixelExec = /^(\d.+)(px)$/.exec(itemChildrenIndentation);
+  if (pixelExec) {
+    return parseFloat(pixelExec[1]);
+  }
+
+  // If the format is neither `px` nor a number, we need to measure the indentation using an actual DOM element.
+  const tempElement = document.createElement('div');
+  tempElement.style.width = itemChildrenIndentation;
+  tempElement.style.position = 'absolute';
+  contentElement.appendChild(tempElement);
+  const value = tempElement.offsetWidth;
+  contentElement.removeChild(tempElement);
+  return value;
+};
+const chooseActionToApply = ({
+  itemChildrenIndentation,
+  validActions,
+  targetHeight,
+  targetDepth,
+  cursorX,
+  cursorY,
+  contentElement
+}) => {
+  let action;
+  const itemChildrenIndentationPx = parseItemChildrenIndentation(itemChildrenIndentation, contentElement);
+  // If we can move the item to the parent of the target, then we allocate the left offset to this action
+  // Support moving to other ancestors
+  if (validActions['move-to-parent'] && cursorX < itemChildrenIndentationPx * targetDepth) {
+    action = 'move-to-parent';
+  }
+
+  // If we can move the item inside the target, then we have the following split:
+  // - the upper quarter of the target moves it above
+  // - the lower quarter of the target moves it below
+  // - the inner half makes it a child
+  else if (validActions['make-child']) {
+    if (validActions['reorder-above'] && cursorY < 1 / 4 * targetHeight) {
+      action = 'reorder-above';
+    } else if (validActions['reorder-below'] && cursorY > 3 / 4 * targetHeight) {
+      action = 'reorder-below';
+    } else {
+      action = 'make-child';
+    }
+  }
+  // If we can't move the item inside the target, then we have the following split:
+  // - the upper half of the target moves it above
+  // - the lower half of the target moves it below
+  else {
+    // eslint-disable-next-line no-lonely-if
+    if (validActions['reorder-above'] && cursorY < 1 / 2 * targetHeight) {
+      action = 'reorder-above';
+    } else if (validActions['reorder-below'] && cursorY >= 1 / 2 * targetHeight) {
+      action = 'reorder-below';
+    } else {
+      action = null;
+    }
+  }
+  return action;
+};
+exports.chooseActionToApply = chooseActionToApply;
+const moveItemInTree = ({
+  itemToMoveId,
+  oldPosition,
+  newPosition,
+  prevState
+}) => {
+  const itemToMoveMeta = prevState.itemMetaMap[itemToMoveId];
+  const oldParentId = oldPosition.parentId ?? _internals.TREE_VIEW_ROOT_PARENT_ID;
+  const newParentId = newPosition.parentId ?? _internals.TREE_VIEW_ROOT_PARENT_ID;
+
+  // 1. Update the `itemOrderedChildrenIds`.
+  const itemOrderedChildrenIds = (0, _extends2.default)({}, prevState.itemOrderedChildrenIds);
+  if (oldParentId === newParentId) {
+    const updatedChildren = [...itemOrderedChildrenIds[oldParentId]];
+    updatedChildren.splice(oldPosition.index, 1);
+    updatedChildren.splice(newPosition.index, 0, itemToMoveId);
+    itemOrderedChildrenIds[itemToMoveMeta.parentId ?? _internals.TREE_VIEW_ROOT_PARENT_ID] = updatedChildren;
+  } else {
+    const updatedOldParentChildren = [...itemOrderedChildrenIds[oldParentId]];
+    updatedOldParentChildren.splice(oldPosition.index, 1);
+    itemOrderedChildrenIds[oldParentId] = updatedOldParentChildren;
+    const updatedNewParentChildren = [...(itemOrderedChildrenIds[newParentId] ?? [])];
+    updatedNewParentChildren.splice(newPosition.index, 0, itemToMoveId);
+    itemOrderedChildrenIds[newParentId] = updatedNewParentChildren;
+  }
+
+  // 2. Update the `itemChildrenIndexes`
+  const itemChildrenIndexes = (0, _extends2.default)({}, prevState.itemChildrenIndexes);
+  itemChildrenIndexes[oldParentId] = (0, _internals.buildSiblingIndexes)(itemOrderedChildrenIds[oldParentId]);
+  if (newParentId !== oldParentId) {
+    itemChildrenIndexes[newParentId] = (0, _internals.buildSiblingIndexes)(itemOrderedChildrenIds[newParentId]);
+  }
+
+  // 3. Update the `itemMetaMap`
+  const itemMetaMap = (0, _extends2.default)({}, prevState.itemMetaMap);
+
+  // 3.1 Update the `expandable` property of the old and the new parent
+  if (oldParentId !== _internals.TREE_VIEW_ROOT_PARENT_ID && oldParentId !== newParentId) {
+    itemMetaMap[oldParentId].expandable = itemOrderedChildrenIds[oldParentId].length > 0;
+  }
+  if (newParentId !== _internals.TREE_VIEW_ROOT_PARENT_ID && newParentId !== oldParentId) {
+    itemMetaMap[newParentId].expandable = itemOrderedChildrenIds[newParentId].length > 0;
+  }
+
+  // 3.2 Update the `parentId` and `depth` properties of the item to move
+  // The depth is always defined because drag&drop is only usable with Rich Tree View components.
+  const itemToMoveDepth = newPosition.parentId == null ? 0 : itemMetaMap[newParentId].depth + 1;
+  itemMetaMap[itemToMoveId] = (0, _extends2.default)({}, itemToMoveMeta, {
+    parentId: newPosition.parentId,
+    depth: itemToMoveDepth
+  });
+
+  // 3.3 Update the depth of all the children of the item to move
+  const updateItemDepth = (itemId, depth) => {
+    itemMetaMap[itemId] = (0, _extends2.default)({}, itemMetaMap[itemId], {
+      depth
+    });
+    itemOrderedChildrenIds[itemId]?.forEach(childId => updateItemDepth(childId, depth + 1));
+  };
+  itemOrderedChildrenIds[itemToMoveId]?.forEach(childId => updateItemDepth(childId, itemToMoveDepth + 1));
+  return (0, _extends2.default)({}, prevState, {
+    itemOrderedChildrenIds,
+    itemChildrenIndexes,
+    itemMetaMap
+  });
+};
+exports.moveItemInTree = moveItemInTree;

package/build/node/internals/utils/releaseInfo.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getReleaseInfo = void 0;
+var _utils = require("@mui/utils");
+const getReleaseInfo = () => {
+  const releaseInfo = "MTcyMjQ2MzIwMDAwMA==";
+  if (process.env.NODE_ENV !== 'production') {
+    // A simple hack to set the value in the test environment (has no build step).
+    // eslint-disable-next-line no-useless-concat
+    if (releaseInfo === '__RELEASE' + '_INFO__') {
+      // eslint-disable-next-line no-underscore-dangle
+      return _utils.ponyfillGlobal.__MUI_RELEASE_INFO__;
+    }
+  }
+  return releaseInfo;
+};
+exports.getReleaseInfo = getReleaseInfo;

package/build/node/internals/zero-styled/index.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createUseThemeProps = createUseThemeProps;
+Object.defineProperty(exports, "styled", {
+  enumerable: true,
+  get: function () {
+    return _styles.styled;
+  }
+});
+var _styles = require("@mui/material/styles");
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+function createUseThemeProps(name) {
+  return _styles.useThemeProps;
+}

package/build/node/themeAugmentation/index.js

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

package/build/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@mui/x-tree-view-pro",
+  "version": "7.12.0",
+  "description": "The Pro plan edition of the Tree View components (MUI X).",
+  "author": "MUI Team",
+  "main": "./node/index.js",
+  "license": "SEE LICENSE IN LICENSE",
+  "bugs": {
+    "url": "https://github.com/mui/mui-x/issues"
+  },
+  "homepage": "https://mui.com/x/react-tree-view/",
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/mui-org"
+  },
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "react",
+    "react-component",
+    "mui",
+    "mui-x",
+    "material-ui",
+    "material design",
+    "treeview"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mui/mui-x.git",
+    "directory": "packages/x-tree-view-pro"
+  },
+  "dependencies": {
+    "@babel/runtime": "^7.25.0",
+    "@mui/system": "^5.16.5",
+    "@mui/utils": "^5.16.5",
+    "@mui/x-internals": "workspace:*",
+    "@mui/x-license": "workspace:*",
+    "@mui/x-tree-view": "workspace:*",
+    "@types/react-transition-group": "^4.4.10",
+    "clsx": "^2.1.1",
+    "prop-types": "^15.8.1",
+    "react-transition-group": "^4.4.5"
+  },
+  "peerDependencies": {
+    "@emotion/react": "^11.9.0",
+    "@emotion/styled": "^11.8.1",
+    "@mui/material": "^5.15.14",
+    "react": "^17.0.0 || ^18.0.0",
+    "react-dom": "^17.0.0 || ^18.0.0"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "private": false,
+  "module": "./index.js",
+  "types": "./index.d.ts"
+}

package/build/themeAugmentation/components.d.ts

@@ -0,0 +1,13 @@
+import { ComponentsProps, ComponentsOverrides, ComponentsVariants } from '@mui/material/styles';
+
+export interface TreeViewComponents<Theme = unknown> {
+  MuiRichTreeViewPro?: {
+    defaultProps?: ComponentsProps['MuiRichTreeViewPro'];
+    styleOverrides?: ComponentsOverrides<Theme>['MuiRichTreeViewPro'];
+    variants?: ComponentsVariants<Theme>['MuiRichTreeViewPro'];
+  };
+}
+
+declare module '@mui/material/styles' {
+  interface Components<Theme = unknown> extends TreeViewComponents<Theme> {}
+}

package/build/themeAugmentation/index.d.ts

@@ -0,0 +1,3 @@
+export * from './overrides';
+export * from './props';
+export * from './components';

package/build/themeAugmentation/index.js

@@ -0,0 +1,3 @@
+export * from './overrides';
+export * from './props';
+export * from './components';

package/build/themeAugmentation/overrides.d.ts

@@ -0,0 +1,13 @@
+import { RichTreeViewProClassKey } from '../RichTreeViewPro';
+
+// prettier-ignore
+export interface TreeViewComponentNameToClassKey {
+  MuiRichTreeViewPro: RichTreeViewProClassKey;
+}
+
+declare module '@mui/material/styles' {
+  interface ComponentNameToClassKey extends TreeViewComponentNameToClassKey {}
+}
+
+// disable automatic export
+export {};