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

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

@@ -1,231 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { areIntervalsOverlapping } from "./index";
-
-describe("areIntervalsOverlapping", () => {
-  const initialIntervalStart = new Date(2016, 10, 10, 13, 0, 0);
-  const initialIntervalEnd = new Date(2016, 11, 3, 15, 0, 0);
-
-  describe("when the time intervals don't overlap", () => {
-    it("returns false for a valid non overlapping interval before another interval", () => {
-      const earlierIntervalStart = new Date(2016, 9, 25);
-      const earlierIntervalEnd = new Date(2016, 10, 9);
-
-      const isOverlapping = areIntervalsOverlapping(
-        { start: initialIntervalStart, end: initialIntervalEnd },
-        { start: earlierIntervalStart, end: earlierIntervalEnd },
-      );
-      expect(!isOverlapping).toBe(true);
-    });
-
-    it("returns false for a valid non overlapping interval after another interval", () => {
-      const laterIntervalStart = new Date(2016, 11, 4);
-      const laterIntervalEnd = new Date(2016, 11, 9);
-
-      const isOverlapping = areIntervalsOverlapping(
-        { start: initialIntervalStart, end: initialIntervalEnd },
-        { start: laterIntervalStart, end: laterIntervalEnd },
-      );
-      expect(!isOverlapping).toBe(true);
-    });
-
-    it("returns false for a non overlapping same-day interval", () => {
-      const sameDayIntervalStart = new Date(2016, 11, 4, 9, 0, 0);
-      const sameDayIntervalEnd = new Date(2016, 11, 4, 18, 0, 0);
-
-      const isOverlapping = areIntervalsOverlapping(
-        { start: initialIntervalStart, end: initialIntervalEnd },
-        { start: sameDayIntervalStart, end: sameDayIntervalEnd },
-      );
-      expect(!isOverlapping).toBe(true);
-    });
-
-    it("returns false for an interval differing by a few hours", () => {
-      const oneDayOverlappingIntervalStart = new Date(2016, 11, 3, 18, 0, 0);
-      const oneDayOverlappingIntervalEnd = new Date(2016, 11, 14, 13, 0, 0);
-
-      const isOverlapping = areIntervalsOverlapping(
-        { start: initialIntervalStart, end: initialIntervalEnd },
-        {
-          start: oneDayOverlappingIntervalStart,
-          end: oneDayOverlappingIntervalEnd,
-        },
-      );
-      expect(!isOverlapping).toBe(true);
-    });
-
-    it("returns false for an interval with the same startDateTime as the initial time intervals's endDateTime", () => {
-      const oneDayOverlapIntervalStart = new Date(2016, 11, 3, 15, 0, 0);
-      const oneDayOverlapIntervalEnd = new Date(2016, 11, 14, 13, 0, 0);
-
-      const isOverlapping = areIntervalsOverlapping(
-        { start: initialIntervalStart, end: initialIntervalEnd },
-        { start: oneDayOverlapIntervalStart, end: oneDayOverlapIntervalEnd },
-      );
-      expect(!isOverlapping).toBe(true);
-    });
-
-    it("returns false for an interval with the same endDateTime as the initial time interval's startDateTime", () => {
-      const oneDayOverlapIntervalStart = new Date(2016, 10, 3, 15, 0, 0);
-      const oneDayOverlapIntervalEnd = new Date(2016, 10, 10, 13, 0, 0);
-
-      const isOverlapping = areIntervalsOverlapping(
-        { start: initialIntervalStart, end: initialIntervalEnd },
-        { start: oneDayOverlapIntervalStart, end: oneDayOverlapIntervalEnd },
-      );
-      expect(!isOverlapping).toBe(true);
-    });
-  });
-
-  describe("when the time intervals overlap", () => {
-    it("returns true for an interval included within another interval", () => {
-      const includedIntervalStart = new Date(2016, 10, 14);
-      const includedIntervalEnd = new Date(2016, 10, 14);
-
-      const isOverlapping = areIntervalsOverlapping(
-        { start: initialIntervalStart, end: initialIntervalEnd },
-        { start: includedIntervalStart, end: includedIntervalEnd },
-      );
-      expect(isOverlapping).toBe(true);
-    });
-
-    it("returns true for an interval overlapping at the end", () => {
-      const endOverlappingIntervalStart = new Date(2016, 10, 5);
-      const endOverlappingIntervalEnd = new Date(2016, 10, 14);
-
-      const isOverlapping = areIntervalsOverlapping(
-        { start: initialIntervalStart, end: initialIntervalEnd },
-        { start: endOverlappingIntervalStart, end: endOverlappingIntervalEnd },
-      );
-      expect(isOverlapping).toBe(true);
-    });
-
-    it("returns true for an interval overlapping at the beginning", () => {
-      const startOverlappingIntervalStart = new Date(2016, 10, 20);
-      const startOverlappingIntervalEnd = new Date(2016, 11, 14);
-
-      const isOverlapping = areIntervalsOverlapping(
-        { start: initialIntervalStart, end: initialIntervalEnd },
-        {
-          start: startOverlappingIntervalStart,
-          end: startOverlappingIntervalEnd,
-        },
-      );
-      expect(isOverlapping).toBe(true);
-    });
-
-    it("returns true for an interval including another interval", () => {
-      const includingIntervalStart = new Date(2016, 10, 5);
-      const includingIntervalEnd = new Date(2016, 11, 15);
-
-      const isOverlapping = areIntervalsOverlapping(
-        { start: initialIntervalStart, end: initialIntervalEnd },
-        { start: includingIntervalStart, end: includingIntervalEnd },
-      );
-      expect(isOverlapping).toBe(true);
-    });
-  });
-
-  it("accepts timestamp", () => {
-    const initialIntervalStart = new Date(2016, 10, 10, 13, 0, 0).getTime();
-    const initialIntervalEnd = new Date(2016, 11, 3, 15, 0, 0).getTime();
-
-    const endOverlappingIntervalStart = new Date(2016, 10, 5).getTime();
-    const endOverlappingIntervalEnd = new Date(2016, 10, 14).getTime();
-
-    const isOverlapping = areIntervalsOverlapping(
-      { start: initialIntervalStart, end: initialIntervalEnd },
-      { start: endOverlappingIntervalStart, end: endOverlappingIntervalEnd },
-    );
-    expect(isOverlapping).toBe(true);
-  });
-
-  it("sort timestamp", () => {
-    const result = areIntervalsOverlapping(
-      { start: "1970-01-01T02:00:00.000Z", end: "1970-01-01T03:00:00.000Z" },
-      { start: "1969-12-31T23:30:00.000Z", end: "1970-01-01T02:30:00.000Z" },
-    );
-    expect(result).toBe(true);
-  });
-
-  it("returns result for the normalized intervals if the start date of the initial time interval is after the end date", () => {
-    const includedIntervalStart = new Date(2016, 10, 14);
-    const includedIntervalEnd = new Date(2016, 10, 14);
-
-    const isOverlapping = areIntervalsOverlapping(
-      { start: initialIntervalEnd, end: initialIntervalStart },
-      { start: includedIntervalStart, end: includedIntervalEnd },
-    );
-    expect(isOverlapping).toBe(true);
-  });
-
-  it("returns result for the normalized intervals if the start date of the compared time interval is after the end date", () => {
-    const includedIntervalStart = new Date(2016, 10, 14);
-    const includedIntervalEnd = new Date(2016, 10, 14);
-
-    const isOverlapping = areIntervalsOverlapping(
-      { start: initialIntervalStart, end: initialIntervalEnd },
-      { start: includedIntervalEnd, end: includedIntervalStart },
-    );
-    expect(isOverlapping).toBe(true);
-  });
-
-  describe("when the inclusive option is true", () => {
-    it("returns true for an interval with the same startDateTime as the initial time interval's endDateTime", () => {
-      const oneDayOverlapIntervalStart = new Date(2016, 11, 3, 15, 0, 0);
-      const oneDayOverlapIntervalEnd = new Date(2016, 11, 14, 13, 0, 0);
-
-      const isOverlapping = areIntervalsOverlapping(
-        { start: initialIntervalStart, end: initialIntervalEnd },
-        { start: oneDayOverlapIntervalStart, end: oneDayOverlapIntervalEnd },
-        { inclusive: true },
-      );
-      expect(isOverlapping).toBe(true);
-    });
-
-    it("returns true for an interval with the same endDateTime as the initial time interval's startDateTime", () => {
-      const oneDayOverlapIntervalStart = new Date(2016, 10, 3, 15, 0, 0);
-      const oneDayOverlapIntervalEnd = new Date(2016, 10, 10, 13, 0, 0);
-
-      const isOverlapping = areIntervalsOverlapping(
-        { start: initialIntervalStart, end: initialIntervalEnd },
-        { start: oneDayOverlapIntervalStart, end: oneDayOverlapIntervalEnd },
-        { inclusive: true },
-      );
-      expect(isOverlapping).toBe(true);
-    });
-  });
-
-  describe("one of the dates is `Invalid Date`", () => {
-    it("returns false if the start date of the initial time interval is `Invalid Date`", () => {
-      const result = areIntervalsOverlapping(
-        { start: new Date(NaN), end: new Date(2016, 10, 3) },
-        { start: new Date(2016, 10, 5), end: new Date(2016, 10, 15) },
-      );
-      expect(!result).toBe(true);
-    });
-
-    it("returns false if the end date of the initial time interval is `Invalid Date`", () => {
-      const result = areIntervalsOverlapping(
-        { start: new Date(2016, 10, 3), end: new Date(NaN) },
-        { start: new Date(2016, 10, 5), end: new Date(2016, 10, 15) },
-      );
-      expect(!result).toBe(true);
-    });
-
-    it("returns false if the start date of the compared time interval is `Invalid Date`", () => {
-      const result = areIntervalsOverlapping(
-        { start: new Date(2016, 10, 3), end: new Date(2016, 10, 7) },
-        { start: new Date(NaN), end: new Date(2016, 10, 5) },
-      );
-      expect(!result).toBe(true);
-    });
-
-    it("returns false if the end date of the compared time interval is `Invalid Date`", () => {
-      const result = areIntervalsOverlapping(
-        { start: new Date(2016, 10, 3), end: new Date(2016, 10, 7) },
-        { start: new Date(2016, 10, 5), end: new Date(NaN) },
-      );
-      expect(!result).toBe(true);
-    });
-  });
-});

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

@@ -1,36 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { clamp } from "./index";
-
-describe("clamp", () => {
-  it("accepts timestamps", () => {
-    const start = new Date(2000, 1, 1).getTime();
-    const date = new Date(2000, 1, 2).getTime();
-    const end = new Date(2000, 1, 3).getTime();
-    const result = clamp(date, { start, end });
-    expect(result).toEqual(new Date(2000, 1, 2));
-  });
-
-  it("returns the start date when the date is less than start", () => {
-    const start = new Date(2001, 1, 1);
-    const date = new Date(2000, 1, 1);
-    const end = new Date(2020, 1, 1);
-    const result = clamp(date, { start, end });
-    expect(result).toEqual(new Date(2001, 1, 1));
-  });
-
-  it("returns the end date when the date is greater than the end date", () => {
-    const start = new Date(2000, 1, 1);
-    const date = new Date(2003, 1, 1);
-    const end = new Date(2001, 1, 1);
-    const result = clamp(date, { start, end });
-    expect(result).toEqual(new Date(2001, 1, 1));
-  });
-
-  it("returns the date when the date is within the bound of start and end", () => {
-    const start = new Date(2000, 1, 1);
-    const date = new Date(2001, 1, 1);
-    const end = new Date(2003, 1, 1);
-    const result = clamp(date, { start, end });
-    expect(result).toEqual(new Date(2001, 1, 1));
-  });
-});

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

@@ -1,57 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { closestIndexTo } from "./index";
-
-describe("closestIndexTo", () => {
-  it("returns the date index from the given array closest to the given date", () => {
-    const date = new Date(2014, 6 /* Jul */, 2);
-    const result = closestIndexTo(date, [
-      new Date(2015, 7 /* Aug */, 31),
-      new Date(2012, 6 /* Jul */, 2),
-    ]);
-    expect(result).toBe(0);
-  });
-
-  it("works if the closest date from the given array is before the given date", () => {
-    const date = new Date(2014, 6 /* Jul */, 2, 6, 30, 4, 500);
-    const result = closestIndexTo(date, [
-      new Date(2014, 6 /* Jul */, 2, 6, 30, 5, 900),
-      new Date(2014, 6 /* Jul */, 2, 6, 30, 3, 900),
-      new Date(2014, 6 /* Jul */, 2, 6, 30, 10),
-    ]);
-    expect(result).toBe(1);
-  });
-
-  it("accepts timestamps", () => {
-    const date = new Date(2014, 6 /* Jul */, 2).getTime();
-    const result = closestIndexTo(date, [
-      new Date(2015, 7 /* Aug */, 31).getTime(),
-      new Date(2012, 6 /* Jul */, 2).getTime(),
-    ]);
-    expect(result).toBe(0);
-  });
-
-  it("returns undefined if the given array is empty", () => {
-    const date = new Date(2014, 6 /* Jul */, 2).getTime();
-    const result = closestIndexTo(date, []);
-    expect(result).toBe(undefined);
-  });
-
-  it("returns NaN if the given date is `Invalid Date`", () => {
-    const date = new Date(NaN);
-    const result = closestIndexTo(date, [
-      new Date(2015, 7 /* Aug */, 31),
-      new Date(2012, 6 /* Jul */, 2),
-    ]);
-    expect(result != null && isNaN(result)).toBe(true);
-  });
-
-  it("returns NaN if any date in the given array is `Invalid Date`", () => {
-    const date = new Date(2014, 6 /* Jul */, 2);
-    const result = closestIndexTo(date, [
-      new Date(2015, 7 /* Aug */, 31),
-      new Date(NaN),
-      new Date(2012, 6 /* Jul */, 2),
-    ]);
-    expect(result != null && isNaN(result)).toBe(true);
-  });
-});

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

@@ -1,59 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { closestTo } from "./index";
-
-describe("closestTo", () => {
-  it("returns the date from the given array closest to the given date", () => {
-    const date = new Date(2014, 6 /* Jul */, 2);
-    const result = closestTo(date, [
-      new Date(2015, 7 /* Aug */, 31),
-      new Date(2012, 6 /* Jul */, 2),
-    ]);
-    expect(result).toEqual(new Date(2015, 7 /* Aug */, 31));
-  });
-
-  it("works if the closest date from the given array is before the given date", () => {
-    const date = new Date(2014, 6 /* Jul */, 2, 6, 30, 4, 500);
-    const result = closestTo(date, [
-      new Date(2014, 6 /* Jul */, 2, 6, 30, 5, 900),
-      new Date(2014, 6 /* Jul */, 2, 6, 30, 3, 900),
-      new Date(2014, 6 /* Jul */, 2, 6, 30, 10),
-    ]);
-    expect(result).toEqual(new Date(2014, 6 /* Jul */, 2, 6, 30, 3, 900));
-  });
-
-  it("accepts timestamps", () => {
-    const date = new Date(2014, 6 /* Jul */, 2).getTime();
-    const result = closestTo(date, [
-      new Date(2015, 7 /* Aug */, 31).getTime(),
-      new Date(2012, 6 /* Jul */, 2).getTime(),
-    ]);
-    expect(result).toEqual(new Date(2015, 7 /* Aug */, 31));
-  });
-
-  it("returns undefined if the given array is empty", () => {
-    const date = new Date(2014, 6 /* Jul */, 2).getTime();
-    const result = closestTo(date, []);
-    expect(result).toEqual(undefined);
-  });
-
-  it("returns `Invalid Date` if the given date is `Invalid Date`", () => {
-    const date = new Date(NaN);
-    const result = closestTo(date, [
-      new Date(2015, 7 /* Aug */, 31),
-      new Date(2012, 6 /* Jul */, 2),
-    ]);
-
-    expect(result instanceof Date && isNaN(result.getTime())).toBe(true);
-  });
-
-  it("returns `Invalid Date` if any date in the given array is `Invalid Date`", () => {
-    const date = new Date(2014, 6 /* Jul */, 2);
-    const result = closestTo(date, [
-      new Date(2015, 7 /* Aug */, 31),
-      new Date(NaN),
-      new Date(2012, 6 /* Jul */, 2),
-    ]);
-
-    expect(result instanceof Date && isNaN(result.getTime())).toBe(true);
-  });
-});

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

@@ -1,70 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { compareAsc } from "./index";
-
-describe("compareAsc", () => {
-  it("returns 0 if the given dates are equal", () => {
-    const result = compareAsc(
-      new Date(1989, 6 /* Jul */, 10),
-      new Date(1989, 6 /* Jul */, 10),
-    );
-    expect(result).toBe(0);
-  });
-
-  it("returns -1 if the first date is before the second one", () => {
-    const result = compareAsc(
-      new Date(1987, 1 /* Feb */, 11),
-      new Date(1989, 6 /* Jul */, 10),
-    );
-    expect(result).toBe(-1);
-  });
-
-  it("returns 1 if the first date is after the second one", () => {
-    const result = compareAsc(
-      new Date(1989, 6 /* Jul */, 10),
-      new Date(1987, 1 /* Feb */, 11),
-    );
-    expect(result).toBe(1);
-  });
-
-  it("sorts the dates array in the chronological order when function is passed as the argument to Array.prototype.sort()", () => {
-    const unsortedArray = [
-      new Date(1995, 6 /* Jul */, 2),
-      new Date(1987, 1 /* Feb */, 11),
-      new Date(1989, 6 /* Jul */, 10),
-    ];
-
-    const sortedArray = [
-      new Date(1987, 1 /* Feb */, 11),
-      new Date(1989, 6 /* Jul */, 10),
-      new Date(1995, 6 /* Jul */, 2),
-    ];
-
-    unsortedArray.sort(compareAsc);
-    const result = unsortedArray;
-
-    expect(result).toEqual(sortedArray);
-  });
-
-  it("accepts timestamps", () => {
-    const result = compareAsc(
-      new Date(1987, 1 /* Feb */, 11).getTime(),
-      new Date(1989, 6 /* Jul */, 10).getTime(),
-    );
-    expect(result).toBe(-1);
-  });
-
-  it("returns NaN if the first date is `Invalid Date`", () => {
-    const result = compareAsc(new Date(NaN), new Date(1989, 6 /* Jul */, 10));
-    expect(isNaN(result)).toBe(true);
-  });
-
-  it("returns NaN if the second date is `Invalid Date`", () => {
-    const result = compareAsc(new Date(1989, 6 /* Jul */, 10), new Date(NaN));
-    expect(isNaN(result)).toBe(true);
-  });
-
-  it("returns NaN if the both dates are `Invalid Date`", () => {
-    const result = compareAsc(new Date(NaN), new Date(NaN));
-    expect(isNaN(result)).toBe(true);
-  });
-});

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

@@ -1,70 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { compareDesc } from "./index";
-
-describe("compareDesc", () => {
-  it("returns 0 if the given dates are equal", () => {
-    const result = compareDesc(
-      new Date(1989, 6 /* Jul */, 10),
-      new Date(1989, 6 /* Jul */, 10),
-    );
-    expect(result).toBe(0);
-  });
-
-  it("returns 1 if the first date is before the second one", () => {
-    const result = compareDesc(
-      new Date(1987, 1 /* Feb */, 11),
-      new Date(1989, 6 /* Jul */, 10),
-    );
-    expect(result).toBe(1);
-  });
-
-  it("returns -1 if the first date is after the second one", () => {
-    const result = compareDesc(
-      new Date(1989, 6 /* Jul */, 10),
-      new Date(1987, 1 /* Feb */, 11),
-    );
-    expect(result).toBe(-1);
-  });
-
-  it("sorts the dates array in the reverse chronological order when function is passed as the argument to Array.prototype.sort()", () => {
-    const unsortedArray = [
-      new Date(1995, 6 /* Jul */, 2),
-      new Date(1987, 1 /* Feb */, 11),
-      new Date(1989, 6 /* Jul */, 10),
-    ];
-
-    const sortedArray = [
-      new Date(1995, 6 /* Jul */, 2),
-      new Date(1989, 6 /* Jul */, 10),
-      new Date(1987, 1 /* Feb */, 11),
-    ];
-
-    unsortedArray.sort(compareDesc);
-    const result = unsortedArray;
-
-    expect(result).toEqual(sortedArray);
-  });
-
-  it("accepts timestamps", () => {
-    const result = compareDesc(
-      new Date(1987, 1 /* Feb */, 11).getTime(),
-      new Date(1989, 6 /* Jul */, 10).getTime(),
-    );
-    expect(result).toBe(1);
-  });
-
-  it("returns NaN if the first date is `Invalid Date`", () => {
-    const result = compareDesc(new Date(NaN), new Date(1989, 6 /* Jul */, 10));
-    expect(isNaN(result)).toBe(true);
-  });
-
-  it("returns NaN if the second date is `Invalid Date`", () => {
-    const result = compareDesc(new Date(1989, 6 /* Jul */, 10), new Date(NaN));
-    expect(isNaN(result)).toBe(true);
-  });
-
-  it("returns NaN if the both dates are `Invalid Date`", () => {
-    const result = compareDesc(new Date(1989, 6 /* Jul */, 10), new Date(NaN));
-    expect(isNaN(result)).toBe(true);
-  });
-});

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

@@ -1,47 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { constructFrom } from ".";
-
-describe("constructFrom", () => {
-  it("should create a new Date instance using the constructor from the reference date", () => {
-    const referenceDate = new Date("2023-10-25T12:00:00");
-    const value = new Date("2023-10-26T12:00:00");
-
-    const result = constructFrom(referenceDate, value);
-
-    expect(result instanceof Date).toBe(true);
-    expect(result).toEqual(value);
-    expect(result.constructor).toBe(referenceDate.constructor);
-  });
-
-  it("should create a new Date instance using a number as the reference date", () => {
-    const referenceDate = 1635158400000; // October 25, 2023
-    const value = new Date("2023-10-26T12:00:00");
-
-    const result = constructFrom(referenceDate, value);
-
-    expect(result instanceof Date).toBe(true);
-    expect(result).toEqual(value);
-  });
-
-  it("should create a new custom Date instance using the constructor from the reference date", () => {
-    class CustomDate extends Date {}
-    const referenceDate = new CustomDate("2023-10-25T12:00:00");
-    const value = new CustomDate("2023-10-26T12:00:00");
-
-    const result = constructFrom(referenceDate, value);
-
-    expect(result instanceof CustomDate).toBe(true);
-    expect(result).toEqual(value);
-    expect(result.constructor).toBe(referenceDate.constructor);
-  });
-
-  it("should create a new Date instance using numbers as both referenceDate and value", () => {
-    const referenceDate = 1635158400000; // October 25, 2023
-    const value = 1635244800000; // October 26, 2023
-
-    const result = constructFrom(referenceDate, value);
-
-    expect(result instanceof Date).toBe(true);
-    expect(result.getTime()).toEqual(value);
-  });
-});

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

@@ -1,37 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { constructNow } from ".";
-
-describe("constructNow", () => {
-  it("creates a new Date instance using the constructor from the reference date", () => {
-    const result = constructNow(new Date("2023-10-25T12:00:00"));
-
-    expect(result instanceof Date).toBe(true);
-    expect(+result - Date.now()).toBeLessThan(10); // Give 10 ms of slack
-    expect(result.constructor).toBe(Date);
-  });
-
-  it("creates a new Date instance using a number as the reference date", () => {
-    const result = constructNow(1635158400000);
-
-    expect(result instanceof Date).toBe(true);
-    expect(+result - Date.now()).toBeLessThan(10); // Give 10 ms of slack
-    expect(result.constructor).toBe(Date);
-  });
-
-  it("creates a new Date instance using a string as the reference date", () => {
-    const result = constructNow("2023-10-25T12:00:00");
-
-    expect(result instanceof Date).toBe(true);
-    expect(+result - Date.now()).toBeLessThan(10); // Give 10 ms of slack
-    expect(result.constructor).toBe(Date);
-  });
-
-  it("creates a new custom Date instance using the constructor from the reference date", () => {
-    class CustomDate extends Date {}
-    const result = constructNow(new CustomDate("2023-10-26T12:00:00"));
-
-    expect(result instanceof CustomDate).toBe(true);
-    expect(+result - Date.now()).toBeLessThan(10); // Give 10 ms of slack
-    expect(result.constructor).toBe(CustomDate);
-  });
-});

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

@@ -1,36 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { daysToWeeks } from "./index";
-
-describe("daysToWeeks", () => {
-  it("converts days to weeks", () => {
-    expect(daysToWeeks(7)).toBe(1);
-    expect(daysToWeeks(14)).toBe(2);
-  });
-
-  it("uses trunc rounding", () => {
-    expect(daysToWeeks(8)).toBe(1);
-    expect(daysToWeeks(6)).toBe(0);
-  });
-
-  it("handles border values", () => {
-    expect(daysToWeeks(7.5)).toBe(1);
-    expect(daysToWeeks(0)).toBe(0);
-  });
-
-  it("properly works with negative numbers", () => {
-    expect(daysToWeeks(7)).toBe(1);
-    expect(daysToWeeks(-7)).toBe(-1);
-
-    expect(daysToWeeks(14)).toBe(2);
-    expect(daysToWeeks(-14)).toBe(-2);
-
-    expect(daysToWeeks(8)).toBe(1);
-    expect(daysToWeeks(-8)).toBe(-1);
-
-    expect(daysToWeeks(6)).toBe(0);
-    expect(daysToWeeks(-6)).toBe(0);
-
-    expect(daysToWeeks(7.5)).toBe(1);
-    expect(daysToWeeks(-7.5)).toBe(-1);
-  });
-});