@mui/x-tree-view 6.0.0-alpha.3 → 6.0.0-beta.0

package/TreeView/TreeView.types.d.ts

@@ -1,8 +1,8 @@
 import * as React from 'react';
 import { Theme } from '@mui/material/styles';
 import { SxProps } from '@mui/system';
-import { DefaultizedProps } from '../internals/models';
 import { TreeViewClasses } from './treeViewClasses';
+import { DefaultTreeViewPluginParameters } from '../internals/plugins/defaultPlugins';
 export interface TreeViewPropsBase extends React.HTMLAttributes<HTMLUListElement> {
     /**
      * The content of the component.
@@ -16,155 +16,12 @@ export interface TreeViewPropsBase extends React.HTMLAttributes<HTMLUListElement
      * Override or extend the styles applied to the component.
      */
     classes?: Partial<TreeViewClasses>;
-    /**
-     * The default icon used to collapse the node.
-     */
-    defaultCollapseIcon?: React.ReactNode;
-    /**
-     * The default icon displayed next to a end node. This is applied to all
-     * tree nodes and can be overridden by the TreeItem `icon` prop.
-     */
-    defaultEndIcon?: React.ReactNode;
-    /**
-     * Expanded node ids.
-     * Used when the item's expansion are not controlled.
-     * @default []
-     */
-    defaultExpanded?: string[];
-    /**
-     * The default icon used to expand the node.
-     */
-    defaultExpandIcon?: React.ReactNode;
-    /**
-     * The default icon displayed next to a parent node. This is applied to all
-     * parent nodes and can be overridden by the TreeItem `icon` prop.
-     */
-    defaultParentIcon?: React.ReactNode;
-    /**
-     * If `true`, will allow focus on disabled items.
-     * @default false
-     */
-    disabledItemsFocusable?: boolean;
-    /**
-     * If `true` selection is disabled.
-     * @default false
-     */
-    disableSelection?: boolean;
-    /**
-     * Expanded node ids.
-     * Used when the item's expansion are controlled.
-     */
-    expanded?: string[];
-    /**
-     * This prop is used to help implement the accessibility logic.
-     * If you don't provide this prop. It falls back to a randomly generated id.
-     */
-    id?: string;
-    /**
-     * Callback fired when tree items are focused.
-     * @param {React.SyntheticEvent} event The event source of the callback **Warning**: This is a generic event not a focus event.
-     * @param {string} nodeId The id of the node focused.
-     * @param {string} value of the focused node.
-     */
-    onNodeFocus?: (event: React.SyntheticEvent, nodeId: string) => void;
-    /**
-     * Callback fired when tree items are expanded/collapsed.
-     * @param {React.SyntheticEvent} event The event source of the callback.
-     * @param {array} nodeIds The ids of the expanded nodes.
-     */
-    onNodeToggle?: (event: React.SyntheticEvent, nodeIds: string[]) => void;
     /**
      * The system prop that allows defining system overrides as well as additional CSS styles.
      */
     sx?: SxProps<Theme>;
 }
-export interface MultiSelectTreeViewProps extends TreeViewPropsBase {
-    /**
-     * Selected node ids. (Uncontrolled)
-     * When `multiSelect` is true this takes an array of strings; when false (default) a string.
-     * @default []
-     */
-    defaultSelected?: string[];
-    /**
-     * Selected node ids. (Controlled)
-     * When `multiSelect` is true this takes an array of strings; when false (default) a string.
-     */
-    selected?: string[];
-    /**
-     * If true `ctrl` and `shift` will trigger multiselect.
-     * @default false
-     */
-    multiSelect?: true;
-    /**
-     * Callback fired when tree items are selected/unselected.
-     * @param {React.SyntheticEvent} event The event source of the callback
-     * @param {string[] | string} nodeIds Ids of the selected nodes. When `multiSelect` is true
-     * this is an array of strings; when false (default) a string.
-     */
-    onNodeSelect?: (event: React.SyntheticEvent, nodeIds: string[]) => void;
-}
-export interface SingleSelectTreeViewProps extends TreeViewPropsBase {
-    /**
-     * Selected node ids. (Uncontrolled)
-     * When `multiSelect` is true this takes an array of strings; when false (default) a string.
-     * @default []
-     */
-    defaultSelected?: string | null;
-    /**
-     * Selected node ids. (Controlled)
-     * When `multiSelect` is true this takes an array of strings; when false (default) a string.
-     */
-    selected?: string | null;
-    /**
-     * If true `ctrl` and `shift` will trigger multiselect.
-     * @default false
-     */
-    multiSelect?: false;
-    /**
-     * Callback fired when tree items are selected/unselected.
-     * @param {React.SyntheticEvent} event The event source of the callback
-     * @param {string[] | string} nodeIds Ids of the selected nodes. When `multiSelect` is true
-     * this is an array of strings; when false (default) a string.
-     */
-    onNodeSelect?: (event: React.SyntheticEvent, nodeIds: string) => void;
-}
-export type TreeViewProps = SingleSelectTreeViewProps | MultiSelectTreeViewProps;
-export type TreeViewDefaultizedProps = DefaultizedProps<TreeViewProps, 'defaultExpanded' | 'defaultSelected' | 'disabledItemsFocusable' | 'disableSelection' | 'multiSelect'>;
-export interface TreeViewNode {
-    id: string;
-    idAttribute: string | undefined;
-    index: number;
-    parentId: string | null;
-    expandable: boolean;
-    disabled: boolean | undefined;
-}
-export interface TreeViewItemRange {
-    start?: string | null;
-    end?: string | null;
-    next?: string | null;
-    current?: string;
-}
-export interface TreeViewContextValue {
-    registerNode: (node: TreeViewNode) => void;
-    unregisterNode: (nodeId: string) => void;
-    isFocused: (nodeId: string) => boolean;
-    isSelected: (nodeId: string) => boolean;
-    isExpanded: (nodeId: string) => boolean;
-    isExpandable: (nodeId: string) => boolean;
-    isDisabled: (nodeId: string) => boolean;
-    mapFirstChar: (nodeId: string, firstChar: string) => void;
-    unMapFirstChar: (nodeId: string) => void;
-    focus: (event: React.SyntheticEvent, nodeId: string) => void;
-    toggleExpansion: (event: React.SyntheticEvent, value?: string) => void;
-    selectNode: (event: React.SyntheticEvent, nodeId: string, multiple?: boolean) => void;
-    selectRange: (event: React.SyntheticEvent, nodes: TreeViewItemRange, stacked?: boolean) => void;
-    multiSelect: boolean;
-    disabledItemsFocusable: boolean;
-    treeId: string | undefined;
-    icons: {
-        defaultCollapseIcon: React.ReactNode;
-        defaultExpandIcon: React.ReactNode;
-        defaultParentIcon: React.ReactNode;
-        defaultEndIcon: React.ReactNode;
-    };
+export interface TreeViewProps<Multiple extends boolean | undefined> extends DefaultTreeViewPluginParameters<Multiple>, TreeViewPropsBase {
 }
+export type SingleSelectTreeViewProps = TreeViewProps<false>;
+export type MultiSelectTreeViewProps = TreeViewProps<true>;

package/index.d.ts

@@ -1,2 +1,3 @@
 export * from './TreeItem';
 export * from './TreeView';
+export { unstable_resetCleanupTracking } from './internals/hooks/useInstanceEventHandler';

package/index.js

@@ -1,9 +1,10 @@
 /**
- * @mui/x-tree-view v6.0.0-alpha.3
+ * @mui/x-tree-view v6.0.0-beta.0
  *
  * @license MIT
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
 export * from './TreeItem';
-export * from './TreeView';
+export * from './TreeView';
+export { unstable_resetCleanupTracking } from './internals/hooks/useInstanceEventHandler';

package/{TreeView/descendants.d.ts → internals/TreeViewProvider/DescendantProvider.d.ts}

@@ -1,5 +1,4 @@
 import * as React from 'react';
-import PropTypes from 'prop-types';
 /**
  * This hook registers our descendant by passing it into an array. We can then
  * search that array by to find its index when registering it in the component.
@@ -30,10 +29,7 @@ interface DescendantProviderProps {
 }
 export declare function DescendantProvider(props: DescendantProviderProps): React.JSX.Element;
 export declare namespace DescendantProvider {
-    var propTypes: {
-        children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
-        id: PropTypes.Requireable<string>;
-    };
+    var propTypes: any;
 }
 export interface TreeItemDescendant {
     element: HTMLLIElement;

package/internals/TreeViewProvider/TreeViewContext.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+import { TreeViewContextValue } from './TreeViewProvider.types';
+export declare const DEFAULT_TREE_VIEW_CONTEXT_VALUE: TreeViewContextValue<any>;
+/**
+ * @ignore - internal component.
+ */
+export declare const TreeViewContext: React.Context<TreeViewContextValue<any>>;

package/{TreeView → internals/TreeViewProvider}/TreeViewContext.js

@@ -1,21 +1,6 @@
 import * as React from 'react';
-/**
- * @ignore - internal component.
- */
-export const TreeViewContext = /*#__PURE__*/React.createContext({
-  registerNode: () => {},
-  unregisterNode: () => {},
-  isFocused: () => false,
-  isSelected: () => false,
-  isExpanded: () => false,
-  isExpandable: () => false,
-  isDisabled: () => false,
-  mapFirstChar: () => {},
-  unMapFirstChar: () => {},
-  focus: () => {},
-  toggleExpansion: () => {},
-  selectNode: () => {},
-  selectRange: () => {},
+export const DEFAULT_TREE_VIEW_CONTEXT_VALUE = {
+  instance: null,
   multiSelect: false,
   disabledItemsFocusable: false,
   treeId: undefined,
@@ -25,7 +10,12 @@ export const TreeViewContext = /*#__PURE__*/React.createContext({
     defaultParentIcon: null,
     defaultEndIcon: null
   }
-});
+};
+
+/**
+ * @ignore - internal component.
+ */
+export const TreeViewContext = /*#__PURE__*/React.createContext(DEFAULT_TREE_VIEW_CONTEXT_VALUE);
 if (process.env.NODE_ENV !== 'production') {
   TreeViewContext.displayName = 'TreeViewContext';
 }

package/internals/TreeViewProvider/TreeViewProvider.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+import { TreeViewProviderProps } from './TreeViewProvider.types';
+import { TreeViewAnyPluginSignature } from '../models';
+/**
+ * Sets up the contexts for the underlying TreeItem components.
+ *
+ * @ignore - do not document.
+ */
+export declare function TreeViewProvider<TPlugins extends readonly TreeViewAnyPluginSignature[]>(props: TreeViewProviderProps<TPlugins>): React.JSX.Element;

package/internals/TreeViewProvider/TreeViewProvider.js

@@ -0,0 +1,21 @@
+import * as React from 'react';
+import { TreeViewContext } from './TreeViewContext';
+import { DescendantProvider } from './DescendantProvider';
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Sets up the contexts for the underlying TreeItem components.
+ *
+ * @ignore - do not document.
+ */
+export function TreeViewProvider(props) {
+  const {
+    value,
+    children
+  } = props;
+  return /*#__PURE__*/_jsx(TreeViewContext.Provider, {
+    value: value,
+    children: /*#__PURE__*/_jsx(DescendantProvider, {
+      children: children
+    })
+  });
+}

package/internals/TreeViewProvider/TreeViewProvider.types.d.ts

@@ -0,0 +1,18 @@
+import * as React from 'react';
+import { TreeViewAnyPluginSignature, TreeViewInstance } from '../models';
+export interface TreeViewContextValue<TPlugins extends readonly TreeViewAnyPluginSignature[]> {
+    treeId: string | undefined;
+    instance: TreeViewInstance<TPlugins> | null;
+    multiSelect: boolean;
+    disabledItemsFocusable: boolean;
+    icons: {
+        defaultCollapseIcon: React.ReactNode;
+        defaultExpandIcon: React.ReactNode;
+        defaultParentIcon: React.ReactNode;
+        defaultEndIcon: React.ReactNode;
+    };
+}
+export interface TreeViewProviderProps<TPlugins extends readonly TreeViewAnyPluginSignature[]> {
+    value: TreeViewContextValue<TPlugins>;
+    children: React.ReactNode;
+}

package/internals/TreeViewProvider/index.d.ts

@@ -0,0 +1,2 @@
+export { TreeViewProvider } from './TreeViewProvider';
+export type { TreeViewProviderProps, TreeViewContextValue } from './TreeViewProvider.types';

package/internals/TreeViewProvider/index.js

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

package/internals/TreeViewProvider/useTreeViewContext.d.ts

@@ -0,0 +1,3 @@
+import { TreeViewAnyPluginSignature } from '../models';
+import { TreeViewContextValue } from './TreeViewProvider.types';
+export declare const useTreeViewContext: <TPlugins extends readonly TreeViewAnyPluginSignature[]>() => TreeViewContextValue<TPlugins>;

package/internals/TreeViewProvider/useTreeViewContext.js

@@ -0,0 +1,3 @@
+import * as React from 'react';
+import { TreeViewContext } from './TreeViewContext';
+export const useTreeViewContext = () => React.useContext(TreeViewContext);

package/internals/corePlugins/corePlugins.d.ts

@@ -0,0 +1,7 @@
+import { ConvertPluginsIntoSignatures, MergePlugins } from '../models';
+/**
+ * Internal plugins that creates the tools used by the other plugins.
+ * These plugins are used by the tree view components.
+ */
+export declare const TREE_VIEW_CORE_PLUGINS: readonly [import("../models").TreeViewPlugin<import("./useTreeViewInstanceEvents").UseTreeViewInstanceEventsSignature>];
+export type TreeViewCorePluginsSignature = MergePlugins<ConvertPluginsIntoSignatures<typeof TREE_VIEW_CORE_PLUGINS>>;

package/internals/corePlugins/corePlugins.js

@@ -0,0 +1,6 @@
+import { useTreeViewInstanceEvents } from './useTreeViewInstanceEvents';
+/**
+ * Internal plugins that creates the tools used by the other plugins.
+ * These plugins are used by the tree view components.
+ */
+export const TREE_VIEW_CORE_PLUGINS = [useTreeViewInstanceEvents];

package/internals/corePlugins/index.d.ts

@@ -0,0 +1,2 @@
+export { TREE_VIEW_CORE_PLUGINS } from './corePlugins';
+export type { TreeViewCorePluginsSignature } from './corePlugins';

package/internals/corePlugins/index.js

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

package/internals/corePlugins/useTreeViewInstanceEvents/index.d.ts

@@ -0,0 +1,2 @@
+export { useTreeViewInstanceEvents } from './useTreeViewInstanceEvents';
+export type { UseTreeViewInstanceEventsSignature } from './useTreeViewInstanceEvents.types';

package/internals/corePlugins/useTreeViewInstanceEvents/index.js

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

package/internals/corePlugins/useTreeViewInstanceEvents/useTreeViewInstanceEvents.d.ts

@@ -0,0 +1,8 @@
+import type { TreeViewPlugin } from '../../models';
+import { UseTreeViewInstanceEventsSignature } from './useTreeViewInstanceEvents.types';
+/**
+ * Plugin responsible for the registration of the nodes defined as JSX children of the TreeView.
+ * When we will have both a SimpleTreeView using JSX children and a TreeView using a data prop,
+ * this plugin will only be used by SimpleTreeView.
+ */
+export declare const useTreeViewInstanceEvents: TreeViewPlugin<UseTreeViewInstanceEventsSignature>;

package/internals/corePlugins/useTreeViewInstanceEvents/useTreeViewInstanceEvents.js

@@ -0,0 +1,35 @@
+import * as React from 'react';
+import { EventManager } from '../../utils/EventManager';
+import { populateInstance } from '../../useTreeView/useTreeView.utils';
+const isSyntheticEvent = event => {
+  return event.isPropagationStopped !== undefined;
+};
+
+/**
+ * Plugin responsible for the registration of the nodes defined as JSX children of the TreeView.
+ * When we will have both a SimpleTreeView using JSX children and a TreeView using a data prop,
+ * this plugin will only be used by SimpleTreeView.
+ */
+export const useTreeViewInstanceEvents = ({
+  instance
+}) => {
+  const [eventManager] = React.useState(() => new EventManager());
+  const publishEvent = React.useCallback((...args) => {
+    const [name, params, event = {}] = args;
+    event.defaultMuiPrevented = false;
+    if (isSyntheticEvent(event) && event.isPropagationStopped()) {
+      return;
+    }
+    eventManager.emit(name, params, event);
+  }, [eventManager]);
+  const subscribeEvent = React.useCallback((event, handler) => {
+    eventManager.on(event, handler);
+    return () => {
+      eventManager.removeListener(event, handler);
+    };
+  }, [eventManager]);
+  populateInstance(instance, {
+    $$publishEvent: publishEvent,
+    $$subscribeEvent: subscribeEvent
+  });
+};

package/internals/corePlugins/useTreeViewInstanceEvents/useTreeViewInstanceEvents.types.d.ts

@@ -0,0 +1,21 @@
+import { TreeViewPluginSignature } from '../../models';
+import { TreeViewEventListener } from '../../models/events';
+export interface UseTreeViewInstanceEventsInstance {
+    /**
+     * Should never be used directly.
+     * Please use `useInstanceEventHandler` instead.
+     * @param {string} eventName Name of the event to subscribe to.
+     * @param {TreeViewEventListener<any>} handler Event handler to call when the event is published.
+     * @returns {() => void} Cleanup function.
+     */
+    $$subscribeEvent: (eventName: string, handler: TreeViewEventListener<any>) => () => void;
+    /**
+     * Should never be used directly.
+     * Please use `publishTreeViewEvent` instead.
+     * @param {string} eventName Name of the event to publish.
+     * @param {any} params The params to publish with the event.
+     */
+    $$publishEvent: (eventName: string, params: any) => void;
+}
+export type UseTreeViewInstanceEventsSignature = TreeViewPluginSignature<{}, {}, UseTreeViewInstanceEventsInstance, {}, {}, never, [
+]>;

package/internals/hooks/useInstanceEventHandler.d.ts

@@ -0,0 +1,15 @@
+import { CleanupTracking } from '../utils/cleanupTracking/CleanupTracking';
+import { TreeViewAnyPluginSignature, TreeViewUsedEvents } from '../models';
+import { TreeViewEventListener } from '../models/events';
+import { UseTreeViewInstanceEventsInstance } from '../corePlugins/useTreeViewInstanceEvents/useTreeViewInstanceEvents.types';
+interface RegistryContainer {
+    registry: CleanupTracking | null;
+}
+export declare function createUseInstanceEventHandler(registryContainer: RegistryContainer): <Instance extends UseTreeViewInstanceEventsInstance & {
+    $$signature: TreeViewAnyPluginSignature;
+}, E extends keyof Instance["$$signature"]["events"] | keyof import("../models").MergePluginsProperty<[import("../corePlugins").TreeViewCorePluginsSignature, ...Instance["$$signature"]["dependantPlugins"]], "events">>(instance: Instance, eventName: E, handler: TreeViewEventListener<TreeViewUsedEvents<Instance["$$signature"]>[E]>) => void;
+export declare const unstable_resetCleanupTracking: () => void;
+export declare const useInstanceEventHandler: <Instance extends UseTreeViewInstanceEventsInstance & {
+    $$signature: TreeViewAnyPluginSignature;
+}, E extends keyof Instance["$$signature"]["events"] | keyof import("../models").MergePluginsProperty<[import("../corePlugins").TreeViewCorePluginsSignature, ...Instance["$$signature"]["dependantPlugins"]], "events">>(instance: Instance, eventName: E, handler: TreeViewEventListener<TreeViewUsedEvents<Instance["$$signature"]>[E]>) => void;
+export {};

package/internals/hooks/useInstanceEventHandler.js

@@ -0,0 +1,82 @@
+import * as React from 'react';
+import { TimerBasedCleanupTracking } from '../utils/cleanupTracking/TimerBasedCleanupTracking';
+import { FinalizationRegistryBasedCleanupTracking } from '../utils/cleanupTracking/FinalizationRegistryBasedCleanupTracking';
+// We use class to make it easier to detect in heap snapshots by name
+class ObjectToBeRetainedByReact {}
+
+// Based on https://github.com/Bnaya/use-dispose-uncommitted/blob/main/src/finalization-registry-based-impl.ts
+// Check https://github.com/facebook/react/issues/15317 to get more information
+export function createUseInstanceEventHandler(registryContainer) {
+  let cleanupTokensCounter = 0;
+  return function useInstanceEventHandler(instance, eventName, handler) {
+    if (registryContainer.registry === null) {
+      registryContainer.registry = typeof FinalizationRegistry !== 'undefined' ? new FinalizationRegistryBasedCleanupTracking() : new TimerBasedCleanupTracking();
+    }
+    const [objectRetainedByReact] = React.useState(new ObjectToBeRetainedByReact());
+    const subscription = React.useRef(null);
+    const handlerRef = React.useRef();
+    handlerRef.current = handler;
+    const cleanupTokenRef = React.useRef(null);
+    if (!subscription.current && handlerRef.current) {
+      const enhancedHandler = (params, event) => {
+        if (!event.defaultMuiPrevented) {
+          var _handlerRef$current;
+          (_handlerRef$current = handlerRef.current) == null || _handlerRef$current.call(handlerRef, params, event);
+        }
+      };
+      subscription.current = instance.$$subscribeEvent(eventName, enhancedHandler);
+      cleanupTokensCounter += 1;
+      cleanupTokenRef.current = {
+        cleanupToken: cleanupTokensCounter
+      };
+      registryContainer.registry.register(objectRetainedByReact,
+      // The callback below will be called once this reference stops being retained
+      () => {
+        var _subscription$current;
+        (_subscription$current = subscription.current) == null || _subscription$current.call(subscription);
+        subscription.current = null;
+        cleanupTokenRef.current = null;
+      }, cleanupTokenRef.current);
+    } else if (!handlerRef.current && subscription.current) {
+      subscription.current();
+      subscription.current = null;
+      if (cleanupTokenRef.current) {
+        registryContainer.registry.unregister(cleanupTokenRef.current);
+        cleanupTokenRef.current = null;
+      }
+    }
+    React.useEffect(() => {
+      if (!subscription.current && handlerRef.current) {
+        const enhancedHandler = (params, event) => {
+          if (!event.defaultMuiPrevented) {
+            var _handlerRef$current2;
+            (_handlerRef$current2 = handlerRef.current) == null || _handlerRef$current2.call(handlerRef, params, event);
+          }
+        };
+        subscription.current = instance.$$subscribeEvent(eventName, enhancedHandler);
+      }
+      if (cleanupTokenRef.current && registryContainer.registry) {
+        // If the effect was called, it means that this render was committed
+        // so we can trust the cleanup function to remove the listener.
+        registryContainer.registry.unregister(cleanupTokenRef.current);
+        cleanupTokenRef.current = null;
+      }
+      return () => {
+        var _subscription$current2;
+        (_subscription$current2 = subscription.current) == null || _subscription$current2.call(subscription);
+        subscription.current = null;
+      };
+    }, [instance, eventName]);
+  };
+}
+const registryContainer = {
+  registry: null
+};
+
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export const unstable_resetCleanupTracking = () => {
+  var _registryContainer$re;
+  (_registryContainer$re = registryContainer.registry) == null || _registryContainer$re.reset();
+  registryContainer.registry = null;
+};
+export const useInstanceEventHandler = createUseInstanceEventHandler(registryContainer);

package/internals/models/events.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+export interface TreeViewEventLookupElement {
+    params: object;
+}
+export type TreeViewEventListener<E extends TreeViewEventLookupElement> = (params: E['params'], event: MuiEvent<{}>) => void;
+export type MuiBaseEvent = React.SyntheticEvent<HTMLElement> | DocumentEventMap[keyof DocumentEventMap] | {};
+export type MuiEvent<E extends MuiBaseEvent = MuiBaseEvent> = E & {
+    defaultMuiPrevented?: boolean;
+};

package/internals/models/helpers.d.ts

@@ -0,0 +1,13 @@
+import { TreeViewAnyPluginSignature, TreeViewPlugin } from './plugin';
+export type DefaultizedProps<P extends {}, RequiredProps extends keyof P, AdditionalProps extends {} = {}> = Omit<P, RequiredProps | keyof AdditionalProps> & Required<Pick<P, RequiredProps>> & AdditionalProps;
+export type MergePluginsProperty<TPlugins extends readonly any[], TProperty extends keyof TreeViewAnyPluginSignature> = TPlugins extends readonly [plugin: infer P, ...otherPlugin: infer R] ? P extends TreeViewAnyPluginSignature ? P[TProperty] & MergePluginsProperty<R, TProperty> : {} : {};
+export type ConvertPluginsIntoSignatures<TPlugins extends readonly any[]> = TPlugins extends readonly [plugin: infer P, ...otherPlugin: infer R] ? P extends TreeViewPlugin<infer TSignature> ? [TSignature, ...ConvertPluginsIntoSignatures<R>] : ConvertPluginsIntoSignatures<R> : [];
+export interface MergePlugins<TPlugins extends readonly any[]> {
+    state: MergePluginsProperty<TPlugins, 'state'>;
+    instance: MergePluginsProperty<TPlugins, 'instance'>;
+    params: MergePluginsProperty<TPlugins, 'params'>;
+    defaultizedParams: MergePluginsProperty<TPlugins, 'defaultizedParams'>;
+    dependantPlugins: MergePluginsProperty<TPlugins, 'dependantPlugins'>;
+    events: MergePluginsProperty<TPlugins, 'events'>;
+    models: MergePluginsProperty<TPlugins, 'models'>;
+}

package/internals/models/helpers.js

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

package/internals/models/index.d.ts

@@ -0,0 +1,3 @@
+export * from './helpers';
+export * from './plugin';
+export * from './treeView';

package/internals/models/index.js

@@ -0,0 +1,3 @@
+export * from './helpers';
+export * from './plugin';
+export * from './treeView';

package/internals/models/plugin.d.ts

@@ -0,0 +1,69 @@
+import * as React from 'react';
+import { EventHandlers } from '@mui/base/utils';
+import { TreeViewModel } from './treeView';
+import type { TreeViewContextValue } from '../TreeViewProvider';
+import type { MergePluginsProperty } from './helpers';
+import { TreeViewEventLookupElement } from './events';
+import type { TreeViewCorePluginsSignature } from '../corePlugins';
+export interface TreeViewPluginOptions<TSignature extends TreeViewAnyPluginSignature> {
+    instance: TreeViewUsedInstance<TSignature>;
+    params: TreeViewUsedDefaultizedParams<TSignature>;
+    state: TreeViewUsedState<TSignature>;
+    models: TreeViewUsedModels<TSignature>;
+    setState: React.Dispatch<React.SetStateAction<TreeViewUsedState<TSignature>>>;
+    rootRef: React.RefObject<HTMLUListElement>;
+}
+type TreeViewModelsInitializer<TSignature extends TreeViewAnyPluginSignature> = {
+    [TControlled in keyof TSignature['models']]: {
+        controlledProp: TControlled;
+        defaultProp: keyof TSignature['params'];
+    };
+};
+interface TreeViewResponse {
+    getRootProps?: <TOther extends EventHandlers = {}>(otherHandlers: TOther) => React.HTMLAttributes<HTMLUListElement>;
+    contextValue?: TreeViewContextValue<any>;
+}
+export type TreeViewPluginSignature<TParams extends {}, TDefaultizedParams extends {}, TInstance extends {}, TEvents extends {
+    [key in keyof TEvents]: TreeViewEventLookupElement;
+}, TState extends {}, TModelNames extends keyof TDefaultizedParams, TDependantPlugins extends readonly TreeViewAnyPluginSignature[]> = {
+    params: TParams;
+    defaultizedParams: TDefaultizedParams;
+    instance: TInstance;
+    state: TState;
+    models: {
+        [TControlled in TModelNames]-?: TreeViewModel<Exclude<TDefaultizedParams[TControlled], undefined>>;
+    };
+    events: TEvents;
+    dependantPlugins: TDependantPlugins;
+};
+export type TreeViewAnyPluginSignature = {
+    state: any;
+    instance: any;
+    params: any;
+    defaultizedParams: any;
+    dependantPlugins: any;
+    events: any;
+    models: any;
+};
+type TreeViewUsedPlugins<TSignature extends TreeViewAnyPluginSignature> = [
+    TreeViewCorePluginsSignature,
+    ...TSignature['dependantPlugins']
+];
+type TreeViewUsedParams<TSignature extends TreeViewAnyPluginSignature> = TSignature['params'] & MergePluginsProperty<TreeViewUsedPlugins<TSignature>, 'params'>;
+type TreeViewUsedDefaultizedParams<TSignature extends TreeViewAnyPluginSignature> = TSignature['defaultizedParams'] & MergePluginsProperty<TreeViewUsedPlugins<TSignature>, 'defaultizedParams'>;
+export type TreeViewUsedInstance<TSignature extends TreeViewAnyPluginSignature> = TSignature['instance'] & MergePluginsProperty<TreeViewUsedPlugins<TSignature>, 'instance'> & {
+    /**
+     * Private property only defined in TypeScript to be able to access the plugin signature from the instance object.
+     */
+    $$signature: TSignature;
+};
+type TreeViewUsedState<TSignature extends TreeViewAnyPluginSignature> = TSignature['state'] & MergePluginsProperty<TreeViewUsedPlugins<TSignature>, 'state'>;
+export type TreeViewUsedModels<TSignature extends TreeViewAnyPluginSignature> = TSignature['models'] & MergePluginsProperty<TreeViewUsedPlugins<TSignature>, 'models'>;
+export type TreeViewUsedEvents<TSignature extends TreeViewAnyPluginSignature> = TSignature['events'] & MergePluginsProperty<TreeViewUsedPlugins<TSignature>, 'events'>;
+export type TreeViewPlugin<TSignature extends TreeViewAnyPluginSignature> = {
+    (options: TreeViewPluginOptions<TSignature>): void | TreeViewResponse;
+    getDefaultizedParams?: (params: TreeViewUsedParams<TSignature>) => TSignature['defaultizedParams'];
+    getInitialState?: (params: TreeViewUsedDefaultizedParams<TSignature>) => TSignature['state'];
+    models?: TreeViewModelsInitializer<TSignature>;
+};
+export {};

package/internals/models/plugin.js

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