@checkdigit/time 4.0.0 → 5.0.0-PR.21-7813

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

@@ -1,10 +1,33 @@
-import { toDate } from '../toDate/index';
-import type { Interval, StepOptions } from '../types';
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* eslint-disable */
+// @ts-nocheck
+
+import { normalizeInterval } from '../_lib/normalizeInterval/index.ts';
+import { constructFrom } from '../constructFrom/index.ts';
+import type { ContextOptions, Interval, StepOptions } from '../types.ts';
 
 /**
  * The {@link eachMonthOfInterval} function options.
  */
-export interface EachMonthOfIntervalOptions extends StepOptions {}
+export interface EachMonthOfIntervalOptions<DateType extends Date = Date>
+  extends StepOptions,
+    ContextOptions<DateType> {}
+
+/**
+ * The {@link eachMonthOfInterval} function result type. It resolves the proper data type.
+ */
+export type EachMonthOfIntervalResult<
+  IntervalType extends Interval,
+  Options extends EachMonthOfIntervalOptions | undefined,
+> = Array<
+  Options extends EachMonthOfIntervalOptions<infer DateType>
+    ? DateType
+    : IntervalType['start'] extends Date
+      ? IntervalType['start']
+      : IntervalType['end'] extends Date
+        ? IntervalType['end']
+        : Date
+>;
 
 /**
  * @name eachMonthOfInterval
@@ -14,9 +37,11 @@ export interface EachMonthOfIntervalOptions extends StepOptions {}
  * @description
  * Return the array of months within the specified time interval.
  *
- * @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).
+ * @typeParam IntervalType - Interval type.
+ * @typeParam Options - Options type.
  *
- * @param interval - The interval
+ * @param interval - The interval.
+ * @param options - An object with options.
  *
  * @returns The array with starts of months from the month of the interval start to the month of the interval end
  *
@@ -36,18 +61,17 @@ export interface EachMonthOfIntervalOptions extends StepOptions {}
  * //   Fri Aug 01 2014 00:00:00
  * // ]
  */
-export function eachMonthOfInterval<DateType extends Date>(
-  interval: Interval<DateType>,
-  options?: EachMonthOfIntervalOptions,
-): DateType[] {
-  const startDate = toDate(interval.start);
-  const endDate = toDate(interval.end);
+export function eachMonthOfInterval<
+  IntervalType extends Interval,
+  Options extends EachMonthOfIntervalOptions | undefined = undefined,
+>(interval: IntervalType, options?: Options): EachMonthOfIntervalResult<IntervalType, Options> {
+  const { start, end } = normalizeInterval(options?.in, interval);
 
-  let reversed = +startDate > +endDate;
-  const endTime = reversed ? +startDate : +endDate;
-  const currentDate = reversed ? endDate : startDate;
-  currentDate.setHours(0, 0, 0, 0);
-  currentDate.setDate(1);
+  let reversed = +start > +end;
+  const endTime = reversed ? +start : +end;
+  const date = reversed ? end : start;
+  date.setHours(0, 0, 0, 0);
+  date.setDate(1);
 
   let step = options?.step ?? 1;
   if (!step) return [];
@@ -56,12 +80,14 @@ export function eachMonthOfInterval<DateType extends Date>(
     reversed = !reversed;
   }
 
-  const dates = [];
+  const dates: EachMonthOfIntervalResult<IntervalType, Options> = [];
 
-  while (+currentDate <= endTime) {
-    dates.push(toDate(currentDate));
-    currentDate.setMonth(currentDate.getMonth() + step);
+  while (+date <= endTime) {
+    dates.push(constructFrom(start, date));
+    date.setMonth(date.getMonth() + step);
   }
 
   return reversed ? dates.reverse() : dates;
 }
+
+/* eslint-enable */

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

@@ -1,12 +1,38 @@
-import { addQuarters } from '../addQuarters/index';
-import { startOfQuarter } from '../startOfQuarter/index';
-import { toDate } from '../toDate/index';
-import type { Interval, StepOptions } from '../types';
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* eslint-disable */
+// @ts-nocheck
+
+import { normalizeInterval } from '../_lib/normalizeInterval/index.ts';
+import { addQuarters } from '../addQuarters/index.ts';
+import { constructFrom } from '../constructFrom/index.ts';
+import { startOfQuarter } from '../startOfQuarter/index.ts';
+import type { ContextOptions, Interval, StepOptions } from '../types.ts';
 
 /**
  * The {@link eachQuarterOfInterval} function options.
  */
-export interface EachQuarterOfIntervalOptions extends StepOptions {}
+export interface EachQuarterOfIntervalOptions<DateType extends Date = Date>
+  extends StepOptions,
+    ContextOptions<DateType> {}
+
+/**
+ * The {@link eachQuarterOfInterval} function result type. It resolves the proper data type.
+ * It uses the first argument date object type, starting from the date argument,
+ * then the start interval date, and finally the end interval date. If
+ * a context function is passed, it uses the context function return type.
+ */
+export type EachQuarterOfIntervalResult<
+  IntervalType extends Interval,
+  Options extends EachQuarterOfIntervalOptions | undefined,
+> = Array<
+  Options extends EachQuarterOfIntervalOptions<infer DateType>
+    ? DateType
+    : IntervalType['start'] extends Date
+      ? IntervalType['start']
+      : IntervalType['end'] extends Date
+        ? IntervalType['end']
+        : Date
+>;
 
 /**
  * @name eachQuarterOfInterval
@@ -16,9 +42,11 @@ export interface EachQuarterOfIntervalOptions extends StepOptions {}
  * @description
  * Return the array of quarters within the specified time interval.
  *
- * @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).
+ * @typeParam IntervalType - Interval type.
+ * @typeParam Options - Options type.
  *
  * @param interval - The interval
+ * @param options - An object with options
  *
  * @returns The array with starts of quarters from the quarter of the interval start to the quarter of the interval end
  *
@@ -26,7 +54,7 @@ export interface EachQuarterOfIntervalOptions extends StepOptions {}
  * // Each quarter within interval 6 February 2014 - 10 August 2014:
  * const result = eachQuarterOfInterval({
  *   start: new Date(2014, 1, 6),
- *   end: new Date(2014, 7, 10)
+ *   end: new Date(2014, 7, 10),
  * })
  * //=> [
  * //   Wed Jan 01 2014 00:00:00,
@@ -34,16 +62,15 @@ export interface EachQuarterOfIntervalOptions extends StepOptions {}
  * //   Tue Jul 01 2014 00:00:00,
  * // ]
  */
-export function eachQuarterOfInterval<DateType extends Date>(
-  interval: Interval<DateType>,
-  options?: EachQuarterOfIntervalOptions,
-): DateType[] {
-  const startDate = toDate(interval.start);
-  const endDate = toDate(interval.end);
+export function eachQuarterOfInterval<
+  IntervalType extends Interval,
+  Options extends EachQuarterOfIntervalOptions | undefined = undefined,
+>(interval: IntervalType, options?: Options): EachQuarterOfIntervalResult<IntervalType, Options> {
+  const { start, end } = normalizeInterval(options?.in, interval);
 
-  let reversed = +startDate > +endDate;
-  const endTime = reversed ? +startOfQuarter(startDate) : +startOfQuarter(endDate);
-  let currentDate = reversed ? startOfQuarter(endDate) : startOfQuarter(startDate);
+  let reversed = +start > +end;
+  const endTime = reversed ? +startOfQuarter(start) : +startOfQuarter(end);
+  let date = reversed ? startOfQuarter(end) : startOfQuarter(start);
 
   let step = options?.step ?? 1;
   if (!step) return [];
@@ -52,12 +79,14 @@ export function eachQuarterOfInterval<DateType extends Date>(
     reversed = !reversed;
   }
 
-  const dates = [];
+  const dates: EachQuarterOfIntervalResult<IntervalType, Options> = [];
 
-  while (+currentDate <= endTime) {
-    dates.push(toDate(currentDate));
-    currentDate = addQuarters(currentDate, step);
+  while (+date <= endTime) {
+    dates.push(constructFrom(start, date));
+    date = addQuarters(date, step);
   }
 
   return reversed ? dates.reverse() : dates;
 }
+
+/* eslint-enable */

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

@@ -1,12 +1,39 @@
-import { addWeeks } from '../addWeeks/index';
-import { startOfWeek } from '../startOfWeek/index';
-import { toDate } from '../toDate/index';
-import type { Interval, LocalizedOptions, StepOptions, WeekOptions } from '../types';
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* eslint-disable */
+// @ts-nocheck
+
+import { normalizeInterval } from '../_lib/normalizeInterval/index.ts';
+import { addWeeks } from '../addWeeks/index.ts';
+import { constructFrom } from '../constructFrom/index.ts';
+import { startOfWeek } from '../startOfWeek/index.ts';
+import type { ContextOptions, Interval, LocalizedOptions, StepOptions, WeekOptions } from '../types.ts';
 
 /**
  * The {@link eachWeekOfInterval} function options.
  */
-export interface EachWeekOfIntervalOptions extends StepOptions, WeekOptions, LocalizedOptions<'options'> {}
+export interface EachWeekOfIntervalOptions<DateType extends Date = Date>
+  extends StepOptions,
+    WeekOptions,
+    LocalizedOptions<'options'>,
+    ContextOptions<DateType> {}
+
+/**
+ * The {@link eachWeekOfInterval} function result type. It resolves the proper data type.
+ * It uses the first argument date object type, starting from the interval start date,
+ * then the end interval date. If a context function is passed, it uses the context function return type.
+ */
+export type EachWeekOfIntervalResult<
+  IntervalType extends Interval,
+  Options extends EachWeekOfIntervalOptions | undefined,
+> = Array<
+  Options extends EachWeekOfIntervalOptions<infer DateType>
+    ? DateType
+    : IntervalType['start'] extends Date
+      ? IntervalType['start']
+      : IntervalType['end'] extends Date
+        ? IntervalType['end']
+        : Date
+>;
 
 /**
  * @name eachWeekOfInterval
@@ -16,8 +43,6 @@ export interface EachWeekOfIntervalOptions extends StepOptions, WeekOptions, Loc
  * @description
  * Return the array of weeks within the specified time interval.
  *
- * @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 interval - The interval.
  * @param options - An object with options.
  *
@@ -40,18 +65,16 @@ export interface EachWeekOfIntervalOptions extends StepOptions, WeekOptions, Loc
  * //   Sun Nov 23 2014 00:00:00
  * // ]
  */
-export function eachWeekOfInterval<DateType extends Date>(
-  interval: Interval<DateType>,
-  options?: EachWeekOfIntervalOptions,
-): DateType[] {
-  const startDate = toDate(interval.start);
-  const endDate = toDate(interval.end);
+export function eachWeekOfInterval<
+  IntervalType extends Interval,
+  Options extends EachWeekOfIntervalOptions | undefined = undefined,
+>(interval: IntervalType, options?: Options): EachWeekOfIntervalResult<IntervalType, Options> {
+  const { start, end } = normalizeInterval(options?.in, interval);
 
-  let reversed = +startDate > +endDate;
-  const startDateWeek = reversed ? startOfWeek(endDate, options) : startOfWeek(startDate, options);
-  const endDateWeek = reversed ? startOfWeek(startDate, options) : startOfWeek(endDate, options);
+  let reversed = +start > +end;
+  const startDateWeek = reversed ? startOfWeek(end, options) : startOfWeek(start, options);
+  const endDateWeek = reversed ? startOfWeek(start, options) : startOfWeek(end, options);
 
-  // Some timezones switch DST at midnight, making start of day unreliable in these timezones, 3pm is a safe bet
   startDateWeek.setHours(15);
   endDateWeek.setHours(15);
 
@@ -65,14 +88,16 @@ export function eachWeekOfInterval<DateType extends Date>(
     reversed = !reversed;
   }
 
-  const dates = [];
+  const dates: EachWeekOfIntervalResult<IntervalType, Options> = [];
 
   while (+currentDate <= endTime) {
     currentDate.setHours(0);
-    dates.push(toDate(currentDate));
+    dates.push(constructFrom(start, currentDate));
     currentDate = addWeeks(currentDate, step);
     currentDate.setHours(15);
   }
 
   return reversed ? dates.reverse() : dates;
 }
+
+/* eslint-enable */

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

@@ -1,6 +1,33 @@
-import { eachDayOfInterval } from '../eachDayOfInterval/index';
-import { isWeekend } from '../isWeekend/index';
-import type { Interval } from '../types';
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* eslint-disable */
+// @ts-nocheck
+
+import { normalizeInterval } from '../_lib/normalizeInterval/index.ts';
+import { constructFrom } from '../constructFrom/index.ts';
+import { eachDayOfInterval } from '../eachDayOfInterval/index.ts';
+import { isWeekend } from '../isWeekend/index.ts';
+import type { ContextOptions, Interval } from '../types.ts';
+
+/**
+ * The {@link eachWeekendOfInterval} function options.
+ */
+export interface EachWeekendOfIntervalOptions<DateType extends Date = Date> extends ContextOptions<DateType> {}
+
+/**
+ * The {@link eachWeekendOfInterval} function result type.
+ */
+export type EachWeekendOfIntervalResult<
+  IntervalType extends Interval,
+  Options extends EachWeekendOfIntervalOptions | undefined,
+> = Array<
+  Options extends EachWeekendOfIntervalOptions<infer DateType>
+    ? DateType
+    : IntervalType['start'] extends Date
+      ? IntervalType['start']
+      : IntervalType['end'] extends Date
+        ? IntervalType['end']
+        : Date
+>;
 
 /**
  * @name eachWeekendOfInterval
@@ -10,9 +37,11 @@ import type { Interval } from '../types';
  * @description
  * Get all the Saturdays and Sundays in the given date interval.
  *
- * @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).
+ * @typeParam IntervalType - Interval type.
+ * @typeParam Options - Options type.
  *
  * @param interval - The given interval
+ * @param options - An object with options
  *
  * @returns An array containing all the Saturdays and Sundays
  *
@@ -29,13 +58,19 @@ import type { Interval } from '../types';
  * //   Sun Sep 30 2018 00:00:00
  * // ]
  */
-export function eachWeekendOfInterval<DateType extends Date>(interval: Interval<DateType>): DateType[] {
-  const dateInterval = eachDayOfInterval(interval);
-  const weekends = [];
+export function eachWeekendOfInterval<
+  IntervalType extends Interval,
+  Options extends EachWeekendOfIntervalOptions | undefined = undefined,
+>(interval: IntervalType, options?: Options): EachWeekendOfIntervalResult<IntervalType, Options> {
+  const { start, end } = normalizeInterval(options?.in, interval);
+  const dateInterval = eachDayOfInterval({ start, end }, options);
+  const weekends: EachWeekendOfIntervalResult<IntervalType, Options> = [];
   let index = 0;
   while (index < dateInterval.length) {
     const date = dateInterval[index++];
-    if (isWeekend(date!)) weekends.push(date!);
+    if (isWeekend(date)) weekends.push(constructFrom(start, date));
   }
   return weekends;
 }
+
+/* eslint-enable */

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

@@ -1,6 +1,16 @@
-import { eachWeekendOfInterval } from '../eachWeekendOfInterval/index';
-import { endOfMonth } from '../endOfMonth/index';
-import { startOfMonth } from '../startOfMonth/index';
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* eslint-disable */
+// @ts-nocheck
+
+import { eachWeekendOfInterval } from '../eachWeekendOfInterval/index.ts';
+import { endOfMonth } from '../endOfMonth/index.ts';
+import { startOfMonth } from '../startOfMonth/index.ts';
+import type { ContextOptions, DateArg } from '../types.ts';
+
+/**
+ * The {@link eachWeekendOfMonth} function options.
+ */
+export interface EachWeekendOfMonthOptions<DateType extends Date = Date> extends ContextOptions<DateType> {}
 
 /**
  * @name eachWeekendOfMonth
@@ -11,8 +21,10 @@ import { startOfMonth } from '../startOfMonth/index';
  * Get all the Saturdays and Sundays in the given month.
  *
  * @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).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
  *
  * @param date - The given month
+ * @param options - An object with options
  *
  * @returns An array containing all the Saturdays and Sundays
  *
@@ -30,8 +42,13 @@ import { startOfMonth } from '../startOfMonth/index';
  * //   Sun Feb 27 2022 00:00:00
  * // ]
  */
-export function eachWeekendOfMonth<DateType extends Date>(date: DateType): DateType[] {
-  const start = startOfMonth(date);
-  const end = endOfMonth(date);
-  return eachWeekendOfInterval({ start, end });
+export function eachWeekendOfMonth<DateType extends Date, ResultDate extends Date = DateType>(
+  date: DateArg<DateType>,
+  options?: EachWeekendOfMonthOptions<ResultDate>,
+): ResultDate[] {
+  const start = startOfMonth(date, options);
+  const end = endOfMonth(date, options);
+  return eachWeekendOfInterval({ start, end }, options);
 }
+
+/* eslint-enable */

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

@@ -1,6 +1,16 @@
-import { eachWeekendOfInterval } from '../eachWeekendOfInterval/index';
-import { endOfYear } from '../endOfYear/index';
-import { startOfYear } from '../startOfYear/index';
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* eslint-disable */
+// @ts-nocheck
+
+import { eachWeekendOfInterval } from '../eachWeekendOfInterval/index.ts';
+import { endOfYear } from '../endOfYear/index.ts';
+import { startOfYear } from '../startOfYear/index.ts';
+import type { ContextOptions, DateArg } from '../types.ts';
+
+/**
+ * The {@link eachWeekendOfYear} function options.
+ */
+export interface EachWeekendOfYearOptions<DateType extends Date = Date> extends ContextOptions<DateType> {}
 
 /**
  * @name eachWeekendOfYear
@@ -11,8 +21,10 @@ import { startOfYear } from '../startOfYear/index';
  * Get all the Saturdays and Sundays in the year.
  *
  * @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).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
  *
  * @param date - The given year
+ * @param options - An object with options
  *
  * @returns An array containing all the Saturdays and Sundays
  *
@@ -27,8 +39,13 @@ import { startOfYear } from '../startOfYear/index';
  * // ]
  * ]
  */
-export function eachWeekendOfYear<DateType extends Date>(date: DateType | number | string): DateType[] {
-  const start = startOfYear(date);
-  const end = endOfYear(date);
-  return eachWeekendOfInterval({ start, end });
+export function eachWeekendOfYear<DateType extends Date, ResultDate extends Date = DateType>(
+  date: DateArg<DateType>,
+  options?: EachWeekendOfYearOptions<ResultDate>,
+): ResultDate[] {
+  const start = startOfYear(date, options);
+  const end = endOfYear(date, options);
+  return eachWeekendOfInterval({ start, end }, options);
 }
+
+/* eslint-enable */

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

@@ -1,10 +1,36 @@
-import { toDate } from '../toDate/index';
-import type { Interval, StepOptions } from '../types';
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* eslint-disable */
+// @ts-nocheck
+
+import { normalizeInterval } from '../_lib/normalizeInterval/index.ts';
+import { constructFrom } from '../constructFrom/index.ts';
+import type { ContextOptions, Interval, StepOptions } from '../types.ts';
 
 /**
  * The {@link eachYearOfInterval} function options.
  */
-export interface EachYearOfIntervalOptions extends StepOptions {}
+export interface EachYearOfIntervalOptions<DateType extends Date = Date>
+  extends StepOptions,
+    ContextOptions<DateType> {}
+
+/**
+ * The {@link eachYearOfInterval} function result type. It resolves the proper data type.
+ * It uses the first argument date object type, starting from the date argument,
+ * then the start interval date, and finally the end interval date. If
+ * a context function is passed, it uses the context function return type.
+ */
+export type EachYearOfIntervalResult<
+  IntervalType extends Interval,
+  Options extends EachYearOfIntervalOptions | undefined,
+> = Array<
+  Options extends EachYearOfIntervalOptions<infer DateType>
+    ? DateType
+    : IntervalType['start'] extends Date
+      ? IntervalType['start']
+      : IntervalType['end'] extends Date
+        ? IntervalType['end']
+        : Date
+>;
 
 /**
  * @name eachYearOfInterval
@@ -14,9 +40,11 @@ export interface EachYearOfIntervalOptions extends StepOptions {}
  * @description
  * Return the array of yearly timestamps within the specified time interval.
  *
- * @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).
+ * @typeParam IntervalType - Interval type.
+ * @typeParam Options - Options type.
  *
  * @param interval - The interval.
+ * @param options - An object with options.
  *
  * @returns The array with starts of yearly timestamps from the month of the interval start to the month of the interval end
  *
@@ -33,18 +61,17 @@ export interface EachYearOfIntervalOptions extends StepOptions {}
  * //   Sun Jan 01 2017 00:00:00
  * // ]
  */
-export function eachYearOfInterval<DateType extends Date>(
-  interval: Interval<DateType>,
-  options?: EachYearOfIntervalOptions,
-): DateType[] {
-  const startDate = toDate(interval.start);
-  const endDate = toDate(interval.end);
+export function eachYearOfInterval<
+  IntervalType extends Interval,
+  Options extends EachYearOfIntervalOptions | undefined = undefined,
+>(interval: IntervalType, options?: Options): EachYearOfIntervalResult<IntervalType, Options> {
+  const { start, end } = normalizeInterval(options?.in, interval);
 
-  let reversed = +startDate > +endDate;
-  const endTime = reversed ? +startDate : +endDate;
-  const currentDate = reversed ? endDate : startDate;
-  currentDate.setHours(0, 0, 0, 0);
-  currentDate.setMonth(0, 1);
+  let reversed = +start > +end;
+  const endTime = reversed ? +start : +end;
+  const date = reversed ? end : start;
+  date.setHours(0, 0, 0, 0);
+  date.setMonth(0, 1);
 
   let step = options?.step ?? 1;
   if (!step) return [];
@@ -53,12 +80,14 @@ export function eachYearOfInterval<DateType extends Date>(
     reversed = !reversed;
   }
 
-  const dates = [];
+  const dates: EachYearOfIntervalResult<IntervalType, Options> = [];
 
-  while (+currentDate <= endTime) {
-    dates.push(toDate(currentDate));
-    currentDate.setFullYear(currentDate.getFullYear() + step);
+  while (+date <= endTime) {
+    dates.push(constructFrom(start, date));
+    date.setFullYear(date.getFullYear() + step);
   }
 
   return reversed ? dates.reverse() : dates;
 }
+
+/* eslint-enable */

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

@@ -1,4 +1,14 @@
-import { toDate } from '../toDate/index';
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* eslint-disable */
+// @ts-nocheck
+
+import { toDate } from '../toDate/index.ts';
+import type { ContextOptions, DateArg } from '../types.ts';
+
+/**
+ * The {@link endOfDay} function options.
+ */
+export interface EndOfDayOptions<DateType extends Date = Date> extends ContextOptions<DateType> {}
 
 /**
  * @name endOfDay
@@ -10,8 +20,10 @@ import { toDate } from '../toDate/index';
  * The result will be in the local timezone.
  *
  * @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).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
  *
  * @param date - The original date
+ * @param options - An object with options
  *
  * @returns The end of a day
  *
@@ -20,8 +32,13 @@ import { toDate } from '../toDate/index';
  * const result = endOfDay(new Date(2014, 8, 2, 11, 55, 0))
  * //=> Tue Sep 02 2014 23:59:59.999
  */
-export function endOfDay<DateType extends Date>(date: DateType | number | string): DateType {
-  const _date = toDate(date);
+export function endOfDay<DateType extends Date, ResultDate extends Date = DateType>(
+  date: DateArg<DateType>,
+  options?: EndOfDayOptions<ResultDate> | undefined,
+): ResultDate {
+  const _date = toDate(date, options?.in);
   _date.setHours(23, 59, 59, 999);
   return _date;
 }
+
+/* eslint-enable */