@mui/x-tree-view 8.0.0-alpha.8 → 8.0.0-beta.0

package/internals/plugins/useTreeViewFocus/useTreeViewFocus.js

@@ -1,56 +1,64 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
-import * as React from 'react';
-import useEventCallback from '@mui/utils/useEventCallback';
-import { useInstanceEventHandler } from "../../hooks/useInstanceEventHandler.js";
-import { getFirstNavigableItem } from "../../utils/tree.js";
-import { convertSelectedItemsToArray } from "../useTreeViewSelection/useTreeViewSelection.utils.js";
-import { selectorDefaultFocusableItemId, selectorFocusedItemId } from "./useTreeViewFocus.selectors.js";
-import { selectorIsItemExpanded } from "../useTreeViewExpansion/useTreeViewExpansion.selectors.js";
-import { selectorCanItemBeFocused, selectorItemMeta } from "../useTreeViewItems/useTreeViewItems.selectors.js";
-export const useTreeViewFocus = ({
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useTreeViewFocus = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var React = _interopRequireWildcard(require("react"));
+var _useEventCallback = _interopRequireDefault(require("@mui/utils/useEventCallback"));
+var _useInstanceEventHandler = require("../../hooks/useInstanceEventHandler");
+var _tree = require("../../utils/tree");
+var _useTreeViewSelection = require("../useTreeViewSelection/useTreeViewSelection.utils");
+var _useTreeViewFocus = require("./useTreeViewFocus.selectors");
+var _useTreeViewExpansion = require("../useTreeViewExpansion/useTreeViewExpansion.selectors");
+var _useTreeViewItems = require("../useTreeViewItems/useTreeViewItems.selectors");
+const useTreeViewFocus = ({
   instance,
   params,
   store,
   models
 }) => {
   React.useEffect(() => {
-    let defaultFocusableItemId = convertSelectedItemsToArray(models.selectedItems.value).find(itemId => {
-      if (!selectorCanItemBeFocused(store.value, itemId)) {
+    let defaultFocusableItemId = (0, _useTreeViewSelection.convertSelectedItemsToArray)(models.selectedItems.value).find(itemId => {
+      if (!(0, _useTreeViewItems.selectorCanItemBeFocused)(store.value, itemId)) {
         return false;
       }
-      const itemMeta = selectorItemMeta(store.value, itemId);
-      return itemMeta && (itemMeta.parentId == null || selectorIsItemExpanded(store.value, itemMeta.parentId));
+      const itemMeta = (0, _useTreeViewItems.selectorItemMeta)(store.value, itemId);
+      return itemMeta && (itemMeta.parentId == null || (0, _useTreeViewExpansion.selectorIsItemExpanded)(store.value, itemMeta.parentId));
     });
     if (defaultFocusableItemId == null) {
-      defaultFocusableItemId = getFirstNavigableItem(store.value) ?? null;
+      defaultFocusableItemId = (0, _tree.getFirstNavigableItem)(store.value) ?? null;
     }
     store.update(prevState => {
       if (defaultFocusableItemId === prevState.focus.defaultFocusableItemId) {
         return prevState;
       }
-      return _extends({}, prevState, {
-        focus: _extends({}, prevState.focus, {
+      return (0, _extends2.default)({}, prevState, {
+        focus: (0, _extends2.default)({}, prevState.focus, {
           defaultFocusableItemId
         })
       });
     });
   }, [store, models.selectedItems.value]);
-  const setFocusedItemId = useEventCallback(itemId => {
+  const setFocusedItemId = (0, _useEventCallback.default)(itemId => {
     store.update(prevState => {
-      const focusedItemId = selectorFocusedItemId(prevState);
+      const focusedItemId = (0, _useTreeViewFocus.selectorFocusedItemId)(prevState);
       if (focusedItemId === itemId) {
         return prevState;
       }
-      return _extends({}, prevState, {
-        focus: _extends({}, prevState.focus, {
+      return (0, _extends2.default)({}, prevState, {
+        focus: (0, _extends2.default)({}, prevState.focus, {
           focusedItemId: itemId
         })
       });
     });
   });
   const isItemVisible = itemId => {
-    const itemMeta = selectorItemMeta(store.value, itemId);
-    return itemMeta && (itemMeta.parentId == null || selectorIsItemExpanded(store.value, itemMeta.parentId));
+    const itemMeta = (0, _useTreeViewItems.selectorItemMeta)(store.value, itemId);
+    return itemMeta && (itemMeta.parentId == null || (0, _useTreeViewExpansion.selectorIsItemExpanded)(store.value, itemMeta.parentId));
   };
   const innerFocusItem = (event, itemId) => {
     const itemElement = instance.getItemDOMElement(itemId);
@@ -62,18 +70,18 @@ export const useTreeViewFocus = ({
       params.onItemFocus(event, itemId);
     }
   };
-  const focusItem = useEventCallback((event, itemId) => {
+  const focusItem = (0, _useEventCallback.default)((event, itemId) => {
     // If we receive an itemId, and it is visible, the focus will be set to it
     if (isItemVisible(itemId)) {
       innerFocusItem(event, itemId);
     }
   });
-  const removeFocusedItem = useEventCallback(() => {
-    const focusedItemId = selectorFocusedItemId(store.value);
+  const removeFocusedItem = (0, _useEventCallback.default)(() => {
+    const focusedItemId = (0, _useTreeViewFocus.selectorFocusedItemId)(store.value);
     if (focusedItemId == null) {
       return;
     }
-    const itemMeta = selectorItemMeta(store.value, focusedItemId);
+    const itemMeta = (0, _useTreeViewItems.selectorItemMeta)(store.value, focusedItemId);
     if (itemMeta) {
       const itemElement = instance.getItemDOMElement(focusedItemId);
       if (itemElement) {
@@ -82,11 +90,11 @@ export const useTreeViewFocus = ({
     }
     setFocusedItemId(null);
   });
-  useInstanceEventHandler(instance, 'removeItem', ({
+  (0, _useInstanceEventHandler.useInstanceEventHandler)(instance, 'removeItem', ({
     id
   }) => {
-    const focusedItemId = selectorFocusedItemId(store.value);
-    const defaultFocusableItemId = selectorDefaultFocusableItemId(store.value);
+    const focusedItemId = (0, _useTreeViewFocus.selectorFocusedItemId)(store.value);
+    const defaultFocusableItemId = (0, _useTreeViewFocus.selectorDefaultFocusableItemId)(store.value);
     if (focusedItemId === id && defaultFocusableItemId != null) {
       innerFocusItem(null, defaultFocusableItemId);
     }
@@ -98,7 +106,7 @@ export const useTreeViewFocus = ({
     }
 
     // if the event bubbled (which is React specific) we don't want to steal focus
-    const defaultFocusableItemId = selectorDefaultFocusableItemId(store.value);
+    const defaultFocusableItemId = (0, _useTreeViewFocus.selectorDefaultFocusableItemId)(store.value);
     if (event.target === event.currentTarget && defaultFocusableItemId != null) {
       innerFocusItem(event, defaultFocusableItemId);
     }
@@ -124,6 +132,7 @@ export const useTreeViewFocus = ({
     }
   };
 };
+exports.useTreeViewFocus = useTreeViewFocus;
 useTreeViewFocus.getInitialState = () => ({
   focus: {
     focusedItemId: null,

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

@@ -1,5 +1,5 @@
-import { UseTreeViewFocusSignature } from './useTreeViewFocus.types';
-import { TreeViewRootSelector } from '../../utils/selectors';
+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.
@@ -8,33 +8,33 @@ import { TreeViewRootSelector } from '../../utils/selectors';
  * @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;
+  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;
 } & {
-    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;
+  argsMemoize: typeof import("reselect").weakMapMemoize;
+  memoize: typeof import("reselect").weakMapMemoize;
 };
 /**
  * Check if an item is the default focusable item.
@@ -43,53 +43,53 @@ export declare const selectorDefaultFocusableItemId: ((state: import("../../core
  * @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;
-} & {
-    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;
+  };
+  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;
-    } & {
-        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];
+      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.
@@ -97,33 +97,33 @@ export declare const selectorIsItemTheDefaultFocusableItem: ((state: any, itemId
  * @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;
+  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;
 } & {
-    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;
+  argsMemoize: typeof import("reselect").weakMapMemoize;
+  memoize: typeof import("reselect").weakMapMemoize;
 };
 /**
  * Check if an item is focused.
@@ -132,51 +132,51 @@ export declare const selectorFocusedItemId: ((state: import("../../corePlugins/u
  * @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;
-} & {
-    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;
+  };
+  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;
-    } & {
-        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];
+      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/internals/plugins/useTreeViewFocus/useTreeViewFocus.selectors.js

@@ -1,4 +1,10 @@
-import { createSelector } from "../../utils/selectors.js";
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.selectorIsItemTheDefaultFocusableItem = exports.selectorIsItemFocused = exports.selectorFocusedItemId = exports.selectorDefaultFocusableItemId = void 0;
+var _selectors = require("../../utils/selectors");
 const selectorTreeViewFocusState = state => state.focus;
 
 /**
@@ -8,7 +14,7 @@ const selectorTreeViewFocusState = state => state.focus;
  * @param {TreeViewState<[UseTreeViewFocusSignature]>} state The state of the tree view.
  * @returns {TreeViewItemId | null} The id of the item that should be sequentially focusable.
  */
-export const selectorDefaultFocusableItemId = createSelector(selectorTreeViewFocusState, focus => focus.defaultFocusableItemId);
+const selectorDefaultFocusableItemId = exports.selectorDefaultFocusableItemId = (0, _selectors.createSelector)(selectorTreeViewFocusState, focus => focus.defaultFocusableItemId);
 
 /**
  * Check if an item is the default focusable item.
@@ -16,14 +22,14 @@ export const selectorDefaultFocusableItemId = createSelector(selectorTreeViewFoc
  * @param {TreeViewItemId} itemId The id of the item to check.
  * @returns {boolean} `true` if the item is the default focusable item, `false` otherwise.
  */
-export const selectorIsItemTheDefaultFocusableItem = createSelector([selectorDefaultFocusableItemId, (_, itemId) => itemId], (defaultFocusableItemId, itemId) => defaultFocusableItemId === itemId);
+const selectorIsItemTheDefaultFocusableItem = exports.selectorIsItemTheDefaultFocusableItem = (0, _selectors.createSelector)([selectorDefaultFocusableItemId, (_, itemId) => itemId], (defaultFocusableItemId, itemId) => defaultFocusableItemId === itemId);
 
 /**
  * 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 const selectorFocusedItemId = createSelector(selectorTreeViewFocusState, focus => focus.focusedItemId);
+const selectorFocusedItemId = exports.selectorFocusedItemId = (0, _selectors.createSelector)(selectorTreeViewFocusState, focus => focus.focusedItemId);
 
 /**
  * Check if an item is focused.
@@ -31,4 +37,4 @@ export const selectorFocusedItemId = createSelector(selectorTreeViewFocusState,
  * @param {TreeViewItemId} itemId The id of the item to check.
  * @returns {boolean} `true` if the item is focused, `false` otherwise.
  */
-export const selectorIsItemFocused = createSelector([selectorFocusedItemId, (_, itemId) => itemId], (focusedItemId, itemId) => focusedItemId === itemId);
+const selectorIsItemFocused = exports.selectorIsItemFocused = (0, _selectors.createSelector)([selectorFocusedItemId, (_, itemId) => itemId], (focusedItemId, itemId) => focusedItemId === itemId);

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

@@ -1,49 +1,45 @@
 import * as React from 'react';
-import { TreeViewPluginSignature } from '../../models';
+import { TreeViewPluginSignature } from "../../models/index.js";
 import type { UseTreeViewItemsSignature } from '../useTreeViewItems';
 import type { UseTreeViewSelectionSignature } from '../useTreeViewSelection';
-import { UseTreeViewExpansionSignature } from '../useTreeViewExpansion';
+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;
+  /**
+   * 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;
+  /**
+   * 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;
+  /**
+   * 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;
-    };
+  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
-    ];
-}>;
+  params: UseTreeViewFocusParameters;
+  defaultizedParams: UseTreeViewFocusDefaultizedParameters;
+  instance: UseTreeViewFocusInstance;
+  publicAPI: UseTreeViewFocusPublicAPI;
+  state: UseTreeViewFocusState;
+  dependencies: [UseTreeViewItemsSignature, UseTreeViewSelectionSignature, UseTreeViewExpansionSignature];
+}>;

package/internals/plugins/useTreeViewFocus/useTreeViewFocus.types.js

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

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

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

package/internals/plugins/useTreeViewIcons/index.js

@@ -1 +1,12 @@
-export { useTreeViewIcons } from "./useTreeViewIcons.js";
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "useTreeViewIcons", {
+  enumerable: true,
+  get: function () {
+    return _useTreeViewIcons.useTreeViewIcons;
+  }
+});
+var _useTreeViewIcons = require("./useTreeViewIcons");

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

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

package/internals/plugins/useTreeViewIcons/useTreeViewIcons.js

@@ -1,5 +1,12 @@
-import * as React from 'react';
-export const useTreeViewIcons = ({
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useTreeViewIcons = void 0;
+var React = _interopRequireWildcard(require("react"));
+const useTreeViewIcons = ({
   slots,
   slotProps
 }) => {
@@ -21,4 +28,5 @@ export const useTreeViewIcons = ({
     contextValue: pluginContextValue
   };
 };
+exports.useTreeViewIcons = useTreeViewIcons;
 useTreeViewIcons.params = {};