chuvsu-js 3.0.2 → 4.0.0

package/README.md

@@ -61,7 +61,7 @@ schedule.currentLesson();
 ```ts
 import { LkClient } from "chuvsu-js";
 
-const lk = new LkClient();
+const lk = new LkClient({ cache: 60_000 });
 await lk.login({ email: "student@mail.ru", password: "password" });
 
 const data = await lk.getPersonalData();
@@ -87,6 +87,8 @@ new TtClient(options?: TtClientOptions)
 | --------------- | ----------------------- | ----------------- | -------------------------------------------------------------- |
 | `educationType` | `EducationType`         | `HigherEducation` | Тип образования: высшее (1) или СПО (2)                        |
 | `cache`         | `number \| CacheConfig` | —                 | TTL кеша в мс. Число задаёт единый TTL, объект — по категориям |
+| `cacheAdapter`  | `CacheAdapter`          | —                 | Внешний L2-кеш для JSON-данных (например Redis/БД)             |
+| `blobAdapter`   | `BlobAdapter`           | —                 | Хранилище бинарных данных, например S3/R2/MinIO                |
 
 #### Авторизация
 
@@ -141,7 +143,13 @@ const data = tt.exportCache();
 tt.importCache(data);
 ```
 
-Категории кеша: `schedule`, `faculties`, `groups`.
+Категории кеша: `schedule`, `faculties`, `groups`, `audiences`, `audienceNames`, `teachers`, `teacherInfo`, `teacherPhotos`, `audienceInfo`, `audienceImages`.
+
+Если передать `cacheAdapter`, библиотека использует двухуровневый кеш:
+- L1: in-memory кеш внутри процесса
+- L2: внешний адаптер (`cacheAdapter`)
+
+Если передать `blobAdapter`, фото преподавателей, аудиторий, корпусов и планов этажей будут храниться во внешнем blob/object storage, а во внешнем JSON-кеше сохранятся только метаданные с ключом blob-объекта.
 
 ### Schedule
 
@@ -224,11 +232,15 @@ getWeekNumber({ period: Period.SpringSemester });
 Клиент для личного кабинета (`lk.chuvsu.ru`).
 
 ```ts
+const lk = new LkClient({ cache?: number | LkCacheConfig });
 await lk.login({ email, password });
 const data = await lk.getPersonalData();
 const groupId = await lk.getGroupId();
 ```
 
+`cache` работает так же, как в `TtClient`: число задаёт единый TTL в мс, объект — TTL по категориям (`personalData`, `photo`, `groupId`).
+Также поддерживаются `cacheAdapter` и `blobAdapter`.
+
 **PersonalData** содержит: `lastName`, `firstName`, `patronymic`, `sex`, `birthday`, `recordBookNumber`, `faculty`, `specialty`, `profile`, `group`, `course`, `email`, `phone`.
 
 ## Типы

package/dist/common/cache.d.ts

@@ -2,6 +2,21 @@ export interface CacheEntry {
     data: unknown;
     timestamp: number;
 }
+export interface CacheAdapter {
+    get(category: string, key: string): Promise<unknown | null | undefined>;
+    set(category: string, key: string, data: unknown, ttl?: number): Promise<void>;
+    clear?(category?: string): Promise<void>;
+    delete?(category: string, key: string): Promise<void>;
+}
+export interface BlobPutOptions {
+    contentType?: string;
+    ttl?: number;
+}
+export interface BlobAdapter {
+    get(key: string): Promise<Buffer | null>;
+    put(key: string, data: Buffer, opts?: BlobPutOptions): Promise<void>;
+    delete?(key: string): Promise<void>;
+}
 export declare class Cache {
     private ttls;
     private store;
@@ -12,3 +27,18 @@ export declare class Cache {
     export(): Record<string, CacheEntry>;
     import(data: Record<string, CacheEntry>): void;
 }
+export declare class HybridCache {
+    private memory;
+    private ttls;
+    private adapter?;
+    constructor(ttls: Record<string, number | undefined>, adapter?: CacheAdapter);
+    ttl(category: string): number | undefined;
+    getLocal(category: string, key: string): unknown | null;
+    setLocal(category: string, key: string, data: unknown): void;
+    get(category: string, key: string): Promise<unknown | null>;
+    set(category: string, key: string, data: unknown): Promise<void>;
+    setExternal(category: string, key: string, data: unknown): Promise<void>;
+    clear(category?: string): Promise<void>;
+    export(): Record<string, CacheEntry>;
+    import(data: Record<string, CacheEntry>): void;
+}

package/dist/common/cache.js

@@ -46,3 +46,55 @@ export class Cache {
         }
     }
 }
+export class HybridCache {
+    memory;
+    ttls;
+    adapter;
+    constructor(ttls, adapter) {
+        this.ttls = ttls;
+        this.memory = new Cache(ttls);
+        this.adapter = adapter;
+    }
+    ttl(category) {
+        return this.ttls[category];
+    }
+    getLocal(category, key) {
+        return this.memory.get(category, key);
+    }
+    setLocal(category, key, data) {
+        this.memory.set(category, key, data);
+    }
+    async get(category, key) {
+        const local = this.memory.get(category, key);
+        if (local !== null)
+            return local;
+        const ttl = this.ttls[category];
+        if (ttl == null || !this.adapter)
+            return null;
+        const external = await this.adapter.get(category, key);
+        if (external === null || external === undefined)
+            return null;
+        this.memory.set(category, key, external);
+        return external;
+    }
+    async set(category, key, data) {
+        this.memory.set(category, key, data);
+        await this.setExternal(category, key, data);
+    }
+    async setExternal(category, key, data) {
+        const ttl = this.ttls[category];
+        if (ttl == null || !this.adapter)
+            return;
+        await this.adapter.set(category, key, data, ttl);
+    }
+    async clear(category) {
+        this.memory.clear(category);
+        await this.adapter?.clear?.(category);
+    }
+    export() {
+        return this.memory.export();
+    }
+    import(data) {
+        this.memory.import(data);
+    }
+}

package/dist/lk/client.d.ts

@@ -1,7 +1,10 @@
-import type { PersonalData } from "./types.js";
+import type { LkClientOptions, PersonalData } from "./types.js";
 export declare class LkClient {
     private http;
     private credentials;
+    private cache;
+    private blobAdapter;
+    constructor(opts?: LkClientOptions);
     login(opts: {
         email: string;
         password: string;

package/dist/lk/client.js

@@ -1,12 +1,34 @@
 import { HttpClient } from "../common/http.js";
+import { HybridCache } from "../common/cache.js";
 import { AuthError } from "../common/types.js";
 import { extractScriptValues } from "./parse.js";
 const BASE = "https://lk.chuvsu.ru";
 const LOGIN_URL = `${BASE}/info/login.php`;
 const STUDENT_BASE = `${BASE}/student`;
+function makeUniformCacheConfig(ttl) {
+    return {
+        personalData: ttl,
+        photo: ttl,
+        groupId: ttl,
+    };
+}
 export class LkClient {
     http = new HttpClient();
     credentials = null;
+    cache;
+    blobAdapter = undefined;
+    constructor(opts) {
+        this.blobAdapter = opts?.blobAdapter;
+        if (opts?.cache == null) {
+            this.cache = null;
+        }
+        else if (typeof opts.cache === "number") {
+            this.cache = new HybridCache(makeUniformCacheConfig(opts.cache), opts.cacheAdapter);
+        }
+        else {
+            this.cache = new HybridCache(opts.cache, opts.cacheAdapter);
+        }
+    }
     async login(opts) {
         const res = await this.http.post(LOGIN_URL, { email: opts.email, password: opts.password, role: "1", enter: "" }, false);
         if (!(res.status === 302 && res.location?.includes("student"))) {
@@ -26,9 +48,12 @@ export class LkClient {
         return res;
     }
     async getPersonalData() {
+        const cached = await this.cache?.get("personalData", "self");
+        if (cached)
+            return cached;
         const { body } = await this.authGet(`${STUDENT_BASE}/personal_data.php`);
         const vals = extractScriptValues(body, "form_personal_data");
-        return {
+        const data = {
             lastName: vals.fam ?? "",
             firstName: vals.nam ?? "",
             patronymic: vals.oth ?? "",
@@ -43,13 +68,49 @@ export class LkClient {
             email: vals.email ?? "",
             phone: vals.phone ?? "",
         };
+        await this.cache?.set("personalData", "self", data);
+        return data;
     }
     async getPhoto() {
-        return this.http.getBuffer(`${STUDENT_BASE}/face.php`);
+        const cached = this.cache?.getLocal("photo", "self") ??
+            await this.cache?.get("photo", "self");
+        if (cached !== null && cached !== undefined) {
+            const entry = cached;
+            if (typeof entry === "string")
+                return Buffer.from(entry, "base64");
+            if (entry.data !== undefined) {
+                return entry.data ? Buffer.from(entry.data, "base64") : Buffer.alloc(0);
+            }
+            if (entry.blobKey && this.blobAdapter) {
+                const photo = await this.blobAdapter.get(entry.blobKey);
+                if (photo) {
+                    this.cache?.setLocal("photo", "self", { data: photo.toString("base64") });
+                    return photo;
+                }
+            }
+        }
+        const photo = await this.http.getBuffer(`${STUDENT_BASE}/face.php`);
+        if (this.blobAdapter) {
+            const blobKey = "lk/photo/self";
+            this.cache?.setLocal("photo", "self", { data: photo.toString("base64") });
+            await this.blobAdapter.put(blobKey, photo, {
+                ttl: this.cache?.ttl("photo"),
+            });
+            await this.cache?.setExternal("photo", "self", { blobKey });
+        }
+        else {
+            await this.cache?.set("photo", "self", photo.toString("base64"));
+        }
+        return photo;
     }
     async getGroupId() {
+        const cached = await this.cache?.get("groupId", "self");
+        if (cached !== null && cached !== undefined)
+            return cached;
         const { body } = await this.authGet(`${STUDENT_BASE}/tt.php`);
         const match = body.match(/tt\.chuvsu\.ru\/index\/grouptt\/gr\/(\d+)/);
-        return match ? parseInt(match[1]) : null;
+        const groupId = match ? parseInt(match[1]) : null;
+        await this.cache?.set("groupId", "self", groupId);
+        return groupId;
     }
 }

package/dist/lk/types.d.ts

@@ -1,3 +1,4 @@
+import type { BlobAdapter, CacheAdapter } from "../common/cache.js";
 export interface PersonalData {
     lastName: string;
     firstName: string;
@@ -13,3 +14,13 @@ export interface PersonalData {
     email: string;
     phone: string;
 }
+export interface LkCacheConfig {
+    personalData?: number;
+    photo?: number;
+    groupId?: number;
+}
+export interface LkClientOptions {
+    cache?: number | LkCacheConfig;
+    cacheAdapter?: CacheAdapter;
+    blobAdapter?: BlobAdapter;
+}

package/dist/shared.d.ts

@@ -4,6 +4,6 @@ export { getAdjacentSemester, getCompensatingWorkDays, getCurrentPeriod, getEffe
 export type { Holiday, HolidayTransfer } from "./tt/utils/index.js";
 export { AuthError, EducationType, ParseError, Period, } from "./common/types.js";
 export type { Teacher, Time, WeekRange } from "./common/types.js";
-export type { CacheEntry } from "./common/cache.js";
+export type { BlobAdapter, BlobPutOptions, CacheAdapter, CacheEntry, } from "./common/cache.js";
 export type { Audience, AudienceInfo, CacheConfig, Faculty, FullScheduleDay, FullScheduleSlot, Group, Lesson, LessonTime, LessonTimeSlot, ScheduleEntry, SemesterWeek, SubstituteForInfo, Substitution, TeacherInfo, TransferInfo, TtClientOptions, } from "./tt/types.js";
-export type { PersonalData } from "./lk/types.js";
+export type { LkCacheConfig, LkClientOptions, PersonalData } from "./lk/types.js";

package/dist/tt/client.d.ts

@@ -6,10 +6,11 @@ export declare class TtClient {
     private http;
     private educationType;
     private cache;
+    private blobAdapter;
     private loginMode;
     constructor(opts?: TtClientOptions);
     private get pertt();
-    clearCache(category?: keyof CacheConfig): void;
+    clearCache(category?: keyof CacheConfig): Promise<void>;
     exportCache(): Record<string, CacheEntry>;
     importCache(data: Record<string, CacheEntry>): void;
     login(opts: {

package/dist/tt/client.js

@@ -1,5 +1,5 @@
 import { HttpClient } from "../common/http.js";
-import { Cache } from "../common/cache.js";
+import { HybridCache } from "../common/cache.js";
 import { AuthError } from "../common/types.js";
 import { parseAudienceButtons, parseAudienceFullSchedule, parseAudienceInfo, parseAudienceName, parseGroupButtons, parseFacultyButtons, parseTeacherButtons, parseFullSchedule, parseTeacherFullSchedule, parseTeacherInfo, } from "./parse/index.js";
 import { Schedule } from "./schedule.js";
@@ -11,33 +11,45 @@ const ALL_PERIODS = [
     3 /* Period.SpringSemester */,
     4 /* Period.SummerSession */,
 ];
+function makeUniformCacheConfig(ttl) {
+    return {
+        schedule: ttl,
+        faculties: ttl,
+        groups: ttl,
+        audiences: ttl,
+        audienceNames: ttl,
+        teachers: ttl,
+        teacherInfo: ttl,
+        teacherPhotos: ttl,
+        audienceInfo: ttl,
+        audienceImages: ttl,
+    };
+}
 export class TtClient {
     http = new HttpClient();
     educationType;
     cache;
+    blobAdapter = undefined;
     loginMode = null;
     constructor(opts) {
         this.educationType = opts?.educationType ?? 1 /* EducationType.HigherEducation */;
+        this.blobAdapter = opts?.blobAdapter;
         if (opts?.cache == null) {
             this.cache = null;
         }
         else if (typeof opts.cache === "number") {
-            this.cache = new Cache({
-                schedule: opts.cache,
-                faculties: opts.cache,
-                groups: opts.cache,
-            });
+            this.cache = new HybridCache(makeUniformCacheConfig(opts.cache), opts.cacheAdapter);
         }
         else {
-            this.cache = new Cache(opts.cache);
+            this.cache = new HybridCache(opts.cache, opts.cacheAdapter);
         }
     }
     get pertt() {
         return String(this.educationType);
     }
     // --- Cache ---
-    clearCache(category) {
-        this.cache?.clear(category);
+    async clearCache(category) {
+        await this.cache?.clear(category);
     }
     exportCache() {
         return this.cache?.export() ?? {};
@@ -102,13 +114,13 @@ export class TtClient {
     // --- Schedule ---
     async fetchSchedule(groupId, period) {
         const cacheKey = `${groupId}:${period}`;
-        const cached = this.cache?.get("schedule", cacheKey);
+        const cached = await this.cache?.get("schedule", cacheKey);
         if (cached)
             return cached;
         const url = `${BASE}/index/grouptt/gr/${groupId}`;
         const { body } = await this.authPost(url, { htype: String(period) });
         const days = parseFullSchedule(body, this.educationType);
-        this.cache?.set("schedule", cacheKey, days);
+        await this.cache?.set("schedule", cacheKey, days);
         return days;
     }
     /**
@@ -137,17 +149,17 @@ export class TtClient {
     }
     // --- Search / Discovery ---
     async getFaculties() {
-        const cached = this.cache?.get("faculties", "all");
+        const cached = await this.cache?.get("faculties", "all");
         if (cached)
             return cached;
         const { body } = await this.authGet(`${BASE}/`);
         const data = parseFacultyButtons(body);
-        this.cache?.set("faculties", "all", data);
+        await this.cache?.set("faculties", "all", data);
         return data;
     }
     async getGroupsForFaculty(opts) {
         const cacheKey = String(opts.facultyId);
-        const cached = this.cache?.get("groups", cacheKey);
+        const cached = await this.cache?.get("groups", cacheKey);
         if (cached)
             return cached;
         const { body } = await this.authPost(`${BASE}/`, {
@@ -155,30 +167,42 @@ export class TtClient {
             pertt: this.pertt,
         });
         const data = parseGroupButtons(body);
-        this.cache?.set("groups", cacheKey, data);
+        await this.cache?.set("groups", cacheKey, data);
         return data;
     }
     async searchGroup(opts) {
+        const cacheKey = `search:${opts.name}:${this.pertt}`;
+        const cached = await this.cache?.get("groups", cacheKey);
+        if (cached)
+            return cached;
         const { body } = await this.authPost(`${BASE}/`, {
             grname: opts.name,
             findgr: "найти",
             hfac: "0",
             pertt: this.pertt,
         });
-        return parseGroupButtons(body);
+        const data = parseGroupButtons(body);
+        await this.cache?.set("groups", cacheKey, data);
+        return data;
     }
     /**
      * Search audiences by name (substring match). The server requires at
      * least 3 characters in the query.
      */
     async searchAudience(opts) {
+        const cacheKey = `search:${opts.name}:${this.pertt}`;
+        const cached = await this.cache?.get("audiences", cacheKey);
+        if (cached)
+            return cached;
         const { body } = await this.authPost(`${BASE}/`, {
             audname: opts.name,
             findaud: "найти",
             hfac: "0",
             pertt: this.pertt,
         });
-        return parseAudienceButtons(body);
+        const data = parseAudienceButtons(body);
+        await this.cache?.set("audiences", cacheKey, data);
+        return data;
     }
     /**
      * Get every audience known to the system in a single request.
@@ -189,13 +213,19 @@ export class TtClient {
      * the full list of (id, name) pairs.
      */
     async getAudiences() {
+        const cacheKey = `all:${this.pertt}`;
+        const cached = await this.cache?.get("audiences", cacheKey);
+        if (cached)
+            return cached;
         const { body } = await this.authPost(`${BASE}/`, {
             audname: "%%%",
             findaud: "найти",
             hfac: "0",
             pertt: this.pertt,
         });
-        return parseAudienceButtons(body);
+        const data = parseAudienceButtons(body);
+        await this.cache?.set("audiences", cacheKey, data);
+        return data;
     }
     /**
      * Resolve an audience id from its exact name by searching and
@@ -208,37 +238,50 @@ export class TtClient {
     }
     /** Fetch the audience's display name from its schedule page. */
     async getAudienceName(audienceId) {
+        const cacheKey = String(audienceId);
+        const cached = await this.cache?.get("audienceNames", cacheKey);
+        if (cached !== null && cached !== undefined)
+            return cached;
+        const cachedInfo = await this.cache?.get("audienceInfo", cacheKey);
+        if (cachedInfo) {
+            return cachedInfo.name ?? null;
+        }
         const { body } = await this.authGet(`${BASE}/index/audtt/aud/${audienceId}`);
-        return parseAudienceName(body);
+        const name = parseAudienceName(body);
+        const info = parseAudienceInfo(body);
+        await this.cache?.set("audienceNames", cacheKey, name);
+        if (info)
+            await this.cache?.set("audienceInfo", cacheKey, info);
+        return name;
     }
     /**
      * Fetch detailed info about an audience (building, floor, usage,
      * image URLs for the audience photo, building photo and floor plan).
      */
     async getAudienceInfo(audienceId) {
-        const cached = this.cache?.get("audienceInfo", String(audienceId));
+        const cached = await this.cache?.get("audienceInfo", String(audienceId));
         if (cached)
             return cached;
         const { body } = await this.authGet(`${BASE}/index/audtt/aud/${audienceId}`);
         const info = parseAudienceInfo(body);
         if (info)
-            this.cache?.set("audienceInfo", String(audienceId), info);
+            await this.cache?.set("audienceInfo", String(audienceId), info);
         return info;
     }
     async fetchAudienceSchedule(audienceId, period) {
         const cacheKey = `audience:${audienceId}:${period}`;
-        const cached = this.cache?.get("schedule", cacheKey);
+        const cached = await this.cache?.get("schedule", cacheKey);
         if (cached)
             return cached;
         const url = `${BASE}/index/audtt/aud/${audienceId}`;
         const { body } = await this.authPost(url, { htype: String(period) });
         const days = parseAudienceFullSchedule(body);
-        this.cache?.set("schedule", cacheKey, days);
+        await this.cache?.set("schedule", cacheKey, days);
         // Cache audience info from the same page to avoid an extra request.
-        if (!this.cache?.get("audienceInfo", String(audienceId))) {
+        if (!(await this.cache?.get("audienceInfo", String(audienceId)))) {
             const info = parseAudienceInfo(body);
             if (info)
-                this.cache?.set("audienceInfo", String(audienceId), info);
+                await this.cache?.set("audienceInfo", String(audienceId), info);
         }
         return days;
     }
@@ -260,24 +303,48 @@ export class TtClient {
         return new Schedule(opts.audienceId, schedules, opts.period, this.educationType);
     }
     async getCachedAudienceImage(cacheKey, fetchUrl) {
-        const cached = this.cache?.get("audienceImages", cacheKey);
+        const cached = this.cache?.getLocal("audienceImages", cacheKey) ??
+            await this.cache?.get("audienceImages", cacheKey);
         if (cached !== null && cached !== undefined) {
             const entry = cached;
-            return entry.data ? Buffer.from(entry.data, "base64") : null;
+            if (entry.data !== undefined) {
+                return entry.data ? Buffer.from(entry.data, "base64") : null;
+            }
+            if (entry.blobKey && this.blobAdapter) {
+                const buf = await this.blobAdapter.get(entry.blobKey);
+                if (buf) {
+                    this.cache?.setLocal("audienceImages", cacheKey, {
+                        data: buf.toString("base64"),
+                    });
+                    return buf;
+                }
+            }
         }
         const url = await fetchUrl();
         if (!url) {
-            this.cache?.set("audienceImages", cacheKey, { data: null });
+            await this.cache?.set("audienceImages", cacheKey, { data: null });
             return null;
         }
         const buf = await this.authGetBuffer(`${BASE}${url}`);
         if (buf.length === 0) {
-            this.cache?.set("audienceImages", cacheKey, { data: null });
+            await this.cache?.set("audienceImages", cacheKey, { data: null });
             return null;
         }
-        this.cache?.set("audienceImages", cacheKey, {
-            data: buf.toString("base64"),
-        });
+        if (this.blobAdapter) {
+            const blobKey = `tt/audience-images/${cacheKey}`;
+            this.cache?.setLocal("audienceImages", cacheKey, {
+                data: buf.toString("base64"),
+            });
+            await this.blobAdapter.put(blobKey, buf, {
+                ttl: this.cache?.ttl("audienceImages"),
+            });
+            await this.cache?.setExternal("audienceImages", cacheKey, { blobKey });
+        }
+        else {
+            await this.cache?.set("audienceImages", cacheKey, {
+                data: buf.toString("base64"),
+            });
+        }
         return buf;
     }
     /** Get the audience photo (audimage). Returns null if missing. */
@@ -293,38 +360,44 @@ export class TtClient {
         return this.getCachedAudienceImage(`floor:${audienceId}`, async () => (await this.getAudienceInfo(audienceId))?.floorplanUrl);
     }
     async searchTeacher(opts) {
+        const cacheKey = `search:${opts.name}:${this.pertt}`;
+        const cached = await this.cache?.get("teachers", cacheKey);
+        if (cached)
+            return cached;
         const { body } = await this.authPost(`${BASE}/`, {
             techname: opts.name,
             findtech: "найти",
             hfac: "0",
             pertt: this.pertt,
         });
-        return parseTeacherButtons(body);
+        const data = parseTeacherButtons(body);
+        await this.cache?.set("teachers", cacheKey, data);
+        return data;
     }
     // --- Teacher schedule ---
     async getTeachers() {
-        const cached = this.cache?.get("teachers", "all");
+        const cached = await this.cache?.get("teachers", "all");
         if (cached)
             return cached;
         const { body } = await this.authGet(`${BASE}/index/tech`);
         const data = parseTeacherButtons(body);
-        this.cache?.set("teachers", "all", data);
+        await this.cache?.set("teachers", "all", data);
         return data;
     }
     async fetchTeacherSchedule(teacherId, period) {
         const cacheKey = `teacher:${teacherId}:${period}`;
-        const cached = this.cache?.get("schedule", cacheKey);
+        const cached = await this.cache?.get("schedule", cacheKey);
         if (cached)
             return cached;
         const url = `${BASE}/index/techtt/tech/${teacherId}`;
         const { body } = await this.authPost(url, { htype: String(period) });
         const days = parseTeacherFullSchedule(body, this.educationType);
-        this.cache?.set("schedule", cacheKey, days);
+        await this.cache?.set("schedule", cacheKey, days);
         // Cache teacher info from the same page to avoid extra requests
-        if (!this.cache?.get("teacherInfo", String(teacherId))) {
+        if (!(await this.cache?.get("teacherInfo", String(teacherId)))) {
             const info = parseTeacherInfo(body);
             if (info)
-                this.cache?.set("teacherInfo", String(teacherId), info);
+                await this.cache?.set("teacherInfo", String(teacherId), info);
         }
         return days;
     }
@@ -346,14 +419,14 @@ export class TtClient {
         return new Schedule(opts.teacherId, schedules, opts.period, this.educationType, undefined, undefined, true);
     }
     async getTeacherInfo(teacherId) {
-        const cached = this.cache?.get("teacherInfo", String(teacherId));
+        const cached = await this.cache?.get("teacherInfo", String(teacherId));
         if (cached)
             return cached;
         const url = `${BASE}/index/techtt/tech/${teacherId}`;
         const { body } = await this.authGet(url);
         const info = parseTeacherInfo(body);
         if (info)
-            this.cache?.set("teacherInfo", String(teacherId), info);
+            await this.cache?.set("teacherInfo", String(teacherId), info);
         return info;
     }
     /**
@@ -363,21 +436,45 @@ export class TtClient {
      */
     async getTeacherPhoto(teacherId) {
         const photoCacheKey = String(teacherId);
-        const cachedPhoto = this.cache?.get("teacherPhotos", photoCacheKey);
+        const cachedPhoto = this.cache?.getLocal("teacherPhotos", photoCacheKey) ??
+            await this.cache?.get("teacherPhotos", photoCacheKey);
         if (cachedPhoto !== null && cachedPhoto !== undefined) {
             const entry = cachedPhoto;
-            return entry.data ? Buffer.from(entry.data, "base64") : null;
+            if (entry.data !== undefined) {
+                return entry.data ? Buffer.from(entry.data, "base64") : null;
+            }
+            if (entry.blobKey && this.blobAdapter) {
+                const buf = await this.blobAdapter.get(entry.blobKey);
+                if (buf) {
+                    this.cache?.setLocal("teacherPhotos", photoCacheKey, {
+                        data: buf.toString("base64"),
+                    });
+                    return buf;
+                }
+            }
         }
         // Get teacher info (may already be cached from schedule fetch)
         const info = await this.getTeacherInfo(teacherId);
         if (!info?.photoUrl) {
-            this.cache?.set("teacherPhotos", photoCacheKey, { data: null });
+            await this.cache?.set("teacherPhotos", photoCacheKey, { data: null });
             return null;
         }
         const photoBuffer = await this.authGetBuffer(`${BASE}${info.photoUrl}`);
-        this.cache?.set("teacherPhotos", photoCacheKey, {
-            data: photoBuffer.toString("base64"),
-        });
+        if (this.blobAdapter) {
+            const blobKey = `tt/teacher-photos/${teacherId}`;
+            this.cache?.setLocal("teacherPhotos", photoCacheKey, {
+                data: photoBuffer.toString("base64"),
+            });
+            await this.blobAdapter.put(blobKey, photoBuffer, {
+                ttl: this.cache?.ttl("teacherPhotos"),
+            });
+            await this.cache?.setExternal("teacherPhotos", photoCacheKey, { blobKey });
+        }
+        else {
+            await this.cache?.set("teacherPhotos", photoCacheKey, {
+                data: photoBuffer.toString("base64"),
+            });
+        }
         return photoBuffer;
     }
     /**
@@ -387,20 +484,44 @@ export class TtClient {
      */
     async getTeacherPhotoLazy(teacherId) {
         const photoCacheKey = String(teacherId);
-        const cachedPhoto = this.cache?.get("teacherPhotos", photoCacheKey);
+        const cachedPhoto = this.cache?.getLocal("teacherPhotos", photoCacheKey) ??
+            await this.cache?.get("teacherPhotos", photoCacheKey);
         if (cachedPhoto !== null && cachedPhoto !== undefined) {
             const entry = cachedPhoto;
-            return entry.data ? Buffer.from(entry.data, "base64") : null;
+            if (entry.data !== undefined) {
+                return entry.data ? Buffer.from(entry.data, "base64") : null;
+            }
+            if (entry.blobKey && this.blobAdapter) {
+                const buf = await this.blobAdapter.get(entry.blobKey);
+                if (buf) {
+                    this.cache?.setLocal("teacherPhotos", photoCacheKey, {
+                        data: buf.toString("base64"),
+                    });
+                    return buf;
+                }
+            }
         }
         const url = `${BASE}/index/photo/tech/${teacherId}/id/${teacherId}`;
         const photoBuffer = await this.authGetBuffer(url);
         if (photoBuffer.length === 0) {
-            this.cache?.set("teacherPhotos", photoCacheKey, { data: null });
+            await this.cache?.set("teacherPhotos", photoCacheKey, { data: null });
             return null;
         }
-        this.cache?.set("teacherPhotos", photoCacheKey, {
-            data: photoBuffer.toString("base64"),
-        });
+        if (this.blobAdapter) {
+            const blobKey = `tt/teacher-photos/${teacherId}`;
+            this.cache?.setLocal("teacherPhotos", photoCacheKey, {
+                data: photoBuffer.toString("base64"),
+            });
+            await this.blobAdapter.put(blobKey, photoBuffer, {
+                ttl: this.cache?.ttl("teacherPhotos"),
+            });
+            await this.cache?.setExternal("teacherPhotos", photoCacheKey, { blobKey });
+        }
+        else {
+            await this.cache?.set("teacherPhotos", photoCacheKey, {
+                data: photoBuffer.toString("base64"),
+            });
+        }
         return photoBuffer;
     }
 }

package/dist/tt/parse/audience.js

@@ -2,6 +2,7 @@ import { parseHtml, parseTeacher, parseWeekParity, parseWeeks, text, } from "../
 import { parseSemesterScheduleWith } from "./full-schedule.js";
 import { parseGroupsString } from "./groups.js";
 import { parseSubstituteForDiv, parseSubstitutionDiv, parseTransferDiv, } from "./overlays.js";
+import { LESSON_TYPE_GLOBAL_RE, LESSON_TYPE_RE, SUBGROUP_ANNOTATION_RE, SUBGROUP_RE, WEEKS_GLOBAL_RE, WEEKS_RE, } from "./patterns.js";
 export function parseAudienceInfo(html) {
     const doc = parseHtml(html);
     // Name: <span class="htext"><nobr>Аудитория <span style="color: blue;">NAME</span></nobr></span>
@@ -105,9 +106,9 @@ function parseAudienceSemesterEntry(el) {
     const subject = subjectEl ? text(subjectEl) : "";
     if (!subject)
         return null;
-    const typeMatch = cleanText.match(/\((лк|пр|лб|зач|экз|зчО|кр|конс)\)/);
-    const weeksMatch = cleanText.match(/\(([^)]*нед\.?[^)]*)\)/);
-    const subgroupMatch = cleanText.match(/(\d+)\s*подгруппа/);
+    const typeMatch = cleanText.match(LESSON_TYPE_RE);
+    const weeksMatch = cleanText.match(WEEKS_RE);
+    const subgroupMatch = cleanText.match(SUBGROUP_RE);
     const weekParity = parseWeekParity(cleanHtml);
     // Audience entries layout:
     //   <span blue>SUBJ</span> (TYPE) (WEEKS) <br>TEACHER<br>GROUPS
@@ -122,9 +123,9 @@ function parseAudienceSemesterEntry(el) {
     const textLines = [];
     for (const p of parts) {
         const cleaned = p
-            .replace(/\((лк|пр|лб|зач|экз|зчО|кр|конс)\)/g, "")
-            .replace(/\([^)]*нед\.?[^)]*\)/g, "")
-            .replace(/\(\d+\s*подгруппа\)/g, "")
+            .replace(LESSON_TYPE_GLOBAL_RE, "")
+            .replace(WEEKS_GLOBAL_RE, "")
+            .replace(SUBGROUP_ANNOTATION_RE, "")
             .trim();
         if (cleaned)
             textLines.push(cleaned);

package/dist/tt/parse/full-schedule.js

@@ -1,6 +1,7 @@
 import { parseHtml, parseTeacher, parseTime, parseWeekParity, parseWeeks, text, } from "../../common/parse.js";
 import { getLessonNumber } from "../utils/index.js";
 import { parseSubstitutionDiv, parseTransferDiv, } from "./overlays.js";
+import { FLEXIBLE_LESSON_TYPE_RE_I, LESSON_TYPE_RE, SUBGROUP_RE, WEEKS_RE, } from "./patterns.js";
 export function parseFullSchedule(html, educationType) {
     const doc = parseHtml(html);
     const edType = educationType ?? 1 /* EducationType.HigherEducation */;
@@ -94,11 +95,11 @@ function parseSemesterEntry(el) {
     const subject = subjectEl ? text(subjectEl) : "";
     if (!subject)
         return null;
-    const typeMatch = cleanText.match(/\((лк|пр|лб|зач|экз|зчО|кр|конс)\)/);
-    const weeksMatch = cleanText.match(/\(([^)]*нед\.?[^)]*)\)/);
+    const typeMatch = cleanText.match(LESSON_TYPE_RE);
+    const weeksMatch = cleanText.match(WEEKS_RE);
     const roomMatch = cleanHtml.match(/(?:<sup>[^<]*<\/sup>)?([А-Яа-яA-Za-z]-\d+)/);
     const teacherMatch = cleanHtml.match(/<br\s*\/?>\s*([^<]+?)(?:<br|<\/td|<div|<i|$)/);
-    const subgroupMatch = cleanText.match(/(\d+)\s*подгруппа/);
+    const subgroupMatch = cleanText.match(SUBGROUP_RE);
     const weekParity = parseWeekParity(cleanHtml);
     return {
         room: roomMatch?.[1] ?? "",
@@ -169,7 +170,7 @@ function parseSessionEntry(td) {
     const roomMatch = fullHtml.match(/^([^<]*?)\s*<span/);
     const room = roomMatch ? roomMatch[1].trim() : "";
     // Type: parenthesized text after </span>, case-insensitive
-    const typeMatch = plainText.match(/\((лк|пр|лб|зач|экз|зчО|кр|конс\.?|Экз)\)/i);
+    const typeMatch = plainText.match(FLEXIBLE_LESSON_TYPE_RE_I);
     const type = typeMatch ? typeMatch[1].replace(/\.$/, "").toLowerCase() : "";
     // Time: after <br>, format HH:MM - HH:MM
     const timeMatch = fullHtml.match(/<br\s*\/?>\s*(\d{2}:\d{2})\s*-\s*(\d{2}:\d{2})/);

package/dist/tt/parse/groups.js

@@ -1,3 +1,4 @@
+import { SUBGROUP_ANNOTATION_RE_I } from "./patterns.js";
 /**
  * Split a raw "groups" string from the schedule HTML into individual group names.
  *
@@ -16,14 +17,15 @@ export function parseGroupsString(raw) {
     if (!raw)
         return [];
     const cleaned = raw
-        .replace(/\s*\(\s*\d+\s*подгруппа\s*\)\s*/gi, " ")
+        .replace(SUBGROUP_ANNOTATION_RE_I, " ")
         .trim();
     if (!cleaned)
         return [];
     const out = [];
-    // A new group starts from its code; trailing qualifiers like "ин" belong to
-    // the current group until the next code begins.
-    const startsGroup = (token) => /^[A-ZА-ЯЁ]{1,}-\d{1,2}-\d{2,4}[A-ZА-ЯЁa-zа-яё]*$/u.test(token);
+    // A new group starts from a code-like token. Optional qualifiers like "ин"
+    // may be attached either directly ("М-30-25ин") or as a separate tail
+    // ("УП-51-23 ин"), so they stay with the current group until the next code.
+    const startsGroup = (token) => /^[A-ZА-ЯЁ]{1,}(?:-[A-ZА-ЯЁa-zа-яё0-9]+)+$/u.test(token);
     let current = "";
     for (const token of cleaned.split(/\s+/)) {
         if (startsGroup(token)) {

package/dist/tt/parse/overlays.js

@@ -1,5 +1,6 @@
 import { parseTeacher, text } from "../../common/parse.js";
 import { parseGroupsString } from "./groups.js";
+import { LESSON_TYPE_PATTERN, LESSON_TYPE_RE, LESSON_TYPE_RE_I, SUBGROUP_RE, } from "./patterns.js";
 export function parseDate(dd, mm, yyyy) {
     return new Date(parseInt(yyyy), parseInt(mm) - 1, parseInt(dd));
 }
@@ -17,19 +18,31 @@ export function parseTransferDiv(div) {
     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*\/?>/);
+    const typeMatch = divText.match(LESSON_TYPE_RE);
+    const parts = divHtml
+        .split(/<br\s*\/?>/i)
+        .map((part) => part.replace(/<[^>]*>/g, "").trim())
+        .filter((part) => part.length > 0);
     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;
+    let groupsPart = "";
+    for (const part of parts.slice(1)) {
+        const cleaned = part.trim();
+        if (!cleaned)
+            continue;
+        const groups = parseGroupsString(cleaned);
+        if (groups.length > 0) {
+            groupsPart = cleaned;
+            continue;
+        }
+        const isLessonMeta = cleaned.includes(subject) ||
+            (roomMatch?.[1] != null && cleaned.includes(roomMatch[1])) ||
+            LESSON_TYPE_RE_I.test(cleaned);
+        if (!isLessonMeta && !teacherPart) {
+            teacherPart = cleaned;
         }
     }
     const transfer = { targetDate, fromDate, fromSlot, subject };
-    const subgroupMatch = divText.match(/(\d+)\s*подгруппа/);
+    const subgroupMatch = divText.match(SUBGROUP_RE);
     return {
         transfer,
         entry: {
@@ -38,7 +51,7 @@ export function parseTransferDiv(div) {
             type: typeMatch?.[1] ?? "",
             weeks: { from: 0, to: 0 },
             teacher: parseTeacher(teacherPart),
-            groups: [],
+            groups: parseGroupsString(groupsPart),
             subgroup: subgroupMatch ? parseInt(subgroupMatch[1]) : undefined,
             transfer,
         },
@@ -86,9 +99,9 @@ export function parseSubstituteForDiv(div) {
     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*подгруппа/);
+    const typeMatch = divText.match(LESSON_TYPE_RE);
+    const groupsMatch = divHtml.match(new RegExp(`\\((?:${LESSON_TYPE_PATTERN})\\)\\s*(?:<br\\s*\\/?>)\\s*([^<]+?)(?:\\s*<i|$)`));
+    const subgroupMatch = divText.match(SUBGROUP_RE);
     return {
         entry: {
             room: roomMatch?.[1] ?? "",

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

@@ -0,0 +1,11 @@
+export declare const LESSON_TYPE_PATTERN = "\u043B\u043A|\u043F\u0440|\u043B\u0431|\u0437\u0430\u0447|\u044D\u043A\u0437|\u043A\u043E\u043D\u0441";
+export declare const FLEXIBLE_LESSON_TYPE_PATTERN = "\u043B\u043A|\u043F\u0440|\u043B\u0431|\u0437\u0430\u0447|\u044D\u043A\u0437|\u043A\u043E\u043D\u0441\\.?|\u042D\u043A\u0437";
+export declare const LESSON_TYPE_RE: RegExp;
+export declare const LESSON_TYPE_RE_I: RegExp;
+export declare const FLEXIBLE_LESSON_TYPE_RE_I: RegExp;
+export declare const LESSON_TYPE_GLOBAL_RE: RegExp;
+export declare const WEEKS_RE: RegExp;
+export declare const WEEKS_GLOBAL_RE: RegExp;
+export declare const SUBGROUP_RE: RegExp;
+export declare const SUBGROUP_ANNOTATION_RE: RegExp;
+export declare const SUBGROUP_ANNOTATION_RE_I: RegExp;

package/dist/tt/parse/patterns.js

@@ -0,0 +1,11 @@
+export const LESSON_TYPE_PATTERN = "лк|пр|лб|зач|экз|конс";
+export const FLEXIBLE_LESSON_TYPE_PATTERN = `${LESSON_TYPE_PATTERN}\\.?|Экз`;
+export const LESSON_TYPE_RE = new RegExp(`\\((${LESSON_TYPE_PATTERN})\\)`);
+export const LESSON_TYPE_RE_I = new RegExp(`\\((${LESSON_TYPE_PATTERN})\\)`, "i");
+export const FLEXIBLE_LESSON_TYPE_RE_I = new RegExp(`\\((${FLEXIBLE_LESSON_TYPE_PATTERN})\\)`, "i");
+export const LESSON_TYPE_GLOBAL_RE = new RegExp(`\\((${LESSON_TYPE_PATTERN})\\)`, "g");
+export const WEEKS_RE = /\(([^)]*нед\.?[^)]*)\)/;
+export const WEEKS_GLOBAL_RE = /\([^)]*нед\.?[^)]*\)/g;
+export const SUBGROUP_RE = /(\d+)\s*подгруппа/;
+export const SUBGROUP_ANNOTATION_RE = /\(\d+\s*подгруппа\)/g;
+export const SUBGROUP_ANNOTATION_RE_I = /\s*\(\s*\d+\s*подгруппа\s*\)\s*/gi;

package/dist/tt/parse/teacher.js

@@ -3,6 +3,7 @@ import { getLessonNumber } from "../utils/index.js";
 import { parseSemesterScheduleWith } from "./full-schedule.js";
 import { parseGroupsString } from "./groups.js";
 import { parseSubstituteForDiv, parseSubstitutionDiv, parseTransferDiv, } from "./overlays.js";
+import { FLEXIBLE_LESSON_TYPE_PATTERN, FLEXIBLE_LESSON_TYPE_RE_I, LESSON_TYPE_RE, SUBGROUP_RE, WEEKS_RE, } from "./patterns.js";
 export function parseTeacherFullSchedule(html, educationType) {
     const doc = parseHtml(html);
     const edType = educationType ?? 1 /* EducationType.HigherEducation */;
@@ -52,11 +53,11 @@ function parseTeacherSemesterEntry(el) {
     const subject = subjectEl ? text(subjectEl) : "";
     if (!subject)
         return null;
-    const typeMatch = cleanText.match(/\((лк|пр|лб|зач|экз|зчО|кр|конс)\)/);
-    const weeksMatch = cleanText.match(/\(([^)]*нед\.?[^)]*)\)/);
+    const typeMatch = cleanText.match(LESSON_TYPE_RE);
+    const weeksMatch = cleanText.match(WEEKS_RE);
     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 subgroupMatch = cleanText.match(SUBGROUP_RE);
     const weekParity = parseWeekParity(cleanHtml);
     return {
         room: roomMatch?.[1] ?? "",
@@ -121,10 +122,10 @@ function parseTeacherSessionEntry(td) {
         return null;
     const roomMatch = fullHtml.match(/^([^<]*?)\s*<span/);
     const room = roomMatch ? roomMatch[1].trim() : "";
-    const typeMatch = plainText.match(/\((лк|пр|лб|зач|экз|зчО|кр|конс\.?|Экз)\)/i);
+    const typeMatch = plainText.match(FLEXIBLE_LESSON_TYPE_RE_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 groupsMatch = fullHtml.match(new RegExp(`\\((?:${FLEXIBLE_LESSON_TYPE_PATTERN})\\)\\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;

package/dist/tt/types.d.ts

@@ -1,3 +1,4 @@
+import type { BlobAdapter, CacheAdapter } from "../common/cache.js";
 import type { Time, WeekRange, Teacher, EducationType } from "../common/types.js";
 export interface Faculty {
     id: number;
@@ -148,6 +149,8 @@ export interface CacheConfig {
     schedule?: number;
     faculties?: number;
     groups?: number;
+    audiences?: number;
+    audienceNames?: number;
     teachers?: number;
     teacherInfo?: number;
     teacherPhotos?: number;
@@ -157,4 +160,6 @@ export interface CacheConfig {
 export interface TtClientOptions {
     educationType?: EducationType;
     cache?: number | CacheConfig;
+    cacheAdapter?: CacheAdapter;
+    blobAdapter?: BlobAdapter;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chuvsu-js",
-  "version": "3.0.2",
+  "version": "4.0.0",
   "description": "Node.js library for ChuvSU student portal (lk.chuvsu.ru) and schedule (tt.chuvsu.ru)",
   "type": "module",
   "main": "dist/index.js",
@@ -42,6 +42,7 @@
   },
   "scripts": {
     "clean": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\"",
-    "build": "pnpm clean && tsc"
+    "build": "pnpm clean && tsc",
+    "test": "pnpm build && node --test"
   }
 }