@carbon/react 1.79.0 → 1.80.0

package/es/internal/ClickListener.js

@@ -5,70 +5,43 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import { defineProperty as _defineProperty } from '../_virtual/_rollupPluginBabelHelpers.js';
-import PropTypes from 'prop-types';
-import React__default from 'react';
+import { useRef, useEffect, cloneElement } from 'react';
 
-/**
- * Generic component used for reacting to a click event happening outside of a
- * given `children` element.
- */
-class ClickListener extends React__default.Component {
-  static getEventTarget(evt) {
-    // support Shadow DOM
-    if (evt.composed && typeof evt.composedPath === 'function') {
-      return evt.composedPath()[0];
+const ClickListener = _ref => {
+  let {
+    children,
+    onClickOutside
+  } = _ref;
+  const elementRef = useRef(null);
+  const getEventTarget = event => {
+    if (event.composed && typeof event.composedPath === 'function') {
+      return event.composedPath()[0];
     }
-    return evt.target;
-  }
-  constructor(props) {
-    super(props);
-    // We manually bind handlers in this Component, versus using class
-    // properties, so that we can properly test the `handleRef` handler.
-    this.handleRef = this.handleRef.bind(this);
-    this.handleDocumentClick = this.handleDocumentClick.bind(this);
-  }
-  componentDidMount() {
-    document.addEventListener('click', this.handleDocumentClick);
-  }
-  componentWillUnmount() {
-    document.removeEventListener('click', this.handleDocumentClick);
-  }
-  handleDocumentClick(evt) {
-    if (this.element) {
-      if (this.element.contains && !this.element.contains(ClickListener.getEventTarget(evt))) {
-        this.props.onClickOutside(evt);
+    return event.target;
+  };
+  const handleDocumentClick = event => {
+    if (elementRef.current?.contains) {
+      const eventTarget = getEventTarget(event);
+      if (eventTarget instanceof Node && !elementRef.current.contains(eventTarget)) {
+        onClickOutside(event);
       }
     }
-  }
-  handleRef(el) {
-    const {
-      children
-    } = this.props;
-    this.element = el;
-
-    /**
-     * One important note, `children.ref` corresponds to a `ref` prop passed in
-     * directly to the child, not necessarily a `ref` defined in the component.
-     * This means that here we target the following `ref` location:
-     *
-     * <ClickListener onClickOutside={() => {}}>
-     *   <Child ref={targetedRefHere} />
-     * </ClickListener>
-     */
-    if (children.ref && typeof children.ref === 'function') {
+  };
+  useEffect(() => {
+    document.addEventListener('click', handleDocumentClick);
+    return () => {
+      document.removeEventListener('click', handleDocumentClick);
+    };
+  }, [onClickOutside]);
+  const handleRef = el => {
+    elementRef.current = el;
+    if ('ref' in children && typeof children.ref === 'function') {
       children.ref(el);
     }
-  }
-  render() {
-    return /*#__PURE__*/React__default.cloneElement(this.props.children, {
-      ref: this.handleRef
-    });
-  }
-}
-_defineProperty(ClickListener, "propTypes", {
-  children: PropTypes.element.isRequired,
-  onClickOutside: PropTypes.func.isRequired
-});
+  };
+  return /*#__PURE__*/cloneElement(children, {
+    ref: handleRef
+  });
+};
 
-export { ClickListener as default };
+export { ClickListener };

package/es/internal/FloatingMenu.js

@@ -104,7 +104,7 @@ const FloatingMenu = _ref2 => {
   const updateMenuPosition = useCallback(isAdjustment => {
     const menuBody = menuBodyRef.current;
     if (!menuBody) {
-      process.env.NODE_ENV !== "production" ? warning(menuBody, 'The DOM node for menu body for calculating its position is not available. Skipping...') : void 0;
+      process.env.NODE_ENV !== "production" ? warning(!!menuBody, 'The DOM node for menu body for calculating its position is not available. Skipping...') : void 0;
       return;
     }
     const triggerEl = triggerRef.current;
@@ -174,7 +174,7 @@ const FloatingMenu = _ref2 => {
     // First programmatic focusable node
     menuBody;
     focusTarget.focus();
-    if (focusTarget === menuBody && process.env.NODE_ENV !== "production") {
+    if (focusTarget === menuBody) {
       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;
     }
   };

package/es/internal/PolymorphicProps.d.ts

@@ -1,3 +1,9 @@
+/**
+ * Copyright IBM Corp. 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.
+ */
 type AsProp<C extends React.ElementType> = {
     as?: C;
 };

package/es/internal/deprecateFieldOnObject.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 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 deprecateFieldOnObject: <T extends {
+    displayName?: string;
+}>(object: T, field: string, Component: {
+    displayName?: string;
+    name?: string;
+}, message?: string) => void;

package/es/internal/deprecateFieldOnObject.js

@@ -7,11 +7,11 @@
 
 import { warning } from './warning.js';
 
-const didWarnAboutDeprecation = {};
-function deprecateFieldOnObject(object, field, Component, message) {
+const deprecateFieldOnObject = (object, field, Component, message) => {
+  const didWarnAboutDeprecation = {};
   Object.defineProperty(object, field, {
     enumerable: true,
-    get() {
+    get: () => {
       if (!didWarnAboutDeprecation[field]) {
         process.env.NODE_ENV !== "production" ? warning(false, message || `The ${field} field has been deprecated on the ${object.displayName} object. ` + `Please import and use ${Component.displayName || Component.name || 'the field'} directly.`) : void 0;
         didWarnAboutDeprecation[field] = true;
@@ -19,6 +19,6 @@ function deprecateFieldOnObject(object, field, Component, message) {
       return Component;
     }
   });
-}
+};
 
 export { deprecateFieldOnObject };

package/es/internal/useControllableState.d.ts

@@ -0,0 +1,34 @@
+/**
+ * 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.
+ */
+interface UseControllableStateConfig<T> {
+    /** The name of the component. */
+    name?: string;
+    /**
+     * The default value for the component. This value is used when the component
+     * is uncontrolled (i.e., when `value` is not provided).
+     */
+    defaultValue: T;
+    /**
+     * This callback is called whenever the state changes. It's useful for
+     * communicating state updates to parent components of controlled components.
+     */
+    onChange?: (value: T) => void;
+    /**
+     * Controlled value. If this prop is omitted, the state will be uncontrolled.
+     */
+    value?: T;
+}
+/**
+ * This hook simplifies the behavior of a component that has state which can be
+ * both controlled and uncontrolled. It works like `useState`. You can use the
+ * `onChange` callback to communicate state updates to parent components.
+ *
+ * Note: This hook will warn if the component switches between controlled and
+ * uncontrolled states.
+ */
+export declare const useControllableState: <T>({ defaultValue, name, onChange, value, }: UseControllableStateConfig<T>) => [T, (stateOrUpdater: T | ((prev: T) => T)) => void];
+export {};

package/es/internal/useControllableState.js

@@ -9,66 +9,51 @@ import { useState, useRef, useEffect } from 'react';
 import { warning } from './warning.js';
 
 /**
- * This custom hook simplifies the behavior of a component if it has state that
- * can be both controlled and uncontrolled. It functions identical to a
- * useState() hook and provides [state, setState] for you to use. You can use
- * the `onChange` argument to allow updates to the `state` to be communicated to
- * owners of controlled components.
+ * This hook simplifies the behavior of a component that has state which can be
+ * both controlled and uncontrolled. It works like `useState`. You can use the
+ * `onChange` callback to communicate state updates to parent components.
  *
- * Note: this hook will warn if a component is switching from controlled to
- * uncontrolled, or vice-versa.
- *
- * @param {object} config
- * @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|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
- * uncontrolled
- * @returns {[any, (v: any) => void]}
+ * Note: This hook will warn if the component switches between controlled and
+ * uncontrolled states.
  */
-function useControllableState(_ref) {
+const useControllableState = _ref => {
   let {
     defaultValue,
     name = 'custom',
     onChange,
     value
   } = _ref;
-  const [state, internalSetState] = useState(value ?? defaultValue);
+  const [state, internalSetState] = useState(typeof value !== 'undefined' ? value : defaultValue);
   const controlled = useRef(null);
   if (controlled.current === null) {
-    controlled.current = value !== undefined;
+    controlled.current = typeof value !== 'undefined';
   }
-  function setState(stateOrUpdater) {
-    const value = typeof stateOrUpdater === 'function' ? stateOrUpdater(state) : stateOrUpdater;
+  const setState = stateOrUpdater => {
+    const newValue = typeof stateOrUpdater === 'function' ? stateOrUpdater(state) : stateOrUpdater;
     if (controlled.current === false) {
-      internalSetState(value);
+      internalSetState(newValue);
     }
     if (onChange) {
-      onChange(value);
+      onChange(newValue);
     }
-  }
+  };
   useEffect(() => {
-    const controlledValue = value !== undefined;
+    const controlledValue = typeof value !== 'undefined';
 
     // Uncontrolled -> Controlled
-    // If the component prop is uncontrolled, the prop value should be undefined
     if (controlled.current === false && controlledValue) {
-      process.env.NODE_ENV !== "production" ? warning(false, 'A component is changing an uncontrolled %s component to be controlled. ' + 'This is likely caused by the value changing to a defined value ' + 'from undefined. Decide between using a controlled or uncontrolled ' + 'value for the lifetime of the component. ' + 'More info: https://reactjs.org/link/controlled-components', name) : void 0;
+      process.env.NODE_ENV !== "production" ? warning(false, `A component is changing an uncontrolled ${name} component to be controlled. ` + 'This is likely caused by the value changing to a defined value ' + 'from undefined. Decide between using a controlled or uncontrolled ' + 'value for the lifetime of the component. ' + 'More info: https://reactjs.org/link/controlled-components') : void 0;
     }
 
     // Controlled -> Uncontrolled
-    // If the component prop is controlled, the prop value should be defined
     if (controlled.current === true && !controlledValue) {
-      process.env.NODE_ENV !== "production" ? warning(false, 'A component is changing a controlled %s component to be uncontrolled. ' + 'This is likely caused by the value changing to an undefined value ' + 'from a defined one. Decide between using a controlled or ' + 'uncontrolled value for the lifetime of the component. ' + 'More info: https://reactjs.org/link/controlled-components', name) : void 0;
+      process.env.NODE_ENV !== "production" ? warning(false, `A component is changing a controlled ${name} component to be uncontrolled. ` + 'This is likely caused by the value changing to an undefined value ' + 'from a defined one. Decide between using a controlled or ' + 'uncontrolled value for the lifetime of the component. ' + 'More info: https://reactjs.org/link/controlled-components') : void 0;
     }
   }, [name, value]);
   if (controlled.current === true) {
     return [value, setState];
   }
   return [state, setState];
-}
+};
 
 export { useControllableState };

package/es/internal/useEvent.js

@@ -7,7 +7,7 @@
 
 import { useRef, useEffect } from 'react';
 
-/* eslint-disable jsdoc/check-tag-names */
+// @ts-check
 
 /**
  * @template {keyof GlobalEventHandlersEventMap} E

package/es/internal/useMergedRefs.d.ts

@@ -1,13 +1,16 @@
 /**
- * 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 { Ref, ForwardedRef } from 'react';
+import { type ForwardedRef, type Ref } from 'react';
 /**
- * Combine multiple refs into a single ref. This use useful when you have two
- * refs from both `React.forwardRef` and `useRef` that you would like to add to
- * the same node.
+ * Merges multiple refs into a single callback ref.
+ *
+ * This hook is useful when you need to attach multiple refs (for example, a ref
+ * passed from `forwardRef` and a local ref from `useRef`) to the same node. It
+ * accepts an array of refs and returns a callback ref that, when attached to a
+ * node, assigns that node to every ref in the array.
  */
-export declare const useMergedRefs: <T extends unknown>(refs: ForwardedRef<T>[]) => Ref<T>;
+export declare const useMergedRefs: <T>(refs: ForwardedRef<T>[]) => Ref<T>;

package/es/internal/useMergedRefs.js

@@ -7,25 +7,24 @@
 
 import { useCallback } from 'react';
 
-// TODO: Investigate updating this hook based on the following code from
-// https://github.com/carbon-design-system/carbon/pull/18611:
-// https://github.com/adamalston/carbon/blob/dd403b6b10de3d8a6ccd8d2e21174c908c1e890a/packages/react/src/components/ListBox/ListBoxMenuItem.tsx#L23-L46
 /**
- * Combine multiple refs into a single ref. This use useful when you have two
- * refs from both `React.forwardRef` and `useRef` that you would like to add to
- * the same node.
+ * Merges multiple refs into a single callback ref.
+ *
+ * This hook is useful when you need to attach multiple refs (for example, a ref
+ * passed from `forwardRef` and a local ref from `useRef`) to the same node. It
+ * accepts an array of refs and returns a callback ref that, when attached to a
+ * node, assigns that node to every ref in the array.
  */
 const useMergedRefs = refs => {
   return useCallback(node => {
     refs.forEach(ref => {
       if (typeof ref === 'function') {
         ref(node);
-      } else if (ref !== null && ref !== undefined) {
+      } else if (ref) {
         ref.current = node;
       }
     });
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, refs);
+  }, [refs]);
 };
 
 export { useMergedRefs };

package/es/internal/useNoInteractiveChildren.js

@@ -9,7 +9,7 @@ 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") {
+  if (process.env.NODE_ENV !== 'production') {
     // eslint-disable-next-line react-hooks/rules-of-hooks
     useEffect(() => {
       const node = ref.current ? getInteractiveContent(ref.current) : false;
@@ -21,7 +21,7 @@ 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") {
+  if (process.env.NODE_ENV !== 'production') {
     // eslint-disable-next-line react-hooks/rules-of-hooks
     useEffect(() => {
       const node = ref.current ? getInteractiveContent(ref.current) : false;

package/es/internal/useOutsideClick.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 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 RefObject } from 'react';
+export declare const useOutsideClick: <T extends HTMLElement>(ref: RefObject<T>, callback: (event: MouseEvent) => void) => void;

package/es/internal/useOutsideClick.js

@@ -6,26 +6,29 @@
  */
 
 import { useRef, useEffect } from 'react';
-import { useEvent } from './useEvent.js';
 import { canUseDOM } from './environment.js';
+import { useWindowEvent } from './useEvent.js';
 
-function useOutsideClick(ref, callback) {
+const useOutsideClick = (ref, callback) => {
   const savedCallback = useRef(callback);
   useEffect(() => {
     savedCallback.current = callback;
-  });
+  }, [callback]);
 
   // We conditionally guard the `useEvent` hook for SSR. `canUseDOM` can be
   // 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) {
     // eslint-disable-next-line react-hooks/rules-of-hooks
-    useEvent(window, 'click', event => {
-      if (ref.current && !ref.current.contains(event.target)) {
+    useWindowEvent('click', event => {
+      const {
+        target
+      } = event;
+      if (target instanceof Node && ref.current && !ref.current.contains(target)) {
         savedCallback.current(event);
       }
     });
   }
-}
+};
 
 export { useOutsideClick };

package/es/internal/useSavedCallback.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.
+ */
+/**
+ * Returns a stable callback reference that always points to the latest version
+ * of a callback. This is useful when you want to avoid including the callback
+ * in dependency arrays while still ensuring the latest callback implementation
+ * is used.
+ *
+ * @param callback - The callback to track.
+ */
+export declare const useSavedCallback: <T extends (...args: any[]) => any>(callback: T | undefined) => (...args: Parameters<T>) => ReturnType<T> | undefined;

package/es/internal/useSavedCallback.js

@@ -8,24 +8,21 @@
 import { useRef, useEffect, useCallback } from 'react';
 
 /**
- * Provide a stable reference for a callback that is passed as a prop to a
- * component. This is helpful when you want access to the latest version of a
- * callback prop but don't want it to be added to the dependency array of an
- * effect.
+ * Returns a stable callback reference that always points to the latest version
+ * of a callback. This is useful when you want to avoid including the callback
+ * in dependency arrays while still ensuring the latest callback implementation
+ * is used.
  *
- * @param {Function | undefined} callback
- * @returns {Function}
+ * @param callback - The callback to track.
  */
-function useSavedCallback(callback) {
+const useSavedCallback = callback => {
   const savedCallback = useRef(callback);
   useEffect(() => {
     savedCallback.current = callback;
-  });
+  }, [callback]);
   return useCallback(function () {
-    if (savedCallback.current) {
-      return savedCallback.current(...arguments);
-    }
+    return savedCallback.current ? savedCallback.current(...arguments) : undefined;
   }, []);
-}
+};
 
 export { useSavedCallback };

package/es/internal/warning.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.
+ */
+/**
+ * Logs a warning.
+ *
+ * The warning is only logged if the condition is not met and
+ * `process.env.NODE_ENV !== 'production'` is truthy.
+ *
+ * @param condition - Condition to evaluate.
+ * @param message - Warning message.
+ * @throws Error if no `message` is provided.
+ */
+export declare const warning: (condition: boolean, message: string) => void;

package/es/internal/warning.js

@@ -5,21 +5,25 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-const emptyFunction = function () {};
-const warning = process.env.NODE_ENV !== "production" ? function warning(condition, format) {
-  for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
-    args[_key - 2] = arguments[_key];
-  }
-  if (format === undefined) {
-    throw new Error('`warning(condition, format, ...args)` requires a warning ' + 'format argument');
+import { noopFn } from './noopFn.js';
+
+/**
+ * Logs a warning.
+ *
+ * The warning is only logged if the condition is not met and
+ * `process.env.NODE_ENV !== 'production'` is truthy.
+ *
+ * @param condition - Condition to evaluate.
+ * @param message - Warning message.
+ * @throws Error if no `message` is provided.
+ */
+const warning = process.env.NODE_ENV !== 'production' ? (condition, message) => {
+  if (typeof message === 'undefined') {
+    throw new Error('`warning(condition, message)` requires a warning ' + 'format argument');
   }
   if (!condition) {
-    let index = 0;
-    const message = format.replace(/%s/g, () => {
-      return args[index++];
-    });
     console.warn('Warning: ' + message);
   }
-} : emptyFunction;
+} : noopFn;
 
 export { warning };

package/es/internal/wrapFocus.js

@@ -75,7 +75,7 @@ function wrapFocusWithoutSentinels(_ref2) {
     currentActiveNode,
     event
   } = _ref2;
-  if (['blur', 'focusout', 'focusin', 'focus'].includes(event.type) && process.env.NODE_ENV !== "production") {
+  if (['blur', 'focusout', 'focusin', 'focus'].includes(event.type) && process.env.NODE_ENV !== 'production') {
     // eslint-disable-next-line react-hooks/rules-of-hooks
     useEffect(() => {
       throw new Error(`Error: wrapFocusWithoutSentinels(...) called in unsupported ${event.type} event.\n\nCall wrapFocusWithoutSentinels(...) from onKeyDown instead.`);

package/es/prop-types/isRequiredOneOf.js

@@ -14,7 +14,7 @@
 function isRequiredOneOf(propTypes) {
   const names = Object.keys(propTypes);
   const checker = propType => function (props, propName, componentName) {
-    if (process.env.NODE_ENV !== "production" && names.every(name => typeof props[name] === 'undefined')) {
+    if (process.env.NODE_ENV !== 'production' && names.every(name => typeof props[name] === 'undefined')) {
       return new Error(`${componentName} requires one of the following props: ${names.join(', ')}`);
     }
     for (var _len = arguments.length, rest = new Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++) {

package/es/prop-types/requiredIfGivenPropIsTruthy.js

@@ -14,7 +14,7 @@
  */
 function requiredIfGivenPropIsTruthy(name, propType) {
   return function check(props, propName, componentName) {
-    if (process.env.NODE_ENV !== "production" && props[name] == true && props[propName] == null) {
+    if (process.env.NODE_ENV !== 'production' && props[name] == true && props[propName] == null) {
       return new Error(`You must provide a value for \`${propName}\` in \`${componentName}\` if \`${name}\` exists.`);
     }
     for (var _len = arguments.length, rest = new Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++) {

package/es/tools/events.js

@@ -5,12 +5,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-/**
- * 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.
- */
+// @ts-check
 
 /**
  * Generic utility to compose event handlers so that consumers can supply their

package/es/tools/toggleClass.js

@@ -5,6 +5,12 @@
  * LICENSE file in the root directory of this source tree.
  */
 
+/**
+ * Adds or removes a CSS class to an element.
+ * @param {Element} element An element.
+ * @param {string} name A CSS class name.
+ * @param {boolean} add `true` to add the given CSS class to given the element. Otherwise to remove.
+ */
 function toggleClass(element, name, add) {
   if (element.classList.contains(name) === !add) {
     element.classList[add ? 'add' : 'remove'](name);

package/es/types/common.d.ts

@@ -1,3 +1,9 @@
+/**
+ * Copyright IBM Corp. 2023, 2024
+ *
+ * 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 * 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>;

package/lib/components/CodeSnippet/CodeSnippet.js

@@ -13,7 +13,7 @@ var _rollupPluginBabelHelpers = require('../../_virtual/_rollupPluginBabelHelper
 var PropTypes = require('prop-types');
 var React = require('react');
 var cx = require('classnames');
-var useResizeObserver = require('use-resize-observer/polyfilled');
+var useResizeObserver = require('use-resize-observer');
 var iconsReact = require('@carbon/icons-react');
 var Copy = require('../Copy/Copy.js');
 var Button = require('../Button/Button.js');

package/lib/components/ComposedModal/ComposedModal.d.ts

@@ -1,3 +1,9 @@
+/**
+ * Copyright IBM Corp. 2023, 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, { type MouseEvent, type KeyboardEvent, type HTMLAttributes, type ReactNode, type RefObject } from 'react';
 export interface ModalBodyProps extends HTMLAttributes<HTMLDivElement> {
     /** Specify the content to be placed in the ModalBody. */

package/lib/components/ComposedModal/ModalFooter.d.ts

@@ -1,3 +1,9 @@
+/**
+ * Copyright IBM Corp. 2023, 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, { type ReactNode, type MouseEvent, type Ref } from 'react';
 import { InlineLoadingStatus } from '../InlineLoading/InlineLoading';
 export interface SecondaryButtonProps {