@aurodesignsystem/auro-library 5.12.2 → 5.13.0

package/scripts/runtime/dateUtilities/dateFormatter.test.js

@@ -0,0 +1,284 @@
+import { expect } from "@open-wc/testing";
+import { dateFormatter } from "./dateFormatter.mjs";
+
+describe("dateFormatter.parseDate", () => {
+  describe("null / undefined / empty input", () => {
+    it("returns undefined for null", () => {
+      expect(dateFormatter.parseDate(null)).to.be.undefined;
+    });
+
+    it("returns undefined for undefined", () => {
+      expect(dateFormatter.parseDate(undefined)).to.be.undefined;
+    });
+
+    it("returns undefined for empty string", () => {
+      expect(dateFormatter.parseDate("")).to.be.undefined;
+    });
+  });
+});
+
+describe("dateFormatter.toNorthAmericanFormat", () => {
+  it("returns the string unchanged for mm/dd/yyyy", () => {
+    expect(
+      dateFormatter.toNorthAmericanFormat("01/15/2024", "mm/dd/yyyy"),
+    ).to.equal("01/15/2024");
+  });
+
+  it("reorders dd/mm/yyyy to mm/dd/yyyy", () => {
+    expect(
+      dateFormatter.toNorthAmericanFormat("15/01/2024", "dd/mm/yyyy"),
+    ).to.equal("01/15/2024");
+  });
+
+  it("reorders yyyy-mm-dd to mm/dd/yyyy", () => {
+    expect(
+      dateFormatter.toNorthAmericanFormat("2024-01-15", "yyyy-mm-dd"),
+    ).to.equal("01/15/2024");
+  });
+
+  it("throws when the date string cannot be parsed", () => {
+    expect(() =>
+      dateFormatter.toNorthAmericanFormat(null, "dd/mm/yyyy"),
+    ).to.throw(Error);
+  });
+});
+
+describe("dateFormatter.stringToDateInstance", () => {
+  describe("ISO input", () => {
+    const isoCases = [
+      { input: "2024-01-15", description: "typical ISO date" },
+      { input: "1999-12-31", description: "end of year ISO date" },
+    ];
+
+    isoCases.forEach(({ input, description }) => {
+      it(`creates Date directly from ISO string for: ${description}`, () => {
+        const result = dateFormatter.stringToDateInstance(input);
+
+        expect(result).to.be.instanceOf(Date);
+        expect(result.toISOString().slice(0, 10)).to.equal(input);
+      });
+    });
+  });
+
+  describe("non-ISO input with explicit format", () => {
+    it("returns a Date using parseDate result for dd/mm/yyyy format", () => {
+      const inputStr = "15/01/2024";
+      const expectedYear = 2024;
+      const expectedMonth = 1; // January (1-based)
+      const expectedDay = 15;
+
+      const result = dateFormatter.stringToDateInstance(inputStr, "dd/mm/yyyy");
+
+      expect(result).to.be.instanceOf(Date);
+      expect(result.getFullYear()).to.equal(expectedYear);
+      expect(result.getMonth()).to.equal(expectedMonth - 1);
+      expect(result.getDate()).to.equal(expectedDay);
+    });
+  });
+
+  describe("default format behaviour", () => {
+    it("uses default format parameter when format is not provided", () => {
+      const inputStr = "2024-02-29";
+
+      const result = dateFormatter.stringToDateInstance(inputStr);
+
+      expect(result).to.be.instanceOf(Date);
+      expect(result.getFullYear()).to.equal(2024);
+      expect(result.getMonth()).to.equal(1);
+      expect(result.getDate()).to.equal(29);
+    });
+  });
+
+  describe("month adjustment", () => {
+    it("correctly adjusts month from 1-based to 0-based when creating Date", () => {
+      const inputStr = "2024-12-31";
+
+      const result = dateFormatter.stringToDateInstance(inputStr);
+
+      expect(result.getFullYear()).to.equal(2024);
+      expect(result.getMonth()).to.equal(11);
+      expect(result.getDate()).to.equal(31);
+    });
+  });
+});
+
+describe("dateFormatter.isValidDate", () => {
+  describe("valid date inputs", () => {
+    const validCases = [
+      {
+        args: ["2024-02-29"],
+        description: "valid leap day ISO (default format)",
+      },
+      {
+        args: ["1999-12-31", "yyyy-mm-dd"],
+        description: "valid ISO with explicit format",
+      },
+      {
+        args: ["12/31/1999", "mm/dd/yyyy"],
+        description: "valid mm/dd/yyyy",
+      },
+      {
+        args: ["31-01-2020", "dd-mm-yyyy"],
+        description: "valid dd-mm-yyyy",
+      },
+      {
+        args: ["01/15/01", "mm/dd/yy"],
+        description: "2-digit year below 50 normalizes to 20xx (01 → 2001)",
+      },
+      {
+        args: ["12/31/99", "mm/dd/yy"],
+        description: "2-digit year >= 50 normalizes to 19xx (99 → 1999)",
+      },
+    ];
+
+    validCases.forEach(({ args, description }) => {
+      it(`returns true for: ${description}`, () => {
+        const result = dateFormatter.isValidDate(...args);
+        expect(result, `Expected ${JSON.stringify(args)} to be a valid date`).to
+          .be.true;
+      });
+    });
+  });
+
+  describe("invalid date inputs", () => {
+    const invalidCases = [
+      {
+        args: ["02/2024", "mm/yyyy"],
+        description: "short format mm/yyyy",
+      },
+      {
+        args: ["2024/02", "yyyy/mm"],
+        description: "short format yyyy/mm",
+      },
+      {
+        args: ["2024", "yyyy"],
+        description: "short format yyyy",
+      },
+      { args: ["2024-02-30"], description: "invalid ISO day" },
+      {
+        args: ["12/31/1999", "yyyy-mm-dd"],
+        description: "non-ISO string with yyyy-mm-dd format",
+      },
+      {
+        args: ["02/30/2024", "mm/dd/yyyy"],
+        description: "invalid mm/dd/yyyy with impossible day",
+      },
+      {
+        args: [null, "mm/dd/yyyy"],
+        description: "non-string date value",
+      },
+      {
+        args: ["13/2024", "mm/yyyy"],
+        description: "invalid mm/yyyy with month out of range",
+      },
+      {
+        args: ["00/24", "mm/yy"],
+        description: "invalid mm/yy with month below range",
+      },
+      {
+        args: ["02/24", "mm/yy"],
+        description: "invalid mm/yy",
+      },
+      {
+        args: ["2024/13", "yyyy/mm"],
+        description: "invalid yyyy/mm with month out of range",
+      },
+      {
+        args: ["ab24", "yyyy"],
+        description: "invalid yyyy with non-numeric value",
+      },
+      {
+        args: ["2a", "yy"],
+        description: "invalid yy with non-numeric value",
+      },
+      {
+        args: ["24", "yy"],
+        description: "invalid yy",
+      },
+      {
+        args: ["00", "mm"],
+        description: "invalid mm below range",
+      },
+      {
+        args: ["12", "mm"],
+        description: "invalid mm",
+      },
+      {
+        args: ["00", "dd"],
+        description: "invalid dd below range",
+      },
+      {
+        args: ["31", "dd"],
+        description: "invalid dd",
+      },
+      {
+        args: ["32", "dd"],
+        description: "invalid dd above range",
+      },
+    ];
+
+    invalidCases.forEach(({ args, description }) => {
+      it(`returns false for: ${description}`, () => {
+        const result = dateFormatter.isValidDate(...args);
+        expect(result, `Expected ${JSON.stringify(args)} to be an invalid date`)
+          .to.be.false;
+      });
+    });
+  });
+});
+
+describe("dateFormatter.toISOFormatString", () => {
+  describe("valid Date inputs", () => {
+    const validCases = [
+      {
+        input: new Date("2024/01/15"),
+        expected: "2024-01-15",
+        description: "typical date",
+      },
+      {
+        input: new Date("1999/12/31"),
+        expected: "1999-12-31",
+        description: "end of year",
+      },
+      {
+        input: new Date("2024/02/29"),
+        expected: "2024-02-29",
+        description: "leap day",
+      },
+      {
+        input: new Date("2000/01/01"),
+        expected: "2000-01-01",
+        description: "first day of millennium",
+      },
+      {
+        input: new Date("2024/12/31"),
+        expected: "2024-12-31",
+        description: "last day of year",
+      },
+    ];
+
+    validCases.forEach(({ input, expected, description }) => {
+      it(`returns "${expected}" for: ${description}`, () => {
+        const result = dateFormatter.toISOFormatString(input);
+        expect(result).to.equal(expected);
+      });
+    });
+  });
+
+  describe("invalid inputs", () => {
+    const invalidCases = [
+      { input: new Date("not-a-date"), description: "invalid Date instance" },
+      { input: "2024-01-15", description: "string input" },
+      { input: null, description: "null input" },
+      { input: undefined, description: "undefined input" },
+      { input: 20240115, description: "number input" },
+      { input: {}, description: "plain object input" },
+    ];
+
+    invalidCases.forEach(({ input, description }) => {
+      it(`throws for: ${description}`, () => {
+        expect(() => dateFormatter.toISOFormatString(input)).to.throw(Error);
+      });
+    });
+  });
+});

package/scripts/runtime/dateUtilities/dateUtilities.mjs

@@ -3,12 +3,11 @@ 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 () {
+  getCentury() {
     return String(new Date().getFullYear()).slice(0, 2);
   }
 
@@ -17,14 +16,12 @@ export class AuroDateUtilities extends AuroDateUtilitiesBase {
    * @param {String} year - The year to convert to four digits.
    * @returns {String} The four digit year.
    */
-  getFourDigitYear (year) {
-
+  getFourDigitYear(year) {
     const strYear = String(year).trim();
     return strYear.length <= 2 ? this.getCentury() + strYear : strYear;
   }
 
   constructor() {
-
     super();
 
     /**
@@ -33,7 +30,8 @@ export class AuroDateUtilities extends AuroDateUtilitiesBase {
      * @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();
+    this.datesMatch = (date1, date2) =>
+      new Date(date1).getTime() === new Date(date2).getTime();
 
     /**
      * Returns true if value passed in is a valid date.
@@ -42,54 +40,41 @@ export class AuroDateUtilities extends AuroDateUtilitiesBase {
      * @returns {Boolean}
      */
     this.validDateStr = (date, format) => {
-
       // The length we expect the date string to be
-      const dateStrLength = format.length;
+      const dateStrLength = format?.length || 0;
 
       // Guard Clause: Date and format are defined
       if (typeof date === "undefined" || typeof format === "undefined") {
-        throw new Error('AuroDatepickerUtilities | validateDateStr: Date and format are required');
+        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');
+        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');
+        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) {
+      // Get a formatted date string and parse and validate it
+      try {
+        return Boolean(dateFormatter.parseDate(date, format));
+      } catch (error) {
         return false;
       }
-
-      // If we passed all other checks, we can assume the date is valid
-      return true;
     };
 
     /**
@@ -99,10 +84,11 @@ export class AuroDateUtilities extends AuroDateUtilitiesBase {
      * @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');
+        throw new Error(
+          "AuroFormValidation | dateFormatMatch: value and format are required",
+        );
       }
 
       // If the lengths are different, they cannot match
@@ -111,11 +97,10 @@ export class AuroDateUtilities extends AuroDateUtilitiesBase {
       }
 
       // Get the parts of the date
-      const dateParts = dateFormatter.parseDate(value, format);
+      const dateParts = dateFormatter.getDateParts(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;
@@ -131,7 +116,9 @@ export class AuroDateUtilities extends AuroDateUtilitiesBase {
 
         // Guard clause: ensure day is a valid integer
         if (Number.isNaN(numDay)) {
-          throw new Error('AuroDatepickerUtilities | dayValueIsValid: Unable to parse day value integer');
+          throw new Error(
+            "AuroDatepickerUtilities | dayValueIsValid: Unable to parse day value integer",
+          );
         }
 
         // Guard clause: ensure day is within the valid range
@@ -145,6 +132,10 @@ export class AuroDateUtilities extends AuroDateUtilitiesBase {
 
       // Validator for month
       const monthValueIsValid = (month) => {
+        // Guard clause: if there is no month in the dateParts, we can ignore this check.
+        if (!dateParts.month) {
+          return true;
+        }
 
         // Guard clause: ensure month exists.
         if (!month) {
@@ -156,7 +147,9 @@ export class AuroDateUtilities extends AuroDateUtilitiesBase {
 
         // Guard clause: ensure month is a valid integer
         if (Number.isNaN(numMonth)) {
-          throw new Error('AuroDatepickerUtilities | monthValueIsValid: Unable to parse month value integer');
+          throw new Error(
+            "AuroDatepickerUtilities | monthValueIsValid: Unable to parse month value integer",
+          );
         }
 
         // Guard clause: ensure month is within the valid range
@@ -170,6 +163,10 @@ export class AuroDateUtilities extends AuroDateUtilitiesBase {
 
       // Validator for year
       const yearIsValid = (_year) => {
+        // Guard clause: if there is no year in the dateParts, we can ignore this check.
+        if (!dateParts.year) {
+          return true;
+        }
 
         // Guard clause: ensure year exists.
         if (!_year) {
@@ -184,7 +181,9 @@ export class AuroDateUtilities extends AuroDateUtilitiesBase {
 
         // Guard clause: ensure year is a valid integer
         if (Number.isNaN(numYear)) {
-          throw new Error('AuroDatepickerUtilities | yearValueIsValid: Unable to parse year value integer');
+          throw new Error(
+            "AuroDatepickerUtilities | yearValueIsValid: Unable to parse year value integer",
+          );
         }
 
         // Guard clause: ensure year is within the valid range
@@ -200,7 +199,7 @@ export class AuroDateUtilities extends AuroDateUtilitiesBase {
       const checks = [
         monthValueIsValid(dateParts.month),
         dayValueIsValid(dateParts.day),
-        yearIsValid(dateParts.year)
+        yearIsValid(dateParts.year),
       ];
 
       // If any of the checks failed, the date format does not match and the result is invalid

package/scripts/runtime/dateUtilities/dateUtilities.test.js

@@ -0,0 +1,80 @@
+import { expect } from "@open-wc/testing";
+import { AuroDateUtilities } from "./dateUtilities.mjs";
+
+const utils = new AuroDateUtilities();
+
+describe("AuroDateUtilities.validDateStr", () => {
+  it("throws when date is undefined", () => {
+    expect(() => utils.validDateStr(undefined, "mm/dd/yyyy")).to.throw(Error);
+  });
+
+  it("throws when format is undefined", () => {
+    expect(() => utils.validDateStr("01/15/2024", undefined)).to.throw(Error);
+  });
+
+  it("throws when date is not a string", () => {
+    expect(() => utils.validDateStr(20240115, "mm/dd/yyyy")).to.throw(Error);
+  });
+
+  it("returns false when date length does not match format length", () => {
+    expect(utils.validDateStr("01/15", "mm/dd/yyyy")).to.be.false;
+  });
+
+  it("returns true for a valid date matching its format", () => {
+    expect(utils.validDateStr("01/15/2024", "mm/dd/yyyy")).to.be.true;
+  });
+
+  it("returns false for an invalid calendar date (Feb 30)", () => {
+    expect(utils.validDateStr("02/30/2024", "mm/dd/yyyy")).to.be.false;
+  });
+});
+
+describe("AuroDateUtilities.dateAndFormatMatch", () => {
+  it("throws when value is falsy", () => {
+    expect(() => utils.dateAndFormatMatch(null, "mm/dd/yyyy")).to.throw(Error);
+  });
+
+  it("throws when format is falsy", () => {
+    expect(() => utils.dateAndFormatMatch("01/15/2024", null)).to.throw(Error);
+  });
+
+  it("returns false when value length differs from format length", () => {
+    expect(utils.dateAndFormatMatch("01/15", "mm/dd/yyyy")).to.be.false;
+  });
+
+  it("returns true for a value that matches the format", () => {
+    expect(utils.dateAndFormatMatch("01/15/2024", "mm/dd/yyyy")).to.be.true;
+  });
+
+  it("returns false when month is below range", () => {
+    expect(utils.dateAndFormatMatch("00/15/2024", "mm/dd/yyyy")).to.be.false;
+  });
+
+  it("returns false when month is above range", () => {
+    expect(utils.dateAndFormatMatch("13/15/2024", "mm/dd/yyyy")).to.be.false;
+  });
+
+  it("returns false when day is below range", () => {
+    expect(utils.dateAndFormatMatch("01/00/2024", "mm/dd/yyyy")).to.be.false;
+  });
+
+  it("returns false when day is above range", () => {
+    expect(utils.dateAndFormatMatch("01/32/2024", "mm/dd/yyyy")).to.be.false;
+  });
+
+  it("returns false when year is below range", () => {
+    expect(utils.dateAndFormatMatch("01/15/1899", "mm/dd/yyyy")).to.be.false;
+  });
+
+  it("returns false when year is above range", () => {
+    expect(utils.dateAndFormatMatch("01/15/2401", "mm/dd/yyyy")).to.be.false;
+  });
+
+  it("skips day check when format has no day component", () => {
+    expect(utils.dateAndFormatMatch("01/2024", "mm/yyyy")).to.be.true;
+  });
+
+  it("skips month check when format has no month component", () => {
+    expect(utils.dateAndFormatMatch("15/2024", "dd/yyyy")).to.be.true;
+  });
+});