@aurodesignsystem-dev/auro-library 0.0.0-pr187.0

package/scripts/runtime/Focusables/test/Focusables.test.js

@@ -0,0 +1,165 @@
+/* eslint-disable max-classes-per-file */
+import { fixture, html, expect, elementUpdated } from '@open-wc/testing';
+
+import {
+  isFocusableComponent,
+  getFocusableElements
+} from '../Focusables.mjs';
+
+describe('isFocusableComponent', () => {
+  it('returns true for enabled custom focusable components', async () => {
+    for (const tag of [
+      'auro-checkbox', 'auro-radio', 'auro-dropdown', 'auro-button', 'auro-combobox',
+      'auro-input', 'auro-counter', 'auro-select', 'auro-datepicker',
+      'auro-hyperlink', 'auro-accordion'
+    ]) {
+      const el = document.createElement(tag);
+      if (tag === 'auro-hyperlink') {
+        el.setAttribute('href', '#');
+      }
+      document.body.appendChild(el);
+      expect(isFocusableComponent(el)).to.be.true;
+      el.remove();
+    }
+  });
+
+  it('returns false for custom components with disabled attribute', async () => {
+    for (const tag of [
+      'auro-checkbox', 'auro-radio', 'auro-dropdown', 'auro-button', 'auro-combobox',
+      'auro-input', 'auro-counter', 'auro-select', 'auro-datepicker',
+      'auro-hyperlink', 'auro-accordion'
+    ]) {
+      const el = document.createElement(tag);
+      el.setAttribute('disabled', '');
+      if (tag === 'auro-hyperlink') {
+        el.setAttribute('href', '#');
+      }
+      document.body.appendChild(el);
+      expect(isFocusableComponent(el)).to.be.false;
+      el.remove();
+    }
+  });
+
+  it('returns false for auro-hyperlink without href', async () => {
+    const el = document.createElement('auro-hyperlink');
+    document.body.appendChild(el);
+    expect(isFocusableComponent(el)).to.be.false;
+    el.remove();
+  });
+
+  it('returns false for non-custom elements', async () => {
+    const el = document.createElement('div');
+    document.body.appendChild(el);
+    expect(isFocusableComponent(el)).to.be.false;
+    el.remove();
+  });
+});
+
+describe('getFocusableElements', () => {
+  it('finds standard focusable elements', async () => {
+    const el = await fixture(html`
+      <div>
+        <button id="btn"></button>
+        <input id="input">
+        <a id="link" href="#"></a>
+        <textarea id="ta"></textarea>
+        <select id="sel"></select>
+      </div>
+    `);
+    const focusables = getFocusableElements(el);
+    expect(focusables.map(e => e.id)).to.include.members(['btn', 'input', 'link', 'ta', 'sel']);
+  });
+
+  it('skips disabled elements', async () => {
+    const el = await fixture(html`
+      <div>
+        <button id="btn" disabled></button>
+        <input id="input" disabled>
+        <textarea id="ta" disabled></textarea>
+        <select id="sel" disabled></select>
+      </div>
+    `);
+    const focusables = getFocusableElements(el);
+    expect(focusables.length).to.equal(0);
+  });
+
+  it('finds custom focusable components', async () => {
+    const el = await fixture(html`
+      <div>
+        <auro-checkbox id="cb"></auro-checkbox>
+        <auro-hyperlink id="hl" href="#"></auro-hyperlink>
+        <auro-button id="ab"></auro-button>
+      </div>
+    `);
+    const focusables = getFocusableElements(el);
+    expect(focusables.map(e => e.id)).to.include.members(['cb', 'hl', 'ab']);
+  });
+
+  it('skips disabled custom components', async () => {
+    const el = await fixture(html`
+      <div>
+        <auro-checkbox id="cb" disabled></auro-checkbox>
+        <auro-hyperlink id="hl" disabled href="#"></auro-hyperlink>
+      </div>
+    `);
+    const focusables = getFocusableElements(el);
+    expect(focusables.length).to.equal(0);
+  });
+
+  it('finds elements in shadow DOM', async () => {
+    class ShadowEl extends HTMLElement {
+      constructor() {
+        super();
+        this.attachShadow({ mode: 'open' });
+      }
+      connectedCallback() {
+        this.shadowRoot.innerHTML = `<button id="shadowBtn"></button>`;
+      }
+    }
+    customElements.define('shadow-el', ShadowEl);
+    const el = await fixture(html`
+      <div>
+        <shadow-el id="host"></shadow-el>
+      </div>
+    `);
+    await elementUpdated(el);
+    const focusables = getFocusableElements(el);
+    // Should find the button inside shadow DOM
+    const shadowBtn = el.querySelector('shadow-el').shadowRoot.getElementById('shadowBtn');
+    expect(focusables).to.include(shadowBtn);
+  });
+
+  it('finds elements assigned to slots', async () => {
+    class SlotEl extends HTMLElement {
+      constructor() {
+        super();
+        this.attachShadow({ mode: 'open' });
+      }
+      connectedCallback() {
+        this.shadowRoot.innerHTML = `<slot></slot>`;
+      }
+    }
+    customElements.define('slot-el', SlotEl);
+    const el = await fixture(html`
+      <slot-el>
+        <button id="slottedBtn"></button>
+      </slot-el>
+    `);
+    await elementUpdated(el);
+    const focusables = getFocusableElements(el);
+    const slottedBtn = el.querySelector('#slottedBtn');
+    expect(focusables).to.include(slottedBtn);
+  });
+
+  it('does not return duplicates', async () => {
+    // This is a contrived case, but let's check that duplicates are not returned
+    const el = await fixture(html`
+      <div>
+        <button id="btn"></button>
+      </div>
+    `);
+    const focusables = getFocusableElements(el);
+    // Should only have one instance of the button
+    expect(focusables.filter(e => e.id === 'btn').length).to.equal(1);
+  });
+});

package/scripts/runtime/dateUtilities/baseDateUtilities.mjs

@@ -0,0 +1,58 @@
+import { DATE_UTIL_CONSTRAINTS } from "./dateConstraints.mjs";
+
+export class AuroDateUtilitiesBase {
+
+  /**
+   * @description The maximum day value allowed by the various utilities in this class.
+   * @readonly
+   * @type {Number}
+   */
+  get maxDay() {
+    return DATE_UTIL_CONSTRAINTS.maxDay;
+  }
+
+  /**
+   * @description The maximum month value allowed by the various utilities in this class.
+   * @readonly
+   * @type {Number}
+   */
+  get maxMonth() {
+    return DATE_UTIL_CONSTRAINTS.maxMonth;
+  }
+
+  /**
+   * @description The maximum year value allowed by the various utilities in this class.
+   * @readonly
+   * @type {Number}
+   */
+  get maxYear() {
+    return DATE_UTIL_CONSTRAINTS.maxYear;
+  }
+
+  /**
+   * @description The minimum day value allowed by the various utilities in this class.
+   * @readonly
+   * @type {Number}
+   */
+  get minDay() {
+    return DATE_UTIL_CONSTRAINTS.minDay;
+  }
+
+  /**
+   * @description The minimum month value allowed by the various utilities in this class.
+   * @readonly
+   * @type {Number}
+   */
+  get minMonth() {
+    return DATE_UTIL_CONSTRAINTS.minMonth;
+  }
+
+  /**
+   * @description The minimum year value allowed by the various utilities in this class.
+   * @readonly
+   * @type {Number}
+   */
+  get minYear() {
+    return DATE_UTIL_CONSTRAINTS.minYear;
+  }
+};

package/scripts/runtime/dateUtilities/dateConstraints.mjs

@@ -0,0 +1,11 @@
+// filepath: dateConstraints.mjs
+const DATE_UTIL_CONSTRAINTS = {
+  maxDay: 31,
+  maxMonth: 12,
+  maxYear: 2400,
+  minDay: 1,
+  minMonth: 1,
+  minYear: 1900,
+};
+
+export { DATE_UTIL_CONSTRAINTS };

package/scripts/runtime/dateUtilities/dateFormatter.mjs

@@ -0,0 +1,104 @@
+class DateFormatter {
+
+  constructor() {
+
+    /**
+     * @description Parses a date string into its components.
+     * @param {string} dateStr - Date string to parse.
+     * @param {string} format - Date format to parse.
+     * @returns {Object<key["month" | "day" | "year"]: number>|undefined}
+     */
+    this.parseDate = (dateStr, format = 'mm/dd/yyyy') => {
+
+      // Guard Clause: Date string is defined
+      if (!dateStr) {
+        return undefined;
+      }
+
+      // Assume the separator is a "/" a defined in our code base
+      const separator = '/';
+
+      // Get the parts of the date and format
+      const valueParts = dateStr.split(separator);
+      const formatParts = format.split(separator);
+
+      // Check if the value and format have the correct number of parts
+      if (valueParts.length !== formatParts.length) {
+        throw new Error('AuroDatepickerUtilities | parseDate: Date string and format length do not match');
+      }
+
+      // Holds the result to be returned
+      const result = formatParts.reduce((acc, part, index) => {
+        const value = valueParts[index];
+
+        if ((/m/iu).test(part)) {
+          acc.month = value;
+        } else if ((/d/iu).test(part)) {
+          acc.day = value;
+        } else if ((/y/iu).test(part)) {
+          acc.year = value;
+        }
+
+        return acc;
+      }, {});
+
+      // If we found all the parts, return the result
+      if (result.month && result.year) {
+        return result;
+      }
+
+      // Throw an error to let the dev know we were unable to parse the date string
+      throw new Error('AuroDatepickerUtilities | parseDate: Unable to parse date string');
+    };
+
+    /**
+     * Convert a date object to string format.
+     * @param {Object} date - Date to convert to string.
+     * @param {String} locale - Optional locale to use for the date string. Defaults to user's locale.
+     * @returns {String} Returns the date as a string.
+     */
+    this.getDateAsString = (date, locale = undefined) => date.toLocaleDateString(locale, {
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+    });
+
+    /**
+     * Converts a date string to a North American date format.
+     * @param {String} dateStr - Date to validate.
+     * @param {String} format - Date format to validate against.
+     * @returns {Boolean}
+     */
+    this.toNorthAmericanFormat = (dateStr, format) => {
+
+      if (format === 'mm/dd/yyyy') {
+        return dateStr;
+      }
+
+      const parsedDate = this.parseDate(dateStr, format);
+
+      if (!parsedDate) {
+        throw new Error('AuroDatepickerUtilities | toNorthAmericanFormat: Unable to parse date string');
+      }
+
+      const { month, day, year } = parsedDate;
+
+      const dateParts = [];
+      if (month) {
+        dateParts.push(month);
+      }
+
+      if (day) {
+        dateParts.push(day);
+      }
+
+      if (year) {
+        dateParts.push(year);
+      }
+
+      return dateParts.join('/');
+    };
+  }
+};
+
+export const dateFormatter = new DateFormatter();

package/scripts/runtime/dateUtilities/dateUtilities.mjs

@@ -0,0 +1,218 @@
+/* eslint-disable no-magic-numbers */
+import { AuroDateUtilitiesBase } from "./baseDateUtilities.mjs";
+import { dateFormatter } from "./dateFormatter.mjs";
+
+export class AuroDateUtilities extends AuroDateUtilitiesBase {
+
+  /**
+   * Returns the current century.
+   * @returns {String} The current century.
+   */
+  getCentury () {
+    return String(new Date().getFullYear()).slice(0, 2);
+  }
+
+  /**
+   * Returns a four digit year.
+   * @param {String} year - The year to convert to four digits.
+   * @returns {String} The four digit year.
+   */
+  getFourDigitYear (year) {
+
+    const strYear = String(year).trim();
+    return strYear.length <= 2 ? this.getCentury() + strYear : strYear;
+  }
+
+  constructor() {
+
+    super();
+
+    /**
+     * Compares two dates to see if they match.
+     * @param {Object} date1 - First date to compare.
+     * @param {Object} date2 - Second date to compare.
+     * @returns {Boolean} Returns true if the dates match.
+     */
+    this.datesMatch = (date1, date2) => new Date(date1).getTime() === new Date(date2).getTime();
+
+    /**
+     * Returns true if value passed in is a valid date.
+     * @param {String} date - Date to validate.
+     * @param {String} format - Date format to validate against.
+     * @returns {Boolean}
+     */
+    this.validDateStr = (date, format) => {
+
+      // The length we expect the date string to be
+      const dateStrLength = format.length;
+
+      // Guard Clause: Date and format are defined
+      if (typeof date === "undefined" || typeof format === "undefined") {
+        throw new Error('AuroDatepickerUtilities | validateDateStr: Date and format are required');
+      }
+
+      // Guard Clause: Date should be of type string
+      if (typeof date !== "string") {
+        throw new Error('AuroDatepickerUtilities | validateDateStr: Date must be a string');
+      }
+
+      // Guard Clause: Format should be of type string
+      if (typeof format !== "string") {
+        throw new Error('AuroDatepickerUtilities | validateDateStr: Format must be a string');
+      }
+
+      // Guard Clause: Length is what we expect it to be
+      if (date.length !== dateStrLength) {
+        return false;
+      };
+
+      // Get a formatted date string and parse it
+      const dateParts = dateFormatter.parseDate(date, format);
+
+      // Guard Clause: Date parse succeeded
+      if (!dateParts) {
+        return false;
+      }
+
+      // Create the expected date string based on the date parts
+      const expectedDateStr = `${dateParts.month}/${dateParts.day || "01"}/${this.getFourDigitYear(dateParts.year)}`;
+
+      // Generate a date object that we will extract a string date from to compare to the passed in date string
+      const dateObj = new Date(this.getFourDigitYear(dateParts.year), dateParts.month - 1, dateParts.day || 1);
+
+      // Get the date string of the date object we created from the string date
+      const actualDateStr = dateFormatter.getDateAsString(dateObj, "en-US");
+
+      // Guard Clause: Generated date matches date string input
+      if (expectedDateStr !== actualDateStr) {
+        return false;
+      }
+
+      // If we passed all other checks, we can assume the date is valid
+      return true;
+    };
+
+    /**
+     * Determines if a string date value matches the format provided.
+     * @param {string} value = The date string value.
+     * @param { string} format = The date format to match against.
+     * @returns {boolean}
+     */
+    this.dateAndFormatMatch = (value, format) => {
+
+      // Ensure we have both values we need to do the comparison
+      if (!value || !format) {
+        throw new Error('AuroFormValidation | dateFormatMatch: value and format are required');
+      }
+
+      // If the lengths are different, they cannot match
+      if (value.length !== format.length) {
+        return false;
+      }
+
+      // Get the parts of the date
+      const dateParts = dateFormatter.parseDate(value, format);
+
+      // Validator for day
+      const dayValueIsValid = (day) => {
+
+        // Guard clause: if there is no day in the dateParts, we can ignore this check.
+        if (!dateParts.day) {
+          return true;
+        }
+
+        // Guard clause: ensure day exists.
+        if (!day) {
+          return false;
+        }
+
+        // Convert day to number
+        const numDay = Number.parseInt(day, 10);
+
+        // Guard clause: ensure day is a valid integer
+        if (Number.isNaN(numDay)) {
+          throw new Error('AuroDatepickerUtilities | dayValueIsValid: Unable to parse day value integer');
+        }
+
+        // Guard clause: ensure day is within the valid range
+        if (numDay < this.minDay || numDay > this.maxDay) {
+          return false;
+        }
+
+        // Default return
+        return true;
+      };
+
+      // Validator for month
+      const monthValueIsValid = (month) => {
+
+        // Guard clause: ensure month exists.
+        if (!month) {
+          return false;
+        }
+
+        // Convert month to number
+        const numMonth = Number.parseInt(month, 10);
+
+        // Guard clause: ensure month is a valid integer
+        if (Number.isNaN(numMonth)) {
+          throw new Error('AuroDatepickerUtilities | monthValueIsValid: Unable to parse month value integer');
+        }
+
+        // Guard clause: ensure month is within the valid range
+        if (numMonth < this.minMonth || numMonth > this.maxMonth) {
+          return false;
+        }
+
+        // Default return
+        return true;
+      };
+
+      // Validator for year
+      const yearIsValid = (_year) => {
+
+        // Guard clause: ensure year exists.
+        if (!_year) {
+          return false;
+        }
+
+        // Get the full year
+        const year = this.getFourDigitYear(_year);
+
+        // Convert year to number
+        const numYear = Number.parseInt(year, 10);
+
+        // Guard clause: ensure year is a valid integer
+        if (Number.isNaN(numYear)) {
+          throw new Error('AuroDatepickerUtilities | yearValueIsValid: Unable to parse year value integer');
+        }
+
+        // Guard clause: ensure year is within the valid range
+        if (numYear < this.minYear || numYear > this.maxYear) {
+          return false;
+        }
+
+        // Default return
+        return true;
+      };
+
+      // Self-contained checks for month, day, and year
+      const checks = [
+        monthValueIsValid(dateParts.month),
+        dayValueIsValid(dateParts.day),
+        yearIsValid(dateParts.year)
+      ];
+
+      // If any of the checks failed, the date format does not match and the result is invalid
+      const isValid = checks.every((check) => check === true);
+
+      //  If the check is invalid, return false
+      if (!isValid) {
+        return false;
+      }
+
+      // Default case
+      return true;
+    };
+  }
+}

package/scripts/runtime/dateUtilities/index.mjs

@@ -0,0 +1,26 @@
+import { dateFormatter } from './dateFormatter.mjs';
+import { AuroDateUtilities } from './dateUtilities.mjs';
+
+export { AuroDateUtilities } from './dateUtilities.mjs';
+
+// Export a class instance
+export const dateUtilities = new AuroDateUtilities();
+
+// Export the class instance methods individually
+export const {
+  datesMatch,
+  validDateStr,
+  dateAndFormatMatch,
+  minDay,
+  minMonth,
+  minYear,
+  maxDay,
+  maxMonth,
+  maxYear
+} = dateUtilities;
+
+export const {
+  toNorthAmericanFormat,
+  parseDate,
+  getDateAsString
+} = dateFormatter;

package/scripts/runtime/dependencyTagVersioning.mjs

@@ -0,0 +1,42 @@
+// Copyright (c) Alaska Air. All right reserved. Licensed under the Apache-2.0 license
+// See LICENSE in the project root for license information.
+
+// ---------------------------------------------------------------------
+
+import { literal, unsafeStatic } from 'lit/static-html.js';
+
+export class AuroDependencyVersioning {
+
+  /**
+   * Generates a unique string to be used for child auro element naming.
+   * @private
+   * @param {string} baseName - Defines the first part of the unique element name.
+   * @param {string} version - Version of the component that will be appended to the baseName.
+   * @returns {string} - Unique string to be used for naming.
+   */
+  generateElementName(baseName, version) {
+    let result = baseName;
+
+    result += '-';
+    result += version.replace(/[.]/g, '_');
+
+    return result;
+  }
+
+  /**
+   * Generates a unique string to be used for child auro element naming.
+   * @param {string} baseName - Defines the first part of the unique element name.
+   * @param {string} version - Version of the component that will be appended to the baseName.
+   * @returns {string} - Unique string to be used for naming.
+   */
+  generateTag(baseName, version, tagClass) {
+    const elementName = this.generateElementName(baseName, version);
+    const tag = literal`${unsafeStatic(elementName)}`;
+
+    if (!customElements.get(elementName)) {
+      customElements.define(elementName, class extends tagClass {});
+    }
+
+    return tag;
+  }
+}