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

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

@@ -1,23 +1,40 @@
-import compareAsc from '../compareAsc/index';
-import { millisecondsInMinute, minutesInDay, minutesInMonth, minutesInYear } from '../constants/index';
-import toDate from '../toDate/index';
-import type { LocaleOptions, FormatDistanceStrictUnit } from '../types';
-import assign from '../_lib/assign/index';
-import cloneObject from '../_lib/cloneObject/index';
-import defaultLocale from '../_lib/defaultLocale/index';
-import { getDefaultOptions } from '../_lib/defaultOptions/index';
-import getTimezoneOffsetInMilliseconds from '../_lib/getTimezoneOffsetInMilliseconds/index';
-import { getRoundingMethod } from '../_lib/roundingMethods/index';
+import { defaultLocale } from "../_lib/defaultLocale/index";
+import { getDefaultOptions } from "../_lib/defaultOptions/index";
+import { getRoundingMethod } from "../_lib/getRoundingMethod/index";
+import { getTimezoneOffsetInMilliseconds } from "../_lib/getTimezoneOffsetInMilliseconds/index";
+import { compareAsc } from "../compareAsc/index";
+import {
+  millisecondsInMinute,
+  minutesInDay,
+  minutesInMonth,
+  minutesInYear,
+} from "../constants/index";
+import { toDate } from "../toDate/index";
+import type { LocalizedOptions, RoundingOptions } from "../types";
 
 /**
  * The {@link formatDistanceStrict} function options.
  */
-export interface FormatDistanceStrictOptions extends LocaleOptions {
+export interface FormatDistanceStrictOptions
+  extends LocalizedOptions<"formatDistance">,
+    RoundingOptions {
+  /** Add "X ago"/"in X" in the locale language */
   addSuffix?: boolean;
+  /** If specified, will force the unit */
   unit?: FormatDistanceStrictUnit;
-  roundingMethod?: 'floor' | 'ceil' | 'round';
 }
 
+/**
+ * The unit used to format the distance in {@link formatDistanceStrict}.
+ */
+export type FormatDistanceStrictUnit =
+  | "second"
+  | "minute"
+  | "hour"
+  | "day"
+  | "month"
+  | "year";
+
 /**
  * @name formatDistanceStrict
  * @category Common Helpers
@@ -37,14 +54,18 @@ export interface FormatDistanceStrictOptions extends LocaleOptions {
  * | 1 ... 11 months        | [1..11] months      |
  * | 1 ... N years          | [1..N]  years       |
  *
- * @param date - the date
- * @param baseDate - the date to compare with
- * @param options - an object with options.
- * @returns the distance in words
- * @throws {RangeError} `date` must not be Invalid Date
- * @throws {RangeError} `baseDate` must not be Invalid Date
- * @throws {RangeError} `options.unit` must be 'second', 'minute', 'hour', 'day', 'month' or 'year'
- * @throws {RangeError} `options.locale` must contain `formatDistance` property
+ * @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 options - An object with options
+ *
+ * @returns The distance in words
+ *
+ * @throws `date` must not be Invalid Date
+ * @throws `baseDate` must not be Invalid Date
+ * @throws `options.unit` must be 'second', 'minute', 'hour', 'day', 'month' or 'year'
+ * @throws `options.locale` must contain `formatDistance` property
  *
  * @example
  * // What is the distance between 2 July 2014 and 1 January 2015?
@@ -94,25 +115,21 @@ export interface FormatDistanceStrictOptions extends LocaleOptions {
  * //=> '1 jaro'
  */
 
-export default function formatDistanceStrict<DateType extends Date>(
-  dirtyDate: DateType | number,
-  dirtyBaseDate: DateType | number,
+export function formatDistanceStrict<DateType extends Date>(
+  date: DateType | number | string,
+  baseDate: DateType | number | string,
   options?: FormatDistanceStrictOptions,
 ): string {
   const defaultOptions = getDefaultOptions();
   const locale = options?.locale ?? defaultOptions.locale ?? defaultLocale;
 
-  if (!locale.formatDistance) {
-    throw new RangeError('locale must contain localize.formatDistance property');
-  }
-
-  const comparison = compareAsc(dirtyDate, dirtyBaseDate);
+  const comparison = compareAsc(date, baseDate);
 
   if (isNaN(comparison)) {
-    throw new RangeError('Invalid time value');
+    throw new RangeError("Invalid time value");
   }
 
-  const localizeOptions = assign(cloneObject(options), {
+  const localizeOptions = Object.assign({}, options, {
     addSuffix: options?.addSuffix,
     comparison: comparison as -1 | 0 | 1,
   });
@@ -120,74 +137,77 @@ export default function formatDistanceStrict<DateType extends Date>(
   let dateLeft;
   let dateRight;
   if (comparison > 0) {
-    dateLeft = toDate(dirtyBaseDate);
-    dateRight = toDate(dirtyDate);
+    dateLeft = toDate(baseDate);
+    dateRight = toDate(date);
   } else {
-    dateLeft = toDate(dirtyDate);
-    dateRight = toDate(dirtyBaseDate);
+    dateLeft = toDate(date);
+    dateRight = toDate(baseDate);
   }
 
-  const roundingMethod = getRoundingMethod(options?.roundingMethod ?? 'round');
+  const roundingMethod = getRoundingMethod(options?.roundingMethod ?? "round");
 
   const milliseconds = dateRight.getTime() - dateLeft.getTime();
   const minutes = milliseconds / millisecondsInMinute;
 
-  const timezoneOffset = getTimezoneOffsetInMilliseconds(dateRight) - getTimezoneOffsetInMilliseconds(dateLeft);
+  const timezoneOffset =
+    getTimezoneOffsetInMilliseconds(dateRight) -
+    getTimezoneOffsetInMilliseconds(dateLeft);
 
   // Use DST-normalized difference in minutes for years, months and days;
   // use regular difference in minutes for hours, minutes and seconds.
-  const dstNormalizedMinutes = (milliseconds - timezoneOffset) / millisecondsInMinute;
+  const dstNormalizedMinutes =
+    (milliseconds - timezoneOffset) / millisecondsInMinute;
 
   const defaultUnit = options?.unit;
   let unit: FormatDistanceStrictUnit;
   if (!defaultUnit) {
     if (minutes < 1) {
-      unit = 'second';
+      unit = "second";
     } else if (minutes < 60) {
-      unit = 'minute';
+      unit = "minute";
     } else if (minutes < minutesInDay) {
-      unit = 'hour';
+      unit = "hour";
     } else if (dstNormalizedMinutes < minutesInMonth) {
-      unit = 'day';
+      unit = "day";
     } else if (dstNormalizedMinutes < minutesInYear) {
-      unit = 'month';
+      unit = "month";
     } else {
-      unit = 'year';
+      unit = "year";
     }
   } else {
     unit = defaultUnit;
   }
 
   // 0 up to 60 seconds
-  if (unit === 'second') {
+  if (unit === "second") {
     const seconds = roundingMethod(milliseconds / 1000);
-    return locale.formatDistance('xSeconds', seconds, localizeOptions);
+    return locale.formatDistance("xSeconds", seconds, localizeOptions);
 
     // 1 up to 60 mins
-  } else if (unit === 'minute') {
+  } else if (unit === "minute") {
     const roundedMinutes = roundingMethod(minutes);
-    return locale.formatDistance('xMinutes', roundedMinutes, localizeOptions);
+    return locale.formatDistance("xMinutes", roundedMinutes, localizeOptions);
 
     // 1 up to 24 hours
-  } else if (unit === 'hour') {
+  } else if (unit === "hour") {
     const hours = roundingMethod(minutes / 60);
-    return locale.formatDistance('xHours', hours, localizeOptions);
+    return locale.formatDistance("xHours", hours, localizeOptions);
 
     // 1 up to 30 days
-  } else if (unit === 'day') {
+  } else if (unit === "day") {
     const days = roundingMethod(dstNormalizedMinutes / minutesInDay);
-    return locale.formatDistance('xDays', days, localizeOptions);
+    return locale.formatDistance("xDays", days, localizeOptions);
 
     // 1 up to 12 months
-  } else if (unit === 'month') {
+  } else if (unit === "month") {
     const months = roundingMethod(dstNormalizedMinutes / minutesInMonth);
-    return months === 12 && defaultUnit !== 'month'
-      ? locale.formatDistance('xYears', 1, localizeOptions)
-      : locale.formatDistance('xMonths', months, localizeOptions);
+    return months === 12 && defaultUnit !== "month"
+      ? locale.formatDistance("xYears", 1, localizeOptions)
+      : locale.formatDistance("xMonths", months, localizeOptions);
 
     // 1 year up to max Date
   } else {
     const years = roundingMethod(dstNormalizedMinutes / minutesInYear);
-    return locale.formatDistance('xYears', years, localizeOptions);
+    return locale.formatDistance("xYears", years, localizeOptions);
   }
 }

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

@@ -0,0 +1,437 @@
+import { describe, expect, it } from "vitest";
+import type { FormatDistanceFn } from "../locale/types";
+import { formatDistanceStrict } from "./index";
+
+describe("formatDistanceStrict", () => {
+  describe("seconds", () => {
+    describe("when no unit is set", () => {
+      it("0 seconds", () => {
+        const result = formatDistanceStrict(
+          new Date(1986, 3, 4, 10, 32, 5),
+          new Date(1986, 3, 4, 10, 32, 5),
+        );
+        expect(result).toBe("0 seconds");
+      });
+
+      it("5 seconds", () => {
+        const result = formatDistanceStrict(
+          new Date(1986, 3, 4, 10, 32, 0),
+          new Date(1986, 3, 4, 10, 32, 5),
+        );
+        expect(result).toBe("5 seconds");
+      });
+    });
+  });
+
+  describe("minutes", () => {
+    it("1 minute", () => {
+      const result = formatDistanceStrict(
+        new Date(1986, 3, 4, 10, 32, 0),
+        new Date(1986, 3, 4, 10, 33, 0),
+      );
+      expect(result).toBe("1 minute");
+    });
+
+    it("n minutes", () => {
+      const result = formatDistanceStrict(
+        new Date(1986, 3, 4, 10, 32, 0),
+        new Date(1986, 3, 4, 10, 35, 0),
+      );
+      expect(result).toBe("3 minutes");
+    });
+  });
+
+  describe("hours", () => {
+    it("1 hour", () => {
+      const result = formatDistanceStrict(
+        new Date(1986, 3, 4, 10, 32, 0),
+        new Date(1986, 3, 4, 11, 32, 0),
+      );
+      expect(result).toBe("1 hour");
+    });
+
+    it("n hours", () => {
+      const result = formatDistanceStrict(
+        new Date(1986, 3, 4, 10, 32, 0),
+        new Date(1986, 3, 4, 13, 32, 0),
+      );
+      expect(result).toBe("3 hours");
+    });
+  });
+
+  describe("days", () => {
+    it("1 day", () => {
+      const result = formatDistanceStrict(
+        new Date(1986, 3, 4, 10, 32, 0),
+        new Date(1986, 3, 5, 10, 32, 0),
+      );
+      expect(result).toBe("1 day");
+    });
+
+    it("n days", () => {
+      const result = formatDistanceStrict(
+        new Date(1986, 3, 4, 10, 32, 0),
+        new Date(1986, 3, 7, 10, 32, 0),
+      );
+      expect(result).toBe("3 days");
+    });
+  });
+
+  describe("months", () => {
+    it("1 month", () => {
+      const result = formatDistanceStrict(
+        new Date(1986, 3, 4, 10, 32, 0),
+        new Date(1986, 4, 4, 10, 32, 0),
+      );
+      expect(result).toBe("1 month");
+    });
+
+    it("n months", () => {
+      const result = formatDistanceStrict(
+        new Date(1986, 3, 4, 10, 32, 0),
+        new Date(1986, 6, 4, 10, 32, 0),
+      );
+      expect(result).toBe("3 months");
+    });
+  });
+
+  describe("years", () => {
+    it("returns `1 year` - see issue 2388", () => {
+      const result = formatDistanceStrict(
+        new Date(2015, 0, 2),
+        new Date(2016, 0, 1),
+      );
+      expect(result).toBe("1 year");
+    });
+
+    it("returns `2 years` - see issue 2388", () => {
+      const result = formatDistanceStrict(
+        new Date(2014, 0, 2),
+        new Date(2016, 0, 1),
+      );
+      expect(result).toBe("2 years");
+    });
+
+    it("1 year", () => {
+      const result = formatDistanceStrict(
+        new Date(1986, 3, 4, 10, 32, 0),
+        new Date(1987, 3, 4, 10, 32, 0),
+      );
+      expect(result).toBe("1 year");
+    });
+
+    it("n years", () => {
+      const result = formatDistanceStrict(
+        new Date(1986, 3, 4, 10, 32, 0),
+        new Date(1991, 3, 4, 10, 32, 0),
+      );
+      expect(result).toBe("5 years");
+    });
+  });
+
+  describe("when the unit option is supplied", () => {
+    describe("second", () => {
+      it("0 seconds", () => {
+        const result = formatDistanceStrict(
+          new Date(1986, 3, 4, 10, 32, 0),
+          new Date(1986, 3, 4, 10, 32, 0),
+          { unit: "second" },
+        );
+        expect(result).toBe("0 seconds");
+      });
+
+      it("5 seconds", () => {
+        const result = formatDistanceStrict(
+          new Date(1986, 3, 4, 10, 32, 0),
+          new Date(1986, 3, 4, 10, 32, 5),
+          { unit: "second" },
+        );
+        expect(result).toBe("5 seconds");
+      });
+
+      it("120 seconds", () => {
+        const result = formatDistanceStrict(
+          new Date(1986, 3, 4, 10, 32, 0),
+          new Date(1986, 3, 4, 10, 34, 0),
+          { unit: "second" },
+        );
+        expect(result).toBe("120 seconds");
+      });
+    });
+
+    describe("minute", () => {
+      it("0 minutes", () => {
+        const result = formatDistanceStrict(
+          new Date(1986, 3, 4, 10, 32, 0),
+          new Date(1986, 3, 4, 10, 32, 0),
+          { unit: "minute" },
+        );
+        expect(result).toBe("0 minutes");
+      });
+
+      it("5 minutes", () => {
+        const result = formatDistanceStrict(
+          new Date(1986, 3, 4, 10, 32, 0),
+          new Date(1986, 3, 4, 10, 37, 0),
+          { unit: "minute" },
+        );
+        expect(result).toBe("5 minutes");
+      });
+
+      it("120 minutes", () => {
+        const result = formatDistanceStrict(
+          new Date(1986, 3, 4, 10, 32, 0),
+          new Date(1986, 3, 4, 12, 32, 0),
+          { unit: "minute" },
+        );
+        expect(result).toBe("120 minutes");
+      });
+    });
+
+    describe("hour", () => {
+      it("0 hours", () => {
+        const result = formatDistanceStrict(
+          new Date(1986, 3, 4, 10, 32, 0),
+          new Date(1986, 3, 4, 10, 32, 0),
+          { unit: "hour" },
+        );
+        expect(result).toBe("0 hours");
+      });
+
+      it("5 hours", () => {
+        const result = formatDistanceStrict(
+          new Date(1986, 3, 4, 10, 32, 0),
+          new Date(1986, 3, 4, 15, 32, 0),
+          { unit: "hour" },
+        );
+        expect(result).toBe("5 hours");
+      });
+
+      it("48 hours", () => {
+        const result = formatDistanceStrict(
+          new Date(1986, 3, 4, 10, 32, 0),
+          new Date(1986, 3, 6, 10, 32, 0),
+          { unit: "hour" },
+        );
+        expect(result).toBe("48 hours");
+      });
+    });
+
+    describe("day", () => {
+      it("0 days", () => {
+        const result = formatDistanceStrict(
+          new Date(1986, 3, 4, 10, 32, 0),
+          new Date(1986, 3, 4, 10, 32, 0),
+          { unit: "day" },
+        );
+        expect(result).toBe("0 days");
+      });
+
+      it("5 days", () => {
+        const result = formatDistanceStrict(
+          new Date(1986, 3, 4, 10, 32, 0),
+          new Date(1986, 3, 9, 10, 32, 0),
+          { unit: "day" },
+        );
+        expect(result).toBe("5 days");
+      });
+
+      it("60 days", () => {
+        const result = formatDistanceStrict(
+          new Date(1986, 3, 4, 10, 32, 0),
+          new Date(1986, 5, 3, 10, 32, 0),
+          { unit: "day" },
+        );
+        expect(result).toBe("60 days");
+      });
+    });
+    describe("month", () => {
+      it("0 months", () => {
+        const result = formatDistanceStrict(
+          new Date(1986, 3, 4, 10, 32, 0),
+          new Date(1986, 3, 4, 10, 32, 0),
+          { unit: "month" },
+        );
+        expect(result).toBe("0 months");
+      });
+
+      it("5 months", () => {
+        const result = formatDistanceStrict(
+          new Date(1986, 3, 4, 10, 32, 0),
+          new Date(1986, 7, 4, 10, 32, 0),
+          { unit: "month" },
+        );
+        expect(result).toBe("4 months");
+      });
+
+      it("12 months - see issue 2388", () => {
+        const result = formatDistanceStrict(
+          new Date(1986, 7, 4, 10, 32, 0),
+          new Date(1985, 7, 4, 10, 32, 0),
+          { unit: "month" },
+        );
+        expect(result).toBe("12 months");
+      });
+
+      it("24 months", () => {
+        const result = formatDistanceStrict(
+          new Date(1986, 3, 4, 10, 32, 0),
+          new Date(1988, 3, 4, 10, 32, 0),
+          { unit: "month" },
+        );
+        expect(result).toBe("24 months");
+      });
+    });
+
+    describe("year", () => {
+      it("0 years", () => {
+        const result = formatDistanceStrict(
+          new Date(1986, 3, 4, 10, 32, 0),
+          new Date(1986, 3, 4, 10, 32, 0),
+          { unit: "year" },
+        );
+        expect(result).toBe("0 years");
+      });
+
+      it("5 years", () => {
+        const result = formatDistanceStrict(
+          new Date(1986, 3, 4, 10, 32, 0),
+          new Date(1991, 3, 4, 15, 32, 0),
+          { unit: "year" },
+        );
+        expect(result).toBe("5 years");
+      });
+    });
+  });
+
+  it("accepts timestamps", () => {
+    const result = formatDistanceStrict(
+      new Date(1986, 3, 4, 10, 32, 0).getTime(),
+      new Date(1986, 3, 4, 11, 32, 0).getTime(),
+    );
+    expect(result).toBe("1 hour");
+  });
+
+  describe("when the addSuffix option is true", () => {
+    it("adds a past suffix", () => {
+      const result = formatDistanceStrict(
+        new Date(1986, 3, 4, 10, 32, 0),
+        new Date(1986, 3, 4, 10, 32, 25),
+        { addSuffix: true },
+      );
+      expect(result).toBe("25 seconds ago");
+    });
+
+    it("adds a future suffix", () => {
+      const result = formatDistanceStrict(
+        new Date(1986, 3, 4, 11, 32, 0),
+        new Date(1986, 3, 4, 10, 32, 0),
+        { addSuffix: true },
+      );
+      expect(result).toBe("in 1 hour");
+    });
+  });
+
+  describe("when the roundingMethod option is supplied", () => {
+    it('default is "round"', () => {
+      const result = formatDistanceStrict(
+        new Date(1986, 3, 4, 10, 32, 0),
+        new Date(1986, 3, 4, 10, 33, 59),
+      );
+      expect(result).toBe("2 minutes");
+    });
+
+    it('"floor"', () => {
+      const result = formatDistanceStrict(
+        new Date(1986, 3, 4, 10, 32, 0),
+        new Date(1986, 3, 4, 10, 33, 59),
+        { roundingMethod: "floor" },
+      );
+      expect(result).toBe("1 minute");
+    });
+
+    it('"ceil"', () => {
+      const result = formatDistanceStrict(
+        new Date(1986, 3, 4, 10, 32, 0),
+        new Date(1986, 3, 4, 10, 33, 1),
+        { roundingMethod: "ceil" },
+      );
+      expect(result).toBe("2 minutes");
+    });
+
+    it('"round" (down)', () => {
+      const result = formatDistanceStrict(
+        new Date(1986, 3, 4, 10, 32, 0),
+        new Date(1986, 3, 4, 10, 33, 29),
+        { roundingMethod: "round" },
+      );
+      expect(result).toBe("1 minute");
+    });
+
+    it('"round" (up)', () => {
+      const result = formatDistanceStrict(
+        new Date(1986, 3, 4, 10, 32, 0),
+        new Date(1986, 3, 4, 10, 33, 30),
+        { roundingMethod: "round" },
+      );
+      expect(result).toBe("2 minutes");
+    });
+  });
+
+  describe("custom locale", () => {
+    it("can be passed to the function", () => {
+      const formatDistance: FormatDistanceFn = (token, count, options) => {
+        expect(token).toBe("xSeconds");
+        expect(count).toBe(25);
+        expect(options!.addSuffix).toBe(true);
+        expect(options!.comparison!).toBeLessThan(0);
+        return "It works!";
+      };
+
+      const customLocale = {
+        formatDistance,
+      };
+
+      const result = formatDistanceStrict(
+        new Date(1986, 3, 4, 10, 32, 0),
+        new Date(1986, 3, 4, 10, 32, 25),
+        {
+          addSuffix: true,
+          locale: customLocale,
+        },
+      );
+
+      expect(result).toBe("It works!");
+    });
+  });
+
+  describe("edge cases", () => {
+    it("detects unit correctly for short months", () => {
+      const result = formatDistanceStrict(
+        new Date(2018, 1 /* Feb */, 1),
+        new Date(2018, 2 /* Mar */, 1),
+      );
+      expect(result).toBe("28 days");
+    });
+  });
+
+  it("throws `RangeError` if the first date is `Invalid Date`", () => {
+    expect(formatDistanceStrict.bind(
+      null,
+      new Date(NaN),
+      new Date(1986, 3, 7, 10, 32, 0),
+    )).toThrow(RangeError);
+  });
+
+  it("throws `RangeError` if the second date is `Invalid Date`", () => {
+    expect(formatDistanceStrict.bind(
+      null,
+      new Date(1986, 3, 4, 10, 32, 0),
+      new Date(NaN),
+    )).toThrow(RangeError);
+  });
+
+  it("throws `RangeError` if the both dates are `Invalid Date`", () => {
+    expect(formatDistanceStrict.bind(null, new Date(NaN), new Date(NaN))).toThrow(RangeError);
+  });
+});

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

@@ -1,4 +1,6 @@
-import distanceInWords, { type FormatDistanceOptions } from '../formatDistance/index';
+import { constructNow } from "../constructNow/index";
+import type { FormatDistanceOptions } from "../formatDistance/index";
+import { formatDistance } from "../formatDistance/index";
 
 /**
  * The {@link formatDistanceToNow} function options.
@@ -43,14 +45,15 @@ export interface FormatDistanceToNowOptions extends FormatDistanceOptions {}
  * | 40 secs ... 60 secs | less than a minute   |
  * | 60 secs ... 90 secs | 1 minute             |
  *
- * > ⚠️ 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.
+ * @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 given date
- * @param options - the object with options
- * @returns the distance in words
- * @throws {RangeError} `date` must not be Invalid Date
- * @throws {RangeError} `options.locale` must contain `formatDistance` property
+ * @param date - The given date
+ * @param options - The object with options
+ *
+ * @returns The distance in words
+ *
+ * @throws `date` must not be Invalid Date
+ * @throws `options.locale` must contain `formatDistance` property
  *
  * @example
  * // If today is 1 January 2015, what is the distance to 2 July 2014?
@@ -87,9 +90,9 @@ export interface FormatDistanceToNowOptions extends FormatDistanceOptions {}
  * )
  * //=> 'pli ol 1 jaro'
  */
-export default function formatDistanceToNow<DateType extends Date>(
-  dirtyDate: DateType | number,
+export function formatDistanceToNow<DateType extends Date>(
+  date: DateType | number | string,
   options?: FormatDistanceToNowOptions,
 ): string {
-  return distanceInWords(dirtyDate, Date.now(), options);
+  return formatDistance(date, constructNow(date), options);
 }