@mui/x-tree-view 8.0.0-beta.2 → 8.0.0

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

@@ -1,145 +0,0 @@
-import * as React from 'react';
-import type { DefaultizedProps } from '@mui/x-internals/types';
-import type { TreeViewPluginSignature } from '../../models';
-import { UseTreeViewItemsSignature } from "../useTreeViewItems/index.js";
-import { UseTreeViewExpansionSignature } from "../useTreeViewExpansion/index.js";
-import { TreeViewSelectionPropagation, TreeViewCancellableEventHandler } from "../../../models/index.js";
-export interface UseTreeViewSelectionPublicAPI {
-  /**
-   * Select or deselect an item.
-   * @param {object} parameters The parameters of the method.
-   * @param {string} parameters.itemId The id of the item to select or deselect.
-   * @param {React.SyntheticEvent} parameters.event The DOM event that triggered the change.
-   * @param {boolean} parameters.keepExistingSelection If `true`, the other already selected items will remain selected, otherwise, they will be deselected. This parameter is only relevant when `multiSelect` is `true`
-   * @param {boolean | undefined} parameters.shouldBeSelected If `true` the item will be selected. If `false` the item will be deselected. If not defined, the item's selection status will be toggled.
-   */
-  setItemSelection: (parameters: {
-    itemId: string;
-    event?: React.SyntheticEvent;
-    shouldBeSelected?: boolean;
-    keepExistingSelection?: boolean;
-  }) => void;
-}
-export interface UseTreeViewSelectionInstance extends UseTreeViewSelectionPublicAPI {
-  /**
-   * Select all the navigable items in the tree.
-   * @param {React.SyntheticEvent} event The DOM event that triggered the change.
-   */
-  selectAllNavigableItems: (event: React.SyntheticEvent) => void;
-  /**
-   * Expand the current selection range up to the given item.
-   * @param {React.SyntheticEvent} event The DOM event that triggered the change.
-   * @param {string} itemId The id of the item to expand the selection to.
-   */
-  expandSelectionRange: (event: React.SyntheticEvent, itemId: string) => void;
-  /**
-   * Expand the current selection range from the first navigable item to the given item.
-   * @param {React.SyntheticEvent} event The DOM event that triggered the change.
-   * @param {string} itemId The id of the item up to which the selection range should be expanded.
-   */
-  selectRangeFromStartToItem: (event: React.SyntheticEvent, itemId: string) => void;
-  /**
-   * Expand the current selection range from the given item to the last navigable item.
-   * @param {React.SyntheticEvent} event The DOM event that triggered the change.
-   * @param {string} itemId The id of the item from which the selection range should be expanded.
-   */
-  selectRangeFromItemToEnd: (event: React.SyntheticEvent, itemId: string) => void;
-  /**
-   * Update the selection when navigating with ArrowUp / ArrowDown keys.
-   * @param {React.SyntheticEvent} event The DOM event that triggered the change.
-   * @param {string} currentItemId The id of the active item before the keyboard navigation.
-   * @param {string} nextItemId The id of the active item after the keyboard navigation.
-   */
-  selectItemFromArrowNavigation: (event: React.SyntheticEvent, currentItemId: string, nextItemId: string) => void;
-}
-type TreeViewSelectionValue<Multiple extends boolean | undefined> = Multiple extends true ? string[] : string | null;
-export interface UseTreeViewSelectionParameters<Multiple extends boolean | undefined> {
-  /**
-   * If `true` selection is disabled.
-   * @default false
-   */
-  disableSelection?: boolean;
-  /**
-   * Selected item ids. (Uncontrolled)
-   * When `multiSelect` is true this takes an array of strings; when false (default) a string.
-   * @default []
-   */
-  defaultSelectedItems?: TreeViewSelectionValue<Multiple>;
-  /**
-   * Selected item ids. (Controlled)
-   * When `multiSelect` is true this takes an array of strings; when false (default) a string.
-   */
-  selectedItems?: TreeViewSelectionValue<Multiple>;
-  /**
-   * If `true`, `ctrl` and `shift` will trigger multiselect.
-   * @default false
-   */
-  multiSelect?: Multiple;
-  /**
-   * If `true`, the Tree View renders a checkbox at the left of its label that allows selecting it.
-   * @default false
-   */
-  checkboxSelection?: boolean;
-  /**
-   * When `selectionPropagation.descendants` is set to `true`.
-   *
-   * - Selecting a parent selects all its descendants automatically.
-   * - Deselecting a parent deselects all its descendants automatically.
-   *
-   * When `selectionPropagation.parents` is set to `true`.
-   *
-   * - Selecting all the descendants of a parent selects the parent automatically.
-   * - Deselecting a descendant of a selected parent deselects the parent automatically.
-   *
-   * Only works when `multiSelect` is `true`.
-   * On the <SimpleTreeView />, only the expanded items are considered (since the collapsed item are not passed to the Tree View component at all)
-   *
-   * @default { parents: false, descendants: false }
-   */
-  selectionPropagation?: TreeViewSelectionPropagation;
-  /**
-   * Callback fired when Tree Items are selected/deselected.
-   * @param {React.SyntheticEvent} event The DOM event that triggered the change. Can be null when the change is caused by the `publicAPI.setItemSelection()` method.
-   * @param {string[] | string} itemIds The ids of the selected items.
-   * When `multiSelect` is `true`, this is an array of strings; when false (default) a string.
-   */
-  onSelectedItemsChange?: (event: React.SyntheticEvent | null, itemIds: TreeViewSelectionValue<Multiple>) => void;
-  /**
-   * Callback fired when a Tree Item is selected or deselected.
-   * @param {React.SyntheticEvent} event The DOM event that triggered the change. Can be null when the change is caused by the `publicAPI.setItemSelection()` method.
-   * @param {array} itemId The itemId of the modified item.
-   * @param {array} isSelected `true` if the item has just been selected, `false` if it has just been deselected.
-   */
-  onItemSelectionToggle?: (event: React.SyntheticEvent | null, itemId: string, isSelected: boolean) => void;
-}
-export type UseTreeViewSelectionDefaultizedParameters<Multiple extends boolean> = DefaultizedProps<UseTreeViewSelectionParameters<Multiple>, 'disableSelection' | 'defaultSelectedItems' | 'multiSelect' | 'checkboxSelection' | 'selectionPropagation'>;
-export interface UseTreeViewSelectionState {
-  selection: {
-    rawSelectedItems: TreeViewSelectionValue<boolean>;
-    selectedItemsMap: Map<string, true>;
-    isEnabled: boolean;
-    isMultiSelectEnabled: boolean;
-    isCheckboxSelectionEnabled: boolean;
-    selectionPropagation: TreeViewSelectionPropagation;
-  };
-}
-export type UseTreeViewSelectionSignature = TreeViewPluginSignature<{
-  params: UseTreeViewSelectionParameters<any>;
-  defaultizedParams: UseTreeViewSelectionDefaultizedParameters<any>;
-  instance: UseTreeViewSelectionInstance;
-  publicAPI: UseTreeViewSelectionPublicAPI;
-  modelNames: 'selectedItems';
-  state: UseTreeViewSelectionState;
-  dependencies: [UseTreeViewItemsSignature, UseTreeViewExpansionSignature, UseTreeViewItemsSignature];
-}>;
-export interface UseTreeItemCheckboxSlotPropsFromSelection {
-  visible?: boolean;
-  checked?: boolean;
-  disabled?: boolean;
-  tabIndex?: -1;
-  onChange?: TreeViewCancellableEventHandler<React.ChangeEvent<HTMLInputElement>>;
-}
-declare module '@mui/x-tree-view/useTreeItem' {
-  interface UseTreeItemCheckboxSlotOwnProps extends UseTreeItemCheckboxSlotPropsFromSelection {}
-}
-export {};

package/modern/internals/plugins/useTreeViewSelection/useTreeViewSelection.types.js

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

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

@@ -1,38 +0,0 @@
-import { TreeViewItemId, TreeViewSelectionPropagation } from "../../../models/index.js";
-import { TreeViewUsedStore } from "../../models/index.js";
-import { UseTreeViewSelectionSignature } from "./useTreeViewSelection.types.js";
-/**
- * Transform the `selectedItems` model to be an array if it was a string or null.
- * @param {string[] | string | null} model The raw model.
- * @returns {string[]} The converted model.
- */
-export declare const convertSelectedItemsToArray: (model: string[] | string | null) => string[];
-export declare const createSelectedItemsMap: (selectedItems: string | string[] | null) => Map<string, true>;
-export declare const getLookupFromArray: (array: string[]) => {
-  [itemId: string]: true;
-};
-export declare const getAddedAndRemovedItems: ({
-  store,
-  oldModel,
-  newModel
-}: {
-  store: TreeViewUsedStore<UseTreeViewSelectionSignature>;
-  oldModel: TreeViewItemId[];
-  newModel: TreeViewItemId[];
-}) => {
-  added: string[];
-  removed: string[];
-};
-export declare const propagateSelection: ({
-  store,
-  selectionPropagation,
-  newModel,
-  oldModel,
-  additionalItemsToPropagate
-}: {
-  store: TreeViewUsedStore<UseTreeViewSelectionSignature>;
-  selectionPropagation: TreeViewSelectionPropagation;
-  newModel: TreeViewItemId[];
-  oldModel: TreeViewItemId[];
-  additionalItemsToPropagate?: TreeViewItemId[];
-}) => string[];

package/modern/internals/plugins/useTreeViewSelection/useTreeViewSelection.utils.js

@@ -1,126 +0,0 @@
-import { selectorIsItemSelected } from "./useTreeViewSelection.selectors.js";
-import { selectorItemOrderedChildrenIds, selectorItemParentId } from "../useTreeViewItems/useTreeViewItems.selectors.js";
-
-/**
- * Transform the `selectedItems` model to be an array if it was a string or null.
- * @param {string[] | string | null} model The raw model.
- * @returns {string[]} The converted model.
- */
-export const convertSelectedItemsToArray = model => {
-  if (Array.isArray(model)) {
-    return model;
-  }
-  if (model != null) {
-    return [model];
-  }
-  return [];
-};
-export const createSelectedItemsMap = selectedItems => {
-  const selectedItemsMap = new Map();
-  convertSelectedItemsToArray(selectedItems).forEach(id => {
-    selectedItemsMap.set(id, true);
-  });
-  return selectedItemsMap;
-};
-export const getLookupFromArray = array => {
-  const lookup = {};
-  array.forEach(itemId => {
-    lookup[itemId] = true;
-  });
-  return lookup;
-};
-export const getAddedAndRemovedItems = ({
-  store,
-  oldModel,
-  newModel
-}) => {
-  const newModelLookup = createSelectedItemsMap(newModel);
-  return {
-    added: newModel.filter(itemId => !selectorIsItemSelected(store.value, itemId)),
-    removed: oldModel.filter(itemId => !newModelLookup.has(itemId))
-  };
-};
-export const propagateSelection = ({
-  store,
-  selectionPropagation,
-  newModel,
-  oldModel,
-  additionalItemsToPropagate
-}) => {
-  if (!selectionPropagation.descendants && !selectionPropagation.parents) {
-    return newModel;
-  }
-  let shouldRegenerateModel = false;
-  const newModelLookup = getLookupFromArray(newModel);
-  const changes = getAddedAndRemovedItems({
-    store,
-    newModel,
-    oldModel
-  });
-  additionalItemsToPropagate?.forEach(itemId => {
-    if (newModelLookup[itemId]) {
-      if (!changes.added.includes(itemId)) {
-        changes.added.push(itemId);
-      }
-    } else if (!changes.removed.includes(itemId)) {
-      changes.removed.push(itemId);
-    }
-  });
-  changes.added.forEach(addedItemId => {
-    if (selectionPropagation.descendants) {
-      const selectDescendants = itemId => {
-        if (itemId !== addedItemId) {
-          shouldRegenerateModel = true;
-          newModelLookup[itemId] = true;
-        }
-        selectorItemOrderedChildrenIds(store.value, itemId).forEach(selectDescendants);
-      };
-      selectDescendants(addedItemId);
-    }
-    if (selectionPropagation.parents) {
-      const checkAllDescendantsSelected = itemId => {
-        if (!newModelLookup[itemId]) {
-          return false;
-        }
-        const children = selectorItemOrderedChildrenIds(store.value, itemId);
-        return children.every(checkAllDescendantsSelected);
-      };
-      const selectParents = itemId => {
-        const parentId = selectorItemParentId(store.value, itemId);
-        if (parentId == null) {
-          return;
-        }
-        const siblings = selectorItemOrderedChildrenIds(store.value, parentId);
-        if (siblings.every(checkAllDescendantsSelected)) {
-          shouldRegenerateModel = true;
-          newModelLookup[parentId] = true;
-          selectParents(parentId);
-        }
-      };
-      selectParents(addedItemId);
-    }
-  });
-  changes.removed.forEach(removedItemId => {
-    if (selectionPropagation.parents) {
-      let parentId = selectorItemParentId(store.value, removedItemId);
-      while (parentId != null) {
-        if (newModelLookup[parentId]) {
-          shouldRegenerateModel = true;
-          delete newModelLookup[parentId];
-        }
-        parentId = selectorItemParentId(store.value, parentId);
-      }
-    }
-    if (selectionPropagation.descendants) {
-      const deSelectDescendants = itemId => {
-        if (itemId !== removedItemId) {
-          shouldRegenerateModel = true;
-          delete newModelLookup[itemId];
-        }
-        selectorItemOrderedChildrenIds(store.value, itemId).forEach(deSelectDescendants);
-      };
-      deSelectDescendants(removedItemId);
-    }
-  });
-  return shouldRegenerateModel ? Object.keys(newModelLookup) : newModel;
-};

package/modern/internals/useTreeView/extractPluginParamsFromProps.d.ts

@@ -1,22 +0,0 @@
-import { ConvertSignaturesIntoPlugins, MergeSignaturesProperty, TreeViewAnyPluginSignature, TreeViewPluginSignature } from "../models/index.js";
-import { UseTreeViewBaseProps } from "./useTreeView.types.js";
-import { TreeViewCorePluginSignatures } from "../corePlugins/index.js";
-interface ExtractPluginParamsFromPropsParameters<TSignatures extends readonly TreeViewAnyPluginSignature[], TProps extends Partial<UseTreeViewBaseProps<TSignatures>>> {
-  plugins: ConvertSignaturesIntoPlugins<readonly [...TreeViewCorePluginSignatures, ...TSignatures]>;
-  props: TProps;
-}
-interface ExtractPluginParamsFromPropsReturnValue<TSignatures extends readonly TreeViewAnyPluginSignature[], TProps extends Partial<UseTreeViewBaseProps<TSignatures>>> extends UseTreeViewBaseProps<TSignatures> {
-  pluginParams: MergeSignaturesProperty<TSignatures, 'defaultizedParams'>;
-  forwardedProps: Omit<TProps, keyof MergeSignaturesProperty<TSignatures, 'params'>>;
-}
-export declare const extractPluginParamsFromProps: <TSignatures extends readonly TreeViewPluginSignature<any>[], TProps extends Partial<UseTreeViewBaseProps<TSignatures>>>({
-  props: {
-    slots,
-    slotProps,
-    apiRef,
-    experimentalFeatures: inExperimentalFeatures,
-    ...props
-  },
-  plugins
-}: ExtractPluginParamsFromPropsParameters<TSignatures, TProps>) => ExtractPluginParamsFromPropsReturnValue<TSignatures, TProps>;
-export {};

package/modern/internals/useTreeView/extractPluginParamsFromProps.js

@@ -1,46 +0,0 @@
-import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
-const _excluded = ["slots", "slotProps", "apiRef", "experimentalFeatures"];
-export const extractPluginParamsFromProps = _ref => {
-  let {
-      props: {
-        slots,
-        slotProps,
-        apiRef,
-        experimentalFeatures: inExperimentalFeatures
-      },
-      plugins
-    } = _ref,
-    props = _objectWithoutPropertiesLoose(_ref.props, _excluded);
-  const paramsLookup = {};
-  plugins.forEach(plugin => {
-    Object.assign(paramsLookup, plugin.params);
-  });
-  const pluginParams = {};
-  const forwardedProps = {};
-  Object.keys(props).forEach(propName => {
-    const prop = props[propName];
-    if (paramsLookup[propName]) {
-      pluginParams[propName] = prop;
-    } else {
-      forwardedProps[propName] = prop;
-    }
-  });
-  const experimentalFeatures = inExperimentalFeatures ?? {};
-  const defaultizedPluginParams = plugins.reduce((acc, plugin) => {
-    if (plugin.getDefaultizedParams) {
-      return plugin.getDefaultizedParams({
-        params: acc,
-        experimentalFeatures
-      });
-    }
-    return acc;
-  }, pluginParams);
-  return {
-    apiRef,
-    forwardedProps,
-    pluginParams: defaultizedPluginParams,
-    slots: slots ?? {},
-    slotProps: slotProps ?? {},
-    experimentalFeatures
-  };
-};

package/modern/internals/useTreeView/index.d.ts

@@ -1 +0,0 @@
-export { useTreeView } from "./useTreeView.js";

package/modern/internals/useTreeView/index.js

@@ -1 +0,0 @@
-export { useTreeView } from "./useTreeView.js";

package/modern/internals/useTreeView/useTreeView.d.ts

@@ -1,9 +0,0 @@
-import * as React from 'react';
-import { TreeViewAnyPluginSignature } from "../models/index.js";
-import { UseTreeViewBaseProps, UseTreeViewParameters, UseTreeViewReturnValue } from "./useTreeView.types.js";
-export declare function useTreeViewApiInitialization<T>(inputApiRef: React.RefObject<T | undefined> | undefined): T;
-export declare const useTreeView: <TSignatures extends readonly TreeViewAnyPluginSignature[], TProps extends Partial<UseTreeViewBaseProps<TSignatures>>>({
-  plugins: inPlugins,
-  rootRef,
-  props
-}: UseTreeViewParameters<TSignatures, TProps>) => UseTreeViewReturnValue<TSignatures>;

package/modern/internals/useTreeView/useTreeView.js

@@ -1,114 +0,0 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
-import * as React from 'react';
-import useForkRef from '@mui/utils/useForkRef';
-import { useTreeViewModels } from "./useTreeViewModels.js";
-import { TREE_VIEW_CORE_PLUGINS } from "../corePlugins/index.js";
-import { extractPluginParamsFromProps } from "./extractPluginParamsFromProps.js";
-import { useTreeViewBuildContext } from "./useTreeViewBuildContext.js";
-import { TreeViewStore } from "../utils/TreeViewStore.js";
-export function useTreeViewApiInitialization(inputApiRef) {
-  const fallbackPublicApiRef = React.useRef({});
-  if (inputApiRef) {
-    if (inputApiRef.current == null) {
-      inputApiRef.current = {};
-    }
-    return inputApiRef.current;
-  }
-  return fallbackPublicApiRef.current;
-}
-let globalId = 0;
-export const useTreeView = ({
-  plugins: inPlugins,
-  rootRef,
-  props
-}) => {
-  const plugins = React.useMemo(() => [...TREE_VIEW_CORE_PLUGINS, ...inPlugins], [inPlugins]);
-  const {
-    pluginParams,
-    forwardedProps,
-    apiRef,
-    experimentalFeatures,
-    slots,
-    slotProps
-  } = extractPluginParamsFromProps({
-    plugins,
-    props
-  });
-  const models = useTreeViewModels(plugins, pluginParams);
-  const instanceRef = React.useRef({});
-  const instance = instanceRef.current;
-  const publicAPI = useTreeViewApiInitialization(apiRef);
-  const innerRootRef = React.useRef(null);
-  const handleRootRef = useForkRef(innerRootRef, rootRef);
-  const storeRef = React.useRef(null);
-  if (storeRef.current == null) {
-    globalId += 1;
-    const initialState = {
-      cacheKey: {
-        id: globalId
-      }
-    };
-    plugins.forEach(plugin => {
-      if (plugin.getInitialState) {
-        Object.assign(initialState, plugin.getInitialState(pluginParams));
-      }
-    });
-    storeRef.current = new TreeViewStore(initialState);
-  }
-  const baseContextValue = useTreeViewBuildContext({
-    plugins,
-    instance,
-    publicAPI,
-    store: storeRef.current,
-    rootRef: innerRootRef
-  });
-  const rootPropsGetters = [];
-  const pluginContextValues = [];
-  const runPlugin = plugin => {
-    const pluginResponse = plugin({
-      instance,
-      params: pluginParams,
-      slots,
-      slotProps,
-      experimentalFeatures,
-      rootRef: innerRootRef,
-      models,
-      plugins,
-      store: storeRef.current
-    });
-    if (pluginResponse.getRootProps) {
-      rootPropsGetters.push(pluginResponse.getRootProps);
-    }
-    if (pluginResponse.publicAPI) {
-      Object.assign(publicAPI, pluginResponse.publicAPI);
-    }
-    if (pluginResponse.instance) {
-      Object.assign(instance, pluginResponse.instance);
-    }
-    if (pluginResponse.contextValue) {
-      pluginContextValues.push(pluginResponse.contextValue);
-    }
-  };
-  plugins.forEach(runPlugin);
-  const getRootProps = (otherHandlers = {}) => {
-    const rootProps = _extends({
-      role: 'tree'
-    }, forwardedProps, otherHandlers, {
-      ref: handleRootRef
-    });
-    rootPropsGetters.forEach(rootPropsGetter => {
-      Object.assign(rootProps, rootPropsGetter(otherHandlers));
-    });
-    return rootProps;
-  };
-  const contextValue = React.useMemo(() => {
-    const copiedBaseContextValue = _extends({}, baseContextValue);
-    return Object.assign(copiedBaseContextValue, ...pluginContextValues);
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [baseContextValue, ...pluginContextValues]);
-  return {
-    getRootProps,
-    rootRef: handleRootRef,
-    contextValue
-  };
-};

package/modern/internals/useTreeView/useTreeView.types.d.ts

@@ -1,23 +0,0 @@
-import * as React from 'react';
-import { EventHandlers } from '@mui/utils/types';
-import type { TreeViewContextValue } from '../TreeViewProvider';
-import { TreeViewAnyPluginSignature, ConvertSignaturesIntoPlugins, MergeSignaturesProperty, TreeViewPublicAPI, TreeViewExperimentalFeatures } from "../models/index.js";
-export interface UseTreeViewParameters<TSignatures extends readonly TreeViewAnyPluginSignature[], TProps extends Partial<UseTreeViewBaseProps<TSignatures>>> {
-  plugins: ConvertSignaturesIntoPlugins<TSignatures>;
-  rootRef?: React.Ref<HTMLUListElement> | undefined;
-  props: TProps;
-}
-export interface UseTreeViewBaseProps<TSignatures extends readonly TreeViewAnyPluginSignature[]> {
-  apiRef: React.RefObject<TreeViewPublicAPI<TSignatures> | undefined> | undefined;
-  slots: MergeSignaturesProperty<TSignatures, 'slots'>;
-  slotProps: MergeSignaturesProperty<TSignatures, 'slotProps'>;
-  experimentalFeatures: TreeViewExperimentalFeatures<TSignatures>;
-}
-export interface UseTreeViewRootSlotProps extends Pick<React.HTMLAttributes<HTMLUListElement>, 'onFocus' | 'onBlur' | 'onKeyDown' | 'id' | 'aria-multiselectable' | 'role' | 'tabIndex'> {
-  ref: React.Ref<HTMLUListElement>;
-}
-export interface UseTreeViewReturnValue<TSignatures extends readonly TreeViewAnyPluginSignature[]> {
-  getRootProps: <TOther extends EventHandlers = {}>(otherHandlers?: TOther) => UseTreeViewRootSlotProps;
-  rootRef: React.RefCallback<HTMLUListElement> | null;
-  contextValue: TreeViewContextValue<TSignatures>;
-}

package/modern/internals/useTreeView/useTreeView.types.js

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

package/modern/internals/useTreeView/useTreeViewBuildContext.d.ts

@@ -1,18 +0,0 @@
-import * as React from 'react';
-import { TreeViewContextValue } from "../TreeViewProvider/index.js";
-import { ConvertSignaturesIntoPlugins, TreeViewAnyPluginSignature, TreeViewInstance, TreeViewPublicAPI } from "../models/index.js";
-import { TreeViewCorePluginSignatures } from "../corePlugins/index.js";
-import { TreeViewStore } from "../utils/TreeViewStore.js";
-export declare const useTreeViewBuildContext: <TSignatures extends readonly TreeViewAnyPluginSignature[]>({
-  plugins,
-  instance,
-  publicAPI,
-  store,
-  rootRef
-}: {
-  plugins: ConvertSignaturesIntoPlugins<readonly [...TreeViewCorePluginSignatures, ...TSignatures]>;
-  instance: TreeViewInstance<TSignatures>;
-  publicAPI: TreeViewPublicAPI<TSignatures>;
-  store: TreeViewStore<TSignatures>;
-  rootRef: React.RefObject<HTMLUListElement | null>;
-}) => TreeViewContextValue<TSignatures>;

package/modern/internals/useTreeView/useTreeViewBuildContext.js

@@ -1,101 +0,0 @@
-import * as React from 'react';
-export const useTreeViewBuildContext = ({
-  plugins,
-  instance,
-  publicAPI,
-  store,
-  rootRef
-}) => {
-  const runItemPlugins = React.useCallback(itemPluginProps => {
-    let finalRootRef = null;
-    let finalContentRef = null;
-    const pluginPropEnhancers = [];
-    const pluginPropEnhancersNames = {};
-    plugins.forEach(plugin => {
-      if (!plugin.itemPlugin) {
-        return;
-      }
-      const itemPluginResponse = plugin.itemPlugin({
-        props: itemPluginProps,
-        rootRef: finalRootRef,
-        contentRef: finalContentRef
-      });
-      if (itemPluginResponse?.rootRef) {
-        finalRootRef = itemPluginResponse.rootRef;
-      }
-      if (itemPluginResponse?.contentRef) {
-        finalContentRef = itemPluginResponse.contentRef;
-      }
-      if (itemPluginResponse?.propsEnhancers) {
-        pluginPropEnhancers.push(itemPluginResponse.propsEnhancers);
-
-        // Prepare a list of all the slots which are enhanced by at least one plugin
-        Object.keys(itemPluginResponse.propsEnhancers).forEach(propsEnhancerName => {
-          pluginPropEnhancersNames[propsEnhancerName] = true;
-        });
-      }
-    });
-    const resolvePropsEnhancer = currentSlotName => currentSlotParams => {
-      const enhancedProps = {};
-      pluginPropEnhancers.forEach(propsEnhancersForCurrentPlugin => {
-        const propsEnhancerForCurrentPluginAndSlot = propsEnhancersForCurrentPlugin[currentSlotName];
-        if (propsEnhancerForCurrentPluginAndSlot != null) {
-          Object.assign(enhancedProps, propsEnhancerForCurrentPluginAndSlot(currentSlotParams));
-        }
-      });
-      return enhancedProps;
-    };
-    const propsEnhancers = Object.fromEntries(Object.keys(pluginPropEnhancersNames).map(propEnhancerName => [propEnhancerName, resolvePropsEnhancer(propEnhancerName)]));
-    return {
-      contentRef: finalContentRef,
-      rootRef: finalRootRef,
-      propsEnhancers
-    };
-  }, [plugins]);
-  const wrapItem = React.useCallback(({
-    itemId,
-    children,
-    idAttribute
-  }) => {
-    let finalChildren = children;
-    // The wrappers are reversed to ensure that the first wrapper is the outermost one.
-    for (let i = plugins.length - 1; i >= 0; i -= 1) {
-      const plugin = plugins[i];
-      if (plugin.wrapItem) {
-        finalChildren = plugin.wrapItem({
-          instance,
-          itemId,
-          children: finalChildren,
-          idAttribute
-        });
-      }
-    }
-    return finalChildren;
-  }, [plugins, instance]);
-  const wrapRoot = React.useCallback(({
-    children
-  }) => {
-    let finalChildren = children;
-    // The wrappers are reversed to ensure that the first wrapper is the outermost one.
-    for (let i = plugins.length - 1; i >= 0; i -= 1) {
-      const plugin = plugins[i];
-      if (plugin.wrapRoot) {
-        finalChildren = plugin.wrapRoot({
-          children: finalChildren
-        });
-      }
-    }
-    return finalChildren;
-  }, [plugins]);
-  return React.useMemo(() => {
-    return {
-      runItemPlugins,
-      wrapItem,
-      wrapRoot,
-      instance,
-      publicAPI,
-      store,
-      rootRef
-    };
-  }, [runItemPlugins, wrapItem, wrapRoot, instance, publicAPI, store, rootRef]);
-};

package/modern/internals/useTreeView/useTreeViewModels.d.ts

@@ -1,7 +0,0 @@
-import { TreeViewAnyPluginSignature, ConvertSignaturesIntoPlugins, MergeSignaturesProperty } from "../models/index.js";
-import { TreeViewCorePluginSignatures } from "../corePlugins/index.js";
-/**
- * Implements the same behavior as `useControlled` but for several models.
- * The controlled models are never stored in the state, and the state is only updated if the model is not controlled.
- */
-export declare const useTreeViewModels: <TSignatures extends readonly TreeViewAnyPluginSignature[]>(plugins: ConvertSignaturesIntoPlugins<readonly [...TreeViewCorePluginSignatures, ...TSignatures]>, props: MergeSignaturesProperty<TSignatures, "defaultizedParams">) => MergeSignaturesProperty<TSignatures, "models">;