Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
158 lines
5.9 KiB
TypeScript
158 lines
5.9 KiB
TypeScript
// Feiertage Schleswig-Holstein und Arbeitstage des Betriebs.
|
||
// Regel aus V70: gearbeitet wird Montag bis Donnerstag. Freitag ist immer frei
|
||
// (Büro, Aufräumen, Reserve), Wochenende und Feiertage zählen nicht.
|
||
|
||
import { type Datum, datum, plusTage, wochentag, jahrVon } from "./datum.js";
|
||
|
||
export interface Feiertag {
|
||
datum: Datum;
|
||
name: string;
|
||
}
|
||
|
||
/** Ostersonntag nach der Gaußschen Osterformel (gregorianisch, anonymer Algorithmus). */
|
||
export function ostersonntag(jahr: number): Datum {
|
||
const a = jahr % 19;
|
||
const b = Math.floor(jahr / 100);
|
||
const c = jahr % 100;
|
||
const d = Math.floor(b / 4);
|
||
const e = b % 4;
|
||
const f = Math.floor((b + 8) / 25);
|
||
const g = Math.floor((b - f + 1) / 3);
|
||
const h = (19 * a + b - d - g + 15) % 30;
|
||
const i = Math.floor(c / 4);
|
||
const k = c % 4;
|
||
const l = (32 + 2 * e + 2 * i - h - k) % 7;
|
||
const m = Math.floor((a + 11 * h + 22 * l) / 451);
|
||
const monat = Math.floor((h + l - 7 * m + 114) / 31);
|
||
const tag = ((h + l - 7 * m + 114) % 31) + 1;
|
||
return datum(jahr, monat, tag);
|
||
}
|
||
|
||
const cache = new Map<number, Feiertag[]>();
|
||
|
||
/** Gesetzliche Feiertage in Schleswig-Holstein. Reformationstag gilt seit 2018. */
|
||
export function feiertageSH(jahr: number): Feiertag[] {
|
||
const vorhanden = cache.get(jahr);
|
||
if (vorhanden) return vorhanden;
|
||
const ostern = ostersonntag(jahr);
|
||
const liste: Feiertag[] = [
|
||
{ datum: datum(jahr, 1, 1), name: "Neujahr" },
|
||
{ datum: plusTage(ostern, -2), name: "Karfreitag" },
|
||
{ datum: plusTage(ostern, 1), name: "Ostermontag" },
|
||
{ datum: datum(jahr, 5, 1), name: "Tag der Arbeit" },
|
||
{ datum: plusTage(ostern, 39), name: "Christi Himmelfahrt" },
|
||
{ datum: plusTage(ostern, 50), name: "Pfingstmontag" },
|
||
{ datum: datum(jahr, 10, 3), name: "Tag der Deutschen Einheit" },
|
||
...(jahr >= 2018 ? [{ datum: datum(jahr, 10, 31), name: "Reformationstag" }] : []),
|
||
{ datum: datum(jahr, 12, 25), name: "1. Weihnachtstag" },
|
||
{ datum: datum(jahr, 12, 26), name: "2. Weihnachtstag" },
|
||
];
|
||
liste.sort((x, y) => x.datum.localeCompare(y.datum));
|
||
cache.set(jahr, liste);
|
||
return liste;
|
||
}
|
||
|
||
export function feiertag(d: Datum): Feiertag | undefined {
|
||
return feiertageSH(jahrVon(d)).find((f) => f.datum === d);
|
||
}
|
||
|
||
export interface Arbeitswoche {
|
||
/** Wochentage 1 = Montag … 7 = Sonntag, an denen gearbeitet wird */
|
||
tage: number[];
|
||
/** einzelne zusätzliche Arbeitstage, z. B. ein freigegebener Freitag eines Vorgangs */
|
||
extra?: Datum[];
|
||
}
|
||
|
||
export const STANDARDWOCHE: Arbeitswoche = { tage: [1, 2, 3, 4] };
|
||
|
||
export function istArbeitstag(d: Datum, woche: Arbeitswoche = STANDARDWOCHE): boolean {
|
||
if (woche.extra?.includes(d)) return true;
|
||
return woche.tage.includes(wochentag(d)) && !feiertag(d);
|
||
}
|
||
|
||
/**
|
||
* Kalender eines Vorgangs (Henning, 21.10.2026): einzelne Freitage lassen sich je Vorgang freigeben; nur für diesen
|
||
* Vorgang zählen sie als Arbeitstag (Dauer, Ende, Auslastung, Einsätze), für alle anderen bleibt der Freitag Reserve.
|
||
*/
|
||
export function wocheVon(v: { freitage?: Datum[] | null }, woche: Arbeitswoche): Arbeitswoche {
|
||
return v.freitage?.length ? { tage: woche.tage, extra: [...(woche.extra ?? []), ...v.freitage] } : woche;
|
||
}
|
||
|
||
/** Bankarbeitstag (Mo–Fr ohne Feiertag), z. B. für Steuerfälligkeiten. Freitagsregel gilt hier nicht. */
|
||
export function istBankarbeitstag(d: Datum): boolean {
|
||
return wochentag(d) <= 5 && !feiertag(d);
|
||
}
|
||
|
||
/** Der Tag selbst, falls Arbeitstag, sonst der nächste Arbeitstag. */
|
||
export function naechsterArbeitstag(d: Datum, woche: Arbeitswoche = STANDARDWOCHE): Datum {
|
||
let x = d;
|
||
for (let i = 0; i < 400; i++) {
|
||
if (istArbeitstag(x, woche)) return x;
|
||
x = plusTage(x, 1);
|
||
}
|
||
throw new Error("Kein Arbeitstag gefunden");
|
||
}
|
||
|
||
export function naechsterBankarbeitstag(d: Datum): Datum {
|
||
let x = d;
|
||
while (!istBankarbeitstag(x)) x = plusTage(x, 1);
|
||
return x;
|
||
}
|
||
|
||
/**
|
||
* Verschiebt um n Arbeitstage (n darf negativ sein). Ausgangspunkt ist der Tag selbst;
|
||
* n = 0 liefert ihn unverändert.
|
||
*/
|
||
export function verschiebeArbeitstage(d: Datum, n: number, woche: Arbeitswoche = STANDARDWOCHE): Datum {
|
||
let x = d;
|
||
const schritt = n >= 0 ? 1 : -1;
|
||
let rest = Math.abs(n);
|
||
while (rest > 0) {
|
||
x = plusTage(x, schritt);
|
||
if (istArbeitstag(x, woche)) rest--;
|
||
}
|
||
return x;
|
||
}
|
||
|
||
const EPS = 1e-9;
|
||
|
||
/** Dauern in Vierteltagen (Henning, 22.10.2026: mehrere kleine Vorgänge an einem Tag) */
|
||
export const viertelTage = (x: number) => Math.round(x * 4) / 4;
|
||
export const istViertel = (x: number) => Math.abs(x * 4 - Math.round(x * 4)) < 1e-6;
|
||
|
||
/**
|
||
* Letzter Arbeitstag eines Vorgangs, der am Start (bzw. dem nächsten Arbeitstag) beginnt
|
||
* und `dauer` Arbeitstage dauert. Dauer 0 ist ein Meilenstein: Ende = Start. `teil` ist der Teil des
|
||
* ersten Tages, der schon vorher belegt ist (0, 0,25, 0,5 oder 0,75).
|
||
*/
|
||
export function endeNachDauer(start: Datum, dauer: number, woche: Arbeitswoche = STANDARDWOCHE, teil = 0): Datum {
|
||
if (!(dauer >= 0) || !istViertel(dauer)) throw new Error(`Ungültige Dauer: ${dauer}`);
|
||
const beginn = naechsterArbeitstag(start, woche);
|
||
if (dauer === 0) return beginn;
|
||
return verschiebeArbeitstage(beginn, Math.ceil(teil + dauer - EPS) - 1, woche);
|
||
}
|
||
|
||
/** Wie viel von jedem Arbeitstag ein Vorgang belegt (1 = ganzer Tag); ein Meilenstein belegt nichts */
|
||
export function tagesAnteile(start: Datum, dauer: number, woche: Arbeitswoche = STANDARDWOCHE, teil = 0): Map<Datum, number> {
|
||
const aus = new Map<Datum, number>();
|
||
let rest = dauer;
|
||
let d = naechsterArbeitstag(start, woche);
|
||
let frei = 1 - teil;
|
||
while (rest > EPS) {
|
||
const a = Math.min(frei, rest);
|
||
aus.set(d, a);
|
||
rest -= a;
|
||
frei = 1;
|
||
d = verschiebeArbeitstage(d, 1, woche);
|
||
}
|
||
return aus;
|
||
}
|
||
|
||
/** Anzahl Arbeitstage von `von` bis `bis`, beide eingeschlossen. 0, wenn bis vor von liegt. */
|
||
export function arbeitstageZwischen(von: Datum, bis: Datum, woche: Arbeitswoche = STANDARDWOCHE): number {
|
||
if (bis < von) return 0;
|
||
let n = 0;
|
||
for (let x = von; x <= bis; x = plusTage(x, 1)) if (istArbeitstag(x, woche)) n++;
|
||
return n;
|
||
}
|