carbon-react 104.34.1 → 104.35.0

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

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,355 @@
+import composedPath from "./composedPath";
+/**
+ * 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
+ *
+ * @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;
+  },
+
+  /**
+   * 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")) {
+      return false;
+    }
+
+    return Events.isNavigationKey(ev);
+  },
+
+  /**
+   * 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")) {
+      return false;
+    }
+
+    return Events.isEnterKey(ev);
+  },
+
+  /**
+   * 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")) {
+      return false;
+    }
+
+    if (Events.isNumberKey(ev) || Events.isAlphabetKey(ev) || Events.isNumpadKey(ev) || Events.isSymbolKey(ev) || Events.isSpaceKey(ev) || Events.isDeletingKey(ev) || Events.isBackspaceKey(ev)) {
+      return true;
+    }
+
+    return false;
+  },
+
+  /**
+   * 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;
+  },
+
+  /**
+   * 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;
+  },
+
+  /**
+   * 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;
+  },
+
+  /**
+   * 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; // \ ]
+  },
+
+  /**
+   * 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;
+  },
+
+  /**
+   * 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;
+  },
+
+  /**
+   * 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;
+  },
+
+  /**
+   * 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;
+  },
+
+  /**
+   * 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;
+  },
+
+  /**
+   * 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;
+  },
+
+  /**
+   * 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;
+  },
+
+  /**
+   * 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;
+  },
+
+  /**
+   * 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;
+  },
+
+  /**
+   * 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";
+  },
+
+  /**
+   * 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";
+  },
+
+  /**
+   * 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);
+  },
+
+  /**
+   * 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;
+  },
+
+  /**
+   * 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;
+  },
+
+  /**
+   * 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;
+  },
+
+  /**
+   * 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;
+  },
+
+  /**
+   * 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;
+  },
+
+  /**
+   * 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";
+  },
+
+  /**
+   * 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;
+  },
+
+  /**
+   * 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;
+  },
+
+  /**
+   * 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);
+  }
+};
+export default Events;

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

@@ -0,0 +1 @@
+export { default } from "./events";

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

@@ -0,0 +1 @@
+export { default } from "./events";

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

@@ -0,0 +1 @@
+export {};

package/esm/__internal__/utils/helpers/guid/__spec__.js

@@ -0,0 +1,10 @@
+import guid from "./guid";
+describe("guid", () => {
+  it("returns a 36 character id", () => {
+    expect(guid().length).toEqual(36);
+  });
+  it("returns a unique id", () => {
+    const id = guid();
+    expect(guid()).not.toEqual(id);
+  });
+});

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

@@ -0,0 +1,2 @@
+declare function _default(): string;
+export default _default;

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

@@ -0,0 +1,12 @@
+/**
+ * Generates a random guid, useful for creating unique IDs.
+ *
+ * @method guid
+ */
+export default (() => {
+  function s4() {
+    return Math.floor((1 + Math.random()) * 0x10000).toString(16).substring(1);
+  }
+
+  return `${s4()}${s4()}-${s4()}-${s4()}-${s4()}-${s4()}${s4()}${s4()}`;
+});

package/esm/__internal__/utils/helpers/guid/package.json

@@ -0,0 +1,3 @@
+{
+  "main": "./guid.js"
+}

package/esm/__internal__/utils/helpers/immutable/__spec__.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/__internal__/utils/helpers/immutable/__spec__.js

@@ -0,0 +1,117 @@
+import Immutable from "immutable";
+import ImmutableHelper from "./immutable";
+describe("Immutable Helper", () => {
+  describe("parseJSON", () => {
+    describe("when the passed json is not an object", () => {
+      it("returns the json", () => {
+        expect(ImmutableHelper.parseJSON("a")).toEqual("a");
+      });
+    });
+    describe("when the passed json is null", () => {
+      it("returns null", () => {
+        expect(ImmutableHelper.parseJSON(null)).toBeNull();
+      });
+    });
+    describe("when the JSON is a simple array", () => {
+      let data, expectedData, result;
+      beforeEach(() => {
+        data = ["a", "b", "c"];
+        expectedData = Immutable.Seq(data).toList();
+        result = ImmutableHelper.parseJSON(data);
+      });
+      it("returns a immutable object of that array", () => {
+        expect(result).toEqual(expectedData);
+        expect(result.get(0)).toEqual("a");
+        expect(result.get(1)).toEqual("b");
+        expect(result.get(2)).toEqual("c");
+      });
+    });
+    describe("when the JSON object is a array of objects", () => {
+      let data, result;
+      it("returns a immutable object of that array", () => {
+        data = [{
+          foo: "a"
+        }, {
+          bar: "b"
+        }, {
+          baz: "c"
+        }];
+        result = ImmutableHelper.parseJSON(data);
+        expect(result.get(0).get("foo")).toEqual("a");
+        expect(result.get(1).get("bar")).toEqual("b");
+        expect(result.get(2).get("baz")).toEqual("c");
+      });
+    });
+    describe("when JSON is a object", () => {
+      let data, expectedData;
+      beforeEach(() => {
+        data = {
+          foo: "bar",
+          baz: "qux"
+        };
+        expectedData = Immutable.Seq(data).toMap();
+      });
+      it("returns a ordered immutable map", () => {
+        const result = ImmutableHelper.parseJSON(data);
+        expect(result).toEqual(expectedData);
+        expect(result.get("foo")).toEqual("bar");
+        expect(result.get("baz")).toEqual("qux");
+      });
+    });
+    describe("when JSON is a complex value with nest arrays and objects", () => {
+      let data, expectedData;
+      beforeEach(() => {
+        data = [{
+          foo: "bar",
+          baz: "qux"
+        }, {
+          a: ["a", "b", "c"],
+          b: "b"
+        }];
+        const obj1 = Immutable.Seq({
+          foo: "bar",
+          baz: "qux"
+        }).toMap();
+        const array1 = Immutable.Seq(["a", "b", "c"]).toList();
+        const obj2 = Immutable.Seq({
+          a: array1,
+          b: "b"
+        }).toMap();
+        expectedData = Immutable.Seq([obj1, obj2]).toList();
+      });
+      it("creates a immutable object in the same format", () => {
+        const result = ImmutableHelper.parseJSON(data);
+        expect(result.toJS()).toEqual(expectedData.toJS());
+      });
+    });
+    describe("when passed a number", () => {
+      it("casts it to a string", () => {
+        expect(ImmutableHelper.parseJSON(1)).toEqual(Immutable.fromJS("1"));
+        expect(ImmutableHelper.parseJSON(3.142)).toEqual(Immutable.fromJS("3.142"));
+      });
+      describe("as a nested element", () => {
+        it("casts all numbers to a string", () => {
+          const data = [{
+            foo: "bar",
+            baz: "qux"
+          }, {
+            a: [1, 2, "c"],
+            b: 2
+          }];
+          const obj1 = Immutable.Seq({
+            foo: "bar",
+            baz: "qux"
+          }).toMap();
+          const array1 = Immutable.Seq(["1", "2", "c"]).toList();
+          const obj2 = Immutable.Seq({
+            a: array1,
+            b: "2"
+          }).toMap();
+          const expectedData = Immutable.Seq([obj1, obj2]).toList();
+          const result = ImmutableHelper.parseJSON(data);
+          expect(result.toJS()).toEqual(expectedData.toJS());
+        });
+      });
+    });
+  });
+});

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

@@ -0,0 +1,4 @@
+export default ImmutableHelper;
+declare namespace ImmutableHelper {
+    function parseJSON(js: Object): any;
+}

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

@@ -0,0 +1,36 @@
+import Immutable from "immutable";
+/**
+ * Immutable Helper
+ *
+ * Provides helper methods for working with immutable data.
+ *
+ * @object ImmutableHelper
+ * @param {String} name
+ * @param {Object} form
+ */
+
+const ImmutableHelper = {
+  /**
+   * Parses a regular JSON object into an Immutable data object, mapping the data
+   * correctly and applying custom transforms to make the data easier to work with.
+   *
+   * @method parseJSON
+   * @param {Object} js
+   */
+  parseJSON: js => {
+    if (typeof js !== "object" || js === null) {
+      if (typeof js === "number") {
+        return String(js);
+      }
+
+      return js;
+    }
+
+    if (Array.isArray(js)) {
+      return Immutable.Seq(js).map(ImmutableHelper.parseJSON).toList();
+    }
+
+    return Immutable.Seq(js).map(ImmutableHelper.parseJSON).toMap();
+  }
+};
+export default ImmutableHelper;

package/esm/__internal__/utils/helpers/immutable/package.json

@@ -0,0 +1,4 @@
+{
+  "name": "immutable",
+  "main": "./immutable.js"
+}

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

@@ -0,0 +1 @@
+export { default } from "./tags";

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

@@ -0,0 +1 @@
+export { default } from "./tags";

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

@@ -0,0 +1 @@
+export { elementsTagTest, rootTagTest } from "./tags-specs";

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

@@ -0,0 +1 @@
+export { elementsTagTest, rootTagTest } from "./tags-specs";

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

@@ -0,0 +1,2 @@
+export function elementsTagTest(wrapper: any, elements: any): void;
+export function rootTagTest(rootNode: any, comp: any, elem: any, role: any): void;

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

@@ -0,0 +1,17 @@
+const elementsTagTest = (wrapper, elements) => {
+  elements.forEach(element => {
+    it(`include 'data-element="${element}"'`, () => {
+      expect(wrapper.find({
+        "data-element": element
+      }).length).toEqual(1);
+    });
+  });
+};
+
+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);
+};
+
+export { elementsTagTest, rootTagTest };

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

@@ -0,0 +1,9 @@
+export default tagComponent;
+/**
+ * Builds props object containing top level data tags
+ *
+ * @param {String} name of component
+ * @param {Object} component props
+ * @return {Object} dataTagProps
+ */
+declare function tagComponent(component: Object, props: any): Object;

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

@@ -0,0 +1,24 @@
+/**
+ * Builds props object containing top level data tags
+ *
+ * @param {String} name of component
+ * @param {Object} component props
+ * @return {Object} dataTagProps
+ */
+function tagComponent(component, props) {
+  const tagProps = {
+    "data-component": component
+  };
+
+  if (props["data-element"]) {
+    tagProps["data-element"] = props["data-element"];
+  }
+
+  if (props["data-role"]) {
+    tagProps["data-role"] = props["data-role"];
+  }
+
+  return tagProps;
+}
+
+export default tagComponent;

package/esm/__internal__/utils/helpers/with-unique-id-props/index.d.ts

@@ -0,0 +1 @@
+export { default } from "./with-unique-id-props.hoc";

package/esm/__internal__/utils/helpers/with-unique-id-props/index.js

@@ -0,0 +1 @@
+export { default } from "./with-unique-id-props.hoc";

package/esm/__internal__/utils/helpers/with-unique-id-props/with-unique-id-props.hoc.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+
+declare function withUniqueIdProps<T, P>(
+  WrappedComponent: React.ComponentType<T & React.RefAttributes<P>>
+): JSX.Element;
+
+export default withUniqueIdProps;