@checkdigit/time 4.0.0-PR.18-9134 → 4.0.0-PR.18-e0fa

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

@@ -1,362 +0,0 @@
-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/test.mts

@@ -1,129 +0,0 @@
-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/test.mts

@@ -1,42 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { previousDay } from "./index";
-
-describe("previousDay", () => {
-  it("returns the previous Monday given various dates after the same", () => {
-    expect(previousDay(new Date(2021, 5 /* Jun */, 18), 1)).toEqual(new Date(2021, 5 /* Jun */, 14));
-
-    expect(previousDay(new Date(2021, 5 /* Jun */, 17), 1)).toEqual(new Date(2021, 5 /* Jun */, 14));
-
-    expect(previousDay(new Date(2021, 5 /* Jun */, 14), 1)).toEqual(new Date(2021, 5 /* Jun */, 7));
-
-    expect(previousDay(new Date(2021, 5 /* Jun */, 9), 1)).toEqual(new Date(2021, 5 /* Jun */, 7));
-
-    expect(previousDay(new Date(2021, 5 /* Jun */, 8), 1)).toEqual(new Date(2021, 5 /* Jun */, 7));
-
-    expect(previousDay(new Date(2021, 5 /* Jun */, 7), 1)).toEqual(new Date(2021, 4 /* May */, 31));
-  });
-
-  it("returns the previous Tuesday given the Saturday after it", () => {
-    expect(previousDay(new Date(2021, 5 /* Jun */, 26), 2)).toEqual(new Date(2021, 5 /* Jun */, 22));
-  });
-
-  it("returns the previous Wednesday given the Saturday after it", () => {
-    expect(previousDay(new Date(2021, 5 /* Jun */, 26), 3)).toEqual(new Date(2021, 5 /* Jun */, 23));
-  });
-
-  it("returns the previous Thursday given the Saturday after it", () => {
-    expect(previousDay(new Date(2021, 5 /* Jun */, 26), 4)).toEqual(new Date(2021, 5 /* Jun */, 24));
-  });
-
-  it("returns the previous Friday given the Saturday after it", () => {
-    expect(previousDay(new Date(2021, 5 /* Jun */, 26), 5)).toEqual(new Date(2021, 5 /* Jun */, 25));
-  });
-
-  it("returns the previous Saturday given the Saturday after it", () => {
-    expect(previousDay(new Date(2021, 5 /* Jun */, 26), 6)).toEqual(new Date(2021, 5 /* Jun */, 19));
-  });
-
-  it("returns the previous Sunday given the day is Sunday", () => {
-    expect(previousDay(new Date(2021, 5 /* Jun */, 27), 0)).toEqual(new Date(2021, 5 /* Jun */, 20));
-  });
-});

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

@@ -1,22 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { previousFriday } from "./index";
-
-describe("previousFriday", () => {
-  it("returns the previous Friday given various dates after the same", () => {
-    expect(previousFriday(new Date(2021, 5 /* Jun */, 5))).toEqual(new Date(2021, 5 /* Jun */, 4));
-
-    expect(previousFriday(new Date(2021, 5 /* Jun */, 6))).toEqual(new Date(2021, 5 /* Jun */, 4));
-
-    expect(previousFriday(new Date(2021, 5 /* Jun */, 11))).toEqual(new Date(2021, 5 /* Jun */, 4));
-
-    expect(previousFriday(new Date(2021, 5 /* Jun */, 14))).toEqual(new Date(2021, 5 /* Jun */, 11));
-
-    expect(previousFriday(new Date(2021, 5 /* Jun */, 15))).toEqual(new Date(2021, 5 /* Jun */, 11));
-
-    expect(previousFriday(new Date(2021, 5 /* Jun */, 24))).toEqual(new Date(2021, 5 /* Jun */, 18));
-  });
-
-  it("returns `Invalid Date` if the given date is invalid", () => {
-    expect(previousFriday(new Date(NaN)) instanceof Date).toBe(true);
-  });
-});

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

@@ -1,22 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { previousMonday } from "./index";
-
-describe("previousMonday", () => {
-  it("returns the previous Monday given various dates after the same", () => {
-    expect(previousMonday(new Date(2021, 5 /* Jun */, 5))).toEqual(new Date(2021, 4 /* May */, 31));
-
-    expect(previousMonday(new Date(2021, 5 /* Jun */, 6))).toEqual(new Date(2021, 4 /* May */, 31));
-
-    expect(previousMonday(new Date(2021, 5 /* Jun */, 7))).toEqual(new Date(2021, 4 /* May */, 31));
-
-    expect(previousMonday(new Date(2021, 5 /* Jun */, 14))).toEqual(new Date(2021, 5 /* Jun */, 7));
-
-    expect(previousMonday(new Date(2021, 5 /* Jun */, 15))).toEqual(new Date(2021, 5 /* Jun */, 14));
-
-    expect(previousMonday(new Date(2021, 5 /* Jun */, 16))).toEqual(new Date(2021, 5 /* Jun */, 14));
-  });
-
-  it("returns `Invalid Date` if the given date is invalid", () => {
-    expect(previousMonday(new Date(NaN)) instanceof Date).toBe(true);
-  });
-});

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

@@ -1,22 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { previousSaturday } from "./index";
-
-describe("previousSaturday", () => {
-  it("returns the previous Saturday given various dates after the same", () => {
-    expect(previousSaturday(new Date(2021, 5 /* Jun */, 7))).toEqual(new Date(2021, 5 /* Jun */, 5));
-
-    expect(previousSaturday(new Date(2021, 5 /* Jun */, 8))).toEqual(new Date(2021, 5 /* Jun */, 5));
-
-    expect(previousSaturday(new Date(2021, 5 /* Jun */, 12))).toEqual(new Date(2021, 5 /* Jun */, 5));
-
-    expect(previousSaturday(new Date(2021, 5 /* Jun */, 16))).toEqual(new Date(2021, 5 /* Jun */, 12));
-
-    expect(previousSaturday(new Date(2021, 5 /* Jun */, 17))).toEqual(new Date(2021, 5 /* Jun */, 12));
-
-    expect(previousSaturday(new Date(2021, 5 /* Jun */, 24))).toEqual(new Date(2021, 5 /* Jun */, 19));
-  });
-
-  it("returns `Invalid Date` if the given date is invalid", () => {
-    expect(previousSaturday(new Date(NaN)) instanceof Date).toBe(true);
-  });
-});

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

@@ -1,22 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { previousSunday } from "./index";
-
-describe("previousSunday", () => {
-  it("returns the previous Sunday given various dates after the same", () => {
-    expect(previousSunday(new Date(2021, 5 /* Jun */, 7))).toEqual(new Date(2021, 5 /* Jun */, 6));
-
-    expect(previousSunday(new Date(2021, 5 /* Jun */, 8))).toEqual(new Date(2021, 5 /* Jun */, 6));
-
-    expect(previousSunday(new Date(2021, 5 /* Jun */, 13))).toEqual(new Date(2021, 5 /* Jun */, 6));
-
-    expect(previousSunday(new Date(2021, 5 /* Jun */, 16))).toEqual(new Date(2021, 5 /* Jun */, 13));
-
-    expect(previousSunday(new Date(2021, 5 /* Jun */, 17))).toEqual(new Date(2021, 5 /* Jun */, 13));
-
-    expect(previousSunday(new Date(2021, 5 /* Jun */, 24))).toEqual(new Date(2021, 5 /* Jun */, 20));
-  });
-
-  it("returns `Invalid Date` if the given date is invalid", () => {
-    expect(previousSunday(new Date(NaN)) instanceof Date).toBe(true);
-  });
-});

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

@@ -1,22 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { previousThursday } from "./index";
-
-describe("previousThursday", () => {
-  it("returns the previous Thursday given various dates after the same", () => {
-    expect(previousThursday(new Date(2021, 5 /* Jun */, 5))).toEqual(new Date(2021, 5 /* Jun */, 3));
-
-    expect(previousThursday(new Date(2021, 5 /* Jun */, 6))).toEqual(new Date(2021, 5 /* Jun */, 3));
-
-    expect(previousThursday(new Date(2021, 5 /* Jun */, 10))).toEqual(new Date(2021, 5 /* Jun */, 3));
-
-    expect(previousThursday(new Date(2021, 5 /* Jun */, 14))).toEqual(new Date(2021, 5 /* Jun */, 10));
-
-    expect(previousThursday(new Date(2021, 5 /* Jun */, 15))).toEqual(new Date(2021, 5 /* Jun */, 10));
-
-    expect(previousThursday(new Date(2021, 5 /* Jun */, 24))).toEqual(new Date(2021, 5 /* Jun */, 17));
-  });
-
-  it("returns `Invalid Date` if the given date is invalid", () => {
-    expect(previousThursday(new Date(NaN)) instanceof Date).toBe(true);
-  });
-});

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

@@ -1,22 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { previousTuesday } from "./index";
-
-describe("previousTuesday", () => {
-  it("returns the previous Tuesday given various dates after the same", () => {
-    expect(previousTuesday(new Date(2021, 5 /* Jun */, 5))).toEqual(new Date(2021, 5 /* Jun */, 1));
-
-    expect(previousTuesday(new Date(2021, 5 /* Jun */, 6))).toEqual(new Date(2021, 5 /* Jun */, 1));
-
-    expect(previousTuesday(new Date(2021, 5 /* Jun */, 8))).toEqual(new Date(2021, 5 /* Jun */, 1));
-
-    expect(previousTuesday(new Date(2021, 5 /* Jun */, 15))).toEqual(new Date(2021, 5 /* Jun */, 8));
-
-    expect(previousTuesday(new Date(2021, 5 /* Jun */, 17))).toEqual(new Date(2021, 5 /* Jun */, 15));
-
-    expect(previousTuesday(new Date(2021, 5 /* Jun */, 18))).toEqual(new Date(2021, 5 /* Jun */, 15));
-  });
-
-  it("returns `Invalid Date` if the given date is invalid", () => {
-    expect(previousTuesday(new Date(NaN)) instanceof Date).toBe(true);
-  });
-});