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, addDays } from "date-fns";

export function businessDaysBetween(startISO, endISO) {
  const startDate = parseISO(startISO);
  const endDate = parseISO(endISO);

  if (endDate <= startDate) {
    return 0;
  }

  const interval = {
    start: addDays(startDate, 1),
    end: endDate
  };

  const days = eachDayOfInterval(interval);
  const businessDays = days.filter(day => !isWeekend(day));

  return businessDays.length;
}
```

The task is to implement a function that counts business days between two dates (exclusive of start, inclusive of end).

Key requirements:
1. Use date-fns library (already imported)
2. Range is (start, end] - exclusive start, inclusive end
3. Business days are weekdays (Monday-Friday)
4. If end <= start, return 0
5. Use parseISO, eachDayOfInterval, and isWeekend

Let me think about the implementation:

1. Parse both ISO strings to Date objects
2. Check if end <= start, if so return 0
3. Create an interval from start to end
4. Use eachDayOfInterval to get all days in the range
5. Filter out weekends using isWeekend
6. Count the remaining days

Wait, I need to be careful about the interval. Since we want exclusive start and inclusive end, I should:
- Start from start date + 1 day
- End at end date

Or I can iterate through each day and check if it's after start and <= end.

Let me think about the date-fns helpers:
- `parseISO` - parses ISO string to Date
- `eachDayOfInterval` - returns array of dates in interval
- `isWeekend` - checks if a date is weekend

For the interval, I need to create an interval that starts from start date (exclusive) and ends at end date (inclusive).

Actually, looking at date-fns documentation, `eachDayOfInterval` takes an interval object with start and end dates. The interval is inclusive on both ends.

So if I want (start, end], I should:
- Start from start date + 1 day
- End at end date

Let me write the code:

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

export function businessDaysBetween(startISO, endISO) {
  const startDate = parseISO(startISO);
  const endDate = parseISO(endISO);
  
  // If end <= start, return 0
  if (endDate <= startDate) {
    return 0;
  }
  
  // Create interval from start + 1 day to end (inclusive)
  const interval = {
    start: addDays(startDate, 1),
    end: endDate
  };
  
  // Get all days in interval
  const days = eachDayOfInterval(interval);
  
  // Filter out weekends and count
  const businessDays = days.filter(day => !isWeekend(day));
  
  return businessDays.length;
}
```

I'll verify the implementation handles edge cases correctly. The function ensures we're counting only weekdays between the start and end dates, excluding the start date itself.

The key steps involve parsing dates, creating an interval, filtering out weekends, and counting the remaining days. This approach ensures we meet the business days calculation requirements precisely.