@carbon/react 1.32.0 → 1.33.0

package/es/components/Tag/Tag.js

@@ -41,6 +41,7 @@ const Tag = _ref => {
     disabled,
     onClose,
     size,
+    as: BaseComponent,
     ...other
   } = _ref;
   const prefix = usePrefix();
@@ -61,7 +62,8 @@ const Tag = _ref => {
     }
   };
   if (filter) {
-    return /*#__PURE__*/React__default.createElement("div", _extends({
+    const ComponentTag = BaseComponent ?? 'div';
+    return /*#__PURE__*/React__default.createElement(ComponentTag, _extends({
       className: tagClasses,
       id: tagId
     }, other), /*#__PURE__*/React__default.createElement("span", {
@@ -76,7 +78,7 @@ const Tag = _ref => {
       title: title
     }, _Close || (_Close = /*#__PURE__*/React__default.createElement(Close, null))));
   }
-  const ComponentTag = other.onClick ? 'button' : 'div';
+  const ComponentTag = BaseComponent ?? (other.onClick ? 'button' : 'div');
   return /*#__PURE__*/React__default.createElement(ComponentTag, _extends({
     disabled: ComponentTag === 'button' ? disabled : null,
     className: tagClasses,
@@ -88,6 +90,11 @@ const Tag = _ref => {
   }, children !== null && children !== undefined ? children : TYPES[type]));
 };
 Tag.propTypes = {
+  /**
+   * Provide an alternative tag or component to use instead of the default
+   * wrapping element
+   */
+  as: PropTypes.elementType,
   /**
    * Provide content to be rendered inside of a <Tag>
    */

package/es/components/TextArea/TextArea.js

@@ -61,7 +61,7 @@ const TextArea = /*#__PURE__*/React__default.forwardRef((props, forwardRef) => {
       if (!other.disabled && onChange) {
         // delay textCount assignation to give the textarea element value time to catch up if is a controlled input
         setTimeout(() => {
-          setTextCount(evt.target.value?.length);
+          setTextCount(evt.target?.value?.length);
         }, 0);
         onChange(evt);
       }

package/es/components/Toggle/Toggle.d.ts

@@ -0,0 +1,129 @@
+/**
+ * Copyright IBM Corp. 2021, 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.
+ */
+import React, { KeyboardEventHandler, MouseEventHandler } from 'react';
+import PropTypes from 'prop-types';
+type ExcludedAttributes = 'aria-labelledby' | 'aria-checked' | 'type' | 'role' | 'id' | 'size' | 'onClick';
+export interface ToggleProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, ExcludedAttributes> {
+    /**
+     * Specify another element's id to be used as the label for this toggle
+     */
+    'aria-labelledby'?: string;
+    /**
+     * Provide an id that unique represents the underlying `<button>`
+     */
+    id: string;
+    /**
+     * Specify the label for the "off" position
+     */
+    labelA?: string | undefined;
+    /**
+     * Specify the label for the "on" position
+     */
+    labelB?: string | undefined;
+    /**
+     * Provide the text that will be read by a screen reader when visiting this
+     * control. This should be provided unless 'aria-labelledby' is set instead
+     * or you use an external <label> element with its "for" attribute set to the
+     * toggle's id.
+     */
+    labelText?: string | undefined;
+    /**
+     * If true, the side labels (props.labelA and props.labelB) will be replaced by
+     * props.labelText (if passed), so that the toggle doesn't render a top label.
+     */
+    hideLabel?: boolean;
+    /**
+     * Provide an event listener that is called when the control is toggled
+     */
+    onClick: MouseEventHandler<HTMLDivElement> | KeyboardEventHandler<HTMLDivElement> | undefined;
+    /**
+     * Provide an event listener that is called when the control is toggled
+     */
+    onToggle?(checked: boolean): void;
+    /**
+     * Specify the size of the Toggle. Currently only supports 'sm' or 'md' (default)
+     */
+    size?: 'sm' | 'md' | undefined;
+    /**
+     * Whether the toggle should be read-only
+     */
+    readOnly?: boolean | undefined;
+    /**
+     * Specify whether the toggle should be on by default
+     */
+    defaultToggled?: boolean | undefined;
+    /**
+     * Specify whether the control is toggled
+     */
+    toggled?: boolean | undefined;
+}
+export declare function Toggle({ 'aria-labelledby': ariaLabelledby, className, defaultToggled, disabled, hideLabel, id, labelA, labelB, labelText, onClick, onToggle, readOnly, size, toggled, ...other }: ToggleProps): JSX.Element;
+export declare namespace Toggle {
+    var propTypes: {
+        /**
+         * Specify another element's id to be used as the label for this toggle
+         */
+        'aria-labelledby': PropTypes.Requireable<string>;
+        /**
+         * Specify a custom className to apply to the form-item node
+         */
+        className: PropTypes.Requireable<string>;
+        /**
+         * Specify whether the toggle should be on by default
+         */
+        defaultToggled: PropTypes.Requireable<boolean>;
+        /**
+         * Whether this control should be disabled
+         */
+        disabled: PropTypes.Requireable<boolean>;
+        /**
+         * If true, the side labels (props.labelA and props.labelB) will be replaced by
+         * props.labelText (if passed), so that the toggle doesn't render a top label.
+         */
+        hideLabel: PropTypes.Requireable<boolean>;
+        /**
+         * Provide an id that unique represents the underlying `<button>`
+         */
+        id: PropTypes.Validator<string>;
+        /**
+         * Specify the label for the "off" position
+         */
+        labelA: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        /**
+         * Specify the label for the "on" position
+         */
+        labelB: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        /**
+         * Provide the text that will be read by a screen reader when visiting this
+         * control. This should be provided unless 'aria-labelledby' is set instead
+         * or you use an external <label> element with its "for" attribute set to the
+         * toggle's id.
+         */
+        labelText: PropTypes.Requireable<string>;
+        /**
+         * Provide an event listener that is called when the control is clicked
+         */
+        onClick: PropTypes.Requireable<(...args: any[]) => any>;
+        /**
+         * Provide an event listener that is called when the control is toggled
+         */
+        onToggle: PropTypes.Requireable<(...args: any[]) => any>;
+        /**
+         * Whether the toggle should be read-only
+         */
+        readOnly: PropTypes.Requireable<boolean>;
+        /**
+         * Specify the size of the Toggle. Currently only supports 'sm' or 'md' (default)
+         */
+        size: PropTypes.Requireable<string>;
+        /**
+         * Specify whether the control is toggled
+         */
+        toggled: PropTypes.Requireable<boolean>;
+    };
+}
+export default Toggle;

package/es/components/Toggle/Toggle.js

@@ -78,7 +78,7 @@ function Toggle(_ref) {
           handleClick(e);
           buttonElement.current.focus();
         }
-      } : null
+      } : undefined
     }, /*#__PURE__*/React__default.createElement("button", _extends({}, other, {
       ref: buttonElement,
       id: id,
@@ -90,7 +90,7 @@ function Toggle(_ref) {
       disabled: disabled,
       onClick: handleClick
     })), /*#__PURE__*/React__default.createElement(LabelComponent, {
-      htmlFor: ariaLabelledby ? null : id,
+      htmlFor: ariaLabelledby ? undefined : id,
       className: `${prefix}--toggle__label`
     }, labelText && /*#__PURE__*/React__default.createElement("span", {
       className: labelTextClasses

package/es/components/Toggle/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 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.
+ */
+import { default as Toggle, ToggleProps } from './Toggle';
+export * from './Toggle.Skeleton';
+export default Toggle;
+export { Toggle };
+export type { ToggleProps };

package/es/components/UIShell/HeaderMenu.js

@@ -26,6 +26,9 @@ class HeaderMenu extends React__default.Component {
   constructor(props) {
     super(props);
     _defineProperty(this, "_subMenus", /*#__PURE__*/React__default.createRef());
+    /**
+     * Toggle the expanded state of the menu on click.
+     */
     _defineProperty(this, "handleOnClick", e => {
       const {
         current: subMenusNode
@@ -37,6 +40,9 @@ class HeaderMenu extends React__default.Component {
         expanded: !prevState.expanded
       }));
     });
+    /**
+     * Keyboard event handler for the entire menu.
+     */
     _defineProperty(this, "handleOnKeyDown", event => {
       // Handle enter or space key for toggling the expanded state of the menu.
       if (matches(event, [Enter, Space])) {
@@ -48,6 +54,11 @@ class HeaderMenu extends React__default.Component {
         return;
       }
     });
+    /**
+     * Handle our blur event from our underlying menuitems. Will mostly be used
+     * for toggling the expansion status of our menu in response to a user
+     * clicking off of the menu or menubar.
+     */
     _defineProperty(this, "handleOnBlur", event => {
       // Rough guess for a blur event that is triggered outside of our menu or
       // menubar context
@@ -60,12 +71,24 @@ class HeaderMenu extends React__default.Component {
         selectedIndex: null
       });
     });
+    /**
+     * ref handler for our menu button. If we are supplied a `focusRef` prop, we also
+     * forward along the node.
+     *
+     * This is useful when this component is a child in a
+     * menu or menubar as it will allow the parent to explicitly focus the menu
+     * button node when that child should receive focus.
+     */
     _defineProperty(this, "handleMenuButtonRef", node => {
       if (this.props.focusRef) {
         this.props.focusRef(node);
       }
       this.menuButtonRef = node;
     });
+    /**
+     * Handles individual menuitem refs. We assign them to a class instance
+     * property so that we can properly manage focus of our children.
+     */
     _defineProperty(this, "handleItemRef", index => node => {
       this.items[index] = node;
     });
@@ -84,6 +107,12 @@ class HeaderMenu extends React__default.Component {
         return;
       }
     });
+    /**
+     * We capture the `ref` for each child inside of `this.items` to properly
+     * manage focus. In addition to this focus management, all items receive a
+     * `tabIndex: -1` so the user won't hit a large number of items in their tab
+     * sequence when they might not want to go through all the items.
+     */
     _defineProperty(this, "_renderMenuItem", (item, index) => {
       if ( /*#__PURE__*/React__default.isValidElement(item)) {
         return /*#__PURE__*/React__default.cloneElement(item, {
@@ -100,35 +129,6 @@ class HeaderMenu extends React__default.Component {
     };
     this.items = [];
   }
-
-  /**
-   * Toggle the expanded state of the menu on click.
-   */
-
-  /**
-   * Keyboard event handler for the entire menu.
-   */
-
-  /**
-   * Handle our blur event from our underlying menuitems. Will mostly be used
-   * for toggling the expansion status of our menu in response to a user
-   * clicking off of the menu or menubar.
-   */
-
-  /**
-   * ref handler for our menu button. If we are supplied a `focusRef` prop, we also
-   * forward along the node.
-   *
-   * This is useful when this component is a child in a
-   * menu or menubar as it will allow the parent to explicitly focus the menu
-   * button node when that child should receive focus.
-   */
-
-  /**
-   * Handles individual menuitem refs. We assign them to a class instance
-   * property so that we can properly manage focus of our children.
-   */
-
   render() {
     const prefix = this.context;
     const {
@@ -191,13 +191,6 @@ class HeaderMenu extends React__default.Component {
       className: `${prefix}--header__menu`
     }), React__default.Children.map(children, this._renderMenuItem)));
   }
-
-  /**
-   * We capture the `ref` for each child inside of `this.items` to properly
-   * manage focus. In addition to this focus management, all items receive a
-   * `tabIndex: -1` so the user won't hit a large number of items in their tab
-   * sequence when they might not want to go through all the items.
-   */
 }
 _defineProperty(HeaderMenu, "propTypes", {
   /**

package/es/components/UIShell/HeaderMenuButton.d.ts

@@ -28,6 +28,10 @@ declare namespace HeaderMenuButton {
          * Specify whether the menu button is "active".
          */
         isActive: PropTypes.Requireable<boolean>;
+        /**
+         * Specify whether the menu button is collapsible.
+         */
+        isCollapsible: PropTypes.Requireable<boolean>;
         /**
          * Optionally provide an onClick handler that is called when the underlying
          * button fires it's onclick event

package/es/components/UIShell/HeaderMenuButton.js

@@ -64,6 +64,10 @@ HeaderMenuButton.propTypes = {
    * Specify whether the menu button is "active".
    */
   isActive: PropTypes.bool,
+  /**
+   * Specify whether the menu button is collapsible.
+   */
+  isCollapsible: PropTypes.bool,
   /**
    * Optionally provide an onClick handler that is called when the underlying
    * button fires it's onclick event

package/es/components/UIShell/HeaderName.d.ts

@@ -0,0 +1,39 @@
+/**
+ * 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.
+ */
+import { type ElementType } from 'react';
+import PropTypes from 'prop-types';
+import { type LinkProps } from './Link';
+type HeaderNameProps<E extends ElementType> = LinkProps<E> & {
+    prefix?: string | undefined;
+};
+declare function HeaderName<E extends ElementType = 'a'>({ children, className: customClassName, prefix, ...rest }: HeaderNameProps<E>): JSX.Element;
+declare namespace HeaderName {
+    var propTypes: {
+        /**
+         * Pass in children that are either a string or can be read as a string by
+         * screen readers
+         */
+        children: PropTypes.Validator<NonNullable<PropTypes.ReactNodeLike>>;
+        /**
+         * Optionally provide a custom class to apply to the underlying `<li>` node
+         */
+        className: PropTypes.Requireable<string>;
+        /**
+         * Provide an href for the name to link to
+         */
+        href: PropTypes.Requireable<string>;
+        /**
+         * Optionally specify a prefix to your header name. Useful for companies, for
+         * example: IBM [Product Name] versus solely [Product Name]
+         */
+        prefix: PropTypes.Requireable<string>;
+        as: PropTypes.Requireable<PropTypes.ReactComponentLike>;
+        element: (props: any, propName: any, componentName: any, ...rest: any[]) => any;
+        isSideNavExpanded: PropTypes.Requireable<boolean>;
+    };
+}
+export default HeaderName;

package/es/components/UIShell/HeaderName.js

@@ -16,15 +16,13 @@ function HeaderName(_ref) {
   let {
     children,
     className: customClassName,
-    prefix,
-    href,
+    prefix = 'IBM',
     ...rest
   } = _ref;
   const selectorPrefix = usePrefix();
   const className = cx(`${selectorPrefix}--header__name`, customClassName);
   return /*#__PURE__*/React__default.createElement(Link, _extends({}, rest, {
-    className: className,
-    href: href
+    className: className
   }), prefix && /*#__PURE__*/React__default.createElement(React__default.Fragment, null, /*#__PURE__*/React__default.createElement("span", {
     className: `${selectorPrefix}--header__name--prefix`
   }, prefix), "\xA0"), children);
@@ -54,8 +52,5 @@ HeaderName.propTypes = {
    */
   prefix: PropTypes.string
 };
-HeaderName.defaultProps = {
-  prefix: 'IBM'
-};
 
 export { HeaderName as default };

package/es/components/UIShell/HeaderPanel.js

@@ -39,7 +39,7 @@ const HeaderPanel = /*#__PURE__*/React__default.forwardRef(function HeaderPanel(
   const eventHandlers = {};
   if (addFocusListeners) {
     eventHandlers.onBlur = event => {
-      if (!event.currentTarget.contains(event.relatedTarget) && !lastClickedElement.classList.contains('cds--switcher__item-link')) {
+      if (!event.currentTarget.contains(event.relatedTarget) && !lastClickedElement?.classList?.contains('cds--switcher__item-link')) {
         setExpandedState(false);
         setLastClickedElement(null);
         if (expanded) {
@@ -60,7 +60,7 @@ const HeaderPanel = /*#__PURE__*/React__default.forwardRef(function HeaderPanel(
   useWindowEvent('click', () => {
     const focusedElement = document.activeElement;
     setLastClickedElement(focusedElement);
-    if (children.type.__docgenInfo.displayName === 'Switcher' && !focusedElement?.closest(`.${prefix}--header-panel--expanded`) && !focusedElement?.closest(`.${prefix}--header__action`) && !headerPanelRef?.current?.classList.contains(`${prefix}--switcher`) && expanded) {
+    if (children.type?.displayName === 'Switcher' && !focusedElement?.closest(`.${prefix}--header-panel--expanded`) && !focusedElement?.closest(`.${prefix}--header__action`) && !headerPanelRef?.current?.classList.contains(`${prefix}--switcher`) && expanded) {
       setExpandedState(false);
       onHeaderPanelFocus();
     }

package/es/components/UIShell/Link.js

@@ -55,5 +55,6 @@ const LinkPropTypes = {
 };
 Link.displayName = 'Link';
 Link.propTypes = LinkPropTypes;
+var Link$1 = Link;
 
-export { LinkPropTypes, Link as default };
+export { LinkPropTypes, Link$1 as default };

package/es/components/UIShell/Switcher.js

@@ -57,12 +57,23 @@ const Switcher = /*#__PURE__*/React__default.forwardRef(function Switcher(props,
     const switcherItem = switcherRef.current.children[nextValidIndex].children[0];
     switcherItem?.focus();
   };
-  const childrenWithProps = React__default.Children.toArray(children).map((child, index) => /*#__PURE__*/React__default.cloneElement(child, {
-    handleSwitcherItemFocus,
-    index,
-    key: index,
-    expanded
-  }));
+  const childrenWithProps = React__default.Children.toArray(children).map((child, index) => {
+    // handleSwitcherItemFocus should only be passed down if the child is a SwitcherItem
+    // SwitcherDivider, for example, does not accept a handleSwitcherItemFocus prop
+    if (child.type?.displayName === 'SwitcherItem') {
+      return /*#__PURE__*/React__default.cloneElement(child, {
+        handleSwitcherItemFocus,
+        index,
+        key: index,
+        expanded
+      });
+    }
+    return /*#__PURE__*/React__default.cloneElement(child, {
+      index,
+      key: index,
+      expanded
+    });
+  });
   return /*#__PURE__*/React__default.createElement("ul", _extends({
     ref: ref,
     className: className

package/es/index.js

@@ -59,6 +59,7 @@ export { default as TextAreaSkeleton } from './components/TextArea/TextArea.Skel
 import './components/TextInput/index.js';
 export { ClickableTile, ExpandableTile, SelectableTile, Tile, TileAboveTheFoldContent, TileBelowTheFoldContent } from './components/Tile/Tile.js';
 export { default as TileGroup } from './components/TileGroup/index.js';
+export { Toggle } from './components/Toggle/Toggle.js';
 export { default as ToggleSkeleton } from './components/Toggle/Toggle.Skeleton.js';
 export { default as ToggleSmallSkeleton } from './components/ToggleSmall/ToggleSmall.Skeleton.js';
 export { Toggletip, ToggletipActions, ToggletipButton, ToggletipContent, ToggletipLabel } from './components/Toggletip/index.js';
@@ -110,7 +111,6 @@ export { default as NumberInputSkeleton } from './components/NumberInput/NumberI
 export { default as ProgressIndicatorSkeleton } from './components/ProgressIndicator/ProgressIndicator.Skeleton.js';
 export { default as TextInputSkeleton } from './components/TextInput/TextInput.Skeleton.js';
 export { default as TextInput } from './components/TextInput/TextInput.js';
-export { Toggle } from './components/Toggle/Toggle.js';
 export { default as TreeNode } from './components/TreeView/TreeNode.js';
 export { default as TreeView } from './components/TreeView/TreeView.js';
 export { default as HeaderContainer } from './components/UIShell/HeaderContainer.js';

package/es/internal/FloatingMenu.js

@@ -142,6 +142,7 @@ class FloatingMenu extends React__default.Component {
     var _this;
     super(...arguments);
     _this = this;
+    // `true` if the menu body is mounted and calculation of the position is in progress.
     _defineProperty(this, "_placeInProgress", false);
     _defineProperty(this, "state", {
       /**
@@ -150,10 +151,36 @@ class FloatingMenu extends React__default.Component {
        */
       floatingPosition: undefined
     });
+    /**
+     * The cached reference to the menu container.
+     * Only used if React portal API is not available.
+     * @type {Element}
+     * @private
+     */
     _defineProperty(this, "_menuContainer", null);
+    /**
+     * The cached reference to the menu body.
+     * The reference is set via callback ref instead of object ref,
+     * in order to hook the event when the element ref gets available,
+     * which can be at a different timing from `cDM()`, presumably with SSR scenario.
+     * @type {Element}
+     * @private
+     */
     _defineProperty(this, "_menuBody", null);
+    /**
+     * Focus sentinel refs for focus trap behavior
+     */
     _defineProperty(this, "startSentinel", /*#__PURE__*/React__default.createRef());
     _defineProperty(this, "endSentinel", /*#__PURE__*/React__default.createRef());
+    /**
+     * Calculates the position in the viewport of floating menu,
+     * once this component is mounted or updated upon change in the following props:
+     *
+     * * `menuOffset` (The adjustment that should be applied to the calculated floating menu's position)
+     * * `menuDirection` (Where the floating menu menu should be placed relative to the trigger button)
+     *
+     * @private
+     */
     _defineProperty(this, "_updateMenuSize", function () {
       let prevProps = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
       let isAdjustment = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
@@ -227,6 +254,11 @@ class FloatingMenu extends React__default.Component {
         }
       }
     });
+    /**
+     * Set focus on floating menu content after menu placement.
+     * @param {Element} menuBody The DOM element of the menu body.
+     * @private
+     */
     _defineProperty(this, "_focusMenuContent", menuBody => {
       const primaryFocusNode = menuBody.querySelector(this.props.selectorPrimaryFocus || null);
       const tabbableNode = menuBody.querySelector(selectorTabbable);
@@ -243,6 +275,10 @@ class FloatingMenu extends React__default.Component {
         process.env.NODE_ENV !== "production" ? warning(focusableNode === null, 'Floating Menus must have at least a programmatically focusable child. ' + 'This can be accomplished by adding tabIndex="-1" to the content element.') : void 0;
       }
     });
+    /**
+     * A callback for called when menu body is mounted or unmounted.
+     * @param {Element} menuBody The menu body being mounted. `null` if the menu body is being unmounted.
+     */
     _defineProperty(this, "_menuRef", menuBody => {
       const {
         menuRef
@@ -253,6 +289,10 @@ class FloatingMenu extends React__default.Component {
         this._updateMenuSize();
       }
     });
+    /**
+     * @returns The child nodes, with styles containing the floating menu position.
+     * @private
+     */
     _defineProperty(this, "_getChildrenWithProps", () => {
       const {
         styles,
@@ -281,6 +321,12 @@ class FloatingMenu extends React__default.Component {
         }
       });
     });
+    /**
+     * Blur handler for when focus wrap behavior is enabled
+     * @param {Event} event
+     * @param {Element} event.target previously focused node
+     * @param {Element} event.relatedTarget current focused node
+     */
     _defineProperty(this, "handleBlur", _ref2 => {
       let {
         target: oldActiveNode,
@@ -302,33 +348,7 @@ class FloatingMenu extends React__default.Component {
         });
       }
     });
-  } // `true` if the menu body is mounted and calculation of the position is in progress.
-  /**
-   * The cached reference to the menu container.
-   * Only used if React portal API is not available.
-   * @type {Element}
-   * @private
-   */
-  /**
-   * The cached reference to the menu body.
-   * The reference is set via callback ref instead of object ref,
-   * in order to hook the event when the element ref gets available,
-   * which can be at a different timing from `cDM()`, presumably with SSR scenario.
-   * @type {Element}
-   * @private
-   */
-  /**
-   * Focus sentinel refs for focus trap behavior
-   */
-  /**
-   * Calculates the position in the viewport of floating menu,
-   * once this component is mounted or updated upon change in the following props:
-   *
-   * * `menuOffset` (The adjustment that should be applied to the calculated floating menu's position)
-   * * `menuDirection` (Where the floating menu menu should be placed relative to the trigger button)
-   *
-   * @private
-   */
+  }
   componentWillUnmount() {
     this.hResize.release();
   }
@@ -337,12 +357,6 @@ class FloatingMenu extends React__default.Component {
       this._updateMenuSize();
     });
   }
-  /**
-   * Set focus on floating menu content after menu placement.
-   * @param {Element} menuBody The DOM element of the menu body.
-   * @private
-   */
-
   componentDidUpdate(prevProps) {
     this._updateMenuSize(prevProps);
     const {
@@ -358,24 +372,6 @@ class FloatingMenu extends React__default.Component {
       }
     }
   }
-
-  /**
-   * A callback for called when menu body is mounted or unmounted.
-   * @param {Element} menuBody The menu body being mounted. `null` if the menu body is being unmounted.
-   */
-
-  /**
-   * @returns The child nodes, with styles containing the floating menu position.
-   * @private
-   */
-
-  /**
-   * Blur handler for when focus wrap behavior is enabled
-   * @param {Event} event
-   * @param {Element} event.target previously focused node
-   * @param {Element} event.relatedTarget current focused node
-   */
-
   render() {
     const {
       context: prefix

package/es/internal/useControllableState.js

@@ -22,7 +22,7 @@ import { warning } from './warning.js';
  * @param {string} [config.name] - the name of the custom component
  * @param {any} config.defaultValue - the default value used for the state. This will be
  * the fallback value used if `value` is not defined.
- * @param {Function} config.onChange - an optional function that is called when
+ * @param {Function|undefined} config.onChange - an optional function that is called when
  * the value of the state changes. This is useful for communicating to parents of
  * controlled components that the value is requesting to be changed.
  * @param {any} config.value - a controlled value. Omitting this means that the state is