genesys-spark-components 4.0.0-beta.8 → 4.0.1

package/dist/collection/test/specTestUtils.js

@@ -0,0 +1,10 @@
+import { newSpecPage as stencilSpecPage } from "@stencil/core/testing";
+import MutationObserver from "mutation-observer";
+import ResizeObserver from "resize-observer-polyfill";
+export async function newSpecPage(opts) {
+  global.MutationObserver = MutationObserver;
+  global.ResizeObserver = ResizeObserver;
+  global.InputEvent = Event;
+  const page = await stencilSpecPage(opts);
+  return page;
+}

package/dist/collection/utils/date/from-iso-time-string.spec.js

@@ -0,0 +1,13 @@
+import { fromIsoTime } from "./from-iso-time-string";
+describe('#fromIsoTime', () => {
+  [{ input: '01:02:03', expectedOutput: [1, 2, 3] }].forEach(({ input, expectedOutput }, index) => {
+    it(`should work as expected (${index + 1})`, () => {
+      const [expectedHours, expectedMinutes, expectedSeconds] = expectedOutput;
+      const output = fromIsoTime(input);
+      expect(output.getUTCHours()).toBe(expectedHours);
+      expect(output.getUTCMinutes()).toBe(expectedMinutes);
+      expect(output.getUTCSeconds()).toBe(expectedSeconds);
+      expect(output.getUTCMilliseconds()).toBe(0);
+    });
+  });
+});

package/dist/collection/utils/date/get-valid-timezone.js

@@ -0,0 +1,7 @@
+import { timeZoneIdentifiers } from "../../i18n/time-zone/identifiers";
+export function getValidTimezone(input, fallback) {
+  if (timeZoneIdentifiers.includes(input)) {
+    return input;
+  }
+  return fallback;
+}

package/dist/collection/utils/date/get-valid-timezone.spec.js

@@ -0,0 +1,38 @@
+import { getValidTimezone } from "./get-valid-timezone";
+import { timeZoneIdentifiers } from "../../i18n/time-zone/identifiers";
+describe('#getValidTimezone', () => {
+  const validTimeZoneIdentifiers = timeZoneIdentifiers;
+  const invalidTimeZoneIdentifiers = ['invalid', '', null, undefined];
+  describe('Valid Timezones', () => {
+    validTimeZoneIdentifiers.forEach((timeZoneIdentifier, index) => {
+      it(`should work as expected (${index + 1})`, () => {
+        const output = getValidTimezone(timeZoneIdentifier);
+        expect(output).toBe(timeZoneIdentifier);
+      });
+    });
+  });
+  describe('Valid Timezones with a fallback', () => {
+    validTimeZoneIdentifiers.forEach((timeZoneIdentifier, index) => {
+      it(`should work as expected (${index + 1})`, () => {
+        const output = getValidTimezone(timeZoneIdentifier, 'UTC');
+        expect(output).toBe(timeZoneIdentifier);
+      });
+    });
+  });
+  describe('Invalid Timezones', () => {
+    invalidTimeZoneIdentifiers.forEach((timeZoneIdentifier, index) => {
+      it(`should work as expected (${index + 1})`, () => {
+        const output = getValidTimezone(timeZoneIdentifier);
+        expect(output).not.toBeDefined();
+      });
+    });
+  });
+  describe('Invalid Timezones with a fallback', () => {
+    invalidTimeZoneIdentifiers.forEach((timeZoneIdentifier, index) => {
+      it(`should work as expected (${index + 1})`, () => {
+        const output = getValidTimezone(timeZoneIdentifier, 'UTC');
+        expect(output).toBe('UTC');
+      });
+    });
+  });
+});

package/dist/collection/utils/date/iso-dates.spec.js

@@ -0,0 +1,170 @@
+import { asIsoDate, asIsoDateRange, fromIsoDate, fromIsoDateRange } from "./iso-dates";
+describe('ISO Date', () => {
+  describe('#asIsoDate', () => {
+    [
+      { input: new Date(2020, 0, 1), expectedOutput: '2020-01-01' },
+      { input: new Date(2020, 1, 1), expectedOutput: '2020-02-01' },
+      { input: new Date(2020, 2, 1), expectedOutput: '2020-03-01' },
+      { input: new Date(2020, 3, 1), expectedOutput: '2020-04-01' },
+      { input: new Date(2020, 4, 1), expectedOutput: '2020-05-01' },
+      { input: new Date(2020, 5, 1), expectedOutput: '2020-06-01' },
+      { input: new Date(2020, 6, 1), expectedOutput: '2020-07-01' },
+      { input: new Date(2020, 7, 1), expectedOutput: '2020-08-01' },
+      { input: new Date(2020, 8, 1), expectedOutput: '2020-09-01' },
+      { input: new Date(2020, 9, 1), expectedOutput: '2020-10-01' },
+      { input: new Date(2020, 10, 1), expectedOutput: '2020-11-01' },
+      { input: new Date(2020, 11, 1), expectedOutput: '2020-12-01' }
+    ].forEach(({ input, expectedOutput }, index) => {
+      it(`should work as expected (${index + 1})`, () => {
+        const output = asIsoDate(input);
+        expect(output).toBe(expectedOutput);
+      });
+    });
+  });
+  describe('#asIsoDateRange', () => {
+    [
+      {
+        input: [new Date(2020, 0, 1), new Date(2020, 1, 15)],
+        expectedOutput: '2020-01-01/2020-02-15'
+      },
+      {
+        input: [new Date(2020, 1, 1), new Date(2020, 2, 15)],
+        expectedOutput: '2020-02-01/2020-03-15'
+      },
+      {
+        input: [new Date(2020, 2, 1), new Date(2020, 3, 15)],
+        expectedOutput: '2020-03-01/2020-04-15'
+      },
+      {
+        input: [new Date(2020, 3, 1), new Date(2020, 4, 15)],
+        expectedOutput: '2020-04-01/2020-05-15'
+      },
+      {
+        input: [new Date(2020, 4, 1), new Date(2020, 5, 15)],
+        expectedOutput: '2020-05-01/2020-06-15'
+      },
+      {
+        input: [new Date(2020, 5, 1), new Date(2020, 6, 15)],
+        expectedOutput: '2020-06-01/2020-07-15'
+      },
+      {
+        input: [new Date(2020, 6, 1), new Date(2020, 7, 15)],
+        expectedOutput: '2020-07-01/2020-08-15'
+      },
+      {
+        input: [new Date(2020, 7, 1), new Date(2020, 8, 15)],
+        expectedOutput: '2020-08-01/2020-09-15'
+      },
+      {
+        input: [new Date(2020, 8, 1), new Date(2020, 9, 15)],
+        expectedOutput: '2020-09-01/2020-10-15'
+      },
+      {
+        input: [new Date(2020, 9, 1), new Date(2020, 10, 15)],
+        expectedOutput: '2020-10-01/2020-11-15'
+      },
+      {
+        input: [new Date(2020, 10, 1), new Date(2020, 11, 15)],
+        expectedOutput: '2020-11-01/2020-12-15'
+      },
+      {
+        input: [new Date(2020, 11, 1), new Date(2021, 0, 15)],
+        expectedOutput: '2020-12-01/2021-01-15'
+      }
+    ].forEach(({ input, expectedOutput }, index) => {
+      it(`should work as expected (${index + 1})`, () => {
+        const output = asIsoDateRange(input[0], input[1]);
+        expect(output).toBe(expectedOutput);
+      });
+    });
+    it('should handle a start date after an end date', () => {
+      const output = asIsoDateRange(new Date(2020, 1, 1), new Date(2020, 0, 1));
+      expect(output).toBe('2020-01-01/2020-02-01');
+    });
+  });
+  describe('#fromIsoDate', () => {
+    [
+      { input: '2020-01-01', expectedOutput: new Date(2020, 0, 1) },
+      { input: '2020-02-01', expectedOutput: new Date(2020, 1, 1) },
+      { input: '2020-03-01', expectedOutput: new Date(2020, 2, 1) },
+      { input: '2020-04-01', expectedOutput: new Date(2020, 3, 1) },
+      { input: '2020-05-01', expectedOutput: new Date(2020, 4, 1) },
+      { input: '2020-06-01', expectedOutput: new Date(2020, 5, 1) },
+      { input: '2020-07-01', expectedOutput: new Date(2020, 6, 1) },
+      { input: '2020-08-01', expectedOutput: new Date(2020, 7, 1) },
+      { input: '2020-09-01', expectedOutput: new Date(2020, 8, 1) },
+      { input: '2020-10-01', expectedOutput: new Date(2020, 9, 1) },
+      { input: '2020-11-01', expectedOutput: new Date(2020, 10, 1) },
+      { input: '2020-12-01', expectedOutput: new Date(2020, 11, 1) }
+    ].forEach(({ input, expectedOutput }, index) => {
+      it(`should work as expected (${index + 1})`, () => {
+        const output = fromIsoDate(input);
+        expect(output).toStrictEqual(expectedOutput);
+      });
+    });
+  });
+  describe('#fromIsoDateRange', () => {
+    [
+      {
+        input: '2020-01-01/2020-02-15',
+        expectedOutput: [new Date(2020, 0, 1), new Date(2020, 1, 15)]
+      },
+      {
+        input: '2020-02-01/2020-03-15',
+        expectedOutput: [new Date(2020, 1, 1), new Date(2020, 2, 15)]
+      },
+      {
+        input: '2020-03-01/2020-04-15',
+        expectedOutput: [new Date(2020, 2, 1), new Date(2020, 3, 15)]
+      },
+      {
+        input: '2020-04-01/2020-05-15',
+        expectedOutput: [new Date(2020, 3, 1), new Date(2020, 4, 15)]
+      },
+      {
+        input: '2020-05-01/2020-06-15',
+        expectedOutput: [new Date(2020, 4, 1), new Date(2020, 5, 15)]
+      },
+      {
+        input: '2020-06-01/2020-07-15',
+        expectedOutput: [new Date(2020, 5, 1), new Date(2020, 6, 15)]
+      },
+      {
+        input: '2020-07-01/2020-08-15',
+        expectedOutput: [new Date(2020, 6, 1), new Date(2020, 7, 15)]
+      },
+      {
+        input: '2020-08-01/2020-09-15',
+        expectedOutput: [new Date(2020, 7, 1), new Date(2020, 8, 15)]
+      },
+      {
+        input: '2020-09-01/2020-10-15',
+        expectedOutput: [new Date(2020, 8, 1), new Date(2020, 9, 15)]
+      },
+      {
+        input: '2020-10-01/2020-11-15',
+        expectedOutput: [new Date(2020, 9, 1), new Date(2020, 10, 15)]
+      },
+      {
+        input: '2020-11-01/2020-12-15',
+        expectedOutput: [new Date(2020, 10, 1), new Date(2020, 11, 15)]
+      },
+      {
+        input: '2020-12-01/2021-01-15',
+        expectedOutput: [new Date(2020, 11, 1), new Date(2021, 0, 15)]
+      }
+    ].forEach(({ input, expectedOutput }, index) => {
+      it(`should work as expected (${index + 1})`, () => {
+        const output = fromIsoDateRange(input);
+        expect(output).toStrictEqual(expectedOutput);
+      });
+    });
+    it('should handle missing zero padding', () => {
+      const output = fromIsoDateRange('2020-1-1/2020-2-15');
+      expect(output).toStrictEqual([
+        new Date(2020, 0, 1),
+        new Date(2020, 1, 15)
+      ]);
+    });
+  });
+});

package/dist/collection/utils/date/time-zone.js

@@ -0,0 +1,98 @@
+import { getTimeZones } from "@vvo/tzdb";
+/**
+ * @desc create a formatted offset string
+ * @param {number} offset timezone offset in minutes
+ * @returns {string} formatted offset string
+ * @example '+HH:mm' or '-HH:mm'
+ */
+export function formatOffset(offset) {
+  const isValidOffset = typeof offset === 'number';
+  if (!isValidOffset) {
+    return '';
+  }
+  const mins = Math.abs(offset) % 60;
+  const stringMins = mins.toString().padStart(2, '0');
+  const hrs = Math.floor(Math.abs(offset) / 60);
+  const stringHrs = hrs.toString().padStart(2, '0');
+  if (offset >= 0) {
+    return `+${stringHrs}:${stringMins}`;
+  }
+  return `-${stringHrs}:${stringMins}`;
+}
+export function getTimeZoneList() {
+  const moduleTimeZones = getTimeZones();
+  const additionalGroupZones = getGroupZones(moduleTimeZones);
+  // Generic time zones not included in @vvo/tzdb that we want to support
+  const genericTimeZones = [
+    { name: 'Etc/GMT', offset: 0 },
+    { name: 'Etc/GMT+0', offset: 0 },
+    { name: 'Etc/GMT+1', offset: -60 },
+    { name: 'Etc/GMT+2', offset: -120 },
+    { name: 'Etc/GMT+3', offset: -180 },
+    { name: 'Etc/GMT+4', offset: -240 },
+    { name: 'Etc/GMT+5', offset: -300 },
+    { name: 'Etc/GMT+6', offset: -360 },
+    { name: 'Etc/GMT+7', offset: -420 },
+    { name: 'Etc/GMT+8', offset: -480 },
+    { name: 'Etc/GMT+9', offset: -540 },
+    { name: 'Etc/GMT+10', offset: -600 },
+    { name: 'Etc/GMT+11', offset: -660 },
+    { name: 'Etc/GMT+12', offset: -720 },
+    { name: 'Etc/GMT-0', offset: +0 },
+    { name: 'Etc/GMT-1', offset: +60 },
+    { name: 'Etc/GMT-2', offset: +120 },
+    { name: 'Etc/GMT-3', offset: +180 },
+    { name: 'Etc/GMT-4', offset: +240 },
+    { name: 'Etc/GMT-5', offset: +300 },
+    { name: 'Etc/GMT-6', offset: +360 },
+    { name: 'Etc/GMT-7', offset: +420 },
+    { name: 'Etc/GMT-8', offset: +480 },
+    { name: 'Etc/GMT-9', offset: +540 },
+    { name: 'Etc/GMT-10', offset: +600 },
+    { name: 'Etc/GMT-11', offset: +660 },
+    { name: 'Etc/GMT-12', offset: +720 },
+    { name: 'Etc/GMT-13', offset: +780 },
+    { name: 'Etc/GMT-14', offset: +840 }
+  ].map(x => {
+    const listing = {
+      name: x.name,
+      alternativeName: '',
+      group: [],
+      continentCode: '',
+      continentName: '',
+      countryName: '',
+      countryCode: '',
+      rawOffsetInMinutes: x.offset,
+      abbreviation: x.name,
+      rawFormat: '',
+      currentTimeOffsetInMinutes: x.offset,
+      currentTimeFormat: '',
+      mainCities: []
+    };
+    return listing;
+  });
+  const allTimeZones = [
+    ...genericTimeZones,
+    ...moduleTimeZones,
+    ...additionalGroupZones
+  ];
+  return allTimeZones;
+}
+/**
+ * @desc Returns 'group' zones that are the same as other zones to the top-level list.
+ * @param GuxTimeZoneListing[] timeZoneList base list of timezones. Group zones found in this list will be returned
+ */
+function getGroupZones(timeZoneList) {
+  const groupZones = [];
+  timeZoneList.forEach(zone => {
+    zone.group.forEach(groupZone => {
+      const existing = timeZoneList.find(zone => zone.name === groupZone);
+      if (!existing && groupZone !== zone.name) {
+        const groupZoneItem = Object.assign({}, zone);
+        groupZoneItem.name = groupZone;
+        groupZones.push(groupZoneItem);
+      }
+    });
+  });
+  return groupZones;
+}

package/dist/collection/utils/date/time-zone.spec.js

@@ -0,0 +1,22 @@
+import { formatOffset, getTimeZoneList } from "./time-zone";
+describe('#formattOffset', () => {
+  [
+    { input: 0, expectedOutput: '+00:00' },
+    { input: 60, expectedOutput: '+01:00' },
+    { input: -60, expectedOutput: '-01:00' },
+    { input: -720, expectedOutput: '-12:00' },
+    { input: +720, expectedOutput: '+12:00' }
+  ].forEach(({ input, expectedOutput }, index) => {
+    it(`should work as expected (${index + 1})`, () => {
+      const output = formatOffset(input);
+      expect(output).toBe(expectedOutput);
+    });
+  });
+});
+describe('#getTimeZoneList', () => {
+  it('should should retrieve the list', () => {
+    jest.setSystemTime(new Date('2023-09-26'));
+    const output = getTimeZoneList();
+    expect(output.length).toEqual(577);
+  });
+});

package/dist/collection/utils/date/year-month-values.spec.js

@@ -0,0 +1,81 @@
+import { getISOYearMonth, getYearMonthObject } from "./year-month-values";
+describe('Year Month Values', () => {
+  describe('#getISOYearMonth', () => {
+    [
+      { year: 2022, month: '01', expectedOutput: '2022-01' },
+      { year: 2022, month: '02', expectedOutput: '2022-02' },
+      { year: 2022, month: '03', expectedOutput: '2022-03' },
+      { year: 2022, month: '04', expectedOutput: '2022-04' },
+      { year: 2022, month: '05', expectedOutput: '2022-05' },
+      { year: 2022, month: '06', expectedOutput: '2022-06' },
+      { year: 2022, month: '07', expectedOutput: '2022-07' },
+      { year: 2022, month: '08', expectedOutput: '2022-08' },
+      { year: 2022, month: '09', expectedOutput: '2022-09' },
+      { year: '2022', month: 10, expectedOutput: '2022-10' },
+      { year: '2022', month: 11, expectedOutput: '2022-11' },
+      { year: '2022', month: 12, expectedOutput: '2022-12' }
+    ].forEach(({ year, month, expectedOutput }, index) => {
+      it(`should work as expected (${index + 1})`, () => {
+        const output = getISOYearMonth(year, month);
+        expect(output).toBe(expectedOutput);
+      });
+    });
+  });
+  describe('#getYearMonthObject', () => {
+    [
+      {
+        ISOYearMonth: '2022-01',
+        expectedOutput: { year: '2022', month: '01' }
+      },
+      {
+        ISOYearMonth: '2022-02',
+        expectedOutput: { year: '2022', month: '02' }
+      },
+      {
+        ISOYearMonth: '2022-03',
+        expectedOutput: { year: '2022', month: '03' }
+      },
+      {
+        ISOYearMonth: '2022-04',
+        expectedOutput: { year: '2022', month: '04' }
+      },
+      {
+        ISOYearMonth: '2022-05',
+        expectedOutput: { year: '2022', month: '05' }
+      },
+      {
+        ISOYearMonth: '2022-06',
+        expectedOutput: { year: '2022', month: '06' }
+      },
+      {
+        ISOYearMonth: '2022-07',
+        expectedOutput: { year: '2022', month: '07' }
+      },
+      {
+        ISOYearMonth: '2022-08',
+        expectedOutput: { year: '2022', month: '08' }
+      },
+      {
+        ISOYearMonth: '2022-09',
+        expectedOutput: { year: '2022', month: '09' }
+      },
+      {
+        ISOYearMonth: '2022-10',
+        expectedOutput: { year: '2022', month: '10' }
+      },
+      {
+        ISOYearMonth: '2022-11',
+        expectedOutput: { year: '2022', month: '11' }
+      },
+      {
+        ISOYearMonth: '2022-12',
+        expectedOutput: { year: '2022', month: '12' }
+      }
+    ].forEach(({ ISOYearMonth, expectedOutput }, index) => {
+      it(`should work as expected (${index + 1})`, () => {
+        const output = getYearMonthObject(ISOYearMonth);
+        expect(output).toStrictEqual(expectedOutput);
+      });
+    });
+  });
+});

package/dist/collection/utils/decorator/on-click-outside.js

@@ -2,7 +2,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/unbound-method */
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-import { Build as BUILD, getElement } from '@stencil/core';
+import { Build as BUILD, getElement } from "@stencil/core";
 const OnClickOutsideOptionsDefaults = {
   triggerEvents: 'click',
   exclude: ''

package/dist/collection/utils/decorator/on-mutation.js

@@ -4,7 +4,7 @@
 /* eslint-disable @typescript-eslint/unbound-method */
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
 /* eslint-disable @typescript-eslint/no-unsafe-call */
-import { Build as BUILD, getElement } from '@stencil/core';
+import { Build as BUILD, getElement } from "@stencil/core";
 export function OnMutation(options) {
   return (proto, methodName) => {
     // this is to resolve the 'compiler optimization issue':

package/dist/collection/utils/decorator/on-resize.js

@@ -4,7 +4,7 @@
 /* eslint-disable @typescript-eslint/unbound-method */
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
 /* eslint-disable @typescript-eslint/no-unsafe-call */
-import { Build as BUILD, getElement } from '@stencil/core';
+import { Build as BUILD, getElement } from "@stencil/core";
 export function OnResize() {
   return (proto, methodName) => {
     // this is to resolve the 'compiler optimization issue':

package/dist/collection/utils/dom/event-is-from.spec.js

@@ -0,0 +1,29 @@
+import { eventIsFrom } from "./event-is-from";
+describe('#eventIsFrom', () => {
+  const parentElement = {
+    matches: selector => {
+      return selector === '.parent';
+    }
+  };
+  const targetElement = {
+    matches: selector => {
+      return selector === '.target';
+    },
+    parentElement
+  };
+  const dummyEvent = {
+    target: targetElement
+  };
+  it('returns true when the event target matches the selector', () => {
+    expect(eventIsFrom('.target', dummyEvent)).toBe(true);
+  });
+  it('returns true when a target ancestor matches the selector', () => {
+    expect(eventIsFrom('.parent', dummyEvent)).toBe(true);
+  });
+  it('returns false when no ancestor matches the selector', () => {
+    expect(eventIsFrom('.nothing', dummyEvent)).toBe(false);
+  });
+  it('returns false when the current target element matches the selector', () => {
+    expect(eventIsFrom('.currentTarget', dummyEvent)).toBe(false);
+  });
+});

package/dist/collection/utils/dom/find-element-by-id.js

@@ -1,11 +1,18 @@
+function getContainingDocument(node) {
+  if (node.nodeType === Node.DOCUMENT_NODE) {
+    return node;
+  }
+  if (node.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {
+    return node;
+  }
+  return node.ownerDocument;
+}
 export function findElementById(root, forElementId) {
   let priorRoot = null;
   let rootNode = root.getRootNode();
   let forElement;
   while (rootNode && rootNode !== priorRoot && !forElement) {
-    const doc = rootNode.nodeType === Node.DOCUMENT_NODE || Node.DOCUMENT_FRAGMENT_NODE
-      ? rootNode
-      : rootNode.ownerDocument;
+    const doc = getContainingDocument(rootNode);
     forElement = doc === null || doc === void 0 ? void 0 : doc.getElementById(forElementId);
     // Keep track of the prior root to stop if a node returns itself as its root
     priorRoot = rootNode;

package/dist/collection/utils/dom/manipulate-elements-classes.spec.js

@@ -0,0 +1,104 @@
+import { JSDOM } from "jsdom";
+import { addClassToElements, removeClassToElements } from "./manipulate-elements-classes";
+describe('manipulate elements classes', () => {
+  let dom;
+  let element1;
+  let element2;
+  let element3;
+  let element4;
+  let element5;
+  beforeEach(() => {
+    dom = new JSDOM(`
+      <!DOCTYPE html>
+      <html>
+        <head>
+         <title>JSDOM DOM</title>
+        </head>
+        <body>
+          <div id="element-1" class="class-1 class-2"><div>
+          <div id="element-2" class="class-1 class-2"><div>
+          <div id="element-3" class="class-1 class-2"><div>
+          <div id="element-4" class="class-1 class-2"><div>
+          <div id="element-5" class="class-1 class-2"><div>
+        </body>
+      </html>
+    `);
+    element1 = dom.window.document.getElementById('element-1');
+    element2 = dom.window.document.getElementById('element-2');
+    element3 = dom.window.document.getElementById('element-3');
+    element4 = dom.window.document.getElementById('element-4');
+    element5 = dom.window.document.getElementById('element-5');
+  });
+  describe('#addClassToElements', () => {
+    it('should add a class to an element', () => {
+      expect(element1.classList.contains('class-1')).toBe(true);
+      expect(element1.classList.contains('class-2')).toBe(true);
+      expect(element1.classList.contains('class-3')).toBe(false);
+      addClassToElements(element1, 'class-3');
+      expect(element1.classList.contains('class-1')).toBe(true);
+      expect(element1.classList.contains('class-2')).toBe(true);
+      expect(element1.classList.contains('class-3')).toBe(true);
+    });
+    it('should add a class to an array of elements', () => {
+      expect(element1.classList.contains('class-3')).toBe(false);
+      expect(element2.classList.contains('class-3')).toBe(false);
+      expect(element3.classList.contains('class-3')).toBe(false);
+      expect(element4.classList.contains('class-3')).toBe(false);
+      expect(element5.classList.contains('class-3')).toBe(false);
+      addClassToElements([element1, element2, element3, element4, element5], 'class-3');
+      expect(element1.classList.contains('class-3')).toBe(true);
+      expect(element2.classList.contains('class-3')).toBe(true);
+      expect(element3.classList.contains('class-3')).toBe(true);
+      expect(element4.classList.contains('class-3')).toBe(true);
+      expect(element5.classList.contains('class-3')).toBe(true);
+    });
+    it('should handle an undefined input for elements', () => {
+      expect(element1.classList.contains('class-3')).toBe(false);
+      expect(element2.classList.contains('class-3')).toBe(false);
+      expect(element3.classList.contains('class-3')).toBe(false);
+      expect(element4.classList.contains('class-3')).toBe(false);
+      expect(element5.classList.contains('class-3')).toBe(false);
+      addClassToElements(undefined, 'class-3');
+      expect(element1.classList.contains('class-3')).toBe(false);
+      expect(element2.classList.contains('class-3')).toBe(false);
+      expect(element3.classList.contains('class-3')).toBe(false);
+      expect(element4.classList.contains('class-3')).toBe(false);
+      expect(element5.classList.contains('class-3')).toBe(false);
+    });
+  });
+  describe('#removeClassToElements', () => {
+    it('should add a class to an element', () => {
+      expect(element1.classList.contains('class-1')).toBe(true);
+      expect(element1.classList.contains('class-2')).toBe(true);
+      removeClassToElements(element1, 'class-2');
+      expect(element1.classList.contains('class-1')).toBe(true);
+      expect(element1.classList.contains('class-2')).toBe(false);
+    });
+    it('should add a class to an array of elements', () => {
+      expect(element1.classList.contains('class-2')).toBe(true);
+      expect(element2.classList.contains('class-2')).toBe(true);
+      expect(element3.classList.contains('class-2')).toBe(true);
+      expect(element4.classList.contains('class-2')).toBe(true);
+      expect(element5.classList.contains('class-2')).toBe(true);
+      removeClassToElements([element1, element2, element3, element4, element5], 'class-2');
+      expect(element1.classList.contains('class-2')).toBe(false);
+      expect(element2.classList.contains('class-2')).toBe(false);
+      expect(element3.classList.contains('class-2')).toBe(false);
+      expect(element4.classList.contains('class-2')).toBe(false);
+      expect(element5.classList.contains('class-2')).toBe(false);
+    });
+    it('should handle an undefined input for elements', () => {
+      expect(element1.classList.contains('class-2')).toBe(true);
+      expect(element2.classList.contains('class-2')).toBe(true);
+      expect(element3.classList.contains('class-2')).toBe(true);
+      expect(element4.classList.contains('class-2')).toBe(true);
+      expect(element5.classList.contains('class-2')).toBe(true);
+      removeClassToElements(undefined, 'class-2');
+      expect(element1.classList.contains('class-2')).toBe(true);
+      expect(element2.classList.contains('class-2')).toBe(true);
+      expect(element3.classList.contains('class-2')).toBe(true);
+      expect(element4.classList.contains('class-2')).toBe(true);
+      expect(element5.classList.contains('class-2')).toBe(true);
+    });
+  });
+});

package/dist/collection/utils/dom/on-input-disabled-state-change.js

@@ -1,4 +1,4 @@
-import { calculateInputDisabledState } from './calculate-input-disabled-state';
+import { calculateInputDisabledState } from "./calculate-input-disabled-state";
 export function onInputDisabledStateChange(element, callback) {
   const fieldSet = element.closest('fieldset');
   const observer = new MutationObserver(mutations => {

package/dist/collection/utils/dom/random-html-id.spec.js

@@ -0,0 +1,14 @@
+import { randomHTMLId } from "./random-html-id";
+describe('#randomHTMLId', () => {
+  it('should return an id with a default prefix', () => {
+    const output = randomHTMLId();
+    expect(output.startsWith('gux-')).toBe(true);
+    expect(output.length).toBeGreaterThan(4);
+  });
+  it('should return an id with a supplied prefix', () => {
+    const prefix = 'test';
+    const output = randomHTMLId(prefix);
+    expect(output.startsWith(`${prefix}-`)).toBe(true);
+    expect(output.length).toBeGreaterThan(`${prefix}-`.length);
+  });
+});

package/dist/collection/utils/dom/set-input-value.js

@@ -1,4 +1,4 @@
-import simulateNativeEvent from './simulate-native-event';
+import simulateNativeEvent from "./simulate-native-event";
 export default function setInputValue(input, value, focusAfter) {
   input.value = value;
   simulateNativeEvent(input, 'input');