js-06-business-days

# Business days between (date-fns)

Implement an ES module **`solution.js`** that uses **date-fns** (already installed — import it):

```js
import { parseISO, eachDayOfInterval, isWeekend } from "date-fns";

export function businessDaysBetween(startISO, endISO) { /* ... */ }
```

Given two ISO date strings (`"YYYY-MM-DD"`), count the number of **business days**
(weekdays Monday–Friday) in the range **(start, end]** — that is, **exclusive of the
start date and inclusive of the end date**.

Rules:
- Saturday and Sunday are not business days.
- The start date itself is never counted (even if it is a weekday).
- The end date is counted if it is a weekday.
- If `end <= start`, return `0`.

Use date-fns helpers such as `parseISO`, `eachDayOfInterval`, and `isWeekend`.

Examples:
```js
businessDaysBetween("2024-01-01", "2024-01-05") // => 4
// Mon..Fri: start Mon excluded; Tue, Wed, Thu, Fri counted

businessDaysBetween("2024-01-05", "2024-01-08") // => 1
// Fri..Mon: Fri excluded, Sat/Sun weekend, Mon counted

businessDaysBetween("2024-01-01", "2024-01-01") // => 0
// same day

businessDaysBetween("2024-01-01", "2024-01-08") // => 5
// one week: Mon excluded; Tue–Fri (4) + next Mon (1)
```

import { test } from "node:test";
import { strict as assert } from "node:assert";
import { businessDaysBetween } from "./solution.js";

test("Mon..Fri excludes start, counts Tue-Fri", () => {
  assert.equal(businessDaysBetween("2024-01-01", "2024-01-05"), 4);
});

test("Fri..Mon skips the weekend, counts Mon", () => {
  assert.equal(businessDaysBetween("2024-01-05", "2024-01-08"), 1);
});

test("same day -> 0", () => {
  assert.equal(businessDaysBetween("2024-01-01", "2024-01-01"), 0);
});

test("end before start -> 0", () => {
  assert.equal(businessDaysBetween("2024-01-10", "2024-01-01"), 0);
});

test("one full week (Mon..Mon) -> 5", () => {
  assert.equal(businessDaysBetween("2024-01-01", "2024-01-08"), 5);
});

test("range entirely within a weekend -> 0", () => {
  // Sat 2024-01-06 .. Sun 2024-01-07
  assert.equal(businessDaysBetween("2024-01-06", "2024-01-07"), 0);
});

test("start on a weekend still excludes start, counts weekdays after", () => {
  // Sat 2024-01-06 .. Fri 2024-01-12: Mon-Fri (5) counted
  assert.equal(businessDaysBetween("2024-01-06", "2024-01-12"), 5);
});

test("two weeks spanning two weekends", () => {
  // Mon 2024-01-01 .. Mon 2024-01-15: exclude first Mon.
  // Tue-Fri wk1 (4) + Mon-Fri wk2 (5) + final Mon (1) = 10
  assert.equal(businessDaysBetween("2024-01-01", "2024-01-15"), 10);
});

You are an expert programmer. Solve the task exactly as specified. Output your solution as fenced code blocks using the required file name(s) and the exact function/type signatures requested. Prefer correctness; do not include prose outside code unless asked.

```javascript
import { parseISO, eachDayOfInterval, isWeekend } from "date-fns";

export function businessDaysBetween(startISO, endISO) {
  const start = parseISO(startISO);
  const end = parseISO(endISO);
  if (end <= start) return 0;
  return eachDayOfInterval({ start, end })
    .slice(1)
    .filter(day => !isWeekend(day))
    .length;
}
```

The user wants an ES module `solution.js` that calculates the number of business days between two ISO date strings.
The range is `(start, end]`, meaning exclusive of start, inclusive of end.
Weekends (Saturday, Sunday) are not business days.
If `end <= start`, return `0`.
I need to use `date-fns` functions: `parseISO`, `eachDayOfInterval`, `isWeekend`.

Let's break down the logic:
1. Parse `startISO` and `endISO` into Date objects.
2. If `end <= start`, return `0`.
3. Generate an array of dates from `start` to `end` using `eachDayOfInterval`. Wait, `eachDayOfInterval` includes both start and end. Since we want `(start, end]`, we can either slice off the first element, or adjust the start date by adding one day, or just filter out the start date.
Actually, `eachDayOfInterval({ start, end })` returns an array of dates from `start` to `end` inclusive.
We want to exclude `start`. So we can take the array, remove the first element, then filter out weekends, and count the remaining.
Alternatively, we can use `eachDayOfInterval({ start: addDays(start, 1), end })` but that requires importing `addDays`. The prompt says "Use date-fns helpers such as `parseISO`, `eachDayOfInterval`, and `isWeekend`." It doesn't strictly forbid others, but sticking to the given ones is safer.
Actually, `eachDayOfInterval` returns an array. We can just slice it: `eachDayOfInterval({ start, end }).slice(1)`.
Then filter: `.filter(day => !isWeekend(day))`.
Then return `.length`.

Wait, what if `end <= start`? `eachDayOfInterval` might return an empty array or just `[start]` depending on implementation, but the rule says if `end <= start`, return `0`. So we should check that first.

Let's test mentally:
`start = "2024-01-01"` (Monday)
`end = "2024-01-05"` (Friday)
`eachDayOfInterval` returns [Mon, Tue, Wed, Thu, Fri]
`.slice(1)` -> [Tue, Wed, Thu, Fri]
`.filter(!isWeekend)` -> [Tue, Wed, Thu, Fri] (length 4) -> Correct.

`start = "2024-01-05"` (Friday)
`end = "2024-01-08"` (Monday)
`eachDayOfInterval` returns [Fri, Sat, Sun, Mon]
`.slice(1)` -> [Sat, Sun, Mon]
`.filter(!isWeekend)` -> [Mon] (length 1) -> Correct.

`start = "2024-01-01"`
`end = "2024-01-01"`
`end <= start` -> returns 0. Correct.

`start = "2024-01-01"`
`end = "2024-01-08"`
`eachDayOfInterval` returns [Mon, Tue, Wed, Thu, Fri, Sat, Sun, Mon]
`.slice(1)` -> [Tue, Wed, Thu, Fri, Sat, Sun, Mon]
`.filter(!isWeekend)` -> [Tue, Wed, Thu, Fri, Mon] (length 5) -> Correct.

Edge case: `end < start`. The rule says return 0.
So:
```js
import { parseISO, eachDayOfInterval, isWeekend } from "date-fns";

export function businessDaysBetween(startISO, endISO) {
  const start = parseISO(startISO);
  const end = parseISO(endISO);
  if (end <= start) return 0;
  return eachDayOfInterval({ start, end })
    .slice(1)
    .filter(day => !isWeekend(day))
    .length;
}
```

Wait, `eachDayOfInterval` might behave differently if `start` and `end` are the same? It returns `[start]`. But we handle `end <= start` first, so it's fine.
What about timezones? `parseISO` parses as UTC or local? `date-fns` `parseISO` parses as local time by default in newer versions, or UTC? Actually, `parseISO` in date-fns v2/v3 parses as local time. But since we only care about dates and `eachDayOfInterval` works with Date objects, it should be fine. The comparison `end <= start` works correctly for dates at midnight.

Let's double check `eachDayOfInterval` signature. It takes an object `{ start, end }`.
Yes.

One minor thing: `eachDayOfInterval` might include the start date. We slice it off. That's correct.
Is there any case where `eachDayOfInterval` returns dates in a different order? No, it's always ascending.

Could there be an issue with `end <= start` check using Date objects? `new Date("2024-01-01") <= new Date("2024-01-01")` is true. So it returns 0. Correct.

What about `eachDayOfInterval` performance? It's fine for typical date ranges. The problem doesn't specify huge ranges.

Let's verify the imports match exactly what's requested:
```js
import { parseISO, eachDayOfInterval, isWeekend } from "date-fns";

export function businessDaysBetween(startISO, endISO) {
  const start = parseISO(startISO);
  const end = parseISO(endISO);
  if (end <= start) return 0;
  return eachDayOfInterval({ start, end })
    .slice(1)
    .filter(day => !isWeekend(day))
    .length;
}
```

Wait, `eachDayOfInterval` in date-fns v3 might have a different signature? In v2 and v3, it's `eachDayOfInterval({ start, end })`.
Actually, in date-fns v3, `eachDayOfInterval` is still `eachDayOfInterval({ start, end })`.
Let's check date-fns docs: `eachDayOfInterval({ start, end })` returns an array of dates.
Yes.

One thing: `eachDayOfInterval` might throw if `start > end` in some versions, but we guard against it.
Actually, in date-fns, if `start > end`, `eachDayOfInterval` returns an empty array or throws? In v2, it returns `[]`. In v3, it might throw or return `[]`. But we check `end <= start` first, so it's safe.

Wait, the prompt says: "If `end <= start`, return `0`."
So our check covers it.

Let's consider if `eachDayOfInterval` includes both start and end. Yes.
So `.slice(1)` correctly excludes start.
Then `.filter(day => !isWeekend(day))` excludes weekends.
Then `.length` gives the count.

Is there any timezone issue with `parseISO`? `parseISO("2024-01-01")` creates a Date at midnight local time. `eachDayOfInterval` will generate dates at midnight local time. `isWeekend` checks the day of week. This is consistent.

One minor point: `eachDayOfInterval` might be called with `start` and `end` as Date objects. That's correct.

Could we optimize or simplify?
```js
import { parseISO, eachDayOfInterval, isWeekend } from "date-fns";

export function businessDaysBetween(startISO, endISO) {
  const start = parseISO(startISO);
  const end = parseISO(endISO);
  if (end <= start) return 0;
  return eachDayOfInterval({ start, end })
    .slice(1)
    .filter(day => !isWeekend(day))
    .length;
}
```

This looks solid.

Let's test with the examples manually:
1. `businessDaysBetween("2024-01-01", "2024-01-05")`
   start: Mon Jan 1
   end: Fri Jan 5
   eachDay: [Mon, Tue, Wed
…[2755 chars elided]…
es that. `isWeekend` checks day of week, which is unaffected by time. So it's fine.

Final check of the code:
```js
import { parseISO, eachDayOfInterval, isWeekend } from "date-fns";

export function businessDaysBetween(startISO, endISO) {
  const start = parseISO(startISO);
  const end = parseISO(endISO);
  if (end <= start) return 0;
  return eachDayOfInterval({ start, end })
    .slice(1)
    .filter(day => !isWeekend(day))
    .length;
}
```
Looks perfect.
Proceeds. 
Output matches request.✅
Note: I'll make sure the formatting matches exactly.
The prompt says: "Implement an ES module **`solution.js`** that uses **date-fns** (already installed — import it):"
I will provide exactly that.
Done. 
Self-Correction/Verification during thought:
Is there any chance `eachDayOfInterval` includes the start date but we want to exclude it? Yes, `.slice(1)` handles it.
What if `start` and `end` are the same? `end <= start` catches it.
What if `end` is one day after `start`? `eachDayOfInterval` returns `[start, end]`. `.slice(1)` returns `[end]`. If `end` is weekday, count 1. Correct.
All edge cases covered.
Ready. 
Output matches. 
Proceeds. 
[Output Generation] -> *code block*
```javascript
import { parseISO, eachDayOfInterval, isWeekend } from "date-fns";

export function businessDaysBetween(startISO, endISO) {
  const start = parseISO(startISO);
  const end = parseISO(endISO);
  if (end <= start) return 0;
  return eachDayOfInterval({ start, end })
    .slice(1)
    .filter(day => !isWeekend(day))
    .length;
}
```
Matches requirements exactly. No extra text. Done. 
I will produce this. 
All steps verified. 
Final Answer Generation. 
(Self-Correction/Refinement during thought)
Wait, `eachDayOfInterval` in date-fns v3 might have changed? Actually, `eachDayOfInterval` is still standard. The signature is `eachDayOfInterval({ start, end })`. It's fine.
One minor thing: `eachDayOfInterval` might be called with `start` and `end` as properties. Yes.
The code is robust.
I'll output it. 
Done. 
[Output Generation] -> *Proceeds*