@alanszp/business-days-date-fns 12.0.2 → 13.0.0

package/node_modules/@types/yargs/yargs.d.ts

@@ -1,9 +0,0 @@
-import { Argv } from '.';
-
-export = Yargs;
-
-declare function Yargs(
-    processArgs?: ReadonlyArray<string> | string,
-    cwd?: string,
-    parentRequire?: NodeRequire,
-): Argv;

package/node_modules/@types/yargs-parser/LICENSE

@@ -1,21 +0,0 @@
-    MIT License
-
-    Copyright (c) Microsoft Corporation.
-
-    Permission is hereby granted, free of charge, to any person obtaining a copy
-    of this software and associated documentation files (the "Software"), to deal
-    in the Software without restriction, including without limitation the rights
-    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-    copies of the Software, and to permit persons to whom the Software is
-    furnished to do so, subject to the following conditions:
-
-    The above copyright notice and this permission notice shall be included in all
-    copies or substantial portions of the Software.
-
-    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-    SOFTWARE

package/node_modules/@types/yargs-parser/README.md

@@ -1,16 +0,0 @@
-# Installation
-> `npm install --save @types/yargs-parser`
-
-# Summary
-This package contains type definitions for yargs-parser (https://github.com/yargs/yargs-parser#readme).
-
-# Details
-Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/yargs-parser.
-
-### Additional Details
- * Last updated: Fri, 02 Jul 2021 16:32:07 GMT
- * Dependencies: none
- * Global values: none
-
-# Credits
-These definitions were written by [Miles Johnson](https://github.com/milesj).

package/node_modules/@types/yargs-parser/index.d.ts

@@ -1,112 +0,0 @@
-// Type definitions for yargs-parser 20.2
-// Project: https://github.com/yargs/yargs-parser#readme
-// Definitions by: Miles Johnson <https://github.com/milesj>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.2
-
-declare namespace yargsParser {
-    interface Arguments {
-        /** Non-option arguments */
-        _: string[];
-        /** The script name or node command */
-        $0: string;
-        /** All remaining options */
-        [argName: string]: any;
-    }
-
-    interface DetailedArguments {
-        /** An object representing the parsed value of `args` */
-        argv: Arguments;
-        /** Populated with an error object if an exception occurred during parsing. */
-        error: Error | null;
-        /** The inferred list of aliases built by combining lists in opts.alias. */
-        aliases: { [alias: string]: string[] };
-        /** Any new aliases added via camel-case expansion. */
-        newAliases: { [alias: string]: boolean };
-        /** The configuration loaded from the yargs stanza in package.json. */
-        configuration: Configuration;
-    }
-
-    interface Configuration {
-        /** Should variables prefixed with --no be treated as negations? Default is `true` */
-        'boolean-negation': boolean;
-        /** Should hyphenated arguments be expanded into camel-case aliases? Default is `true` */
-        'camel-case-expansion': boolean;
-        /** Should arrays be combined when provided by both command line arguments and a configuration file. Default is `false`  */
-        'combine-arrays': boolean;
-        /** Should keys that contain . be treated as objects? Default is `true` */
-        'dot-notation': boolean;
-        /** Should arguments be coerced into an array when duplicated. Default is `true` */
-        'duplicate-arguments-array': boolean;
-        /** Should array arguments be coerced into a single array when duplicated. Default is `true` */
-        'flatten-duplicate-arrays': boolean;
-        /** Should arrays consume more than one positional argument following their flag. Default is `true` */
-        'greedy-arrays': boolean;
-        /** Should nargs consume dash options as well as positional arguments. Default is `false` */
-        'nargs-eats-options': boolean;
-        /** Should parsing stop at the first text argument? This is similar to how e.g. ssh parses its command line. Default is `false` */
-        'halt-at-non-option': boolean;
-        /** The prefix to use for negated boolean variables. Default is `'no-'` */
-        'negation-prefix': string;
-        /** Should keys that look like numbers be treated as such? Default is `true` */
-        'parse-numbers': boolean;
-        /** Should positional keys that look like numbers be treated as such? Default is `true` */
-        'parse-positional-numbers': boolean;
-        /** Should unparsed flags be stored in -- or _. Default is `false` */
-        'populate--': boolean;
-        /** Should a placeholder be added for keys not set via the corresponding CLI argument? Default is `false` */
-        'set-placeholder-key': boolean;
-        /** Should a group of short-options be treated as boolean flags? Default is `true` */
-        'short-option-groups': boolean;
-        /** Should aliases be removed before returning results? Default is `false` */
-        'strip-aliased': boolean;
-        /** Should dashed keys be removed before returning results? This option has no effect if camel-case-expansion is disabled. Default is `false` */
-        'strip-dashed': boolean;
-        /** Should unknown options be treated like regular arguments? An unknown option is one that is not configured in opts. Default is `false` */
-        'unknown-options-as-args': boolean;
-    }
-
-    interface Options {
-        /** An object representing the set of aliases for a key: `{ alias: { foo: ['f']} }`. */
-        alias?: { [key: string]: string | string[] } | undefined;
-        /**
-         * Indicate that keys should be parsed as an array: `{ array: ['foo', 'bar'] }`.
-         * Indicate that keys should be parsed as an array and coerced to booleans / numbers:
-         * { array: [ { key: 'foo', boolean: true }, {key: 'bar', number: true} ] }`.
-         */
-        array?: string[] | Array<{ key: string; boolean?: boolean | undefined, number?: boolean | undefined }> | undefined;
-        /** Arguments should be parsed as booleans: `{ boolean: ['x', 'y'] }`. */
-        boolean?: string[] | undefined;
-        /** Indicate a key that represents a path to a configuration file (this file will be loaded and parsed). */
-        config?: string | string[] | { [key: string]: boolean } | undefined;
-        /** Provide configuration options to the yargs-parser. */
-        configuration?: Partial<Configuration> | undefined;
-        /**
-         * Provide a custom synchronous function that returns a coerced value from the argument provided (or throws an error), e.g.
-         * `{ coerce: { foo: function (arg) { return modifiedArg } } }`.
-         */
-        coerce?: { [key: string]: (arg: any) => any } | undefined;
-        /** Indicate a key that should be used as a counter, e.g., `-vvv = {v: 3}`. */
-        count?: string[] | undefined;
-        /** Provide default values for keys: `{ default: { x: 33, y: 'hello world!' } }`. */
-        default?: { [key: string]: any } | undefined;
-        /** Environment variables (`process.env`) with the prefix provided should be parsed. */
-        envPrefix?: string | undefined;
-        /** Specify that a key requires n arguments: `{ narg: {x: 2} }`. */
-        narg?: { [key: string]: number } | undefined;
-        /** `path.normalize()` will be applied to values set to this key. */
-        normalize?: string[] | undefined;
-        /** Keys should be treated as strings (even if they resemble a number `-x 33`). */
-        string?: string[] | undefined;
-        /** Keys should be treated as numbers. */
-        number?: string[] | undefined;
-    }
-
-    interface Parser {
-        (argv: string | string[], opts?: Options): Arguments;
-        detailed(argv: string | string[], opts?: Options): DetailedArguments;
-    }
-}
-
-declare var yargsParser: yargsParser.Parser;
-export = yargsParser;

package/node_modules/@types/yargs-parser/package.json

@@ -1,25 +0,0 @@
-{
-    "name": "@types/yargs-parser",
-    "version": "20.2.1",
-    "description": "TypeScript definitions for yargs-parser",
-    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/yargs-parser",
-    "license": "MIT",
-    "contributors": [
-        {
-            "name": "Miles Johnson",
-            "url": "https://github.com/milesj",
-            "githubUsername": "milesj"
-        }
-    ],
-    "main": "",
-    "types": "index.d.ts",
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
-        "directory": "types/yargs-parser"
-    },
-    "scripts": {},
-    "dependencies": {},
-    "typesPublisherContentHash": "692e79ed176a53400e7007c2c3a8ab37780ca4e58b46acaec3e61cd1e365d4d2",
-    "typeScriptVersion": "3.6"
-}

package/src/cache/index.ts

@@ -1,14 +0,0 @@
-import LRUCache, { Options } from "lru-cache";
-
-const oneDay = 1000 * 60 * 60 * 24;
-
-const DEFAULT_OPTIONS: Options<string, Promise<Date[]>> = {
-  max: 300,
-  maxAge: oneDay,
-  stale: true,
-  updateAgeOnGet: true,
-};
-
-export const buildNonBusinessDaysCache = (
-  options?: Options<string, Promise<Date[]>>
-) => new LRUCache<string, Promise<Date[]>>(options ?? DEFAULT_OPTIONS);

package/src/index.ts

@@ -1 +0,0 @@
-export { withNonBusinessDays } from "./utils/withNonBusinessDays";

package/src/utils/addBusinessDays.test.ts

@@ -1,131 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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

@@ -1,176 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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)
-  );
-}