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

package/internals/useTreeView/useTreeView.js

@@ -1,12 +1,21 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
-import * as React from 'react';
-import useForkRef from '@mui/utils/useForkRef';
-import { useTreeViewModels } from "./useTreeViewModels.js";
-import { TREE_VIEW_CORE_PLUGINS } from "../corePlugins/index.js";
-import { extractPluginParamsFromProps } from "./extractPluginParamsFromProps.js";
-import { useTreeViewBuildContext } from "./useTreeViewBuildContext.js";
-import { TreeViewStore } from "../utils/TreeViewStore.js";
-export function useTreeViewApiInitialization(inputApiRef) {
+"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.useTreeView = void 0;
+exports.useTreeViewApiInitialization = useTreeViewApiInitialization;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var React = _interopRequireWildcard(require("react"));
+var _useForkRef = _interopRequireDefault(require("@mui/utils/useForkRef"));
+var _useTreeViewModels = require("./useTreeViewModels");
+var _corePlugins = require("../corePlugins");
+var _extractPluginParamsFromProps = require("./extractPluginParamsFromProps");
+var _useTreeViewBuildContext = require("./useTreeViewBuildContext");
+var _TreeViewStore = require("../utils/TreeViewStore");
+function useTreeViewApiInitialization(inputApiRef) {
   const fallbackPublicApiRef = React.useRef({});
   if (inputApiRef) {
     if (inputApiRef.current == null) {
@@ -17,12 +26,12 @@ export function useTreeViewApiInitialization(inputApiRef) {
   return fallbackPublicApiRef.current;
 }
 let globalId = 0;
-export const useTreeView = ({
+const useTreeView = ({
   plugins: inPlugins,
   rootRef,
   props
 }) => {
-  const plugins = React.useMemo(() => [...TREE_VIEW_CORE_PLUGINS, ...inPlugins], [inPlugins]);
+  const plugins = React.useMemo(() => [..._corePlugins.TREE_VIEW_CORE_PLUGINS, ...inPlugins], [inPlugins]);
   const {
     pluginParams,
     forwardedProps,
@@ -30,16 +39,16 @@ export const useTreeView = ({
     experimentalFeatures,
     slots,
     slotProps
-  } = extractPluginParamsFromProps({
+  } = (0, _extractPluginParamsFromProps.extractPluginParamsFromProps)({
     plugins,
     props
   });
-  const models = useTreeViewModels(plugins, pluginParams);
+  const models = (0, _useTreeViewModels.useTreeViewModels)(plugins, pluginParams);
   const instanceRef = React.useRef({});
   const instance = instanceRef.current;
   const publicAPI = useTreeViewApiInitialization(apiRef);
   const innerRootRef = React.useRef(null);
-  const handleRootRef = useForkRef(innerRootRef, rootRef);
+  const handleRootRef = (0, _useForkRef.default)(innerRootRef, rootRef);
   const storeRef = React.useRef(null);
   if (storeRef.current == null) {
     globalId += 1;
@@ -53,9 +62,9 @@ export const useTreeView = ({
         Object.assign(initialState, plugin.getInitialState(pluginParams));
       }
     });
-    storeRef.current = new TreeViewStore(initialState);
+    storeRef.current = new _TreeViewStore.TreeViewStore(initialState);
   }
-  const baseContextValue = useTreeViewBuildContext({
+  const baseContextValue = (0, _useTreeViewBuildContext.useTreeViewBuildContext)({
     plugins,
     instance,
     publicAPI,
@@ -91,7 +100,7 @@ export const useTreeView = ({
   };
   plugins.forEach(runPlugin);
   const getRootProps = (otherHandlers = {}) => {
-    const rootProps = _extends({
+    const rootProps = (0, _extends2.default)({
       role: 'tree'
     }, forwardedProps, otherHandlers, {
       ref: handleRootRef
@@ -102,7 +111,7 @@ export const useTreeView = ({
     return rootProps;
   };
   const contextValue = React.useMemo(() => {
-    const copiedBaseContextValue = _extends({}, baseContextValue);
+    const copiedBaseContextValue = (0, _extends2.default)({}, baseContextValue);
     return Object.assign(copiedBaseContextValue, ...pluginContextValues);
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [baseContextValue, ...pluginContextValues]);
@@ -111,4 +120,5 @@ export const useTreeView = ({
     rootRef: handleRootRef,
     contextValue
   };
-};
+};
+exports.useTreeView = useTreeView;

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

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

package/internals/useTreeView/useTreeView.types.js

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

package/internals/useTreeView/useTreeViewBuildContext.d.ts

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

package/internals/useTreeView/useTreeViewBuildContext.js

@@ -1,5 +1,12 @@
-import * as React from 'react';
-export const useTreeViewBuildContext = ({
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useTreeViewBuildContext = void 0;
+var React = _interopRequireWildcard(require("react"));
+const useTreeViewBuildContext = ({
   plugins,
   instance,
   publicAPI,
@@ -98,4 +105,5 @@ export const useTreeViewBuildContext = ({
       rootRef
     };
   }, [runItemPlugins, wrapItem, wrapRoot, instance, publicAPI, store, rootRef]);
-};
+};
+exports.useTreeViewBuildContext = useTreeViewBuildContext;

package/internals/useTreeView/useTreeViewModels.d.ts

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

package/internals/useTreeView/useTreeViewModels.js

@@ -1,10 +1,18 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
-import * as React from 'react';
+"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.useTreeViewModels = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var React = _interopRequireWildcard(require("react"));
 /**
  * Implements the same behavior as `useControlled` but for several models.
  * The controlled models are never stored in the state, and the state is only updated if the model is not controlled.
  */
-export const useTreeViewModels = (plugins, props) => {
+const useTreeViewModels = (plugins, props) => {
   const modelsRef = React.useRef({});
   const [modelsState, setModelsState] = React.useState(() => {
     const initialState = {};
@@ -27,7 +35,7 @@ export const useTreeViewModels = (plugins, props) => {
       value,
       setControlledValue: newValue => {
         if (!model.isControlled) {
-          setModelsState(prevState => _extends({}, prevState, {
+          setModelsState(prevState => (0, _extends2.default)({}, prevState, {
             [modelName]: newValue
           }));
         }
@@ -59,4 +67,5 @@ export const useTreeViewModels = (plugins, props) => {
   /* eslint-enable react-hooks/rules-of-hooks, react-hooks/exhaustive-deps */
 
   return models;
-};
+};
+exports.useTreeViewModels = useTreeViewModels;

package/internals/useTreeView/useTreeViewPlugins.js

@@ -0,0 +1 @@
+"use strict";

package/internals/utils/TreeViewStore.d.ts

@@ -2,11 +2,11 @@ import type { TreeViewAnyPluginSignature, TreeViewState } from '../models';
 type Listener<T> = (value: T) => void;
 export type StoreUpdater<TSignatures extends readonly TreeViewAnyPluginSignature[]> = (prevState: TreeViewState<TSignatures>) => TreeViewState<TSignatures>;
 export declare class TreeViewStore<TSignatures extends readonly TreeViewAnyPluginSignature[]> {
-    value: TreeViewState<TSignatures>;
-    private listeners;
-    constructor(value: TreeViewState<TSignatures>);
-    subscribe: (fn: Listener<TreeViewState<TSignatures>>) => () => void;
-    getSnapshot: () => TreeViewState<TSignatures>;
-    update: (updater: StoreUpdater<TSignatures>) => void;
+  value: TreeViewState<TSignatures>;
+  private listeners;
+  constructor(value: TreeViewState<TSignatures>);
+  subscribe: (fn: Listener<TreeViewState<TSignatures>>) => () => void;
+  getSnapshot: () => TreeViewState<TSignatures>;
+  update: (updater: StoreUpdater<TSignatures>) => void;
 }
-export {};
+export {};

package/internals/utils/TreeViewStore.js

@@ -1,4 +1,10 @@
-export class TreeViewStore {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TreeViewStore = void 0;
+class TreeViewStore {
   constructor(value) {
     this.value = void 0;
     this.listeners = void 0;
@@ -21,4 +27,5 @@ export class TreeViewStore {
     this.value = value;
     this.listeners = new Set();
   }
-}
+}
+exports.TreeViewStore = TreeViewStore;

package/internals/utils/cleanupTracking/CleanupTracking.d.ts

@@ -1,9 +1,9 @@
 export type UnregisterToken = {
-    cleanupToken: number;
+  cleanupToken: number;
 };
 export type UnsubscribeFn = () => void;
 export interface CleanupTracking {
-    register(object: any, unsubscribe: UnsubscribeFn, unregisterToken: UnregisterToken): void;
-    unregister(unregisterToken: UnregisterToken): void;
-    reset(): void;
-}
+  register(object: any, unsubscribe: UnsubscribeFn, unregisterToken: UnregisterToken): void;
+  unregister(unregisterToken: UnregisterToken): void;
+  reset(): void;
+}

package/internals/utils/cleanupTracking/CleanupTracking.js

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

package/internals/utils/cleanupTracking/FinalizationRegistryBasedCleanupTracking.d.ts

@@ -1,7 +1,7 @@
-import { CleanupTracking, UnsubscribeFn, UnregisterToken } from './CleanupTracking';
+import { CleanupTracking, UnsubscribeFn, UnregisterToken } from "./CleanupTracking.js";
 export declare class FinalizationRegistryBasedCleanupTracking implements CleanupTracking {
-    registry: FinalizationRegistry<UnsubscribeFn>;
-    register(object: any, unsubscribe: UnsubscribeFn, unregisterToken: UnregisterToken): void;
-    unregister(unregisterToken: UnregisterToken): void;
-    reset(): void;
-}
+  registry: FinalizationRegistry<UnsubscribeFn>;
+  register(object: any, unsubscribe: UnsubscribeFn, unregisterToken: UnregisterToken): void;
+  unregister(unregisterToken: UnregisterToken): void;
+  reset(): void;
+}

package/internals/utils/cleanupTracking/FinalizationRegistryBasedCleanupTracking.js

@@ -1,4 +1,10 @@
-export class FinalizationRegistryBasedCleanupTracking {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FinalizationRegistryBasedCleanupTracking = void 0;
+class FinalizationRegistryBasedCleanupTracking {
   constructor() {
     this.registry = new FinalizationRegistry(unsubscribe => {
       if (typeof unsubscribe === 'function') {
@@ -15,4 +21,5 @@ export class FinalizationRegistryBasedCleanupTracking {
 
   // eslint-disable-next-line class-methods-use-this
   reset() {}
-}
+}
+exports.FinalizationRegistryBasedCleanupTracking = FinalizationRegistryBasedCleanupTracking;

package/internals/utils/cleanupTracking/TimerBasedCleanupTracking.d.ts

@@ -1,9 +1,9 @@
-import { CleanupTracking, UnregisterToken, UnsubscribeFn } from './CleanupTracking';
+import { CleanupTracking, UnregisterToken, UnsubscribeFn } from "./CleanupTracking.js";
 export declare class TimerBasedCleanupTracking implements CleanupTracking {
-    timeouts?: Map<number, NodeJS.Timeout> | undefined;
-    cleanupTimeout: number;
-    constructor(timeout?: number);
-    register(object: any, unsubscribe: UnsubscribeFn, unregisterToken: UnregisterToken): void;
-    unregister(unregisterToken: UnregisterToken): void;
-    reset(): void;
-}
+  timeouts?: Map<number, NodeJS.Timeout> | undefined;
+  cleanupTimeout: number;
+  constructor(timeout?: number);
+  register(object: any, unsubscribe: UnsubscribeFn, unregisterToken: UnregisterToken): void;
+  unregister(unregisterToken: UnregisterToken): void;
+  reset(): void;
+}

package/internals/utils/cleanupTracking/TimerBasedCleanupTracking.js

@@ -1,6 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TimerBasedCleanupTracking = void 0;
 // If no effect ran after this amount of time, we assume that the render was not committed by React
 const CLEANUP_TIMER_LOOP_MILLIS = 1000;
-export class TimerBasedCleanupTracking {
+class TimerBasedCleanupTracking {
   constructor(timeout = CLEANUP_TIMER_LOOP_MILLIS) {
     this.timeouts = new Map();
     this.cleanupTimeout = CLEANUP_TIMER_LOOP_MILLIS;
@@ -35,4 +41,5 @@ export class TimerBasedCleanupTracking {
       this.timeouts = undefined;
     }
   }
-}
+}
+exports.TimerBasedCleanupTracking = TimerBasedCleanupTracking;

package/internals/utils/plugins.d.ts

@@ -1,2 +1,2 @@
-import { TreeViewAnyPluginSignature, TreeViewInstance, TreeViewPlugin } from '../models';
-export declare const hasPlugin: <TSignature extends TreeViewAnyPluginSignature, TInstance extends TreeViewInstance<[], [TSignature]>>(instance: TInstance, plugin: TreeViewPlugin<TSignature>) => instance is Omit<TInstance, keyof TSignature["instance"]> & TSignature["instance"];
+import { TreeViewAnyPluginSignature, TreeViewInstance, TreeViewPlugin } from "../models/index.js";
+export declare const hasPlugin: <TSignature extends TreeViewAnyPluginSignature, TInstance extends TreeViewInstance<[], [TSignature]>>(instance: TInstance, plugin: TreeViewPlugin<TSignature>) => instance is Omit<TInstance, keyof TSignature["instance"]> & TSignature["instance"];

package/internals/utils/plugins.js

@@ -1,4 +1,11 @@
-export const hasPlugin = (instance, plugin) => {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.hasPlugin = void 0;
+const hasPlugin = (instance, plugin) => {
   const plugins = instance.getAvailablePlugins();
   return plugins.has(plugin);
-};
+};
+exports.hasPlugin = hasPlugin;

package/internals/utils/publishTreeViewEvent.d.ts

@@ -1,5 +1,5 @@
-import { UseTreeViewInstanceEventsInstance } from '../corePlugins/useTreeViewInstanceEvents/useTreeViewInstanceEvents.types';
-import { TreeViewAnyPluginSignature, TreeViewUsedEvents } from '../models';
+import { UseTreeViewInstanceEventsInstance } from "../corePlugins/useTreeViewInstanceEvents/useTreeViewInstanceEvents.types.js";
+import { TreeViewAnyPluginSignature, TreeViewUsedEvents } from "../models/index.js";
 export declare const publishTreeViewEvent: <Instance extends UseTreeViewInstanceEventsInstance & {
-    $$signature: TreeViewAnyPluginSignature;
-}, E extends keyof TreeViewUsedEvents<Instance["$$signature"]>>(instance: Instance, eventName: E, params: TreeViewUsedEvents<Instance["$$signature"]>[E]["params"]) => void;
+  $$signature: TreeViewAnyPluginSignature;
+}, E extends keyof TreeViewUsedEvents<Instance["$$signature"]>>(instance: Instance, eventName: E, params: TreeViewUsedEvents<Instance["$$signature"]>[E]["params"]) => void;

package/internals/utils/publishTreeViewEvent.js

@@ -1,3 +1,10 @@
-export const publishTreeViewEvent = (instance, eventName, params) => {
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.publishTreeViewEvent = void 0;
+const publishTreeViewEvent = (instance, eventName, params) => {
   instance.$$publishEvent(eventName, params);
-};
+};
+exports.publishTreeViewEvent = publishTreeViewEvent;

package/internals/utils/selectors.d.ts

@@ -1,9 +1,9 @@
 import { CreateSelectorFunction } from 'reselect';
-import { TreeViewAnyPluginSignature, TreeViewState } from '../models';
+import { TreeViewAnyPluginSignature, TreeViewState } from "../models/index.js";
 export type TreeViewRootSelector<TSignature extends TreeViewAnyPluginSignature> = <TSignatures extends [TSignature]>(state: TreeViewState<TSignatures>) => TSignature['state'][keyof TSignature['state']];
 export type TreeViewSelector<TState, TArgs, TResult> = (state: TState, args: TArgs) => TResult;
 /**
  * Method wrapping reselect's createSelector to provide caching for tree view instances.
  *
  */
-export declare const createSelector: CreateSelectorFunction;
+export declare const createSelector: CreateSelectorFunction;

package/internals/utils/selectors.js

@@ -1,6 +1,12 @@
-import { lruMemoize, createSelectorCreator } from 'reselect';
-const reselectCreateSelector = createSelectorCreator({
-  memoize: lruMemoize,
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createSelector = void 0;
+var _reselect = require("reselect");
+const reselectCreateSelector = (0, _reselect.createSelectorCreator)({
+  memoize: _reselect.lruMemoize,
   memoizeOptions: {
     maxSize: 1,
     equalityCheck: Object.is
@@ -11,7 +17,7 @@ const cache = new WeakMap();
  * Method wrapping reselect's createSelector to provide caching for tree view instances.
  *
  */
-export const createSelector = (...createSelectorArgs) => {
+const createSelector = (...createSelectorArgs) => {
   const selector = (state, selectorArgs) => {
     const cacheKey = state.cacheKey;
 
@@ -34,4 +40,5 @@ export const createSelector = (...createSelectorArgs) => {
     return fn(state, selectorArgs);
   };
   return selector;
-};
+};
+exports.createSelector = createSelector;

package/internals/utils/tree.d.ts

@@ -1,4 +1,4 @@
-import { TreeViewState } from '../models';
+import { TreeViewState } from "../models/index.js";
 import type { UseTreeViewExpansionSignature } from '../plugins/useTreeViewExpansion';
 import type { UseTreeViewItemsSignature } from '../plugins/useTreeViewItems';
 export declare const getPreviousNavigableItem: (state: TreeViewState<[UseTreeViewItemsSignature, UseTreeViewExpansionSignature]>, itemId: string) => string | null;
@@ -29,4 +29,4 @@ export declare const getAllNavigableItems: (state: TreeViewState<[UseTreeViewIte
  * @param {HTMLElement | null} itemRoot The root of the item to check if the event target is in its descendants
  * @returns {boolean} Whether the target is in a descendant of this item
  */
-export declare const isTargetInDescendants: (target: HTMLElement, itemRoot: HTMLElement | null) => boolean;
+export declare const isTargetInDescendants: (target: HTMLElement, itemRoot: HTMLElement | null) => boolean;