nhb-toolbox 4.20.70 → 4.20.80

package/CHANGELOG.md

@@ -6,6 +6,14 @@ All notable changes to the package will be documented here.
 
 ---
 
+## [4.20.80] - 2025-10-07
+
+### 🕧 Updates in Chronos
+
+- **Added** _overload signatures_ for `isWeekend`, `isWorkDay` and `isBusinessHour` methods from `businessPlugin`.
+- **Fixed** issues with `isBusinessHour`: previously skipped _business start and end hours_ in some cases.
+- **Added** new _utility type_ `RangeTuple` to create _ranged tuple_.
+
 ## [4.20.69-70] - 2025-10-07
 
 ### 🕧 Updates in Chronos

package/dist/cjs/date/Chronos.js

@@ -204,19 +204,20 @@ class Chronos {
     }
     #normalizeDuration(result, absolute, isFuture) {
         const entries = Object.entries(result);
+        const updated = {};
         if (!absolute && !isFuture) {
             for (const [key, value] of entries) {
                 if (value !== 0) {
-                    result[key] = value * -1;
+                    updated[key] = value * -1;
                 }
             }
         }
         else if (absolute) {
             for (const [key, value] of entries) {
-                result[key] = Math.abs(value);
+                updated[key] = Math.abs(value);
             }
         }
-        return result;
+        return updated;
     }
     get year() {
         return this.#date.getFullYear();

package/dist/cjs/date/plugins/businessPlugin.js

@@ -2,36 +2,44 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.businessPlugin = void 0;
 const non_primitives_1 = require("../../guards/non-primitives");
+const primitives_1 = require("../../guards/primitives");
 const constants_1 = require("../constants");
 const businessPlugin = (ChronosClass) => {
     const internalDate = ChronosClass[constants_1.INTERNALS].internalDate;
-    ChronosClass.prototype.isWeekend = function (weekStartsOn = 0, weekendLength = 2, weekendDays) {
+    ChronosClass.prototype.isWeekend = function (determiner = 0, weekendLength = 2) {
         const day = internalDate(this).getDay();
-        if ((0, non_primitives_1.isValidArray)(weekendDays)) {
-            return weekendDays.includes(day);
+        if ((0, non_primitives_1.isValidArray)(determiner)) {
+            return determiner.includes(day);
         }
-        const lastDayOfWeek = (weekStartsOn + 6) % 7;
+        const lastDayOfWeek = (determiner + 6) % 7;
         const computedWeekendDays = Array.from({ length: weekendLength }, (_, i) => (lastDayOfWeek - i + 7) % 7);
         return computedWeekendDays.includes(day);
     };
-    ChronosClass.prototype.isWorkday = function (weekStartsOn = 0, weekendLength = 2, weekendDays) {
-        return !this.isWeekend(weekStartsOn, weekendLength, weekendDays);
+    ChronosClass.prototype.isWorkday = function (determiner = 0, weekendLength = 2) {
+        if ((0, non_primitives_1.isValidArray)(determiner)) {
+            return !this.isWeekend(determiner);
+        }
+        return !this.isWeekend(determiner, weekendLength);
     };
     ChronosClass.prototype.isBusinessHour = function (options) {
-        const { businessStartHour = 9, businessEndHour = 17, weekStartsOn = 0, weekendLength = 2, weekendDays, } = options ?? {};
-        if (this.isWeekend(weekStartsOn, weekendLength, weekendDays)) {
-            return false;
-        }
-        const hour = internalDate(this).getHours();
-        if (businessStartHour === businessEndHour) {
-            return false;
-        }
-        if (businessStartHour < businessEndHour) {
-            return hour >= businessStartHour && hour < businessEndHour;
-        }
-        else {
-            return hour >= businessStartHour || hour < businessEndHour;
+        const _isBusinessHour = () => {
+            const { businessStartHour = 9, businessEndHour = 17 } = options ?? {};
+            if (businessStartHour === businessEndHour) {
+                return false;
+            }
+            const hour = internalDate(this).getHours();
+            if (businessStartHour < businessEndHour) {
+                return hour >= businessStartHour && hour < businessEndHour;
+            }
+            else {
+                return hour >= businessStartHour || hour < businessEndHour;
+            }
+        };
+        if (options && 'weekendDays' in options && !(0, primitives_1.isUndefined)(options?.weekendDays)) {
+            return this.isWorkday(options?.weekendDays) && _isBusinessHour();
         }
+        const { weekStartsOn = 0, weekendLength = 2 } = (options ?? {});
+        return this.isWorkday(weekStartsOn, weekendLength) && _isBusinessHour();
     };
     ChronosClass.prototype.toFiscalQuarter = function (startMonth = 7) {
         const month = internalDate(this).getMonth() + 1;

package/dist/dts/date/plugins/businessPlugin.d.ts

@@ -1,15 +1,14 @@
 import type { Enumerate, NumberRange } from '../../number/types';
-import type { TupleOf } from '../../utils/types';
-import type { BusinessHourOptions, Quarter } from '../types';
+import type { RangeTuple } from '../../utils/types';
+import type { AcademicYear, BusinessOptionsBasic, BusinessOptionsWeekends, Quarter } from '../types';
 type MainChronos = typeof import('../Chronos').Chronos;
 declare module '../Chronos' {
     interface Chronos {
         /**
-         * @instance Checks if the current date falls on a weekend.
+         * @instance Checks if the current date falls on a weekend using week start day and weekend length.
          *
          * @param weekStartsOn Optional. The day index (0–6) that the week starts on. Default is `0` (Sunday).
          * @param weekendLength Optional. The number of consecutive days at the end of the week considered as weekend. Must be between 1 and 4. Default is `2`.
-         * @param weekendDays Optional. A tuple of custom weekend day indices (0–6). Its length must match `weekendLength`. If provided, this overrides `weekStartsOn` + `weekendLength` calculation.
          * @returns `true` if the current date is a weekend day according to the provided parameters; otherwise `false`.
          *
          * @description
@@ -19,7 +18,6 @@ declare module '../Chronos' {
          * - By default (`weekStartsOn = 0`, `weekendLength = 2`), Saturday (6) and Friday (5) are considered weekend.
          * - `weekStartsOn` sets the start of the week for calculating weekend days.
          * - `weekendLength` sets how many days at the end of the week are treated as weekend.
-         * - `weekendDays`, if provided, is used directly as the weekend days instead of calculating from `weekStartsOn` + `weekendLength`.
          *
          * @example
          * // Default: Saturday & Friday are weekend
@@ -30,17 +28,30 @@ declare module '../Chronos' {
          *
          * // Custom 3-day weekend (Friday, Saturday, Sunday)
          * new Chronos().isWeekend(1, 3);
+         */
+        isWeekend(weekStartsOn?: Enumerate<7>, weekendLength?: NumberRange<1, 4>): boolean;
+        /**
+         * @instance Checks if the current date falls on a weekend using indices of weekend days.
          *
+         * @param weekendDays Optional. A tuple of custom weekend day indices (0–6). Can pass only 1-4 elements.
+         * @returns `true` if the current date is a weekend day according to the provided `weekendDays`; otherwise `false`.
+         *
+         * @description
+         * Determines whether the current date is considered part of the weekend.
+         *
+         * **Behavior:**
+         * - `weekendDays` is used directly as the weekend days instead of calculating from `weekStartsOn` + `weekendLength`.
+         *
+         * @example
          * // Fully custom weekend days (Sunday, Friday, Saturday)
-         * new Chronos().isWeekend(0, 3, [0, 5, 6]);
+         * new Chronos().isWeekend([0, 5, 6]);
          */
-        isWeekend<Length extends NumberRange<1, 4>>(weekStartsOn?: Enumerate<7>, weekendLength?: Length, weekendDays?: TupleOf<Enumerate<7>, Length>): boolean;
+        isWeekend(weekendDays: RangeTuple<Enumerate<7>, 1, 4>): boolean;
         /**
-         * @instance Checks if the current date is a workday (non-weekend day).
+         * @instance Checks if the current date is a workday (non-weekend day) using week start day and weekend length.
          *
          * @param weekStartsOn Optional. The day index (0–6) that the week starts on. Default is `0` (Sunday).
          * @param weekendLength Optional. The number of consecutive days at the end of the week considered as weekend. Must be between 1 and 4. Default is `2`.
-         * @param weekendDays Optional. A tuple of custom weekend day indices (0–6). Its length must match `weekendLength`. If provided, this overrides `weekStartsOn` + `weekendLength` calculation.
          * @returns `true` if the current date is a work day according to the provided parameters; otherwise `false`.
          *
          * @description
@@ -50,13 +61,25 @@ declare module '../Chronos' {
          * - By default (`weekStartsOn = 0`, `weekendLength = 2`), Saturday (6) and Friday (5) are considered weekend.
          * - `weekStartsOn` sets the start of the week for calculating weekend days.
          * - `weekendLength` sets how many days at the end of the week are treated as weekend.
-         * - `weekendDays`, if provided, is used directly as the weekend days instead of calculating from `weekStartsOn` + `weekendLength`.
          */
-        isWorkday<Length extends NumberRange<1, 4>>(weekStartsOn?: Enumerate<7>, weekendLength?: Length, weekendDays?: TupleOf<Enumerate<7>, Length>): boolean;
+        isWorkday(weekStartsOn?: Enumerate<7>, weekendLength?: NumberRange<1, 4>): boolean;
         /**
-         * @instance Checks if the current date and time fall within business hours.
+         * @instance Checks if the current date is a workday (non-weekend day) using indices of weekend days.
+         *
+         * @param weekendDays A tuple of custom weekend day indices (0–6). Can pass only 1-4 elements.
+         * @returns `true` if the current date is a work day according to the provided `weekendDays`; otherwise `false`.
          *
-         * @param options Options to configure business hour
+         * @description
+         * Determines whether the current date is considered as workday. Internally uses {@link isWeekend} method.
+         *
+         * **Behavior:**
+         * - `weekendDays` is used directly as the weekend days instead of calculating from `weekStartsOn` + `weekendLength`.
+         */
+        isWorkday(weekendDays: RangeTuple<Enumerate<7>, 1, 4>): boolean;
+        /**
+         * @instance Checks if the current date and time fall within business hours using week start day and weekend length & other options.
+         *
+         * @param options Options to configure business hour and weekends.
          *
          * @returns Whether the current time is within business hours.
          *
@@ -65,23 +88,29 @@ declare module '../Chronos' {
          * - Supports standard and overnight business hours. Overnight means `end < start`.
          * - Example: `businessStartHour = 22`, `businessEndHour = 6` will cover 10 PM to 6 AM next day.
          *
-         * * *Weekends are determined by `weekStartsOn` and `weekendLength` or `weekdays` array if provided using the {@link isWeekend} method.*
+         * * *Weekends are determined by `weekStartsOn` and `weekendLength` using the {@link isWorkday} method.*
+         */
+        isBusinessHour(options?: BusinessOptionsBasic): boolean;
+        /**
+         * @instance Checks if the current date and time fall within business hours using indices of weekend days & other options.
+         *
+         * @param options Options to configure business hour and weekends.
          *
-         * - If you only want to pass `weekendDays` option you should pass the `weekendLength` option or pass a generic (1-4):
-         * ```ts
-         * new Chronos().isBusinessHour<3>({ weekendDays: [0, 2, 4] });
+         * @returns Whether the current time is within business hours.
          *
-         * // Or
+         * @remarks
+         * - Business hours are typically 9 AM to 5 PM on weekdays.
+         * - Supports standard and overnight business hours. Overnight means `end < start`.
+         * - Example: `businessStartHour = 22`, `businessEndHour = 6` will cover 10 PM to 6 AM next day.
          *
-         * new Chronos().isBusinessHour({weekendLength: 3, weekendDays: [0, 2, 4] });
-         * ```
+         * * *Weekends are determined by `weekendDays` tuple using the {@link isWorkday} method.*
          */
-        isBusinessHour<Length extends NumberRange<1, 4>>(options?: BusinessHourOptions<Length>): boolean;
+        isBusinessHour(options?: BusinessOptionsWeekends): boolean;
         /**
          * @instance Returns the academic year based on a typical start in July and end in June.
          * @returns The academic year in format `YYYY-YYYY`.
          */
-        toAcademicYear(): `${number}-${number}`;
+        toAcademicYear(): AcademicYear;
         /**
          * @instance Returns the fiscal quarter based on custom fiscal year start (defaults to July).
          * @param startMonth - The fiscal year start month (1-12), default is July (7).

package/dist/dts/date/types.d.ts

@@ -1,5 +1,5 @@
 import type { Enumerate, NumberRange } from '../number/types';
-import type { LooseLiteral, TupleOf } from '../utils/types';
+import type { LooseLiteral, RangeTuple } from '../utils/types';
 import type { Chronos } from './Chronos';
 import type { ChronosStatics } from './chronos-statics';
 import type { DATE_FORMATS, DAY_FORMATS, DAYS, HOUR_FORMATS, MILLISECOND_FORMATS, MINUTE_FORMATS, MONTH_FORMATS, MONTHS, SECOND_FORMATS, TIME_FORMATS, TIME_ZONES, WESTERN_ZODIAC_SIGNS, YEAR_FORMATS, ZODIAC_PRESETS } from './constants';
@@ -76,27 +76,46 @@ type DateTimeConnector = ' ' | ', ' | '; ' | ' - ';
 export type StrictFormat = LooseLiteral<DateParts | TimeParts | `${DateParts}${DateTimeConnector}${TimeParts}`>;
 /** Iterable `Chronos` object properties */
 export interface ChronosObject {
+    /** Full year (e.g., 2025). */
     year: number;
+    /** Month index starting from 0 (January = 0). */
     month: Enumerate<12>;
+    /** ISO month number starting from 1 (January = 1). */
     isoMonth: NumberRange<1, 12>;
+    /** Day of the month (1–31). */
     date: NumberRange<1, 31>;
+    /** Day of the week index (0–6, Sunday = 0). */
     weekDay: Enumerate<7>;
+    /** ISO day of the week number (1–7, Monday = 1). */
     isoWeekDay: NumberRange<1, 7>;
+    /** Hour of the day (0–23). */
     hour: Enumerate<24>;
+    /** Minute of the hour (0–59). */
     minute: Enumerate<60>;
+    /** Second of the minute (0–59). */
     second: Enumerate<60>;
+    /** Milliseconds within the second. */
     millisecond: Milliseconds;
+    /** Timestamp in milliseconds since the Unix epoch. */
     timestamp: number;
+    /** Unix timestamp in seconds since the epoch. */
     unix: number;
 }
 /** Return object type of `duration` method of `Chronos`. */
 export interface TimeDuration {
+    /** Total number of years. */
     years: number;
+    /** Number of months remaining after full years are counted. */
     months: number;
+    /** Number of days remaining after full months are counted. */
     days: number;
+    /** Number of hours remaining after full days are counted. */
     hours: number;
+    /** Number of minutes remaining after full hours are counted. */
     minutes: number;
+    /** Number of seconds remaining after full minutes are counted. */
     seconds: number;
+    /** Number of milliseconds remaining after full seconds are counted. */
     milliseconds: number;
 }
 /** Interface for accessing internal private properties in extended `Chronos` class */
@@ -184,6 +203,8 @@ export type DayPart = 'night' | 'midnight' | 'lateNight' | 'morning' | 'afternoo
 export type DayPartConfig = Record<DayPart, [ClockHour, ClockHour]>;
 /** Quarters of the year */
 export type Quarter = 1 | 2 | 3 | 4;
+/** Academic year, e.g. `2024-2025` */
+export type AcademicYear = `${number}-${number}`;
 /** Names of Zodiac signs */
 export type ZodiacSign = (typeof WESTERN_ZODIAC_SIGNS)[number][0];
 /** Presets for Zodiac Sign Configuration */
@@ -329,19 +350,26 @@ export interface SeasonOptions {
 }
 /** * A plugin that augments the Chronos class with methods or properties. */
 export type ChronosPlugin = (ChronosClass: $Chronos) => void;
-/** Options for configuring business hour */
-export interface BusinessHourOptions<Length extends NumberRange<1, 4>> {
+export interface $BusinessHourBaseOptions {
     /** - Optional starting hour of business time (0–23). Defaults to `9` (9 AM). */
     businessStartHour?: Enumerate<24>;
     /** - Optional ending hour of business time (0–23). Defaults to `17` (5 PM). */
     businessEndHour?: Enumerate<24>;
+}
+/** Options for configuring business hour with `weekStartsOn` and `weekendLength` */
+export interface BusinessOptionsBasic extends $BusinessHourBaseOptions {
     /** - Optional day the week starts on (0–6). Default is `0` (Sunday). */
-    weekStartsOn?: Enumerate<7>;
-    /** - Optional weekend length (1 or 2). Default is `2`.*/
-    weekendLength?: Length;
-    /** - Tuple of indices of weekend days. Default is `undefined`. */
-    weekendDays?: TupleOf<Enumerate<7>, Length>;
+    weekStartsOn?: Enumerate<7> | undefined;
+    /** - Optional weekend length (1-4). Default is `2`.*/
+    weekendLength?: NumberRange<1, 4> | undefined;
 }
+/** Options for configuring business hour with `weekendDays` tuple */
+export interface BusinessOptionsWeekends extends $BusinessHourBaseOptions {
+    /** - Tuple of indices (0-6) of weekend days. Can pass only 1-4 elements. Default is `undefined`. */
+    weekendDays?: RangeTuple<Enumerate<7>, 1, 4> | undefined;
+}
+/** Options for configuring business hour */
+export type $BusinessHourOptions = BusinessOptionsBasic | BusinessOptionsWeekends;
 /** Interface representing a date-like object. */
 export interface DateLike {
     toJSON?(): string;

package/dist/dts/utils/types.d.ts

@@ -241,6 +241,18 @@ export type TupleToUnion<T extends readonly unknown[]> = T[number];
  * type EmptyTuple = TupleOf<boolean, 0>; // []
  */
 export type TupleOf<T, N extends number, R extends unknown[] = []> = R['length'] extends N ? R : TupleOf<T, N, [...R, T]>;
+/** * Build a tuple of given length (helper for type-level arithmetic). */
+export type $BuildTuple<L extends number, T extends unknown[] = []> = T['length'] extends L ? T : $BuildTuple<L, [...T, unknown]>;
+/** * Produce a union of numbers `From | From+1 | ... | To`. */
+export type $Range<From extends number, To extends number, Arr extends unknown[] = $BuildTuple<From>, Result = never> = Arr['length'] extends To ? Result | To : $Range<From, To, [...Arr, unknown], Result | Arr['length']>;
+/**
+ * * Creates a tuple with length between `Min` and `Max` (inclusive).
+ *
+ * @example
+ * type Ranged = RangeTuple<string, 2, 4>;
+ * // Ranged -> [string, string] | [string, string, string] | [string, string, string, string]
+ */
+export type RangeTuple<T, Min extends number, Max extends number> = $Range<Min, Max> extends infer N ? N extends number ? TupleOf<T, N> : never : never;
 /**
  * * Makes selected or all properties of an object type optional (only the values, not the keys).
  *
@@ -262,7 +274,7 @@ export type TupleOf<T, N extends number, R extends unknown[] = []> = R['length']
 export type ValueOptional<O, K extends keyof O = keyof O> = {
     [P in keyof O]: P extends K ? O[P] | undefined : O[P];
 };
-type $Without<T, U> = {
+export type $Without<T, U> = {
     [P in Exclude<keyof T, keyof U>]?: never;
 };
 /**
@@ -366,14 +378,12 @@ export type RemoveNever<T> = {
 export type RenameKeys<T, R extends Partial<Record<keyof T, string>>> = {
     [K in keyof T as K extends keyof R ? Extract<R[K], string | number | symbol> : K]: T[K];
 };
-/** * Build a tuple of given length (helper for type-level arithmetic). */
-export type BuildTuple<L extends number, T extends unknown[] = []> = T['length'] extends L ? T : BuildTuple<L, [...T, unknown]>;
 /** * Subtracts `B` from `A` (helper for type-level arithmetic). */
-export type Subtract<A extends number, B extends number> = [
-    ...BuildTuple<A>
-] extends [...BuildTuple<B>, ...infer R] ? R['length'] : never;
+export type $Subtract<A extends number, B extends number> = [
+    ...$BuildTuple<A>
+] extends [...$BuildTuple<B>, ...infer R] ? R['length'] : never;
 /** * Forbids all properties not in `K`. */
-export type Forbid<T, K extends keyof T> = {
+export type $Forbid<T, K extends keyof T> = {
     [P in Exclude<keyof T, K>]?: never;
 };
 /**
@@ -405,7 +415,7 @@ export type Forbid<T, K extends keyof T> = {
 export type RequireAtLeast<T extends GenericObject, N extends number, Keys extends keyof T = keyof T> = N extends 1 ? {
     [K in Keys]-?: Required<Pick<T, K>> & Partial<Omit<T, K>>;
 }[Keys] : {
-    [K in Keys]-?: Required<Pick<T, K>> & RequireAtLeast<Omit<T, K>, Subtract<N, 1>>;
+    [K in Keys]-?: Required<Pick<T, K>> & RequireAtLeast<Omit<T, K>, $Subtract<N, 1>>;
 }[Keys];
 /**
  * * Enforces that exactly `N` properties of type `T` are required.
@@ -436,7 +446,7 @@ export type RequireAtLeast<T extends GenericObject, N extends number, Keys exten
  * const c6: TwoExact = { host: "a", port: 1, secure: true }; 	// ❌ Error
  */
 export type RequireExactly<T extends GenericObject, N extends number> = {
-    [K in keyof T]: Required<Pick<T, K>> & (N extends 1 ? Forbid<T, K> : RequireExactly<Omit<T, K>, Subtract<N, 1>>);
+    [K in keyof T]: Required<Pick<T, K>> & (N extends 1 ? $Forbid<T, K> : RequireExactly<Omit<T, K>, $Subtract<N, 1>>);
 }[keyof T];
 /**
  * * Enforces that between `Min` and `Max` properties of type `T` are required.
@@ -459,7 +469,7 @@ export type RequireExactly<T extends GenericObject, N extends number> = {
  * const s3: OneOrTwo = { theme: "dark", lang: "en", debug: true }; // ❌ (3 keys)
  * const s4: OneOrTwo = {};                                 		// ❌ (0 keys)
  */
-export type RequireBetween<T extends GenericObject, Min extends number, Max extends number, C extends unknown[] = BuildTuple<Max>, Acc extends unknown[] = BuildTuple<Min>> = RequireExactly<T, Acc['length']> | (Acc['length'] extends Max ? never : RequireBetween<T, Min, Max, C, [...Acc, unknown]>);
+export type RequireBetween<T extends GenericObject, Min extends number, Max extends number, C extends unknown[] = $BuildTuple<Max>, Acc extends unknown[] = $BuildTuple<Min>> = RequireExactly<T, Acc['length']> | (Acc['length'] extends Max ? never : RequireBetween<T, Min, Max, C, [...Acc, unknown]>);
 /**
  * * Cast one type to another while preserving compatibility.
  *

package/dist/esm/date/Chronos.js

@@ -201,19 +201,20 @@ export class Chronos {
     }
     #normalizeDuration(result, absolute, isFuture) {
         const entries = Object.entries(result);
+        const updated = {};
         if (!absolute && !isFuture) {
             for (const [key, value] of entries) {
                 if (value !== 0) {
-                    result[key] = value * -1;
+                    updated[key] = value * -1;
                 }
             }
         }
         else if (absolute) {
             for (const [key, value] of entries) {
-                result[key] = Math.abs(value);
+                updated[key] = Math.abs(value);
             }
         }
-        return result;
+        return updated;
     }
     get year() {
         return this.#date.getFullYear();

package/dist/esm/date/plugins/businessPlugin.js

@@ -1,34 +1,42 @@
 import { isValidArray } from '../../guards/non-primitives.js';
+import { isUndefined } from '../../guards/primitives.js';
 import { INTERNALS } from '../constants.js';
 export const businessPlugin = (ChronosClass) => {
     const internalDate = ChronosClass[INTERNALS].internalDate;
-    ChronosClass.prototype.isWeekend = function (weekStartsOn = 0, weekendLength = 2, weekendDays) {
+    ChronosClass.prototype.isWeekend = function (determiner = 0, weekendLength = 2) {
         const day = internalDate(this).getDay();
-        if (isValidArray(weekendDays)) {
-            return weekendDays.includes(day);
+        if (isValidArray(determiner)) {
+            return determiner.includes(day);
         }
-        const lastDayOfWeek = (weekStartsOn + 6) % 7;
+        const lastDayOfWeek = (determiner + 6) % 7;
         const computedWeekendDays = Array.from({ length: weekendLength }, (_, i) => (lastDayOfWeek - i + 7) % 7);
         return computedWeekendDays.includes(day);
     };
-    ChronosClass.prototype.isWorkday = function (weekStartsOn = 0, weekendLength = 2, weekendDays) {
-        return !this.isWeekend(weekStartsOn, weekendLength, weekendDays);
+    ChronosClass.prototype.isWorkday = function (determiner = 0, weekendLength = 2) {
+        if (isValidArray(determiner)) {
+            return !this.isWeekend(determiner);
+        }
+        return !this.isWeekend(determiner, weekendLength);
     };
     ChronosClass.prototype.isBusinessHour = function (options) {
-        const { businessStartHour = 9, businessEndHour = 17, weekStartsOn = 0, weekendLength = 2, weekendDays, } = options ?? {};
-        if (this.isWeekend(weekStartsOn, weekendLength, weekendDays)) {
-            return false;
-        }
-        const hour = internalDate(this).getHours();
-        if (businessStartHour === businessEndHour) {
-            return false;
-        }
-        if (businessStartHour < businessEndHour) {
-            return hour >= businessStartHour && hour < businessEndHour;
-        }
-        else {
-            return hour >= businessStartHour || hour < businessEndHour;
+        const _isBusinessHour = () => {
+            const { businessStartHour = 9, businessEndHour = 17 } = options ?? {};
+            if (businessStartHour === businessEndHour) {
+                return false;
+            }
+            const hour = internalDate(this).getHours();
+            if (businessStartHour < businessEndHour) {
+                return hour >= businessStartHour && hour < businessEndHour;
+            }
+            else {
+                return hour >= businessStartHour || hour < businessEndHour;
+            }
+        };
+        if (options && 'weekendDays' in options && !isUndefined(options?.weekendDays)) {
+            return this.isWorkday(options?.weekendDays) && _isBusinessHour();
         }
+        const { weekStartsOn = 0, weekendLength = 2 } = (options ?? {});
+        return this.isWorkday(weekStartsOn, weekendLength) && _isBusinessHour();
     };
     ChronosClass.prototype.toFiscalQuarter = function (startMonth = 7) {
         const month = internalDate(this).getMonth() + 1;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nhb-toolbox",
-  "version": "4.20.70",
+  "version": "4.20.80",
   "description": "A versatile collection of smart, efficient, and reusable utility functions, classes and types for everyday development needs.",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",