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

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

@@ -1,20 +1,26 @@
-import { compareAsc } from '../compareAsc/index';
-import { differenceInCalendarMonths } from '../differenceInCalendarMonths/index';
-import { isLastDayOfMonth } from '../isLastDayOfMonth/index';
-import { toDate } from '../toDate/index';
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* eslint-disable */
+// @ts-nocheck
+
+import { normalizeDates } from '../_lib/normalizeDates/index.ts';
+import { compareAsc } from '../compareAsc/index.ts';
+import { differenceInCalendarMonths } from '../differenceInCalendarMonths/index.ts';
+import { isLastDayOfMonth } from '../isLastDayOfMonth/index.ts';
+import type { ContextOptions, DateArg } from '../types.ts';
+
+/**
+ * The {@link differenceInMonths} function options.
+ */
+export interface DifferenceInMonthsOptions extends ContextOptions<Date> {}
 
 /**
  * @name differenceInMonths
  * @category Month Helpers
  * @summary Get the number of full months between the given dates.
  *
- * @description
- * Get the number of full months between the given dates using trunc as a default rounding method.
- *
- * @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 dateLeft - The later date
- * @param dateRight - The earlier date
+ * @param laterDate - The later date
+ * @param earlierDate - The earlier date
+ * @param options - An object with options
  *
  * @returns The number of full months
  *
@@ -23,41 +29,30 @@ import { toDate } from '../toDate/index';
  * const result = differenceInMonths(new Date(2014, 8, 1), new Date(2014, 0, 31))
  * //=> 7
  */
-export function differenceInMonths<DateType extends Date>(
-  dateLeft: DateType | number | string,
-  dateRight: DateType | number | string,
+export function differenceInMonths(
+  laterDate: DateArg<Date> & {},
+  earlierDate: DateArg<Date> & {},
+  options?: DifferenceInMonthsOptions | undefined,
 ): number {
-  const _dateLeft = toDate(dateLeft);
-  const _dateRight = toDate(dateRight);
-
-  const sign = compareAsc(_dateLeft, _dateRight);
-  const difference = Math.abs(differenceInCalendarMonths(_dateLeft, _dateRight));
-  let result;
-
-  // Check for the difference of less than month
-  if (difference < 1) {
-    result = 0;
-  } else {
-    if (_dateLeft.getMonth() === 1 && _dateLeft.getDate() > 27) {
-      // This will check if the date is end of Feb and assign a higher end of month date
-      // to compare it with Jan
-      _dateLeft.setDate(30);
-    }
-
-    _dateLeft.setMonth(_dateLeft.getMonth() - sign * difference);
-
-    // Math.abs(diff in full months - diff in calendar months) === 1 if last calendar month is not full
-    // If so, result must be decreased by 1 in absolute value
-    let isLastMonthNotFull = compareAsc(_dateLeft, _dateRight) === -sign;
-
-    // Check for cases of one full calendar month
-    if (isLastDayOfMonth(toDate(dateLeft)) && difference === 1 && compareAsc(dateLeft, _dateRight) === 1) {
-      isLastMonthNotFull = false;
-    }
-
-    result = sign * (difference - Number(isLastMonthNotFull));
+  const [laterDate_, workingLaterDate, earlierDate_] = normalizeDates(options?.in, laterDate, laterDate, earlierDate);
+
+  const sign = compareAsc(workingLaterDate, earlierDate_);
+  const difference = Math.abs(differenceInCalendarMonths(workingLaterDate, earlierDate_));
+
+  if (difference < 1) return 0;
+
+  if (workingLaterDate.getMonth() === 1 && workingLaterDate.getDate() > 27) workingLaterDate.setDate(30);
+
+  workingLaterDate.setMonth(workingLaterDate.getMonth() - sign * difference);
+
+  let isLastMonthNotFull = compareAsc(workingLaterDate, earlierDate_) === -sign;
+
+  if (isLastDayOfMonth(laterDate_) && difference === 1 && compareAsc(laterDate_, earlierDate_) === 1) {
+    isLastMonthNotFull = false;
   }
 
-  // Prevent negative zero
+  const result = sign * (difference - +isLastMonthNotFull);
   return result === 0 ? 0 : result;
 }
+
+/* eslint-enable */

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

@@ -1,11 +1,15 @@
-import { getRoundingMethod } from '../_lib/getRoundingMethod/index';
-import { differenceInMonths } from '../differenceInMonths/index';
-import type { RoundingOptions } from '../types';
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* eslint-disable */
+// @ts-nocheck
+
+import { getRoundingMethod } from '../_lib/getRoundingMethod/index.ts';
+import { differenceInMonths } from '../differenceInMonths/index.ts';
+import type { ContextOptions, DateArg, RoundingOptions } from '../types.ts';
 
 /**
  * The {@link differenceInQuarters} function options.
  */
-export interface DifferenceInQuartersOptions extends RoundingOptions {}
+export interface DifferenceInQuartersOptions extends RoundingOptions, ContextOptions<Date> {}
 
 /**
  * @name differenceInQuarters
@@ -15,10 +19,8 @@ export interface DifferenceInQuartersOptions extends RoundingOptions {}
  * @description
  * Get the number of quarters between the given dates.
  *
- * @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 dateLeft - The later date
- * @param dateRight - The earlier date
+ * @param laterDate - The later date
+ * @param earlierDate - The earlier date
  * @param options - An object with options.
  *
  * @returns The number of full quarters
@@ -28,11 +30,13 @@ export interface DifferenceInQuartersOptions extends RoundingOptions {}
  * const result = differenceInQuarters(new Date(2014, 6, 2), new Date(2013, 11, 31))
  * //=> 2
  */
-export function differenceInQuarters<DateType extends Date>(
-  dateLeft: DateType | number | string,
-  dateRight: DateType | number | string,
-  options?: DifferenceInQuartersOptions,
+export function differenceInQuarters(
+  laterDate: DateArg<Date> & {},
+  earlierDate: DateArg<Date> & {},
+  options?: DifferenceInQuartersOptions | undefined,
 ): number {
-  const diff = differenceInMonths(dateLeft, dateRight) / 3;
+  const diff = differenceInMonths(laterDate, earlierDate, options) / 3;
   return getRoundingMethod(options?.roundingMethod)(diff);
 }
+
+/* eslint-enable */

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

@@ -1,6 +1,10 @@
-import { getRoundingMethod } from '../_lib/getRoundingMethod/index';
-import { differenceInMilliseconds } from '../differenceInMilliseconds/index';
-import type { RoundingOptions } from '../types';
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* eslint-disable */
+// @ts-nocheck
+
+import { getRoundingMethod } from '../_lib/getRoundingMethod/index.ts';
+import { differenceInMilliseconds } from '../differenceInMilliseconds/index.ts';
+import type { DateArg, RoundingOptions } from '../types.ts';
 
 /**
  * The {@link differenceInSeconds} function options.
@@ -15,10 +19,8 @@ export interface DifferenceInSecondsOptions extends RoundingOptions {}
  * @description
  * Get the number of seconds between the given dates.
  *
- * @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 dateLeft - The later date
- * @param dateRight - The earlier date
+ * @param laterDate - The later date
+ * @param earlierDate - The earlier date
  * @param options - An object with options.
  *
  * @returns The number of seconds
@@ -32,11 +34,13 @@ export interface DifferenceInSecondsOptions extends RoundingOptions {}
  * )
  * //=> 12
  */
-export function differenceInSeconds<DateType extends Date>(
-  dateLeft: DateType | number | string,
-  dateRight: DateType | number | string,
+export function differenceInSeconds(
+  laterDate: DateArg<Date> & {},
+  earlierDate: DateArg<Date> & {},
   options?: DifferenceInSecondsOptions,
 ): number {
-  const diff = differenceInMilliseconds(dateLeft, dateRight) / 1000;
+  const diff = differenceInMilliseconds(laterDate, earlierDate) / 1000;
   return getRoundingMethod(options?.roundingMethod)(diff);
 }
+
+/* eslint-enable */

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

@@ -1,11 +1,15 @@
-import { getRoundingMethod } from '../_lib/getRoundingMethod/index';
-import { differenceInDays } from '../differenceInDays/index';
-import type { RoundingOptions } from '../types';
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* eslint-disable */
+// @ts-nocheck
+
+import { getRoundingMethod } from '../_lib/getRoundingMethod/index.ts';
+import { differenceInDays } from '../differenceInDays/index.ts';
+import type { ContextOptions, DateArg, RoundingOptions } from '../types.ts';
 
 /**
  * The {@link differenceInWeeks} function options.
  */
-export interface DifferenceInWeeksOptions extends RoundingOptions {}
+export interface DifferenceInWeeksOptions extends RoundingOptions, ContextOptions<Date> {}
 
 /**
  * @name differenceInWeeks
@@ -23,10 +27,8 @@ export interface DifferenceInWeeksOptions extends RoundingOptions {}
  * To ignore DST and only measure exact 7*24-hour periods, use this instead:
  * `Math.trunc(differenceInHours(dateLeft, dateRight)/(7*24))|0`.
  *
- * @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 dateLeft - The later date
- * @param dateRight - The earlier date
+ * @param laterDate - The later date
+ * @param earlierDate - The earlier date
  * @param options - An object with options
  *
  * @returns The number of full weeks
@@ -49,11 +51,13 @@ export interface DifferenceInWeeksOptions extends RoundingOptions {}
  * )
  * //=> 8
  */
-export function differenceInWeeks<DateType extends Date>(
-  dateLeft: DateType | number | string,
-  dateRight: DateType | number | string,
-  options?: DifferenceInWeeksOptions,
+export function differenceInWeeks(
+  laterDate: DateArg<Date> & {},
+  earlierDate: DateArg<Date> & {},
+  options?: DifferenceInWeeksOptions | undefined,
 ): number {
-  const diff = differenceInDays(dateLeft, dateRight) / 7;
+  const diff = differenceInDays(laterDate, earlierDate, options) / 7;
   return getRoundingMethod(options?.roundingMethod)(diff);
 }
+
+/* eslint-enable */

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

@@ -1,6 +1,16 @@
-import { compareAsc } from '../compareAsc/index';
-import { differenceInCalendarYears } from '../differenceInCalendarYears/index';
-import { toDate } from '../toDate/index';
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* eslint-disable */
+// @ts-nocheck
+
+import { normalizeDates } from '../_lib/normalizeDates/index.ts';
+import { compareAsc } from '../compareAsc/index.ts';
+import { differenceInCalendarYears } from '../differenceInCalendarYears/index.ts';
+import type { ContextOptions, DateArg } from '../types.ts';
+
+/**
+ * The {@link differenceInYears} function options.
+ */
+export interface DifferenceInYearsOptions extends ContextOptions<Date> {}
 
 /**
  * @name differenceInYears
@@ -10,10 +20,9 @@ import { toDate } from '../toDate/index';
  * @description
  * Get the number of full years between the given dates.
  *
- * @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 dateLeft - The later date
- * @param dateRight - The earlier date
+ * @param laterDate - The later date
+ * @param earlierDate - The earlier date
+ * @param options - An object with options
  *
  * @returns The number of full years
  *
@@ -22,26 +31,38 @@ import { toDate } from '../toDate/index';
  * const result = differenceInYears(new Date(2015, 1, 11), new Date(2013, 11, 31))
  * //=> 1
  */
-export function differenceInYears<DateType extends Date>(
-  dateLeft: DateType | number | string,
-  dateRight: DateType | number | string,
+export function differenceInYears(
+  laterDate: DateArg<Date> & {},
+  earlierDate: DateArg<Date> & {},
+  options?: DifferenceInYearsOptions | undefined,
 ): number {
-  const _dateLeft = toDate(dateLeft);
-  const _dateRight = toDate(dateRight);
+  const [laterDate_, earlierDate_] = normalizeDates(options?.in, laterDate, earlierDate);
+
+  // -1 if the left date is earlier than the right date
+  // 2023-12-31 - 2024-01-01 = -1
+  const sign = compareAsc(laterDate_, earlierDate_);
 
-  const sign = compareAsc(_dateLeft, _dateRight);
-  const difference = Math.abs(differenceInCalendarYears(_dateLeft, _dateRight));
+  // First calculate the difference in calendar years
+  // 2024-01-01 - 2023-12-31 = 1 year
+  const diff = Math.abs(differenceInCalendarYears(laterDate_, earlierDate_));
 
-  // Set both dates to a valid leap year for accurate comparison when dealing
-  // with leap days
-  _dateLeft.setFullYear(1584);
-  _dateRight.setFullYear(1584);
+  // Now we need to calculate if the difference is full. To do that we set
+  // both dates to the same year and check if the both date's month and day
+  // form a full year.
+  laterDate_.setFullYear(1584);
+  earlierDate_.setFullYear(1584);
 
-  // Math.abs(diff in full years - diff in calendar years) === 1 if last calendar year is not full
-  // If so, result must be decreased by 1 in absolute value
-  const isLastYearNotFull = compareAsc(_dateLeft, _dateRight) === -sign;
-  const result = sign * (difference - +isLastYearNotFull);
+  // For it to be true, when the later date is indeed later than the earlier date
+  // (2026-02-01 - 2023-12-10 = 3 years), the difference is full if
+  // the normalized later date is also later than the normalized earlier date.
+  // In our example, 1584-02-01 is earlier than 1584-12-10, so the difference
+  // is partial, hence we need to subtract 1 from the difference 3 - 1 = 2.
+  const partial = compareAsc(laterDate_, earlierDate_) === -sign;
+
+  const result = sign * (diff - +partial);
 
   // Prevent negative zero
   return result === 0 ? 0 : result;
 }
+
+/* eslint-enable */

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

@@ -1,10 +1,34 @@
-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 eachDayOfInterval} function options.
  */
-export interface EachDayOfIntervalOptions extends StepOptions {}
+export interface EachDayOfIntervalOptions<DateType extends Date = Date> extends StepOptions, ContextOptions<DateType> {}
+
+/**
+ * The {@link eachDayOfInterval} 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 EachDayOfIntervalResult<
+  IntervalType extends Interval,
+  Options extends EachDayOfIntervalOptions | undefined,
+> = Array<
+  Options extends EachDayOfIntervalOptions<infer DateType>
+    ? DateType
+    : IntervalType['start'] extends Date
+      ? IntervalType['start']
+      : IntervalType['end'] extends Date
+        ? IntervalType['end']
+        : Date
+>;
 
 /**
  * @name eachDayOfInterval
@@ -14,7 +38,8 @@ export interface EachDayOfIntervalOptions extends StepOptions {}
  * @description
  * Return the array of dates 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.
@@ -35,17 +60,16 @@ export interface EachDayOfIntervalOptions extends StepOptions {}
  * //   Fri Oct 10 2014 00:00:00
  * // ]
  */
-export function eachDayOfInterval<DateType extends Date>(
-  interval: Interval<DateType>,
-  options?: EachDayOfIntervalOptions,
-): DateType[] {
-  const startDate = toDate(interval.start);
-  const endDate = toDate(interval.end);
+export function eachDayOfInterval<
+  IntervalType extends Interval,
+  Options extends EachDayOfIntervalOptions | undefined = undefined,
+>(interval: IntervalType, options?: Options): EachDayOfIntervalResult<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);
+  let reversed = +start > +end;
+  const endTime = reversed ? +start : +end;
+  const date = reversed ? end : start;
+  date.setHours(0, 0, 0, 0);
 
   let step = options?.step ?? 1;
   if (!step) return [];
@@ -54,13 +78,15 @@ export function eachDayOfInterval<DateType extends Date>(
     reversed = !reversed;
   }
 
-  const dates = [];
+  const dates: EachDayOfIntervalResult<IntervalType, Options> = [];
 
-  while (+currentDate <= endTime) {
-    dates.push(toDate(currentDate));
-    currentDate.setDate(currentDate.getDate() + step);
-    currentDate.setHours(0, 0, 0, 0);
+  while (+date <= endTime) {
+    dates.push(constructFrom(start, date));
+    date.setDate(date.getDate() + step);
+    date.setHours(0, 0, 0, 0);
   }
 
   return reversed ? dates.reverse() : dates;
 }
+
+/* eslint-enable */

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

@@ -1,11 +1,34 @@
-import { addHours } from '../addHours/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 { constructFrom } from '../constructFrom/index.ts';
+import type { ContextOptions, Interval, StepOptions } from '../types.ts';
 
 /**
  * The {@link eachHourOfInterval} function options.
  */
-export interface EachHourOfIntervalOptions extends StepOptions {}
+export interface EachHourOfIntervalOptions<DateType extends Date = Date>
+  extends StepOptions,
+    ContextOptions<DateType> {}
+
+/**
+ * The {@link eachHourOfInterval} function result type.
+ * Resolves to the appropriate date type based on inputs.
+ */
+export type EachHourOfIntervalResult<
+  IntervalType extends Interval,
+  Options extends EachHourOfIntervalOptions | undefined,
+> = Array<
+  Options extends EachHourOfIntervalOptions<infer DateType>
+    ? DateType
+    : IntervalType['start'] extends Date
+      ? IntervalType['start']
+      : IntervalType['end'] extends Date
+        ? IntervalType['end']
+        : Date
+>;
 
 /**
  * @name eachHourOfInterval
@@ -15,7 +38,8 @@ export interface EachHourOfIntervalOptions extends StepOptions {}
  * @description
  * Return the array of hours 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.
@@ -27,7 +51,7 @@ export interface EachHourOfIntervalOptions extends StepOptions {}
  * const result = eachHourOfInterval({
  *   start: new Date(2014, 9, 6, 12),
  *   end: new Date(2014, 9, 6, 15)
- * })
+ * });
  * //=> [
  * //   Mon Oct 06 2014 12:00:00,
  * //   Mon Oct 06 2014 13:00:00,
@@ -35,17 +59,16 @@ export interface EachHourOfIntervalOptions extends StepOptions {}
  * //   Mon Oct 06 2014 15:00:00
  * // ]
  */
-export function eachHourOfInterval<DateType extends Date>(
-  interval: Interval<DateType>,
-  options?: EachHourOfIntervalOptions,
-): DateType[] {
-  const startDate = toDate(interval.start);
-  const endDate = toDate(interval.end);
+export function eachHourOfInterval<
+  IntervalType extends Interval,
+  Options extends EachHourOfIntervalOptions | undefined = undefined,
+>(interval: IntervalType, options?: Options): EachHourOfIntervalResult<IntervalType, Options> {
+  const { start, end } = normalizeInterval(options?.in, interval);
 
-  let reversed = +startDate > +endDate;
-  const endTime = reversed ? +startDate : +endDate;
-  let currentDate = reversed ? endDate : startDate;
-  currentDate.setMinutes(0, 0, 0);
+  let reversed = +start > +end;
+  const endTime = reversed ? +start : +end;
+  const date = reversed ? end : start;
+  date.setMinutes(0, 0, 0);
 
   let step = options?.step ?? 1;
   if (!step) return [];
@@ -54,12 +77,14 @@ export function eachHourOfInterval<DateType extends Date>(
     reversed = !reversed;
   }
 
-  const dates = [];
+  const dates: EachHourOfIntervalResult<IntervalType, Options> = [];
 
-  while (+currentDate <= endTime) {
-    dates.push(toDate(currentDate));
-    currentDate = addHours(currentDate, step);
+  while (+date <= endTime) {
+    dates.push(constructFrom(start, date));
+    date.setHours(date.getHours() + step);
   }
 
   return reversed ? dates.reverse() : dates;
 }
+
+/* eslint-enable */

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

@@ -1,12 +1,37 @@
-import { addMinutes } from '../addMinutes/index';
-import { startOfMinute } from '../startOfMinute/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 { addMinutes } from '../addMinutes/index.ts';
+import { constructFrom } from '../constructFrom/index.ts';
+import type { ContextOptions, Interval, StepOptions } from '../types.ts';
 
 /**
  * The {@link eachMinuteOfInterval} function options.
  */
-export interface EachMinuteOfIntervalOptions extends StepOptions {}
+export interface EachMinuteOfIntervalOptions<DateType extends Date = Date>
+  extends StepOptions,
+    ContextOptions<DateType> {}
+
+/**
+ * The {@link eachMinuteOfInterval} 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 EachMinuteOfIntervalResult<
+  IntervalType extends Interval,
+  Options extends EachMinuteOfIntervalOptions | undefined,
+> = Array<
+  Options extends EachMinuteOfIntervalOptions<infer DateType>
+    ? DateType
+    : IntervalType['start'] extends Date
+      ? IntervalType['start']
+      : IntervalType['end'] extends Date
+        ? IntervalType['end']
+        : Date
+>;
 
 /**
  * @name eachMinuteOfInterval
@@ -16,7 +41,8 @@ export interface EachMinuteOfIntervalOptions extends StepOptions {}
  * @description
  * Returns the array of minutes 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.
@@ -36,16 +62,17 @@ export interface EachMinuteOfIntervalOptions extends StepOptions {}
  * //   Wed Oct 14 2014 13:03:00
  * // ]
  */
-export function eachMinuteOfInterval<DateType extends Date>(
-  interval: Interval<DateType>,
-  options?: EachMinuteOfIntervalOptions,
-): DateType[] {
-  const startDate = startOfMinute(toDate(interval.start));
-  const endDate = toDate(interval.end);
+export function eachMinuteOfInterval<
+  IntervalType extends Interval,
+  Options extends EachMinuteOfIntervalOptions | undefined = undefined,
+>(interval: IntervalType, options?: Options): EachMinuteOfIntervalResult<IntervalType, Options> {
+  const { start, end } = normalizeInterval(options?.in, interval);
+  // Set to the start of the minute
+  start.setSeconds(0, 0);
 
-  let reversed = +startDate > +endDate;
-  const endTime = reversed ? +startDate : +endDate;
-  let currentDate = reversed ? endDate : startDate;
+  let reversed = +start > +end;
+  const endTime = reversed ? +start : +end;
+  let date = reversed ? end : start;
 
   let step = options?.step ?? 1;
   if (!step) return [];
@@ -54,12 +81,14 @@ export function eachMinuteOfInterval<DateType extends Date>(
     reversed = !reversed;
   }
 
-  const dates = [];
+  const dates: EachMinuteOfIntervalResult<IntervalType, Options> = [];
 
-  while (+currentDate <= endTime) {
-    dates.push(toDate(currentDate));
-    currentDate = addMinutes(currentDate, step);
+  while (+date <= endTime) {
+    dates.push(constructFrom(start, date));
+    date = addMinutes(date, step);
   }
 
   return reversed ? dates.reverse() : dates;
 }
+
+/* eslint-enable */