@checkdigit/time 3.0.0-PR.17-58cd → 4.0.0-PR.18-9134

package/src/date-fns/parseISO/index.ts

@@ -1,9 +1,13 @@
-import { millisecondsInHour, millisecondsInMinute } from '../constants/index';
+import {
+  millisecondsInHour,
+  millisecondsInMinute,
+} from "../constants/index";
 
 /**
  * The {@link parseISO} function options.
  */
 export interface ParseISOOptions {
+  /** The additional number of digits in the extended year format */
   additionalDigits?: 0 | 1 | 2;
 }
 
@@ -21,9 +25,12 @@ export interface ParseISOOptions {
  * If the argument isn't a string, the function cannot parse the string or
  * the values are invalid, it returns Invalid Date.
  *
- * @param argument - the value to convert
- * @param options - an object with options.
- * @returns the parsed date in the local time zone
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ *
+ * @param argument - The value to convert
+ * @param options - An object with options
+ *
+ * @returns The parsed date in the local time zone
  *
  * @example
  * // Convert string '2014-02-11T11:30:30' to date:
@@ -36,7 +43,7 @@ export interface ParseISOOptions {
  * const result = parseISO('+02014101', { additionalDigits: 1 })
  * //=> Fri Apr 11 2014 00:00:00
  */
-export default function parseISO(argument: string, options?: ParseISOOptions): Date {
+export function parseISO(argument: string, options?: ParseISOOptions): Date {
   const additionalDigits = options?.additionalDigits ?? 2;
   const dateStrings = splitDateString(argument);
 
@@ -68,13 +75,17 @@ export default function parseISO(argument: string, options?: ParseISOOptions): D
     }
   } else {
     const dirtyDate = new Date(timestamp + time);
-    // js parsed string assuming it's in UTC timezone
+    // JS parsed string assuming it's in UTC timezone
     // but we need it to be parsed in our timezone
     // so we use utc values to build date in our timezone.
     // Year values from 0 to 99 map to the years 1900 to 1999
     // so set year explicitly with setFullYear.
     const result = new Date(0);
-    result.setFullYear(dirtyDate.getUTCFullYear(), dirtyDate.getUTCMonth(), dirtyDate.getUTCDate());
+    result.setFullYear(
+      dirtyDate.getUTCFullYear(),
+      dirtyDate.getUTCMonth(),
+      dirtyDate.getUTCDate(),
+    );
     result.setHours(
       dirtyDate.getUTCHours(),
       dirtyDate.getUTCMinutes(),
@@ -104,8 +115,10 @@ const patterns = {
   timezone: /([Z+-].*)$/,
 };
 
-const dateRegex = /^-?(?:(\d{3})|(\d{2})(?:-?(\d{2}))?|W(\d{2})(?:-?(\d{1}))?|)$/;
-const timeRegex = /^(\d{2}(?:[.,]\d*)?)(?::?(\d{2}(?:[.,]\d*)?))?(?::?(\d{2}(?:[.,]\d*)?))?$/;
+const dateRegex =
+  /^-?(?:(\d{3})|(\d{2})(?:-?(\d{2}))?|W(\d{2})(?:-?(\d{1}))?|)$/;
+const timeRegex =
+  /^(\d{2}(?:[.,]\d*)?)(?::?(\d{2}(?:[.,]\d*)?))?(?::?(\d{2}(?:[.,]\d*)?))?$/;
 const timezoneRegex = /^([+-])(\d{2})(?::?(\d{2}))?$/;
 
 function splitDateString(dateString: string): DateString {
@@ -119,22 +132,25 @@ function splitDateString(dateString: string): DateString {
     return dateStrings;
   }
 
-  if (/:/.test(array[0] as string)) {
+  if (/:/.test(array[0]!)) {
     timeString = array[0];
   } else {
-    dateStrings.date = array[0] as string;
+    dateStrings.date = array[0]!;
     timeString = array[1];
     if (patterns.timeZoneDelimiter.test(dateStrings.date)) {
-      dateStrings.date = dateString.split(patterns.timeZoneDelimiter)[0] as string;
-      timeString = dateString.substr(dateStrings.date.length, dateString.length);
+      dateStrings.date = dateString.split(patterns.timeZoneDelimiter)[0]!;
+      timeString = dateString.substr(
+        dateStrings.date.length,
+        dateString.length,
+      );
     }
   }
 
   if (timeString) {
     const token = patterns.timezone.exec(timeString);
     if (token) {
-      dateStrings.time = timeString.replace(token[1] as string, '');
-      dateStrings.timezone = token[1] as string;
+      dateStrings.time = timeString.replace(token[1]!, "");
+      dateStrings.timezone = token[1]!;
     } else {
       dateStrings.time = timeString;
     }
@@ -145,12 +161,16 @@ function splitDateString(dateString: string): DateString {
 
 function parseYear(dateString: string, additionalDigits: number): ParsedYear {
   const regex = new RegExp(
-    '^(?:(\\d{4}|[+-]\\d{' + (4 + additionalDigits) + '})|(\\d{2}|[+-]\\d{' + (2 + additionalDigits) + '})$)',
+    "^(?:(\\d{4}|[+-]\\d{" +
+      (4 + additionalDigits) +
+      "})|(\\d{2}|[+-]\\d{" +
+      (2 + additionalDigits) +
+      "})$)",
   );
 
   const captures = dateString.match(regex);
   // Invalid ISO-formatted year
-  if (!captures) return { year: NaN, restDateString: '' };
+  if (!captures) return { year: NaN, restDateString: "" };
 
   const year = captures[1] ? parseInt(captures[1]) : null;
   const century = captures[2] ? parseInt(captures[2]) : null;
@@ -158,7 +178,7 @@ function parseYear(dateString: string, additionalDigits: number): ParsedYear {
   // either year or century is null, not both
   return {
     year: century === null ? (year as number) : century * 100,
-    restDateString: dateString.slice(((captures[1] as string) || (captures[2] as string)).length),
+    restDateString: dateString.slice((captures[1] || captures[2]!).length),
   };
 }
 
@@ -171,11 +191,11 @@ function parseDate(dateString: string, year: number): Date {
   if (!captures) return new Date(NaN);
 
   const isWeekDate = !!captures[4];
-  const dayOfYear = parseDateUnit(captures[1] as string);
-  const month = parseDateUnit(captures[2] as string) - 1;
-  const day = parseDateUnit(captures[3] as string);
-  const week = parseDateUnit(captures[4] as string);
-  const dayOfWeek = parseDateUnit(captures[5] as string) - 1;
+  const dayOfYear = parseDateUnit(captures[1]!);
+  const month = parseDateUnit(captures[2]!) - 1;
+  const day = parseDateUnit(captures[3]!);
+  const week = parseDateUnit(captures[4]!);
+  const dayOfWeek = parseDateUnit(captures[5]!) - 1;
 
   if (isWeekDate) {
     if (!validateWeekDate(year, week, dayOfWeek)) {
@@ -184,7 +204,10 @@ function parseDate(dateString: string, year: number): Date {
     return dayOfISOWeekYear(year, week, dayOfWeek);
   } else {
     const date = new Date(0);
-    if (!validateDate(year, month, day) || !validateDayOfYearDate(year, dayOfYear)) {
+    if (
+      !validateDate(year, month, day) ||
+      !validateDayOfYearDate(year, dayOfYear)
+    ) {
       return new Date(NaN);
     }
     date.setUTCFullYear(year, month, Math.max(dayOfYear, day));
@@ -200,29 +223,31 @@ function parseTime(timeString: string): number {
   const captures = timeString.match(timeRegex);
   if (!captures) return NaN; // Invalid ISO-formatted time
 
-  const hours = parseTimeUnit(captures[1] as string);
-  const minutes = parseTimeUnit(captures[2] as string);
-  const seconds = parseTimeUnit(captures[3] as string);
+  const hours = parseTimeUnit(captures[1]!);
+  const minutes = parseTimeUnit(captures[2]!);
+  const seconds = parseTimeUnit(captures[3]!);
 
   if (!validateTime(hours, minutes, seconds)) {
     return NaN;
   }
 
-  return hours * millisecondsInHour + minutes * millisecondsInMinute + seconds * 1000;
+  return (
+    hours * millisecondsInHour + minutes * millisecondsInMinute + seconds * 1000
+  );
 }
 
 function parseTimeUnit(value: string): number {
-  return (value && parseFloat(value.replace(',', '.'))) || 0;
+  return (value && parseFloat(value.replace(",", "."))) || 0;
 }
 
 function parseTimezone(timezoneString: string): number {
-  if (timezoneString === 'Z') return 0;
+  if (timezoneString === "Z") return 0;
 
   const captures = timezoneString.match(timezoneRegex);
   if (!captures) return 0;
 
-  const sign = captures[1] === '+' ? -1 : 1;
-  const hours = parseInt(captures[2] as string);
+  const sign = captures[1] === "+" ? -1 : 1;
+  const hours = parseInt(captures[2]!);
   const minutes = (captures[3] && parseInt(captures[3])) || 0;
 
   if (!validateTimezone(hours, minutes)) {
@@ -232,7 +257,11 @@ function parseTimezone(timezoneString: string): number {
   return sign * (hours * millisecondsInHour + minutes * millisecondsInMinute);
 }
 
-function dayOfISOWeekYear(isoWeekYear: number, week: number, day: number): Date {
+function dayOfISOWeekYear(
+  isoWeekYear: number,
+  week: number,
+  day: number,
+): Date {
   const date = new Date(0);
   date.setUTCFullYear(isoWeekYear, 0, 4);
   const fourthOfJanuaryDay = date.getUTCDay() || 7;
@@ -251,7 +280,12 @@ function isLeapYearIndex(year: number): boolean {
 }
 
 function validateDate(year: number, month: number, date: number): boolean {
-  return month >= 0 && month <= 11 && date >= 1 && date <= (daysInMonths[month] || (isLeapYearIndex(year) ? 29 : 28));
+  return (
+    month >= 0 &&
+    month <= 11 &&
+    date >= 1 &&
+    date <= (daysInMonths[month] || (isLeapYearIndex(year) ? 29 : 28))
+  );
 }
 
 function validateDayOfYearDate(year: number, dayOfYear: number): boolean {
@@ -262,12 +296,23 @@ function validateWeekDate(_year: number, week: number, day: number): boolean {
   return week >= 1 && week <= 53 && day >= 0 && day <= 6;
 }
 
-function validateTime(hours: number, minutes: number, seconds: number): boolean {
+function validateTime(
+  hours: number,
+  minutes: number,
+  seconds: number,
+): boolean {
   if (hours === 24) {
     return minutes === 0 && seconds === 0;
   }
 
-  return seconds >= 0 && seconds < 60 && minutes >= 0 && minutes < 60 && hours >= 0 && hours < 25;
+  return (
+    seconds >= 0 &&
+    seconds < 60 &&
+    minutes >= 0 &&
+    minutes < 60 &&
+    hours >= 0 &&
+    hours < 25
+  );
 }
 
 function validateTimezone(_hours: number, minutes: number): boolean {

package/src/date-fns/parseISO/test.mts

@@ -0,0 +1,362 @@
+import { describe, expect, it } from "vitest";
+import { parseISO } from "./index";
+
+describe("parseISO", () => {
+  describe("string argument", () => {
+    describe("centuries", () => {
+      it("parses YY", () => {
+        const result = parseISO("20");
+        expect(result).toEqual(new Date(2000, 0 /* Jan */, 1));
+      });
+    });
+
+    describe("years", () => {
+      it("parses YYYY", () => {
+        const result = parseISO("2014");
+        expect(result).toEqual(new Date(2014, 0 /* Jan */, 1));
+      });
+    });
+
+    describe("months", () => {
+      it("parses YYYY-MM", () => {
+        const result = parseISO("2014-02");
+        expect(result).toEqual(new Date(2014, 1 /* Feb */, 1));
+      });
+    });
+
+    describe("weeks", () => {
+      it("parses YYYY-Www", () => {
+        const result = parseISO("2014-W02");
+        expect(result).toEqual(new Date(2014, 0 /* Jan */, 6));
+      });
+
+      it("parses YYYYWww", () => {
+        const result = parseISO("2014W02");
+        expect(result).toEqual(new Date(2014, 0 /* Jan */, 6));
+      });
+    });
+
+    describe("calendar dates", () => {
+      it("parses YYYY-MM-DD", () => {
+        const result = parseISO("2014-02-11");
+        expect(result).toEqual(new Date(2014, 1, /* Feb */ 11));
+      });
+
+      it("parses YYYYMMDD", () => {
+        const result = parseISO("20140211");
+        expect(result).toEqual(new Date(2014, 1 /* Feb */, 11));
+      });
+    });
+
+    describe("week dates", () => {
+      it("parses YYYY-Www-D", () => {
+        const result = parseISO("2014-W02-7");
+        expect(result).toEqual(new Date(2014, 0 /* Jan */, 12));
+      });
+
+      it("parses YYYYWwwD", () => {
+        const result = parseISO("2014W027");
+        expect(result).toEqual(new Date(2014, 0 /* Jan */, 12));
+      });
+
+      it("correctly handles years in which 4 January is Sunday", () => {
+        const result = parseISO("2009-W01-1");
+        expect(result).toEqual(new Date(2008, 11 /* Dec */, 29));
+      });
+    });
+
+    describe("ordinal dates", () => {
+      it("parses YYYY-DDD", () => {
+        const result = parseISO("2014-026");
+        expect(result).toEqual(new Date(2014, 0 /* Jan */, 26));
+      });
+
+      it("parses YYYYDDD", () => {
+        const result = parseISO("2014026");
+        expect(result).toEqual(new Date(2014, 0 /* Jan */, 26));
+      });
+    });
+
+    describe("date and time combined", () => {
+      it("parses YYYY-MM-DDThh:mm", () => {
+        const result = parseISO("2014-02-11T11:30");
+        expect(result).toEqual(new Date(2014, 1 /* Feb */, 11, 11, 30));
+      });
+
+      it("parses YYYY-MM-DDThhmm", () => {
+        const result = parseISO("2014-02-11T1130");
+        expect(result).toEqual(new Date(2014, 1 /* Feb */, 11, 11, 30));
+      });
+    });
+
+    describe("extended century representation", () => {
+      it("parses century 101 BC - 2 BC", () => {
+        const result = parseISO("-0001");
+        const date = new Date(0);
+        date.setFullYear(-100, 0 /* Jan */, 1);
+        date.setHours(0, 0, 0, 0);
+        expect(result).toEqual(date);
+      });
+
+      it("parses century 1 BC - 99 AD", () => {
+        const result = parseISO("00");
+        const date = new Date(0);
+        date.setFullYear(0, 0 /* Jan */, 1);
+        date.setHours(0, 0, 0, 0);
+        expect(result).toEqual(date);
+      });
+
+      it("parses centuries after 9999 AD", () => {
+        const result = parseISO("+0123");
+        expect(result).toEqual(new Date(12300, 0 /* Jan */, 1));
+      });
+
+      it("allows to specify the number of additional digits", () => {
+        const result = parseISO("-20", { additionalDigits: 0 });
+        const date = new Date(0);
+        date.setFullYear(-2000, 0 /* Jan */, 1);
+        date.setHours(0, 0, 0, 0);
+        expect(result).toEqual(date);
+      });
+    });
+
+    describe("extended year representation", () => {
+      it("correctly parses years from 1 AD to 99 AD", () => {
+        const result = parseISO("0095-07-02");
+        const date = new Date(0);
+        date.setFullYear(95, 6 /* Jul */, 2);
+        date.setHours(0, 0, 0, 0);
+        expect(result).toEqual(date);
+      });
+
+      it("parses years after 9999 AD", () => {
+        const result = parseISO("+012345-07-02");
+        expect(result).toEqual(new Date(12345, 6 /* Jul */, 2));
+      });
+
+      it("allows to specify the number of additional digits", () => {
+        const result = parseISO("+12340702", { additionalDigits: 0 });
+        expect(result).toEqual(new Date(1234, 6 /* Jul */, 2));
+      });
+
+      it("parses year 1 BC", () => {
+        const result = parseISO("0000-07-02");
+        const date = new Date(0);
+        date.setFullYear(0, 6 /* Jul */, 2);
+        date.setHours(0, 0, 0, 0);
+        expect(result).toEqual(date);
+      });
+
+      it("parses years less than 1 BC", () => {
+        const result = parseISO("-000001-07-02");
+        const date = new Date(0);
+        date.setFullYear(-1, 6 /* Jul */, 2);
+        date.setHours(0, 0, 0, 0);
+        expect(result).toEqual(date);
+      });
+    });
+
+    describe("float time", () => {
+      it("parses float hours", () => {
+        const result = parseISO("2014-02-11T11.5");
+        expect(result).toEqual(new Date(2014, 1 /* Feb */, 11, 11, 30));
+      });
+
+      it("parses float minutes", () => {
+        const result = parseISO("2014-02-11T11:30.5");
+        expect(result).toEqual(new Date(2014, 1 /* Feb */, 11, 11, 30, 30));
+      });
+
+      it("parses float seconds", () => {
+        const result = parseISO("2014-02-11T11:30:30.768");
+        expect(result).toEqual(new Date(2014, 1 /* Feb */, 11, 11, 30, 30, 768));
+      });
+
+      it("parses , as decimal mark", () => {
+        const result = parseISO("2014-02-11T11,5");
+        expect(result).toEqual(new Date(2014, 1 /* Feb */, 11, 11, 30));
+      });
+    });
+
+    describe("timezones", () => {
+      describe("when the date and the time are specified", () => {
+        it("parses Z", () => {
+          const result = parseISO("2014-10-25T06:46:20Z");
+          expect(result).toEqual(new Date("2014-10-25T13:46:20+07:00"));
+        });
+
+        it("parses ±hh:mm", () => {
+          const result = parseISO("2014-10-25T13:46:20+07:00");
+          expect(result).toEqual(new Date("2014-10-25T13:46:20+07:00"));
+        });
+
+        it("parses ±hhmm", () => {
+          const result = parseISO("2014-10-25T03:46:20-0300");
+          expect(result).toEqual(new Date("2014-10-25T13:46:20+07:00"));
+        });
+
+        it("parses ±hh", () => {
+          const result = parseISO("2014-10-25T13:46:20+07");
+          expect(result).toEqual(new Date("2014-10-25T13:46:20+07:00"));
+        });
+      });
+      describe("when the year and the month are specified", () => {
+        it("sets timezone correctly on yyyy-MMZ format", () => {
+          const result = parseISO("2012-01Z");
+          expect(result).toEqual(new Date("2012-01-01T00:00:00+00:00"));
+        });
+      });
+    });
+
+    describe("failure", () => {
+      it("returns `Invalid Date` if the string is not an ISO formatted date", () => {
+        const result = parseISO(new Date(2014, 8 /* Sep */, 1, 11).toString());
+        expect(result instanceof Date).toBe(true);
+        expect(isNaN(result.getTime())).toBe(true);
+      });
+    });
+  });
+
+  describe("validation", () => {
+    describe("months", () => {
+      it("returns `Invalid Date` for invalid month", () => {
+        const result = parseISO("2014-00");
+        expect(result instanceof Date).toBe(true);
+        expect(isNaN(result.getTime())).toBe(true);
+      });
+    });
+
+    describe("weeks", () => {
+      it("returns `Invalid Date` for invalid week", () => {
+        const result = parseISO("2014-W00");
+        expect(result instanceof Date).toBe(true);
+        expect(isNaN(result.getTime())).toBe(true);
+      });
+
+      it("returns `Invalid Date` for 54th week", () => {
+        const result = parseISO("2014-W54");
+        expect(result instanceof Date).toBe(true);
+        expect(isNaN(result.getTime())).toBe(true);
+      });
+    });
+
+    describe("calendar dates", () => {
+      it("returns `Invalid Date` for invalid day of the month", () => {
+        const result = parseISO("2012-02-30");
+        expect(result instanceof Date).toBe(true);
+        expect(isNaN(result.getTime())).toBe(true);
+      });
+
+      it("returns `Invalid Date` for 29th of February of non-leap year", () => {
+        const result = parseISO("2014-02-29");
+        expect(result instanceof Date).toBe(true);
+        expect(isNaN(result.getTime())).toBe(true);
+      });
+
+      it("parses 29th of February of leap year", () => {
+        const result = parseISO("2012-02-29");
+        expect(result).toEqual(new Date(2012, 1, /* Feb */ 29));
+      });
+    });
+
+    describe("week dates", () => {
+      it("returns `Invalid Date` for invalid day of the week", () => {
+        const result = parseISO("2014-W02-0");
+        expect(result instanceof Date).toBe(true);
+        expect(isNaN(result.getTime())).toBe(true);
+      });
+    });
+
+    describe("ordinal dates", () => {
+      it("returns `Invalid Date` for invalid day of the year", () => {
+        const result = parseISO("2012-000");
+        expect(result instanceof Date).toBe(true);
+        expect(isNaN(result.getTime())).toBe(true);
+      });
+
+      it("returns `Invalid Date` for 366th day of non-leap year", () => {
+        const result = parseISO("2014-366");
+        expect(result instanceof Date).toBe(true);
+        expect(isNaN(result.getTime())).toBe(true);
+      });
+
+      it("parses 366th day of leap year", () => {
+        const result = parseISO("2012-366");
+        expect(result).toEqual(new Date(2012, 11, /* Dec */ 31));
+      });
+    });
+
+    describe("date", () => {
+      it("returns `Invalid Date` when it contains spaces after the date", () => {
+        const result = parseISO("2014-02-11  basketball");
+        expect(result instanceof Date).toBe(true);
+        expect(isNaN(result.getTime())).toBe(true);
+      });
+    });
+
+    describe("time", () => {
+      it("parses 24:00 as midnight of the next day", () => {
+        const result = parseISO("2014-02-11T24:00");
+        expect(result).toEqual(new Date(2014, 1 /* Feb */, 12, 0, 0));
+      });
+
+      it("returns `Invalid Date` for anything after 24:00", () => {
+        const result = parseISO("2014-02-11T24:01");
+        expect(result instanceof Date).toBe(true);
+        expect(isNaN(result.getTime())).toBe(true);
+      });
+
+      it("returns `Invalid Date` for invalid hours", () => {
+        const result = parseISO("2014-02-11T25");
+        expect(result instanceof Date).toBe(true);
+        expect(isNaN(result.getTime())).toBe(true);
+      });
+
+      it("returns `Invalid Date` for invalid minutes", () => {
+        const result = parseISO("2014-02-11T21:60");
+        expect(result instanceof Date).toBe(true);
+        expect(isNaN(result.getTime())).toBe(true);
+      });
+
+      it("returns `Invalid Date` for invalid seconds", () => {
+        const result = parseISO("2014-02-11T21:59:60");
+        expect(result instanceof Date).toBe(true);
+        expect(isNaN(result.getTime())).toBe(true);
+      });
+
+      it("returns `Invalid Date` for invalid time", () => {
+        const result = parseISO("2014-02-11T21:basketball");
+        expect(result instanceof Date).toBe(true);
+        expect(isNaN(result.getTime())).toBe(true);
+      });
+
+      it("returns `Invalid Date` when it contains spaces after the time", () => {
+        const result = parseISO("2014-02-11T21:59:00  basketball");
+        expect(result instanceof Date).toBe(true);
+        expect(isNaN(result.getTime())).toBe(true);
+      });
+    });
+
+    describe("timezones", () => {
+      it("returns `Invalid Date` for invalid timezone minutes", () => {
+        const result = parseISO("2014-02-11T21:35:45+04:60");
+        expect(result instanceof Date).toBe(true);
+        expect(isNaN(result.getTime())).toBe(true);
+      });
+    });
+  });
+
+  describe("invalid argument", () => {
+    it("returns Invalid Date if argument is non-date string", () => {
+      const result = parseISO("abc");
+      expect(result instanceof Date).toBe(true);
+      expect(isNaN(result.getTime())).toBe(true);
+    });
+
+    it("returns Invalid Date if argument is non-date string containing a colon", () => {
+      const result = parseISO("00:00");
+      expect(result instanceof Date).toBe(true);
+      expect(isNaN(result.getTime())).toBe(true);
+    });
+  });
+});

package/src/date-fns/parseJSON/index.ts

@@ -21,31 +21,32 @@
  * - `2000-03-15 05:20:10`: With a space instead of a 'T' separator for APIs returning a SQL date without reformatting
  *
  * For convenience and ease of use these other input types are also supported
- * via [toDate]{@link https://date-fns.org/docs/toDate}:
+ * via [toDate](https://date-fns.org/docs/toDate):
  *
  * - A `Date` instance will be cloned
  * - A `number` will be treated as a timestamp
  *
  * Any other input type or invalid date strings will return an `Invalid Date`.
  *
- * @param argument A fully formed ISO8601 date string to convert
- * @returns the parsed date in the local time zone
+ * @param dateStr - A fully formed ISO8601 date string to convert
+ *
+ * @returns The parsed date in the local time zone
  */
-export default function parseJSON(dateString: string): Date {
-  const parts = dateString.match(
+export function parseJSON(dateStr: string): Date {
+  const parts = dateStr.match(
     /(\d{4})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2}):(\d{2})(?:\.(\d{0,7}))?(?:Z|(.)(\d{2}):?(\d{2})?)?/,
   );
   if (parts) {
     // Group 8 matches the sign
     return new Date(
       Date.UTC(
-        +(parts[1] as string),
-        +(parts[2] as string) - 1,
-        +(parts[3] as string),
-        +(parts[4] as string) - (+(parts[9] as string) || 0) * (parts[8] == '-' ? -1 : 1),
-        +(parts[5] as string) - (+(parts[10] as string) || 0) * (parts[8] == '-' ? -1 : 1),
-        +(parts[6] as string),
-        +((parts[7] || '0') + '00').substring(0, 3),
+        +parts[1]!,
+        +parts[2]! - 1,
+        +parts[3]!,
+        +parts[4]! - (+parts[9]! || 0) * (parts[8] == "-" ? -1 : 1),
+        +parts[5]! - (+parts[10]! || 0) * (parts[8] == "-" ? -1 : 1),
+        +parts[6]!,
+        +((parts[7] || "0") + "00").substring(0, 3),
       ),
     );
   }