@itwin/itwinui-react 3.15.5 → 3.16.1

package/cjs/core/Table/actionHandlers/selectHandler.js

@@ -20,6 +20,7 @@ _export(exports, {
     return onToggleHandler;
   },
 });
+const _Table = require('../Table.js');
 const onSelectHandler = (newState, instance, onSelect, isRowDisabled) => {
   if (!instance?.rows.length) {
     onSelect?.([], newState);
@@ -29,14 +30,16 @@ const onSelectHandler = (newState, instance, onSelect, isRowDisabled) => {
   let handleRow = (row) => {
     if (isRowDisabled?.(row.original)) return false;
     let isAllSubSelected = true;
-    row.initialSubRows.forEach((subRow) => {
-      let result = handleRow(subRow);
-      if (!result) isAllSubSelected = false;
-    });
+    if (row.initialSubRows[0]?.original[_Table.iuiId] === void 0)
+      row.initialSubRows.forEach((subRow) => {
+        let result = handleRow(subRow);
+        if (!result) isAllSubSelected = false;
+      });
     if (
-      (!instance.selectSubRows && newState.selectedRowIds[row.id]) ||
-      (!row.initialSubRows.length && newState.selectedRowIds[row.id]) ||
-      (row.initialSubRows.length && isAllSubSelected)
+      newState.selectedRowIds[row.id] &&
+      (!instance.selectSubRows ||
+        !row.initialSubRows.length ||
+        isAllSubSelected)
     )
       newSelectedRowIds[row.id] = true;
     return !!newSelectedRowIds[row.id];

package/cjs/core/Table/columns/selectionColumn.js

@@ -21,6 +21,7 @@ const _interop_require_wildcard = require('@swc/helpers/_/_interop_require_wildc
 const _react = _interop_require_wildcard._(require('react'));
 const _Checkbox = require('../../Checkbox/Checkbox.js');
 const _index = require('../cells/index.js');
+const _Table = require('../Table.js');
 const SELECTION_CELL_ID = 'iui-table-checkbox-selector';
 const SelectionColumn = (props = {}) => {
   let { isDisabled, density } = props;
@@ -70,7 +71,11 @@ const SelectionColumn = (props = {}) => {
         disabled: isDisabled?.(row.original),
         onClick: (e) => e.stopPropagation(),
         onChange: () => {
-          if (row.subRows.length > 0 && selectSubRows)
+          if (
+            row.subRows.length > 0 &&
+            selectSubRows &&
+            void 0 === row.initialSubRows[0].original[_Table.iuiId]
+          )
             row.toggleRowSelected(
               !row.subRows.every(
                 (subRow) => subRow.isSelected || isDisabled?.(subRow.original),

package/cjs/core/Tree/Tree.d.ts

@@ -42,7 +42,8 @@ export type TreeProps<T> = {
     /**
      * Render function that should return the node element.
      * Recommended to use `TreeNode` component.
-     * Must be memoized.
+     *
+     ***Note**: When virtualization is enabled, the return value of `nodeRenderer()` is cloned and a `ref` is passed to it. Thus, you would need a `React.forwardRef` in the component returned by `nodeRenderer()`, except if you are returning `TreeNode` since that already forwards its ref.
      * @example
      * const nodeRenderer = React.useCallback(({ node, ...rest }: NodeRenderProps<DataType>) => (
      *   <TreeNode

package/cjs/core/Tree/Tree.js

@@ -170,6 +170,7 @@ const Tree = (props) => {
           onKeyDown: handleKeyDown,
           ref: treeRef,
           className: className,
+          'data-iui-size': 'small' === size ? 'small' : void 0,
           style: style,
           ...rest,
         })

package/cjs/index.d.ts

@@ -62,6 +62,7 @@ export { ModalContent } from './core/Modal/ModalContent.js';
 export { ModalButtonBar } from './core/Modal/ModalButtonBar.js';
 export { NotificationMarker } from './core/NotificationMarker/NotificationMarker.js';
 export { Overlay } from './core/Overlay/Overlay.js';
+export { Panels as unstable_Panels } from './core/Panels/Panels.js';
 export { ProgressLinear } from './core/ProgressIndicators/ProgressLinear.js';
 export { ProgressRadial } from './core/ProgressIndicators/ProgressRadial.js';
 export { Radio } from './core/Radio/Radio.js';

package/cjs/index.js

@@ -371,6 +371,9 @@ _export(exports, {
   tableFilters: function () {
     return _index.tableFilters;
   },
+  unstable_Panels: function () {
+    return _Panels.Panels;
+  },
   useToaster: function () {
     return _Toaster.useToaster;
   },
@@ -437,6 +440,7 @@ const _ModalContent = require('./core/Modal/ModalContent.js');
 const _ModalButtonBar = require('./core/Modal/ModalButtonBar.js');
 const _NotificationMarker = require('./core/NotificationMarker/NotificationMarker.js');
 const _Overlay = require('./core/Overlay/Overlay.js');
+const _Panels = require('./core/Panels/Panels.js');
 const _ProgressLinear = require('./core/ProgressIndicators/ProgressLinear.js');
 const _ProgressRadial = require('./core/ProgressIndicators/ProgressRadial.js');
 const _Radio = require('./core/Radio/Radio.js');

package/cjs/styles.js

@@ -1,6 +1,6 @@
 'use strict';
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const e = '3.15.5';
+const e = '3.16.1';
 const u = new Proxy(
   {},
   {

package/cjs/utils/components/MiddleTextTruncation.d.ts

@@ -1,6 +1,6 @@
 import * as React from 'react';
-import type { CommonProps } from '../props.js';
-export type MiddleTextTruncationProps = {
+import type { PolymorphicForwardRefComponent } from '../props.js';
+type MiddleTextTruncationProps = {
     /**
      * Text to truncate.
      */
@@ -14,7 +14,7 @@ export type MiddleTextTruncationProps = {
      * Custom renderer for the truncated text.
      */
     textRenderer?: (truncatedText: string, originalText: string) => React.ReactNode;
-} & CommonProps;
+};
 /**
  * Truncates text with the ellipsis in the middle,
  * leaving defined number of chars at the end.
@@ -31,7 +31,5 @@ export type MiddleTextTruncationProps = {
  *   )}
  * />
  */
-export declare const MiddleTextTruncation: {
-    (props: MiddleTextTruncationProps): React.JSX.Element;
-    displayName: string;
-};
+export declare const MiddleTextTruncation: PolymorphicForwardRefComponent<"span", MiddleTextTruncationProps>;
+export {};

package/cjs/utils/components/MiddleTextTruncation.js

@@ -11,9 +11,11 @@ Object.defineProperty(exports, 'MiddleTextTruncation', {
 const _interop_require_wildcard = require('@swc/helpers/_/_interop_require_wildcard');
 const _react = _interop_require_wildcard._(require('react'));
 const _OverflowContainer = require('./OverflowContainer.js');
+const _VisuallyHidden = require('../../core/VisuallyHidden/VisuallyHidden.js');
+const _ShadowRoot = require('./ShadowRoot.js');
 const ELLIPSIS_CHAR = '…';
-const MiddleTextTruncation = (props) => {
-  let { text, style, ...rest } = props;
+const MiddleTextTruncation = _react.forwardRef((props, forwardedRef) => {
+  let { text, endCharsCount, textRenderer, style, ...rest } = props;
   return _react.createElement(
     _OverflowContainer.OverflowContainer,
     {
@@ -27,10 +29,26 @@ const MiddleTextTruncation = (props) => {
       },
       itemsCount: text.length,
       ...rest,
+      ref: forwardedRef,
     },
-    _react.createElement(MiddleTextTruncationContent, props),
+    _react.createElement(
+      _ShadowRoot.ShadowRoot,
+      null,
+      _react.createElement(_VisuallyHidden.VisuallyHidden, null, text),
+      _react.createElement('slot', {
+        'aria-hidden': true,
+        style: {
+          pointerEvents: 'none',
+        },
+      }),
+    ),
+    _react.createElement(MiddleTextTruncationContent, {
+      text: text,
+      endCharsCount: endCharsCount,
+      textRenderer: textRenderer,
+    }),
   );
-};
+});
 const MiddleTextTruncationContent = (props) => {
   let { text, endCharsCount = 6, textRenderer } = props;
   let { visibleCount } = _OverflowContainer.OverflowContainer.useContext();

package/cjs/utils/components/OverflowContainer.d.ts

@@ -15,6 +15,7 @@ type OverflowContainerOverflowNodeProps = {
     children: React.ReactNode;
 };
 /**
+ * @private
  * Wrapper over `useOverflow`.
  *
  * - Use `OverflowContainer.useContext()` to get overflow related properties.

package/cjs/utils/components/OverflowContainer.js

@@ -12,48 +12,191 @@ const _interop_require_default = require('@swc/helpers/_/_interop_require_defaul
 const _react = _interop_require_default._(require('react'));
 const _useMergedRefs = require('../hooks/useMergedRefs.js');
 const _Box = require('./Box.js');
-const _useOverflow = require('../hooks/useOverflow.js');
+const _useIsomorphicLayoutEffect = require('../hooks/useIsomorphicLayoutEffect.js');
 const _useSafeContext = require('../hooks/useSafeContext.js');
-const OverflowContainerComponent = _react.default.forwardRef((props, ref) => {
-  let { itemsCount, children, overflowOrientation, ...rest } = props;
-  let [containerRef, visibleCount] = (0, _useOverflow.useOverflow)(
-    itemsCount,
-    false,
-    overflowOrientation,
-  );
-  let overflowContainerContextValue = _react.default.useMemo(
-    () => ({
-      visibleCount,
+const _dev = require('../functions/dev.js');
+const _useResizeObserver = require('../hooks/useResizeObserver.js');
+const OverflowContainerMain = _react.default.forwardRef(
+  (props, forwardedRef) => {
+    let { itemsCount, children, overflowOrientation, ...rest } = props;
+    let [containerRef, visibleCount] = useOverflow(
       itemsCount,
-    }),
-    [itemsCount, visibleCount],
-  );
-  return _react.default.createElement(
-    OverflowContainerContext.Provider,
-    {
-      value: overflowContainerContextValue,
-    },
-    _react.default.createElement(
-      _Box.Box,
+      overflowOrientation,
+    );
+    let overflowContainerContextValue = _react.default.useMemo(
+      () => ({
+        visibleCount,
+        itemsCount,
+      }),
+      [itemsCount, visibleCount],
+    );
+    return _react.default.createElement(
+      OverflowContainerContext.Provider,
       {
-        ref: (0, _useMergedRefs.useMergedRefs)(ref, containerRef),
-        ...rest,
+        value: overflowContainerContextValue,
       },
-      children,
-    ),
-  );
-});
+      _react.default.createElement(
+        _Box.Box,
+        {
+          ref: (0, _useMergedRefs.useMergedRefs)(forwardedRef, containerRef),
+          ...rest,
+        },
+        children,
+      ),
+    );
+  },
+);
 const OverflowContainerOverflowNode = (props) => {
   let { children } = props;
   let { visibleCount, itemsCount } = useOverflowContainerContext();
   let isOverflowing = visibleCount < itemsCount;
   return isOverflowing ? children : null;
 };
+const OverflowContainerComponent = _react.default.forwardRef(
+  (props, forwardedRef) => {
+    let { itemsCount, overflowOrientation = 'horizontal', ...rest } = props;
+    let [size, setSize] = _react.default.useState(null);
+    let [resizeRef] = (0, _useResizeObserver.useResizeObserver)(setSize);
+    let ref = (0, _useMergedRefs.useMergedRefs)(resizeRef, forwardedRef);
+    let key = `${itemsCount}${
+      'vertical' === overflowOrientation ? size?.height : size?.width
+    }`;
+    return _react.default.createElement(OverflowContainerMain, {
+      ...rest,
+      key: key,
+      ref: ref,
+      itemsCount: itemsCount,
+      overflowOrientation: overflowOrientation,
+    });
+  },
+);
 const OverflowContainer = Object.assign(OverflowContainerComponent, {
   OverflowNode: OverflowContainerOverflowNode,
   useContext: useOverflowContainerContext,
 });
 const OverflowContainerContext = _react.default.createContext(void 0);
+const useOverflow = (itemsCount, orientation = 'horizontal') => {
+  let [guessState, dispatch] = _react.default.useReducer(
+    overflowGuessReducer,
+    {
+      itemsCount,
+    },
+    overflowGuessReducerInitialState,
+  );
+  let containerRef = _react.default.useRef(null);
+  let isGuessing = _react.default.useRef(false);
+  (0, _useIsomorphicLayoutEffect.useLayoutEffect)(() => {
+    let { minGuess, maxGuess, isStabilized, visibleCount } = guessState;
+    if (isStabilized) return;
+    guessVisibleCount();
+    function guessVisibleCount() {
+      if (isStabilized || isGuessing.current || _dev.isUnitTest) return;
+      try {
+        isGuessing.current = true;
+        if (null == containerRef.current) return;
+        let dimension = 'horizontal' === orientation ? 'Width' : 'Height';
+        let availableSize = containerRef.current[`offset${dimension}`];
+        let requiredSize = containerRef.current[`scroll${dimension}`];
+        let isOverflowing = availableSize < requiredSize;
+        if (
+          0 === itemsCount ||
+          (1 === visibleCount && isOverflowing) ||
+          (visibleCount === itemsCount && !isOverflowing) ||
+          (maxGuess - minGuess === 1 && visibleCount === minGuess)
+        ) {
+          dispatch({
+            type: 'stabilize',
+          });
+          return;
+        }
+        if (maxGuess === visibleCount && !isOverflowing) {
+          dispatch({
+            type: 'shiftGuessRangeForward',
+          });
+          return;
+        }
+        isOverflowing
+          ? dispatch({
+              type: 'decreaseMaxGuess',
+              currentState: guessState,
+            })
+          : dispatch({
+              type: 'increaseMinGuess',
+              currentState: guessState,
+            });
+      } finally {
+        isGuessing.current = false;
+      }
+    }
+  }, [guessState, itemsCount, orientation]);
+  return [containerRef, guessState.visibleCount];
+};
+const STARTING_MAX_ITEMS_COUNT = 32;
+const overflowGuessReducerInitialState = ({ itemsCount }) => {
+  let initialVisibleCount = Math.min(itemsCount, STARTING_MAX_ITEMS_COUNT);
+  return _dev.isUnitTest
+    ? {
+        isStabilized: true,
+        minGuess: null,
+        maxGuess: null,
+        itemsCount,
+        visibleCount: itemsCount,
+      }
+    : {
+        isStabilized: false,
+        minGuess: 0,
+        maxGuess: initialVisibleCount,
+        itemsCount,
+        visibleCount: initialVisibleCount,
+      };
+};
+const overflowGuessReducer = (state, action) => {
+  let getSafeVisibleCount = ({ visibleCount, itemsCount }) =>
+    Math.min(itemsCount, visibleCount);
+  switch (action.type) {
+    case 'decreaseMaxGuess':
+    case 'increaseMinGuess':
+      if (state.isStabilized) return state;
+      let newMinGuess = state.minGuess;
+      let newMaxGuess = state.maxGuess;
+      if ('decreaseMaxGuess' === action.type)
+        newMaxGuess = action.currentState.visibleCount;
+      else newMinGuess = action.currentState.visibleCount;
+      let newVisibleCount = Math.floor((newMinGuess + newMaxGuess) / 2);
+      return {
+        ...state,
+        isStabilized: false,
+        minGuess: newMinGuess,
+        maxGuess: newMaxGuess,
+        visibleCount: getSafeVisibleCount({
+          visibleCount: newVisibleCount,
+          itemsCount: state.itemsCount,
+        }),
+      };
+    case 'shiftGuessRangeForward':
+      if (state.isStabilized) return state;
+      let doubleOfMaxGuess = 2 * state.maxGuess;
+      return {
+        ...state,
+        isStabilized: false,
+        minGuess: state.maxGuess,
+        maxGuess: doubleOfMaxGuess,
+        visibleCount: getSafeVisibleCount({
+          visibleCount: doubleOfMaxGuess,
+          itemsCount: state.itemsCount,
+        }),
+      };
+    case 'stabilize':
+      return {
+        ...state,
+        isStabilized: true,
+        minGuess: null,
+        maxGuess: null,
+      };
+    default:
+      return state;
+  }
+};
 function useOverflowContainerContext() {
   let overflowContainerContext = (0, _useSafeContext.useSafeContext)(
     OverflowContainerContext,

package/cjs/utils/hooks/index.d.ts

@@ -1,6 +1,5 @@
 export * from './useEventListener.js';
 export * from './useMergedRefs.js';
-export * from './useOverflow.js';
 export * from './useResizeObserver.js';
 export * from './useContainerWidth.js';
 export * from './useGlobals.js';
@@ -14,4 +13,5 @@ export * from './useId.js';
 export * from './useControlledState.js';
 export * from './useSyncExternalStore.js';
 export * from './useVirtualScroll.js';
+export * from './useInstance.js';
 export * from './useWarningLogger.js';

package/cjs/utils/hooks/index.js

@@ -5,7 +5,6 @@ Object.defineProperty(exports, '__esModule', {
 const _export_star = require('@swc/helpers/_/_export_star');
 _export_star._(require('./useEventListener.js'), exports);
 _export_star._(require('./useMergedRefs.js'), exports);
-_export_star._(require('./useOverflow.js'), exports);
 _export_star._(require('./useResizeObserver.js'), exports);
 _export_star._(require('./useContainerWidth.js'), exports);
 _export_star._(require('./useGlobals.js'), exports);
@@ -19,4 +18,5 @@ _export_star._(require('./useId.js'), exports);
 _export_star._(require('./useControlledState.js'), exports);
 _export_star._(require('./useSyncExternalStore.js'), exports);
 _export_star._(require('./useVirtualScroll.js'), exports);
+_export_star._(require('./useInstance.js'), exports);
 _export_star._(require('./useWarningLogger.js'), exports);

package/cjs/utils/hooks/useInstance.d.ts

@@ -0,0 +1,22 @@
+declare class Instance {
+}
+export declare const useInstance: () => Instance;
+/**
+ * Synchronizes the instance with the provided properties.
+ *
+ * @param instance Instance created by `useInstance`.
+ * @param properties Memoized object containing properties to be synchronized.
+ *
+ * @example
+ * const instance = useInstance();
+ *
+ * const properties = React.useMemo(() => ({
+ *   show: () => console.log('show'),
+ * }), []);
+ *
+ * useSynchronizeInstance(instance, properties);
+ *
+ * instance.show(); // logs 'show'
+ */
+export declare const useSynchronizeInstance: <T>(instance: T, properties: T) => T;
+export {};

package/cjs/utils/hooks/useInstance.js

@@ -0,0 +1,38 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+function _export(target, all) {
+  for (var name in all)
+    Object.defineProperty(target, name, {
+      enumerable: true,
+      get: all[name],
+    });
+}
+_export(exports, {
+  useInstance: function () {
+    return useInstance;
+  },
+  useSynchronizeInstance: function () {
+    return useSynchronizeInstance;
+  },
+});
+const _interop_require_wildcard = require('@swc/helpers/_/_interop_require_wildcard');
+const _react = _interop_require_wildcard._(require('react'));
+const _useSyncExternalStore = require('./useSyncExternalStore.js');
+class Instance {}
+const useInstance = () => _react.useMemo(() => new Instance(), []);
+const useSynchronizeInstance = (instance, properties) => {
+  let synchronize = _react.useCallback(() => {
+    if (!(instance instanceof Instance)) return () => {};
+    Object.assign(instance, properties);
+    return () => {
+      for (let key in properties) delete instance[key];
+    };
+  }, [instance, properties]);
+  return (0, _useSyncExternalStore.useSyncExternalStore)(
+    synchronize,
+    () => instance,
+    () => instance,
+  );
+};

package/esm/core/Breadcrumbs/Breadcrumbs.js

@@ -8,7 +8,7 @@ import {
 } from '../../utils/index.js';
 import { Button } from '../Buttons/Button.js';
 import { Anchor } from '../Typography/Anchor.js';
-let BreadcrumbsComponent = React.forwardRef((props, ref) => {
+let BreadcrumbsComponent = React.forwardRef((props, forwardedRef) => {
   let {
     children: childrenProp,
     currentIndex = React.Children.count(childrenProp) - 1,
@@ -26,7 +26,7 @@ let BreadcrumbsComponent = React.forwardRef((props, ref) => {
     {
       as: 'nav',
       className: cx('iui-breadcrumbs', className),
-      ref: ref,
+      ref: forwardedRef,
       'aria-label': 'Breadcrumb',
       ...rest,
     },

package/esm/core/Checkbox/Checkbox.js

@@ -34,11 +34,11 @@ export const Checkbox = React.forwardRef((props, ref) => {
         'iui-checkbox',
         {
           'iui-checkbox-visibility': 'eyeball' === variant,
-          'iui-loading': isLoading,
         },
         className,
       ),
       style: style,
+      'data-iui-loading': isLoading ? 'true' : void 0,
       disabled: disabled || isLoading,
       type: 'checkbox',
       ref: refs,
@@ -57,15 +57,10 @@ export const Checkbox = React.forwardRef((props, ref) => {
         Box,
         {
           as: 'label',
-          className: cx(
-            'iui-checkbox-wrapper',
-            {
-              'iui-disabled': disabled,
-              [`iui-${status}`]: !!status,
-              'iui-loading': isLoading,
-            },
-            wrapperClassName,
-          ),
+          className: cx('iui-checkbox-wrapper', wrapperClassName),
+          'data-iui-disabled': disabled ? 'true' : void 0,
+          'data-iui-status': status,
+          'data-iui-loading': isLoading ? 'true' : void 0,
           ...restWrapperProps,
         },
         checkbox,

package/esm/core/ComboBox/ComboBox.d.ts

@@ -33,11 +33,24 @@ export type ComboboxMultipleTypeProps<T> = {
      * Callback fired when selected value changes.
      */
     onChange?: (value: T) => void;
+    /**
+     * Only applicable when `multiple` is enabled.
+     *
+     * If `true`, toggling an option will clear the filter.
+     * Useful when users would likely want to re-filter after toggling an option.
+     *
+     * If `false`, the filter will remain as-is after toggling an option.
+     * Useful when users would likely want to toggle multiple options from the _same_ filtered results.
+     *
+     * @default true
+     */
+    clearFilterOnOptionToggle?: never;
 } | {
     multiple: true;
     value?: T[] | null | undefined;
     defaultValue?: T[] | null;
     onChange?: (value: T[], event: MultipleOnChangeProps<T>) => void;
+    clearFilterOnOptionToggle?: boolean;
 };
 export type ComboBoxProps<T> = {
     /**

package/esm/core/ComboBox/ComboBox.js

@@ -47,6 +47,7 @@ export const ComboBox = React.forwardRef((props, forwardedRef) => {
     onHide: onHideProp,
     id = inputProps?.id ? `iui-${inputProps.id}-cb` : idPrefix,
     defaultValue,
+    clearFilterOnOptionToggle = true,
     ...rest
   } = props;
   let inputRef = React.useRef(null);
@@ -200,7 +201,6 @@ export const ComboBox = React.forwardRef((props, forwardedRef) => {
         preventScroll: true,
       });
       if (optionsRef.current[__originalIndex]?.disabled) return;
-      setIsInputDirty(false);
       if (multiple) {
         let actionType = isMenuItemSelected(__originalIndex)
           ? 'removed'
@@ -218,7 +218,10 @@ export const ComboBox = React.forwardRef((props, forwardedRef) => {
             .filter(Boolean)
             .join(', '),
         );
-        setInputValue('');
+        if (clearFilterOnOptionToggle) {
+          setInputValue('');
+          setIsInputDirty(false);
+        }
       } else {
         setSelectedIndexes(__originalIndex);
         hide();
@@ -226,13 +229,14 @@ export const ComboBox = React.forwardRef((props, forwardedRef) => {
       }
     },
     [
-      selectedChangeHandler,
-      isMenuItemSelected,
+      optionsRef,
       multiple,
+      isMenuItemSelected,
+      selectedChangeHandler,
+      setSelectedIndexes,
       onChangeHandler,
-      optionsRef,
+      clearFilterOnOptionToggle,
       hide,
-      setSelectedIndexes,
     ],
   );
   let getMenuItem = React.useCallback(

package/esm/core/DatePicker/DatePicker.d.ts

@@ -29,8 +29,8 @@ export type DateRangePickerProps = {
     onChange?: (date: Date) => void;
 } | {
     enableRangeSelect: true;
-    startDate: Date;
-    endDate: Date;
+    startDate?: Date;
+    endDate?: Date;
     onChange?: (startDate: Date, endDate: Date) => void;
 };
 type DatePickerProps = {

package/esm/core/DatePicker/DatePicker.js

@@ -8,6 +8,8 @@ import {
   isBefore,
   Box,
   useId,
+  useLayoutEffect,
+  useWarningLogger,
 } from '../../utils/index.js';
 import { IconButton } from '../Buttons/IconButton.js';
 import { TimePicker } from '../TimePicker/TimePicker.js';
@@ -135,6 +137,7 @@ export const DatePicker = React.forwardRef((props, forwardedRef) => {
     showDatesOutsideMonth = true,
     ...rest
   } = props;
+  let logWarning = useWarningLogger();
   let monthNames = localizedNames?.months ?? defaultMonths;
   let shortDays = localizedNames?.shortDays ?? defaultShortDays;
   let longDays = localizedNames?.days ?? defaultLongDays;
@@ -177,7 +180,7 @@ export const DatePicker = React.forwardRef((props, forwardedRef) => {
     );
   }, [date, setMonthAndYear, startDate, endDate, enableRangeSelect]);
   let popoverInitialFocusContext = React.useContext(PopoverInitialFocusContext);
-  React.useLayoutEffect(() => {
+  useLayoutEffect(() => {
     if (setFocus && popoverInitialFocusContext)
       popoverInitialFocusContext.setInitialFocus(-1);
   }, [popoverInitialFocusContext, setFocus]);