working/business day

[justLuiz]

with the Temporal.Duration its be possible represent a working/business day?

[justingrant]

It depends.

Temporal.Duration can store any kind of date/time units. So if you want to record "2 working days and 6 working hours" you can do that with Temporal.Duration.from({days: 2, hours: 6}).

But the rounding, totalling, and arithmetic functions of durations are for actual days and hours. So, for example, Temporal.Duration.from({days: 2, hours: 6}).round({smallestUnit: 'days'}) returns P2D not P3D as you'd expect for working hours.

[justLuiz]

i mean...

example:

const { PlainDate, Duration } = Temporal;

// List of holidays
const holidays = [
    PlainDate.from('2025-01-01'), // New Year's Day
    PlainDate.from('2025-02-25'), // Carnival
    PlainDate.from('2025-12-25'), // Christmas
];

function isHoliday(date) {
    return holidays.some(holiday => holiday.includes(date));
}

function isWeekend(date) {
    const dayOfWeek = date.dayOfWeek;
    return dayOfWeek === 6 || dayOfWeek === 7;
}

function addBusinessDays(start, period) {
    let endDate = start.add(period); // Calculate the end date of the period

    // Loop to ensure the end date doesn't fall on a holiday or weekend
    let businessDaysAdded = 0;
    while (businessDaysAdded < period.days) {
        if (!isHoliday(endDate) && !isWeekend(endDate)) {
            businessDaysAdded++;
        }

        endDate = endDate.add({ days: 1 });
    }

    return endDate;
}

// Example usage
const startDate = PlainDate.from('2025-05-01');
const period = Duration.from({ days: 10 });

const endDate = addBusinessDays(startDate, period);

console.log(`Start date: ${startDate}`);
console.log(`Adjusted end date: ${endDate}`);

With this code, when there are weekends or holidays within the period, equivalent days are added forward.

My question is, is there a better way to solve this with Temporal?

[ljharb]

Working days are regionally different, and industry-dependent. I’m not sure it makes sense for Temporal to solve it.

[gibson042]

// Example usage
const startDate = PlainDate.from('2025-05-01');
const period = Duration.from({ days: 10 });

const endDate = addBusinessDays(startDate, period);

console.log(Start date: ${startDate});
console.log(Adjusted end date: ${endDate});
With this code, when there are weekends or holidays within the period, equivalent days are added forward.

My question is, is there a better way to solve this with Temporal?

Better in what way? I don't think I understand your function, which for arguments (plainDate, { days: N }) seems to add N days and then add N more non-weekend non-holiday days and possibly ending on a weekend or holiday (e.g., addBusinessDays(PlainDate.from('2025-05-01'), {days: 10}) returns 2025-05-24, which is a Saturday falling 23 days after the start date). But I could imagine using weeks to reduce calculation and/or Temporal.PlainMonthDay to more accurately represent many holidays, e.g.

function addBusinessDays(startPlainDate, days) {
  // `relativeTo` might not be a business day, but the output must be.
  // Friday + 1 bd is Monday, as is Saturday + 0 bd. But Saturday + 1 bd is less
  // obvious. We take the position that it is Tuesday, just like Monday + 1 bd,
  // and ignore the opposite direction by requiring callers to provide only
  // non-negative `days`.
  let relativeTo = startPlainDate;
  while (isWeekend(relativeTo) || isHoliday(relativeTo)) {
    relativeTo = relativeTo.add({ days: 1 });
  }

  // Each 5 business days is a full week.
  let weeks = Math.floor(days / 5);
  let endDate = relativeTo.add({ weeks });
  let extraDays = days - 5 * weeks;
  if (extraDays) {
    const newDayOfWeek = endDate.dayOfWeek + extraDays;
    // Assume that "weekend" means Saturday/Sunday.
    endDate = endDate.add({
      days: newDayOfWeek <= 5 ? extraDays : extraDays + 2,
    });
  }

  while (true) {
    // Account for holidays with fixed calendar dates (floating holidays require
    // bounds checking, and are omitted here for convenience), avoiding double-
    // counting those that fall on weekends.
    let skipDays = 0;
    // Start with the first holiday after relativeTo.
    let { year } = relativeTo;
    let i = sortedFixedHolidays.findIndex(
      pmd => PlainDate.compare(pmd.toPlainDate({ year }), relativeTo) > 0,
    );
    if (i === -1) {
      year++;
      i = 0;
    }
    while (true) {
      const pmd = sortedFixedHolidays[i % sortedFixedHolidays.length];
      let holiday = pmd.toPlainDate({ year });
      if (PlainDate.compare(endDate, holiday) < 0) break;
      if (!isWeekend(holiday)) skipDays++;
      i = (i + 1) % sortedFixedHolidays.length;
      if (i === 0) year++;
    }

    if (!skipDays) return endDate;

    relativeTo = endDate;
    weeks = Math.floor(skipDays / 5);
    endDate = endDate.add({ weeks });
    extraDays = skipDays - 5 * weeks;
    if (extraDays) {
      const newDayOfWeek = endDate.dayOfWeek + extraDays;
      endDate = endDate.add({
        days: newDayOfWeek <= 5 ? extraDays : extraDays + 2,
      });
    }
  }
}

[justLuiz]

// Example usage
const startDate = PlainDate.from('2025-05-01');
const period = Duration.from({ days: 10 });
const endDate = addBusinessDays(startDate, period);
console.log(Start date: ${startDate});
console.log(Adjusted end date: ${endDate});
With this code, when there are weekends or holidays within the period, equivalent days are added forward.
My question is, is there a better way to solve this with Temporal?

Better in what way? I don't think I understand your function, which for arguments (plainDate, { days: N }) seems to add N days and then add N more non-weekend non-holiday days and possibly ending on a weekend or holiday (e.g., addBusinessDays(PlainDate.from('2025-05-01'), {days: 10}) returns 2025-05-24, which is a Saturday falling 23 days after the start date). But I could imagine using weeks to reduce calculation and/or Temporal.PlainMonthDay to more accurately represent many holidays, e.g.

function addBusinessDays(startPlainDate, days) {
// relativeTo might not be a business day, but the output must be.
// Friday + 1 bd is Monday, as is Saturday + 0 bd. But Saturday + 1 bd is less
// obvious. We take the position that it is Tuesday, just like Monday + 1 bd,
// and ignore the opposite direction by requiring callers to provide only
// non-negative days.
let relativeTo = startPlainDate;
while (isWeekend(relativeTo) || isHoliday(relativeTo)) {
relativeTo = relativeTo.add({ days: 1 });
}

// Each 5 business days is a full week.
let weeks = Math.floor(days / 5);
let endDate = relativeTo.add({ weeks });
let extraDays = days - 5 * weeks;
if (extraDays) {
const newDayOfWeek = endDate.dayOfWeek + extraDays;
// Assume that "weekend" means Saturday/Sunday.
endDate = endDate.add({
days: newDayOfWeek <= 5 ? extraDays : extraDays + 2,
});
}

while (true) {
// Account for holidays with fixed calendar dates (floating holidays require
// bounds checking, and are omitted here for convenience), avoiding double-
// counting those that fall on weekends.
let skipDays = 0;
// Start with the first holiday after relativeTo.
let { year } = relativeTo;
let i = sortedFixedHolidays.findIndex(
pmd => PlainDate.compare(pmd.toPlainDate({ year }), relativeTo) > 0,
);
if (i === -1) {
year++;
i = 0;
}
while (true) {
const pmd = sortedFixedHolidays[i % sortedFixedHolidays.length];
let holiday = pmd.toPlainDate({ year });
if (PlainDate.compare(endDate, holiday) < 0) break;
if (!isWeekend(holiday)) skipDays++;
i = (i + 1) % sortedFixedHolidays.length;
if (i === 0) year++;
}

if (!skipDays) return endDate;

relativeTo = endDate;
weeks = Math.floor(skipDays / 5);
endDate = endDate.add({ weeks });
extraDays = skipDays - 5 * weeks;
if (extraDays) {
  const newDayOfWeek = endDate.dayOfWeek + extraDays;
  endDate = endDate.add({
    days: newDayOfWeek <= 5 ? extraDays : extraDays + 2,
  });
}

}
}

It was just an example to clarify what kind of problem I'm referring to, I didn't even test it.

When I say "better way" I mean understanding whether the Temporal proposal would already resolve this in some more direct way.

However, what @ljharb says makes a lot of sense to me

[mirobo]

What if calculation of all sorts of national holidays and functions to calculate and configure business days were implemented once per engine? Imagine all the code that could be saved in modern web apps :D. Or do you leave this up to separate libraries?

[ljharb]

Imagine all the code that would be added to every single web app, whether they needed that calculation or not.