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

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

@@ -1,14 +1,38 @@
-import { toDate } from '../toDate/index';
-import type { NormalizedInterval } from '../types';
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* eslint-disable */
+// @ts-nocheck
+
+import { normalizeDates } from '../_lib/normalizeDates/index.ts';
+import type { ContextOptions, DateArg, NormalizedInterval } from '../types.ts';
 
 /**
  * The {@link interval} function options.
  */
-export interface IntervalOptions {
+export interface IntervalOptions<ContextDate extends Date = Date> extends ContextOptions<ContextDate> {
   /** Asserts that the interval is positive (start is after the end). */
   assertPositive?: boolean;
 }
 
+/**
+ * The {@link interval} function result type. It resolves the proper data type.
+ * It uses the first argument date object type, starting from the start argument,
+ * then the end interval date. If a context function is passed, it uses the context
+ * function return type.
+ */
+export type IntervalResult<
+  StartDate extends DateArg<Date>,
+  EndDate extends DateArg<Date>,
+  Options extends IntervalOptions | undefined = undefined,
+> = NormalizedInterval<
+  Options extends IntervalOptions<infer DateType extends Date>
+    ? DateType
+    : StartDate extends Date
+      ? StartDate
+      : EndDate extends Date
+        ? EndDate
+        : Date
+>;
+
 /**
  * @name interval
  * @category Interval Helpers
@@ -17,7 +41,9 @@ export interface IntervalOptions {
  * @description
  * Creates a normalized interval object and validates its values. If the interval is invalid, an exception is thrown.
  *
- * @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 StartDate - Start date type.
+ * @typeParam EndDate - End date type.
+ * @typeParam Options - Options type.
  *
  * @param start - The start of the interval.
  * @param end - The end of the interval.
@@ -29,18 +55,19 @@ export interface IntervalOptions {
  *
  * @returns The normalized and validated interval object.
  */
-export function interval<DateType extends Date>(
-  start: DateType | number | string,
-  end: DateType | number | string,
-  options?: IntervalOptions,
-): NormalizedInterval<DateType> {
-  const _start = toDate(start);
-  if (isNaN(+_start)) throw new TypeError('Start date is invalid');
+export function interval<
+  StartDate extends DateArg<Date>,
+  EndDate extends DateArg<Date>,
+  Options extends IntervalOptions | undefined = undefined,
+>(start: StartDate, end: EndDate, options?: Options): IntervalResult<StartDate, EndDate, Options> {
+  const [_start, _end] = normalizeDates(options?.in, start, end);
 
-  const _end = toDate(end);
+  if (isNaN(+_start)) throw new TypeError('Start date is invalid');
   if (isNaN(+_end)) throw new TypeError('End date is invalid');
 
   if (options?.assertPositive && +_start > +_end) throw new TypeError('End date must be after start date');
 
-  return { start: _start, end: _end };
+  return { start: _start, end: _end } as IntervalResult<StartDate, EndDate, Options>;
 }
+
+/* eslint-enable */

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

@@ -1,12 +1,21 @@
-import { add } from '../add/index';
-import { differenceInDays } from '../differenceInDays/index';
-import { differenceInHours } from '../differenceInHours/index';
-import { differenceInMinutes } from '../differenceInMinutes/index';
-import { differenceInMonths } from '../differenceInMonths/index';
-import { differenceInSeconds } from '../differenceInSeconds/index';
-import { differenceInYears } from '../differenceInYears/index';
-import { toDate } from '../toDate/index';
-import type { Duration, Interval } from '../types';
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* eslint-disable */
+// @ts-nocheck
+
+import { normalizeInterval } from '../_lib/normalizeInterval/index.ts';
+import { add } from '../add/index.ts';
+import { differenceInDays } from '../differenceInDays/index.ts';
+import { differenceInHours } from '../differenceInHours/index.ts';
+import { differenceInMinutes } from '../differenceInMinutes/index.ts';
+import { differenceInMonths } from '../differenceInMonths/index.ts';
+import { differenceInSeconds } from '../differenceInSeconds/index.ts';
+import { differenceInYears } from '../differenceInYears/index.ts';
+import type { ContextOptions, Duration, Interval } from '../types.ts';
+
+/**
+ * The {@link intervalToDuration} function options.
+ */
+export interface IntervalToDurationOptions extends ContextOptions<Date> {}
 
 /**
  * @name intervalToDuration
@@ -14,11 +23,10 @@ import type { Duration, Interval } from '../types';
  * @summary Convert interval to duration
  *
  * @description
- * Convert a interval object to a duration object.
- *
- * @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).
+ * Convert an interval object to a duration object.
  *
  * @param interval - The interval to convert to duration
+ * @param options - The context options
  *
  * @returns The duration object
  *
@@ -27,43 +35,37 @@ import type { Duration, Interval } from '../types';
  * intervalToDuration({
  *   start: new Date(1929, 0, 15, 12, 0, 0),
  *   end: new Date(1968, 3, 4, 19, 5, 0)
- * })
- * // => { years: 39, months: 2, days: 20, hours: 7, minutes: 5, seconds: 0 }
+ * });
+ * //=> { years: 39, months: 2, days: 20, hours: 7, minutes: 5, seconds: 0 }
  */
-export function intervalToDuration<DateType extends Date>(interval: Interval<DateType>): Duration {
-  const start = toDate(interval.start);
-  const end = toDate(interval.end);
-
+export function intervalToDuration(interval: Interval, options?: IntervalToDurationOptions | undefined): Duration {
+  const { start, end } = normalizeInterval(options?.in, interval);
   const duration: Duration = {};
 
   const years = differenceInYears(end, start);
   if (years) duration.years = years;
 
-  // @ts-ignore
   const remainingMonths = add(start, { years: duration.years });
-
   const months = differenceInMonths(end, remainingMonths);
   if (months) duration.months = months;
 
-  const remainingDays = add(remainingMonths, { months: duration.months! });
-
+  const remainingDays = add(remainingMonths, { months: duration.months });
   const days = differenceInDays(end, remainingDays);
   if (days) duration.days = days;
 
-  const remainingHours = add(remainingDays, { days: duration.days! });
-
+  const remainingHours = add(remainingDays, { days: duration.days });
   const hours = differenceInHours(end, remainingHours);
   if (hours) duration.hours = hours;
 
-  const remainingMinutes = add(remainingHours, { hours: duration.hours! });
-
+  const remainingMinutes = add(remainingHours, { hours: duration.hours });
   const minutes = differenceInMinutes(end, remainingMinutes);
   if (minutes) duration.minutes = minutes;
 
-  const remainingSeconds = add(remainingMinutes, { minutes: duration.minutes! });
-
+  const remainingSeconds = add(remainingMinutes, { minutes: duration.minutes });
   const seconds = differenceInSeconds(end, remainingSeconds);
   if (seconds) duration.seconds = seconds;
 
   return duration;
 }
+
+/* eslint-enable */

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

@@ -1,7 +1,15 @@
-import { toDate } from '../toDate/index';
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* eslint-disable */
+// @ts-nocheck
+
+import { toDate } from '../toDate/index.ts';
+import type { DateArg, MaybeArray } from '../types.ts';
 
 /**
  * The locale string (see: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl#locales_argument).
+ * @deprecated
+ *
+ * [TODO] Remove in v4
  */
 export type IntlFormatLocale = Intl.ResolvedDateTimeFormatOptions['locale'];
 
@@ -14,8 +22,8 @@ export type IntlFormatFormatOptions = Intl.DateTimeFormatOptions;
  * The locale options.
  */
 export interface IntlFormatLocaleOptions {
-  /** The locale(s) to use (see: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl#locales_argument) */
-  locale: IntlFormatLocale | IntlFormatLocale[];
+  /** The locales to use (see: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl#locales_argument) */
+  locale: MaybeArray<Intl.ResolvedDateTimeFormatOptions['locale']>;
 }
 
 /**
@@ -30,8 +38,6 @@ export interface IntlFormatLocaleOptions {
  *
  * > ⚠️ Please note that before Node version 13.0.0, only the locale data for en-US is available by default.
  *
- * @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 format
  *
  * @returns The formatted date string
@@ -43,11 +49,9 @@ export interface IntlFormatLocaleOptions {
  * const result = intlFormat(new Date(2019, 9, 4, 12, 30, 13, 456))
  * //=> 10/4/2019
  */
-export function intlFormat<DateType extends Date>(date: DateType | number | string): string;
+export function intlFormat(date: DateArg<Date> & {}): string;
 
 /**
- * @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 format
  * @param localeOptions - An object with locale
  *
@@ -63,14 +67,9 @@ export function intlFormat<DateType extends Date>(date: DateType | number | stri
  * })
  * //=> 2019. 10. 4.
  */
-export function intlFormat<DateType extends Date>(
-  date: DateType | number | string,
-  localeOptions: IntlFormatLocaleOptions,
-): string;
+export function intlFormat(date: DateArg<Date> & {}, localeOptions: IntlFormatLocaleOptions): string;
 
 /**
- * @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 format
  * @param formatOptions - The format options
  *
@@ -89,14 +88,9 @@ export function intlFormat<DateType extends Date>(
  * })
  * //=> 10/4/2019, 12 PM
  */
-export function intlFormat<DateType extends Date>(
-  date: DateType | number | string,
-  formatOptions: IntlFormatFormatOptions,
-): string;
+export function intlFormat(date: DateArg<Date> & {}, formatOptions: IntlFormatFormatOptions): string;
 
 /**
- * @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 format
  * @param formatOptions - The format options
  * @param localeOptions - An object with locale
@@ -118,14 +112,14 @@ export function intlFormat<DateType extends Date>(
  * })
  * //=> Freitag, 4. Oktober 2019
  */
-export function intlFormat<DateType extends Date>(
-  date: DateType | number | string,
+export function intlFormat(
+  date: DateArg<Date> & {},
   formatOptions: IntlFormatFormatOptions,
   localeOptions: IntlFormatLocaleOptions,
 ): string;
 
-export function intlFormat<DateType extends Date>(
-  date: DateType | number | string,
+export function intlFormat(
+  date: DateArg<Date> & {},
   formatOrLocale?: IntlFormatFormatOptions | IntlFormatLocaleOptions,
   localeOptions?: IntlFormatLocaleOptions,
 ): string {
@@ -145,3 +139,5 @@ function isFormatOptions(
 ): opts is IntlFormatFormatOptions {
   return opts !== undefined && !('locale' in opts);
 }
+
+/* eslint-enable */

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

@@ -1,3 +1,8 @@
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* eslint-disable */
+// @ts-nocheck
+
+import { normalizeDates } from '../_lib/normalizeDates/index.ts';
 import {
   secondsInDay,
   secondsInHour,
@@ -6,31 +11,25 @@ import {
   secondsInQuarter,
   secondsInWeek,
   secondsInYear,
-} from '../constants/index';
-import { differenceInCalendarDays } from '../differenceInCalendarDays/index';
-import { differenceInCalendarMonths } from '../differenceInCalendarMonths/index';
-import { differenceInCalendarQuarters } from '../differenceInCalendarQuarters/index';
-import { differenceInCalendarWeeks } from '../differenceInCalendarWeeks/index';
-import { differenceInCalendarYears } from '../differenceInCalendarYears/index';
-import { differenceInHours } from '../differenceInHours/index';
-import { differenceInMinutes } from '../differenceInMinutes/index';
-import { differenceInSeconds } from '../differenceInSeconds/index';
-import { toDate } from '../toDate/index';
+} from '../constants/index.ts';
+import { differenceInCalendarDays } from '../differenceInCalendarDays/index.ts';
+import { differenceInCalendarMonths } from '../differenceInCalendarMonths/index.ts';
+import { differenceInCalendarQuarters } from '../differenceInCalendarQuarters/index.ts';
+import { differenceInCalendarWeeks } from '../differenceInCalendarWeeks/index.ts';
+import { differenceInCalendarYears } from '../differenceInCalendarYears/index.ts';
+import { differenceInHours } from '../differenceInHours/index.ts';
+import { differenceInMinutes } from '../differenceInMinutes/index.ts';
+import { differenceInSeconds } from '../differenceInSeconds/index.ts';
+import type { ContextOptions, DateArg, MaybeArray } from '../types.ts';
 
 /**
  * The {@link intlFormatDistance} function options.
  */
-export interface IntlFormatDistanceOptions {
+export interface IntlFormatDistanceOptions extends Intl.RelativeTimeFormatOptions, ContextOptions<Date> {
   /** Force the distance unit */
   unit?: IntlFormatDistanceUnit;
-  /** The locale(s) to use (see: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl#locales_argument) */
-  locale?: Intl.UnicodeBCP47LocaleIdentifier | Intl.UnicodeBCP47LocaleIdentifier[];
-  /** The locale matching algorithm to use. Other value: 'lookup'. See MDN for details [Locale identification and negotiation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl#locale_identification_and_negotiation) */
-  localeMatcher?: Intl.RelativeTimeFormatLocaleMatcher;
-  /** The output message format. The values are 'auto' (e.g. `yesterday`), 'always'(e.g. `1 day ago`) */
-  numeric?: Intl.RelativeTimeFormatNumeric;
-  /** The length of the result. The values are: 'long' (e.g. `1 month`), 'short' (e.g. 'in 1 mo.'), 'narrow' (e.g. 'in 1 mo.'). The narrow one could be similar to the short one for some locales. */
-  style?: Intl.RelativeTimeFormatStyle;
+  /** The locales to use (see: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl#locales_argument) */
+  locale?: MaybeArray<Intl.ResolvedDateTimeFormatOptions['locale']>;
 }
 
 /**
@@ -68,10 +67,8 @@ export type IntlFormatDistanceUnit = 'year' | 'quarter' | 'month' | 'week' | 'da
  * | 1 year                 | last year      | next year       |
  * | 2+ years               | X years ago    | in X years      |
  *
- * @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
- * @param baseDate - The date to compare with.
+ * @param laterDate - The date
+ * @param earlierDate - The date to compare with.
  * @param options - An object with options.
  * See MDN for details [Locale identification and negotiation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl#locale_identification_and_negotiation)
  * The narrow one could be similar to the short one for some locales.
@@ -137,81 +134,85 @@ export type IntlFormatDistanceUnit = 'year' | 'quarter' | 'month' | 'week' | 'da
  * )
  * //=> 'in 2 yr'
  */
-export function intlFormatDistance<DateType extends Date>(
-  date: DateType | number | string,
-  baseDate: DateType | number | string,
+export function intlFormatDistance(
+  laterDate: DateArg<Date> & {},
+  earlierDate: DateArg<Date> & {},
   options?: IntlFormatDistanceOptions,
 ): string {
   let value: number = 0;
   let unit: Intl.RelativeTimeFormatUnit;
-  const dateLeft = toDate(date);
-  const dateRight = toDate(baseDate);
+
+  const [laterDate_, earlierDate_] = normalizeDates(options?.in, laterDate, earlierDate);
 
   if (!options?.unit) {
     // Get the unit based on diffInSeconds calculations if no unit is specified
-    const diffInSeconds = differenceInSeconds(dateLeft, dateRight); // The smallest unit
+    const diffInSeconds = differenceInSeconds(laterDate_, earlierDate_); // The smallest unit
 
     if (Math.abs(diffInSeconds) < secondsInMinute) {
-      value = differenceInSeconds(dateLeft, dateRight);
+      value = differenceInSeconds(laterDate_, earlierDate_);
       unit = 'second';
     } else if (Math.abs(diffInSeconds) < secondsInHour) {
-      value = differenceInMinutes(dateLeft, dateRight);
+      value = differenceInMinutes(laterDate_, earlierDate_);
       unit = 'minute';
-    } else if (Math.abs(diffInSeconds) < secondsInDay && Math.abs(differenceInCalendarDays(dateLeft, dateRight)) < 1) {
-      value = differenceInHours(dateLeft, dateRight);
+    } else if (
+      Math.abs(diffInSeconds) < secondsInDay &&
+      Math.abs(differenceInCalendarDays(laterDate_, earlierDate_)) < 1
+    ) {
+      value = differenceInHours(laterDate_, earlierDate_);
       unit = 'hour';
     } else if (
       Math.abs(diffInSeconds) < secondsInWeek &&
-      (value = differenceInCalendarDays(dateLeft, dateRight)) &&
+      (value = differenceInCalendarDays(laterDate_, earlierDate_)) &&
       Math.abs(value) < 7
     ) {
       unit = 'day';
     } else if (Math.abs(diffInSeconds) < secondsInMonth) {
-      value = differenceInCalendarWeeks(dateLeft, dateRight);
+      value = differenceInCalendarWeeks(laterDate_, earlierDate_);
       unit = 'week';
     } else if (Math.abs(diffInSeconds) < secondsInQuarter) {
-      value = differenceInCalendarMonths(dateLeft, dateRight);
+      value = differenceInCalendarMonths(laterDate_, earlierDate_);
       unit = 'month';
     } else if (Math.abs(diffInSeconds) < secondsInYear) {
-      if (differenceInCalendarQuarters(dateLeft, dateRight) < 4) {
+      if (differenceInCalendarQuarters(laterDate_, earlierDate_) < 4) {
         // To filter out cases that are less than a year but match 4 quarters
-        value = differenceInCalendarQuarters(dateLeft, dateRight);
+        value = differenceInCalendarQuarters(laterDate_, earlierDate_);
         unit = 'quarter';
       } else {
-        value = differenceInCalendarYears(dateLeft, dateRight);
+        value = differenceInCalendarYears(laterDate_, earlierDate_);
         unit = 'year';
       }
     } else {
-      value = differenceInCalendarYears(dateLeft, dateRight);
+      value = differenceInCalendarYears(laterDate_, earlierDate_);
       unit = 'year';
     }
   } else {
     // Get the value if unit is specified
     unit = options?.unit;
     if (unit === 'second') {
-      value = differenceInSeconds(dateLeft, dateRight);
+      value = differenceInSeconds(laterDate_, earlierDate_);
     } else if (unit === 'minute') {
-      value = differenceInMinutes(dateLeft, dateRight);
+      value = differenceInMinutes(laterDate_, earlierDate_);
     } else if (unit === 'hour') {
-      value = differenceInHours(dateLeft, dateRight);
+      value = differenceInHours(laterDate_, earlierDate_);
     } else if (unit === 'day') {
-      value = differenceInCalendarDays(dateLeft, dateRight);
+      value = differenceInCalendarDays(laterDate_, earlierDate_);
     } else if (unit === 'week') {
-      value = differenceInCalendarWeeks(dateLeft, dateRight);
+      value = differenceInCalendarWeeks(laterDate_, earlierDate_);
     } else if (unit === 'month') {
-      value = differenceInCalendarMonths(dateLeft, dateRight);
+      value = differenceInCalendarMonths(laterDate_, earlierDate_);
     } else if (unit === 'quarter') {
-      value = differenceInCalendarQuarters(dateLeft, dateRight);
+      value = differenceInCalendarQuarters(laterDate_, earlierDate_);
     } else if (unit === 'year') {
-      value = differenceInCalendarYears(dateLeft, dateRight);
+      value = differenceInCalendarYears(laterDate_, earlierDate_);
     }
   }
 
   const rtf = new Intl.RelativeTimeFormat(options?.locale, {
-    ...(options?.localeMatcher === undefined ? {} : { localeMatcher: options?.localeMatcher }),
-    numeric: options?.numeric || 'auto',
-    ...(options?.style === undefined ? {} : { style: options?.style }),
+    numeric: 'auto',
+    ...options,
   });
 
   return rtf.format(value, unit);
 }
+
+/* eslint-enable */

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

@@ -1,4 +1,9 @@
-import { toDate } from '../toDate/index';
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* eslint-disable */
+// @ts-nocheck
+
+import { toDate } from '../toDate/index.ts';
+import type { DateArg } from '../types.ts';
 
 /**
  * @name isAfter
@@ -8,8 +13,6 @@ import { toDate } from '../toDate/index';
  * @description
  * Is the first date after the second one?
  *
- * @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 that should be after the other one to return true
  * @param dateToCompare - The date to compare with
  *
@@ -20,11 +23,8 @@ import { toDate } from '../toDate/index';
  * const result = isAfter(new Date(1989, 6, 10), new Date(1987, 1, 11))
  * //=> true
  */
-export function isAfter<DateType extends Date>(
-  date: DateType | number | string,
-  dateToCompare: DateType | number | string,
-): boolean {
-  const _date = toDate(date);
-  const _dateToCompare = toDate(dateToCompare);
-  return _date.getTime() > _dateToCompare.getTime();
+export function isAfter(date: DateArg<Date> & {}, dateToCompare: DateArg<Date> & {}): boolean {
+  return +toDate(date) > +toDate(dateToCompare);
 }
+
+/* eslint-enable */

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

@@ -1,4 +1,9 @@
-import { toDate } from '../toDate/index';
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* eslint-disable */
+// @ts-nocheck
+
+import { toDate } from '../toDate/index.ts';
+import type { DateArg } from '../types.ts';
 
 /**
  * @name isBefore
@@ -8,8 +13,6 @@ import { toDate } from '../toDate/index';
  * @description
  * Is the first date before the second one?
  *
- * @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 that should be before the other one to return true
  * @param dateToCompare - The date to compare with
  *
@@ -20,11 +23,8 @@ import { toDate } from '../toDate/index';
  * const result = isBefore(new Date(1989, 6, 10), new Date(1987, 1, 11))
  * //=> false
  */
-export function isBefore<DateType extends Date>(
-  date: DateType | number | string,
-  dateToCompare: DateType | number | string,
-): boolean {
-  const _date = toDate(date);
-  const _dateToCompare = toDate(dateToCompare);
-  return +_date < +_dateToCompare;
+export function isBefore(date: DateArg<Date> & {}, dateToCompare: DateArg<Date> & {}): boolean {
+  return +toDate(date) < +toDate(dateToCompare);
 }
+
+/* eslint-enable */

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

@@ -1,3 +1,7 @@
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* eslint-disable */
+// @ts-nocheck
+
 /**
  * @name isDate
  * @category Common Helpers
@@ -35,3 +39,5 @@ export function isDate(value: unknown): value is Date {
     value instanceof Date || (typeof value === 'object' && Object.prototype.toString.call(value) === '[object Date]')
   );
 }
+
+/* eslint-enable */

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

@@ -1,4 +1,9 @@
-import { toDate } from '../toDate/index';
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* eslint-disable */
+// @ts-nocheck
+
+import { toDate } from '../toDate/index.ts';
+import type { DateArg } from '../types.ts';
 
 /**
  * @name isEqual
@@ -8,8 +13,6 @@ import { toDate } from '../toDate/index';
  * @description
  * Are the given dates equal?
  *
- * @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 first date to compare
  * @param dateRight - The second date to compare
  *
@@ -23,11 +26,8 @@ import { toDate } from '../toDate/index';
  * )
  * //=> false
  */
-export function isEqual<DateType extends Date>(
-  leftDate: DateType | number | string,
-  rightDate: DateType | number | string,
-): boolean {
-  const _dateLeft = toDate(leftDate);
-  const _dateRight = toDate(rightDate);
-  return +_dateLeft === +_dateRight;
+export function isEqual(leftDate: DateArg<Date> & {}, rightDate: DateArg<Date> & {}): boolean {
+  return +toDate(leftDate) === +toDate(rightDate);
 }
+
+/* eslint-enable */

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

@@ -1,3 +1,7 @@
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* eslint-disable */
+// @ts-nocheck
+
 /**
  * @name isExists
  * @category Common Helpers
@@ -26,3 +30,5 @@ export function isExists(year: number, month: number, day: number): boolean {
   const date = new Date(year, month, day);
   return date.getFullYear() === year && date.getMonth() === month && date.getDate() === day;
 }
+
+/* eslint-enable */

package/src/date-fns/isFirstDayOfMonth/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 isFirstDayOfMonth} function options.
+ */
+export interface IsFirstDayOfMonthOptions extends ContextOptions<Date> {}
 
 /**
  * @name isFirstDayOfMonth
@@ -8,10 +18,9 @@ import { toDate } from '../toDate/index';
  * @description
  * Is the given date the first day of a 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).
- *
  * @param date - The date to check
-
+ * @param options - An object with options
+ *
  * @returns The date is the first day of a month
  *
  * @example
@@ -19,6 +28,8 @@ import { toDate } from '../toDate/index';
  * const result = isFirstDayOfMonth(new Date(2014, 8, 1))
  * //=> true
  */
-export function isFirstDayOfMonth<DateType extends Date>(date: DateType | number | string): boolean {
-  return toDate(date).getDate() === 1;
+export function isFirstDayOfMonth(date: DateArg<Date> & {}, options?: IsFirstDayOfMonthOptions | undefined): boolean {
+  return toDate(date, options?.in).getDate() === 1;
 }
+
+/* eslint-enable */