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.

```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;
  }

  const days = eachDayOfInterval({ start, end });
  const weekdaysCount = days.filter(day => !isWeekend(day)).length;

  // The range is (start, end], so the start date is excluded.
  // If the start date is a weekday, it was included in weekdaysCount, so subtract 1.
  if (!isWeekend(start)) {
    return weekdaysCount - 1;
  }

  return weekdaysCount;
}
```

The user wants an ES module `solution.js` that exports a function `businessDaysBetween(startISO, endISO)`.

Requirements:
1. Use `date-fns` imports: `parseISO`, `eachDayOfInterval`, `isWeekend`.
2. Count business days (Mon-Fri) in range `(start, end]`.
3. Start date is exclusive.
4. End date is inclusive.
5. If `end <= start`, return 0.

Logic:
1. Parse `startISO` and `endISO` into Date objects using `parseISO`.
2. Check if `end <= start`. If so, return 0.
3. Generate the interval of days. Since the range is `(start, end]`, the interval should start from the day after `start` and end at `end`.
   - `eachDayOfInterval` takes an object `{ start, end }`.
   - So, `start` for the interval should be `addDays(start, 1)` or just handle the filtering logic.
   - Alternatively, generate days from `start` to `end` and filter out the first one, or generate from `start + 1 day` to `end`.
   - Let's look at `eachDayOfInterval`. It includes both start and end dates.
   - If I use `{ start: start, end: end }`, I get `[start, ..., end]`.
   - I need `(start, end]`, so I need to exclude `start`.
   - Or, I can calculate the next day after start. `date-fns` has `addDays`. But the prompt only explicitly listed `parseISO`, `eachDayOfInterval`, `isWeekend` in the snippet, though it said "Use date-fns helpers such as...". It's safer to stick to the listed ones or standard logic if `addDays` isn't imported.
   - Actually, I can just filter the array returned by `eachDayOfInterval`.
   - Interval: `{ start: start, end: end }`.
   - Filter: `d => !isWeekend(d) && d !== start`.
   - Wait, `d !== start` works for Date objects? No, Date objects are references. `d.getTime() !== start.getTime()` is better.
   - Or, simpler: Generate interval from `start` to `end`. Filter out weekends. Then subtract 1 if `start` was a weekday?
   - Let's trace:
     - Range `(start, end]`.
     - Days = `eachDayOfInterval({ start, end })`.
     - Business days in `[start, end]` = count where `!isWeekend(d)`.
     - If `start` is a weekday, it is included in that count, but we need to exclude it.
     - So: `count = days.filter(d => !isWeekend(d)).length`.
     - If `!isWeekend(start)`, `count--`.
     - This seems robust.

Let's double check the `end <= start` condition.
- If `end <= start`, `eachDayOfInterval` might behave differently or return empty/just start depending on implementation, but the requirement says return 0.
- `parseISO` returns Date objects. Comparison `end <= start` works for Date objects (compares timestamps).

Refined Logic:
1. `const start = parseISO(startISO);`
2. `const end = parseISO(endISO);`
3. `if (end <= start) return 0;`
4. `const days = eachDayOfInterval({ start, end });`
5. `let count = 0;`
6. `for (const day of days) {`
7. `  if (!isWeekend(day) && day !== start) count++;` // `day !== start` is risky with Date objects if `eachDayOfInterval` returns new instances or same instances.
   - `eachDayOfInterval` returns new Date objects usually.
   - Better check: `day.getTime() !== start.getTime()`.
   - Or use the subtraction method:
     - `const allBusinessDays = days.filter(d => !isWeekend(d)).length;`
     - `if (!isWeekend(start)) allBusinessDays--;`
     - Return `allBusinessDays`.

Let's verify with examples.
Ex 1: "2024-01-01" (Mon) to "2024-01-05" (Fri).
- Interval: Mon, Tue, Wed, Thu, Fri.
- All are weekdays. Count = 5.
- Start (Mon) is weekday. Subtract 1. Result = 4. Correct.

Ex 2: "2024-01-05" (Fri) to "2024-01-08" (Mon).
- Interval: Fri, Sat, Sun, Mon.
- Weekdays: Fri, Mon. Count = 2.
- Start (Fri) is weekday. Subtract 1. Result = 1. Correct.

Ex 3: "2024-01-01" (Mon) to "2024-01-01" (Mon).
- `end <= start` is true. Return 0. Correct.

Ex 4: "2024-01-01" (Mon) to "2024-01-08" (Mon).
- Interval: Mon..Mon (next week).
- Weekdays: Mon, Tue, Wed, Thu, Fri, Mon. Count = 6.
- Start (Mon) is weekday. Subtract 1. Result = 5. Correct.

What if start is weekend?
Ex: "2024-01-06" (Sat) to "2024-01-08" (Mon).
- Interval: Sat, Sun, Mon.
- Weekdays: Mon. Count = 1.
- Start (Sat) is weekend. Do not subtract. Result = 1.
- Logic check: Range (Sat, Mon]. Days are Sun, Mon. Sun is weekend. Mon is weekday. Count 1. Correct.

Implementation details:
- Imports provided in prompt.
- Function signature provided.

Code structure:
```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;
  }

  const days = eachDayOfInterval({ start, end });
  
  // Count weekdays in [start, end]
  let count = 0;
  for (const day of days) {
    if (!isWeekend(day)) {
      count++;
    }
  }

  // Exclude start date if it was a weekday
  if (!isWeekend(start)) {
    count--;
  }

  return count;
}
```

Wait, `eachDayOfInterval` might be heavy if the range is huge, but for typical business logic tasks, it's fine. The prompt explicitly suggests using it.

Alternative using filter:
```js
const count = days.filter(d => !isWeekend(d)).length;
return !isWeekend(start) ? count - 1 : count;
```
This is cleaner.

One edge case: `end <= start`.
If `end === start`, `eachDayOfInterval` returns `[start]`.
Count = 1 (if weekday).
Subtract 1 -> 0.
So the explicit check `if (end <= start) return 0` is good practice but the logic holds for `end === start` too. However, if `end < start`, `eachDayOfInterval` behavior might vary (usually returns empty array or throws depending on version/config, but standard behavior is empty or just start if invalid). The prompt explicitly asks to return 0 if `end <= start`, so keeping the check is safer and follows instructions.

Let's write the solution.

```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;
  }

  const days = eachDayOfInterval({ start, end });
  const weekdaysCount = days.filter(day => !isWeekend(day)).length;

  // Since the range is (start, end], we must exclude the start date
  // if i
…[9911 chars elided]…
business days calculation, this is standard unless ranges are massive (years), but even then it's fast enough in JS.

I'm confident.

```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;
  }

  const days = eachDayOfInterval({ start, end });
  const weekdaysCount = days.filter(day => !isWeekend(day)).length;

  // Exclude start date if it is a weekday, as the range is (start, end]
  if (!isWeekend(start)) {
    return weekdaysCount - 1;
  }

  return weekdaysCount;
}
```
This is the code.

Wait, I should check if `end <= start` handles `Invalid Date` gracefully if inputs are weird?
`parseISO` returns `Invalid Date` for bad strings.
`Invalid Date <= Invalid Date` is `false`.
`eachDayOfInterval` might throw.
But prompt implies valid ISO strings. "Given two ISO date strings".
So no need to overengineer error handling.

Final Answer construction.
File: `solution.js`.
Code inside.

```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;
  }

  const days = eachDayOfInterval({ start, end });
  const weekdaysCount = days.filter(day => !isWeekend(day)).length;

  // The range is (start, end], so the start date is excluded.
  // If the start date is a weekday, it was included in weekdaysCount, so subtract 1.
  if (!isWeekend(start)) {
    return weekdaysCount - 1;
  }

  return weekdaysCount;
}
```
Looks good.

One variation:
`const days = eachDayOfInterval({ start, end });`
If `start` and `end` are same, `days` has 1 element.
`weekdaysCount` is 1 (if weekday).
`!isWeekend(start)` is true.
Returns 0.
So `end <= start` check is technically redundant for `end === start` but required for `end < start` (to avoid -1).
Keeping it is correct.

I will produce the output now.