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

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

@@ -0,0 +1,24 @@
+import { describe, expect, it } from "vitest";
+import { secondsToHours } from "./index";
+
+describe("secondsToHours", () => {
+  it("converts seconds to hours", () => {
+    expect(secondsToHours(3600)).toBe(1);
+    expect(secondsToHours(7200)).toBe(2);
+  });
+
+  it("uses floor rounding", () => {
+    expect(secondsToHours(3601)).toBe(1);
+    expect(secondsToHours(3599)).toBe(0);
+  });
+
+  it("handles border values", () => {
+    expect(secondsToHours(3600.5)).toBe(1);
+    expect(secondsToHours(0)).toBe(0);
+  });
+
+  it("properly works with negative numbers", () => {
+    expect(secondsToHours(123456)).toBe(34);
+    expect(secondsToHours(-123456)).toBe(-34);
+  });
+});

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

@@ -1,4 +1,4 @@
-import { millisecondsInSecond } from '../constants/index';
+import { millisecondsInSecond } from "../constants/index";
 
 /**
  * @name secondsToMilliseconds
@@ -8,15 +8,15 @@ import { millisecondsInSecond } from '../constants/index';
  * @description
  * Convert a number of seconds to a full number of milliseconds.
  *
- * @param seconds - number of seconds to be converted
+ * @param seconds - The number of seconds to be converted
  *
- * @returns the number of seconds converted in milliseconds
+ * @returns The number of seconds converted in milliseconds
  *
  * @example
  * // Convert 2 seconds into milliseconds
  * const result = secondsToMilliseconds(2)
  * //=> 2000
  */
-export default function secondsToMilliseconds(seconds: number): number {
+export function secondsToMilliseconds(seconds: number): number {
   return seconds * millisecondsInSecond;
 }

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

@@ -0,0 +1,14 @@
+import { describe, expect, it } from "vitest";
+import { secondsToMilliseconds } from "./index";
+
+describe("secondsToMilliseconds", () => {
+  it("converts seconds to milliseconds", () => {
+    expect(secondsToMilliseconds(1)).toBe(1000);
+    expect(secondsToMilliseconds(2)).toBe(2000);
+  });
+
+  it("handles border values", () => {
+    expect(secondsToMilliseconds(1.5)).toBe(1500);
+    expect(secondsToMilliseconds(0)).toBe(0);
+  });
+});

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

@@ -1,4 +1,4 @@
-import { secondsInMinute } from '../constants/index';
+import { secondsInMinute } from "../constants/index";
 
 /**
  * @name secondsToMinutes
@@ -8,9 +8,9 @@ import { secondsInMinute } from '../constants/index';
  * @description
  * Convert a number of seconds to a full number of minutes.
  *
- * @param seconds - number of seconds to be converted
+ * @param seconds - The number of seconds to be converted
  *
- * @returns the number of seconds converted in minutes
+ * @returns The number of seconds converted in minutes
  *
  * @example
  * // Convert 120 seconds into minutes
@@ -22,7 +22,7 @@ import { secondsInMinute } from '../constants/index';
  * const result = secondsToMinutes(119)
  * //=> 1
  */
-export default function secondsToMinutes(seconds: number): number {
+export function secondsToMinutes(seconds: number): number {
   const minutes = seconds / secondsInMinute;
-  return Math.floor(minutes);
+  return Math.trunc(minutes);
 }

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

@@ -0,0 +1,24 @@
+import { describe, expect, it } from "vitest";
+import { secondsToMinutes } from "./index";
+
+describe("secondsToMinutes", () => {
+  it("converts seconds to minutes", () => {
+    expect(secondsToMinutes(60)).toBe(1);
+    expect(secondsToMinutes(120)).toBe(2);
+  });
+
+  it("uses floor rounding", () => {
+    expect(secondsToMinutes(61)).toBe(1);
+    expect(secondsToMinutes(59)).toBe(0);
+  });
+
+  it("handles border values", () => {
+    expect(secondsToMinutes(60.5)).toBe(1);
+    expect(secondsToMinutes(0)).toBe(0);
+  });
+
+  it("properly works with negative numbers", () => {
+    expect(secondsToMinutes(123456)).toBe(2057);
+    expect(secondsToMinutes(-123456)).toBe(-2057);
+  });
+});

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

@@ -1,7 +1,7 @@
-import constructFrom from '../constructFrom/index';
-import setMonth from '../setMonth/index';
-import toDate from '../toDate/index';
-import type { DateValues } from '../types';
+import { constructFrom } from "../constructFrom/index";
+import { setMonth } from "../setMonth/index";
+import { toDate } from "../toDate/index";
+import type { DateValues } from "../types";
 
 /**
  * @name set
@@ -18,16 +18,12 @@ import type { DateValues } from '../types';
  * to use native `Date#setX` methods. If you use this function, you may not want to include the
  * other `setX` functions that date-fns provides if you are concerned about the bundle size.
  *
- * @param date - the date to be changed
- * @param values - an object with options
- * @param values.year - the number of years to be set
- * @param values.month - the number of months to be set
- * @param values.date - the number of days to be set
- * @param values.hours - the number of hours to be set
- * @param values.minutes - the number of minutes to be set
- * @param values.seconds - the number of seconds to be set
- * @param values.milliseconds - the number of milliseconds to be set
- * @returns the new date with options set
+ * @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 be changed
+ * @param values - The date values to be set
+ *
+ * @returns The new date with options set
  *
  * @example
  * // Transform 1 September 2014 into 20 October 2015 in a single line:
@@ -40,41 +36,44 @@ import type { DateValues } from '../types';
  * //=> Mon Sep 01 2014 12:23:45
  */
 
-export default function set<DateType extends Date>(dirtyDate: DateType | number, values: DateValues): DateType {
-  let date = toDate(dirtyDate);
+export function set<DateType extends Date>(
+  date: DateType | number | string,
+  values: DateValues,
+): DateType {
+  let _date = toDate(date);
 
   // Check if date is Invalid Date because Date.prototype.setFullYear ignores the value of Invalid Date
-  if (isNaN(date.getTime())) {
-    return constructFrom(dirtyDate, NaN);
+  if (isNaN(+_date)) {
+    return constructFrom(date, NaN);
   }
 
   if (values.year != null) {
-    date.setFullYear(values.year);
+    _date.setFullYear(values.year);
   }
 
   if (values.month != null) {
-    date = setMonth(date, values.month);
+    _date = setMonth(_date, values.month);
   }
 
   if (values.date != null) {
-    date.setDate(values.date);
+    _date.setDate(values.date);
   }
 
   if (values.hours != null) {
-    date.setHours(values.hours);
+    _date.setHours(values.hours);
   }
 
   if (values.minutes != null) {
-    date.setMinutes(values.minutes);
+    _date.setMinutes(values.minutes);
   }
 
   if (values.seconds != null) {
-    date.setSeconds(values.seconds);
+    _date.setSeconds(values.seconds);
   }
 
   if (values.milliseconds != null) {
-    date.setMilliseconds(values.milliseconds);
+    _date.setMilliseconds(values.milliseconds);
   }
 
-  return date;
+  return _date;
 }

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

@@ -0,0 +1,121 @@
+import { describe, expect, it } from "vitest";
+import { set } from "./index";
+
+describe("set", () => {
+  it("sets all values", () => {
+    const result = set(new Date(2013, 0 /* Jan */), {
+      year: 2014,
+      month: 8, // Sep
+      date: 20,
+      hours: 12,
+      minutes: 12,
+      seconds: 12,
+      milliseconds: 12,
+    });
+    expect(result.toString()).toEqual(new Date(2014, 8 /* Sep */, 20, 12, 12, 12, 12).toString());
+  });
+
+  it("sets year", () => {
+    const result = set(new Date(2013, 8 /* Sep */), { year: 2014 });
+    expect(result).toEqual(new Date(2014, 8 /* Sep */));
+  });
+
+  it("sets month", () => {
+    const result = set(new Date(2014, 8 /* Sep */), { month: 9 /* Oct */ });
+    expect(result).toEqual(new Date(2014, 9 /* Oct */));
+  });
+
+  it("sets day of month", () => {
+    const result = set(new Date(2014, 8 /* Sep */), { date: 20 });
+    expect(result).toEqual(new Date(2014, 8 /* Sep */, 20));
+  });
+
+  it("sets hours", () => {
+    const result = set(new Date(2014, 8 /* Sep */, 1), { hours: 12 });
+    expect(result).toEqual(new Date(2014, 8 /* Sep */, 1, 12));
+  });
+
+  it("sets minutes", () => {
+    const result = set(new Date(2014, 8 /* Sep */, 1, 1), { minutes: 12 });
+    expect(result).toEqual(new Date(2014, 8 /* Sep */, 1, 1, 12));
+  });
+
+  it("sets seconds", () => {
+    const result = set(new Date(2014, 8 /* Sep */, 1, 1, 1), { seconds: 12 });
+    expect(result).toEqual(new Date(2014, 8 /* Sep */, 1, 1, 1, 12));
+  });
+
+  it("sets milliseconds", () => {
+    const result = set(new Date(2014, 8 /* Sep */, 1, 1, 1, 1), {
+      milliseconds: 500,
+    });
+    expect(result).toEqual(new Date(2014, 8 /* Sep */, 1, 1, 1, 1, 500));
+  });
+
+  describe("value overflow", () => {
+    it("months overflow into years", () => {
+      const result = set(new Date(2014, 8 /* Sep */, 1), {
+        month: 12 /* 13th month */,
+      });
+      expect(result).toEqual(new Date(2015, 0 /* Jan */, 1));
+    });
+
+    it("days of months overflow into months", () => {
+      const result = set(new Date(2014, 8 /* Sep */, 1), { date: 31 });
+      expect(result).toEqual(new Date(2014, 9 /* Oct */, 1));
+    });
+
+    it("hours overflow into days", () => {
+      const result = set(new Date(2014, 8 /* Sep */, 19), { hours: 24 });
+      expect(result).toEqual(new Date(2014, 8 /* Sep */, 20));
+    });
+
+    it("minutes overflow into hours", () => {
+      const result = set(new Date(2014, 8 /* Sep */, 20, 11), { minutes: 60 });
+      expect(result).toEqual(new Date(2014, 8 /* Sep */, 20, 12));
+    });
+
+    it("seconds overflow into minutes", () => {
+      const result = set(new Date(2014, 8 /* Sep */, 20, 12, 58), {
+        seconds: 60,
+      });
+      expect(result).toEqual(new Date(2014, 8 /* Sep */, 20, 12, 59));
+    });
+
+    it("milliseconds overflow into seconds", () => {
+      const result = set(new Date(2014, 8 /* Sep */, 20, 12, 58, 30), {
+        milliseconds: 1000,
+      });
+      expect(result).toEqual(new Date(2014, 8 /* Sep */, 20, 12, 58, 31));
+    });
+  });
+
+  describe("edge cases", () => {
+    it("sets January", () => {
+      const result = set(new Date(2014, 8 /* Sep */), { month: 0 /* Jan */ });
+      expect(result).toEqual(new Date(2014, 0 /* Jan */));
+    });
+
+    it("sets the last day of new month if the initial date was the last day of a longer month", () => {
+      const result = set(new Date(2014, 7 /* Aug */, 31), {
+        month: 8 /* Sep */,
+      });
+      expect(result).toEqual(new Date(2014, 8 /* Sep */, 30));
+    });
+
+    it("ignores undefined values", () => {
+      const result = set(new Date(2014, 8 /* Sep */), { year: undefined });
+      expect(result).toEqual(new Date(2014, 8 /* Sep */));
+    });
+
+    it("returns Invalid Date if any value in values is NaN", () => {
+      const result = set(new Date(2014, 8 /* Sep */), { year: NaN });
+      expect(isNaN(result.getTime())).toBe(true);
+    });
+
+    it("returns Invalid Date the initial date was Invalid Date as well", () => {
+      const result = set(new Date(NaN), { year: 2019 });
+      expect(isNaN(result.getTime())).toBe(true);
+    });
+  });
+});

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

@@ -1,4 +1,4 @@
-import toDate from '../toDate/index';
+import { toDate } from "../toDate/index";
 
 /**
  * @name setDate
@@ -8,17 +8,23 @@ import toDate from '../toDate/index';
  * @description
  * Set the day of the month to the given date.
  *
- * @param date - the date to be changed
- * @param dayOfMonth - the day of the month of the new date
- * @returns the new date with the day of the month set
+ * @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 be changed
+ * @param dayOfMonth - The day of the month of the new date
+ *
+ * @returns The new date with the day of the month set
  *
  * @example
  * // Set the 30th day of the month to 1 September 2014:
  * const result = setDate(new Date(2014, 8, 1), 30)
  * //=> Tue Sep 30 2014 00:00:00
  */
-export default function setDate<DateType extends Date>(dirtyDate: DateType | number, dayOfMonth: number): DateType {
-  const date = toDate(dirtyDate);
-  date.setDate(dayOfMonth);
-  return date;
+export function setDate<DateType extends Date>(
+  date: DateType | number | string,
+  dayOfMonth: number,
+): DateType {
+  const _date = toDate(date);
+  _date.setDate(dayOfMonth);
+  return _date;
 }

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

@@ -0,0 +1,30 @@
+import { describe, expect, it } from "vitest";
+import { setDate } from "./index";
+
+describe("setDate", () => {
+  it("sets the day of the month", () => {
+    const result = setDate(new Date(2014, 8 /* Sep */, 1), 30);
+    expect(result).toEqual(new Date(2014, 8 /* Sep */, 30));
+  });
+
+  it("accepts a timestamp", () => {
+    const result = setDate(new Date(2014, 8 /* Sep */, 1).getTime(), 25);
+    expect(result).toEqual(new Date(2014, 8 /* Sep */, 25));
+  });
+
+  it("does not mutate the original date", () => {
+    const date = new Date(2014, 8 /* Sep */, 1);
+    setDate(date, 20);
+    expect(date).toEqual(new Date(2014, 8 /* Sep */, 1));
+  });
+
+  it("returns `Invalid Date` if the given date is invalid", () => {
+    const result = setDate(new Date(NaN), 30);
+    expect(result instanceof Date && isNaN(result.getTime())).toBe(true);
+  });
+
+  it("returns `Invalid Date` if the given amount is NaN", () => {
+    const result = setDate(new Date(2014, 8 /* Sep */, 1), NaN);
+    expect(result instanceof Date && isNaN(result.getTime())).toBe(true);
+  });
+});

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

@@ -1,12 +1,14 @@
-import addDays from '../addDays/index';
-import toDate from '../toDate/index';
-import type { LocaleOptions, WeekStartOptions } from '../types';
-import { getDefaultOptions } from '../_lib/defaultOptions/index';
+import { addDays } from "../addDays/index";
+import { toDate } from "../toDate/index";
+import type { LocalizedOptions, WeekOptions } from "../types";
+import { getDefaultOptions } from "../_lib/defaultOptions/index";
 
 /**
  * The {@link setDay} function options.
  */
-export interface SetDayOptions extends LocaleOptions, WeekStartOptions {}
+export interface SetDayOptions
+  extends LocalizedOptions<"options">,
+    WeekOptions {}
 
 /**
  * @name setDay
@@ -16,10 +18,13 @@ export interface SetDayOptions extends LocaleOptions, WeekStartOptions {}
  * @description
  * Set the day of the week to the given date.
  *
- * @param date - the date to be changed
- * @param day - the day of the week of the new date
- * @param options - an object with options.
- * @returns the new date with the day of the week set
+ * @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 be changed
+ * @param day - The day of the week of the new date
+ * @param options - An object with options.
+ *
+ * @returns The new date with the day of the week set
  *
  * @example
  * // Set week day to Sunday, with the default weekStartsOn of Sunday:
@@ -31,8 +36,8 @@ export interface SetDayOptions extends LocaleOptions, WeekStartOptions {}
  * const result = setDay(new Date(2014, 8, 1), 0, { weekStartsOn: 1 })
  * //=> Sun Sep 07 2014 00:00:00
  */
-export default function setDay<DateType extends Date>(
-  dirtyDate: DateType | number,
+export function setDay<DateType extends Date>(
+  date: DateType | number | string,
   day: number,
   options?: SetDayOptions,
 ): DateType {
@@ -44,14 +49,16 @@ export default function setDay<DateType extends Date>(
     defaultOptions.locale?.options?.weekStartsOn ??
     0;
 
-  const date = toDate(dirtyDate);
-  const currentDay = date.getDay();
+  const _date = toDate(date);
+  const currentDay = _date.getDay();
 
   const remainder = day % 7;
   const dayIndex = (remainder + 7) % 7;
 
   const delta = 7 - weekStartsOn;
   const diff =
-    day < 0 || day > 6 ? day - ((currentDay + delta) % 7) : ((dayIndex + delta) % 7) - ((currentDay + delta) % 7);
-  return addDays(date, diff);
+    day < 0 || day > 6
+      ? day - ((currentDay + delta) % 7)
+      : ((dayIndex + delta) % 7) - ((currentDay + delta) % 7);
+  return addDays(_date, diff);
 }

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

@@ -0,0 +1,112 @@
+import { describe, expect, it } from "vitest";
+import { setDay } from "./index";
+
+describe("setDay", () => {
+  it("sets the day of the week", () => {
+    const result = setDay(new Date(2014, 8 /* Sep */, 1), 0);
+    expect(result).toEqual(new Date(2014, 7 /* Aug */, 31));
+  });
+
+  it("allows to specify which day is the first day of the week", () => {
+    const result = setDay(new Date(2014, 8 /* Sep */, 1), 0, {
+      weekStartsOn: 1,
+    });
+    expect(result).toEqual(new Date(2014, 8 /* Sep */, 7));
+  });
+
+  it("allows to specify which day is the first day of the week in locale", () => {
+    const result = setDay(new Date(2014, 8 /* Sep */, 1), 0, {
+      locale: {
+        options: { weekStartsOn: 1 },
+      },
+    });
+    expect(result).toEqual(new Date(2014, 8 /* Sep */, 7));
+  });
+
+  it("`options.weekStartsOn` overwrites the first day of the week specified in locale", () => {
+    const result = setDay(new Date(2014, 8 /* Sep */, 1), 0, {
+      weekStartsOn: 1,
+      locale: {
+        options: { weekStartsOn: 0 },
+      },
+    });
+    expect(result).toEqual(new Date(2014, 8 /* Sep */, 7));
+  });
+
+  it("specifies Monday as the first day of the week", () => {
+    const result = setDay(new Date(2014, 8 /* Sep */, 6), 1, {
+      weekStartsOn: 1,
+    });
+    expect(result).toEqual(new Date(2014, 8 /* Sep */, 1));
+  });
+
+  it("specifies Tuesday as the first day of the week", () => {
+    const result = setDay(new Date(2014, 8 /* Sep */, 6), 1, {
+      weekStartsOn: 2,
+    });
+    expect(result).toEqual(new Date(2014, 8 /* Sep */, 8));
+  });
+
+  describe("the day index is more than 6", () => {
+    it("sets the day of the next week", () => {
+      const result = setDay(new Date(2014, 8 /* Sep */, 1), 8);
+      expect(result).toEqual(new Date(2014, 8 /* Sep */, 8));
+    });
+
+    it("allows to specify which day is the first day of the week", () => {
+      const result = setDay(new Date(2014, 8 /* Sep */, 1), 7, {
+        weekStartsOn: 1,
+      });
+      expect(result).toEqual(new Date(2014, 8 /* Sep */, 8));
+    });
+
+    it("sets the day of another week in the future", () => {
+      const result = setDay(new Date(2014, 8 /* Sep */, 1), 14, {
+        weekStartsOn: 1,
+      });
+      expect(result).toEqual(new Date(2014, 8 /* Sep */, 15));
+    });
+  });
+
+  describe("the day index is less than 0", () => {
+    it("sets the day of the last week", () => {
+      const result = setDay(new Date(2014, 8 /* Sep */, 1), -6);
+      expect(result).toEqual(new Date(2014, 7 /* Aug */, 25));
+    });
+
+    it("allows to specify which day is the first day of the week", () => {
+      const result = setDay(new Date(2014, 8 /* Sep */, 1), -7, {
+        weekStartsOn: 1,
+      });
+      expect(result).toEqual(new Date(2014, 7 /* Aug */, 25));
+    });
+
+    it("set the day of another week in the past", () => {
+      const result = setDay(new Date(2014, 8 /* Sep */, 1), -14, {
+        weekStartsOn: 1,
+      });
+      expect(result).toEqual(new Date(2014, 7 /* Aug */, 18));
+    });
+  });
+
+  it("accepts a timestamp", () => {
+    const result = setDay(new Date(2014, 8 /* Sep */, 1).getTime(), 3);
+    expect(result).toEqual(new Date(2014, 8 /* Sep */, 3));
+  });
+
+  it("does not mutate the original date", () => {
+    const date = new Date(2014, 8 /* Sep */, 1);
+    setDay(date, 3);
+    expect(date).toEqual(new Date(2014, 8 /* Sep */, 1));
+  });
+
+  it("returns `Invalid Date` if the given date is invalid", () => {
+    const result = setDay(new Date(NaN), 0);
+    expect(result instanceof Date && isNaN(result.getTime())).toBe(true);
+  });
+
+  it("returns `Invalid Date` if the given amount is NaN", () => {
+    const result = setDay(new Date(2014, 8 /* Sep */, 1), NaN);
+    expect(result instanceof Date && isNaN(result.getTime())).toBe(true);
+  });
+});

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

@@ -1,4 +1,4 @@
-import toDate from '../toDate/index';
+import { toDate } from "../toDate/index";
 
 /**
  * @name setDayOfYear
@@ -8,18 +8,24 @@ import toDate from '../toDate/index';
  * @description
  * Set the day of the year to the given date.
  *
- * @param date - the date to be changed
- * @param dayOfYear - the day of the year of the new date
- * @returns the new date with the day of the year set
+ * @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 be changed
+ * @param dayOfYear - The day of the year of the new date
+ *
+ * @returns The new date with the day of the year set
  *
  * @example
  * // Set the 2nd day of the year to 2 July 2014:
  * const result = setDayOfYear(new Date(2014, 6, 2), 2)
  * //=> Thu Jan 02 2014 00:00:00
  */
-export default function setDayOfYear<DateType extends Date>(dirtyDate: DateType | number, dayOfYear: number): DateType {
-  const date = toDate(dirtyDate);
-  date.setMonth(0);
-  date.setDate(dayOfYear);
-  return date;
+export function setDayOfYear<DateType extends Date>(
+  date: DateType | number | string,
+  dayOfYear: number,
+): DateType {
+  const _date = toDate(date);
+  _date.setMonth(0);
+  _date.setDate(dayOfYear);
+  return _date;
 }

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

@@ -0,0 +1,30 @@
+import { describe, expect, it } from "vitest";
+import { setDayOfYear } from "./index";
+
+describe("setDayOfYear", () => {
+  it("sets the day of the year", () => {
+    const result = setDayOfYear(new Date(2014, 6 /* Jul */, 2), 2);
+    expect(result).toEqual(new Date(2014, 0 /* Jan */, 2));
+  });
+
+  it("accepts a timestamp", () => {
+    const result = setDayOfYear(new Date(2014, 6 /* Jul */, 2).getTime(), 60);
+    expect(result).toEqual(new Date(2014, 2 /* Mar */, 1));
+  });
+
+  it("does not mutate the original date", () => {
+    const date = new Date(2014, 6 /* Jul */, 2);
+    setDayOfYear(date, 365);
+    expect(date).toEqual(new Date(2014, 6 /* Jul */, 2));
+  });
+
+  it("returns `Invalid Date` if the given date is invalid", () => {
+    const result = setDayOfYear(new Date(NaN), 2);
+    expect(result instanceof Date && isNaN(result.getTime())).toBe(true);
+  });
+
+  it("returns `Invalid Date` if the given amount is NaN", () => {
+    const result = setDayOfYear(new Date(2014, 6 /* Jul */, 2), NaN);
+    expect(result instanceof Date && isNaN(result.getTime())).toBe(true);
+  });
+});