chuvsu-js 4.2.0 → 5.0.0

package/dist/tt/domain/schedule.d.ts

@@ -0,0 +1,37 @@
+import { AcademicPeriod } from "../../common/types.js";
+import { type Holiday, type HolidayTransfer } from "../utils/index.js";
+import { TimetableRepository } from "./repository.js";
+import type { LessonOccurrence, LessonSeries, ScheduleOwner } from "./types.js";
+export interface ScheduleQueryOptions {
+    subgroup?: number;
+}
+export interface ScheduleWeekdayOptions extends ScheduleQueryOptions {
+    week?: number;
+}
+export interface ScheduleOptions {
+    period?: AcademicPeriod;
+    holidays?: Holiday[] | null;
+    holidayTransfers?: HolidayTransfer[];
+}
+export declare class Schedule {
+    readonly repository: TimetableRepository;
+    readonly owner: ScheduleOwner;
+    readonly academicYearStartYear: number;
+    readonly period: AcademicPeriod;
+    readonly holidays: Holiday[];
+    readonly holidayTransfers: HolidayTransfer[];
+    constructor(repository: TimetableRepository, owner: ScheduleOwner, academicYearStartYear: number, options?: ScheduleOptions);
+    get revision(): number;
+    series(): LessonSeries[];
+    on(date: Date, options?: ScheduleQueryOptions): LessonOccurrence[];
+    week(week?: number, options?: ScheduleQueryOptions): LessonOccurrence[];
+    weekday(weekday: number, options?: ScheduleWeekdayOptions): LessonOccurrence[];
+    today(options?: ScheduleQueryOptions): LessonOccurrence[];
+    tomorrow(options?: ScheduleQueryOptions): LessonOccurrence[];
+    thisWeek(options?: ScheduleQueryOptions): LessonOccurrence[];
+    current(options?: ScheduleQueryOptions): LessonOccurrence | null;
+    getWeekNumber(date?: Date): number;
+    getSemesterWeeks(weekCount?: number): import("../types.js").SemesterWeek[];
+    getSemesterStart(): Date;
+    private isInAcademicYear;
+}

package/dist/tt/domain/schedule.js

@@ -0,0 +1,292 @@
+import { AcademicPeriod } from "../../common/types.js";
+import { getAdjacentSemester, getCurrentPeriod, getMonday, getSemesterStart, getSemesterWeeks, getWeekNumber, formatLocalDate, isHoliday, parseLocalDate, RUSSIAN_HOLIDAYS, } from "../utils/index.js";
+import { occurrenceIdForSeries } from "./ids.js";
+import { entityKey, normalizeScheduleText } from "./normalize.js";
+function dateAt(date, time) {
+    const value = new Date(date);
+    value.setHours(time.hours, time.minutes, 0, 0);
+    return value;
+}
+function semesterCalendarYear(series) {
+    return series.period === AcademicPeriod.FallSemester
+        ? series.academicYearStartYear
+        : series.academicYearStartYear + 1;
+}
+function recurrenceIncludes(series, date) {
+    if (date.getDay() !== series.recurrence.weekday)
+        return null;
+    const week = getWeekNumber({
+        period: series.period,
+        year: semesterCalendarYear(series),
+        date,
+    });
+    const from = series.recurrence.weeks?.from ?? 1;
+    const to = series.recurrence.weeks?.to ?? 17;
+    if (week < from || week > to)
+        return null;
+    if (series.recurrence.parity === "even" && week % 2 !== 0)
+        return null;
+    if (series.recurrence.parity === "odd" && week % 2 === 0)
+        return null;
+    return week;
+}
+function attendanceMatchesSubgroup(groups, owner, subgroup) {
+    if (subgroup == null)
+        return true;
+    if (owner.type === "group") {
+        const ownerKey = entityKey(owner.group);
+        const attendance = groups.filter((value) => entityKey(value.group) === ownerKey);
+        return attendance.some((value) => value.subgroup == null || value.subgroup === subgroup);
+    }
+    return groups.some((value) => value.subgroup == null || value.subgroup === subgroup);
+}
+function occurrenceMatchesOwner(occurrence, owner) {
+    if (owner.type === "group") {
+        const key = entityKey(owner.group);
+        return occurrence.groups.values.some((value) => entityKey(value.group) === key);
+    }
+    if (owner.type === "teacher") {
+        const key = entityKey(owner.teacher);
+        return occurrence.teachers.values.some((value) => entityKey(value) === key);
+    }
+    const key = entityKey(owner.room);
+    return occurrence.rooms.values.some((value) => entityKey(value) === key);
+}
+function attendanceOverlaps(left, right) {
+    if (left.length === 0 || right.length === 0)
+        return undefined;
+    return left.some((leftValue) => right.some((rightValue) => entityKey(leftValue.group) === entityKey(rightValue.group) &&
+        (leftValue.subgroup == null ||
+            rightValue.subgroup == null ||
+            leftValue.subgroup === rightValue.subgroup)));
+}
+function sortOccurrences(left, right) {
+    return (left.scheduledDate.localeCompare(right.scheduledDate) ||
+        ((left.time?.start.hours ?? 24) * 60 + (left.time?.start.minutes ?? 0)) -
+            ((right.time?.start.hours ?? 24) * 60 + (right.time?.start.minutes ?? 0)) ||
+        (left.slotNumber ?? Number.MAX_SAFE_INTEGER) -
+            (right.slotNumber ?? Number.MAX_SAFE_INTEGER) ||
+        left.subject.localeCompare(right.subject) ||
+        left.id.localeCompare(right.id));
+}
+export class Schedule {
+    repository;
+    owner;
+    academicYearStartYear;
+    period;
+    holidays;
+    holidayTransfers;
+    constructor(repository, owner, academicYearStartYear, options) {
+        this.repository = repository;
+        this.owner = structuredClone(owner);
+        this.academicYearStartYear = academicYearStartYear;
+        this.period = options?.period ?? getCurrentPeriod();
+        this.holidays = structuredClone(options?.holidays ?? RUSSIAN_HOLIDAYS);
+        this.holidayTransfers = (options?.holidayTransfers ?? []).map((value) => ({
+            dayOff: new Date(value.dayOff),
+            workDay: value.workDay == null ? null : new Date(value.workDay),
+        }));
+    }
+    get revision() {
+        return this.repository.revision;
+    }
+    series() {
+        return this.repository.getSeries({
+            owner: this.owner,
+            academicYearStartYear: this.academicYearStartYear,
+        });
+    }
+    on(date, options) {
+        if (!this.isInAcademicYear(date))
+            return [];
+        const holiday = isHoliday(date, this.holidays, this.holidayTransfers);
+        const localDate = formatLocalDate(date);
+        const direct = this.repository.getDirectOccurrences({
+            owner: this.owner,
+            academicYearStartYear: this.academicYearStartYear,
+        });
+        const movedSources = direct
+            .filter((value) => value.movedFrom)
+            .map((value) => ({
+            date: value.movedFrom.date,
+            slotNumber: value.movedFrom.slotNumber,
+            subject: value.subject,
+            groups: value.groups.values,
+        }));
+        const occurrences = [];
+        for (const series of this.series()) {
+            if (holiday)
+                continue;
+            const week = recurrenceIncludes(series, date);
+            if (week == null)
+                continue;
+            if (movedSources.some((source) => source.date === localDate &&
+                source.slotNumber === series.slotNumber &&
+                normalizeScheduleText(source.subject) ===
+                    normalizeScheduleText(series.subject) &&
+                attendanceOverlaps(source.groups, series.groups.values) !== false)) {
+                continue;
+            }
+            let rooms = series.rooms;
+            let teachers = series.teachers;
+            let isDistance = series.isDistance;
+            let originalRooms;
+            let originalTeachers;
+            const substitution = series.substitutions.find((value) => value.date === localDate);
+            if (substitution?.rooms) {
+                originalRooms = rooms;
+                rooms = { values: substitution.rooms, completeness: "complete" };
+            }
+            if (substitution?.teachers) {
+                originalTeachers = teachers;
+                teachers = { values: substitution.teachers, completeness: "complete" };
+            }
+            if (substitution?.isDistance != null) {
+                isDistance = substitution.isDistance;
+            }
+            const occurrence = {
+                id: occurrenceIdForSeries(series.id, week),
+                seriesId: series.id,
+                academicYearStartYear: series.academicYearStartYear,
+                period: series.period,
+                academicWeek: week,
+                nominalDate: localDate,
+                scheduledDate: localDate,
+                subject: series.subject,
+                type: series.type,
+                slotNumber: series.slotNumber,
+                time: series.time,
+                groups: series.groups,
+                teachers,
+                rooms,
+                isDistance,
+                possibleChanges: series.possibleChanges,
+                status: "scheduled",
+                originalRooms,
+                originalTeachers,
+                sources: series.sources,
+            };
+            if (occurrenceMatchesOwner(occurrence, this.owner) &&
+                attendanceMatchesSubgroup(occurrence.groups.values, this.owner, options?.subgroup)) {
+                occurrences.push(occurrence);
+            }
+        }
+        for (const occurrence of direct) {
+            if (occurrence.scheduledDate !== localDate)
+                continue;
+            if (!occurrenceMatchesOwner(occurrence, this.owner))
+                continue;
+            if (!attendanceMatchesSubgroup(occurrence.groups.values, this.owner, options?.subgroup)) {
+                continue;
+            }
+            occurrences.push(occurrence);
+        }
+        return occurrences.sort(sortOccurrences);
+    }
+    week(week, options) {
+        const period = this.period === AcademicPeriod.WinterSession ||
+            this.period === AcademicPeriod.SummerSession
+            ? getAdjacentSemester(this.period)
+            : this.period;
+        const year = period === AcademicPeriod.FallSemester
+            ? this.academicYearStartYear
+            : this.academicYearStartYear + 1;
+        let monday;
+        if (week != null) {
+            if (!Number.isInteger(week) || week < 1) {
+                throw new RangeError("Academic week must be a positive integer");
+            }
+            const data = getSemesterWeeks({ period, year, weekCount: week }).find((value) => value.week === week);
+            if (!data)
+                return [];
+            monday = data.start;
+        }
+        else {
+            monday = getMonday(new Date());
+        }
+        const result = [];
+        for (let day = 0; day < 7; day++) {
+            const date = new Date(monday);
+            date.setDate(monday.getDate() + day);
+            result.push(...this.on(date, options));
+        }
+        return result.sort(sortOccurrences);
+    }
+    weekday(weekday, options) {
+        if (!Number.isInteger(weekday) || weekday < 0 || weekday > 6) {
+            throw new RangeError("Weekday must be an integer from 0 to 6");
+        }
+        if (options?.week != null) {
+            return this.week(options.week, options).filter((value) => parseLocalDate(value.scheduledDate).getDay() === weekday);
+        }
+        const now = new Date();
+        const date = new Date(now);
+        date.setDate(now.getDate() + weekday - now.getDay());
+        date.setHours(0, 0, 0, 0);
+        return this.on(date, options);
+    }
+    today(options) {
+        return this.on(new Date(), options);
+    }
+    tomorrow(options) {
+        const date = new Date();
+        date.setDate(date.getDate() + 1);
+        return this.on(date, options);
+    }
+    thisWeek(options) {
+        return this.week(undefined, options);
+    }
+    current(options) {
+        const now = new Date();
+        return (this.on(now, options).find((value) => {
+            if (!value.time)
+                return false;
+            const start = dateAt(now, value.time.start);
+            const end = dateAt(now, value.time.end);
+            return now >= start && now <= end;
+        }) ?? null);
+    }
+    getWeekNumber(date) {
+        const period = this.period === AcademicPeriod.WinterSession ||
+            this.period === AcademicPeriod.SummerSession
+            ? getAdjacentSemester(this.period)
+            : this.period;
+        return getWeekNumber({
+            period,
+            year: period === AcademicPeriod.FallSemester
+                ? this.academicYearStartYear
+                : this.academicYearStartYear + 1,
+            date,
+        });
+    }
+    getSemesterWeeks(weekCount) {
+        const period = this.period === AcademicPeriod.WinterSession ||
+            this.period === AcademicPeriod.SummerSession
+            ? getAdjacentSemester(this.period)
+            : this.period;
+        return getSemesterWeeks({
+            period,
+            year: period === AcademicPeriod.FallSemester
+                ? this.academicYearStartYear
+                : this.academicYearStartYear + 1,
+            weekCount,
+        });
+    }
+    getSemesterStart() {
+        const period = this.period === AcademicPeriod.WinterSession ||
+            this.period === AcademicPeriod.SummerSession
+            ? getAdjacentSemester(this.period)
+            : this.period;
+        return getSemesterStart({
+            period,
+            year: period === AcademicPeriod.FallSemester
+                ? this.academicYearStartYear
+                : this.academicYearStartYear + 1,
+        });
+    }
+    isInAcademicYear(date) {
+        const start = new Date(this.academicYearStartYear, 8, 1);
+        const end = new Date(this.academicYearStartYear + 1, 7, 31, 23, 59, 59, 999);
+        return date >= start && date <= end;
+    }
+}

package/dist/tt/domain/types.d.ts

@@ -0,0 +1,175 @@
+import type { AcademicPeriod, LocalDate, TimeRange, WeekRange } from "../../common/types.js";
+export type LessonSeriesId = string;
+export type LessonId = string;
+export interface NamedEntityRef {
+    id?: number;
+    name: string;
+}
+export interface GroupRef extends NamedEntityRef {
+    specialty?: string;
+    profile?: string;
+}
+export interface TeacherRef extends NamedEntityRef {
+    position?: string;
+    degree?: string;
+}
+export interface RoomRef extends NamedEntityRef {
+    building?: string;
+}
+export interface GroupAttendance {
+    group: GroupRef;
+    subgroup?: number;
+}
+export type ScheduleOwner = {
+    type: "group";
+    group: GroupRef;
+} | {
+    type: "teacher";
+    teacher: TeacherRef;
+} | {
+    type: "room";
+    room: RoomRef;
+};
+export type RelationCompleteness = "unknown" | "partial" | "complete";
+export interface RelationSet<T> {
+    values: T[];
+    completeness: RelationCompleteness;
+}
+export interface LessonRecurrence {
+    weekday: number;
+    weeks?: WeekRange;
+    parity?: "even" | "odd";
+}
+export interface LessonSubstitution {
+    date: LocalDate;
+    rooms?: RoomRef[];
+    teachers?: TeacherRef[];
+    isDistance?: boolean;
+}
+export interface LessonTransfer {
+    fromDate: LocalDate;
+    fromSlot: number;
+    targetDate: LocalDate;
+}
+export interface LessonSourceRef {
+    sourceKey: string;
+    observationKey: string;
+    observedAt: Date;
+    owner: ScheduleOwner;
+}
+export interface LessonSeries {
+    id: LessonSeriesId;
+    academicYearStartYear: number;
+    period: AcademicPeriod;
+    subject: string;
+    type: string;
+    slotNumber?: number;
+    time?: TimeRange;
+    recurrence: LessonRecurrence;
+    groups: RelationSet<GroupAttendance>;
+    teachers: RelationSet<TeacherRef>;
+    rooms: RelationSet<RoomRef>;
+    isDistance: boolean;
+    possibleChanges: boolean;
+    substitutions: LessonSubstitution[];
+    sources: LessonSourceRef[];
+}
+export type LessonStatus = "scheduled" | "moved" | "cancelled";
+export interface LessonOccurrence {
+    id: LessonId;
+    seriesId?: LessonSeriesId;
+    academicYearStartYear: number;
+    period: AcademicPeriod;
+    academicWeek?: number;
+    nominalDate: LocalDate;
+    scheduledDate: LocalDate;
+    subject: string;
+    type: string;
+    slotNumber?: number;
+    time?: TimeRange;
+    groups: RelationSet<GroupAttendance>;
+    teachers: RelationSet<TeacherRef>;
+    rooms: RelationSet<RoomRef>;
+    isDistance: boolean;
+    possibleChanges: boolean;
+    status: LessonStatus;
+    movedFrom?: {
+        date: LocalDate;
+        slotNumber?: number;
+    };
+    originalRooms?: RelationSet<RoomRef>;
+    originalTeachers?: RelationSet<TeacherRef>;
+    sources: LessonSourceRef[];
+}
+interface ObservationBase {
+    /** Stable only inside one source page projection. */
+    key: string;
+    subject: string;
+    type: string;
+    slotNumber?: number;
+    time?: TimeRange;
+    groups: RelationSet<GroupAttendance>;
+    teachers: RelationSet<TeacherRef>;
+    rooms: RelationSet<RoomRef>;
+    isDistance?: boolean;
+    possibleChanges?: boolean;
+    substitutions?: LessonSubstitution[];
+}
+export interface SeriesObservation extends ObservationBase {
+    kind: "series";
+    recurrence: LessonRecurrence;
+}
+export interface OccurrenceObservation extends ObservationBase {
+    kind: "occurrence";
+    date: LocalDate;
+    transfer?: LessonTransfer;
+}
+export type ScheduleObservation = SeriesObservation | OccurrenceObservation;
+export interface ScheduleSourceSnapshot {
+    sourceKey: string;
+    owner: ScheduleOwner;
+    academicYearStartYear: number;
+    period: AcademicPeriod;
+    observedAt: Date;
+    observations: ScheduleObservation[];
+}
+export interface IngestResult {
+    revision: number;
+    seriesIds: LessonSeriesId[];
+    lessonIds: LessonId[];
+    created: number;
+    updated: number;
+    removedObservations: number;
+}
+export interface SerializedScheduleSourceSnapshot extends Omit<ScheduleSourceSnapshot, "observedAt" | "observations"> {
+    observedAt: string;
+    observations: SerializedScheduleObservation[];
+}
+export type SerializedScheduleObservation = ScheduleObservation;
+export interface TimetableRepositorySnapshot {
+    schemaVersion: 5;
+    revision: number;
+    directory: TimetableDirectorySnapshot;
+    sources: SerializedScheduleSourceSnapshot[];
+    links: Array<{
+        sourceKey: string;
+        observationKey: string;
+        kind: "series" | "occurrence";
+        id: string;
+    }>;
+}
+export interface TimetableDirectorySnapshot {
+    groups: GroupRef[];
+    teachers: TeacherRef[];
+    rooms: RoomRef[];
+}
+export interface TimetableRepositoryAdapter {
+    load(): Promise<TimetableRepositorySnapshot | null>;
+    compareAndSet(expectedRevision: number, snapshot: TimetableRepositorySnapshot): Promise<boolean>;
+    clear?(): Promise<void>;
+}
+export interface LessonIdGenerator {
+    seriesId(): LessonSeriesId;
+    lessonId(): LessonId;
+}
+export {};

package/dist/tt/domain/types.js

@@ -0,0 +1 @@
+export {};

package/dist/tt/observations.d.ts

@@ -0,0 +1,11 @@
+import type { ParsedScheduleDay } from "./types.js";
+import type { ScheduleOwner, ScheduleSourceSnapshot } from "./domain/types.js";
+export interface CreateScheduleSnapshotOptions {
+    sourceKey: string;
+    owner: ScheduleOwner;
+    academicYearStartYear: number;
+    period: ScheduleSourceSnapshot["period"];
+    observedAt?: Date;
+    days: ParsedScheduleDay[];
+}
+export declare function createScheduleSourceSnapshot(options: CreateScheduleSnapshotOptions): ScheduleSourceSnapshot;

package/dist/tt/observations.js

@@ -0,0 +1,131 @@
+import { parseLocalDate } from "./utils/index.js";
+const WEEKDAY_INDEX = new Map([
+    ["воскресенье", 0],
+    ["понедельник", 1],
+    ["вторник", 2],
+    ["среда", 3],
+    ["четверг", 4],
+    ["пятница", 5],
+    ["суббота", 6],
+]);
+function teacherRef(value) {
+    if (!value.name)
+        return null;
+    return { ...value };
+}
+function relationSet(values, explicitlyEmpty = false) {
+    return {
+        values: values ?? [],
+        completeness: explicitlyEmpty ? "complete" : values?.length ? "partial" : "unknown",
+    };
+}
+function groupsFor(entry, owner) {
+    const visible = entry.groups?.map((name) => ({
+        group: { name },
+        subgroup: entry.subgroup,
+    })) ?? [];
+    const groups = relationSet(visible, entry.groups === null || Array.isArray(entry.groups) && entry.groups.length === 0);
+    if (owner.type === "group") {
+        groups.values.unshift({ group: owner.group, subgroup: entry.subgroup });
+        if (groups.completeness === "unknown")
+            groups.completeness = "partial";
+    }
+    return groups;
+}
+function teachersFor(entry, owner) {
+    const teacher = entry.teacher ? teacherRef(entry.teacher) : null;
+    const teachers = relationSet(teacher ? [teacher] : undefined, entry.teacher === null);
+    if (owner.type === "teacher") {
+        teachers.values.unshift(owner.teacher);
+        if (teachers.completeness === "unknown")
+            teachers.completeness = "partial";
+    }
+    return teachers;
+}
+function roomsFor(entry, owner) {
+    const rooms = relationSet(entry.room ? [{ name: entry.room }] : undefined, entry.room === null);
+    if (owner.type === "room") {
+        rooms.values.unshift(owner.room);
+        if (rooms.completeness === "unknown")
+            rooms.completeness = "partial";
+    }
+    return rooms;
+}
+function substitutionsFor(substitutions) {
+    if (!substitutions?.length)
+        return undefined;
+    return substitutions.map((value) => ({
+        date: value.date,
+        rooms: value.room ? [{ name: value.room }] : undefined,
+        teachers: value.teacher
+            ? [teacherRef(value.teacher)].filter((teacher) => teacher != null)
+            : undefined,
+        isDistance: value.isDistance,
+    }));
+}
+function observationBase(key, entry, block, owner) {
+    return {
+        key,
+        subject: entry.subject,
+        type: entry.type,
+        slotNumber: block.slotNumber,
+        time: block.time,
+        groups: groupsFor(entry, owner),
+        teachers: teachersFor(entry, owner),
+        rooms: roomsFor(entry, owner),
+        isDistance: entry.isDistance,
+        possibleChanges: entry.possibleChanges,
+        substitutions: substitutionsFor(entry.substitutions),
+    };
+}
+function occurrenceFrom(key, entry, block, date, owner) {
+    return {
+        kind: "occurrence",
+        ...observationBase(key, entry, block, owner),
+        date,
+        transfer: entry.transfer
+            ? {
+                fromDate: entry.transfer.fromDate,
+                fromSlot: entry.transfer.fromSlot,
+                targetDate: entry.transfer.targetDate,
+            }
+            : undefined,
+    };
+}
+function seriesFrom(key, entry, block, weekday, owner) {
+    return {
+        kind: "series",
+        ...observationBase(key, entry, block, owner),
+        recurrence: {
+            weekday,
+            weeks: entry.weeks,
+            parity: entry.weekParity,
+        },
+    };
+}
+export function createScheduleSourceSnapshot(options) {
+    const observations = [];
+    for (const [dayIndex, day] of options.days.entries()) {
+        const weekday = (day.date ? parseLocalDate(day.date).getDay() : undefined) ??
+            WEEKDAY_INDEX.get(day.weekday.toLowerCase());
+        if (weekday == null)
+            continue;
+        for (const [blockIndex, block] of day.blocks.entries()) {
+            for (const [lessonIndex, entry] of block.lessons.entries()) {
+                const key = `day:${dayIndex}:block:${blockIndex}:lesson:${lessonIndex}`;
+                const directDate = entry.transfer?.targetDate ?? entry.substituteFor?.date ?? day.date;
+                observations.push(directDate
+                    ? occurrenceFrom(key, entry, block, directDate, options.owner)
+                    : seriesFrom(key, entry, block, weekday, options.owner));
+            }
+        }
+    }
+    return {
+        sourceKey: options.sourceKey,
+        owner: options.owner,
+        academicYearStartYear: options.academicYearStartYear,
+        period: options.period,
+        observedAt: options.observedAt ?? new Date(),
+        observations,
+    };
+}

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

@@ -1,3 +1,3 @@
-import type { AudienceInfo, FullScheduleDay } from "../types.js";
-export declare function parseAudienceInfo(html: string): AudienceInfo | null;
-export declare function parseAudienceFullSchedule(html: string): FullScheduleDay[];
+import type { RoomInfo, ParsedScheduleDay } from "../types.js";
+export declare function parseRoomInfo(html: string): RoomInfo | null;
+export declare function parseRoomSchedule(html: string): ParsedScheduleDay[];