chuvsu-js 4.2.0 → 5.0.0

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

@@ -0,0 +1,14 @@
+import type { GroupRef, RoomRef, TeacherRef, TimetableDirectorySnapshot } from "./types.js";
+export declare class TimetableDirectory {
+    private groups;
+    private teachers;
+    private rooms;
+    constructor(snapshot?: TimetableDirectorySnapshot);
+    rememberGroups(values: GroupRef[]): boolean;
+    rememberTeachers(values: TeacherRef[]): boolean;
+    rememberRooms(values: RoomRef[]): boolean;
+    resolveGroup(value: GroupRef): GroupRef;
+    resolveTeacher(value: TeacherRef): TeacherRef;
+    resolveRoom(value: RoomRef): RoomRef;
+    export(): TimetableDirectorySnapshot;
+}

package/dist/tt/domain/directory.js

@@ -0,0 +1,116 @@
+import { mergeEntityRefs, normalizeScheduleText, } from "./normalize.js";
+function personKey(name) {
+    const words = normalizeScheduleText(name)
+        .replace(/[.,]/gu, " ")
+        .split(/\s+/gu)
+        .filter(Boolean);
+    const surname = words[0] ?? "";
+    const initials = words
+        .slice(1)
+        .map((word) => word[0] ?? "")
+        .join("");
+    return `${surname}|${initials}`;
+}
+function exactKey(name) {
+    return normalizeScheduleText(name);
+}
+function validateRefs(values, label) {
+    for (const value of values) {
+        if (!value.name.trim())
+            throw new TypeError(`${label} name is empty`);
+        if (value.id != null &&
+            (!Number.isInteger(value.id) || value.id < 1)) {
+            throw new RangeError(`${label} ID must be a positive integer`);
+        }
+    }
+}
+function mergeByIdAndName(current, incoming) {
+    const values = mergeEntityRefs([...current, ...incoming]);
+    const before = JSON.stringify(current);
+    const after = JSON.stringify(values);
+    return { values, changed: before !== after };
+}
+function mergeTeachersByIdentity(current, incoming) {
+    const merged = mergeEntityRefs([...current, ...incoming]);
+    const identified = merged.filter((value) => value.id != null);
+    const unresolved = [];
+    for (const alias of merged.filter((value) => value.id == null)) {
+        const matches = identified
+            .map((value, index) => ({ value, index }))
+            .filter(({ value }) => personKey(value.name) === personKey(alias.name));
+        const ids = new Set(matches.map(({ value }) => value.id));
+        if (ids.size === 1) {
+            const match = matches[0];
+            identified[match.index] = { ...alias, ...match.value };
+        }
+        else {
+            unresolved.push(alias);
+        }
+    }
+    const values = mergeEntityRefs([...identified, ...unresolved]);
+    return {
+        values,
+        changed: JSON.stringify(current) !== JSON.stringify(values),
+    };
+}
+function resolveUnique(value, known, key) {
+    if (value.id != null) {
+        const byId = known.find((candidate) => candidate.id === value.id);
+        return byId ? mergeEntityRefs([value, byId])[0] : value;
+    }
+    const lookup = key(value.name);
+    const candidates = known.filter((candidate) => candidate.id != null && key(candidate.name) === lookup);
+    const ids = new Set(candidates.map((candidate) => candidate.id));
+    if (ids.size !== 1)
+        return value;
+    return mergeEntityRefs([value, candidates[0]])[0];
+}
+export class TimetableDirectory {
+    groups = [];
+    teachers = [];
+    rooms = [];
+    constructor(snapshot) {
+        if (snapshot) {
+            validateRefs(snapshot.groups, "Group");
+            validateRefs(snapshot.teachers, "Teacher");
+            validateRefs(snapshot.rooms, "Room");
+            this.groups = mergeEntityRefs(structuredClone(snapshot.groups));
+            this.teachers = mergeTeachersByIdentity([], structuredClone(snapshot.teachers)).values;
+            this.rooms = mergeEntityRefs(structuredClone(snapshot.rooms));
+        }
+    }
+    rememberGroups(values) {
+        validateRefs(values, "Group");
+        const result = mergeByIdAndName(this.groups, values);
+        this.groups = result.values;
+        return result.changed;
+    }
+    rememberTeachers(values) {
+        validateRefs(values, "Teacher");
+        const result = mergeTeachersByIdentity(this.teachers, values);
+        this.teachers = result.values;
+        return result.changed;
+    }
+    rememberRooms(values) {
+        validateRefs(values, "Room");
+        const result = mergeByIdAndName(this.rooms, values);
+        this.rooms = result.values;
+        return result.changed;
+    }
+    resolveGroup(value) {
+        return resolveUnique(value, this.groups, exactKey);
+    }
+    resolveTeacher(value) {
+        return resolveUnique(value, this.teachers, personKey);
+    }
+    resolveRoom(value) {
+        return resolveUnique(value, this.rooms, exactKey);
+    }
+    export() {
+        return {
+            groups: structuredClone(this.groups),
+            teachers: structuredClone(this.teachers),
+            rooms: structuredClone(this.rooms),
+        };
+    }
+}

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

@@ -0,0 +1,7 @@
+import type { LessonId, LessonIdGenerator, LessonSeriesId } from "./types.js";
+export declare class RandomLessonIdGenerator implements LessonIdGenerator {
+    seriesId(): LessonSeriesId;
+    lessonId(): LessonId;
+}
+/** Stable occurrence identity inside a persisted series. */
+export declare function occurrenceIdForSeries(seriesId: LessonSeriesId, academicWeek: number, ordinal?: number): LessonId;

package/dist/tt/domain/ids.js

@@ -0,0 +1,20 @@
+function randomId(prefix) {
+    const cryptoApi = globalThis.crypto;
+    if (cryptoApi?.randomUUID)
+        return `${prefix}_${cryptoApi.randomUUID()}`;
+    const random = Math.random().toString(36).slice(2);
+    const time = Date.now().toString(36);
+    return `${prefix}_${time}_${random}`;
+}
+export class RandomLessonIdGenerator {
+    seriesId() {
+        return randomId("ser");
+    }
+    lessonId() {
+        return randomId("les");
+    }
+}
+/** Stable occurrence identity inside a persisted series. */
+export function occurrenceIdForSeries(seriesId, academicWeek, ordinal = 0) {
+    return `les_${seriesId}_${academicWeek}_${ordinal}`;
+}

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

@@ -0,0 +1,7 @@
+export { RandomLessonIdGenerator, occurrenceIdForSeries } from "./ids.js";
+export { TimetableDirectory } from "./directory.js";
+export { entityKey, mergeEntityRefs, mergeGroups, mergeRooms, mergeTeachers, normalizeScheduleText, } from "./normalize.js";
+export { MemoryTimetableRepositoryAdapter, TimetableRepository, } from "./repository.js";
+export { Schedule } from "./schedule.js";
+export type { ScheduleQueryOptions, ScheduleOptions, ScheduleWeekdayOptions, } from "./schedule.js";
+export type { GroupAttendance, GroupRef, IngestResult, LessonId, LessonIdGenerator, LessonOccurrence, LessonRecurrence, LessonSeries, LessonSeriesId, RelationCompleteness, RelationSet, LessonSourceRef, LessonStatus, LessonSubstitution, LessonTransfer, NamedEntityRef, OccurrenceObservation, RoomRef, ScheduleObservation, ScheduleOwner, ScheduleSourceSnapshot, SeriesObservation, TeacherRef, TimetableDirectorySnapshot, TimetableRepositoryAdapter, TimetableRepositorySnapshot, } from "./types.js";

package/dist/tt/domain/index.js

@@ -0,0 +1,5 @@
+export { RandomLessonIdGenerator, occurrenceIdForSeries } from "./ids.js";
+export { TimetableDirectory } from "./directory.js";
+export { entityKey, mergeEntityRefs, mergeGroups, mergeRooms, mergeTeachers, normalizeScheduleText, } from "./normalize.js";
+export { MemoryTimetableRepositoryAdapter, TimetableRepository, } from "./repository.js";
+export { Schedule } from "./schedule.js";

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

@@ -0,0 +1,7 @@
+import type { GroupAttendance, NamedEntityRef, RoomRef, TeacherRef } from "./types.js";
+export declare function normalizeScheduleText(value: string): string;
+export declare function entityKey(value: NamedEntityRef): string;
+export declare function mergeEntityRefs<T extends NamedEntityRef>(values: T[]): T[];
+export declare function mergeGroups(values: GroupAttendance[]): GroupAttendance[];
+export declare function mergeTeachers(values: TeacherRef[]): TeacherRef[];
+export declare function mergeRooms(values: RoomRef[]): RoomRef[];

package/dist/tt/domain/normalize.js

@@ -0,0 +1,65 @@
+export function normalizeScheduleText(value) {
+    return value
+        .normalize("NFKC")
+        .toLocaleLowerCase("ru-RU")
+        .replace(/ё/gu, "е")
+        .replace(/\s+/gu, " ")
+        .trim();
+}
+export function entityKey(value) {
+    return value.id != null
+        ? `id:${value.id}`
+        : `name:${normalizeScheduleText(value.name)}`;
+}
+function mergeNamed(current, next) {
+    const merged = { ...current, ...next };
+    if (!next.name && current.name)
+        merged.name = current.name;
+    return merged;
+}
+export function mergeEntityRefs(values) {
+    const byId = new Map();
+    const byName = new Map();
+    for (const value of values) {
+        const nameKey = normalizeScheduleText(value.name);
+        const idMatch = value.id == null ? undefined : byId.get(value.id);
+        const nameMatch = nameKey ? byName.get(nameKey) : undefined;
+        const existing = idMatch ?? nameMatch;
+        const merged = existing ? mergeNamed(existing, value) : { ...value };
+        if (merged.id != null)
+            byId.set(merged.id, merged);
+        if (nameKey)
+            byName.set(nameKey, merged);
+        if (existing && existing !== merged) {
+            if (existing.id != null)
+                byId.set(existing.id, merged);
+            const oldName = normalizeScheduleText(existing.name);
+            if (oldName)
+                byName.set(oldName, merged);
+        }
+    }
+    return [...new Set([...byId.values(), ...byName.values()])].sort((a, b) => entityKey(a).localeCompare(entityKey(b)));
+}
+export function mergeGroups(values) {
+    const merged = new Map();
+    for (const value of values) {
+        const key = `${entityKey(value.group)}:${value.subgroup ?? 0}`;
+        const current = merged.get(key);
+        merged.set(key, {
+            group: current
+                ? mergeEntityRefs([current.group, value.group])[0]
+                : { ...value.group },
+            subgroup: value.subgroup,
+        });
+    }
+    return [...merged.values()].sort((a, b) => {
+        const group = entityKey(a.group).localeCompare(entityKey(b.group));
+        return group || (a.subgroup ?? 0) - (b.subgroup ?? 0);
+    });
+}
+export function mergeTeachers(values) {
+    return mergeEntityRefs(values);
+}
+export function mergeRooms(values) {
+    return mergeEntityRefs(values);
+}

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

@@ -0,0 +1,51 @@
+import type { AcademicPeriod } from "../../common/types.js";
+import { TimetableDirectory } from "./directory.js";
+import type { IngestResult, LessonIdGenerator, LessonOccurrence, LessonSeries, ScheduleOwner, ScheduleSourceSnapshot, TimetableRepositoryAdapter, TimetableRepositorySnapshot } from "./types.js";
+export declare class TimetableRepository {
+    private readonly idGenerator;
+    private _directory;
+    private readonly sources;
+    private readonly links;
+    private readonly seriesRecords;
+    private readonly occurrenceRecords;
+    private _revision;
+    constructor(opts?: {
+        idGenerator?: LessonIdGenerator;
+        snapshot?: TimetableRepositorySnapshot;
+    });
+    get directory(): TimetableDirectory;
+    get revision(): number;
+    rememberGroups(values: Parameters<TimetableDirectory["rememberGroups"]>[0]): void;
+    rememberTeachers(values: Parameters<TimetableDirectory["rememberTeachers"]>[0]): void;
+    rememberRooms(values: Parameters<TimetableDirectory["rememberRooms"]>[0]): void;
+    ingest(snapshot: ScheduleSourceSnapshot): IngestResult;
+    getSeries(opts?: {
+        owner?: ScheduleOwner;
+        academicYearStartYear?: number;
+        periods?: readonly AcademicPeriod[];
+    }): LessonSeries[];
+    getDirectOccurrences(opts?: {
+        owner?: ScheduleOwner;
+        academicYearStartYear?: number;
+        periods?: readonly AcademicPeriod[];
+    }): LessonOccurrence[];
+    export(): TimetableRepositorySnapshot;
+    replaceSnapshot(snapshot: TimetableRepositorySnapshot): void;
+    private restore;
+    private validateSource;
+    private rememberSourceEntities;
+    private pruneEmptyRecords;
+    private removeClaim;
+    private addClaim;
+    private findPriorTarget;
+    private findCanonicalTarget;
+    private aggregateSubstitutions;
+    private aggregateSeries;
+    private aggregateOccurrence;
+}
+export declare class MemoryTimetableRepositoryAdapter implements TimetableRepositoryAdapter {
+    private snapshot;
+    load(): Promise<TimetableRepositorySnapshot | null>;
+    compareAndSet(expectedRevision: number, snapshot: TimetableRepositorySnapshot): Promise<boolean>;
+    clear(): Promise<void>;
+}