carbon-react 105.1.2 → 106.0.1

package/esm/__internal__/tooltip-provider/index.d.ts

@@ -1,26 +1,21 @@
-import * as React from "react";
-
-export interface ToolbarContextProps {
-  tooltipPosition: "top" | "bottom" | "left" | "right";
+import React from "react";
+interface TooltipProviderProps {
+    /** The position to display the tooltip */
+    tooltipPosition?: "top" | "bottom" | "left" | "right";
+    /** Control whether the tooltip is visible */
+    children: React.ReactNode;
+    /** Aria label for rendered help component */
+    helpAriaLabel?: string;
+    focusable?: boolean;
+    tooltipVisible?: boolean;
+    disabled?: boolean;
+    target?: Element;
 }
-
-export interface TooltipProviderProps {
-  /** The position to display the tooltip */
-  tooltipPosition?: "top" | "bottom" | "left" | "right";
-  /** Control whether the tooltip is visible */
-  children: React.ReactNode;
-  /** Aria label for rendered help component */
-  helpAriaLabel?: string;
-  focusable?: boolean;
-  tooltipVisible?: boolean;
-  disabled?: boolean;
-  target?: Element;
+interface ToolbarContextProps extends Omit<TooltipProviderProps, "children"> {
+    tooltipId?: {
+        current: string;
+    };
 }
-
-declare const ToolbarContext: React.Context<ToolbarContextProps>;
-
-declare function TooltipProvider(props: TooltipProviderProps): JSX.Element;
-
-export { ToolbarContext };
-
-export default TooltipProvider;
+export declare const TooltipContext: React.Context<ToolbarContextProps>;
+export declare const TooltipProvider: ({ children, tooltipPosition, helpAriaLabel, focusable, tooltipVisible, disabled, target, }: TooltipProviderProps) => JSX.Element;
+export {};

package/esm/__internal__/tooltip-provider/index.js

@@ -1,6 +1,5 @@
 import React, { useRef } from "react";
-import PropTypes from "prop-types";
-import guid from "../utils/helpers/guid/guid";
+import guid from "../utils/helpers/guid";
 export const TooltipContext = /*#__PURE__*/React.createContext({});
 export const TooltipProvider = ({
   children,
@@ -23,13 +22,4 @@ export const TooltipProvider = ({
       target
     }
   }, children);
-};
-TooltipProvider.propTypes = {
-  children: PropTypes.node.isRequired,
-  tooltipPosition: PropTypes.oneOf(["top", "bottom", "left", "right"]),
-  helpAriaLabel: PropTypes.string,
-  focusable: PropTypes.bool,
-  tooltipVisible: PropTypes.bool,
-  disabled: PropTypes.bool,
-  target: PropTypes.instanceOf(Element)
 };

package/esm/__internal__/utils/helpers/browser/index.d.ts

@@ -1 +1,15 @@
-export { default } from "./browser";
+/**
+ * Browser provides helper methods for working with Browser behavior.
+ */
+declare const Browser: {
+    isDomAvailable: () => boolean;
+    /**
+     * Get the current window
+     */
+    getWindow: () => Window | undefined;
+    /**
+     * Get the current document
+     */
+    getDocument: () => Document | undefined;
+};
+export default Browser;

package/esm/__internal__/utils/helpers/browser/index.js

@@ -1 +1,33 @@
-export { default } from "./browser";
+const globalNode = {
+  window,
+  document: window.document,
+  ...global
+};
+/**
+ * Browser provides helper methods for working with Browser behavior.
+ */
+
+const Browser = {
+  isDomAvailable: () => {
+    const _window = Browser.getWindow();
+
+    const _document = Browser.getDocument();
+
+    return !!(typeof _window !== "undefined" && _document && _document.createElement);
+  },
+
+  /**
+   * Get the current window
+   */
+  getWindow: () => {
+    return globalNode.window;
+  },
+
+  /**
+   * Get the current document
+   */
+  getDocument: () => {
+    return globalNode.document;
+  }
+};
+export default Browser;

package/esm/__internal__/utils/helpers/browser-type-check/index.d.ts

@@ -1 +1,7 @@
-export { default, isSafari, isEdge } from "./browser-type-check";
+interface WindowInterface extends Partial<Window> {
+    chrome?: Record<string, unknown>;
+    sidebar?: Record<string, unknown>;
+}
+declare function browserTypeCheck(_window: WindowInterface): boolean;
+export declare function isSafari(navigator: Navigator): boolean;
+export default browserTypeCheck;

package/esm/__internal__/utils/helpers/browser-type-check/index.js

@@ -1 +1,8 @@
-export { default, isSafari, isEdge } from "./browser-type-check";
+function browserTypeCheck(_window) {
+  return Boolean(_window.chrome || _window.sidebar);
+}
+
+export function isSafari(navigator) {
+  return navigator.vendor.includes("Apple");
+}
+export default browserTypeCheck;

package/esm/__internal__/utils/helpers/events/composedPath.d.ts

@@ -1,2 +1,2 @@
-declare function _default(ev: any): any[];
+declare const _default: (ev: CustomEvent) => EventTarget[];
 export default _default;

package/esm/__internal__/utils/helpers/events/events.d.ts

@@ -1,32 +1,133 @@
+/**
+ * JavaScript Events
+ *
+ * A collection of functions to be used with events.
+ *
+ * E.g. The KeyPress event has different implementations accross browsers, so
+ * this class contains methods to polyfill this functionality to ensure a standardised
+ * implementation between browsers
+ *
+ */
+declare const Events: {
+    /**
+     * A method to determine if an event is of a particular type
+     * */
+    isEventType: (ev: React.SyntheticEvent | Event, type: string) => boolean;
+    /**
+     * A method to determine whether a key down event was an arrow key
+     * */
+    isNavigationKeyup: (ev: React.KeyboardEvent | KeyboardEvent) => boolean;
+    /**
+     * A method to determine whether a key down event was an enter key
+     * */
+    isEnterKeyup: (ev: React.KeyboardEvent | KeyboardEvent) => boolean;
+    /**
+     * A method to determine whether a key up event is allowed or not.
+     * */
+    isValidKeypress: (ev: React.KeyboardEvent | KeyboardEvent) => boolean;
+    /**
+     * Determines if a number key along the top of the keyboard or a number key on the
+     * keypad is pressed
+     * */
+    isNumberKey: (ev: React.KeyboardEvent | KeyboardEvent) => boolean;
+    /**
+     * Determines if the key pressed is part of the numpad
+     * includes symbols
+     * */
+    isNumpadKey: (ev: React.KeyboardEvent | KeyboardEvent) => boolean;
+    /**
+     * Determines if the key pressed is a alphabet key
+     * Case insensitive
+     * */
+    isAlphabetKey: (ev: React.KeyboardEvent | KeyboardEvent) => boolean;
+    /**
+     * Determines if the key pressed is a valid symbol
+     * */
+    isSymbolKey: (ev: React.KeyboardEvent | KeyboardEvent) => boolean;
+    /**
+     * Determines if the key pressed is a navigation key
+     * */
+    isNavigationKey: (ev: React.KeyboardEvent | KeyboardEvent) => boolean;
+    /**
+     * Determines if the key pressed is a navigation left key
+     * */
+    isLeftKey: (ev: React.KeyboardEvent | KeyboardEvent) => boolean;
+    /**
+     * Determines if the key pressed is a navigation up key
+     * */
+    isUpKey: (ev: React.KeyboardEvent | KeyboardEvent) => boolean;
+    /**
+     * Determines if the key pressed is a navigation right key
+     * */
+    isRightKey: (ev: React.KeyboardEvent | KeyboardEvent) => boolean;
+    /**
+     * Determines if the key pressed is a navigation down key
+     * */
+    isDownKey: (ev: React.KeyboardEvent | KeyboardEvent) => boolean;
+    /**
+     * Determines if the key pressed is a meta key
+     * */
+    isMetaKey: (ev: React.KeyboardEvent | KeyboardEvent) => boolean;
+    /**
+     * Determines if the key pressed is the escape key
+     * */
+    isEscKey: (ev: React.KeyboardEvent | KeyboardEvent) => boolean;
+    /**
+     * Determines if the key pressed is the enter key
+     * */
+    isEnterKey: (ev: React.KeyboardEvent | KeyboardEvent) => boolean;
+    /**
+     * Determines if the key pressed is the tab key
+     * */
+    isTabKey: (ev: React.KeyboardEvent | KeyboardEvent) => boolean;
+    /**
+     * Determines if the key pressed is the backspace key
+     * */
+    isBackspaceKey: (ev: React.KeyboardEvent | KeyboardEvent) => boolean;
+    /**
+     * Determines if the key pressed is the delete key
+     * */
+    isDeleteKey: (ev: React.KeyboardEvent | KeyboardEvent) => boolean;
+    /**
+     * Determines if the key pressed is the backspace or delete key
+     * */
+    isDeletingKey: (ev: React.KeyboardEvent | KeyboardEvent) => boolean;
+    /**
+     * Determines if the key pressed is the shift key
+     * */
+    isShiftKey: (ev: React.KeyboardEvent | KeyboardEvent) => boolean;
+    /**
+     * Determines if the key pressed is the space key
+     * */
+    isSpaceKey: (ev: React.KeyboardEvent | KeyboardEvent) => boolean;
+    /**
+     * Determines if the key pressed is the space key or enter key
+     * */
+    isEnterOrSpaceKey: (ev: React.KeyboardEvent | KeyboardEvent) => boolean;
+    /**
+     * Determines if the key pressed is the period key
+     * */
+    isPeriodKey: (ev: React.KeyboardEvent | KeyboardEvent) => boolean;
+    /**
+     * Determines if the key pressed is the comma key
+     * */
+    isCommaKey: (ev: React.KeyboardEvent | KeyboardEvent) => boolean;
+    /**
+     * Determines if the key pressed is the minus key
+     * */
+    isMinusKey: (ev: React.KeyboardEvent | KeyboardEvent) => boolean;
+    /**
+     * Determines if the key pressed is the home key
+     * */
+    isHomeKey: (ev: React.KeyboardEvent | KeyboardEvent) => boolean;
+    /**
+     * Determines if the key pressed is the end key
+     * */
+    isEndKey: (ev: React.KeyboardEvent | KeyboardEvent) => boolean;
+    /**
+     * Gets the event's path which is an array of the objects on which listeners will be invoked.
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/Event/composedPath
+     */
+    composedPath: (ev: CustomEvent) => EventTarget[];
+};
 export default Events;
-declare namespace Events {
-    function isEventType(ev: Event, type: Type): boolean;
-    function isNavigationKeyup(ev: Event): boolean;
-    function isEnterKeyup(ev: Event): boolean;
-    function isValidKeypress(ev: Event): boolean;
-    function isNumberKey(ev: Event): boolean;
-    function isNumpadKey(ev: Event): boolean;
-    function isAlphabetKey(ev: Event): boolean;
-    function isSymbolKey(ev: Event): boolean;
-    function isNavigationKey(ev: Event): boolean;
-    function isLeftKey(ev: Event): boolean;
-    function isUpKey(ev: Event): boolean;
-    function isRightKey(ev: Event): boolean;
-    function isDownKey(ev: Event): boolean;
-    function isMetaKey(ev: Event): boolean;
-    function isEscKey(ev: Event): boolean;
-    function isEnterKey(ev: Event): boolean;
-    function isTabKey(ev: Event): boolean;
-    function isBackspaceKey(ev: Event): boolean;
-    function isDeleteKey(ev: Event): boolean;
-    function isDeletingKey(ev: Event): boolean;
-    function isShiftKey(ev: Event): boolean;
-    function isSpaceKey(ev: Event): boolean;
-    function isEnterOrSpaceKey(ev: Event): boolean;
-    function isPeriodKey(ev: Event): boolean;
-    function isCommaKey(ev: Event): boolean;
-    function isMinusKey(ev: Event): boolean;
-    function isHomeKey(ev: Event): boolean;
-    function isEndKey(ev: Event): boolean;
-    function composedPath(ev: Event): EventTarget[];
-}

package/esm/__internal__/utils/helpers/events/events.js

@@ -8,17 +8,11 @@ import composedPath from "./composedPath";
  * this class contains methods to polyfill this functionality to ensure a standardised
  * implementation between browsers
  *
- * @object Events
  */
 
 const Events = {
   /**
    * A method to determine if an event is of a particular type
-   *
-   * @method isEventType
-   * @param {Event} ev A JavaScript event
-   * @param {Type} type A JavaScript event type
-   * @returns {Boolean} true if event type matches passed type
    * */
   isEventType: (ev, type) => {
     return ev.type === type;
@@ -26,10 +20,6 @@ const Events = {
 
   /**
    * A method to determine whether a key down event was an arrow key
-   *
-   * @method isNavigationKeyup
-   * @param {Event} ev A JavaScript event
-   * @returns {Boolean} true if key up event and a navigation key
    * */
   isNavigationKeyup: ev => {
     if (!Events.isEventType(ev, "keyup")) {
@@ -41,10 +31,6 @@ const Events = {
 
   /**
    * A method to determine whether a key down event was an enter key
-   *
-   * @method isEnterKeyup
-   * @param {Event} ev A JavaScript event
-   * @returns {Boolean} true if keyup event and enter key
    * */
   isEnterKeyup: ev => {
     if (!Events.isEventType(ev, "keyup")) {
@@ -56,10 +42,6 @@ const Events = {
 
   /**
    * A method to determine whether a key up event is allowed or not.
-   *
-   * @method isValidKeypress
-   * @param {Event} ev A JavaScript event
-   * @returns {Boolean} true if keyup and valid
    * */
   isValidKeypress: ev => {
     if (!Events.isEventType(ev, "keyup")) {
@@ -76,68 +58,46 @@ const Events = {
   /**
    * Determines if a number key along the top of the keyboard or a number key on the
    * keypad is pressed
-   *
-   * @method isNumberKey
-   * @param {Event} ev A JavaScript event
-   * @returns {Boolean} true if valid number key
    * */
   isNumberKey: ev => {
-    const charCode = ev.key.charCodeAt(0);
-    return charCode >= 48 && charCode <= 57;
+    var _ev$key;
+
+    const charCode = (_ev$key = ev.key) === null || _ev$key === void 0 ? void 0 : _ev$key.charCodeAt(0);
+    return charCode !== undefined && charCode >= 48 && charCode <= 57;
   },
 
   /**
    * Determines if the key pressed is part of the numpad
    * includes symbols
-   *
-   * @method isNumberKey
-   * @param {Event} ev A JavaScript event
-   * @returns {Boolean} true if key is part of numpad
    * */
   isNumpadKey: ev => {
-    return ev.which >= 96 && ev.which <= 111;
+    return ev.which !== undefined && ev.which >= 96 && ev.which <= 111;
   },
 
   /**
    * Determines if the key pressed is a alphabet key
    * Case insensitive
-   *
-   * @method isAlphabetKey
-   * @param {Event} ev A JavaScript event
-   * @returns {Boolean} true if alphabet key is pressed
    * */
   isAlphabetKey: ev => {
-    return ev.which >= 65 && ev.which <= 90;
+    return ev.which !== undefined && ev.which >= 65 && ev.which <= 90;
   },
 
   /**
    * Determines if the key pressed is a valid symbol
-   *
-   * @method isSymbolKey
-   * @param {Event} ev A JavaScript event
-   * @returns {Boolean} true if any symbol key is pressed
    * */
   isSymbolKey: ev => {
-    return ev.which >= 58 && ev.which <= 64 || ev.which >= 106 && ev.which <= 107 || ev.which >= 186 && ev.which <= 192 || ev.which >= 219 && ev.which <= 222; // \ ]
+    return ev.which !== undefined && (ev.which >= 58 && ev.which <= 64 || ev.which >= 106 && ev.which <= 107 || ev.which >= 186 && ev.which <= 192 || ev.which >= 219 && ev.which <= 222);
   },
 
   /**
    * Determines if the key pressed is a navigation key
-   *
-   * @method isNavigationKey
-   * @param {Event} ev A JavaScript event
-   * @returns {Boolean} true if one of four arrow keys
    * */
   isNavigationKey: ev => {
-    return ev.which >= 37 && ev.which <= 40;
+    return ev.which !== undefined && ev.which >= 37 && ev.which <= 40;
   },
 
   /**
    * Determines if the key pressed is a navigation left key
-   *
-   * @method isLeftKey
-   * @param {Event} ev A JavaScript event
-   * @returns {Boolean} true if left arrow key
    * */
   isLeftKey: ev => {
     return ev.which === 37;
@@ -145,10 +105,6 @@ const Events = {
 
   /**
    * Determines if the key pressed is a navigation up key
-   *
-   * @method isUpKey
-   * @param {Event} ev A JavaScript event
-   * @returns {Boolean} true if up arrow key
    * */
   isUpKey: ev => {
     return ev.which === 38;
@@ -156,10 +112,6 @@ const Events = {
 
   /**
    * Determines if the key pressed is a navigation right key
-   *
-   * @method isRightKey
-   * @param {Event} ev A JavaScript event
-   * @returns {Boolean} true if right arrow key
    * */
   isRightKey: ev => {
     return ev.which === 39;
@@ -167,10 +119,6 @@ const Events = {
 
   /**
    * Determines if the key pressed is a navigation down key
-   *
-   * @method isDownKey
-   * @param {Event} ev A JavaScript event
-   * @returns {Boolean} true if down arrow key
    * */
   isDownKey: ev => {
     return ev.which === 40;
@@ -178,21 +126,13 @@ const Events = {
 
   /**
    * Determines if the key pressed is a meta key
-   *
-   * @method isMetaKey
-   * @param {Event} ev A JavaScript event
-   * @returns {Boolean} true if any meta key is pressed
    * */
   isMetaKey: ev => {
-    return ev.metaKey;
+    return !!ev.metaKey;
   },
 
   /**
    * Determines if the key pressed is the escape key
-   *
-   * @method isEscKey
-   * @param {Event} ev A JavaScript event
-   * @returns {Boolean} true if esc key
    * */
   isEscKey: ev => {
     return ev.which === 27;
@@ -200,10 +140,6 @@ const Events = {
 
   /**
    * Determines if the key pressed is the enter key
-   *
-   * @method isEnterKey
-   * @param {Event} ev A JavaScript event
-   * @returns {Boolean} true if enter key
    * */
   isEnterKey: ev => {
     return ev.which === 13;
@@ -211,10 +147,6 @@ const Events = {
 
   /**
    * Determines if the key pressed is the tab key
-   *
-   * @method isTabKey
-   * @param {Event} ev A JavaScript event
-   * @returns {Boolean} true if tab key
    * */
   isTabKey: ev => {
     return ev.which === 9;
@@ -222,10 +154,6 @@ const Events = {
 
   /**
    * Determines if the key pressed is the backspace key
-   *
-   * @method isBackspaceKey
-   * @param {Event} ev A JavaScript event
-   * @returns {Boolean} true if backspace key
    * */
   isBackspaceKey: ev => {
     return ev.key === "Backspace";
@@ -233,10 +161,6 @@ const Events = {
 
   /**
    * Determines if the key pressed is the delete key
-   *
-   * @method isDeleteKey
-   * @param {Event} ev A JavaScript event
-   * @returns {Boolean} true if delete key
    * */
   isDeleteKey: ev => {
     return ev.key === "Delete";
@@ -244,10 +168,6 @@ const Events = {
 
   /**
    * Determines if the key pressed is the backspace or delete key
-   *
-   * @method isDeletingKey
-   * @param {Event} ev A JavaScript event
-   * @returns {Boolean} true if is delete key or backspace key
    * */
   isDeletingKey: ev => {
     return Events.isDeleteKey(ev) || Events.isBackspaceKey(ev);
@@ -255,10 +175,6 @@ const Events = {
 
   /**
    * Determines if the key pressed is the shift key
-   *
-   * @method isShiftKey
-   * @param {Event} ev A JavaScript event
-   * @returns {Boolean} true if shift key
    * */
   isShiftKey: ev => {
     return ev.shiftKey || ev.which === 16;
@@ -266,10 +182,6 @@ const Events = {
 
   /**
    * Determines if the key pressed is the space key
-   *
-   * @method isSpaceKey
-   * @param {Event} ev A JavaScript event
-   * @returns {Boolean} true if space key
    * */
   isSpaceKey: ev => {
     return ev.which === 32;
@@ -277,10 +189,6 @@ const Events = {
 
   /**
    * Determines if the key pressed is the space key or enter key
-   *
-   * @method isEnterOrSpaceKey
-   * @param {Event} ev A JavaScript event
-   * @returns {Boolean} true if space key
    * */
   isEnterOrSpaceKey: ev => {
     return ev.which === 13 || ev.which === 32;
@@ -288,10 +196,6 @@ const Events = {
 
   /**
    * Determines if the key pressed is the period key
-   *
-   * @method isPeriodKey
-   * @param {Event} ev A JavaScript event
-   * @returns {Boolean} true if period key
    * */
   isPeriodKey: ev => {
     return ev.which === 190;
@@ -299,10 +203,6 @@ const Events = {
 
   /**
    * Determines if the key pressed is the comma key
-   *
-   * @method isCommaKey
-   * @param {Event} ev A JavaScript event
-   * @returns {Boolean} true if comma key
    * */
   isCommaKey: ev => {
     return ev.which === 188;
@@ -310,10 +210,6 @@ const Events = {
 
   /**
    * Determines if the key pressed is the minus key
-   *
-   * @method isMinusKey
-   * @param {Event} ev A JavaScript event
-   * @returns {Boolean} true if minus key
    * */
   isMinusKey: ev => {
     return ev.key === "-" || ev.key === "Subtract";
@@ -321,10 +217,6 @@ const Events = {
 
   /**
    * Determines if the key pressed is the home key
-   *
-   * @method isHomeKey
-   * @param {Event} ev A JavaScript event
-   * @returns {Boolean} true if home key
    * */
   isHomeKey: ev => {
     return ev.which === 36;
@@ -332,10 +224,6 @@ const Events = {
 
   /**
    * Determines if the key pressed is the end key
-   *
-   * @method isEndKey
-   * @param {Event} ev A JavaScript event
-   * @returns {Boolean} true if end key
    * */
   isEndKey: ev => {
     return ev.which === 35;
@@ -344,12 +232,9 @@ const Events = {
   /**
    * Gets the event's path which is an array of the objects on which listeners will be invoked.
    * @see https://developer.mozilla.org/en-US/docs/Web/API/Event/composedPath
-   * @method composedPath
-   * @param {Event} ev A Javascript event
-   * @returns {EventTarget[]} objects representing the objects on which an event listener will be invoked
    */
   composedPath: ev => {
-    return ev.path || ev.detail && ev.detail.enzymeTestingTarget && composedPath(ev) || ev.composedPath && ev.composedPath() || composedPath(ev);
+    return ev.detail && ev.detail.enzymeTestingTarget && composedPath(ev) || ev.composedPath && ev.composedPath() || composedPath(ev);
   }
 };
 export default Events;

package/esm/__internal__/utils/helpers/guid/index.d.ts

@@ -0,0 +1,5 @@
+declare const _default: () => string;
+/**
+ * Generates a random guid, useful for creating unique IDs.
+ */
+export default _default;

package/esm/__internal__/utils/helpers/guid/{guid.js → index.js}

@@ -1,7 +1,5 @@
 /**
  * Generates a random guid, useful for creating unique IDs.
- *
- * @method guid
  */
 export default (() => {
   function s4() {

package/esm/__internal__/utils/helpers/tags/tags-specs/tags-specs.d.ts

@@ -1,2 +1,4 @@
-export function elementsTagTest(wrapper: any, elements: any): void;
-export function rootTagTest(rootNode: any, comp: any, elem: any, role: any): void;
+import { ReactWrapper, ShallowWrapper } from "enzyme";
+declare const elementsTagTest: (wrapper: ReactWrapper, elements: string[]) => void;
+declare const rootTagTest: (rootNode: ReactWrapper | ShallowWrapper, comp: string, elem?: string | undefined, role?: string | undefined) => void;
+export { elementsTagTest, rootTagTest };

package/esm/__internal__/utils/helpers/tags/tags-specs/tags-specs.js

@@ -12,6 +12,7 @@ const rootTagTest = (rootNode, comp, elem, role) => {
   expect(rootNode.prop("data-component")).toEqual(comp);
   expect(rootNode.prop("data-element")).toEqual(elem);
   expect(rootNode.prop("data-role")).toEqual(role);
-};
+}; // eslint-disable-next-line jest/no-export
+
 
 export { elementsTagTest, rootTagTest };