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

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

@@ -1,35 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { formatISO9075 } from "./index";
-
-describe("formatISO9075", () => {
-  it("formats ISO-9075 extended date format", () => {
-    const date = new Date(2019, 2 /* Mar */, 3, 19, 0, 52, 123);
-    expect(formatISO9075(date)).toBe("2019-03-03 19:00:52");
-  });
-
-  it("accepts a timestamp", () => {
-    const date = new Date(2019, 2 /* Mar */, 3, 19, 0, 52, 123).getTime();
-    expect(formatISO9075(date)).toBe("2019-03-03 19:00:52");
-  });
-
-  it("formats ISO-8601 basic date format", () => {
-    const date = new Date(2019, 9 /* Oct */, 4, 12, 30, 13, 456);
-    expect(formatISO9075(date, { format: "basic" })).toBe("20191004 123013");
-  });
-
-  it("formats only date", () => {
-    const date = new Date(2019, 11 /* Dec */, 11, 1, 0, 0, 789);
-    expect(formatISO9075(date, { representation: "date", format: "extended" })).toBe("2019-12-11");
-    expect(formatISO9075(date, { representation: "date", format: "basic" })).toBe("20191211");
-  });
-
-  it("formats only time", () => {
-    const date = new Date(2019, 2 /* Mar */, 3, 19, 0, 52, 123);
-    expect(formatISO9075(date, { representation: "time", format: "extended" })).toBe("19:00:52");
-    expect(formatISO9075(date, { representation: "time", format: "basic" })).toBe("190052");
-  });
-
-  it("throws RangeError if the time value is invalid", () => {
-    expect(formatISO9075.bind(null, new Date(NaN))).toThrow(RangeError);
-  });
-});

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

@@ -1,75 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { formatISODuration } from "./index";
-import { intervalToDuration } from "../intervalToDuration/index";
-
-describe("formatISODuration", () => {
-  it("Everything returns correct duration for arbitrary dates", () => {
-    const start = new Date(1929, 0, 15, 12, 0, 0);
-    const end = new Date(1968, 3, 4, 19, 5, 0);
-    const result = formatISODuration(intervalToDuration({ start, end }));
-
-    expect(result).toBe("P39Y2M20DT7H5M0S");
-  });
-  it("Everything returns P1Y1M1DT1H1M1S (1 of everything)", () => {
-    const start = new Date(2020, 2, 1, 12, 0, 0);
-    const end = new Date(2021, 3, 2, 13, 1, 1);
-    const result = formatISODuration(intervalToDuration({ start, end }));
-
-    expect(result).toBe("P1Y1M1DT1H1M1S");
-  });
-  it("Returns P0Y0M0DT0H0M0S when the dates are the same", () => {
-    const start = new Date(2020, 2, 1, 12, 0, 0);
-    const end = new Date(2020, 2, 1, 12, 0, 0);
-    const result = formatISODuration(intervalToDuration({ start, end }));
-
-    expect(result).toBe("P0Y0M0DT0H0M0S");
-  });
-  it("Seconds returns P0Y0M0DT0H0M1S (1 second)", () => {
-    const start = new Date(2020, 2, 1, 12, 0, 0);
-    const end = new Date(2020, 2, 1, 12, 0, 1);
-    const result = formatISODuration(intervalToDuration({ start, end }));
-
-    expect(result).toBe("P0Y0M0DT0H0M1S");
-  });
-  it("Minutes returns P0Y0M0DT0H1M0S (1 minute)", () => {
-    const start = new Date(2020, 2, 1, 12, 0, 0);
-    const end = new Date(2020, 2, 1, 12, 1, 0);
-    const result = formatISODuration(intervalToDuration({ start, end }));
-
-    expect(result).toBe("P0Y0M0DT0H1M0S");
-  });
-  it("Hours returns P0Y0M0DT1H0M0S (1 hour)", () => {
-    const start = new Date(2020, 2, 1, 12, 0, 0);
-    const end = new Date(2020, 2, 1, 13, 0, 0);
-    const result = formatISODuration(intervalToDuration({ start, end }));
-
-    expect(result).toBe("P0Y0M0DT1H0M0S");
-  });
-  it("Days returns P0Y0M1DT0H0M0S (1 day)", () => {
-    const start = new Date(2020, 2, 1, 12, 0, 0);
-    const end = new Date(2020, 2, 2, 12, 0, 0);
-    const result = formatISODuration(intervalToDuration({ start, end }));
-
-    expect(result).toBe("P0Y0M1DT0H0M0S");
-  });
-  it("Months returns P0Y1M0DT0H0M0S (1 month)", () => {
-    const start = new Date(2020, 2, 1, 12, 0, 0);
-    const end = new Date(2020, 3, 1, 12, 0, 0);
-    const result = formatISODuration(intervalToDuration({ start, end }));
-
-    expect(result).toBe("P0Y1M0DT0H0M0S");
-  });
-  it("Years returns P1Y0M0DT0H0M1S (1 year)", () => {
-    const start = new Date(2020, 2, 1, 12, 0, 0);
-    const end = new Date(2021, 2, 1, 12, 0, 0);
-    const result = formatISODuration(intervalToDuration({ start, end }));
-
-    expect(result).toBe("P1Y0M0DT0H0M0S");
-  });
-
-  it("returns P0Y0M0DT0H0M0S when given an empty object", () => {
-    const result = formatISODuration({});
-
-    expect(result).toBe("P0Y0M0DT0H0M0S");
-  });
-});

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

@@ -1,44 +0,0 @@
-import { describe, expect, it } from "vitest";
-import sinon from "sinon";
-import { formatRFC3339 } from "./index";
-import { generateOffset } from "../_lib/test/index";
-
-describe("formatRFC3339", () => {
-  it("formats RFC-3339 date string", () => {
-    const date = new Date(2019, 2 /* Mar */, 3, 19, 0, 52, 123);
-    expect(formatRFC3339(date)).toBe(`2019-03-03T19:00:52${generateOffset(date)}`);
-
-    const getTimezoneOffsetStub = sinon.stub(
-      Date.prototype,
-      "getTimezoneOffset",
-    );
-
-    getTimezoneOffsetStub.returns(0);
-    expect(formatRFC3339(date)).toBe("2019-03-03T19:00:52Z");
-
-    getTimezoneOffsetStub.returns(480);
-    expect(formatRFC3339(date)).toBe("2019-03-03T19:00:52-08:00");
-
-    getTimezoneOffsetStub.restore();
-  });
-
-  it("accepts a timestamp", () => {
-    const date = new Date(2019, 9 /* Oct */, 4, 12, 30, 13, 456);
-    const time = date.getTime();
-    expect(formatRFC3339(time)).toBe(`2019-10-04T12:30:13${generateOffset(date)}`);
-  });
-
-  it("allows to specify digits of second fractions", () => {
-    const date = new Date(2019, 11 /* Dec */, 11, 1, 0, 0, 789);
-    expect(formatRFC3339(date, { fractionDigits: 3 })).toBe(`2019-12-11T01:00:00.789${generateOffset(date)}`);
-  });
-
-  it("works when ms < 100", () => {
-    const date = new Date(2019, 11 /* Dec */, 11, 1, 0, 0, 12);
-    expect(formatRFC3339(date, { fractionDigits: 2 })).toBe(`2019-12-11T01:00:00.01${generateOffset(date)}`);
-  });
-
-  it("throws RangeError if the time value is invalid", () => {
-    expect(formatRFC3339.bind(null, new Date(NaN))).toThrow(RangeError);
-  });
-});

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

@@ -1,18 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { formatRFC7231 } from "./index";
-
-describe("formatRFC7231", () => {
-  it("formats RFC-7231 date string", () => {
-    const date = new Date(Date.UTC(2019, 2, 3, 19, 0, 52));
-    expect(formatRFC7231(date)).toBe("Sun, 03 Mar 2019 19:00:52 GMT");
-  });
-
-  it("accepts a timestamp", () => {
-    const date = Date.UTC(2019, 9, 4, 12, 30, 13);
-    expect(formatRFC7231(date)).toBe("Fri, 04 Oct 2019 12:30:13 GMT");
-  });
-
-  it("throws RangeError if the time value is invalid", () => {
-    expect(formatRFC7231.bind(null, new Date(NaN))).toThrow(RangeError);
-  });
-});

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

@@ -1,118 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { formatRelative } from "./index";
-
-describe("formatRelative", () => {
-  const baseDate = new Date(1986, 3 /* Apr */, 4, 10, 32, 0, 900);
-
-  it("accepts a timestamp", () => {
-    const date = new Date(2014, 3 /* Apr */, 4);
-    expect(formatRelative(date.getTime(), baseDate.getTime())).toBe("04/04/2014");
-  });
-
-  it("before the last week", () => {
-    const result = formatRelative(
-      new Date(1986, 2 /* Mar */, 28, 16, 50),
-      baseDate,
-    );
-    expect(result).toBe("03/28/1986");
-  });
-
-  it("last week", () => {
-    const result = formatRelative(new Date(1986, 3 /* Apr */, 1), baseDate);
-    expect(result).toBe("last Tuesday at 12:00 AM");
-  });
-
-  it("yesterday", () => {
-    const result = formatRelative(
-      new Date(1986, 3 /* Apr */, 3, 22, 22),
-      baseDate,
-    );
-    expect(result).toBe("yesterday at 10:22 PM");
-  });
-
-  it("today", () => {
-    const result = formatRelative(
-      new Date(1986, 3 /* Apr */, 4, 16, 50),
-      baseDate,
-    );
-    expect(result).toBe("today at 4:50 PM");
-  });
-
-  it("tomorrow", () => {
-    const result = formatRelative(
-      new Date(1986, 3 /* Apr */, 5, 7, 30),
-      baseDate,
-    );
-    expect(result).toBe("tomorrow at 7:30 AM");
-  });
-
-  it("next week", () => {
-    const result = formatRelative(
-      new Date(1986, 3 /* Apr */, 6, 12, 0),
-      baseDate,
-    );
-    expect(result).toBe("Sunday at 12:00 PM");
-  });
-
-  it("after the next week", () => {
-    const result = formatRelative(
-      new Date(1986, 3 /* Apr */, 11, 16, 50),
-      baseDate,
-    );
-    expect(result).toBe("04/11/1986");
-  });
-
-  describe("edge cases", () => {
-    it("throws RangeError if the date isn't valid", () => {
-      expect(formatRelative.bind(null, new Date(NaN), baseDate)).toThrow(RangeError);
-    });
-
-    it("throws RangeError if the base date isn't valid", () => {
-      expect(formatRelative.bind(
-        null,
-        new Date(2017, 0 /* Jan */, 1),
-        new Date(NaN),
-      )).toThrow(RangeError);
-    });
-
-    it("throws RangeError if both dates aren't valid", () => {
-      expect(formatRelative.bind(null, new Date(NaN), new Date(NaN))).toThrow(RangeError);
-    });
-
-    it("handles dates before 100 AD", () => {
-      const date = new Date(0);
-      date.setFullYear(7, 11 /* Dec */, 31);
-      date.setHours(0, 0, 0, 0);
-      expect(formatRelative(date, baseDate)).toBe("12/31/0007");
-    });
-  });
-
-  describe("custom locale", () => {
-    it("allows to pass a custom locale", () => {
-      const customLocale = {
-        localize: {
-          month: () => {
-            return "works";
-          },
-        },
-        formatLong: {
-          date: () => {
-            return "'It' MMMM";
-          },
-        },
-        formatRelative: () => {
-          return "P 'perfectly!'";
-        },
-      };
-      const result = formatRelative(
-        new Date(1986, 2 /* Mar */, 28, 16, 50),
-        baseDate,
-        {
-          // @ts-expect-error - It's ok to have incomplete locale
-          locale: customLocale,
-        },
-      );
-      expect(result).toBe("It works perfectly!");
-    });
-  });
-});

package/src/date-fns/fp/_lib/convertToFP/test.mts

@@ -1,120 +0,0 @@
-import { pipe } from "fp-ts/function";
-import { flow as jsFnsFlow } from "js-fns";
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment -- Lodash types trip in different environemnts, so we can't put ts-expect-error
-// @ts-ignore - Lodash types are tripping ("Module '"lodash"' has no exported member 'flow'.ts(2305)")
-import { flow as lodashFlow } from "lodash";
-import { describe, expect, it } from "vitest";
-import { addDays, addHours, isEqual } from "../../index";
-import { convertToFP } from "./index";
-
-describe("convertToFP", () => {
-  function fn(a: unknown, b: unknown, c: unknown) {
-    return "a b c"
-      .replace("a", String(a))
-      .replace("b", String(b))
-      .replace("c", String(c));
-  }
-
-  describe("arity of converted function === arity of initial function", () => {
-    it("allows arguments to be curried (and reverses their order)", () => {
-      const fpFn = convertToFP(fn, 3);
-      expect(fpFn(3)(2)(1)).toBe("1 2 3");
-    });
-
-    it("allows to group arguments", () => {
-      const fpFn = convertToFP(fn, 3);
-      expect(fpFn(3, 2)(1)).toBe("1 2 3");
-      expect(fpFn(3)(2, 1)).toBe("1 2 3");
-    });
-
-    it("allows the function to be called with all arguments in the reversed order", () => {
-      const fpFn = convertToFP(fn, 3);
-      expect(fpFn(3, 2, 1)).toBe("1 2 3");
-    });
-
-    it("ignores calls without curried arguments", () => {
-      const fpFn = convertToFP(fn, 3);
-      expect(fpFn()()(3, 2)()()(1)).toBe("1 2 3");
-    });
-
-    it("ignores extra curried arguments in the last group", () => {
-      const fpFn = convertToFP(fn, 3);
-      // @ts-expect-error - It's ok, we're testing the function
-      expect(fpFn(3, 2, 1, 0, -1, -2)).toBe("1 2 3");
-      // @ts-expect-error - It's ok, we're testing the function
-      expect(fpFn(3)(2)(1, 0, -1, -2)).toBe("1 2 3");
-    });
-  });
-
-  describe("arity of converted function < arity of initial function", () => {
-    it("calls the initial function with a short list of arguments", () => {
-      const fpFn = convertToFP(fn, 2);
-      expect(fpFn(2)(1)).toBe("1 2 undefined");
-      expect(fpFn(2, 1)).toBe("1 2 undefined");
-    });
-
-    it("ignores extra curried arguments in the last group", () => {
-      const fpFn = convertToFP(fn, 2);
-      // @ts-expect-error - It's ok, we're testing the function
-      expect(fpFn(3)(2, 1)).toBe("2 3 undefined");
-      // @ts-expect-error - It's ok, we're testing the function
-      expect(fpFn(3, 2, 1)).toBe("2 3 undefined");
-    });
-  });
-
-  describe("arity of converted function > arity of initial function", () => {
-    it("works, but ignores the extra arguments", () => {
-      const fpFn = convertToFP(fn, 4);
-      // @ts-expect-error - It's ok, we're testing the function
-      expect(fpFn(4)(3)(2)(1)).toBe("1 2 3");
-      // @ts-expect-error - It's ok, we're testing the function
-      expect(fpFn(4, 3, 2, 1)).toBe("1 2 3");
-    });
-  });
-
-  describe("arity of converted function === 0", () => {
-    it("returns the constant instead of function", () => {
-      // @ts-expect-error - It's ok, we're testing the function
-      const result = convertToFP(fn, 0);
-      expect(result).toBe("undefined undefined undefined");
-    });
-  });
-
-  describe("types", () => {
-    it("resolves proper types", () => {
-      const fn1 = addDays();
-      const fn2 = fn1(1);
-      const result = fn2(new Date(1987, 1));
-      expect(result.getFullYear()).toBe(1987);
-    });
-  });
-
-  describe("Lodash", () => {
-    it("works with flow", () => {
-      const fn = lodashFlow(addDays(1), addHours(1));
-      const result = fn(new Date(1987, 1, 11));
-      expect(result.getFullYear()).toBe(1987);
-      expect(result).toEqual(new Date(1987, 1, 12, 1));
-    });
-  });
-
-  describe("fp-ts", () => {
-    it("works with pipe", () => {
-      const result = pipe(
-        new Date(1987, 1, 11),
-        isEqual(new Date(1987, 1, 11)),
-      );
-      const _assign: boolean = result;
-      expect(result).toBe(true);
-    });
-  });
-
-  describe("js-fns", () => {
-    it("works with flow", () => {
-      const fn = jsFnsFlow(addDays(1), addHours(1));
-      const result = fn(new Date(1987, 1, 11));
-      expect(result.getFullYear()).toBe(1987);
-      expect(result).toEqual(new Date(1987, 1, 12, 1));
-    });
-  });
-});

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

@@ -1,14 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { fromUnixTime } from "./index";
-
-describe("fromUnixTime", () => {
-  it("returns the date derived from the given UNIX timestamp", () => {
-    const result = fromUnixTime(1330515499);
-    expect(result.getTime()).toBe(1330515499000);
-  });
-
-  it("returns invalid if the given timestamp is invalid", () => {
-    const result = fromUnixTime(NaN);
-    expect(isNaN(result.getTime())).toBe(true);
-  });
-});

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

@@ -1,19 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { getDate } from "./index";
-
-describe("getDate", () => {
-  it("returns the day of the month of the given date", () => {
-    const result = getDate(new Date(2012, 1 /* Feb */, 29));
-    expect(result).toBe(29);
-  });
-
-  it("accepts a timestamp", () => {
-    const result = getDate(new Date(2014, 11 /* Dec */, 31).getTime());
-    expect(result).toBe(31);
-  });
-
-  it("returns NaN if the given date is invalid", () => {
-    const result = getDate(new Date(NaN));
-    expect(isNaN(result)).toBe(true);
-  });
-});

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

@@ -1,19 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { getDay } from "./index";
-
-describe("getDay", () => {
-  it("returns the day of the week of the given date", () => {
-    const result = getDay(new Date(2012, 1 /* Feb */, 29));
-    expect(result).toBe(3);
-  });
-
-  it("accepts a timestamp", () => {
-    const result = getDay(new Date(2014, 5 /* Jun */, 1).getTime());
-    expect(result).toBe(0);
-  });
-
-  it("returns NaN if the given date is invalid", () => {
-    const result = getDay(new Date(NaN));
-    expect(isNaN(result)).toBe(true);
-  });
-});

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

@@ -1,27 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { getDayOfYear } from "./index";
-
-describe("getDayOfYear", () => {
-  it("returns the day of the year of the given date", () => {
-    const result = getDayOfYear(new Date(2014, 6 /* Jul */, 2));
-    expect(result).toBe(183);
-  });
-
-  it("accepts a timestamp", () => {
-    const result = getDayOfYear(new Date(2014, 0 /* Jan */, 2).getTime());
-    expect(result).toBe(2);
-  });
-
-  it("handles dates before 100 AD", () => {
-    const initialDate = new Date(0);
-    initialDate.setFullYear(0, 11 /* Dec */, 31);
-    initialDate.setHours(0, 0, 0, 0);
-    const result = getDayOfYear(initialDate);
-    expect(result).toBe(366);
-  });
-
-  it("returns NaN if the given date is invalid", () => {
-    const result = getDayOfYear(new Date(NaN));
-    expect(isNaN(result)).toBe(true);
-  });
-});

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

@@ -1,33 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { getDaysInMonth } from "./index";
-
-describe("getDaysInMonth", () => {
-  it("returns the number of days in the month of the given date", () => {
-    const result = getDaysInMonth(new Date(2100, 1 /* Feb */, 11));
-    expect(result).toBe(28);
-  });
-
-  it("works for the February of a leap year", () => {
-    const result = getDaysInMonth(new Date(2000, 1 /* Feb */, 11));
-    expect(result).toBe(29);
-  });
-
-  it("accepts a timestamp", () => {
-    const date = new Date(2014, 6 /* Jul */, 2).getTime();
-    const result = getDaysInMonth(date);
-    expect(result).toBe(31);
-  });
-
-  it("handles dates before 100 AD", () => {
-    const date = new Date(0);
-    date.setFullYear(0, 1 /* Feb */, 15);
-    date.setHours(0, 0, 0, 0);
-    const result = getDaysInMonth(date);
-    expect(result).toBe(29);
-  });
-
-  it("returns NaN if the given date is invalid", () => {
-    const result = getDaysInMonth(new Date(NaN));
-    expect(isNaN(result)).toBe(true);
-  });
-});

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

@@ -1,35 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { getDaysInYear } from "./index";
-
-describe("getDaysInYear", () => {
-  it("returns the number of days in the year of the given date", () => {
-    const result = getDaysInYear(new Date(2014, 6 /* Jul */, 2));
-    expect(result).toBe(365);
-  });
-
-  it("works for a leap year", () => {
-    const result = getDaysInYear(new Date(2012, 6 /* Jul */, 2));
-    expect(result).toBe(366);
-  });
-
-  it("works for the years divisible by 100 but not by 400", () => {
-    const result = getDaysInYear(new Date(2100, 6 /* Jul */, 2));
-    expect(result).toBe(365);
-  });
-
-  it("works for the years divisible by 400", () => {
-    const result = getDaysInYear(new Date(2000, 6 /* Jul */, 2));
-    expect(result).toBe(366);
-  });
-
-  it("accepts a timestamp", () => {
-    const date = new Date(2012, 6 /* Jul */, 2).getTime();
-    const result = getDaysInYear(date);
-    expect(result).toBe(366);
-  });
-
-  it("returns NaN if the given date is invalid", () => {
-    const result = getDaysInYear(new Date(NaN));
-    expect(isNaN(result)).toBe(true);
-  });
-});

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

@@ -1,24 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { getDecade } from "./index";
-
-describe("getDecade", () => {
-  it("returns the decade for a the given date", () => {
-    const result = getDecade(new Date(1971, 10 /* Nov */, 8));
-    expect(result).toBe(1970);
-  });
-
-  it("accepts a timestamp", () => {
-    const result = getDecade(new Date(1969, 6 /* Jul */, 20).getTime());
-    expect(result).toBe(1960);
-  });
-
-  it("returns NaN if the given date is invalid", () => {
-    const result = getDecade(new Date(NaN));
-    expect(isNaN(result)).toBe(true);
-  });
-
-  it("properly works with negative numbers", () => {
-    expect(getDecade(new Date(2009, 0, 1))).toBe(2000);
-    expect(getDecade(new Date(-2001, 0, 1))).toBe(-2010);
-  });
-});

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

@@ -1,58 +0,0 @@
-import { afterEach, beforeAll, describe, expect, it } from "vitest";
-import { getDefaultOptions } from "./index";
-import { setDefaultOptions } from "../setDefaultOptions/index";
-import { startOfWeek } from "../startOfWeek/index";
-import {
-  getDefaultOptions as getInternalDefaultOptions,
-  setDefaultOptions as setInternalDefaultOptions,
-} from "../_lib/defaultOptions/index";
-import { resetDefaultOptions } from "../_lib/test/index";
-import { Locale } from "../types";
-
-describe.skip("getDefaultOptions", () => {
-  afterEach(resetDefaultOptions);
-
-  let eo: Locale
-  beforeAll(async () => {
-    // @ts-expect-error
-    ({ eo } = await import("../locale/eo/index"));
-  });
-
-  it("returns an empty object", () => {
-    const result = getDefaultOptions();
-    expect(result).toEqual({});
-  });
-
-  it("returns a clone of the original object", () => {
-    setInternalDefaultOptions({ weekStartsOn: 1 });
-    const result = getDefaultOptions();
-    expect(getInternalDefaultOptions()).toEqual(result);
-  });
-
-  it("mutating the result does not affect functions that use options", () => {
-    const defaultOptionsClone = getDefaultOptions();
-    defaultOptionsClone.weekStartsOn = 1;
-    const result = startOfWeek(new Date(2014, 8 /* Sep */, 2, 11, 55, 0));
-    expect(result).toEqual(new Date(2014, 7 /* Aug */, 31));
-
-    // Mutating the original object does affect `startOfWeek`
-    const _defaultOptions = getInternalDefaultOptions();
-    _defaultOptions.weekStartsOn = 1;
-    const result2 = startOfWeek(new Date(2014, 8 /* Sep */, 2, 11, 55, 0));
-    expect(result2).toEqual(new Date(2014, 8 /* Sep */, 1));
-  });
-
-  it("returns new values after setting them via `setDefaultOptions`", () => {
-    setDefaultOptions({
-      weekStartsOn: 1,
-      firstWeekContainsDate: 4,
-      locale: eo,
-    });
-    const result = getDefaultOptions();
-    expect(result).toEqual({
-      weekStartsOn: 1,
-      firstWeekContainsDate: 4,
-      locale: eo,
-    });
-  });
-});

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

@@ -1,19 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { getHours } from "./index";
-
-describe("getHours", () => {
-  it("returns the hours of the given date", () => {
-    const result = getHours(new Date(2012, 1 /* Feb */, 29, 11, 45));
-    expect(result).toBe(11);
-  });
-
-  it("accepts a timestamp", () => {
-    const result = getHours(new Date(2014, 3 /* Apr */, 2, 23, 30).getTime());
-    expect(result).toBe(23);
-  });
-
-  it("returns NaN if the given date is invalid", () => {
-    const result = getHours(new Date(NaN));
-    expect(isNaN(result)).toBe(true);
-  });
-});