- {day}
- {#if getHoliday(day)}
-
+ {@const holiday = getHoliday(day)}
+
+ {day}
+ {#if holiday}
+
{/if}
{/each}
@@ -199,4 +197,9 @@
font-size: 0.8em;
}
}
+
+ .strikethrough {
+ text-decoration: line-through;
+ opacity: 0.5;
+ }
\ No newline at end of file
diff --git a/src/lib/holidayUtils.ts b/src/lib/holidayUtils.ts
index 105749a..99a6296 100644
--- a/src/lib/holidayUtils.ts
+++ b/src/lib/holidayUtils.ts
@@ -1,223 +1,179 @@
import Holidays from 'date-holidays';
-// Constants
const MS_IN_A_DAY = 86400000;
const MAX_GAP_LENGTH = 5;
-// Helper function to check if a date is a weekend
-const isWeekend = (date: Date): boolean => date.getDay() === 0 || date.getDay() === 6;
-
-// Helper function to check if two dates are the same day
-const isSameDay = (date1: Date, date2: Date): boolean =>
- date1.getFullYear() === date2.getFullYear() &&
- date1.getMonth() === date2.getMonth() &&
- date1.getDate() === date2.getDate();
-
-// Helper function to generate a unique key for a date
+// Core date helper functions
const dateKey = (date: Date): string => `${date.getFullYear()}-${date.getMonth()}-${date.getDate()}`;
+const isWeekend = (date: Date, weekendDays: number[]): boolean => weekendDays.includes(date.getDay());
+const isHoliday = (date: Date, holidays: { date: Date }[]): boolean => holidays.some(h => dateKey(h.date) === dateKey(date));
+const daysBetween = (start: Date, end: Date): number => Math.round((end.getTime() - start.getTime()) / MS_IN_A_DAY);
-// Helper function to check if a date is a holiday
-const isHoliday = (date: Date, holidays: { date: Date }[]): boolean => holidays.some(h => isSameDay(h.date, date));
-
-// Helper function to check if a date is a day off
-const isDayOff = (date: Date, allDaysOffSet: Set
): boolean => allDaysOffSet.has(dateKey(date));
-
-// Helper function to calculate the number of days between two dates
-const daysBetween = (startDate: Date, endDate: Date): number => Math.round((endDate.getTime() - startDate.getTime()) / MS_IN_A_DAY);
-
-// Helper function to format a date
-const formatDate = (date: Date): string => date.toLocaleDateString('en-US', { month: 'short', day: 'numeric' });
-
-// Get holidays for a specific year and country
+// Get holidays for a year, handling multi-day holidays and timezone differences
export function getHolidaysForYear(countryCode: string, year: number, stateCode?: string): { date: Date; name: string }[] {
- // The date-holidays lib has translations for many holidays, but defaults to using the language of the country.
- // We can pass in the browser's preferred languages (though the lib doesn't fall back, e.g. from `de-AT` to `de`)
- const languages = navigator.languages.map(lang => lang.split('-')[0]);
- // Start/end dates are returned in that country/state's time zone, so we need to provide our time zone to localise
- const opts = { languages, timezone: Intl.DateTimeFormat().resolvedOptions().timeZone };
+ // Use browser's languages and timezone to get localized holiday names
+ const opts = {
+ languages: navigator.languages.map(lang => lang.split('-')[0]),
+ timezone: Intl.DateTimeFormat().resolvedOptions().timeZone
+ };
const hd = stateCode ? new Holidays(countryCode, stateCode, opts) : new Holidays(countryCode, opts);
- console.log(hd.getHolidays(year));
+
return hd.getHolidays(year)
.filter(holiday => holiday.type === 'public')
- .flatMap(holiday =>
- // To handle single- and multi-day holidays, we generate a holiday entry for each day in the period
- Array.from({ length: daysBetween(holiday.start, holiday.end) }, (_, i) => ({
+ .flatMap(holiday => Array.from(
+ { length: daysBetween(holiday.start, holiday.end) },
+ (_, i) => ({
date: new Date(holiday.start.getFullYear(), holiday.start.getMonth(), holiday.start.getDate() + i),
name: holiday.name,
- }))
- )
- .sort((holiday1, holiday2) => holiday1.date.getTime() - holiday2.date.getTime() || holiday1.name.localeCompare(holiday2.name));
+ })
+ ))
+ .sort((a, b) => a.date.getTime() - b.date.getTime() || a.name.localeCompare(b.name));
}
-// Optimize days off to create the longest possible chains
-export function optimizeDaysOff(holidays: { date: Date }[], year: number, daysOff: number): Date[] {
- const currentYearHolidays = holidays.filter(h => h.date.getFullYear() === year);
- const weekends = getWeekends(year);
- const allDaysOffSet = new Set([
- ...currentYearHolidays.map(h => dateKey(h.date)),
- ...weekends.map(d => dateKey(d))
+// Find optimal placement of PTO days to maximize consecutive time off
+export function optimizeDaysOff(holidays: { date: Date }[], year: number, daysOff: number, weekendDays: number[] = [0, 6]): Date[] {
+ const allDaysOff = new Set([
+ ...holidays.filter(h => h.date.getFullYear() === year).map(h => dateKey(h.date)),
+ ...getWeekends(year, weekendDays).map(d => dateKey(d))
]);
- let rankedGaps = rankGapsByEfficiency(findGaps(allDaysOffSet, year), allDaysOffSet);
-
- return selectDaysOff(rankedGaps, daysOff, allDaysOffSet, year);
+ const gaps = findGaps(allDaysOff, year, weekendDays);
+ return selectDaysOff(rankGapsByEfficiency(gaps, allDaysOff, weekendDays), daysOff, allDaysOff, weekendDays);
}
-// Calculate consecutive days off
-export function calculateConsecutiveDaysOff(holidays: { date: Date }[], optimizedDaysOff: Date[], year: number): { startDate: Date; endDate: Date; usedDaysOff: number; totalDays: number }[] {
- const allDaysOffSet = new Set([...holidays.map(h => dateKey(h.date)), ...optimizedDaysOff.map(d => dateKey(d))]);
- const consecutiveDaysOff: { startDate: Date; endDate: Date; usedDaysOff: number; totalDays: number }[] = [];
- let currentGroup: Date[] = [];
-
- for (let month = 0; month < 12; month++) {
- for (let day = 1; day <= 31; day++) {
- const date = new Date(year, month, day);
- if (date.getMonth() !== month) break;
+// Calculate periods of consecutive days off (weekends + holidays + PTO)
+export function calculateConsecutiveDaysOff(holidays: { date: Date }[], optimizedDaysOff: Date[], year: number, weekendDays: number[] = [0, 6]) {
+ const allDaysOff = new Set([
+ ...holidays.map(h => dateKey(h.date)),
+ ...optimizedDaysOff.map(d => dateKey(d)),
+ ...getWeekends(year, weekendDays).map(d => dateKey(d))
+ ]);
- if (isWeekend(date) || isHoliday(date, holidays) || isDayOff(date, allDaysOffSet)) {
- currentGroup.push(date);
- } else {
- if (currentGroup.length > 2) {
- addConsecutiveDaysOff(consecutiveDaysOff, currentGroup, optimizedDaysOff);
- }
- currentGroup = [];
+ const consecutiveDaysOff = [];
+ let currentGroup = [];
+
+ for (let d = new Date(year, 0, 1); d <= new Date(year, 11, 31); d.setDate(d.getDate() + 1)) {
+ if (isWeekend(d, weekendDays) || isHoliday(d, holidays) || allDaysOff.has(dateKey(d))) {
+ currentGroup.push(new Date(d));
+ } else if (currentGroup.length > 0) {
+ if (hasWeekendAndNonWeekendHoliday(currentGroup, weekendDays, holidays, optimizedDaysOff)) {
+ consecutiveDaysOff.push(createPeriod(currentGroup, optimizedDaysOff));
}
+ currentGroup = [];
}
}
- if (currentGroup.length > 2) {
- addConsecutiveDaysOff(consecutiveDaysOff, currentGroup, optimizedDaysOff);
+ if (currentGroup.length > 0 && hasWeekendAndNonWeekendHoliday(currentGroup, weekendDays, holidays, optimizedDaysOff)) {
+ consecutiveDaysOff.push(createPeriod(currentGroup, optimizedDaysOff));
}
return consecutiveDaysOff;
}
-// Get all weekends for a specific year
-function getWeekends(year: number): Date[] {
- const weekends: Date[] = [];
- for (let month = 0; month < 12; month++) {
- for (let day = 1; day <= 31; day++) {
- const date = new Date(year, month, day);
- if (date.getMonth() !== month) break;
- if (isWeekend(date)) weekends.push(date);
+// Get all weekend days for a year
+function getWeekends(year: number, weekendDays: number[]): Date[] {
+ const weekends = [];
+ for (let d = new Date(year, 0, 1); d <= new Date(year, 11, 31); d.setDate(d.getDate() + 1)) {
+ if (d.getMonth() === d.getMonth() && isWeekend(d, weekendDays)) {
+ weekends.push(new Date(d));
}
}
return weekends;
}
-// Find gaps between days off
-function findGaps(allDaysOffSet: Set, year: number): { start: Date; end: Date; gapLength: number }[] {
- const gaps: { start: Date; end: Date; gapLength: number }[] = [];
- let currentGapStart: Date | null = null;
+// Find gaps between days off that could be filled with PTO
+function findGaps(allDaysOff: Set, year: number, weekendDays: number[]) {
+ const gaps = [];
+ let gapStart = null;
- for (let month = 0; month < 12; month++) {
- for (let day = 1; day <= 31; day++) {
- const date = new Date(year, month, day);
- if (date.getMonth() !== month) break;
-
- const isDayOff = allDaysOffSet.has(dateKey(date));
-
- if (!isDayOff && !isWeekend(date)) {
- if (!currentGapStart) currentGapStart = date;
- } else if (currentGapStart) {
- const gapLength = daysBetween(currentGapStart, date);
- if (gapLength > 0 && gapLength <= MAX_GAP_LENGTH) {
- gaps.push({ start: currentGapStart, end: new Date(date.getTime() - MS_IN_A_DAY), gapLength });
- }
- currentGapStart = null;
+ for (let d = new Date(year, 0, 1); d <= new Date(year, 11, 31); d.setDate(d.getDate() + 1)) {
+ if (!allDaysOff.has(dateKey(d)) && !isWeekend(d, weekendDays)) {
+ if (!gapStart) gapStart = new Date(d);
+ } else if (gapStart) {
+ const gapLength = daysBetween(gapStart, d);
+ if (gapLength > 0 && gapLength <= MAX_GAP_LENGTH) {
+ gaps.push({ start: gapStart, end: new Date(d.getTime() - MS_IN_A_DAY), gapLength });
}
+ gapStart = null;
}
}
-
- if (currentGapStart) {
- const lastDayOfYear = new Date(year, 11, 31);
- const gapLength = daysBetween(currentGapStart, lastDayOfYear) + 1;
- if (gapLength > 0 && gapLength <= MAX_GAP_LENGTH) {
- gaps.push({ start: currentGapStart, end: lastDayOfYear, gapLength });
- }
- }
-
return gaps;
}
-// Rank gaps by efficiency
-function rankGapsByEfficiency(gaps: { start: Date; end: Date; gapLength: number }[], allDaysOffSet: Set): any[] {
- return gaps.map(gap => {
- const backward = calculateChain(gap.start, gap.gapLength, allDaysOffSet, 'backward');
- const forward = calculateChain(gap.end, gap.gapLength, allDaysOffSet, 'forward');
-
- return forward.chainLength > backward.chainLength || (forward.chainLength === backward.chainLength && forward.usedDaysOff <= backward.usedDaysOff)
- ? { ...gap, ...forward, fillFrom: 'end' }
- : { ...gap, ...backward, fillFrom: 'start' };
- }).sort((a, b) => a.gapLength - b.gapLength || b.chainLength - a.chainLength || a.usedDaysOff - b.usedDaysOff);
+// Rank gaps by how efficiently they can be used to create longer periods off
+function rankGapsByEfficiency(gaps: any[], allDaysOff: Set, weekendDays: number[]) {
+ return gaps
+ .map(gap => {
+ const [backward, forward] = ['backward', 'forward'].map(direction =>
+ calculateChain(direction === 'backward' ? gap.start : gap.end, gap.gapLength, allDaysOff, direction as 'backward' | 'forward', weekendDays)
+ );
+ return forward.chainLength > backward.chainLength ||
+ (forward.chainLength === backward.chainLength && forward.usedDaysOff <= backward.usedDaysOff)
+ ? { ...gap, ...forward, fillFrom: 'end' }
+ : { ...gap, ...backward, fillFrom: 'start' };
+ })
+ .sort((a, b) => a.gapLength - b.gapLength || b.chainLength - a.chainLength || a.usedDaysOff - b.usedDaysOff);
}
-// Calculate potential chain length and days off used
-function calculateChain(startDate: Date, gapLength: number, allDaysOffSet: Set, direction: 'backward' | 'forward'): { chainLength: number; usedDaysOff: number } {
- let chainLength = gapLength;
- let usedDaysOff = 0;
- let currentDate = new Date(startDate);
-
+// Calculate potential chain length in either direction from a gap
+function calculateChain(date: Date, gapLength: number, allDaysOff: Set, direction: 'backward' | 'forward', weekendDays: number[]) {
const increment = direction === 'backward' ? -1 : 1;
- const boundaryCheck = direction === 'backward' ? -MS_IN_A_DAY : MS_IN_A_DAY;
-
- while (allDaysOffSet.has(dateKey(new Date(currentDate.getTime() + boundaryCheck))) || isWeekend(new Date(currentDate.getTime() + boundaryCheck))) {
+ let chainLength = gapLength;
+ let currentDate = new Date(date);
+
+ while (allDaysOff.has(dateKey(new Date(currentDate.getTime() + MS_IN_A_DAY * increment))) ||
+ isWeekend(new Date(currentDate.getTime() + MS_IN_A_DAY * increment), weekendDays)) {
chainLength++;
currentDate.setDate(currentDate.getDate() + increment);
}
- for (let i = 0; i < gapLength; i++) {
- const potentialDayOff = new Date(startDate);
- potentialDayOff.setDate(potentialDayOff.getDate() + (i * increment));
- if (!allDaysOffSet.has(dateKey(potentialDayOff)) && !isWeekend(potentialDayOff)) {
- usedDaysOff++;
- }
- }
-
- return { chainLength, usedDaysOff };
+ return {
+ chainLength,
+ usedDaysOff: Array.from({ length: gapLength }, (_, i) => {
+ const d = new Date(date);
+ d.setDate(d.getDate() + i * increment);
+ return !allDaysOff.has(dateKey(d)) && !isWeekend(d, weekendDays);
+ }).filter(Boolean).length
+ };
}
-// Select days off based on ranked gaps
-function selectDaysOff(rankedGaps: any[], daysOff: number, allDaysOffSet: Set, year: number): Date[] {
- const selectedDays: Date[] = [];
-
- while (daysOff > 0 && rankedGaps.length > 0) {
- const gap = rankedGaps.shift();
+// Select optimal days off based on ranked gaps
+function selectDaysOff(rankedGaps: any[], daysOff: number, allDaysOff: Set, weekendDays: number[]): Date[] {
+ const selectedDays = [];
+ let remainingDays = daysOff;
+ for (const gap of rankedGaps) {
+ if (remainingDays <= 0) break;
+
const increment = gap.fillFrom === 'start' ? 1 : -1;
const startDate = gap.fillFrom === 'start' ? gap.start : gap.end;
- for (let i = 0; i < gap.gapLength && daysOff > 0; i++) {
- const potentialDayOff = new Date(startDate);
- potentialDayOff.setDate(potentialDayOff.getDate() + (i * increment));
-
- if (!allDaysOffSet.has(dateKey(potentialDayOff)) && !isWeekend(potentialDayOff)) {
- selectedDays.push(potentialDayOff);
- allDaysOffSet.add(dateKey(potentialDayOff));
- daysOff--;
+ for (let i = 0; i < gap.gapLength && remainingDays > 0; i++) {
+ const day = new Date(startDate);
+ day.setDate(day.getDate() + (i * increment));
+
+ if (!allDaysOff.has(dateKey(day)) && !isWeekend(day, weekendDays)) {
+ selectedDays.push(day);
+ remainingDays--;
}
}
-
- const newGaps = findGaps(allDaysOffSet, year);
- rankedGaps = rankGapsByEfficiency(newGaps, allDaysOffSet);
}
return selectedDays;
}
-// Add consecutive days off to the list
-function addConsecutiveDaysOff(consecutiveDaysOff: { startDate: Date; endDate: Date; usedDaysOff: number; totalDays: number }[], currentGroup: Date[], optimizedDaysOff: Date[]) {
- const startDate = currentGroup[0];
- const endDate = currentGroup[currentGroup.length - 1];
- const totalDays = daysBetween(startDate, endDate) + 1;
- const usedDaysOff = currentGroup.filter(d => isDayOff(d, new Set(optimizedDaysOff.map(d => dateKey(d))))).length;
+// Check if a group contains both a weekend day and a non-weekend holiday/PTO day
+function hasWeekendAndNonWeekendHoliday(group: Date[], weekendDays: number[], holidays: { date: Date }[], optimizedDaysOff: Date[]) {
+ return group.some(d => weekendDays.includes(d.getDay())) &&
+ group.some(d => !weekendDays.includes(d.getDay()) && (isHoliday(d, holidays) || optimizedDaysOff.some(od => dateKey(od) === dateKey(d))));
+}
- if (totalDays > 2) {
- consecutiveDaysOff.push({
- startDate,
- endDate,
- usedDaysOff,
- totalDays
- });
- }
+// Create a period object from a group of consecutive days
+function createPeriod(group: Date[], optimizedDaysOff: Date[]) {
+ return {
+ startDate: group[0],
+ endDate: group[group.length - 1],
+ totalDays: daysBetween(group[0], group[group.length - 1]) + 1,
+ usedDaysOff: group.filter(d => optimizedDaysOff.some(od => dateKey(od) === dateKey(d))).length
+ };
}
\ No newline at end of file
diff --git a/src/routes/+page.svelte b/src/routes/+page.svelte
index 60415fd..be864f2 100644
--- a/src/routes/+page.svelte
+++ b/src/routes/+page.svelte
@@ -1,7 +1,5 @@
@@ -632,37 +711,74 @@
- {#if showHolidaysList}
+ {#if showHolidaysList || showWeekendSettings}
-
Public Holidays
-
- {#each holidays as holiday}
- -
-
-
- {formatDate(holiday.date)}: {holiday.name}
-
-
-
- {/each}
-
+ {#if showHolidaysList}
+
+ {/if}
+
+ {#if showWeekendSettings}
+
+
Weekend Days
+
+ {#each getOrderedDays() as {name, index}}
+ -
+
+
+ {name}
+
+
+
+ {/each}
+
+
+ {/if}