@carbon/react 1.70.0-rc.0 → 1.71.0-rc.0

package/lib/components/Dropdown/Dropdown.js

@@ -49,13 +49,50 @@ const defaultItemToString = item => {
   }
   return '';
 };
+/**
+ * Custom state reducer for `useSelect` in Downshift, providing control over
+ * state changes.
+ *
+ * This function is called each time `useSelect` updates its internal state or
+ * triggers `onStateChange`. It allows for fine-grained control of state
+ * updates by modifying or overriding the default changes from Downshift's
+ * reducer.
+ * https://github.com/downshift-js/downshift/tree/master/src/hooks/useSelect#statereducer
+ *
+ * @param {Object} state - The current full state of the Downshift component.
+ * @param {Object} actionAndChanges - Contains the action type and proposed
+ * changes from the default Downshift reducer.
+ * @param {Object} actionAndChanges.changes - Suggested state changes.
+ * @param {string} actionAndChanges.type - The action type for the state
+ * change (e.g., item selection).
+ * @returns {Object} - The modified state based on custom logic or default
+ * changes if no custom logic applies.
+ */
+function stateReducer(state, actionAndChanges) {
+  const {
+    changes,
+    type
+  } = actionAndChanges;
+  switch (type) {
+    case ItemMouseMove:
+    case MenuMouseLeave:
+      if (changes.highlightedIndex === state.highlightedIndex) {
+        // Prevent state update if highlightedIndex hasn't changed
+        return state;
+      }
+      return changes;
+    default:
+      return changes;
+  }
+}
 const Dropdown = /*#__PURE__*/React__default["default"].forwardRef((_ref, ref) => {
   let {
     autoAlign = false,
     className: containerClassName,
+    decorator,
     disabled = false,
     direction = 'bottom',
-    items,
+    items: itemsProp,
     label,
     ['aria-label']: ariaLabel,
     ariaLabel: deprecatedAriaLabel,
@@ -128,49 +165,47 @@ const Dropdown = /*#__PURE__*/React__default["default"].forwardRef((_ref, ref) =
   const {
     isFluid
   } = React.useContext(FormContext.FormContext);
-  const selectProps = {
+  const onSelectedItemChange = React.useCallback(_ref3 => {
+    let {
+      selectedItem
+    } = _ref3;
+    if (onChange) {
+      onChange({
+        selectedItem: selectedItem ?? null
+      });
+    }
+  }, [onChange]);
+  const isItemDisabled = React.useCallback((item, _index) => {
+    const isObject = item !== null && typeof item === 'object';
+    return isObject && 'disabled' in item && item.disabled === true;
+  }, []);
+  const onHighlightedIndexChange = React.useCallback(changes => {
+    const {
+      highlightedIndex
+    } = changes;
+    if (highlightedIndex !== undefined && highlightedIndex > -1 && typeof window !== undefined) {
+      const itemArray = document.querySelectorAll(`li.${prefix}--list-box__menu-item[role="option"]`);
+      const highlightedItem = itemArray[highlightedIndex];
+      if (highlightedItem) {
+        highlightedItem.scrollIntoView({
+          behavior: 'smooth',
+          block: 'nearest'
+        });
+      }
+    }
+  }, [prefix]);
+  const items = React.useMemo(() => itemsProp, [itemsProp]);
+  const selectProps = React.useMemo(() => ({
     items,
     itemToString,
     initialSelectedItem,
     onSelectedItemChange,
     stateReducer,
-    isItemDisabled(item, _index) {
-      const isObject = item !== null && typeof item === 'object';
-      return isObject && 'disabled' in item && item.disabled === true;
-    },
-    onHighlightedIndexChange: _ref3 => {
-      let {
-        highlightedIndex
-      } = _ref3;
-      if (highlightedIndex > -1 && typeof window !== undefined) {
-        const itemArray = document.querySelectorAll(`li.${prefix}--list-box__menu-item[role="option"]`);
-        const highlightedItem = itemArray[highlightedIndex];
-        if (highlightedItem) {
-          highlightedItem.scrollIntoView({
-            behavior: 'smooth',
-            block: 'nearest'
-          });
-        }
-      }
-    },
+    isItemDisabled,
+    onHighlightedIndexChange,
     ...downshiftProps
-  };
+  }), [items, itemToString, initialSelectedItem, onSelectedItemChange, stateReducer, isItemDisabled, onHighlightedIndexChange, downshiftProps]);
   const dropdownInstanceId = useId.useId();
-  function stateReducer(state, actionAndChanges) {
-    const {
-      changes,
-      type
-    } = actionAndChanges;
-    switch (type) {
-      case ItemMouseMove:
-      case MenuMouseLeave:
-        return {
-          ...changes,
-          highlightedIndex: state.highlightedIndex
-        };
-    }
-    return changes;
-  }
 
   // only set selectedItem if the prop is defined. Setting if it is undefined
   // will overwrite default selected items from useSelect
@@ -215,80 +250,79 @@ const Dropdown = /*#__PURE__*/React__default["default"].forwardRef((_ref, ref) =
     [`${prefix}--list-box__wrapper--inline--invalid`]: inline && invalid,
     [`${prefix}--list-box__wrapper--fluid--invalid`]: isFluid && invalid,
     [`${prefix}--list-box__wrapper--fluid--focus`]: isFluid && isFocused && !isOpen,
-    [`${prefix}--list-box__wrapper--slug`]: slug
+    [`${prefix}--list-box__wrapper--slug`]: slug,
+    [`${prefix}--list-box__wrapper--decorator`]: decorator
   });
   const helperId = !helperText ? undefined : `dropdown-helper-text-${dropdownInstanceId}`;
 
   // needs to be Capitalized for react to render it correctly
   const ItemToElement = itemToElement;
-  const toggleButtonProps = getToggleButtonProps({
+  const toggleButtonProps = React.useMemo(() => getToggleButtonProps({
     'aria-label': ariaLabel || deprecatedAriaLabel
-  });
+  }), [getToggleButtonProps, ariaLabel, deprecatedAriaLabel, isOpen]);
   const helper = helperText && !isFluid ? /*#__PURE__*/React__default["default"].createElement("div", {
     id: helperId,
     className: helperClasses
   }, helperText) : null;
-  function onSelectedItemChange(_ref4) {
-    let {
-      selectedItem
-    } = _ref4;
-    if (onChange) {
-      onChange({
-        selectedItem: selectedItem ?? null
-      });
-    }
-  }
   const handleFocus = evt => {
     setIsFocused(evt.type === 'focus' ? true : false);
   };
   const mergedRef = mergeRefs["default"](toggleButtonProps.ref, ref);
   const [currTimer, setCurrTimer] = React.useState();
-
-  // eslint-disable-next-line prefer-const
-  let [isTyping, setIsTyping] = React.useState(false);
-  const readOnlyEventHandlers = readOnly ? {
-    onClick: evt => {
-      // NOTE: does not prevent click
-      evt.preventDefault();
-      // focus on the element as per readonly input behavior
-      mergedRef?.current?.focus();
-    },
-    onKeyDown: evt => {
-      const selectAccessKeys = ['ArrowDown', 'ArrowUp', ' ', 'Enter'];
-      // This prevents the select from opening for the above keys
-      if (selectAccessKeys.includes(evt.key)) {
-        evt.preventDefault();
-      }
+  const [isTyping, setIsTyping] = React.useState(false);
+  const onKeyDownHandler = React.useCallback(evt => {
+    if (evt.code !== 'Space' || !['ArrowDown', 'ArrowUp', ' ', 'Enter'].includes(evt.key)) {
+      setIsTyping(true);
     }
-  } : {
-    onKeyDown: evt => {
-      if (evt.code !== 'Space' || !['ArrowDown', 'ArrowUp', ' ', 'Enter'].includes(evt.key)) {
-        setIsTyping(true);
+    if (isTyping && evt.code === 'Space' || !['ArrowDown', 'ArrowUp', ' ', 'Enter'].includes(evt.key)) {
+      if (currTimer) {
+        clearTimeout(currTimer);
       }
-      if (isTyping && evt.code === 'Space' || !['ArrowDown', 'ArrowUp', ' ', 'Enter'].includes(evt.key)) {
-        if (currTimer) {
-          clearTimeout(currTimer);
+      setCurrTimer(setTimeout(() => {
+        setIsTyping(false);
+      }, 3000));
+    }
+    if (toggleButtonProps.onKeyDown) {
+      toggleButtonProps.onKeyDown(evt);
+    }
+  }, [isTyping, currTimer, toggleButtonProps]);
+  const readOnlyEventHandlers = React.useMemo(() => {
+    if (readOnly) {
+      return {
+        onClick: evt => {
+          // NOTE: does not prevent click
+          evt.preventDefault();
+          // focus on the element as per readonly input behavior
+          mergedRef?.current?.focus();
+        },
+        onKeyDown: evt => {
+          const selectAccessKeys = ['ArrowDown', 'ArrowUp', ' ', 'Enter'];
+          // This prevents the select from opening for the above keys
+          if (selectAccessKeys.includes(evt.key)) {
+            evt.preventDefault();
+          }
         }
-        setCurrTimer(setTimeout(() => {
-          setIsTyping(false);
-        }, 3000));
-      }
-      if (toggleButtonProps.onKeyDown) {
-        toggleButtonProps.onKeyDown(evt);
-      }
+      };
+    } else {
+      return {
+        onKeyDown: onKeyDownHandler
+      };
     }
-  };
+  }, [readOnly, onKeyDownHandler]);
   const menuProps = React.useMemo(() => getMenuProps({
     ref: enableFloatingStyles || autoAlign ? refs.setFloating : null
-  }), [autoAlign, getMenuProps, refs.setFloating]);
+  }), [autoAlign, getMenuProps, refs.setFloating, enableFloatingStyles]);
 
-  // Slug is always size `mini`
-  let normalizedSlug;
-  if (slug && slug['type']?.displayName === 'AILabel') {
-    normalizedSlug = /*#__PURE__*/React__default["default"].cloneElement(slug, {
-      size: 'mini'
-    });
-  }
+  // AILabel is always size `mini`
+  const normalizedDecorator = React.useMemo(() => {
+    let element = slug ?? decorator;
+    if (element && element['type']?.displayName === 'AILabel') {
+      return /*#__PURE__*/React__default["default"].cloneElement(element, {
+        size: 'mini'
+      });
+    }
+    return /*#__PURE__*/React__default["default"].isValidElement(element) ? element : null;
+  }, [slug, decorator]);
   return /*#__PURE__*/React__default["default"].createElement("div", _rollupPluginBabelHelpers["extends"]({
     className: wrapperClasses
   }, other), titleText && /*#__PURE__*/React__default["default"].createElement("label", _rollupPluginBabelHelpers["extends"]({
@@ -327,7 +361,9 @@ const Dropdown = /*#__PURE__*/React__default["default"].forwardRef((_ref, ref) =
   }, selectedItem ? renderSelectedItem ? renderSelectedItem(selectedItem) : itemToString(selectedItem) : label), /*#__PURE__*/React__default["default"].createElement(index$1["default"].MenuIcon, {
     isOpen: isOpen,
     translateWithId: translateWithId
-  })), normalizedSlug, /*#__PURE__*/React__default["default"].createElement(index$1["default"].Menu, menuProps, isOpen && items.map((item, index) => {
+  })), slug ? normalizedDecorator : decorator ? /*#__PURE__*/React__default["default"].createElement("div", {
+    className: `${prefix}--list-box__inner-wrapper--decorator`
+  }, normalizedDecorator) : '', /*#__PURE__*/React__default["default"].createElement(index$1["default"].Menu, menuProps, isOpen && items.map((item, index) => {
     const isObject = item !== null && typeof item === 'object';
     const itemProps = getItemProps({
       item,
@@ -370,6 +406,10 @@ Dropdown.propTypes = {
    * Provide a custom className to be applied on the cds--dropdown node
    */
   className: PropTypes__default["default"].string,
+  /**
+   * **Experimental**: Provide a `decorator` component to be rendered inside the `Dropdown` component
+   */
+  decorator: PropTypes__default["default"].node,
   /**
    * Specify the direction of the dropdown. Can be either top or bottom.
    */
@@ -463,7 +503,7 @@ Dropdown.propTypes = {
   /**
    * **Experimental**: Provide a `Slug` component to be rendered inside the `Dropdown` component
    */
-  slug: PropTypes__default["default"].node,
+  slug: deprecate["default"](PropTypes__default["default"].node, 'The `slug` prop for `Dropdown` has ' + 'been deprecated in favor of the new `decorator` prop. It will be removed in the next major release.'),
   /**
    * Provide the title text that will be read by a screen reader when
    * visiting this control

package/lib/components/FeatureFlags/index.js

@@ -129,8 +129,7 @@ function useChangedValue(value, compare, callback) {
  */
 function useFeatureFlag(flag) {
   const scope = React.useContext(FeatureFlagContext);
-  //updated to return false for undefined flags
-  return scope.enabled(flag) ?? false;
+  return scope.enabled(flag);
 }
 
 /**

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

@@ -8,11 +8,14 @@ import React, { ReactNode } from 'react';
 import { ButtonSize } from '../Button';
 export declare const IconButtonKinds: readonly ["primary", "secondary", "ghost", "tertiary"];
 export type IconButtonKind = (typeof IconButtonKinds)[number];
+export type DeprecatedIconButtonAlignment = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right' | 'left-bottom' | 'left-top' | 'right-bottom' | 'right-top';
+export type NewIconButtonAlignment = 'top' | 'bottom' | 'left' | 'right' | 'top-start' | 'top-end' | 'bottom-start' | 'bottom-end' | 'left-end' | 'left-start' | 'right-end' | 'right-start';
+export type IconButtonAlignment = DeprecatedIconButtonAlignment | NewIconButtonAlignment;
 interface IconButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
     /**
      * Specify how the trigger should align with the tooltip
      */
-    align?: 'top' | 'top-left' | 'top-start' | 'top-right' | 'top-end' | 'bottom' | 'bottom-left' | 'bottom-start' | 'bottom-right' | 'bottom-end' | 'left' | 'right';
+    align?: IconButtonAlignment;
     /**
      * **Experimental**: Will attempt to automatically align the tooltip
      */

package/lib/components/IconButton/index.js

@@ -17,6 +17,7 @@ require('../Tooltip/DefinitionTooltip.js');
 var Tooltip = require('../Tooltip/Tooltip.js');
 var usePrefix = require('../../internal/usePrefix.js');
 var ButtonBase = require('../Button/ButtonBase.js');
+var deprecateValuesWithin = require('../../prop-types/deprecateValuesWithin.js');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -25,6 +26,19 @@ var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
 var cx__default = /*#__PURE__*/_interopDefaultLegacy(cx);
 
 const IconButtonKinds = ['primary', 'secondary', 'ghost', 'tertiary'];
+const propMappingFunction = deprecatedValue => {
+  const mapping = {
+    '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'
+  };
+  return mapping[deprecatedValue];
+};
 const IconButton = /*#__PURE__*/React__default["default"].forwardRef(function IconButton(_ref, ref) {
   let {
     align,
@@ -70,7 +84,32 @@ IconButton.propTypes = {
   /**
    * Specify how the trigger should align with the tooltip
    */
-  align: PropTypes__default["default"].oneOf(['top', 'top-left', 'top-start', 'top-right', 'top-end', 'bottom', 'bottom-left', 'bottom-start', 'bottom-right', 'bottom-end', 'left', 'right']),
+  align: deprecateValuesWithin["default"](PropTypes__default["default"].oneOf(['top', 'top-left',
+  // deprecated use top-start instead
+  'top-right',
+  // deprecated use top-end instead
+
+  'bottom', 'bottom-left',
+  // deprecated use bottom-start instead
+  'bottom-right',
+  // deprecated use bottom-end instead
+
+  'left', 'left-bottom',
+  // deprecated use left-end instead
+  'left-top',
+  // deprecated use left-start instead
+
+  'right', 'right-bottom',
+  // deprecated use right-end instead
+  'right-top',
+  // 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),
   /**
    * **Experimental**: Will attempt to automatically align the tooltip
    */

package/lib/components/InlineCheckbox/InlineCheckbox.d.ts

@@ -0,0 +1,50 @@
+import React from 'react';
+export interface InlineCheckboxProps {
+    'aria-label': string;
+    /**
+     * Deprecated, please use `aria-label` instead.
+     * Specify the label for the control
+     */
+    ariaLabel?: string;
+    /**
+     * Specify whether the underlying control is checked,
+     * or not
+     * @default false
+     * */
+    checked?: boolean;
+    /**
+     * Specify whether the underlying input control should be disabled
+     * @default false
+     */
+    disabled?: boolean;
+    /**
+     * Provide an `id` for the underlying input control
+     */
+    id: string;
+    /**
+     * Specify whether the control is in an indeterminate state
+     */
+    indeterminate?: boolean;
+    /**
+     * Provide a `name` for the underlying input control
+     */
+    name: string;
+    /**
+     * Provide an optional hook that is called each time the input is updated
+     */
+    onChange?: (checked: boolean, id: string, event: React.ChangeEvent<HTMLInputElement>) => void;
+    /**
+     * Provide a handler that is invoked when a user clicks on the control
+     */
+    onClick?: (event: React.MouseEvent<HTMLInputElement>) => void;
+    /**
+     * Provide a handler that is invoked on the key down event for the control
+     */
+    onKeyDown?: (event: React.KeyboardEvent<HTMLInputElement>) => void;
+    /**
+     * Provide an optional tooltip for the InlineCheckbox
+     */
+    title?: string;
+}
+declare const InlineCheckbox: React.ForwardRefExoticComponent<InlineCheckboxProps & React.RefAttributes<HTMLInputElement>>;
+export default InlineCheckbox;

package/lib/components/InlineCheckbox/InlineCheckbox.js

@@ -20,7 +20,6 @@ function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'defau
 var PropTypes__default = /*#__PURE__*/_interopDefaultLegacy(PropTypes);
 var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
 
-/** @type any */
 const InlineCheckbox = /*#__PURE__*/React__default["default"].forwardRef(function InlineCheckbox(props, forwardRef) {
   const {
     ['aria-label']: ariaLabel,
@@ -57,15 +56,14 @@ const InlineCheckbox = /*#__PURE__*/React__default["default"].forwardRef(functio
   }
   React.useEffect(() => {
     if (inputRef?.current) {
-      inputRef.current.indeterminate = indeterminate;
+      inputRef.current.indeterminate = indeterminate || false;
     }
   }, [indeterminate]);
   function onClickCheckBoxInput(evt) {
-    // If the previous "indeterminate" is true, change "checked" to false. If it is not undefined, we're working on `TableSelectAll`
     if (indeterminate) {
       evt.target.checked = false;
     }
-    onClick(evt);
+    onClick?.(evt);
   }
   return /*#__PURE__*/React__default["default"].createElement("div", {
     className: `${prefix}--checkbox--inline`
@@ -130,6 +128,5 @@ InlineCheckbox.propTypes = {
    */
   title: PropTypes__default["default"].string
 };
-var InlineCheckbox$1 = InlineCheckbox;
 
-exports["default"] = InlineCheckbox$1;
+exports["default"] = InlineCheckbox;

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

@@ -0,0 +1,9 @@
+/**
+ * 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 InlineCheckbox, { type InlineCheckboxProps } from './InlineCheckbox';
+export default InlineCheckbox;
+export { InlineCheckbox, type InlineCheckboxProps };

package/lib/components/LayoutDirection/LayoutDirection.d.ts

@@ -0,0 +1,44 @@
+/**
+ * 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 PropTypes from 'prop-types';
+import { ElementType, ReactNode } from 'react';
+import { LayoutDirectionContext } from './LayoutDirectionContext';
+type Direction = 'ltr' | 'rtl';
+interface LayoutDirectionProps {
+    /**
+     * Customize the element type used to render the outermost node
+     */
+    as?: ElementType;
+    /**
+     * Provide child elements or components to be rendered inside of this
+     * component
+     */
+    children?: ReactNode;
+    /**
+     * Specify the layout direction of this part of the page
+     */
+    dir: Direction;
+}
+declare function LayoutDirection({ as: BaseComponent, children, dir, ...rest }: LayoutDirectionProps): import("react/jsx-runtime").JSX.Element;
+declare namespace LayoutDirection {
+    var propTypes: {
+        /**
+         * Customize the element type used to render the outermost node
+         */
+        as: PropTypes.Requireable<NonNullable<((...args: any[]) => any) | PropTypes.ReactComponentLike | null | undefined>>;
+        /**
+         * Provide child elements or components to be rendered inside of this
+         * component
+         */
+        children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        /**
+         * Specify the layout direction of this part of the page
+         */
+        dir: PropTypes.Validator<string>;
+    };
+}
+export { LayoutDirectionContext, LayoutDirection };

package/lib/components/LayoutDirection/LayoutDirectionContext.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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 React from 'react';
+export declare const LayoutDirectionContext: React.Context<{
+    direction: string;
+}>;

package/lib/components/LayoutDirection/useLayoutDirection.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 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.
+ */
+/**
+ * Get access to the current layout direction in context
+ */
+export declare function useLayoutDirection(): {
+    direction: string;
+};

package/lib/components/Menu/MenuItem.js

@@ -253,9 +253,6 @@ const MenuItemSelectable = /*#__PURE__*/React.forwardRef(function MenuItemSelect
   });
   function handleClick(e) {
     setChecked(!checked);
-    if (onChange) {
-      onChange(e);
-    }
   }
   React.useEffect(() => {
     if (!context.state.hasIcons) {

package/lib/components/MultiSelect/FilterableMultiSelect.d.ts

@@ -61,7 +61,7 @@ export interface FilterableMultiSelectProps<ItemType> extends MultiSelectSorting
      */
     filterItems(items: readonly ItemType[], extra: {
         inputValue: string | null;
-        itemToString: NonNullable<UseMultipleSelectionProps<ItemType>['itemToString']>;
+        itemToString: NonNullable<UseComboboxProps<ItemType>['itemToString']>;
     }): ItemType[];
     /**
      * Specify whether the title text should be hidden or not

package/lib/components/MultiSelect/FilterableMultiSelect.js

@@ -276,7 +276,7 @@ const FilterableMultiSelect = /*#__PURE__*/React__default["default"].forwardRef(
     inputValue,
     stateReducer,
     isItemDisabled(item, _index) {
-      return item.disabled;
+      return item?.disabled;
     }
   });
   function stateReducer(state, actionAndChanges) {
@@ -393,7 +393,6 @@ const FilterableMultiSelect = /*#__PURE__*/React__default["default"].forwardRef(
     activeIndex: highlightedIndex,
     initialSelectedItems,
     selectedItems: controlledSelectedItems,
-    itemToString: itemToString$1,
     onStateChange(changes) {
       switch (changes.type) {
         case SelectedItemKeyDownBackspace:

package/lib/components/MultiSelect/MultiSelect.js

@@ -207,7 +207,7 @@ const MultiSelect = /*#__PURE__*/React__default["default"].forwardRef((_ref, ref
     selectedItem: controlledSelectedItems,
     items: filteredItems,
     isItemDisabled(item, _index) {
-      return item.disabled;
+      return item?.disabled;
     },
     ...downshiftProps
   };

package/lib/components/Notification/Notification.d.ts

@@ -516,6 +516,13 @@ export declare namespace ActionableNotification {
  * Callout
  * ==================
  */
+/**
+ * Deprecated callout kind values.
+ * @deprecated Use NewKindProps instead.
+ */
+export type DeprecatedKindProps = 'error' | 'info' | 'info-square' | 'success' | 'warning' | 'warning-alt';
+export type NewKindProps = 'warning' | 'info';
+export type KindProps = DeprecatedKindProps | NewKindProps;
 export interface CalloutProps extends HTMLAttributes<HTMLDivElement> {
     /**
      * Pass in the action button label that will be rendered within the ActionableNotification.
@@ -532,7 +539,7 @@ export interface CalloutProps extends HTMLAttributes<HTMLDivElement> {
     /**
      * Specify what state the notification represents
      */
-    kind?: 'error' | 'info' | 'info-square' | 'success' | 'warning' | 'warning-alt';
+    kind?: KindProps;
     /**
      * Specify whether you are using the low contrast variant of the Callout.
      */
@@ -576,7 +583,7 @@ export declare namespace Callout {
         /**
          * Specify what state the notification represents
          */
-        kind: PropTypes.Requireable<string>;
+        kind: (props: any, propName: any, componentName: any, ...rest: any[]) => any;
         /**
          * Specify whether you are using the low contrast variant of the Callout.
          */