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

package/modern/internals/plugins/useTreeViewFocus/useTreeViewFocus.selectors.d.ts

@@ -0,0 +1,182 @@
+import { UseTreeViewFocusSignature } from "./useTreeViewFocus.types.js";
+import { TreeViewRootSelector } from "../../utils/selectors.js";
+/**
+ * Get the item that should be sequentially focusable (usually with the Tab key).
+ * At any point in time, there is a single item that can be sequentially focused in the Tree View.
+ * This item is the first selected item (that is both visible and navigable), if any, or the first navigable item if no item is selected.
+ * @param {TreeViewState<[UseTreeViewFocusSignature]>} state The state of the tree view.
+ * @returns {TreeViewItemId | null} The id of the item that should be sequentially focusable.
+ */
+export declare const selectorDefaultFocusableItemId: ((state: import("../../corePlugins/useTreeViewId/useTreeViewId.types").UseTreeViewIdState & import("./useTreeViewFocus.types").UseTreeViewFocusState & Partial<{}> & {
+  cacheKey: import("../../models").TreeViewStateCacheKey;
+}) => string | null) & {
+  clearCache: () => void;
+  resultsCount: () => number;
+  resetResultsCount: () => void;
+} & {
+  resultFunc: (resultFuncArgs_0: {
+    focusedItemId: string | null;
+    defaultFocusableItemId: string | null;
+  }) => string | null;
+  memoizedResultFunc: ((resultFuncArgs_0: {
+    focusedItemId: string | null;
+    defaultFocusableItemId: string | null;
+  }) => string | null) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  };
+  lastResult: () => string | null;
+  dependencies: [TreeViewRootSelector<UseTreeViewFocusSignature>];
+  recomputations: () => number;
+  resetRecomputations: () => void;
+  dependencyRecomputations: () => number;
+  resetDependencyRecomputations: () => void;
+} & {
+  argsMemoize: typeof import("reselect").weakMapMemoize;
+  memoize: typeof import("reselect").weakMapMemoize;
+};
+/**
+ * Check if an item is the default focusable item.
+ * @param {TreeViewState<[UseTreeViewFocusSignature]>} state The state of the tree view.
+ * @param {TreeViewItemId} itemId The id of the item to check.
+ * @returns {boolean} `true` if the item is the default focusable item, `false` otherwise.
+ */
+export declare const selectorIsItemTheDefaultFocusableItem: ((state: any, itemId: string) => boolean) & {
+  clearCache: () => void;
+  resultsCount: () => number;
+  resetResultsCount: () => void;
+} & {
+  resultFunc: (resultFuncArgs_0: string | null, resultFuncArgs_1: string) => boolean;
+  memoizedResultFunc: ((resultFuncArgs_0: string | null, resultFuncArgs_1: string) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  };
+  lastResult: () => boolean;
+  dependencies: [((state: import("../../corePlugins/useTreeViewId/useTreeViewId.types").UseTreeViewIdState & import("./useTreeViewFocus.types").UseTreeViewFocusState & Partial<{}> & {
+    cacheKey: import("../../models").TreeViewStateCacheKey;
+  }) => string | null) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  } & {
+    resultFunc: (resultFuncArgs_0: {
+      focusedItemId: string | null;
+      defaultFocusableItemId: string | null;
+    }) => string | null;
+    memoizedResultFunc: ((resultFuncArgs_0: {
+      focusedItemId: string | null;
+      defaultFocusableItemId: string | null;
+    }) => string | null) & {
+      clearCache: () => void;
+      resultsCount: () => number;
+      resetResultsCount: () => void;
+    };
+    lastResult: () => string | null;
+    dependencies: [TreeViewRootSelector<UseTreeViewFocusSignature>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+  } & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+  }, (_: any, itemId: string) => string];
+  recomputations: () => number;
+  resetRecomputations: () => void;
+  dependencyRecomputations: () => number;
+  resetDependencyRecomputations: () => void;
+} & {
+  argsMemoize: typeof import("reselect").weakMapMemoize;
+  memoize: typeof import("reselect").weakMapMemoize;
+};
+/**
+ * Get the id of the item that is currently focused.
+ * @param {TreeViewState<[UseTreeViewFocusSignature]>} state The state of the tree view.
+ * @returns {TreeViewItemId | null} The id of the item that is currently focused.
+ */
+export declare const selectorFocusedItemId: ((state: import("../../corePlugins/useTreeViewId/useTreeViewId.types").UseTreeViewIdState & import("./useTreeViewFocus.types").UseTreeViewFocusState & Partial<{}> & {
+  cacheKey: import("../../models").TreeViewStateCacheKey;
+}) => string | null) & {
+  clearCache: () => void;
+  resultsCount: () => number;
+  resetResultsCount: () => void;
+} & {
+  resultFunc: (resultFuncArgs_0: {
+    focusedItemId: string | null;
+    defaultFocusableItemId: string | null;
+  }) => string | null;
+  memoizedResultFunc: ((resultFuncArgs_0: {
+    focusedItemId: string | null;
+    defaultFocusableItemId: string | null;
+  }) => string | null) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  };
+  lastResult: () => string | null;
+  dependencies: [TreeViewRootSelector<UseTreeViewFocusSignature>];
+  recomputations: () => number;
+  resetRecomputations: () => void;
+  dependencyRecomputations: () => number;
+  resetDependencyRecomputations: () => void;
+} & {
+  argsMemoize: typeof import("reselect").weakMapMemoize;
+  memoize: typeof import("reselect").weakMapMemoize;
+};
+/**
+ * Check if an item is focused.
+ * @param {TreeViewState<[UseTreeViewFocusSignature]>} state The state of the tree view.
+ * @param {TreeViewItemId} itemId The id of the item to check.
+ * @returns {boolean} `true` if the item is focused, `false` otherwise.
+ */
+export declare const selectorIsItemFocused: ((state: any, itemId: string) => boolean) & {
+  clearCache: () => void;
+  resultsCount: () => number;
+  resetResultsCount: () => void;
+} & {
+  resultFunc: (resultFuncArgs_0: string | null, resultFuncArgs_1: string) => boolean;
+  memoizedResultFunc: ((resultFuncArgs_0: string | null, resultFuncArgs_1: string) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  };
+  lastResult: () => boolean;
+  dependencies: [((state: import("../../corePlugins/useTreeViewId/useTreeViewId.types").UseTreeViewIdState & import("./useTreeViewFocus.types").UseTreeViewFocusState & Partial<{}> & {
+    cacheKey: import("../../models").TreeViewStateCacheKey;
+  }) => string | null) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  } & {
+    resultFunc: (resultFuncArgs_0: {
+      focusedItemId: string | null;
+      defaultFocusableItemId: string | null;
+    }) => string | null;
+    memoizedResultFunc: ((resultFuncArgs_0: {
+      focusedItemId: string | null;
+      defaultFocusableItemId: string | null;
+    }) => string | null) & {
+      clearCache: () => void;
+      resultsCount: () => number;
+      resetResultsCount: () => void;
+    };
+    lastResult: () => string | null;
+    dependencies: [TreeViewRootSelector<UseTreeViewFocusSignature>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+  } & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+  }, (_: any, itemId: string) => string];
+  recomputations: () => number;
+  resetRecomputations: () => void;
+  dependencyRecomputations: () => number;
+  resetDependencyRecomputations: () => void;
+} & {
+  argsMemoize: typeof import("reselect").weakMapMemoize;
+  memoize: typeof import("reselect").weakMapMemoize;
+};

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

@@ -0,0 +1,45 @@
+import * as React from 'react';
+import { TreeViewPluginSignature } from "../../models/index.js";
+import type { UseTreeViewItemsSignature } from '../useTreeViewItems';
+import type { UseTreeViewSelectionSignature } from '../useTreeViewSelection';
+import { UseTreeViewExpansionSignature } from "../useTreeViewExpansion/index.js";
+export interface UseTreeViewFocusPublicAPI {
+  /**
+   * Focus the item with the given id.
+   *
+   * If the item is the child of a collapsed item, then this method will do nothing.
+   * Make sure to expand the ancestors of the item before calling this method if needed.
+   * @param {React.SyntheticEvent} event The DOM event that triggered the change.
+   * @param {TreeViewItemId} itemId The id of the item to focus.
+   */
+  focusItem: (event: React.SyntheticEvent, itemId: string) => void;
+}
+export interface UseTreeViewFocusInstance extends UseTreeViewFocusPublicAPI {
+  /**
+   * Remove the focus from the currently focused item (both from the internal state and the DOM).
+   */
+  removeFocusedItem: () => void;
+}
+export interface UseTreeViewFocusParameters {
+  /**
+   * Callback fired when a given Tree Item is focused.
+   * @param {React.SyntheticEvent | null} event The DOM event that triggered the change. **Warning**: This is a generic event not a focus event.
+   * @param {string} itemId The id of the focused item.
+   */
+  onItemFocus?: (event: React.SyntheticEvent | null, itemId: string) => void;
+}
+export type UseTreeViewFocusDefaultizedParameters = UseTreeViewFocusParameters;
+export interface UseTreeViewFocusState {
+  focus: {
+    focusedItemId: string | null;
+    defaultFocusableItemId: string | null;
+  };
+}
+export type UseTreeViewFocusSignature = TreeViewPluginSignature<{
+  params: UseTreeViewFocusParameters;
+  defaultizedParams: UseTreeViewFocusDefaultizedParameters;
+  instance: UseTreeViewFocusInstance;
+  publicAPI: UseTreeViewFocusPublicAPI;
+  state: UseTreeViewFocusState;
+  dependencies: [UseTreeViewItemsSignature, UseTreeViewSelectionSignature, UseTreeViewExpansionSignature];
+}>;

package/modern/internals/plugins/useTreeViewIcons/index.d.ts

@@ -0,0 +1,2 @@
+export { useTreeViewIcons } from "./useTreeViewIcons.js";
+export type { UseTreeViewIconsSignature, UseTreeViewIconsParameters, UseTreeViewIconsDefaultizedParameters } from './useTreeViewIcons.types';

package/modern/internals/plugins/useTreeViewIcons/useTreeViewIcons.d.ts

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

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

@@ -0,0 +1,42 @@
+import * as React from 'react';
+import { SlotComponentProps } from '@mui/utils/types';
+import { TreeViewPluginSignature } from "../../models/index.js";
+import { UseTreeViewItemsSignature } from "../useTreeViewItems/index.js";
+import { UseTreeViewSelectionSignature } from "../useTreeViewSelection/index.js";
+export interface UseTreeViewIconsParameters {}
+export type UseTreeViewIconsDefaultizedParameters = UseTreeViewIconsParameters;
+interface UseTreeViewIconsSlots {
+  /**
+   * The default icon used to collapse the item.
+   */
+  collapseIcon?: React.ElementType;
+  /**
+   * The default icon used to expand the item.
+   */
+  expandIcon?: React.ElementType;
+  /**
+   * The default icon displayed next to an end item.
+   * This is applied to all Tree Items and can be overridden by the TreeItem `icon` slot prop.
+   */
+  endIcon?: React.ElementType;
+}
+interface UseTreeViewIconsSlotProps {
+  collapseIcon?: SlotComponentProps<'svg', {}, {}>;
+  expandIcon?: SlotComponentProps<'svg', {}, {}>;
+  endIcon?: SlotComponentProps<'svg', {}, {}>;
+}
+interface UseTreeViewIconsContextValue {
+  icons: {
+    slots: UseTreeViewIconsSlots;
+    slotProps: UseTreeViewIconsSlotProps;
+  };
+}
+export type UseTreeViewIconsSignature = TreeViewPluginSignature<{
+  params: UseTreeViewIconsParameters;
+  defaultizedParams: UseTreeViewIconsDefaultizedParameters;
+  contextValue: UseTreeViewIconsContextValue;
+  slots: UseTreeViewIconsSlots;
+  slotProps: UseTreeViewIconsSlotProps;
+  dependencies: [UseTreeViewItemsSignature, UseTreeViewSelectionSignature];
+}>;
+export {};

package/modern/internals/plugins/useTreeViewItems/index.d.ts

@@ -0,0 +1,3 @@
+export { useTreeViewItems } from "./useTreeViewItems.js";
+export type { UseTreeViewItemsSignature, UseTreeViewItemsParameters, UseTreeViewItemsDefaultizedParameters, UseTreeViewItemsState } from './useTreeViewItems.types';
+export { buildSiblingIndexes, TREE_VIEW_ROOT_PARENT_ID } from "./useTreeViewItems.utils.js";

package/modern/internals/plugins/useTreeViewItems/useTreeViewItems.d.ts

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