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.

To solve this problem, we need to count the number of business days between two given dates. Business days are defined as weekdays (Monday to Friday), and the count should be exclusive of the start date and inclusive of the end date.

### Approach
1. **Parse the Dates**: Convert the given ISO date strings into Date objects using `parseISO`.
2. **Check Date Order**: If the end date is earlier than or the same as the start date, return 0 as there are no days to count.
3. **Adjust Start Date**: Create a new start date that is one day after the original start date to ensure the start date itself is excluded.
4. **Generate Interval**: Use `eachDayOfInterval` to generate all days from the adjusted start date to the end date.
5. **Count Business Days**: Iterate through each day in the generated interval and count only the days that are not weekends (Saturday or Sunday).

### Solution Code
```javascript
import { parseISO, eachDayOfInterval, isWeekend, addDays } from "date-fns";

export function businessDaysBetween(startISO, endISO) {
    const start = parseISO(startISO);
    const end = parseISO(endISO);

    if (end <= start) {
        return 0;
    }

    const newStart = addDays(start, 1);
    const days = eachDayOfInterval({ start: newStart, end });

    let count = 0;
    for (const day of days) {
        if (!isWeekend(day)) {
            count++;
        }
    }

    return count;
}
```

### Explanation
1. **Parsing Dates**: The `parseISO` function converts the ISO date strings into Date objects, allowing us to work with them programmatically.
2. **Date Order Check**: If the end date is not after the start date, we immediately return 0 as there are no days to consider.
3. **Adjusting Start Date**: By adding one day to the start date, we ensure that the start date itself is excluded from the count.
4. **Generating Days**: Using `eachDayOfInterval`, we generate all days from the adjusted start date to the end date, inclusive.
5. **Counting Business Days**: We iterate through each day in the generated interval and use `isWeekend` to check if the day is a weekend. If it is not a weekend, we increment our count.

This approach efficiently handles all edge cases, including weekends, same-day inputs, and cases where the end date is before the start date.

Okay, I need to solve this problem where I have to count the number of business days between two dates. The function is called businessDaysBetween and it takes two ISO date strings. The goal is to count the weekdays from start (exclusive) to end (inclusive). 

First, I should understand the problem thoroughly. So, business days are Monday to Friday. If the start date is a business day, it's not counted. The end date is counted if it's a business day. Also, if end is before or equal to start, return 0.

Let me think about the steps I need to take.

Step 1: Parse the ISO strings into Date objects. I can use parseISO from date-fns for that.

Step 2: Create an interval between the start and end dates. But wait, since the start is exclusive, I need to make sure that the interval starts from the day after the start date. Or maybe create a range that starts from start + 1 day up to end.

Wait, how does eachDayOfInterval work? It gives me each day in the interval, including both start and end. So if I create an interval from start to end, and then iterate through each day, I can check if each day is a business day, but only if it's after the start date.

Wait no, because the start date is exclusive. So perhaps the interval should be from start + 1 day to end.

But how do I handle that? Because if I have start and end as the same day, I should return 0. Also, if end is before start, return 0.

So first, I need to check if end is before or equal to start. If so, return 0.

Otherwise, create a date interval from the next day after start to end, inclusive.

Wait, but how do I create that interval? Because eachDayOfInterval requires a start and end date. So perhaps I should create a new start date that is the day after the original start.

But wait, what if the original start is a weekend? Then the next day after start could be Monday. So for example, if start is Saturday, the next day is Sunday, then the next is Monday.

Hmm, perhaps the correct approach is to create an interval that starts from the day after the start date, and ends on the end date. Then, for each day in this interval, check if it's a business day.

So, the plan is:

1. Parse both dates into Date objects using parseISO.

2. Check if end is <= start. If yes, return 0.

3. Otherwise, create a new start date which is the day after the original start date.

4. Create an interval from this new start date to the end date.

5. For each day in this interval, check if it's a business day (i.e., not a weekend).

6. Count the number of such days.

Wait, but how do I create the new start date? Because adding one day could be done with date-fns functions. Like, add 1 day to the original start date.

Wait, but date-fns functions work with Date objects. So, perhaps:

const startDate = parseISO(startISO);
const endDate = parseISO(endISO);

if (endDate <= startDate) return 0;

Then, create a new start date which is startDate + 1 day.

But how to add a day? I think date-fns has addDays function. So:

import { addDays } from 'date-fns';

So, newStart = addDays(startDate, 1);

Then, the interval is from newStart to endDate.

Then, for each day in this interval, check if it's a business day.

Wait, but eachDayOfInterval returns an array of days from start to end, inclusive. So if newStart is after endDate, the array will be empty. So, in that case, the count is 0.

So, the steps are:

- Parse start and end dates.

- If end <= start, return 0.

- Else, create newStart as start + 1 day.

- Create an interval from newStart to end.

- For each day in this interval, check if it's not a weekend.

- Count the number of such days.

So, how to implement this.

First, import the necessary functions: parseISO, eachDayOfInterval, isWeekend, and addDays.

Wait, the function is already given with the imports. So in the code, I have to make sure to import addDays as well.

Wait, looking back, the initial code provided only imports parseISO, eachDayOfInterval, and isWeekend. So I need to add addDays to the import.

So, the import statement should be:

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

But wait, in the initial code, the function is given as:

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

So I need to add addDays to the import.

So, in the code, I'll have to include that.

Now, the function:

function businessDaysBetween(startISO, endISO) {

   // parse dates

   const start = parseISO(startISO);

   const end = parseISO(endISO);

   if (end <= start) return 0;

   // create newStart as start + 1 day

   const newStart = addDays(start, 1);

   // create interval from newStart to end

   const days = eachDayOfInterval({ start: newStart, end });

   // count the days that are not weekends

   let count = 0;

   for (const day of days) {

      if (!isWeekend(day)) {

         count++;

      }

   }

   return count;

}

Wait, but what if newStart is after end? For example, if start is 2024-01-05 (Friday), and end is 2024-01-05. Then, newStart is 2024-01-06, which is after end. So the interval is empty, and count is 0.

Which is correct because end is same as start, so return 0.

Wait, no. Because in the function, the first check is if end <= start, return 0. So in that case, when end is same as start, it returns 0.

But what about when end is after start, but newStart is after end? Like, start is 2024-01-05 (Friday), end is 2024-01-06 (Saturday). Then newStart is 2024-01-06, which is same as end. So the interval is [2024-01-06], which is a Saturday. So isWeekend returns true, so count is 0.

Which is correct because the end date is Saturday, so it's not counted.

Another example: start is 2024-01-01 (Monday), end is 2024-01-05 (Friday). So newStart is 2024-01-02 (Tuesday). The interval is from 2024-01-02 to 2024-01-05, which includes 4 days: Tue, Wed, Thu, Fri. All are business days, so count is 4. Which matches the sample.

Another sample: businessDaysBetween("2024-01-05", "2024-01-08") should return 1.

Let's see: start is 2024-01-05 (Friday), end is 2024-01-08 (Monday).

newStart is 2024-01-06 (Saturday). The interval is from 2024-01-06 to 2024
…[811 chars elided]…
 So the interval is [2024-01-06], which is a Saturday. So isWeekend is true, so count is 0.

Which is correct because the end date is Saturday, not a business day.

Another test case: start is 2024-01-01 (Monday), end is 2024-01-02 (Tuesday). So newStart is 2024-01-02. The interval is [2024-01-02]. Is it a business day? Yes. So count is 1.

Yes, because the start is Monday (excluded), and end is Tuesday (included). So 1 business day.

Another test case: start is 2024-01-06 (Saturday), end is 2024-01-08 (Monday). So newStart is 2024-01-07 (Sunday). The interval is [2024-01-07, 2024-01-08]. 2024-01-07 is Sunday (weekend), 2024-01-08 is Monday (business). So count is 1.

Yes.

So the code seems to handle all cases correctly.

Now, I need to write the code accordingly.

Wait, but in the function, I have to make sure that the newStart is correctly computed. Also, I need to import addDays.

So, the code will be:

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

export function businessDaysBetween(startISO, endISO) {

   const start = parseISO(startISO);

   const end = parseISO(endISO);

   if (end <= start) {

      return 0;

   }

   const newStart = addDays(start, 1);

   const days = eachDayOfInterval({ start: newStart, end });

   let count = 0;

   for (const day of days) {

      if (!isWeekend(day)) {

         count++;

      }

   }

   return count;

}

Wait, but what if newStart is after end? For example, start is 2024-01-05 (Friday), end is 2024-01-05 (Friday). Then, newStart is 2024-01-06, which is after end. So eachDayOfInterval returns an empty array, so count is 0. Which is correct because end is same as start, so return 0.

Wait, no. Because in the first condition, end <= start returns true, so function returns 0. So the code is correct.

Another case: start is 2024-01-05 (Friday), end is 2024-01-06 (Saturday). So newStart is 2024-01-06. The interval is [2024-01-06], which is a Saturday. So count is 0.

Yes.

So the code should handle all cases.

I think this should work.