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

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

@@ -1,11 +1,12 @@
-import isValid from '../isValid/index';
-import toDate from '../toDate/index';
-import addLeadingZeros from '../_lib/addLeadingZeros/index';
+import { isValid } from "../isValid/index";
+import { toDate } from "../toDate/index";
+import { addLeadingZeros } from "../_lib/addLeadingZeros/index";
 
 /**
  * The {@link formatRFC3339} function options.
  */
 export interface FormatRFC3339Options {
+  /** The number of digits after the decimal point after seconds, defaults to 0 */
   fractionDigits?: 0 | 1 | 2 | 3;
 }
 
@@ -17,66 +18,69 @@ export interface FormatRFC3339Options {
  * @description
  * Return the formatted date string in RFC 3339 format. Options may be passed to control the parts and notations of the date.
  *
- * @param date - the original date
- * @param options - an object with options.
- * @returns the formatted date string
- * @throws {RangeError} `date` must not be Invalid Date
+ * @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 original date
+ * @param options - An object with options.
+ *
+ * @returns The formatted date string
+ *
+ * @throws `date` must not be Invalid Date
  *
  * @example
  * // Represent 18 September 2019 in RFC 3339 format:
- * const result = formatRFC3339(new Date(2019, 8, 18, 19, 0, 52))
+ * formatRFC3339(new Date(2019, 8, 18, 19, 0, 52))
  * //=> '2019-09-18T19:00:52Z'
  *
  * @example
- * // Represent 18 September 2019 in RFC 3339 format, 2 digits of second fraction:
- * const result = formatRFC3339(new Date(2019, 8, 18, 19, 0, 52, 234), { fractionDigits: 2 })
- * //=> '2019-09-18T19:00:52.23Z'
- *
- * @example
  * // Represent 18 September 2019 in RFC 3339 format, 3 digits of second fraction
- * const result = formatRFC3339(new Date(2019, 8, 18, 19, 0, 52, 234), { fractionDigits: 3 })
+ * formatRFC3339(new Date(2019, 8, 18, 19, 0, 52, 234), {
+ *   fractionDigits: 3
+ * })
  * //=> '2019-09-18T19:00:52.234Z'
  */
-export default function formatRFC3339<DateType extends Date>(
-  dirtyDate: DateType | number,
+export function formatRFC3339<DateType extends Date>(
+  date: DateType | number | string,
   options?: FormatRFC3339Options,
 ): string {
-  const originalDate = toDate(dirtyDate);
+  const _date = toDate(date);
 
-  if (!isValid(originalDate)) {
-    throw new RangeError('Invalid time value');
+  if (!isValid(_date)) {
+    throw new RangeError("Invalid time value");
   }
 
   const fractionDigits = options?.fractionDigits ?? 0;
 
-  const day = addLeadingZeros(originalDate.getDate(), 2);
-  const month = addLeadingZeros(originalDate.getMonth() + 1, 2);
-  const year = originalDate.getFullYear();
+  const day = addLeadingZeros(_date.getDate(), 2);
+  const month = addLeadingZeros(_date.getMonth() + 1, 2);
+  const year = _date.getFullYear();
 
-  const hour = addLeadingZeros(originalDate.getHours(), 2);
-  const minute = addLeadingZeros(originalDate.getMinutes(), 2);
-  const second = addLeadingZeros(originalDate.getSeconds(), 2);
+  const hour = addLeadingZeros(_date.getHours(), 2);
+  const minute = addLeadingZeros(_date.getMinutes(), 2);
+  const second = addLeadingZeros(_date.getSeconds(), 2);
 
-  let fractionalSecond = '';
+  let fractionalSecond = "";
   if (fractionDigits > 0) {
-    const milliseconds = originalDate.getMilliseconds();
-    const fractionalSeconds = Math.floor(milliseconds * Math.pow(10, fractionDigits - 3));
-    fractionalSecond = '.' + addLeadingZeros(fractionalSeconds, fractionDigits);
+    const milliseconds = _date.getMilliseconds();
+    const fractionalSeconds = Math.trunc(
+      milliseconds * Math.pow(10, fractionDigits - 3),
+    );
+    fractionalSecond = "." + addLeadingZeros(fractionalSeconds, fractionDigits);
   }
 
-  let offset = '';
-  const tzOffset = originalDate.getTimezoneOffset();
+  let offset = "";
+  const tzOffset = _date.getTimezoneOffset();
 
   if (tzOffset !== 0) {
     const absoluteOffset = Math.abs(tzOffset);
     const hourOffset = addLeadingZeros(Math.trunc(absoluteOffset / 60), 2);
     const minuteOffset = addLeadingZeros(absoluteOffset % 60, 2);
     // If less than 0, the sign is +, because it is ahead of time.
-    const sign = tzOffset < 0 ? '+' : '-';
+    const sign = tzOffset < 0 ? "+" : "-";
 
     offset = `${sign}${hourOffset}:${minuteOffset}`;
   } else {
-    offset = 'Z';
+    offset = "Z";
   }
 
   return `${year}-${month}-${day}T${hour}:${minute}:${second}${fractionalSecond}${offset}`;

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

@@ -0,0 +1,44 @@
+import { describe, expect, it } from "vitest";
+import sinon from "sinon";
+import { formatRFC3339 } from "./index";
+import { generateOffset } from "../_lib/test/index";
+
+describe("formatRFC3339", () => {
+  it("formats RFC-3339 date string", () => {
+    const date = new Date(2019, 2 /* Mar */, 3, 19, 0, 52, 123);
+    expect(formatRFC3339(date)).toBe(`2019-03-03T19:00:52${generateOffset(date)}`);
+
+    const getTimezoneOffsetStub = sinon.stub(
+      Date.prototype,
+      "getTimezoneOffset",
+    );
+
+    getTimezoneOffsetStub.returns(0);
+    expect(formatRFC3339(date)).toBe("2019-03-03T19:00:52Z");
+
+    getTimezoneOffsetStub.returns(480);
+    expect(formatRFC3339(date)).toBe("2019-03-03T19:00:52-08:00");
+
+    getTimezoneOffsetStub.restore();
+  });
+
+  it("accepts a timestamp", () => {
+    const date = new Date(2019, 9 /* Oct */, 4, 12, 30, 13, 456);
+    const time = date.getTime();
+    expect(formatRFC3339(time)).toBe(`2019-10-04T12:30:13${generateOffset(date)}`);
+  });
+
+  it("allows to specify digits of second fractions", () => {
+    const date = new Date(2019, 11 /* Dec */, 11, 1, 0, 0, 789);
+    expect(formatRFC3339(date, { fractionDigits: 3 })).toBe(`2019-12-11T01:00:00.789${generateOffset(date)}`);
+  });
+
+  it("works when ms < 100", () => {
+    const date = new Date(2019, 11 /* Dec */, 11, 1, 0, 0, 12);
+    expect(formatRFC3339(date, { fractionDigits: 2 })).toBe(`2019-12-11T01:00:00.01${generateOffset(date)}`);
+  });
+
+  it("throws RangeError if the time value is invalid", () => {
+    expect(formatRFC3339.bind(null, new Date(NaN))).toThrow(RangeError);
+  });
+});

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

@@ -1,10 +1,23 @@
-import isValid from '../isValid/index';
-import toDate from '../toDate/index';
-import addLeadingZeros from '../_lib/addLeadingZeros/index';
+import { isValid } from "../isValid/index";
+import { toDate } from "../toDate/index";
+import { addLeadingZeros } from "../_lib/addLeadingZeros/index";
 
-const days = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
+const days = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
 
-const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+const months = [
+  "Jan",
+  "Feb",
+  "Mar",
+  "Apr",
+  "May",
+  "Jun",
+  "Jul",
+  "Aug",
+  "Sep",
+  "Oct",
+  "Nov",
+  "Dec",
+];
 
 /**
  * @name formatRFC7231
@@ -15,30 +28,36 @@ const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', '
  * Return the formatted date string in RFC 7231 format.
  * The result will always be in UTC timezone.
  *
- * @param date - the original date
- * @returns the formatted date string
- * @throws {RangeError} `date` must not be Invalid Date
+ * @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 original date
+ *
+ * @returns The formatted date string
+ *
+ * @throws `date` must not be Invalid Date
  *
  * @example
  * // Represent 18 September 2019 in RFC 7231 format:
  * const result = formatRFC7231(new Date(2019, 8, 18, 19, 0, 52))
  * //=> 'Wed, 18 Sep 2019 19:00:52 GMT'
  */
-export default function formatRFC7231<DateType extends Date>(dirtyDate: DateType | number): string {
-  const originalDate = toDate(dirtyDate);
+export function formatRFC7231<DateType extends Date>(
+  date: DateType | number | string,
+): string {
+  const _date = toDate(date);
 
-  if (!isValid(originalDate)) {
-    throw new RangeError('Invalid time value');
+  if (!isValid(_date)) {
+    throw new RangeError("Invalid time value");
   }
 
-  const dayName = days[originalDate.getUTCDay()];
-  const dayOfMonth = addLeadingZeros(originalDate.getUTCDate(), 2);
-  const monthName = months[originalDate.getUTCMonth()];
-  const year = originalDate.getUTCFullYear();
+  const dayName = days[_date.getUTCDay()];
+  const dayOfMonth = addLeadingZeros(_date.getUTCDate(), 2);
+  const monthName = months[_date.getUTCMonth()];
+  const year = _date.getUTCFullYear();
 
-  const hour = addLeadingZeros(originalDate.getUTCHours(), 2);
-  const minute = addLeadingZeros(originalDate.getUTCMinutes(), 2);
-  const second = addLeadingZeros(originalDate.getUTCSeconds(), 2);
+  const hour = addLeadingZeros(_date.getUTCHours(), 2);
+  const minute = addLeadingZeros(_date.getUTCMinutes(), 2);
+  const second = addLeadingZeros(_date.getUTCSeconds(), 2);
 
   // Result variables.
   return `${dayName}, ${dayOfMonth} ${monthName} ${year} ${hour}:${minute}:${second} GMT`;

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

@@ -0,0 +1,18 @@
+import { describe, expect, it } from "vitest";
+import { formatRFC7231 } from "./index";
+
+describe("formatRFC7231", () => {
+  it("formats RFC-7231 date string", () => {
+    const date = new Date(Date.UTC(2019, 2, 3, 19, 0, 52));
+    expect(formatRFC7231(date)).toBe("Sun, 03 Mar 2019 19:00:52 GMT");
+  });
+
+  it("accepts a timestamp", () => {
+    const date = Date.UTC(2019, 9, 4, 12, 30, 13);
+    expect(formatRFC7231(date)).toBe("Fri, 04 Oct 2019 12:30:13 GMT");
+  });
+
+  it("throws RangeError if the time value is invalid", () => {
+    expect(formatRFC7231.bind(null, new Date(NaN))).toThrow(RangeError);
+  });
+});

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

@@ -1,15 +1,19 @@
-import differenceInCalendarDays from '../differenceInCalendarDays/index';
-import format from '../format/index';
-import type { FormatRelativeToken } from '../locale/types';
-import toDate from '../toDate/index';
-import type { LocaleOptions, WeekStartOptions } from '../types';
-import defaultLocale from '../_lib/defaultLocale/index';
-import { getDefaultOptions } from '../_lib/defaultOptions/index';
+import { differenceInCalendarDays } from "../differenceInCalendarDays/index";
+import { format } from "../format/index";
+import type { FormatRelativeToken } from "../locale/types";
+import { toDate } from "../toDate/index";
+import type { LocalizedOptions, WeekOptions } from "../types";
+import { defaultLocale } from "../_lib/defaultLocale/index";
+import { getDefaultOptions } from "../_lib/defaultOptions/index";
 
 /**
  * The {@link formatRelative} function options.
  */
-export interface FormatRelativeOptions extends LocaleOptions, WeekStartOptions {}
+export interface FormatRelativeOptions
+  extends LocalizedOptions<
+      "options" | "localize" | "formatLong" | "formatRelative"
+    >,
+    WeekOptions {}
 
 /**
  * @name formatRelative
@@ -28,28 +32,32 @@ export interface FormatRelativeOptions extends LocaleOptions, WeekStartOptions {
  * | Next 6 days               | Sunday at 04:30 AM        |
  * | Other                     | 12/31/2017                |
  *
- * @param date - the date to format
- * @param baseDate - the date to compare with
- * @param options - an object with options.
- * @returns the date in words
- * @throws {RangeError} `date` must not be Invalid Date
- * @throws {RangeError} `baseDate` must not be Invalid Date
- * @throws {RangeError} `options.locale` must contain `localize` property
- * @throws {RangeError} `options.locale` must contain `formatLong` property
- * @throws {RangeError} `options.locale` must contain `formatRelative` 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 to format
+ * @param baseDate - The date to compare with
+ * @param options - An object with options
+ *
+ * @returns The date in words
+ *
+ * @throws `date` must not be Invalid Date
+ * @throws `baseDate` must not be Invalid Date
+ * @throws `options.locale` must contain `localize` property
+ * @throws `options.locale` must contain `formatLong` property
+ * @throws `options.locale` must contain `formatRelative` property
  *
  * @example
  * // Represent the date of 6 days ago in words relative to the given base date. In this example, today is Wednesday
- * const result = formatRelative(addDays(new Date(), -6), new Date())
+ * const result = formatRelative(subDays(new Date(), 6), new Date())
  * //=> "last Thursday at 12:45 AM"
  */
-export default function formatRelative<DateType extends Date>(
-  dirtyDate: DateType | number,
-  dirtyBaseDate: DateType | number,
+export function formatRelative<DateType extends Date>(
+  date: DateType | number | string,
+  baseDate: DateType | number | string,
   options?: FormatRelativeOptions,
 ): string {
-  const date = toDate(dirtyDate);
-  const baseDate = toDate(dirtyBaseDate);
+  const _date = toDate(date);
+  const _baseDate = toDate(baseDate);
 
   const defaultOptions = getDefaultOptions();
   const locale = options?.locale ?? defaultOptions.locale ?? defaultLocale;
@@ -60,44 +68,32 @@ export default function formatRelative<DateType extends Date>(
     defaultOptions.locale?.options?.weekStartsOn ??
     0;
 
-  if (!locale.localize) {
-    throw new RangeError('locale must contain localize property');
-  }
-
-  if (!locale.formatLong) {
-    throw new RangeError('locale must contain formatLong property');
-  }
-
-  if (!locale.formatRelative) {
-    throw new RangeError('locale must contain formatRelative property');
-  }
-
-  const diff = differenceInCalendarDays(date, baseDate);
+  const diff = differenceInCalendarDays(_date, _baseDate);
 
   if (isNaN(diff)) {
-    throw new RangeError('Invalid time value');
+    throw new RangeError("Invalid time value");
   }
 
   let token: FormatRelativeToken;
   if (diff < -6) {
-    token = 'other';
+    token = "other";
   } else if (diff < -1) {
-    token = 'lastWeek';
+    token = "lastWeek";
   } else if (diff < 0) {
-    token = 'yesterday';
+    token = "yesterday";
   } else if (diff < 1) {
-    token = 'today';
+    token = "today";
   } else if (diff < 2) {
-    token = 'tomorrow';
+    token = "tomorrow";
   } else if (diff < 7) {
-    token = 'nextWeek';
+    token = "nextWeek";
   } else {
-    token = 'other';
+    token = "other";
   }
 
-  const formatStr = locale.formatRelative(token, date, baseDate, {
+  const formatStr = locale.formatRelative(token, _date, _baseDate, {
     locale,
     weekStartsOn,
   });
-  return format(date, formatStr, { locale, weekStartsOn });
+  return format(_date, formatStr, { locale, weekStartsOn });
 }

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

@@ -0,0 +1,118 @@
+import { describe, expect, it } from "vitest";
+import { formatRelative } from "./index";
+
+describe("formatRelative", () => {
+  const baseDate = new Date(1986, 3 /* Apr */, 4, 10, 32, 0, 900);
+
+  it("accepts a timestamp", () => {
+    const date = new Date(2014, 3 /* Apr */, 4);
+    expect(formatRelative(date.getTime(), baseDate.getTime())).toBe("04/04/2014");
+  });
+
+  it("before the last week", () => {
+    const result = formatRelative(
+      new Date(1986, 2 /* Mar */, 28, 16, 50),
+      baseDate,
+    );
+    expect(result).toBe("03/28/1986");
+  });
+
+  it("last week", () => {
+    const result = formatRelative(new Date(1986, 3 /* Apr */, 1), baseDate);
+    expect(result).toBe("last Tuesday at 12:00 AM");
+  });
+
+  it("yesterday", () => {
+    const result = formatRelative(
+      new Date(1986, 3 /* Apr */, 3, 22, 22),
+      baseDate,
+    );
+    expect(result).toBe("yesterday at 10:22 PM");
+  });
+
+  it("today", () => {
+    const result = formatRelative(
+      new Date(1986, 3 /* Apr */, 4, 16, 50),
+      baseDate,
+    );
+    expect(result).toBe("today at 4:50 PM");
+  });
+
+  it("tomorrow", () => {
+    const result = formatRelative(
+      new Date(1986, 3 /* Apr */, 5, 7, 30),
+      baseDate,
+    );
+    expect(result).toBe("tomorrow at 7:30 AM");
+  });
+
+  it("next week", () => {
+    const result = formatRelative(
+      new Date(1986, 3 /* Apr */, 6, 12, 0),
+      baseDate,
+    );
+    expect(result).toBe("Sunday at 12:00 PM");
+  });
+
+  it("after the next week", () => {
+    const result = formatRelative(
+      new Date(1986, 3 /* Apr */, 11, 16, 50),
+      baseDate,
+    );
+    expect(result).toBe("04/11/1986");
+  });
+
+  describe("edge cases", () => {
+    it("throws RangeError if the date isn't valid", () => {
+      expect(formatRelative.bind(null, new Date(NaN), baseDate)).toThrow(RangeError);
+    });
+
+    it("throws RangeError if the base date isn't valid", () => {
+      expect(formatRelative.bind(
+        null,
+        new Date(2017, 0 /* Jan */, 1),
+        new Date(NaN),
+      )).toThrow(RangeError);
+    });
+
+    it("throws RangeError if both dates aren't valid", () => {
+      expect(formatRelative.bind(null, new Date(NaN), new Date(NaN))).toThrow(RangeError);
+    });
+
+    it("handles dates before 100 AD", () => {
+      const date = new Date(0);
+      date.setFullYear(7, 11 /* Dec */, 31);
+      date.setHours(0, 0, 0, 0);
+      expect(formatRelative(date, baseDate)).toBe("12/31/0007");
+    });
+  });
+
+  describe("custom locale", () => {
+    it("allows to pass a custom locale", () => {
+      const customLocale = {
+        localize: {
+          month: () => {
+            return "works";
+          },
+        },
+        formatLong: {
+          date: () => {
+            return "'It' MMMM";
+          },
+        },
+        formatRelative: () => {
+          return "P 'perfectly!'";
+        },
+      };
+      const result = formatRelative(
+        new Date(1986, 2 /* Mar */, 28, 16, 50),
+        baseDate,
+        {
+          // @ts-expect-error - It's ok to have incomplete locale
+          locale: customLocale,
+        },
+      );
+      expect(result).toBe("It works perfectly!");
+    });
+  });
+});

package/src/date-fns/fp/_lib/convertToFP/index.ts

@@ -1,9 +1,25 @@
-export default function convertToFP(fn: Function, arity: number, a: any[] = []) {
-  if (a.length >= arity) {
-    return fn.apply(null, a.slice(0, arity).reverse());
-  }
+import type { FPArity, FPFn, FPFnInput } from "../../types";
 
-  return function (...args: any[]) {
-    return convertToFP(fn, arity, a.concat(args));
-  };
+/**
+ * Converts a function to a curried function that accepts arguments in reverse
+ * order.
+ *
+ * @param fn - The function to convert to FP
+ * @param arity - The arity of the function
+ * @param curriedArgs - The curried arguments
+ *
+ * @returns FP version of the function
+ *
+ * @private
+ */
+export function convertToFP<Fn extends FPFnInput, Arity extends FPArity>(
+  fn: Fn,
+  arity: Arity,
+  curriedArgs: unknown[] = [],
+): FPFn<Fn, Arity> {
+  return (
+    curriedArgs.length >= arity
+      ? fn(...curriedArgs.slice(0, arity).reverse())
+      : (...args: unknown[]) => convertToFP(fn, arity, curriedArgs.concat(args))
+  ) as FPFn<Fn, Arity>;
 }

package/src/date-fns/fp/_lib/convertToFP/test.mts

@@ -0,0 +1,120 @@
+import { pipe } from "fp-ts/function";
+import { flow as jsFnsFlow } from "js-fns";
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment -- Lodash types trip in different environemnts, so we can't put ts-expect-error
+// @ts-ignore - Lodash types are tripping ("Module '"lodash"' has no exported member 'flow'.ts(2305)")
+import { flow as lodashFlow } from "lodash";
+import { describe, expect, it } from "vitest";
+import { addDays, addHours, isEqual } from "../../index";
+import { convertToFP } from "./index";
+
+describe("convertToFP", () => {
+  function fn(a: unknown, b: unknown, c: unknown) {
+    return "a b c"
+      .replace("a", String(a))
+      .replace("b", String(b))
+      .replace("c", String(c));
+  }
+
+  describe("arity of converted function === arity of initial function", () => {
+    it("allows arguments to be curried (and reverses their order)", () => {
+      const fpFn = convertToFP(fn, 3);
+      expect(fpFn(3)(2)(1)).toBe("1 2 3");
+    });
+
+    it("allows to group arguments", () => {
+      const fpFn = convertToFP(fn, 3);
+      expect(fpFn(3, 2)(1)).toBe("1 2 3");
+      expect(fpFn(3)(2, 1)).toBe("1 2 3");
+    });
+
+    it("allows the function to be called with all arguments in the reversed order", () => {
+      const fpFn = convertToFP(fn, 3);
+      expect(fpFn(3, 2, 1)).toBe("1 2 3");
+    });
+
+    it("ignores calls without curried arguments", () => {
+      const fpFn = convertToFP(fn, 3);
+      expect(fpFn()()(3, 2)()()(1)).toBe("1 2 3");
+    });
+
+    it("ignores extra curried arguments in the last group", () => {
+      const fpFn = convertToFP(fn, 3);
+      // @ts-expect-error - It's ok, we're testing the function
+      expect(fpFn(3, 2, 1, 0, -1, -2)).toBe("1 2 3");
+      // @ts-expect-error - It's ok, we're testing the function
+      expect(fpFn(3)(2)(1, 0, -1, -2)).toBe("1 2 3");
+    });
+  });
+
+  describe("arity of converted function < arity of initial function", () => {
+    it("calls the initial function with a short list of arguments", () => {
+      const fpFn = convertToFP(fn, 2);
+      expect(fpFn(2)(1)).toBe("1 2 undefined");
+      expect(fpFn(2, 1)).toBe("1 2 undefined");
+    });
+
+    it("ignores extra curried arguments in the last group", () => {
+      const fpFn = convertToFP(fn, 2);
+      // @ts-expect-error - It's ok, we're testing the function
+      expect(fpFn(3)(2, 1)).toBe("2 3 undefined");
+      // @ts-expect-error - It's ok, we're testing the function
+      expect(fpFn(3, 2, 1)).toBe("2 3 undefined");
+    });
+  });
+
+  describe("arity of converted function > arity of initial function", () => {
+    it("works, but ignores the extra arguments", () => {
+      const fpFn = convertToFP(fn, 4);
+      // @ts-expect-error - It's ok, we're testing the function
+      expect(fpFn(4)(3)(2)(1)).toBe("1 2 3");
+      // @ts-expect-error - It's ok, we're testing the function
+      expect(fpFn(4, 3, 2, 1)).toBe("1 2 3");
+    });
+  });
+
+  describe("arity of converted function === 0", () => {
+    it("returns the constant instead of function", () => {
+      // @ts-expect-error - It's ok, we're testing the function
+      const result = convertToFP(fn, 0);
+      expect(result).toBe("undefined undefined undefined");
+    });
+  });
+
+  describe("types", () => {
+    it("resolves proper types", () => {
+      const fn1 = addDays();
+      const fn2 = fn1(1);
+      const result = fn2(new Date(1987, 1));
+      expect(result.getFullYear()).toBe(1987);
+    });
+  });
+
+  describe("Lodash", () => {
+    it("works with flow", () => {
+      const fn = lodashFlow(addDays(1), addHours(1));
+      const result = fn(new Date(1987, 1, 11));
+      expect(result.getFullYear()).toBe(1987);
+      expect(result).toEqual(new Date(1987, 1, 12, 1));
+    });
+  });
+
+  describe("fp-ts", () => {
+    it("works with pipe", () => {
+      const result = pipe(
+        new Date(1987, 1, 11),
+        isEqual(new Date(1987, 1, 11)),
+      );
+      const _assign: boolean = result;
+      expect(result).toBe(true);
+    });
+  });
+
+  describe("js-fns", () => {
+    it("works with flow", () => {
+      const fn = jsFnsFlow(addDays(1), addHours(1));
+      const result = fn(new Date(1987, 1, 11));
+      expect(result.getFullYear()).toBe(1987);
+      expect(result).toEqual(new Date(1987, 1, 12, 1));
+    });
+  });
+});