@checkdigit/time 3.0.0-PR.17-5aaf → 4.0.0-PR.18-81a3

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

@@ -4,6 +4,7 @@ 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 +22,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 +40,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,7 +72,7 @@ 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
@@ -119,13 +123,13 @@ 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;
+      dateStrings.date = dateString.split(patterns.timeZoneDelimiter)[0]!;
       timeString = dateString.substr(dateStrings.date.length, dateString.length);
     }
   }
@@ -133,8 +137,8 @@ function splitDateString(dateString: string): DateString {
   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;
     }
@@ -158,7 +162,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 +175,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)) {
@@ -200,9 +204,9 @@ 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;
@@ -222,7 +226,7 @@ function parseTimezone(timezoneString: string): number {
   if (!captures) return 0;
 
   const sign = captures[1] === '+' ? -1 : 1;
-  const hours = parseInt(captures[2] as string);
+  const hours = parseInt(captures[2]!);
   const minutes = (captures[3] && parseInt(captures[3])) || 0;
 
   if (!validateTimezone(hours, minutes)) {

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,30 +21,31 @@
  * - `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[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),
       ),
     );

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

@@ -0,0 +1,129 @@
+import { describe, expect, it } from 'vitest';
+import { parseJSON } from './index';
+import { format } from '../format/index';
+
+describe('parseJSON', () => {
+  it('parses a formatted new Date() back to UTC - issue 2149', () => {
+    const date = new Date();
+    const jsonFormat = format(date, "yyyy-MM-dd'T'HH:mm:ss.SSSxxx");
+    const parsedDate = parseJSON(jsonFormat);
+    expect(parsedDate.toISOString()).toBe(date.toISOString());
+  });
+
+  it('parses a formatted date with an hour of offset back to UTC - issue 2149', () => {
+    const date = '2021-01-09T13:18:10.873+01:00';
+    const expectedDate = new Date('2021-01-09T12:18:10.873Z');
+    const parsedDate = parseJSON(date);
+    expect(parsedDate.toISOString()).toBe(expectedDate.toISOString());
+  });
+
+  it('parses a formatted date with 2 hours of offset back to UTC - issue 2149', () => {
+    const date = '2021-01-09T13:18:10.873+02:00';
+    const expectedDate = new Date('2021-01-09T11:18:10.873Z');
+    const parsedDate = parseJSON(date);
+    expect(parsedDate.toISOString()).toBe(expectedDate.toISOString());
+  });
+
+  it('parses a formatted date with -2 hours of offset back to UTC - issue 2149', () => {
+    const date = '2021-01-09T13:18:10.873-02:00';
+    const expectedDate = new Date('2021-01-09T15:18:10.873Z');
+    const parsedDate = parseJSON(date);
+    expect(parsedDate.toISOString()).toBe(expectedDate.toISOString());
+  });
+
+  it('parses a formatted Indian Standart Time in Asia/Kolkata with +5:30 hours of offset back to UTC - issue 2149', () => {
+    const date = '2021-02-15T02:56:04.678+05:30';
+    const expectedDate = new Date('2021-02-14T21:26:04.678Z');
+    const parsedDate = parseJSON(date);
+    expect(parsedDate.toISOString()).toBe(expectedDate.toISOString());
+  });
+
+  it('parses a formatted time in Asia/Kathmandu with +5:45 hours of offset back to UTC - issue 2149', () => {
+    const date = '2021-02-15T17:45:00.900+05:45';
+    const expectedDate = new Date('2021-02-15T12:00:00.900Z');
+    const parsedDate = parseJSON(date);
+    expect(parsedDate.toISOString()).toBe(expectedDate.toISOString());
+  });
+
+  it('parses a fully formed ISO date with Z', () => {
+    const date = '2000-03-15T05:20:10.123Z';
+    const parsedDate = parseJSON(date);
+    expect(parsedDate.toISOString()).toBe(date);
+  });
+
+  it('parses a fully formed ISO date with Z without ms', () => {
+    const date = '2000-03-15T05:20:10Z';
+    const expectedDate = '2000-03-15T05:20:10.000Z';
+    const parsedDate = parseJSON(date);
+    expect(parsedDate.toISOString()).toBe(expectedDate);
+  });
+
+  it('parses a fully formed ISO date with zero offset', () => {
+    const zeroOffset = '2000-03-15T05:20:10+00:00';
+    const expectedDate = '2000-03-15T05:20:10.000Z';
+    const parsedDate = parseJSON(zeroOffset);
+    expect(parsedDate.toISOString()).toBe(expectedDate);
+  });
+
+  it('parses a fully formed ISO date with zero offset without colon', () => {
+    const zeroOffset = '2000-03-15T05:20:10+0000';
+    const expectedDate = '2000-03-15T05:20:10.000Z';
+    const parsedDate = parseJSON(zeroOffset);
+    expect(parsedDate.toISOString()).toBe(expectedDate);
+  });
+
+  it('parses a fully formed ISO date without Z', () => {
+    const date = '2000-03-15T05:20:10.123';
+    const expectedDate = '2000-03-15T05:20:10.123Z';
+    const parsedDate = parseJSON(date);
+    expect(parsedDate.toISOString()).toBe(expectedDate);
+  });
+
+  it('parses a fully formed ISO date without Z and with 6-digit millisecond part', () => {
+    const date = '2000-03-15T05:20:10.123456';
+    const expectedDate = '2000-03-15T05:20:10.123Z';
+    const parsedDate = parseJSON(date);
+    expect(parsedDate.toISOString()).toBe(expectedDate);
+  });
+
+  it('parses a fully formed ISO with 1-digit millisecond part', () => {
+    const date = '2000-03-15T05:20:10.1Z';
+    const expectedDate = '2000-03-15T05:20:10.100Z';
+    const parsedDate = parseJSON(date);
+    expect(parsedDate.toISOString()).toBe(expectedDate);
+  });
+
+  it('parses a fully formed ISO with 2-digit millisecond part', () => {
+    const date = '2000-03-15T05:20:10.12Z';
+    const expectedDate = '2000-03-15T05:20:10.120Z';
+    const parsedDate = parseJSON(date);
+    expect(parsedDate.toISOString()).toBe(expectedDate);
+  });
+
+  it('parses supported formats with a space time separator instead of a T', () => {
+    const date = '2000-03-15 05:20:10.123Z';
+    const expectedDate = '2000-03-15T05:20:10.123Z';
+    const parsedDate = parseJSON(date);
+    expect(parsedDate.toISOString()).toBe(expectedDate);
+  });
+
+  it('parses the SQL datetime format without milliseconds', () => {
+    const date = '2000-03-15 05:20:10';
+    const expectedDate = '2000-03-15T05:20:10.000Z';
+    const parsedDate = parseJSON(date);
+    expect(parsedDate.toISOString()).toBe(expectedDate);
+  });
+
+  it('parses the SQL datetime format with up to 7 millisecond digits', () => {
+    const date = '2000-03-15 05:20:10.1234567';
+    const expectedDate = '2000-03-15T05:20:10.123Z';
+    const parsedDate = parseJSON(date);
+    expect(parsedDate.toISOString()).toBe(expectedDate);
+  });
+
+  it('returns an invalid date for anything else', () => {
+    expect(parseJSON('').toString()).toBe('Invalid Date');
+    expect(parseJSON('invalid').toString()).toBe('Invalid Date');
+    expect(parseJSON('2020-10-10').toString()).toBe('Invalid Date');
+  });
+});

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

@@ -1,5 +1,5 @@
-import getDay from '../getDay/index';
-import subDays from '../subDays/index';
+import { getDay } from '../getDay/index';
+import { subDays } from '../subDays/index';
 import type { Day } from '../types';
 
 /**
@@ -10,9 +10,12 @@ import type { Day } from '../types';
  * @description
  * When is the previous day of the week? 0-6 the day of the week, 0 represents Sunday.
  *
- * @param date - the date to check
- * @param day - day of the week
- * @returns - the date is the previous day of week
+ * @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 date - The date to check
+ * @param day - The day of the week
+ *
+ * @returns The date is the previous day of week
  *
  * @example
  * // When is the previous Monday before Mar, 20, 2020?
@@ -24,7 +27,7 @@ import type { Day } from '../types';
  * const result = previousDay(new Date(2020, 2, 21), 2)
  * //=> Tue Mar 17 2020 00:00:00
  */
-export default function previousDay<DateType extends Date>(date: DateType | number, day: Day): DateType {
+export function previousDay<DateType extends Date>(date: DateType | number | string, day: Day): DateType {
   let delta = getDay(date) - day;
   if (delta <= 0) delta += 7;