@alanszp/business-days-date-fns 4.0.10

package/src/utils/addBusinessDays.test.ts

@@ -0,0 +1,131 @@
+import assert from "assert";
+import { addBusinessDays } from "./addBusinessDays";
+
+describe("addBusinessDays", () => {
+  it("should return 2 next days", () => {
+    const result = addBusinessDays(
+      [new Date("2022-01-20")],
+      new Date("2022-01-19"),
+      1
+    );
+    expect(result).toEqual(new Date("2022-01-21"));
+  });
+
+  it("should return next monday", () => {
+    const result = addBusinessDays(
+      [new Date("2022-01-20"), new Date("2022-01-21")],
+      new Date("2022-01-19"),
+      1
+    );
+    expect(result).toEqual(new Date("2022-01-24"));
+  });
+
+  it("should return next monday when you start on weekend", () => {
+    const result = addBusinessDays([], new Date("2022-01-21"), 1);
+    expect(result).toEqual(new Date("2022-01-24"));
+  });
+
+  // original tests
+
+  it("adds the given number of business days", () => {
+    const result = addBusinessDays([], new Date(2014, 8 /* Sep */, 1), 10);
+    expect(result).toEqual(new Date(2014, 8 /* Sep */, 15));
+  });
+
+  it("handles negative amount", () => {
+    const result = addBusinessDays([], new Date(2014, 8 /* Sep */, 15), -10);
+    expect(result).toEqual(new Date(2014, 8 /* Sep */, 1));
+  });
+
+  it("returns the Monday when 1 day is added on the Friday", () => {
+    expect(
+      addBusinessDays([], new Date(2020, 0 /* Jan */, 10), 1) // Friday
+    ).toEqual(
+      new Date(2020, 0 /* Jan */, 13) // Monday
+    );
+  });
+
+  it("returns the Monday when 1 day is added on the Saturday", () => {
+    expect(
+      addBusinessDays([], new Date(2020, 0 /* Jan */, 11), 1) // Saturday
+    ).toEqual(
+      new Date(2020, 0 /* Jan */, 13) // Monday
+    );
+  });
+
+  it("returns the Monday when 1 day is added on the Sunday", () => {
+    expect(
+      addBusinessDays([], new Date(2020, 0 /* Jan */, 12), 1) // Sunday
+    ).toEqual(
+      new Date(2020, 0 /* Jan */, 13) // Monday
+    );
+  });
+
+  it("can handle a large number of business days", () => {
+    // @ts-ignore
+    if (typeof global.timeout === "function") {
+      // @ts-ignore
+      global.timeout(500 /* 500 ms test timeout */);
+    }
+
+    const result = addBusinessDays([], new Date(2014, 0 /* Jan */, 1), 3387885);
+    expect(result).toEqual(new Date(15000, 0 /* Jan */, 1));
+  });
+
+  it("accepts a timestamp", () => {
+    const result = addBusinessDays(
+      [],
+      new Date(2014, 8 /* Sep */, 1).getTime(),
+      10
+    );
+    expect(result).toEqual(new Date(2014, 8 /* Sep */, 15));
+  });
+
+  it("converts a fractional number to an integer", () => {
+    const result = addBusinessDays([], new Date(2014, 8 /* Sep */, 1), 10.5);
+    expect(result).toEqual(new Date(2014, 8 /* Sep */, 15));
+  });
+
+  it("implicitly converts number arguments", () => {
+    // @ts-ignore
+    const result = addBusinessDays([], new Date(2014, 8 /* Sep */, 1), "10");
+    expect(result).toEqual(new Date(2014, 8 /* Sep */, 15));
+  });
+
+  it("does not mutate the original date", () => {
+    const date = new Date(2014, 8 /* Sep */, 1);
+    addBusinessDays([], date, 11);
+    expect(date).toEqual(new Date(2014, 8 /* Sep */, 1));
+  });
+
+  it("returns `Invalid Date` if the given date is invalid", () => {
+    const result = addBusinessDays([], new Date(NaN), 10);
+    assert(result instanceof Date && Number.isNaN(result.getTime()));
+  });
+
+  it("throws TypeError exception if passed less than 2 arguments", () => {
+    try {
+      assert.throws(addBusinessDays.bind(null), TypeError);
+
+      assert.throws(addBusinessDays.bind(null, 1), TypeError);
+    } catch {}
+  });
+
+  it("starting from a weekend day should land on a weekday when reducing a divisible by 5", () => {
+    const substractResult = addBusinessDays([], new Date(2019, 7, 18), -5);
+    expect(substractResult).toEqual(new Date(2019, 7, 12));
+
+    const subtractResultWeekend = addBusinessDays(
+      [],
+      new Date(2019, 7, 17),
+      -5
+    );
+    expect(subtractResultWeekend).toEqual(new Date(2019, 7, 12));
+
+    const addResult = addBusinessDays([], new Date(2019, 7, 18), 5);
+    expect(addResult).toEqual(new Date(2019, 7, 23));
+
+    const addResultWeekend = addBusinessDays([], new Date(2019, 7, 17), 5);
+    expect(addResultWeekend).toEqual(new Date(2019, 7, 23));
+  });
+});

package/src/utils/addBusinessDays.ts

@@ -0,0 +1,46 @@
+import toDate from "date-fns/toDate";
+import isSunday from "date-fns/isSunday";
+import isSaturday from "date-fns/isSaturday";
+import { toInteger } from "lodash";
+import { isNonBusinessDay } from "./isNonBusinessDay";
+import { requiredArgs } from "./requiredArgs";
+
+export function addBusinessDays(
+  nonBusinessDays: Date[],
+  dirtyDate: Date | number,
+  dirtyAmount: number
+): Date {
+  requiredArgs(2, [dirtyDate, dirtyAmount]);
+
+  const date = toDate(dirtyDate);
+  const startedOnWeekend = isNonBusinessDay(nonBusinessDays, date);
+  const amount = toInteger(dirtyAmount);
+
+  if (Number.isNaN(amount)) return new Date(Number.NaN);
+
+  const hours = date.getHours();
+  const sign = amount < 0 ? -1 : 1;
+  const fullWeeks = toInteger(amount / 5);
+
+  date.setDate(date.getDate() + fullWeeks * 7);
+
+  let restDays = Math.abs(amount % 5);
+
+  while (restDays > 0) {
+    date.setDate(date.getDate() + sign);
+    if (!isNonBusinessDay(nonBusinessDays, date)) restDays -= 1;
+  }
+
+  if (
+    startedOnWeekend &&
+    isNonBusinessDay(nonBusinessDays, date) &&
+    amount !== 0
+  ) {
+    if (isSaturday(date)) date.setDate(date.getDate() + (sign < 0 ? 2 : -1));
+    if (isSunday(date)) date.setDate(date.getDate() + (sign < 0 ? 1 : -2));
+  }
+
+  date.setHours(hours);
+
+  return date;
+}

package/src/utils/differenceInBusinessDay.test.ts

@@ -0,0 +1,176 @@
+import assert from "assert";
+import { differenceInBusinessDays } from "./differenceInBusinessDays";
+
+describe("differenceInBusinessDays", () => {
+  it("should return 2 difference day taking weekend days", () => {
+    const result = differenceInBusinessDays(
+      [new Date("2022-01-20"), new Date("2022-01-21")],
+      new Date("2022-01-25"),
+      new Date("2022-01-19")
+    );
+    expect(result).toBe(2);
+  });
+
+  it("should return 2 difference", () => {
+    const result = differenceInBusinessDays(
+      [new Date("2022-01-19")],
+      new Date("2022-01-21"),
+      new Date("2022-01-18")
+    );
+    expect(result).toBe(2);
+  });
+
+  // date-fns original tests
+
+  it("returns the number of business days between the given dates, excluding weekends", () => {
+    const result = differenceInBusinessDays(
+      [],
+      new Date(2014, 6 /* Jul */, 18),
+      new Date(2014, 0 /* Jan */, 10)
+    );
+    expect(result).toEqual(135);
+  });
+
+  it("can handle long ranges", () => {
+    // @ts-ignore
+    if (typeof global.timeout === "function") {
+      // @ts-ignore
+      global.timeout(500 /* 500 ms test timeout */);
+    }
+
+    const result = differenceInBusinessDays(
+      [],
+      new Date(15000, 0 /* Jan */, 1),
+      new Date(2014, 0 /* Jan */, 1)
+    );
+    expect(result).toEqual(3387885);
+  });
+
+  it("the same except given first date falls on a weekend", () => {
+    const result = differenceInBusinessDays(
+      [],
+      new Date(2019, 6 /* Jul */, 20),
+      new Date(2019, 6 /* Jul */, 18)
+    );
+    expect(result).toEqual(2);
+  });
+
+  it("the same except given second date falls on a weekend", () => {
+    const result = differenceInBusinessDays(
+      [],
+      new Date(2019, 6 /* Jul */, 23),
+      new Date(2019, 6 /* Jul */, 20)
+    );
+    expect(result).toEqual(1);
+  });
+
+  it("the same except both given dates fall on a weekend", () => {
+    const result = differenceInBusinessDays(
+      [],
+      new Date(2019, 6 /* Jul */, 28),
+      new Date(2019, 6 /* Jul */, 20)
+    );
+    expect(result).toEqual(5);
+  });
+
+  it("returns a negative number if the time value of the first date is smaller", () => {
+    const result = differenceInBusinessDays(
+      [],
+      new Date(2014, 0 /* Jan */, 10),
+      new Date(2014, 6 /* Jul */, 20)
+    );
+    expect(result).toEqual(-135);
+  });
+
+  it("accepts timestamps", () => {
+    const result = differenceInBusinessDays(
+      [],
+      new Date(2014, 6, 18).getTime(),
+      new Date(2014, 0, 10).getTime()
+    );
+    expect(result).toEqual(135);
+  });
+
+  it("the difference is less than a day, but the given dates are in different calendar days", () => {
+    const result = differenceInBusinessDays(
+      [],
+      new Date(2014, 8 /* Sep */, 5, 0, 0),
+      new Date(2014, 8 /* Sep */, 4, 23, 59)
+    );
+    expect(result).toEqual(1);
+  });
+
+  it("the same for the swapped dates", () => {
+    const result = differenceInBusinessDays(
+      [],
+      new Date(2014, 8 /* Sep */, 4, 23, 59),
+      new Date(2014, 8 /* Sep */, 5, 0, 0)
+    );
+    expect(result).toEqual(-1);
+  });
+
+  it("the time values of the given dates are the same", () => {
+    const result = differenceInBusinessDays(
+      [],
+      new Date(2014, 8 /* Sep */, 5, 0, 0),
+      new Date(2014, 8 /* Sep */, 4, 0, 0)
+    );
+    expect(result).toEqual(1);
+  });
+
+  it("the given dates are the same", () => {
+    const result = differenceInBusinessDays(
+      [],
+      new Date(2014, 8 /* Sep */, 5, 0, 0),
+      new Date(2014, 8 /* Sep */, 5, 0, 0)
+    );
+    expect(result).toEqual(0);
+  });
+
+  it("does not return -0 when the given dates are the same", () => {
+    // eslint-disable-next-line unicorn/consistent-function-scoping
+    function isNegativeZero(x: number) {
+      return x === 0 && 1 / x < 0;
+    }
+
+    const result = differenceInBusinessDays(
+      [],
+      new Date(2014, 8 /* Sep */, 5, 0, 0),
+      new Date(2014, 8 /* Sep */, 5, 0, 0)
+    );
+
+    const resultIsNegative = isNegativeZero(result);
+    expect(resultIsNegative).toBeFalsy();
+  });
+
+  it("returns NaN if the first date is `Invalid Date`", () => {
+    const result = differenceInBusinessDays(
+      [],
+      new Date(NaN),
+      new Date(2017, 0 /* Jan */, 1)
+    );
+    expect(Number.isNaN(result)).toBeTruthy();
+  });
+
+  it("returns NaN if the second date is `Invalid Date`", () => {
+    const result = differenceInBusinessDays(
+      [],
+      new Date(2017, 0 /* Jan */, 1),
+      new Date(NaN)
+    );
+    expect(Number.isNaN(result)).toBeTruthy();
+  });
+
+  it("returns NaN if the both dates are `Invalid Date`", () => {
+    const result = differenceInBusinessDays([], new Date(NaN), new Date(NaN));
+    expect(Number.isNaN(result)).toBeTruthy();
+  });
+
+  it("throws TypeError exception if passed less than 2 arguments", () => {
+    try {
+      assert.throws(differenceInBusinessDays.bind(null), TypeError);
+
+      assert.throws(differenceInBusinessDays.bind(null, 1), TypeError);
+    } catch {}
+  });
+});

package/src/utils/differenceInBusinessDays.ts

@@ -0,0 +1,37 @@
+import differenceInCalendarDays from "date-fns/differenceInCalendarDays";
+import addDays from "date-fns/addDays";
+import isSameDay from "date-fns/isSameDay";
+import isValid from "date-fns/isValid";
+import toInteger from "lodash/toInteger";
+import toDate from "date-fns/toDate";
+import { requiredArgs } from "./requiredArgs";
+import { isNonBusinessDay } from "./isNonBusinessDay";
+
+export function differenceInBusinessDays(
+  nonBusinessDays: Date[],
+  dirtyDateLeft: Date | number,
+  dirtyDateRight: Date | number
+): number {
+  // eslint-disable-next-line prefer-rest-params
+  requiredArgs(2, [dirtyDateLeft, dirtyDateRight]);
+
+  const dateLeft = toDate(dirtyDateLeft);
+  let dateRight = toDate(dirtyDateRight);
+
+  if (!isValid(dateLeft) || !isValid(dateRight)) return Number.NaN;
+
+  const calendarDifference = differenceInCalendarDays(dateLeft, dateRight);
+  const sign = calendarDifference < 0 ? -1 : 1;
+
+  const weeks = toInteger(calendarDifference / 7);
+
+  let result = weeks * 5;
+  dateRight = addDays(dateRight, weeks * 7);
+
+  while (!isSameDay(dateLeft, dateRight)) {
+    result += isNonBusinessDay(nonBusinessDays, dateRight) ? 0 : sign;
+    dateRight = addDays(dateRight, sign);
+  }
+
+  return result === 0 ? 0 : result;
+}

package/src/utils/isBusinessDay.test.ts

@@ -0,0 +1,47 @@
+import assert from "assert";
+import { parse } from "date-fns";
+import { isBusinessDay } from "./isBusinessDay";
+
+describe("isNonBusinessDay", () => {
+  it("should return is non business day", () => {
+    const result = isBusinessDay(
+      [new Date("2022-01-01"), new Date("2022-01-02")],
+      new Date("2022-01-01")
+    );
+
+    expect(result).toBeFalsy();
+  });
+
+  it("should return is a business day", () => {
+    const result = isBusinessDay(
+      [new Date("2022-01-01"), new Date("2022-01-02")],
+      new Date("2022-01-03")
+    );
+
+    expect(result).toBeTruthy();
+  });
+
+  it("should work properly using hh:mm:ss", () => {
+    const mondayLate = isBusinessDay(
+      [],
+      parse("2022-01-24T23:59:59", "yyyy-MM-dd HH:mm:ss", new Date())
+    );
+    const fridayLate = isBusinessDay(
+      [parse("2022-01-28T23:59:59", "yyyy-MM-dd HH:mm:ss", new Date())],
+      parse("2022-01-28T23:59:59", "yyyy-MM-dd HH:mm:ss", new Date())
+    );
+
+    expect(mondayLate).toBeTruthy();
+    expect(fridayLate).toBeTruthy();
+  });
+
+  it("throws TypeError exception if passed less than 2 arguments", () => {
+    try {
+      // @ts-ignore
+      isBusinessDay([new Date("2022-01-01"), new Date("2022-01-02")]);
+
+      assert.throws(isBusinessDay.bind(null), TypeError);
+      assert.throws(isBusinessDay.bind(null, 1), TypeError);
+    } catch {}
+  });
+});

package/src/utils/isBusinessDay.ts

@@ -0,0 +1,18 @@
+import { isWeekend, toDate } from "date-fns";
+import isSameDay from "date-fns/isSameDay";
+import { requiredArgs } from "./requiredArgs";
+
+export function isBusinessDay(
+  nonBusinessDays: Date[],
+  dirtyDate: Date | number
+): boolean {
+  requiredArgs(1, [dirtyDate]);
+
+  const date = toDate(dirtyDate);
+
+  return (
+    !nonBusinessDays.some((nonBusinessDay) =>
+      isSameDay(nonBusinessDay, date)
+    ) && !isWeekend(date)
+  );
+}

package/src/utils/isNonBusinessDay.test.ts

@@ -0,0 +1,69 @@
+import assert from "assert";
+import { parse } from "date-fns";
+import { isNonBusinessDay } from "./isNonBusinessDay";
+
+describe("isNonBusinessDay", () => {
+  it("should return true because is part of NBD", () => {
+    const result = isNonBusinessDay(
+      [new Date("2022-01-01"), new Date("2022-01-02")],
+      new Date("2022-01-01")
+    );
+
+    expect(result).toBe(true);
+  });
+
+  it("should return true because weekend", () => {
+    const saturday = isNonBusinessDay([], new Date("2022-01-01"));
+    const sunday = isNonBusinessDay([], new Date("2022-01-02"));
+
+    expect(saturday).toBeTruthy();
+    expect(sunday).toBeTruthy();
+  });
+
+  it("should return false because are part of the week", () => {
+    const monday = isNonBusinessDay([], new Date("2022-01-03"));
+    const tuesday = isNonBusinessDay([], new Date("2022-01-04"));
+    const wednesday = isNonBusinessDay([], new Date("2022-01-05"));
+    const thursday = isNonBusinessDay([], new Date("2022-01-06"));
+    const friday = isNonBusinessDay([], new Date("2022-01-07"));
+
+    expect(monday).toBeFalsy();
+    expect(tuesday).toBeFalsy();
+    expect(wednesday).toBeFalsy();
+    expect(thursday).toBeFalsy();
+    expect(friday).toBeFalsy();
+  });
+
+  it("should work properly using hh:mm:ss", () => {
+    const sundayLate = isNonBusinessDay(
+      [],
+      parse("2022-01-23T23:59:59", "yyyy-MM-dd HH:mm:ss", new Date())
+    );
+    const dayOffLate = isNonBusinessDay(
+      [parse("2022-01-24T23:59:59", "yyyy-MM-dd HH:mm:ss", new Date())],
+      parse("2022-01-24T23:59:59", "yyyy-MM-dd HH:mm:ss", new Date())
+    );
+
+    expect(sundayLate).toBeFalsy();
+    expect(dayOffLate).toBeFalsy();
+  });
+
+  it("should return false because is not part of is part of NBD", () => {
+    const result = isNonBusinessDay(
+      [new Date("2022-01-01"), new Date("2022-01-02")],
+      new Date("2022-01-03")
+    );
+
+    expect(result).toBe(false);
+  });
+
+  it("throws TypeError exception if passed less than 2 arguments", () => {
+    try {
+      // @ts-ignore
+      isNonBusinessDay([new Date("2022-01-01"), new Date("2022-01-02")]);
+
+      assert.throws(isNonBusinessDay.bind(null), TypeError);
+      assert.throws(isNonBusinessDay.bind(null, 1), TypeError);
+    } catch {}
+  });
+});

package/src/utils/isNonBusinessDay.ts

@@ -0,0 +1,17 @@
+import { isWeekend, toDate } from "date-fns";
+import isSameDay from "date-fns/isSameDay";
+import { requiredArgs } from "./requiredArgs";
+
+export function isNonBusinessDay(
+  nonBusinessDays: Date[],
+  dirtyDate: Date
+): boolean {
+  requiredArgs(1, [dirtyDate]);
+
+  const date = toDate(dirtyDate);
+
+  return (
+    nonBusinessDays.some((nonBusinessDay) => isSameDay(nonBusinessDay, date)) ||
+    isWeekend(date)
+  );
+}

package/src/utils/requiredArgs.ts

@@ -0,0 +1,5 @@
+export function requiredArgs(required: number, args: unknown[]): void {
+  if (args.length < required) {
+    throw new TypeError(`${required} argument${required > 1 ? "s" : ""} required, but only ${args.length} present`);
+  }
+}

package/src/utils/subBusinessDays.test.ts

@@ -0,0 +1,99 @@
+import assert from "assert";
+import { subBusinessDays } from "./subBusinessDays";
+
+describe("subBusinessDay", () => {
+  it("should return 2 next days", () => {
+    const result = subBusinessDays(
+      [new Date("2022-01-20")],
+      new Date("2022-01-21"),
+      1
+    );
+    expect(result).toEqual(new Date("2022-01-19"));
+  });
+
+  it("should return next monday", () => {
+    const result = subBusinessDays(
+      [new Date("2022-01-20"), new Date("2022-01-21")],
+      new Date("2022-01-24"),
+      1
+    );
+    expect(result).toEqual(new Date("2022-01-19"));
+  });
+
+  it("should return next monday when you start on weekend", () => {
+    const result = subBusinessDays([], new Date("2022-01-24"), 1);
+    expect(result).toEqual(new Date("2022-01-21"));
+  });
+
+  it("substract the given number of business days", () => {
+    const result = subBusinessDays([], new Date(2014, 8 /* Sep */, 1), 10);
+    expect(result).toEqual(new Date(2014, 7 /* Aug */, 18));
+  });
+
+  it("handles negative amount", () => {
+    const result = subBusinessDays([], new Date(2014, 7 /* Sep */, 18), -10);
+    expect(result).toEqual(new Date(2014, 8 /* Sep */, 1));
+  });
+
+  it("can handle a large number of business days", () => {
+    // @ts-ignore
+    if (typeof global.timeout === "function") {
+      // @ts-ignore
+      global.timeout(500 /* 500 ms test timeout */);
+    }
+
+    const result = subBusinessDays(
+      [],
+      new Date(15000, 0 /* Jan */, 1),
+      3387885
+    );
+    expect(result).toEqual(new Date(2014, 0 /* Jan */, 1));
+  });
+
+  it("accepts a timestamp", () => {
+    const result = subBusinessDays(
+      [],
+      new Date(2014, 8 /* Sep */, 1).getTime(),
+      10
+    );
+    expect(result).toEqual(new Date(2014, 7 /* Aug */, 18));
+  });
+
+  it("converts a fractional number to an integer", () => {
+    const result = subBusinessDays([], new Date(2014, 8 /* Sep */, 1), 10.5);
+    expect(result).toEqual(new Date(2014, 7 /* Aug */, 18));
+  });
+
+  it("implicitly converts number arguments", () => {
+    const result = subBusinessDays(
+      [],
+      new Date(2014, 8 /* Sep */, 1),
+      // @ts-ignore
+      "10"
+    );
+    expect(result).toEqual(new Date(2014, 7 /* Aug */, 18));
+  });
+
+  it("does not mutate the original date", () => {
+    const date = new Date(2014, 8 /* Sep */, 1);
+    subBusinessDays([], date, 11);
+    expect(date).toEqual(new Date(2014, 8 /* Sep */, 1));
+  });
+
+  it("returns `Invalid Date` if the given date is invalid", () => {
+    const result = subBusinessDays([], new Date(NaN), 10);
+    expect(
+      result instanceof Date && Number.isNaN(result.getTime())
+    ).toBeTruthy();
+  });
+
+  it("throws TypeError exception if passed less than 2 arguments", () => {
+    try {
+      assert.throws(subBusinessDays.bind(null), TypeError);
+      assert.throws(
+        subBusinessDays.bind(null, new Date(2014, 8 /* Sep */, 1)),
+        TypeError
+      );
+    } catch {}
+  });
+});

package/src/utils/subBusinessDays.ts

@@ -0,0 +1,10 @@
+import { toInteger } from "lodash";
+import { addBusinessDays } from "./addBusinessDays";
+import { requiredArgs } from "./requiredArgs";
+
+export function subBusinessDays(nonBusinessDays: Date[], dirtyDate: Date | number, dirtyAmount: number): Date {
+  // eslint-disable-next-line prefer-rest-params
+  requiredArgs(2, [dirtyDate, dirtyAmount]);
+  const amount = toInteger(dirtyAmount);
+  return addBusinessDays(nonBusinessDays, dirtyDate, -amount);
+}