@carbon/react 1.81.0 → 1.82.0-rc.0

package/es/components/TimePickerSelect/TimePickerSelect.js

@@ -9,18 +9,19 @@ import { extends as _extends } from '../../_virtual/_rollupPluginBabelHelpers.js
 import { ChevronDown } from '@carbon/icons-react';
 import cx from 'classnames';
 import PropTypes from 'prop-types';
-import React__default from 'react';
+import React__default, { forwardRef } from 'react';
 import { usePrefix } from '../../internal/usePrefix.js';
 
-const TimePickerSelect = /*#__PURE__*/React__default.forwardRef(function TimePickerSelect(_ref, ref) {
-  let {
+const frFn = forwardRef;
+const TimePickerSelect = frFn((props, ref) => {
+  const {
     ['aria-label']: ariaLabel = 'open list of options',
     children,
     id,
     disabled = false,
     className,
     ...rest
-  } = _ref;
+  } = props;
   const prefix = usePrefix();
   const selectClasses = cx({
     [`${prefix}--select`]: true,

package/es/components/TreeView/TreeNode.js

@@ -14,7 +14,7 @@ import { ArrowLeft, ArrowRight, Enter, Space } from '../../internal/keyboard/key
 import { matches, match } from '../../internal/keyboard/match.js';
 import { useControllableState } from '../../internal/useControllableState.js';
 import { usePrefix } from '../../internal/usePrefix.js';
-import uniqueId from '../../tools/uniqueId.js';
+import { uniqueId } from '../../tools/uniqueId.js';
 import { useFeatureFlag } from '../FeatureFlags/index.js';
 
 const TreeNode = /*#__PURE__*/React__default.forwardRef((_ref, forwardedRef) => {
@@ -201,6 +201,18 @@ const TreeNode = /*#__PURE__*/React__default.forwardRef((_ref, forwardedRef) =>
     }
     if (matches(event, [Enter, Space])) {
       event.preventDefault();
+      if (match(event, Enter) && children) {
+        // Toggle expansion state for parent nodes
+        if (!enableTreeviewControllable) {
+          onToggle?.(event, {
+            id,
+            isExpanded: !expanded,
+            label,
+            value
+          });
+        }
+        setExpanded(!expanded);
+      }
       if (href) {
         currentNode.current?.click();
       }

package/es/components/TreeView/TreeView.js

@@ -13,7 +13,7 @@ import { ArrowUp, ArrowDown, Home, End } from '../../internal/keyboard/keys.js';
 import { matches, match } from '../../internal/keyboard/match.js';
 import { useControllableState } from '../../internal/useControllableState.js';
 import { usePrefix } from '../../internal/usePrefix.js';
-import uniqueId from '../../tools/uniqueId.js';
+import { uniqueId } from '../../tools/uniqueId.js';
 import { useFeatureFlag } from '../FeatureFlags/index.js';
 import TreeNode from './TreeNode.js';
 

package/es/index.js

@@ -107,8 +107,8 @@ export { default as SkeletonPlaceholder } from './components/SkeletonPlaceholder
 export { default as SkeletonText } from './components/SkeletonText/SkeletonText.js';
 export { default as Slider } from './components/Slider/index.js';
 export { HStack } from './components/Stack/HStack.js';
-export { VStack } from './components/Stack/VStack.js';
 export { Stack } from './components/Stack/Stack.js';
+export { VStack } from './components/Stack/VStack.js';
 export { StructuredListBody, StructuredListCell, StructuredListHead, StructuredListInput, StructuredListRow, StructuredListWrapper } from './components/StructuredList/StructuredList.js';
 export { default as StructuredListSkeleton } from './components/StructuredList/StructuredList.Skeleton.js';
 export { default as Switch } from './components/Switch/Switch.js';

package/es/internal/FloatingMenu.js

@@ -15,7 +15,7 @@ import { selectorTabbable, selectorFocusable } from './keyboard/navigation.js';
 import { OptimizedResize } from './OptimizedResize.js';
 import { PrefixContext } from './usePrefix.js';
 import { warning } from './warning.js';
-import wrapFocus, { wrapFocusWithoutSentinels } from './wrapFocus.js';
+import { wrapFocus, wrapFocusWithoutSentinels } from './wrapFocus.js';
 
 const DIRECTION_LEFT = 'left';
 const DIRECTION_TOP = 'top';
@@ -246,13 +246,17 @@ const FloatingMenu = _ref2 => {
    * Blur handler used when focus trapping is enabled.
    */
   const handleBlur = event => {
-    if (menuBodyRef.current && startSentinelRef.current && endSentinelRef.current) {
+    const {
+      target,
+      relatedTarget
+    } = event;
+    if (menuBodyRef.current && startSentinelRef.current && endSentinelRef.current && target instanceof HTMLElement && relatedTarget instanceof HTMLElement) {
       wrapFocus({
         bodyNode: menuBodyRef.current,
         startTrapNode: startSentinelRef.current,
         endTrapNode: endSentinelRef.current,
-        currentActiveNode: event.relatedTarget,
-        oldActiveNode: event.target
+        currentActiveNode: relatedTarget,
+        oldActiveNode: target
       });
     }
   };
@@ -261,7 +265,7 @@ const FloatingMenu = _ref2 => {
    * Keydown handler for focus wrapping when experimental focus trap is enabled.
    */
   const handleKeyDown = event => {
-    if (match(event, Tab) && menuBodyRef.current) {
+    if (match(event, Tab) && menuBodyRef.current && event.target instanceof HTMLElement) {
       wrapFocusWithoutSentinels({
         containerNode: menuBodyRef.current,
         currentActiveNode: event.target,

package/es/internal/environment.js

@@ -11,9 +11,16 @@
  * @see https://github.com/facebook/fbjs/blob/4d1751311d3f67af2dcce2e40df8512a23c7b9c6/packages/fbjs/src/core/ExecutionEnvironment.js#L12
  */
 const canUseDOM = !!(typeof window !== 'undefined' &&
+// TODO: `ssr-friendly` doesn't support ESLint v9.
+// https://github.com/kopiro/eslint-plugin-ssr-friendly/issues/30
+// https://github.com/carbon-design-system/carbon/issues/18991
+/*
 // eslint-disable-next-line ssr-friendly/no-dom-globals-in-module-scope
+*/
 window.document &&
+/*
 // eslint-disable-next-line ssr-friendly/no-dom-globals-in-module-scope
+*/
 window.document.createElement);
 
 export { canUseDOM };

package/es/internal/keyboard/navigation.d.ts

@@ -17,16 +17,6 @@ import { KeyboardEvent } from 'react';
  *  getNextIndex(keyCodes.RIGHT, 0, 4)
  */
 export declare const getNextIndex: (key: KeyboardEvent | number | string, index: number, arrayLength: number) => number | undefined;
-/**
- * A flag `node.compareDocumentPosition(target)` returns that indicates
- * `target` is located earlier than `node` in the document or `target` contains `node`.
- */
-export declare const DOCUMENT_POSITION_BROAD_PRECEDING: number;
-/**
- * A flag `node.compareDocumentPosition(target)` returns that indicates
- * `target` is located later than `node` in the document or `node` contains `target`.
- */
-export declare const DOCUMENT_POSITION_BROAD_FOLLOWING: number;
 /**
  * CSS selector that selects major nodes that are sequentially focusable.
  */

package/es/internal/keyboard/navigation.js

@@ -29,18 +29,6 @@ const getNextIndex = (key, index, arrayLength) => {
   return;
 };
 
-/**
- * A flag `node.compareDocumentPosition(target)` returns that indicates
- * `target` is located earlier than `node` in the document or `target` contains `node`.
- */
-const DOCUMENT_POSITION_BROAD_PRECEDING = typeof Node !== 'undefined' ? Node.DOCUMENT_POSITION_PRECEDING | Node.DOCUMENT_POSITION_CONTAINS : 0;
-
-/**
- * A flag `node.compareDocumentPosition(target)` returns that indicates
- * `target` is located later than `node` in the document or `node` contains `target`.
- */
-const DOCUMENT_POSITION_BROAD_FOLLOWING = typeof Node !== 'undefined' ? Node.DOCUMENT_POSITION_FOLLOWING | Node.DOCUMENT_POSITION_CONTAINED_BY : 0;
-
 /**
  * CSS selector that selects major nodes that are sequentially focusable.
  */
@@ -61,4 +49,4 @@ const selectorFocusable = `
   iframe, object, embed, *[tabindex]:not([disabled]), *[contenteditable=true]
 `;
 
-export { DOCUMENT_POSITION_BROAD_FOLLOWING, DOCUMENT_POSITION_BROAD_PRECEDING, getNextIndex, selectorFocusable, selectorTabbable };
+export { getNextIndex, selectorFocusable, selectorTabbable };

package/es/internal/useId.js

@@ -5,7 +5,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import React__default, { useState, useEffect, useLayoutEffect } from 'react';
+import React__default, { useLayoutEffect, useEffect, useState } from 'react';
 import { setupGetInstanceId } from '../tools/setupGetInstanceId.js';
 import { canUseDOM } from './environment.js';
 import { useIdPrefix } from './useIdPrefix.js';

package/es/internal/useNoInteractiveChildren.js

@@ -10,11 +10,15 @@ import { useEffect } from 'react';
 function useNoInteractiveChildren(ref) {
   let message = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'component should have no interactive child nodes';
   if (process.env.NODE_ENV !== 'production') {
+    // TODO: https://github.com/carbon-design-system/carbon/issues/19005
+    /*
     // eslint-disable-next-line react-hooks/rules-of-hooks
+    */
     useEffect(() => {
       const node = ref.current ? getInteractiveContent(ref.current) : false;
       if (node) {
         const errorMessage = `Error: ${message}.\n\nInstead found: ${node.outerHTML}`;
+        // eslint-disable-next-line no-console
         console.error(errorMessage);
         throw new Error(errorMessage);
       }
@@ -24,7 +28,10 @@ function useNoInteractiveChildren(ref) {
 function useInteractiveChildrenNeedDescription(ref) {
   let message = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : `interactive child node(s) should have an \`aria-describedby\` property`;
   if (process.env.NODE_ENV !== 'production') {
+    // TODO: https://github.com/carbon-design-system/carbon/issues/19005
+    /*
     // eslint-disable-next-line react-hooks/rules-of-hooks
+    */
     useEffect(() => {
       const node = ref.current ? getInteractiveContent(ref.current) : false;
       if (node && !node.hasAttribute('aria-describedby')) {

package/es/internal/useOutsideClick.js

@@ -19,7 +19,10 @@ const useOutsideClick = (ref, callback) => {
   // treated as a constant as it will be false when executed in a Node.js
   // environment and true when executed in the browser
   if (canUseDOM) {
+    // TODO: https://github.com/carbon-design-system/carbon/issues/19005
+    /*
     // eslint-disable-next-line react-hooks/rules-of-hooks
+    */
     useWindowEvent('click', event => {
       const {
         target

package/es/internal/wrapFocus.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Copyright IBM Corp. 2020, 2025
+ *
+ * This source code is licensed under the Apache-2.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * Checks whether the given node or one of its ancestors matches any of the
+ * specified floating menu selectors.
+ *
+ * @param {Node} node - A DOM node.
+ * @param {string[]} selectorsFloatingMenus - Additional CSS selectors that
+ * match floating menus.
+ * @returns {boolean} Whether the node or one of its ancestors is in a floating
+ * menu.
+ */
+export declare const elementOrParentIsFloatingMenu: (node: Node, selectorsFloatingMenus?: string[]) => boolean;
+/**
+ * Ensures the focus is kept within the given container by implementing
+ * "focus-wrap" behavior.
+ */
+export declare const wrapFocus: ({ bodyNode, startTrapNode, endTrapNode, currentActiveNode, oldActiveNode, selectorsFloatingMenus, }: {
+    /** The DOM node of the container. */
+    bodyNode: HTMLElement | null;
+    /** The start sentinel node for focus trapping. */
+    startTrapNode: HTMLElement | null;
+    /** The end sentinel node for focus trapping. */
+    endTrapNode: HTMLElement | null;
+    /** The current active node (i.e., the one with focus). */
+    currentActiveNode: HTMLElement;
+    /** The previous active node (i.e., the one that had focus before). */
+    oldActiveNode: HTMLElement;
+    /** CSS selectors for floating menus. */
+    selectorsFloatingMenus?: string[];
+}) => void;
+/**
+ * Ensures the focus is kept in the given container, implementing "focus-wrap"
+ * behavior.
+ *
+ * Note: This must be called *before* focus moves using `onKeyDown` or similar.
+ */
+export declare const wrapFocusWithoutSentinels: ({ containerNode, currentActiveNode, event, }: {
+    /** The container node within which to keep focus. */
+    containerNode: HTMLElement;
+    /** The current active node (i.e., the one with focus). */
+    currentActiveNode: HTMLElement;
+    /** The event that triggered this function. */
+    event: React.KeyboardEvent | KeyboardEvent;
+}) => void;

package/es/internal/wrapFocus.js

@@ -6,33 +6,45 @@
  */
 
 import { useEffect } from 'react';
-import { DOCUMENT_POSITION_BROAD_PRECEDING, selectorTabbable, DOCUMENT_POSITION_BROAD_FOLLOWING } from './keyboard/navigation.js';
 import { tabbable } from 'tabbable';
+import { selectorTabbable } from './keyboard/navigation.js';
 
 /**
- * @param {Node} node A DOM node.
- * @param {string[]} selectorsFloatingMenus The CSS selectors that matches floating menus.
- * @returns {boolean} `true` of the given `node` is in a floating menu.
+ * A flag `node.compareDocumentPosition(target)` returns that indicates
+ * `target` is located earlier than `node` in the document or `target` contains `node`.
  */
-function elementOrParentIsFloatingMenu(node) {
+const DOCUMENT_POSITION_BROAD_PRECEDING = typeof Node !== 'undefined' ? Node.DOCUMENT_POSITION_PRECEDING | Node.DOCUMENT_POSITION_CONTAINS : 0;
+
+/**
+ * A flag `node.compareDocumentPosition(target)` returns that indicates
+ * `target` is located later than `node` in the document or `node` contains `target`.
+ */
+const DOCUMENT_POSITION_BROAD_FOLLOWING = typeof Node !== 'undefined' ? Node.DOCUMENT_POSITION_FOLLOWING | Node.DOCUMENT_POSITION_CONTAINED_BY : 0;
+
+/**
+ * Checks whether the given node or one of its ancestors matches any of the
+ * specified floating menu selectors.
+ *
+ * @param {Node} node - A DOM node.
+ * @param {string[]} selectorsFloatingMenus - Additional CSS selectors that
+ * match floating menus.
+ * @returns {boolean} Whether the node or one of its ancestors is in a floating
+ * menu.
+ */
+const elementOrParentIsFloatingMenu = function (node) {
   let selectorsFloatingMenus = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
-  if (node && typeof node.closest === 'function') {
-    const allSelectorsFloatingMenus = [`.cds--overflow-menu-options`, `.cds--tooltip`, '.flatpickr-calendar', ...selectorsFloatingMenus];
-    return allSelectorsFloatingMenus.some(selector => node.closest(selector));
+  if (node instanceof Element && typeof node.closest === 'function') {
+    const allSelectorsFloatingMenus = ['.cds--overflow-menu-options', '.cds--tooltip', '.flatpickr-calendar', ...selectorsFloatingMenus];
+    return allSelectorsFloatingMenus.some(selector => !!node.closest(selector));
   }
-}
+  return false;
+};
 
 /**
- * Ensures the focus is kept in the given `modalNode`, implementing "focus-wrap" behavior.
- * @param {object} options The options.
- * @param {Node|null} options.bodyNode
- * @param {Node|null} options.startTrapNode The DOM node of the focus sentinel the is placed earlier next to `modalNode`.
- * @param {Node|null} options.endTrapNode The DOM node of the focus sentinel the is placed next to `modalNode`.
- * @param {Node} options.currentActiveNode The DOM node that has focus.
- * @param {Node} options.oldActiveNode The DOM node that previously had focus.
- * @param {string[]} [options.selectorsFloatingMenus] The CSS selectors that matches floating menus.
+ * Ensures the focus is kept within the given container by implementing
+ * "focus-wrap" behavior.
  */
-function wrapFocus(_ref) {
+const wrapFocus = _ref => {
   let {
     bodyNode,
     startTrapNode,
@@ -44,59 +56,60 @@ function wrapFocus(_ref) {
   if (bodyNode && currentActiveNode && oldActiveNode && !bodyNode.contains(currentActiveNode) && !elementOrParentIsFloatingMenu(currentActiveNode, selectorsFloatingMenus)) {
     const comparisonResult = oldActiveNode.compareDocumentPosition(currentActiveNode);
     if (currentActiveNode === startTrapNode || comparisonResult & DOCUMENT_POSITION_BROAD_PRECEDING) {
-      const tabbable = [...bodyNode.querySelectorAll(selectorTabbable)].reverse().find(elem => Boolean(elem.offsetParent));
-      if (tabbable) {
-        tabbable.focus();
+      const tabbableElement = Array.from(bodyNode.querySelectorAll(selectorTabbable)).reverse().find(_ref2 => {
+        let {
+          offsetParent
+        } = _ref2;
+        return Boolean(offsetParent);
+      });
+      if (tabbableElement) {
+        tabbableElement.focus();
       } else if (bodyNode !== oldActiveNode) {
         bodyNode.focus();
       }
     } else if (currentActiveNode === endTrapNode || comparisonResult & DOCUMENT_POSITION_BROAD_FOLLOWING) {
-      const tabbable = Array.prototype.find.call(bodyNode.querySelectorAll(selectorTabbable), elem => Boolean(elem.offsetParent));
-      if (tabbable) {
-        tabbable.focus();
+      const tabbableElement = Array.from(bodyNode.querySelectorAll(selectorTabbable)).find(_ref3 => {
+        let {
+          offsetParent
+        } = _ref3;
+        return Boolean(offsetParent);
+      });
+      if (tabbableElement) {
+        tabbableElement.focus();
       } else if (bodyNode !== oldActiveNode) {
         bodyNode.focus();
       }
     }
   }
-}
+};
 
 /**
- * Ensures the focus is kept in the given `containerNode`, implementing "focus-wrap" behavior.
- * Note: This must be called *before* focus moves using onKeyDown or similar.
- * @param {object} options The options.
- * @param {Node|null} options.containerNode
- * @param {EventTarget} options.currentActiveNode The DOM node that has focus.
- * @param {React.KeyboardEvent} options.event The DOM event
+ * Ensures the focus is kept in the given container, implementing "focus-wrap"
+ * behavior.
+ *
+ * Note: This must be called *before* focus moves using `onKeyDown` or similar.
  */
-function wrapFocusWithoutSentinels(_ref2) {
+const wrapFocusWithoutSentinels = _ref4 => {
   let {
     containerNode,
     currentActiveNode,
     event
-  } = _ref2;
-  if (['blur', 'focusout', 'focusin', 'focus'].includes(event.type) && process.env.NODE_ENV !== 'production') {
-    // eslint-disable-next-line react-hooks/rules-of-hooks
-    useEffect(() => {
+  } = _ref4;
+  if (!containerNode) return;
+  useEffect(() => {
+    if (['blur', 'focusout', 'focusin', 'focus'].includes(event.type) && process.env.NODE_ENV !== 'production') {
       throw new Error(`Error: wrapFocusWithoutSentinels(...) called in unsupported ${event.type} event.\n\nCall wrapFocusWithoutSentinels(...) from onKeyDown instead.`);
-    });
-  }
+    }
+  }, []);
 
-  // The reason we're using tabbable is because it returns the tabbable
-  // items *in tab order*, whereas using our `selectorTabbable` only
-  // returns in DOM order
+  // Use `tabbable` to get the focusable elements in tab order.
+  // `selectorTabbable` returns elements in DOM order which is why it's not
+  // used.
   const tabbables = tabbable(containerNode);
   const firstTabbable = tabbables[0];
   const lastTabbable = tabbables[tabbables.length - 1];
 
-  // console.log(`---------------------------------`);
-  // console.log(containerNode);
-  // console.log(tabbables);
-  // console.log(firstTabbable);
-  // console.log(lastTabbable);
-  // console.log(currentActiveNode);
-
-  // The shift key is used to determine if focus is moving forwards or backwards
+  // The shift key indicates if focus is moving forwards or backwards.
   if (currentActiveNode === lastTabbable && !event.shiftKey) {
     // Cancel the current movement of focus because we're going to place it ourselves
     event.preventDefault();
@@ -107,6 +120,6 @@ function wrapFocusWithoutSentinels(_ref2) {
     event.preventDefault();
     lastTabbable.focus();
   }
-}
+};
 
-export { wrapFocus as default, elementOrParentIsFloatingMenu, wrapFocusWithoutSentinels };
+export { elementOrParentIsFloatingMenu, wrapFocus, wrapFocusWithoutSentinels };

package/es/tools/events.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Copyright IBM Corp. 2016, 2025
+ *
+ * This source code is licensed under the Apache-2.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { SyntheticEvent } from 'react';
+/**
+ * Composes multiple event handler functions into a single event handler. The
+ * composed handler calls each provided function sequentially with the event and
+ * any additional arguments. If any handler calls `event.preventDefault()`,
+ * further handlers are skipped.
+ *
+ * @param handlers - An array of event handler functions.
+ * @returns A composite event handler.
+ */
+export declare const composeEventHandlers: <E extends SyntheticEvent = SyntheticEvent<Element, Event>>(handlers: (((event: E, ...args: any[]) => void) | undefined)[]) => (event: E, ...args: any[]) => void;

package/es/tools/events.js

@@ -5,28 +5,25 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-// @ts-check
-
 /**
- * Generic utility to compose event handlers so that consumers can supply their
- * own event listeners on table components. The default heuristic here is to
- * iterate through the given functions until `preventDefault` is called on the
- * given event.
+ * Composes multiple event handler functions into a single event handler. The
+ * composed handler calls each provided function sequentially with the event and
+ * any additional arguments. If any handler calls `event.preventDefault()`,
+ * further handlers are skipped.
  *
- * @param {Array<Function|undefined>} fns array of functions to apply to the event
- * @returns {any}
+ * @param handlers - An array of event handler functions.
+ * @returns A composite event handler.
  */
-const composeEventHandlers = fns => function (event) {
+const composeEventHandlers = handlers => function (event) {
   for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
     args[_key - 1] = arguments[_key];
   }
-  for (let i = 0; i < fns.length; i++) {
+  for (const handler of handlers) {
     if (event.defaultPrevented) {
       break;
     }
-    const fn = fns[i];
-    if (typeof fn === 'function') {
-      fn(event, ...args);
+    if (typeof handler === 'function') {
+      handler(event, ...args);
     }
   }
 };

package/es/tools/mapPopoverAlign.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Copyright IBM Corp. 2016, 2025
+ *
+ * This source code is licensed under the Apache-2.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { Placement } from '@floating-ui/react';
+/**
+ * Maps popover alignment values to their corresponding replacement values.
+ *
+ * @param align - The original align value.
+ * @returns The new align value based on mapping or the original align if no
+ *          mapping exists.
+ */
+export declare const mapPopoverAlign: (align: string) => Placement;

package/es/tools/mapPopoverAlign.js

@@ -0,0 +1,28 @@
+/**
+ * Copyright IBM Corp. 2016, 2023
+ *
+ * This source code is licensed under the Apache-2.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+const popoverAlignMapping = {
+  'top-left': 'top-start',
+  'top-right': 'top-end',
+  'bottom-left': 'bottom-start',
+  'bottom-right': 'bottom-end',
+  'left-bottom': 'left-end',
+  'left-top': 'left-start',
+  'right-bottom': 'right-end',
+  'right-top': 'right-start'
+};
+
+/**
+ * Maps popover alignment values to their corresponding replacement values.
+ *
+ * @param align - The original align value.
+ * @returns The new align value based on mapping or the original align if no
+ *          mapping exists.
+ */
+const mapPopoverAlign = align => popoverAlignMapping[align] ?? align;
+
+export { mapPopoverAlign };

package/es/tools/uniqueId.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Copyright IBM Corp. 2016, 2025
+ *
+ * This source code is licensed under the Apache-2.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+export declare const uniqueId: (prefix?: string) => string;

package/es/tools/uniqueId.js

@@ -6,10 +6,10 @@
  */
 
 let lastId = 0;
-function uniqueId() {
+const uniqueId = function () {
   let prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'id';
   lastId++;
   return `${prefix}${lastId}`;
-}
+};
 
-export { uniqueId as default };
+export { uniqueId };

package/es/types/common.d.ts

@@ -6,8 +6,6 @@
  */
 import * as React from 'react';
 export type ReactAttr<T = HTMLElement> = React.HTMLAttributes<T>;
-export type ForwardRefProps<T, P = unknown> = React.PropsWithoutRef<React.PropsWithChildren<P>> & React.RefAttributes<T>;
-export type ForwardRefReturn<T, P = unknown> = React.ForwardRefExoticComponent<ForwardRefProps<T, P>>;
 /**
  * For "as" props.  Creates an "as" property that supports native html tags such as 'span', 'a', 'button' as well as custom functional components
  * All native props for the supplied html tag/component are inferred as part of the base component props, allowing us to use props like `href` on an 'a' element etc

package/lib/components/AILabel/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright IBM Corp. 2016, 2024
+ * Copyright IBM Corp. 2016, 2025
  *
  * This source code is licensed under the Apache-2.0 license found in the
  * LICENSE file in the root directory of this source tree.

package/lib/components/AILabel/index.js

@@ -17,7 +17,7 @@ var React = require('react');
 var usePrefix = require('../../internal/usePrefix.js');
 var index = require('../Toggletip/index.js');
 var index$1 = require('../IconButton/index.js');
-var createPropAdapter = require('../../tools/createPropAdapter.js');
+var mapPopoverAlign = require('../../tools/mapPopoverAlign.js');
 var iconsReact = require('@carbon/icons-react');
 var useId = require('../../internal/useId.js');
 var deprecate = require('../../prop-types/deprecate.js');
@@ -90,9 +90,6 @@ AILabelActions.propTypes = {
  * @deprecated Use NewPopoverAlignment instead.
  */
 
-const propMappingFunction = deprecatedValue => {
-  return createPropAdapter.mapPopoverAlignProp(deprecatedValue);
-};
 const AILabel = /*#__PURE__*/React__default["default"].forwardRef(function AILabel(_ref3, ref) {
   let {
     aiText = 'AI',
@@ -191,11 +188,7 @@ AILabel.propTypes = {
   // deprecated use right-start instead
 
   // new values to match floating-ui
-  'top-start', 'top-end', 'bottom-start', 'bottom-end', 'left-end', 'left-start', 'right-end', 'right-start']),
-  //allowed prop values
-  ['top', 'top-start', 'top-end', 'bottom', 'bottom-start', 'bottom-end', 'left', 'left-start', 'left-end', 'right', 'right-start', 'right-end'],
-  //optional mapper function
-  propMappingFunction),
+  'top-start', 'top-end', 'bottom-start', 'bottom-end', 'left-end', 'left-start', 'right-end', 'right-start']), ['top', 'top-start', 'top-end', 'bottom', 'bottom-start', 'bottom-end', 'left', 'left-start', 'left-end', 'right', 'right-start', 'right-end'], mapPopoverAlign.mapPopoverAlign),
   /**
    * Specify the text that will be provided to the aria-label of the `AILabel` button
    */

package/lib/components/Breadcrumb/Breadcrumb.d.ts

@@ -1,11 +1,10 @@
 /**
- * Copyright IBM Corp. 2016, 2023
+ * Copyright IBM Corp. 2016, 2025
  *
  * This source code is licensed under the Apache-2.0 license found in the
  * LICENSE file in the root directory of this source tree.
  */
 import React from 'react';
-import { ForwardRefReturn } from '../../types/common';
 export interface BreadcrumbProps extends React.HTMLAttributes<HTMLElement> {
     /**
      * Specify the label for the breadcrumb container
@@ -25,5 +24,5 @@ export interface BreadcrumbProps extends React.HTMLAttributes<HTMLElement> {
      */
     size?: 'sm' | 'md';
 }
-declare const Breadcrumb: ForwardRefReturn<HTMLElement, BreadcrumbProps>;
+declare const Breadcrumb: React.ForwardRefExoticComponent<BreadcrumbProps & React.RefAttributes<HTMLElement>>;
 export default Breadcrumb;