@mui/x-tree-view 8.0.0-alpha.11 → 8.0.0-alpha.13

package/modern/TreeItem/TreeItem.types.d.ts

@@ -0,0 +1,93 @@
+import * as React from 'react';
+import { SlotComponentPropsFromProps } from '@mui/x-internals/types';
+import { TransitionProps } from '@mui/material/transitions';
+import { SlotComponentProps } from '@mui/utils/types';
+import { UseTreeItemParameters, UseTreeItemStatus } from "../useTreeItem/index.js";
+import { TreeItemClasses } from "./treeItemClasses.js";
+import { TreeItemIconSlotProps, TreeItemIconSlots } from "../TreeItemIcon/index.js";
+import { TreeViewCancellableEventHandler } from "../models/index.js";
+export interface TreeItemSlots extends TreeItemIconSlots {
+  /**
+   * The component that renders the root.
+   * @default TreeItemRoot
+   */
+  root?: React.ElementType;
+  /**
+   * The component that renders the content of the item.
+   * (e.g.: everything related to this item, not to its children).
+   * @default TreeItemContent
+   */
+  content?: React.ElementType;
+  /**
+   * The component that renders the children of the item.
+   * @default TreeItemGroupTransition
+   */
+  groupTransition?: React.ElementType;
+  /**
+   * The component that renders the icon.
+   * @default TreeItemIconContainer
+   */
+  iconContainer?: React.ElementType;
+  /**
+   * The component that renders the item checkbox for selection.
+   * @default TreeItemCheckbox
+   */
+  checkbox?: React.ElementType;
+  /**
+   * The component that renders the item label.
+   * @default TreeItemLabel
+   */
+  label?: React.ElementType;
+  /**
+   * The component that renders the input to edit the label when the item is editable and is currently being edited.
+   * @default TreeItemLabelInput
+   */
+  labelInput?: React.ElementType;
+  /**
+   * The component that renders the overlay when an item reordering is ongoing.
+   * Warning: This slot is only useful when using the `<RichTreeViewPro />` component.
+   * @default TreeItemDragAndDropOverlay
+   */
+  dragAndDropOverlay?: React.ElementType;
+}
+export interface TreeItemSlotProps extends TreeItemIconSlotProps {
+  root?: SlotComponentProps<'li', {}, {}>;
+  content?: SlotComponentProps<'div', {}, {}>;
+  groupTransition?: SlotComponentPropsFromProps<TransitionProps, {}, {}>;
+  iconContainer?: SlotComponentProps<'div', {}, {}>;
+  checkbox?: SlotComponentProps<'button', {}, {}>;
+  label?: SlotComponentProps<'div', {}, {}>;
+  labelInput?: SlotComponentProps<'input', {}, {}>;
+  dragAndDropOverlay?: SlotComponentProps<'div', {}, {}>;
+}
+export interface TreeItemProps extends Omit<UseTreeItemParameters, 'rootRef'>, Omit<React.HTMLAttributes<HTMLLIElement>, 'onFocus'> {
+  className?: string;
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes?: Partial<TreeItemClasses>;
+  /**
+   * Overridable component slots.
+   * @default {}
+   */
+  slots?: TreeItemSlots;
+  /**
+   * The props used for each component slot.
+   * @default {}
+   */
+  slotProps?: TreeItemSlotProps;
+  /**
+   * This prop isn't supported.
+   * Use the `onItemFocus` callback on the tree if you need to monitor an item's focus.
+   */
+  onFocus?: null;
+  /**
+   * Callback fired when the item root is blurred.
+   */
+  onBlur?: TreeViewCancellableEventHandler<React.FocusEvent<HTMLLIElement>>;
+  /**
+   * Callback fired when a key is pressed on the keyboard and the tree is in focus.
+   */
+  onKeyDown?: TreeViewCancellableEventHandler<React.KeyboardEvent<HTMLLIElement>>;
+}
+export interface TreeItemOwnerState extends Omit<TreeItemProps, 'disabled'>, UseTreeItemStatus {}

package/modern/TreeItem/index.d.ts

@@ -0,0 +1,3 @@
+export { TreeItem, TreeItemRoot, TreeItemContent, TreeItemIconContainer, TreeItemGroupTransition, TreeItemCheckbox, TreeItemLabel } from "./TreeItem.js";
+export type { TreeItemProps, TreeItemSlots, TreeItemSlotProps } from './TreeItem.types';
+export * from "./treeItemClasses.js";

package/modern/TreeItem/treeItemClasses.d.ts

@@ -0,0 +1,33 @@
+export interface TreeItemClasses {
+  /** Styles applied to the root element. */
+  root: string;
+  /** Styles applied to the transition component. */
+  groupTransition: string;
+  /** Styles applied to the content element. */
+  content: string;
+  /** State class applied to the content element when expanded. */
+  expanded: string;
+  /** State class applied to the content element when selected. */
+  selected: string;
+  /** State class applied to the content element when focused. */
+  focused: string;
+  /** State class applied to the element when disabled. */
+  disabled: string;
+  /** Styles applied to the Tree Item icon. */
+  iconContainer: string;
+  /** Styles applied to the label element. */
+  label: string;
+  /** Styles applied to the checkbox element. */
+  checkbox: string;
+  /** Styles applied to the input element that is visible when editing is enabled. */
+  labelInput: string;
+  /** Styles applied to the content element when editing is enabled. */
+  editing: string;
+  /** Styles applied to the content of the items that are editable. */
+  editable: string;
+  /** Styles applied to the drag and drop overlay. */
+  dragAndDropOverlay: string;
+}
+export type TreeItemClassKey = keyof TreeItemClasses;
+export declare function getTreeItemUtilityClass(slot: string): string;
+export declare const treeItemClasses: TreeItemClasses;

package/modern/TreeItemDragAndDropOverlay/TreeItemDragAndDropOverlay.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+import { TreeItemDragAndDropOverlayProps } from "./TreeItemDragAndDropOverlay.types.js";
+declare function TreeItemDragAndDropOverlay(props: TreeItemDragAndDropOverlayProps): React.JSX.Element | null;
+declare namespace TreeItemDragAndDropOverlay {
+  var propTypes: any;
+}
+export { TreeItemDragAndDropOverlay };

package/modern/TreeItemDragAndDropOverlay/TreeItemDragAndDropOverlay.types.d.ts

@@ -0,0 +1,6 @@
+import * as React from 'react';
+import { TreeViewItemsReorderingAction } from "../models/index.js";
+export interface TreeItemDragAndDropOverlayProps {
+  action?: TreeViewItemsReorderingAction;
+  style?: React.CSSProperties;
+}

package/modern/TreeItemDragAndDropOverlay/index.d.ts

@@ -0,0 +1,2 @@
+export { TreeItemDragAndDropOverlay } from "./TreeItemDragAndDropOverlay.js";
+export type { TreeItemDragAndDropOverlayProps } from './TreeItemDragAndDropOverlay.types';

package/modern/TreeItemIcon/TreeItemIcon.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+import { TreeItemIconProps } from "./TreeItemIcon.types.js";
+declare function TreeItemIcon(props: TreeItemIconProps): React.JSX.Element | null;
+declare namespace TreeItemIcon {
+  var propTypes: any;
+}
+export { TreeItemIcon };

package/modern/TreeItemIcon/TreeItemIcon.types.d.ts

@@ -0,0 +1,40 @@
+import * as React from 'react';
+import { SlotComponentProps } from '@mui/utils/types';
+import { UseTreeItemStatus } from "../useTreeItem/index.js";
+export interface TreeItemIconSlots {
+  /**
+   * The icon used to collapse the item.
+   */
+  collapseIcon?: React.ElementType;
+  /**
+   * The icon used to expand the item.
+   */
+  expandIcon?: React.ElementType;
+  /**
+   * The icon displayed next to an end item.
+   */
+  endIcon?: React.ElementType;
+  /**
+   * The icon to display next to the Tree Item's label.
+   */
+  icon?: React.ElementType;
+}
+export interface TreeItemIconSlotProps {
+  collapseIcon?: SlotComponentProps<'svg', {}, {}>;
+  expandIcon?: SlotComponentProps<'svg', {}, {}>;
+  endIcon?: SlotComponentProps<'svg', {}, {}>;
+  icon?: SlotComponentProps<'svg', {}, {}>;
+}
+export interface TreeItemIconProps {
+  status: UseTreeItemStatus;
+  /**
+   * Overridable component slots.
+   * @default {}
+   */
+  slots?: TreeItemIconSlots;
+  /**
+   * The props used for each component slot.
+   * @default {}
+   */
+  slotProps?: TreeItemIconSlotProps;
+}

package/modern/TreeItemIcon/index.d.ts

@@ -0,0 +1,2 @@
+export { TreeItemIcon } from "./TreeItemIcon.js";
+export type { TreeItemIconProps, TreeItemIconSlots, TreeItemIconSlotProps } from './TreeItemIcon.types';

package/modern/TreeItemLabelInput/TreeItemLabelInput.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @ignore - internal component.
+ */
+declare const TreeItemLabelInput: import("@emotion/styled").StyledComponent<import("@mui/system").MUIStyledCommonProps<import("@mui/material").Theme>, Pick<import("react").DetailedHTMLProps<import("react").InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, keyof import("react").ClassAttributes<HTMLInputElement> | keyof import("react").InputHTMLAttributes<HTMLInputElement>>, {}>;
+export { TreeItemLabelInput };

package/modern/TreeItemLabelInput/TreeItemLabelInput.types.d.ts

@@ -0,0 +1,14 @@
+import * as React from 'react';
+import { TreeViewCancellableEventHandler } from "../models/index.js";
+export interface TreeItemLabelInputProps {
+  value?: string;
+  /**
+   * Used to determine if the target of keydown or blur events is the input and prevent the event from propagating to the root.
+   */
+  'data-element'?: 'labelInput';
+  onChange?: React.ChangeEventHandler<HTMLInputElement>;
+  onKeyDown?: TreeViewCancellableEventHandler<React.KeyboardEvent<HTMLInputElement>>;
+  onBlur?: TreeViewCancellableEventHandler<React.FocusEvent<HTMLInputElement>>;
+  autoFocus?: true;
+  type?: 'text';
+}

package/modern/TreeItemLabelInput/index.d.ts

@@ -0,0 +1,2 @@
+export { TreeItemLabelInput } from "./TreeItemLabelInput.js";
+export type { TreeItemLabelInputProps } from './TreeItemLabelInput.types';

package/modern/TreeItemProvider/TreeItemProvider.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+import { TreeItemProviderProps } from "./TreeItemProvider.types.js";
+declare function TreeItemProvider(props: TreeItemProviderProps): React.JSX.Element;
+declare namespace TreeItemProvider {
+  var propTypes: any;
+}
+export { TreeItemProvider };

package/modern/TreeItemProvider/TreeItemProvider.types.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+import { TreeViewItemId } from "../models/index.js";
+export interface TreeItemProviderProps {
+  children: React.ReactNode;
+  itemId: TreeViewItemId;
+  id: string | undefined;
+}

package/modern/TreeItemProvider/index.d.ts

@@ -0,0 +1,2 @@
+export { TreeItemProvider } from "./TreeItemProvider.js";
+export type { TreeItemProviderProps } from './TreeItemProvider.types';

package/modern/hooks/index.d.ts

@@ -0,0 +1,3 @@
+export { useTreeViewApiRef } from "./useTreeViewApiRef.js";
+export { useTreeItemUtils } from "./useTreeItemUtils/index.js";
+export { useTreeItemModel } from "./useTreeItemModel.js";

package/modern/hooks/useTreeItemModel.d.ts

@@ -0,0 +1,2 @@
+import { TreeViewBaseItem, TreeViewDefaultItemModelProperties, TreeViewItemId } from "../models/index.js";
+export declare const useTreeItemModel: <R extends {} = TreeViewDefaultItemModelProperties>(itemId: TreeViewItemId) => TreeViewBaseItem<R> | null;

package/modern/hooks/useTreeItemUtils/index.d.ts

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

package/modern/hooks/useTreeItemUtils/useTreeItemUtils.d.ts

@@ -0,0 +1,41 @@
+import * as React from 'react';
+import type { UseTreeViewSelectionSignature } from '../../internals/plugins/useTreeViewSelection';
+import type { UseTreeViewExpansionSignature } from '../../internals/plugins/useTreeViewExpansion';
+import type { UseTreeViewItemsSignature } from '../../internals/plugins/useTreeViewItems';
+import type { UseTreeViewFocusSignature } from '../../internals/plugins/useTreeViewFocus';
+import { UseTreeViewLabelSignature } from "../../internals/plugins/useTreeViewLabel/index.js";
+import type { UseTreeItemStatus } from '../../useTreeItem';
+import { TreeViewPublicAPI } from "../../internals/models/index.js";
+export interface UseTreeItemInteractions {
+  handleExpansion: (event: React.MouseEvent) => void;
+  handleSelection: (event: React.MouseEvent) => void;
+  handleCheckboxSelection: (event: React.ChangeEvent<HTMLInputElement>) => void;
+  toggleItemEditing: () => void;
+  handleSaveItemLabel: (event: React.SyntheticEvent, label: string) => void;
+  handleCancelItemLabelEditing: (event: React.SyntheticEvent) => void;
+}
+/**
+ * Plugins that need to be present in the Tree View in order for `useTreeItemUtils` to work correctly.
+ */
+type UseTreeItemUtilsMinimalPlugins = readonly [UseTreeViewSelectionSignature, UseTreeViewExpansionSignature, UseTreeViewItemsSignature, UseTreeViewFocusSignature];
+/**
+ * Plugins that `useTreeItemUtils` can use if they are present, but are not required.
+ */
+export type UseTreeItemUtilsOptionalPlugins = readonly [UseTreeViewLabelSignature];
+interface UseTreeItemUtilsReturnValue<TSignatures extends UseTreeItemUtilsMinimalPlugins, TOptionalSignatures extends UseTreeItemUtilsOptionalPlugins> {
+  interactions: UseTreeItemInteractions;
+  status: UseTreeItemStatus;
+  /**
+   * The object the allows Tree View manipulation.
+   */
+  publicAPI: TreeViewPublicAPI<TSignatures, TOptionalSignatures>;
+}
+export declare const isItemExpandable: (reactChildren: React.ReactNode) => boolean;
+export declare const useTreeItemUtils: <TSignatures extends UseTreeItemUtilsMinimalPlugins = UseTreeItemUtilsMinimalPlugins, TOptionalSignatures extends UseTreeItemUtilsOptionalPlugins = UseTreeItemUtilsOptionalPlugins>({
+  itemId,
+  children
+}: {
+  itemId: string;
+  children?: React.ReactNode;
+}) => UseTreeItemUtilsReturnValue<TSignatures, TOptionalSignatures>;
+export {};

package/modern/hooks/useTreeViewApiRef.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+import { TreeViewAnyPluginSignature, TreeViewPublicAPI } from "../internals/models/index.js";
+import { RichTreeViewPluginSignatures } from "../RichTreeView/RichTreeView.plugins.js";
+/**
+ * Hook that instantiates a [[TreeViewApiRef]].
+ */
+export declare const useTreeViewApiRef: <TSignatures extends readonly TreeViewAnyPluginSignature[] = readonly [import("../internals").UseTreeViewItemsSignature, import("../internals").UseTreeViewExpansionSignature, import("../internals").UseTreeViewSelectionSignature, import("../internals").UseTreeViewFocusSignature, import("../internals").UseTreeViewKeyboardNavigationSignature, import("../internals").UseTreeViewIconsSignature, import("../internals").UseTreeViewLabelSignature]>() => React.RefObject<TreeViewPublicAPI<TSignatures> | undefined>;

package/modern/icons/icons.d.ts

@@ -0,0 +1,6 @@
+export declare const TreeViewExpandIcon: import("@mui/material/OverridableComponent").OverridableComponent<import("@mui/material").SvgIconTypeMap<{}, "svg">> & {
+  muiName: string;
+};
+export declare const TreeViewCollapseIcon: import("@mui/material/OverridableComponent").OverridableComponent<import("@mui/material").SvgIconTypeMap<{}, "svg">> & {
+  muiName: string;
+};

package/modern/icons/index.d.ts

@@ -0,0 +1 @@
+export * from "./icons.js";

package/modern/index.d.ts

@@ -0,0 +1,12 @@
+export * from "./SimpleTreeView/index.js";
+export * from "./RichTreeView/index.js";
+export * from "./TreeItem/index.js";
+export * from "./useTreeItem/index.js";
+export * from "./TreeItemIcon/index.js";
+export * from "./TreeItemProvider/index.js";
+export * from "./TreeItemDragAndDropOverlay/index.js";
+export * from "./TreeItemLabelInput/index.js";
+export { unstable_resetCleanupTracking } from "./internals/hooks/useInstanceEventHandler.js";
+export * from "./models/index.js";
+export * from "./icons/index.js";
+export * from "./hooks/index.js";

package/modern/index.js

@@ -1,5 +1,5 @@
 /**
- * @mui/x-tree-view v8.0.0-alpha.11
+ * @mui/x-tree-view v8.0.0-alpha.13
  *
  * @license MIT
  * This source code is licensed under the MIT license found in the

package/modern/internals/TreeViewItemDepthContext/TreeViewItemDepthContext.d.ts

@@ -0,0 +1,5 @@
+import * as React from 'react';
+import { TreeViewItemId } from "../../models/index.js";
+import { TreeViewState } from "../models/index.js";
+import type { UseTreeViewItemsSignature } from '../plugins/useTreeViewItems';
+export declare const TreeViewItemDepthContext: React.Context<number | ((state: TreeViewState<[UseTreeViewItemsSignature]>, itemId: TreeViewItemId) => number)>;

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

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

package/modern/internals/TreeViewProvider/TreeViewChildrenItemProvider.d.ts

@@ -0,0 +1,17 @@
+import * as React from 'react';
+export declare const TreeViewChildrenItemContext: React.Context<TreeViewChildrenItemContextValue | null>;
+interface TreeViewChildrenItemProviderProps {
+  itemId: string | null;
+  idAttribute: string | null;
+  children: React.ReactNode;
+}
+export declare function TreeViewChildrenItemProvider(props: TreeViewChildrenItemProviderProps): React.JSX.Element;
+export declare namespace TreeViewChildrenItemProvider {
+  var propTypes: any;
+}
+interface TreeViewChildrenItemContextValue {
+  registerChild: (idAttribute: string, itemId: string) => void;
+  unregisterChild: (idAttribute: string) => void;
+  parentId: string | null;
+}
+export {};

package/modern/internals/TreeViewProvider/TreeViewContext.d.ts

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

package/modern/internals/TreeViewProvider/TreeViewProvider.d.ts

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

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

@@ -0,0 +1,19 @@
+import * as React from 'react';
+import { MergeSignaturesProperty, TreeItemWrapper, TreeRootWrapper, TreeViewAnyPluginSignature, TreeViewInstance, TreeViewItemPluginResponse, TreeViewPublicAPI } from "../models/index.js";
+import { TreeViewStore } from "../utils/TreeViewStore.js";
+import { TreeViewCorePluginSignatures } from "../corePlugins/index.js";
+import type { TreeItemProps } from '../../TreeItem/TreeItem.types';
+export type TreeViewItemPluginsRunner = (props: TreeItemProps) => Required<TreeViewItemPluginResponse>;
+export type TreeViewContextValue<TSignatures extends readonly TreeViewAnyPluginSignature[], TOptionalSignatures extends readonly TreeViewAnyPluginSignature[] = []> = MergeSignaturesProperty<[...TreeViewCorePluginSignatures, ...TSignatures], 'contextValue'> & Partial<MergeSignaturesProperty<TOptionalSignatures, 'contextValue'>> & {
+  instance: TreeViewInstance<TSignatures, TOptionalSignatures>;
+  publicAPI: TreeViewPublicAPI<TSignatures, TOptionalSignatures>;
+  store: TreeViewStore<TSignatures>;
+  rootRef: React.RefObject<HTMLUListElement | null>;
+  wrapItem: TreeItemWrapper<TSignatures>;
+  wrapRoot: TreeRootWrapper;
+  runItemPlugins: TreeViewItemPluginsRunner;
+};
+export interface TreeViewProviderProps<TSignatures extends readonly TreeViewAnyPluginSignature[]> {
+  value: TreeViewContextValue<TSignatures>;
+  children: React.ReactNode;
+}

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

@@ -0,0 +1,3 @@
+export { TreeViewProvider } from "./TreeViewProvider.js";
+export { useTreeViewContext } from "./useTreeViewContext.js";
+export type { TreeViewProviderProps, TreeViewContextValue, TreeViewItemPluginsRunner } from './TreeViewProvider.types';

package/modern/internals/TreeViewProvider/useTreeViewContext.d.ts

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

package/modern/internals/components/RichTreeViewItems.d.ts

@@ -0,0 +1,32 @@
+import * as React from 'react';
+import { SlotComponentProps } from '@mui/utils/types';
+import { TreeItem, TreeItemProps } from "../../TreeItem/index.js";
+import { TreeViewItemId } from "../../models/index.js";
+export declare function RichTreeViewItems(props: RichTreeViewItemsProps): React.JSX.Element;
+interface RichTreeViewItemsOwnerState {
+  itemId: TreeViewItemId;
+  label: string;
+}
+export interface RichTreeViewItemsSlots {
+  /**
+   * Custom component to render a Tree Item.
+   * @default TreeItem.
+   */
+  item?: React.JSXElementConstructor<TreeItemProps>;
+}
+export interface RichTreeViewItemsSlotProps {
+  item?: SlotComponentProps<typeof TreeItem, {}, RichTreeViewItemsOwnerState>;
+}
+export interface RichTreeViewItemsProps {
+  /**
+   * Overridable component slots.
+   * @default {}
+   */
+  slots?: RichTreeViewItemsSlots;
+  /**
+   * The props used for each component slot.
+   * @default {}
+   */
+  slotProps?: RichTreeViewItemsSlotProps;
+}
+export {};

package/modern/internals/corePlugins/corePlugins.d.ts

@@ -0,0 +1,9 @@
+import { UseTreeViewIdParameters } from "./useTreeViewId/index.js";
+import { ConvertPluginsIntoSignatures } from "../models/index.js";
+/**
+ * Internal plugins that create 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("..").TreeViewPlugin<import("./useTreeViewInstanceEvents").UseTreeViewInstanceEventsSignature>, import("..").TreeViewPlugin<import("./useTreeViewOptionalPlugins").UseTreeViewOptionalPluginsSignature>, import("..").TreeViewPlugin<import("./useTreeViewId").UseTreeViewIdSignature>];
+export type TreeViewCorePluginSignatures = ConvertPluginsIntoSignatures<typeof TREE_VIEW_CORE_PLUGINS>;
+export interface TreeViewCorePluginParameters extends UseTreeViewIdParameters {}

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

@@ -0,0 +1,2 @@
+export { TREE_VIEW_CORE_PLUGINS } from "./corePlugins.js";
+export type { TreeViewCorePluginSignatures, TreeViewCorePluginParameters } from './corePlugins';

package/modern/internals/corePlugins/useTreeViewId/index.d.ts

@@ -0,0 +1,2 @@
+export { useTreeViewId } from "./useTreeViewId.js";
+export type { UseTreeViewIdSignature, UseTreeViewIdParameters, UseTreeViewIdDefaultizedParameters } from './useTreeViewId.types';

package/modern/internals/corePlugins/useTreeViewId/useTreeViewId.d.ts

@@ -0,0 +1,3 @@
+import { TreeViewPlugin } from "../../models/index.js";
+import { UseTreeViewIdSignature } from "./useTreeViewId.types.js";
+export declare const useTreeViewId: TreeViewPlugin<UseTreeViewIdSignature>;

package/modern/internals/corePlugins/useTreeViewId/useTreeViewId.selectors.d.ts

@@ -0,0 +1,36 @@
+import { TreeViewRootSelector } from "../../utils/selectors.js";
+import { UseTreeViewIdSignature } from "./useTreeViewId.types.js";
+/**
+ * Get the id attribute of the tree view.
+ * @param {TreeViewState<[UseTreeViewIdSignature]>} state The state of the tree view.
+ * @returns {string} The id attribute of the tree view.
+ */
+export declare const selectorTreeViewId: ((state: import("./useTreeViewId.types").UseTreeViewIdState & Partial<{}> & {
+  cacheKey: import("../../models").TreeViewStateCacheKey;
+}) => string | undefined) & {
+  clearCache: () => void;
+  resultsCount: () => number;
+  resetResultsCount: () => void;
+} & {
+  resultFunc: (resultFuncArgs_0: {
+    treeId: string | undefined;
+    providedTreeId: string | undefined;
+  }) => string | undefined;
+  memoizedResultFunc: ((resultFuncArgs_0: {
+    treeId: string | undefined;
+    providedTreeId: string | undefined;
+  }) => string | undefined) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  };
+  lastResult: () => string | undefined;
+  dependencies: [TreeViewRootSelector<UseTreeViewIdSignature>];
+  recomputations: () => number;
+  resetRecomputations: () => void;
+  dependencyRecomputations: () => number;
+  resetDependencyRecomputations: () => void;
+} & {
+  argsMemoize: typeof import("reselect").weakMapMemoize;
+  memoize: typeof import("reselect").weakMapMemoize;
+};

package/modern/internals/corePlugins/useTreeViewId/useTreeViewId.types.d.ts

@@ -0,0 +1,20 @@
+import { TreeViewPluginSignature } from "../../models/index.js";
+export interface UseTreeViewIdParameters {
+  /**
+   * 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;
+}
+export type UseTreeViewIdDefaultizedParameters = UseTreeViewIdParameters;
+export interface UseTreeViewIdState {
+  id: {
+    treeId: string | undefined;
+    providedTreeId: string | undefined;
+  };
+}
+export type UseTreeViewIdSignature = TreeViewPluginSignature<{
+  params: UseTreeViewIdParameters;
+  defaultizedParams: UseTreeViewIdDefaultizedParameters;
+  state: UseTreeViewIdState;
+}>;

package/modern/internals/corePlugins/useTreeViewId/useTreeViewId.utils.d.ts

@@ -0,0 +1,21 @@
+import { TreeViewItemId } from "../../../models/index.js";
+export declare const createTreeViewDefaultId: () => string;
+/**
+ * Generate the id attribute (i.e.: the `id` attribute passed to the DOM element) of a Tree Item.
+ * If the user explicitly defined an id attribute, it will be returned.
+ * Otherwise, the method creates a unique id for the item based on the Tree View id attribute and the item `itemId`
+ * @param {object} params The parameters to determine the id attribute of the item.
+ * @param {TreeViewItemId} params.itemId The id of the item to get the id attribute of.
+ * @param {string | undefined} params.idAttribute The id attribute of the item if explicitly defined by the user.
+ * @param {string} params.treeId The id attribute of the Tree View.
+ * @returns {string} The id attribute of the item.
+ */
+export declare const generateTreeItemIdAttribute: ({
+  id,
+  treeId,
+  itemId
+}: {
+  id: TreeViewItemId | undefined;
+  treeId: string | undefined;
+  itemId: string;
+}) => string;

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

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

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

@@ -0,0 +1,3 @@
+import type { TreeViewPlugin } from '../../models';
+import { UseTreeViewInstanceEventsSignature } from "./useTreeViewInstanceEvents.types.js";
+export declare const useTreeViewInstanceEvents: TreeViewPlugin<UseTreeViewInstanceEventsSignature>;

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

@@ -0,0 +1,22 @@
+import { TreeViewPluginSignature } from "../../models/index.js";
+import { TreeViewEventListener } from "../../models/events.js";
+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<{
+  instance: UseTreeViewInstanceEventsInstance;
+}>;

package/modern/internals/corePlugins/useTreeViewOptionalPlugins/index.d.ts

@@ -0,0 +1,2 @@
+export { useTreeViewOptionalPlugins } from "./useTreeViewOptionalPlugins.js";
+export type { UseTreeViewOptionalPluginsSignature } from './useTreeViewOptionalPlugins.types';

package/modern/internals/corePlugins/useTreeViewOptionalPlugins/useTreeViewOptionalPlugins.d.ts

@@ -0,0 +1,3 @@
+import { TreeViewPlugin } from "../../models/index.js";
+import { UseTreeViewOptionalPluginsSignature } from "./useTreeViewOptionalPlugins.types.js";
+export declare const useTreeViewOptionalPlugins: TreeViewPlugin<UseTreeViewOptionalPluginsSignature>;

package/modern/internals/corePlugins/useTreeViewOptionalPlugins/useTreeViewOptionalPlugins.types.d.ts

@@ -0,0 +1,8 @@
+import { TreeViewPlugin, TreeViewAnyPluginSignature, TreeViewPluginSignature } from "../../models/index.js";
+interface UseTreeViewOptionalPluginsInstance {
+  getAvailablePlugins: () => Set<TreeViewPlugin<TreeViewAnyPluginSignature>>;
+}
+export type UseTreeViewOptionalPluginsSignature = TreeViewPluginSignature<{
+  instance: UseTreeViewOptionalPluginsInstance;
+}>;
+export {};