@checkdigit/time 1.1.0 → 2.0.0-PR.14-c9b0

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

@@ -0,0 +1,64 @@
+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';
+
+/**
+ * @name intervalToDuration
+ * @category Common Helpers
+ * @summary Convert interval to duration
+ *
+ * @description
+ * Convert a interval object to a duration object.
+ *
+ * @param interval - the interval to convert to duration
+ *
+ * @returns The duration Object
+ * @throws {RangeError} `start` must not be Invalid Date
+ * @throws {RangeError} `end` must not be Invalid Date
+ * @throws {RangeError} The start of an interval cannot be after its end
+ *
+ * @example
+ * // Get the duration between January 15, 1929 and April 4, 1968.
+ * 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 }
+ */
+export default function interval<DateType extends Date>(interval: Interval<DateType>): Duration {
+  const start = toDate(interval.start);
+  const end = toDate(interval.end);
+
+  if (isNaN(start.getTime())) throw new RangeError('Start Date is invalid');
+  if (isNaN(end.getTime())) throw new RangeError('End Date is invalid');
+  if (start > end) {
+    throw new RangeError('The start of an interval cannot be after its end');
+  }
+
+  const duration: Duration = {
+    years: differenceInYears(end, start),
+  };
+
+  const remainingMonths = add(start, { years: duration.years as number });
+  duration.months = differenceInMonths(end, remainingMonths);
+
+  const remainingDays = add(remainingMonths, { months: duration.months });
+  duration.days = differenceInDays(end, remainingDays);
+
+  const remainingHours = add(remainingDays, { days: duration.days });
+  duration.hours = differenceInHours(end, remainingHours);
+
+  const remainingMinutes = add(remainingHours, { hours: duration.hours });
+  duration.minutes = differenceInMinutes(end, remainingMinutes);
+
+  const remainingSeconds = add(remainingMinutes, { minutes: duration.minutes });
+  duration.seconds = differenceInSeconds(end, remainingSeconds);
+
+  return duration;
+}

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

@@ -0,0 +1,104 @@
+type Locale = Intl.ResolvedDateTimeFormatOptions['locale'];
+type FormatOptions = Intl.DateTimeFormatOptions;
+type LocaleOptions = { locale: Locale | Locale[] };
+
+export default function intlFormat<DateType extends Date>(date: DateType): string;
+
+export default function intlFormat<DateType extends Date>(date: DateType, localeOptions: LocaleOptions): string;
+
+export default function intlFormat<DateType extends Date>(date: DateType, formatOptions: FormatOptions): string;
+
+export default function intlFormat<DateType extends Date>(
+  date: DateType,
+  formatOptions: FormatOptions,
+  localeOptions: LocaleOptions,
+): string;
+
+/**
+ * @name intlFormat
+ * @category Common Helpers
+ * @summary  Format the date with Intl.DateTimeFormat (https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat).
+ *
+ * @description
+ * Return the formatted date string in the given format.
+ * The method uses [`Intl.DateTimeFormat`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat) inside.
+ * formatOptions are the same as [`Intl.DateTimeFormat` options](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat#using_options)
+ *
+ * > ⚠️ Please note that before Node version 13.0.0, only the locale data for en-US is available by default.
+ *
+ * @param argument - the original date.
+ * @param formatOptions - an object with options.
+ * @param formatOptions.localeMatcher - locale selection algorithm.
+ * @param formatOptions.weekday - representation the days of the week.
+ * @param formatOptions.era - representation of eras.
+ * @param formatOptions.year - representation of years.
+ * @param formatOptions.month - representation of month.
+ * @param formatOptions.day - representation of day.
+ * @param formatOptions.hour - representation of hours.
+ * @param formatOptions.minute - representation of minutes.
+ * @param formatOptions.second - representation of seconds.
+ * @param formatOptions.timeZoneName - representation of names of time zones.
+ * @param formatOptions.formatMatcher - format selection algorithm.
+ * @param formatOptions.hour12 - determines whether to use 12-hour time format.
+ * @param formatOptions.timeZone - the time zone to use.
+ * @param localeOptions - an object with locale.
+ * @param localeOptions.locale - the locale code
+ * @returns the formatted date string.
+ * @throws {RangeError} `date` must not be Invalid Date
+ *
+ * @example
+ * // Represent 10 October 2019 in German.
+ * // Convert the date with format's options and locale's options.
+ * const result = intlFormat(new Date(2019, 9, 4, 12, 30, 13, 456), {
+ *      weekday: 'long',
+ *      year: 'numeric',
+ *      month: 'long',
+ *      day: 'numeric',
+ *    }, {
+ *      locale: 'de-DE',
+ *  })
+ * //=> Freitag, 4. Oktober 2019
+ *
+ * @example
+ * // Represent 10 October 2019.
+ * // Convert the date with format's options.
+ * const result = intlFormat.default(new Date(2019, 9, 4, 12, 30, 13, 456), {
+ *      year: 'numeric',
+ *      month: 'numeric',
+ *      day: 'numeric',
+ *      hour: 'numeric',
+ *  })
+ * //=> 10/4/2019, 12 PM
+ *
+ * @example
+ * // Represent 10 October 2019 in Korean.
+ * // Convert the date with locale's options.
+ * const result = intlFormat(new Date(2019, 9, 4, 12, 30, 13, 456), {
+ *      locale: 'ko-KR',
+ *  })
+ * //=> 2019. 10. 4.
+ *
+ * @example
+ * // Represent 10 October 2019 in middle-endian format:
+ * const result = intlFormat(new Date(2019, 9, 4, 12, 30, 13, 456))
+ * //=> 10/4/2019
+ */
+export default function intlFormat<DateType extends Date>(
+  date: DateType,
+  formatOrLocale?: FormatOptions | LocaleOptions,
+  localeOptions?: LocaleOptions,
+): string {
+  let formatOptions: FormatOptions | undefined;
+
+  if (isFormatOptions(formatOrLocale)) {
+    formatOptions = formatOrLocale;
+  } else {
+    localeOptions = formatOrLocale;
+  }
+
+  return new Intl.DateTimeFormat(localeOptions?.locale, formatOptions).format(date);
+}
+
+function isFormatOptions(opts: LocaleOptions | FormatOptions | undefined): opts is FormatOptions {
+  return opts !== undefined && !('locale' in opts);
+}

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

@@ -0,0 +1,204 @@
+import {
+  secondsInDay,
+  secondsInHour,
+  secondsInMinute,
+  secondsInMonth,
+  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';
+import type { IntlOptionsUnit } from '../types';
+
+/**
+ * The {@link intlFormatDistance} function options.
+ */
+export interface IntlFormatDistanceOptions {
+  unit?: IntlOptionsUnit;
+  locale?: Intl.BCP47LanguageTag;
+  localeMatcher?: Intl.RelativeTimeFormatLocaleMatcher;
+  numeric?: Intl.RelativeTimeFormatNumeric;
+  style?: Intl.RelativeTimeFormatStyle;
+}
+
+/**
+ * @name intlFormatDistance
+ * @category Common Helpers
+ * @summary Formats distance between two dates in a human-readable format
+ * @description
+ * The function calculates the difference between two dates and formats it as a human-readable string.
+ *
+ * The function will pick the most appropriate unit depending on the distance between dates. For example, if the distance is a few hours, it might return `x hours`. If the distance is a few months, it might return `x months`.
+ *
+ * You can also specify a unit to force using it regardless of the distance to get a result like `123456 hours`.
+ *
+ * See the table below for the unit picking logic:
+ *
+ * | Distance between dates | Result (past)  | Result (future) |
+ * | ---------------------- | -------------- | --------------- |
+ * | 0 seconds              | now            | now             |
+ * | 1-59 seconds           | X seconds ago  | in X seconds    |
+ * | 1-59 minutes           | X minutes ago  | in X minutes    |
+ * | 1-23 hours             | X hours ago    | in X hours      |
+ * | 1 day                  | yesterday      | tomorrow        |
+ * | 2-6 days               | X days ago     | in X days       |
+ * | 7 days                 | last week      | next week       |
+ * | 8 days-1 month         | X weeks ago    | in X weeks      |
+ * | 1 month                | last month     | next month      |
+ * | 2-3 months             | X months ago   | in X months     |
+ * | 1 quarter              | last quarter   | next quarter    |
+ * | 2-3 quarters           | X quarters ago | in X quarters   |
+ * | 1 year                 | last year      | next year       |
+ * | 2+ years               | X years ago    | in X years      |
+ *
+ * @param date - the date
+ * @param baseDate - 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.
+ * @returns the distance in words according to language-sensitive relative time formatting.
+ * @throws {RangeError} `date` must not be Invalid Date
+ * @throws {RangeError} `baseDate` must not be Invalid Date
+ * @throws {RangeError} `options.unit` must not be invalid Unit
+ * @throws {RangeError} `options.locale` must not be invalid locale
+ * @throws {RangeError} `options.localeMatcher` must not be invalid localeMatcher
+ * @throws {RangeError} `options.numeric` must not be invalid numeric
+ * @throws {RangeError} `options.style` must not be invalid style
+ *
+ * @example
+ * // What is the distance between the dates when the fist date is after the second?
+ * intlFormatDistance(
+ *   new Date(1986, 3, 4, 11, 30, 0),
+ *   new Date(1986, 3, 4, 10, 30, 0)
+ * )
+ * //=> 'in 1 hour'
+ *
+ * // What is the distance between the dates when the fist date is before the second?
+ * intlFormatDistance(
+ *   new Date(1986, 3, 4, 10, 30, 0),
+ *   new Date(1986, 3, 4, 11, 30, 0)
+ * )
+ * //=> '1 hour ago'
+ *
+ * @example
+ * // Use the unit option to force the function to output the result in quarters. Without setting it, the example would return "next year"
+ * intlFormatDistance(
+ *   new Date(1987, 6, 4, 10, 30, 0),
+ *   new Date(1986, 3, 4, 10, 30, 0),
+ *   { unit: 'quarter' }
+ * )
+ * //=> 'in 5 quarters'
+ *
+ * @example
+ * // Use the locale option to get the result in Spanish. Without setting it, the example would return "in 1 hour".
+ * intlFormatDistance(
+ *   new Date(1986, 3, 4, 11, 30, 0),
+ *   new Date(1986, 3, 4, 10, 30, 0),
+ *   { locale: 'es' }
+ * )
+ * //=> 'dentro de 1 hora'
+ *
+ * @example
+ * // Use the numeric option to force the function to use numeric values. Without setting it, the example would return "tomorrow".
+ * intlFormatDistance(
+ *   new Date(1986, 3, 5, 11, 30, 0),
+ *   new Date(1986, 3, 4, 11, 30, 0),
+ *   { numeric: 'always' }
+ * )
+ * //=> 'in 1 day'
+ *
+ * @example
+ * // Use the style option to force the function to use short values. Without setting it, the example would return "in 2 years".
+ * intlFormatDistance(
+ *   new Date(1988, 3, 4, 11, 30, 0),
+ *   new Date(1986, 3, 4, 11, 30, 0),
+ *   { style: 'short' }
+ * )
+ * //=> 'in 2 yr'
+ */
+export default function intlFormatDistance(
+  date: Date | number,
+  baseDate: Date | number,
+  options?: IntlFormatDistanceOptions,
+): string {
+  let value: number = 0;
+  let unit: Intl.RelativeTimeFormatUnit;
+  const dateLeft = toDate(date);
+  const dateRight = toDate(baseDate);
+
+  if (!options?.unit) {
+    // Get the unit based on diffInSeconds calculations if no unit is specified
+    const diffInSeconds = differenceInSeconds(dateLeft, dateRight); // The smallest unit
+
+    if (Math.abs(diffInSeconds) < secondsInMinute) {
+      value = differenceInSeconds(dateLeft, dateRight);
+      unit = 'second';
+    } else if (Math.abs(diffInSeconds) < secondsInHour) {
+      value = differenceInMinutes(dateLeft, dateRight);
+      unit = 'minute';
+    } else if (Math.abs(diffInSeconds) < secondsInDay && Math.abs(differenceInCalendarDays(dateLeft, dateRight)) < 1) {
+      value = differenceInHours(dateLeft, dateRight);
+      unit = 'hour';
+    } else if (
+      Math.abs(diffInSeconds) < secondsInWeek &&
+      (value = differenceInCalendarDays(dateLeft, dateRight)) &&
+      Math.abs(value) < 7
+    ) {
+      unit = 'day';
+    } else if (Math.abs(diffInSeconds) < secondsInMonth) {
+      value = differenceInCalendarWeeks(dateLeft, dateRight);
+      unit = 'week';
+    } else if (Math.abs(diffInSeconds) < secondsInQuarter) {
+      value = differenceInCalendarMonths(dateLeft, dateRight);
+      unit = 'month';
+    } else if (Math.abs(diffInSeconds) < secondsInYear) {
+      if (differenceInCalendarQuarters(dateLeft, dateRight) < 4) {
+        // To filter out cases that are less than a year but match 4 quarters
+        value = differenceInCalendarQuarters(dateLeft, dateRight);
+        unit = 'quarter';
+      } else {
+        value = differenceInCalendarYears(dateLeft, dateRight);
+        unit = 'year';
+      }
+    } else {
+      value = differenceInCalendarYears(dateLeft, dateRight);
+      unit = 'year';
+    }
+  } else {
+    // Get the value if unit is specified
+    unit = options?.unit;
+    if (unit === 'second') {
+      value = differenceInSeconds(dateLeft, dateRight);
+    } else if (unit === 'minute') {
+      value = differenceInMinutes(dateLeft, dateRight);
+    } else if (unit === 'hour') {
+      value = differenceInHours(dateLeft, dateRight);
+    } else if (unit === 'day') {
+      value = differenceInCalendarDays(dateLeft, dateRight);
+    } else if (unit === 'week') {
+      value = differenceInCalendarWeeks(dateLeft, dateRight);
+    } else if (unit === 'month') {
+      value = differenceInCalendarMonths(dateLeft, dateRight);
+    } else if (unit === 'quarter') {
+      value = differenceInCalendarQuarters(dateLeft, dateRight);
+    } else if (unit === 'year') {
+      value = differenceInCalendarYears(dateLeft, dateRight);
+    }
+  }
+
+  const rtf = new Intl.RelativeTimeFormat(options?.locale, {
+    localeMatcher: options?.localeMatcher as Intl.RelativeTimeFormatLocaleMatcher,
+    numeric: options?.numeric || 'auto',
+    style: options?.style as Intl.RelativeTimeFormatStyle,
+  });
+
+  return rtf.format(value, unit);
+}

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

@@ -0,0 +1,27 @@
+import toDate from '../toDate/index';
+
+/**
+ * @name isAfter
+ * @category Common Helpers
+ * @summary Is the first date after the second one?
+ *
+ * @description
+ * Is the first date after the second one?
+ *
+ * @param date - the date that should be after the other one to return true
+ * @param dateToCompare - the date to compare with
+ * @returns the first date is after the second date
+ *
+ * @example
+ * // Is 10 July 1989 after 11 February 1987?
+ * const result = isAfter(new Date(1989, 6, 10), new Date(1987, 1, 11))
+ * //=> true
+ */
+export default function isAfter<DateType extends Date>(
+  dirtyDate: DateType | number,
+  dirtyDateToCompare: DateType | number,
+): boolean {
+  const date = toDate(dirtyDate);
+  const dateToCompare = toDate(dirtyDateToCompare);
+  return date.getTime() > dateToCompare.getTime();
+}

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

@@ -0,0 +1,27 @@
+import toDate from '../toDate/index';
+
+/**
+ * @name isBefore
+ * @category Common Helpers
+ * @summary Is the first date before the second one?
+ *
+ * @description
+ * Is the first date before the second one?
+ *
+ * @param date - the date that should be before the other one to return true
+ * @param dateToCompare - the date to compare with
+ * @returns the first date is before the second date
+ *
+ * @example
+ * // Is 10 July 1989 before 11 February 1987?
+ * const result = isBefore(new Date(1989, 6, 10), new Date(1987, 1, 11))
+ * //=> false
+ */
+export default function isBefore<DateType extends Date>(
+  dirtyDate: DateType | number,
+  dirtyDateToCompare: DateType | number,
+): boolean {
+  const date = toDate(dirtyDate);
+  const dateToCompare = toDate(dirtyDateToCompare);
+  return date.getTime() < dateToCompare.getTime();
+}

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

@@ -0,0 +1,36 @@
+/**
+ * @name isDate
+ * @category Common Helpers
+ * @summary Is the given value a date?
+ *
+ * @description
+ * Returns true if the given value is an instance of Date. The function works for dates transferred across iframes.
+ *
+ * @param value - the value to check
+ * @returns true if the given value is a date
+ *
+ * @example
+ * // For a valid date:
+ * const result = isDate(new Date())
+ * //=> true
+ *
+ * @example
+ * // For an invalid date:
+ * const result = isDate(new Date(NaN))
+ * //=> true
+ *
+ * @example
+ * // For some value:
+ * const result = isDate('2014-02-31')
+ * //=> false
+ *
+ * @example
+ * // For an object:
+ * const result = isDate({})
+ * //=> false
+ */
+export default function isDate(value: unknown): value is Date {
+  return (
+    value instanceof Date || (typeof value === 'object' && Object.prototype.toString.call(value) === '[object Date]')
+  );
+}

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

@@ -0,0 +1,30 @@
+import toDate from '../toDate/index';
+
+/**
+ * @name isEqual
+ * @category Common Helpers
+ * @summary Are the given dates equal?
+ *
+ * @description
+ * Are the given dates equal?
+ *
+ * @param dateLeft - the first date to compare
+ * @param dateRight - the second date to compare
+ * @returns the dates are equal
+ *
+ * @example
+ * // Are 2 July 2014 06:30:45.000 and 2 July 2014 06:30:45.500 equal?
+ * const result = isEqual(
+ *   new Date(2014, 6, 2, 6, 30, 45, 0),
+ *   new Date(2014, 6, 2, 6, 30, 45, 500)
+ * )
+ * //=> false
+ */
+export default function isEqual<DateType extends Date>(
+  dirtyLeftDate: DateType | number,
+  dirtyRightDate: DateType | number,
+): boolean {
+  const dateLeft = toDate(dirtyLeftDate);
+  const dateRight = toDate(dirtyRightDate);
+  return dateLeft.getTime() === dateRight.getTime();
+}

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

@@ -0,0 +1,27 @@
+/**
+ * @name isExists
+ * @category Common Helpers
+ * @summary Is the given date exists?
+ *
+ * @description
+ * Checks if the given arguments convert to an existing date.
+ *
+ * @param year of the date to check
+ * @param month of the date to check
+ * @param day of the date to check
+ * @returns the date exists
+ *
+ * @example
+ * // For the valid date:
+ * const result = isExists(2018, 0, 31)
+ * //=> true
+ *
+ * @example
+ * // For the invalid date:
+ * const result = isExists(2018, 1, 31)
+ * //=> false
+ */
+export default 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;
+}

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

@@ -0,0 +1,21 @@
+import toDate from '../toDate/index';
+
+/**
+ * @name isFirstDayOfMonth
+ * @category Month Helpers
+ * @summary Is the given date the first day of a month?
+ *
+ * @description
+ * Is the given date the first day of a month?
+ *
+ * @param date - the date to check
+ * @returns the date is the first day of a month
+ *
+ * @example
+ * // Is 1 September 2014 the first day of a month?
+ * const result = isFirstDayOfMonth(new Date(2014, 8, 1))
+ * //=> true
+ */
+export default function isFirstDayOfMonth<DateType extends Date>(dirtyDate: DateType | number): boolean {
+  return toDate(dirtyDate).getDate() === 1;
+}

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

@@ -0,0 +1,21 @@
+import toDate from '../toDate/index';
+
+/**
+ * @name isFriday
+ * @category Weekday Helpers
+ * @summary Is the given date Friday?
+ *
+ * @description
+ * Is the given date Friday?
+ *
+ * @param date - the date to check
+ * @returns the date is Friday
+ *
+ * @example
+ * // Is 26 September 2014 Friday?
+ * const result = isFriday(new Date(2014, 8, 26))
+ * //=> true
+ */
+export default function isFriday<DateType extends Date>(dirtyDate: DateType | number): boolean {
+  return toDate(dirtyDate).getDay() === 5;
+}

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

@@ -0,0 +1,25 @@
+import toDate from '../toDate/index';
+
+/**
+ * @name isFuture
+ * @category Common Helpers
+ * @summary Is the given date in the future?
+ * @pure false
+ *
+ * @description
+ * Is the given date in the future?
+ *
+ * > ⚠️ Please note that this function is not present in the FP submodule as
+ * > it uses `Date.now()` internally hence impure and can't be safely curried.
+ *
+ * @param date - the date to check
+ * @returns the date is in the future
+ *
+ * @example
+ * // If today is 6 October 2014, is 31 December 2014 in the future?
+ * const result = isFuture(new Date(2014, 11, 31))
+ * //=> true
+ */
+export default function isFuture<DateType extends Date>(dirtyDate: DateType | number): boolean {
+  return toDate(dirtyDate).getTime() > Date.now();
+}

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

@@ -0,0 +1,24 @@
+import endOfDay from '../endOfDay/index';
+import endOfMonth from '../endOfMonth/index';
+import toDate from '../toDate/index';
+
+/**
+ * @name isLastDayOfMonth
+ * @category Month Helpers
+ * @summary Is the given date the last day of a month?
+ *
+ * @description
+ * Is the given date the last day of a month?
+ *
+ * @param date - the date to check
+ * @returns the date is the last day of a month
+ *
+ * @example
+ * // Is 28 February 2014 the last day of a month?
+ * const result = isLastDayOfMonth(new Date(2014, 1, 28))
+ * //=> true
+ */
+export default function isLastDayOfMonth<DateType extends Date>(dirtyDate: DateType | number): boolean {
+  const date = toDate(dirtyDate);
+  return endOfDay(date).getTime() === endOfMonth(date).getTime();
+}

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

@@ -0,0 +1,23 @@
+import toDate from '../toDate/index';
+
+/**
+ * @name isLeapYear
+ * @category Year Helpers
+ * @summary Is the given date in the leap year?
+ *
+ * @description
+ * Is the given date in the leap year?
+ *
+ * @param date - the date to check
+ * @returns the date is in the leap year
+ *
+ * @example
+ * // Is 1 September 2012 in the leap year?
+ * const result = isLeapYear(new Date(2012, 8, 1))
+ * //=> true
+ */
+export default function isLeapYear<DateType extends Date>(dirtyDate: DateType | number): boolean {
+  const date = toDate(dirtyDate);
+  const year = date.getFullYear();
+  return year % 400 === 0 || (year % 4 === 0 && year % 100 !== 0);
+}