chuvsu-js 2.8.1 → 3.0.0

package/dist/tt/parse/overlays.js

@@ -0,0 +1,104 @@
+import { parseTeacher, text } from "../../common/parse.js";
+import { parseGroupsString } from "./groups.js";
+export function parseDate(dd, mm, yyyy) {
+    return new Date(parseInt(yyyy), parseInt(mm) - 1, parseInt(dd));
+}
+export function parseTransferDiv(div) {
+    const divText = text(div);
+    const divHtml = div.innerHTML ?? "";
+    const m = divText.match(/(\d{2})\.(\d{2})\.(\d{4})\s*перенос\s*c\s*(\d{2})\.(\d{2})\.(\d{4})\s*\((\d+)\s*пара\)/);
+    if (!m)
+        return null;
+    const targetDate = parseDate(m[1], m[2], m[3]);
+    const fromDate = parseDate(m[4], m[5], m[6]);
+    const fromSlot = parseInt(m[7]);
+    const subjectEl = div.querySelector('span[style*="color: blue"]');
+    const subject = subjectEl ? text(subjectEl) : "";
+    if (!subject)
+        return null;
+    const roomMatch = divHtml.match(/([А-Яа-яA-Za-z]-\d+)/);
+    const typeMatch = divText.match(/\((лк|пр|лб|зач|экз|зчО|кр|конс)\)/);
+    // Teacher: last text line that isn't a subgroup marker
+    const parts = divHtml.split(/<br\s*\/?>/);
+    let teacherPart = "";
+    for (let i = parts.length - 1; i >= 0; i--) {
+        const clean = parts[i].replace(/<[^>]*>/g, "").trim();
+        if (clean && !/подгруппа/.test(clean)) {
+            teacherPart = clean;
+            break;
+        }
+    }
+    const transfer = { targetDate, fromDate, fromSlot, subject };
+    const subgroupMatch = divText.match(/(\d+)\s*подгруппа/);
+    return {
+        transfer,
+        entry: {
+            room: roomMatch?.[1] ?? "",
+            subject,
+            type: typeMatch?.[1] ?? "",
+            weeks: { from: 0, to: 0 },
+            teacher: parseTeacher(teacherPart),
+            groups: [],
+            subgroup: subgroupMatch ? parseInt(subgroupMatch[1]) : undefined,
+            transfer,
+        },
+    };
+}
+export function parseSubstitutionDiv(div) {
+    const divText = text(div);
+    const divHtml = div.innerHTML ?? "";
+    const m = divText.match(/(\d{2})\.(\d{2})\.(\d{4})\s*замена\s*на:/);
+    if (!m)
+        return null;
+    const date = parseDate(m[1], m[2], m[3]);
+    let room;
+    let teacher;
+    const roomMatch = divHtml.match(/Аудитория:\s*<span[^>]*>([^<]+)<\/span>/);
+    if (roomMatch)
+        room = roomMatch[1].trim();
+    const teacherMatch = divHtml.match(/Преподаватель:\s*<span[^>]*>([^<]+)<\/span>/);
+    if (teacherMatch)
+        teacher = parseTeacher(teacherMatch[1].trim());
+    return { date, room, teacher };
+}
+export function parseSubstituteForDiv(div) {
+    const divText = text(div);
+    const divHtml = div.innerHTML ?? "";
+    const m = divText.match(/(\d{2})\.(\d{2})\.(\d{4})\s*замена\s*вместо:/);
+    if (!m)
+        return null;
+    const date = parseDate(m[1], m[2], m[3]);
+    // Original teacher: first blue span (right after "замена вместо:")
+    const origTeacherMatch = divHtml.match(/замена\s*вместо:\s*<\/b><\/span>\s*<span[^>]*>([^<]+)<\/span>/);
+    const originalTeacher = origTeacherMatch
+        ? parseTeacher(origTeacherMatch[1].trim())
+        : { name: "" };
+    // Subject: second blue span
+    const subjectEl = div.querySelectorAll('span[style*="color: blue"]');
+    let subject = "";
+    for (const el of subjectEl) {
+        const t = text(el);
+        if (t && t !== origTeacherMatch?.[1]?.trim()) {
+            subject = t;
+            break;
+        }
+    }
+    if (!subject)
+        return null;
+    const roomMatch = divHtml.match(/(?:<br\s*\/?>)\s*([А-Яа-яA-Za-z]-\d+)/);
+    const typeMatch = divText.match(/\((лк|пр|лб|зач|экз|зчО|кр|конс)\)/);
+    const groupsMatch = divHtml.match(/\((?:лк|пр|лб|зач|экз|зчО|кр|конс)\)\s*(?:<br\s*\/?>)\s*([^<]+?)(?:\s*<i|$)/);
+    const subgroupMatch = divText.match(/(\d+)\s*подгруппа/);
+    return {
+        entry: {
+            room: roomMatch?.[1] ?? "",
+            subject,
+            type: typeMatch?.[1] ?? "",
+            weeks: { from: 0, to: 0 },
+            teacher: { name: "" },
+            groups: parseGroupsString(groupsMatch?.[1]),
+            subgroup: subgroupMatch ? parseInt(subgroupMatch[1]) : undefined,
+            substituteFor: { date, originalTeacher },
+        },
+    };
+}

package/dist/tt/parse/teacher.d.ts

@@ -0,0 +1,4 @@
+import { EducationType } from "../../common/types.js";
+import type { FullScheduleDay, TeacherInfo } from "../types.js";
+export declare function parseTeacherFullSchedule(html: string, educationType?: EducationType): FullScheduleDay[];
+export declare function parseTeacherInfo(html: string): TeacherInfo | null;

package/dist/tt/parse/teacher.js

@@ -0,0 +1,166 @@
+import { parseHtml, parseTime, parseWeekParity, parseWeeks, text, } from "../../common/parse.js";
+import { getLessonNumber } from "../utils/index.js";
+import { parseSemesterScheduleWith } from "./full-schedule.js";
+import { parseGroupsString } from "./groups.js";
+import { parseSubstituteForDiv, parseSubstitutionDiv, parseTransferDiv, } from "./overlays.js";
+export function parseTeacherFullSchedule(html, educationType) {
+    const doc = parseHtml(html);
+    const edType = educationType ?? 1 /* EducationType.HigherEducation */;
+    if (doc.querySelector('td[id^="trd2"]')) {
+        return parseTeacherSessionSchedule(doc, edType);
+    }
+    return parseSemesterScheduleWith(doc, parseTeacherSemesterEntry);
+}
+function parseTeacherSemesterEntry(el) {
+    const td = el.querySelector("td") ?? el;
+    const fullHtml = td.innerHTML ?? "";
+    const plainText = text(td);
+    if (!plainText)
+        return null;
+    const possibleChanges = (td.getAttribute("class") ?? "").includes("want") || undefined;
+    const redDivs = td.querySelectorAll('div[style*="border: 2px solid red"]');
+    for (const div of redDivs) {
+        const result = parseTransferDiv(div);
+        if (result) {
+            if (possibleChanges)
+                result.entry.possibleChanges = true;
+            return result.entry;
+        }
+    }
+    // "замена вместо:" (substitute lesson for another teacher)
+    for (const div of redDivs) {
+        const result = parseSubstituteForDiv(div);
+        if (result) {
+            if (possibleChanges)
+                result.entry.possibleChanges = true;
+            return result.entry;
+        }
+    }
+    const substitutions = [];
+    for (const div of redDivs) {
+        const sub = parseSubstitutionDiv(div);
+        if (sub)
+            substitutions.push(sub);
+    }
+    let cleanHtml = fullHtml;
+    let cleanText = plainText;
+    for (const div of redDivs) {
+        cleanHtml = cleanHtml.replace(div.outerHTML ?? "", "");
+        cleanText = cleanText.replace(text(div), "");
+    }
+    const subjectEl = td.querySelector('span[style*="color: blue"]');
+    const subject = subjectEl ? text(subjectEl) : "";
+    if (!subject)
+        return null;
+    const typeMatch = cleanText.match(/\((лк|пр|лб|зач|экз|зчО|кр|конс)\)/);
+    const weeksMatch = cleanText.match(/\(([^)]*нед\.?[^)]*)\)/);
+    const roomMatch = cleanHtml.match(/(?:<sup>[^<]*<\/sup>)?([А-Яа-яA-Za-z]-\d+)/);
+    const groupsMatch = cleanHtml.match(/<br\s*\/?>\s*([^<]+?)(?:<br|<\/td|<div|<i|$)/);
+    const subgroupMatch = cleanText.match(/(\d+)\s*подгруппа/);
+    const weekParity = parseWeekParity(cleanHtml);
+    return {
+        room: roomMatch?.[1] ?? "",
+        subject,
+        type: typeMatch?.[1] ?? "",
+        weeks: parseWeeks(weeksMatch?.[1] ?? ""),
+        teacher: { name: "" },
+        groups: parseGroupsString(groupsMatch?.[1]),
+        subgroup: subgroupMatch ? parseInt(subgroupMatch[1]) : undefined,
+        weekParity,
+        substitutions: substitutions.length > 0 ? substitutions : undefined,
+        possibleChanges,
+    };
+}
+function parseTeacherSessionSchedule(doc, educationType) {
+    const days = [];
+    for (const dateCell of doc.querySelectorAll('td[id^="trd2"]')) {
+        const id = dateCell.getAttribute("id") ?? "";
+        const dateMatch = id.match(/trd(\d{4})(\d{2})(\d{2})/);
+        if (!dateMatch)
+            continue;
+        const year = parseInt(dateMatch[1]);
+        const month = parseInt(dateMatch[2]) - 1;
+        const dayNum = parseInt(dateMatch[3]);
+        const date = new Date(year, month, dayNum);
+        const cellHtml = dateCell.innerHTML ?? "";
+        const brMatch = cellHtml.match(/<br\s*\/?>\s*(.+)/i);
+        const weekday = brMatch ? brMatch[1].trim() : "";
+        const row = dateCell.parentElement;
+        if (!row)
+            continue;
+        const dataCell = row.querySelector("td.trdata:not(.trfd)");
+        if (!dataCell)
+            continue;
+        const slots = [];
+        for (const entryRow of dataCell.querySelectorAll("table tr")) {
+            const td = entryRow.querySelector("td") ?? entryRow;
+            const entry = parseTeacherSessionEntry(td);
+            if (!entry)
+                continue;
+            slots.push({
+                number: getLessonNumber(entry.timeStart, educationType),
+                timeStart: entry.timeStart,
+                timeEnd: entry.timeEnd,
+                entries: [entry.entry],
+            });
+        }
+        if (slots.length > 0) {
+            days.push({ weekday, date, slots });
+        }
+    }
+    return days;
+}
+function parseTeacherSessionEntry(td) {
+    const fullHtml = td.innerHTML ?? "";
+    const plainText = text(td);
+    if (!plainText)
+        return null;
+    const subjectEl = td.querySelector('span[style*="color: blue"]');
+    const subject = subjectEl ? text(subjectEl) : "";
+    if (!subject)
+        return null;
+    const roomMatch = fullHtml.match(/^([^<]*?)\s*<span/);
+    const room = roomMatch ? roomMatch[1].trim() : "";
+    const typeMatch = plainText.match(/\((лк|пр|лб|зач|экз|зчО|кр|конс\.?|Экз)\)/i);
+    const type = typeMatch ? typeMatch[1].replace(/\.$/, "").toLowerCase() : "";
+    // Groups: text between </span> type and <br>time
+    const groupsMatch = fullHtml.match(/\((?:лк|пр|лб|зач|экз|зчО|кр|конс\.?|Экз)\)\s*([^<]+?)\s*<br/i);
+    const timeMatch = fullHtml.match(/<br\s*\/?>\s*(\d{2}:\d{2})\s*-\s*(\d{2}:\d{2})/);
+    if (!timeMatch)
+        return null;
+    return {
+        entry: {
+            room,
+            subject,
+            type,
+            weeks: { from: 0, to: 0 },
+            teacher: { name: "" },
+            groups: parseGroupsString(groupsMatch?.[1]),
+        },
+        timeStart: parseTime(timeMatch[1]),
+        timeEnd: parseTime(timeMatch[2]),
+    };
+}
+export function parseTeacherInfo(html) {
+    const doc = parseHtml(html);
+    const nameEl = doc.querySelector(".htextb");
+    if (!nameEl)
+        return null;
+    const nameHtml = nameEl.innerHTML ?? "";
+    const nameMatch = nameHtml.match(/^([^<]+)/);
+    const name = nameMatch?.[1]?.trim() ?? "";
+    if (!name)
+        return null;
+    const degreeEl = nameEl.querySelector('span[style*="color: blue"]');
+    const degree = degreeEl ? text(degreeEl).trim() : undefined;
+    const deptEl = doc.querySelector(".htext");
+    const department = deptEl ? text(deptEl).trim() : undefined;
+    const photoImg = doc.querySelector("#photosrc");
+    const photoUrl = photoImg?.getAttribute("src") || undefined;
+    return {
+        name,
+        degree: degree || undefined,
+        department: department || undefined,
+        photoUrl,
+    };
+}

package/dist/tt/schedule.d.ts

@@ -1,6 +1,6 @@
 import type { FullScheduleDay, SemesterWeek, Lesson } from "./types.js";
 import { Period, EducationType } from "../common/types.js";
-import { type Holiday, type HolidayTransfer } from "./utils.js";
+import { type Holiday, type HolidayTransfer } from "./utils/index.js";
 export declare class Schedule {
     readonly groupId: number;
     readonly scheduleMap: Map<number, FullScheduleDay[]>;
@@ -23,7 +23,6 @@ export declare class Schedule {
     getDays(period: Period): FullScheduleDay[];
     private getSlotsForWeekday;
     private getDateForWeekday;
-    private static isSameDay;
     forDay(weekday: number, opts?: {
         subgroup?: number;
         week?: number;

package/dist/tt/schedule.js

@@ -1,4 +1,4 @@
-import { getCurrentPeriod, isSessionPeriod, getWeekdayName, getMonday, getSemesterStart, getSemesterWeeks, getWeekNumber, getAdjacentSemester, filterSlots, slotsToLessons, sortLessons, isHoliday, collectTransfers, suppressTransferredLessons, RUSSIAN_HOLIDAYS, } from "./utils.js";
+import { collectTransfers, filterSlots, getAdjacentSemester, getCurrentPeriod, getMonday, getSemesterStart, getSemesterWeeks, getWeekNumber, getWeekdayName, isHoliday, isSameDay, isSessionPeriod, RUSSIAN_HOLIDAYS, slotsToLessons, sortLessons, suppressTransferredLessons, } from "./utils/index.js";
 export class Schedule {
     groupId;
     scheduleMap;
@@ -60,12 +60,6 @@ export class Schedule {
         date.setHours(0, 0, 0, 0);
         return date;
     }
-    // --- Session helpers (date-based) ---
-    static isSameDay(a, b) {
-        return (a.getFullYear() === b.getFullYear() &&
-            a.getMonth() === b.getMonth() &&
-            a.getDate() === b.getDate());
-    }
     // --- Public query methods ---
     forDay(weekday, opts) {
         const period = this.period;
@@ -93,7 +87,7 @@ export class Schedule {
         // 1. Check all periods for date-based (session) entries matching this date
         for (const [, d] of this.scheduleMap) {
             for (const day of d) {
-                if (day.date && Schedule.isSameDay(day.date, date)) {
+                if (day.date && isSameDay(day.date, date)) {
                     lessons.push(...slotsToLessons(day.slots, date, { isTeacherSchedule: this.isTeacherSchedule }));
                 }
             }

package/dist/tt/types.d.ts

@@ -68,8 +68,13 @@ export interface ScheduleEntry {
     type: string;
     weeks: WeekRange;
     teacher: Teacher;
-    /** For teacher schedules: group names (e.g. "КТ-42-25 (1 подгруппа)"). */
-    groups?: string;
+    /**
+     * Group names for this lesson (e.g. `["КТ-42-25 (АихС)", "КТ-41-25"]`).
+     * Parenthesized annotations that are part of the group name are preserved;
+     * service markers like "(N подгруппа)" are stripped and moved to {@link ScheduleEntry.subgroup}.
+     * Empty array if no groups are listed.
+     */
+    groups: string[];
     subgroup?: number;
     weekParity?: "even" | "odd";
     /** Date-specific substitutions (замена на). */
@@ -110,8 +115,8 @@ export interface Lesson {
     type: string;
     room: string;
     teacher: Teacher;
-    /** For teacher schedules: group names. */
-    groups?: string;
+    /** Group names for this lesson. See {@link ScheduleEntry.groups}. */
+    groups: string[];
     weeks: WeekRange;
     subgroup?: number;
     weekParity?: "even" | "odd";
@@ -147,6 +152,7 @@ export interface CacheConfig {
     teacherInfo?: number;
     teacherPhotos?: number;
     audienceInfo?: number;
+    audienceImages?: number;
 }
 export interface TtClientOptions {
     educationType?: EducationType;

package/dist/tt/utils/date.d.ts

@@ -0,0 +1,5 @@
+export declare function getWeekdayName(weekday: number): string;
+/** Monday of the week containing `date` (at 00:00 local time). */
+export declare function getMonday(date: Date): Date;
+/** True if `a` and `b` fall on the same calendar day (local time). */
+export declare function isSameDay(a: Date, b: Date): boolean;

package/dist/tt/utils/date.js

@@ -0,0 +1,27 @@
+const WEEKDAY_NAMES = [
+    "Воскресенье",
+    "Понедельник",
+    "Вторник",
+    "Среда",
+    "Четверг",
+    "Пятница",
+    "Суббота",
+];
+export function getWeekdayName(weekday) {
+    return WEEKDAY_NAMES[weekday] ?? "";
+}
+/** Monday of the week containing `date` (at 00:00 local time). */
+export function getMonday(date) {
+    const d = new Date(date);
+    const day = d.getDay();
+    const diff = day === 0 ? -6 : 1 - day;
+    d.setDate(d.getDate() + diff);
+    d.setHours(0, 0, 0, 0);
+    return d;
+}
+/** True if `a` and `b` fall on the same calendar day (local time). */
+export function isSameDay(a, b) {
+    return (a.getFullYear() === b.getFullYear() &&
+        a.getMonth() === b.getMonth() &&
+        a.getDate() === b.getDate());
+}

package/dist/tt/{utils.d.ts → utils/holidays.d.ts}

@@ -1,55 +1,5 @@
-import type { FullScheduleDay, FullScheduleSlot, ScheduleEntry, SemesterWeek, Lesson, LessonTimeSlot } from "./types.js";
-import { Period, EducationType } from "../common/types.js";
-import type { Time } from "../common/types.js";
-export declare function getCurrentPeriod(opts?: {
-    date?: Date;
-}): Period;
-export declare function isSessionPeriod(period: Period): boolean;
-export declare function sortLessons(a: Lesson, b: Lesson): number;
-export declare function getWeekdayName(weekday: number): string;
-export declare function getMonday(date: Date): Date;
-/**
- * Get the start date of a semester.
- * Fall: September 1 of the given year.
- * Spring: first Monday of February of the given year.
- */
-export declare function getSemesterStart(opts: {
-    period: Period;
-    year?: number;
-}): Date;
-/**
- * Get all weeks in a semester with their start/end dates.
- * Week 0 starts from the semester start date.
- */
-export declare function getSemesterWeeks(opts: {
-    period: Period;
-    year?: number;
-    weekCount?: number;
-}): SemesterWeek[];
-/**
- * Get the current week number within a semester.
- */
-export declare function getWeekNumber(opts: {
-    period: Period;
-    date?: Date;
-}): number;
-export declare function filterSlots(slots: FullScheduleSlot[], opts?: {
-    subgroup?: number;
-    week?: number;
-    date?: Date;
-}): FullScheduleSlot[];
-export declare function slotsToLessons(slots: FullScheduleSlot[], date: Date, opts?: {
-    isTeacherSchedule?: boolean;
-}): Lesson[];
-/** Collect all transfer entries from schedule days. */
-export declare function collectTransfers(days: FullScheduleDay[]): ScheduleEntry[];
-/** Remove lessons whose source date/slot match a transfer. */
-export declare function suppressTransferredLessons(lessons: Lesson[], transfers: ScheduleEntry[], date: Date): Lesson[];
-export declare function getTimeSlots(educationType: EducationType): LessonTimeSlot[];
-export declare function getLessonNumber(time: Time, educationType: EducationType): number;
-export declare function getAdjacentSemester(session: Period): Period;
 export interface Holiday {
-    /** Month number, 1–12. */
+    /** Month number, 1-12. */
     month: number;
     /** Day of month. */
     day: number;
@@ -75,7 +25,7 @@ export declare const RUSSIAN_HOLIDAYS: Holiday[];
  * 1. All holidays in the list are non-working days.
  * 2. For non-January holidays: if a holiday falls on Sat/Sun, the day off
  *    automatically transfers to the next working day.
- * 3. For January holidays (1–8): weekend transfers are NOT automatic —
+ * 3. For January holidays (1-8): weekend transfers are NOT automatic —
  *    they are decided by annual government decree. Pass them via `transfers`.
  * 4. Bridge days: if a non-January holiday falls on Tue, Mon is day off
  *    (preceding Sat works); if on Thu, Fri is day off (following Sat works).
@@ -87,17 +37,17 @@ export declare const RUSSIAN_HOLIDAYS: Holiday[];
  */
 export declare function getEffectiveHolidays(year: number, holidays?: Holiday[], transfers?: HolidayTransfer[], sixDayWeek?: boolean): Date[];
 /**
- * Compute all transfers (auto bridges + explicit) for a given year.
+ * All transfers (auto bridges + explicit) for a given year.
  * Useful for getting compensating work days (Saturdays that become working).
  */
 export declare function getHolidayTransfers(year: number, holidays: Holiday[] | undefined, transfers: HolidayTransfer[] | undefined, sixDayWeek: boolean): HolidayTransfer[];
 /**
- * Returns the list of compensating work days (e.g. Saturdays that become working).
+ * List of compensating work days (e.g. Saturdays that become working).
  * Includes both auto-computed bridge compensations and explicit transfers.
  */
 export declare function getCompensatingWorkDays(year: number, holidays: Holiday[] | undefined, transfers: HolidayTransfer[] | undefined, sixDayWeek: boolean): Date[];
 /**
- * Returns true if the given date is a non-working holiday,
+ * True if the given date is a non-working holiday,
  * including transferred holidays when they fall on weekends (Art. 112 ТК РФ)
  * and auto-computed bridge days.
  * Pass an empty array for `holidays` to disable holiday checking.

package/dist/tt/utils/holidays.js

@@ -0,0 +1,197 @@
+import { isSameDay } from "./date.js";
+/** Russian non-working public holidays (Статья 112 ТК РФ). */
+export const RUSSIAN_HOLIDAYS = [
+    { month: 1, day: 1, name: "Новый год" },
+    { month: 1, day: 2, name: "Новогодние каникулы" },
+    { month: 1, day: 3, name: "Новогодние каникулы" },
+    { month: 1, day: 4, name: "Новогодние каникулы" },
+    { month: 1, day: 5, name: "Новогодние каникулы" },
+    { month: 1, day: 6, name: "Новогодние каникулы" },
+    { month: 1, day: 7, name: "Рождество Христово" },
+    { month: 1, day: 8, name: "Новогодние каникулы" },
+    { month: 2, day: 23, name: "День защитника Отечества" },
+    { month: 3, day: 8, name: "Международный женский день" },
+    { month: 5, day: 1, name: "Праздник Весны и Труда" },
+    { month: 5, day: 9, name: "День Победы" },
+    { month: 6, day: 12, name: "День России" },
+    { month: 11, day: 4, name: "День народного единства" },
+];
+/**
+ * January holiday dates (1-8) are excluded from automatic weekend transfer
+ * per Art. 112 ТК РФ. Their transfers are decided by government decree.
+ */
+function isJanuaryHoliday(h) {
+    return h.month === 1 && h.day >= 1 && h.day <= 8;
+}
+/**
+ * Bridge-day transfers for non-January holidays.
+ *
+ * Pattern (consistent across government decrees):
+ * - Holiday on Tuesday -> Monday becomes day off, preceding Saturday is work day
+ * - Holiday on Thursday -> Friday becomes day off, following Saturday is work day
+ *   (only for 5-day week; 6-day week has Saturday classes, so no gap to bridge)
+ *
+ * January holidays are excluded (their 2 transfers are unpredictable).
+ */
+function computeBridgeDays(year, holidays, effectiveDays, sixDayWeek) {
+    const bridges = [];
+    for (const h of holidays) {
+        if (isJanuaryHoliday(h))
+            continue;
+        const date = new Date(year, h.month - 1, h.day);
+        const dow = date.getDay();
+        if (dow === 2) {
+            // Tuesday -> Monday off, preceding Saturday works
+            const monday = new Date(date);
+            monday.setDate(date.getDate() - 1);
+            const saturday = new Date(date);
+            saturday.setDate(date.getDate() - 3);
+            if (!effectiveDays.some((d) => isSameDay(d, monday))) {
+                bridges.push({
+                    dayOff: monday,
+                    workDay: sixDayWeek ? null : saturday,
+                });
+            }
+        }
+        else if (dow === 4 && !sixDayWeek) {
+            // Thursday -> Friday off, following Saturday works
+            // Only for 5-day week: 6-day week has no gap (Saturday is a work day)
+            const friday = new Date(date);
+            friday.setDate(date.getDate() + 1);
+            const saturday = new Date(date);
+            saturday.setDate(date.getDate() + 2);
+            if (!effectiveDays.some((d) => isSameDay(d, friday))) {
+                bridges.push({ dayOff: friday, workDay: saturday });
+            }
+        }
+    }
+    return bridges;
+}
+/**
+ * Compute effective non-working holiday dates for a given year.
+ *
+ * Rules (Art. 112 ТК РФ):
+ * 1. All holidays in the list are non-working days.
+ * 2. For non-January holidays: if a holiday falls on Sat/Sun, the day off
+ *    automatically transfers to the next working day.
+ * 3. For January holidays (1-8): weekend transfers are NOT automatic —
+ *    they are decided by annual government decree. Pass them via `transfers`.
+ * 4. Bridge days: if a non-January holiday falls on Tue, Mon is day off
+ *    (preceding Sat works); if on Thu, Fri is day off (following Sat works).
+ *    Computed automatically, can be overridden via `transfers`.
+ * 5. Government decree transfers (`transfers`) add extra days off and
+ *    override auto-computed bridge days.
+ * 6. For 6-day week (`sixDayWeek`): Saturday is a work day, so
+ *    Thursday bridges don't apply and Saturday holidays don't auto-transfer.
+ */
+export function getEffectiveHolidays(year, holidays = RUSSIAN_HOLIDAYS, transfers = [], sixDayWeek = true) {
+    const originalDates = holidays.map((h) => new Date(year, h.month - 1, h.day));
+    const isOriginalHoliday = (d) => originalDates.some((od) => isSameDay(od, d));
+    const effectiveDays = [...originalDates];
+    // Auto-transfer: only non-January holidays that fall on weekends
+    const nonJanuaryOnWeekend = holidays
+        .filter((h) => !isJanuaryHoliday(h))
+        .map((h) => new Date(year, h.month - 1, h.day))
+        .filter((d) => d.getDay() === 0 || d.getDay() === 6)
+        .sort((a, b) => a.getTime() - b.getTime());
+    for (const holiday of nonJanuaryOnWeekend) {
+        let candidate = new Date(holiday);
+        if (candidate.getDay() === 6) {
+            candidate.setDate(candidate.getDate() + 2);
+        }
+        else {
+            candidate.setDate(candidate.getDate() + 1);
+        }
+        while (candidate.getDay() === 0 ||
+            candidate.getDay() === 6 ||
+            isOriginalHoliday(candidate) ||
+            effectiveDays.some((ed) => isSameDay(ed, candidate))) {
+            candidate.setDate(candidate.getDate() + 1);
+        }
+        effectiveDays.push(new Date(candidate));
+    }
+    // Bridge days (auto-computed, can be overridden)
+    const autoBridges = computeBridgeDays(year, holidays, effectiveDays, sixDayWeek);
+    // Merge: explicit transfers override auto-computed bridges
+    const allTransfers = [...autoBridges];
+    for (const t of transfers) {
+        const idx = allTransfers.findIndex((b) => isSameDay(b.dayOff, t.dayOff));
+        if (idx !== -1) {
+            allTransfers[idx] = t;
+        }
+        else {
+            allTransfers.push(t);
+        }
+    }
+    for (const t of allTransfers) {
+        if (!effectiveDays.some((d) => isSameDay(d, t.dayOff))) {
+            effectiveDays.push(t.dayOff);
+        }
+    }
+    return effectiveDays.sort((a, b) => a.getTime() - b.getTime());
+}
+/**
+ * All transfers (auto bridges + explicit) for a given year.
+ * Useful for getting compensating work days (Saturdays that become working).
+ */
+export function getHolidayTransfers(year, holidays = RUSSIAN_HOLIDAYS, transfers = [], sixDayWeek) {
+    const originalDates = holidays.map((h) => new Date(year, h.month - 1, h.day));
+    const effectiveDays = [...originalDates];
+    // Replay weekend transfers to build effectiveDays for bridge computation
+    const nonJanuaryOnWeekend = holidays
+        .filter((h) => !isJanuaryHoliday(h))
+        .map((h) => new Date(year, h.month - 1, h.day))
+        .filter((d) => d.getDay() === 0 || d.getDay() === 6)
+        .sort((a, b) => a.getTime() - b.getTime());
+    const isOriginalHoliday = (d) => originalDates.some((od) => isSameDay(od, d));
+    for (const holiday of nonJanuaryOnWeekend) {
+        let candidate = new Date(holiday);
+        if (candidate.getDay() === 6) {
+            candidate.setDate(candidate.getDate() + 2);
+        }
+        else {
+            candidate.setDate(candidate.getDate() + 1);
+        }
+        while (candidate.getDay() === 0 ||
+            candidate.getDay() === 6 ||
+            isOriginalHoliday(candidate) ||
+            effectiveDays.some((ed) => isSameDay(ed, candidate))) {
+            candidate.setDate(candidate.getDate() + 1);
+        }
+        effectiveDays.push(new Date(candidate));
+    }
+    const autoBridges = computeBridgeDays(year, holidays, effectiveDays, sixDayWeek);
+    const allTransfers = [...autoBridges];
+    for (const t of transfers) {
+        const idx = allTransfers.findIndex((b) => isSameDay(b.dayOff, t.dayOff));
+        if (idx !== -1) {
+            allTransfers[idx] = t;
+        }
+        else {
+            allTransfers.push(t);
+        }
+    }
+    return allTransfers;
+}
+/**
+ * List of compensating work days (e.g. Saturdays that become working).
+ * Includes both auto-computed bridge compensations and explicit transfers.
+ */
+export function getCompensatingWorkDays(year, holidays = RUSSIAN_HOLIDAYS, transfers = [], sixDayWeek) {
+    return getHolidayTransfers(year, holidays, transfers, sixDayWeek)
+        .filter((t) => t.workDay != null)
+        .map((t) => t.workDay);
+}
+/**
+ * True if the given date is a non-working holiday,
+ * including transferred holidays when they fall on weekends (Art. 112 ТК РФ)
+ * and auto-computed bridge days.
+ * Pass an empty array for `holidays` to disable holiday checking.
+ */
+export function isHoliday(date, holidays = RUSSIAN_HOLIDAYS, transfers = [], sixDayWeek = true) {
+    if (holidays.length === 0 && transfers.length === 0)
+        return false;
+    const year = date.getFullYear();
+    const effectiveDays = getEffectiveHolidays(year, holidays, transfers, sixDayWeek);
+    return effectiveDays.some((d) => isSameDay(d, date));
+}