course-format-ts 1.0.0

package/dist/courseFormat/Tags.d.ts

@@ -0,0 +1,16 @@
+export declare class Tag {
+    readonly text: string;
+    private readonly searchOption;
+    constructor(text: string, searchOption?: string);
+    getSearchText(): string;
+    accept(filter: string): boolean;
+}
+export declare class ProgrammingLanguageTag extends Tag {
+    constructor(language: string);
+}
+export declare class HumanLanguageTag extends Tag {
+    constructor(languageName: string);
+}
+export declare class FeaturedTag extends Tag {
+    constructor();
+}

package/dist/courseFormat/Tags.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeaturedTag = exports.HumanLanguageTag = exports.ProgrammingLanguageTag = exports.Tag = void 0;
+const uiMessages_1 = require("./uiMessages");
+const PROGRAMMING_LANGUAGE_TAG_SEARCH_OPTION = "programming_language";
+const LANGUAGE_TAG_SEARCH_OPTION = "language";
+class Tag {
+    constructor(text, searchOption = "tag") {
+        this.text = text;
+        this.searchOption = searchOption;
+    }
+    getSearchText() {
+        return `${this.searchOption}:${this.text}`.toLowerCase();
+    }
+    accept(filter) {
+        const textInLowerCase = this.text.toLowerCase();
+        if (textInLowerCase.includes(filter)) {
+            return true;
+        }
+        const searchPrefix = `${this.searchOption}:`;
+        return filter.startsWith(searchPrefix) && textInLowerCase.includes(filter.substring(searchPrefix.length));
+    }
+}
+exports.Tag = Tag;
+class ProgrammingLanguageTag extends Tag {
+    constructor(language) {
+        super(language, PROGRAMMING_LANGUAGE_TAG_SEARCH_OPTION);
+    }
+}
+exports.ProgrammingLanguageTag = ProgrammingLanguageTag;
+class HumanLanguageTag extends Tag {
+    constructor(languageName) {
+        super(languageName, LANGUAGE_TAG_SEARCH_OPTION);
+    }
+}
+exports.HumanLanguageTag = HumanLanguageTag;
+class FeaturedTag extends Tag {
+    constructor() {
+        super((0, uiMessages_1.message)("course.dialog.tags.featured"));
+    }
+}
+exports.FeaturedTag = FeaturedTag;

package/dist/courseFormat/TaskFile.d.ts

@@ -0,0 +1,26 @@
+import { EduFile } from "./EduFile";
+import { AnswerPlaceholder } from "./AnswerPlaceholder";
+import type { Task } from "./tasks/Task";
+import { FileContents } from "./FileContents";
+export declare class TaskFile extends EduFile {
+    private _answerPlaceholders;
+    private _task?;
+    isVisible: boolean;
+    constructor();
+    constructor(name: string, text: string);
+    constructor(name: string, contents: FileContents);
+    constructor(name: string, text: string, isVisible: boolean);
+    constructor(name: string, text: string, isVisible: boolean, isLearnerCreated: boolean);
+    get answerPlaceholders(): AnswerPlaceholder[];
+    set answerPlaceholders(value: AnswerPlaceholder[]);
+    get task(): Task;
+    set task(value: Task);
+    initTaskFile(task: Task, isRestarted: boolean): void;
+    addAnswerPlaceholder(answerPlaceholder: AnswerPlaceholder): void;
+    removeAnswerPlaceholder(answerPlaceholder: AnswerPlaceholder): void;
+    getAnswerPlaceholder(offset: number): AnswerPlaceholder | undefined;
+    removeAllPlaceholders(): void;
+    sortAnswerPlaceholders(): void;
+    hasFailedPlaceholders(): boolean;
+    isValid(text: string): boolean;
+}

package/dist/courseFormat/TaskFile.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskFile = void 0;
+const EduFile_1 = require("./EduFile");
+const AnswerPlaceholderComparator_1 = require("./AnswerPlaceholderComparator");
+const CheckStatus_1 = require("./CheckStatus");
+class TaskFile extends EduFile_1.EduFile {
+    constructor(name, textOrContents, isVisible, isLearnerCreated) {
+        super();
+        this._answerPlaceholders = [];
+        this.isVisible = true;
+        if (name !== undefined)
+            this.name = name;
+        if (typeof textOrContents === "string") {
+            this.text = textOrContents;
+        }
+        else if (textOrContents) {
+            this.contents = textOrContents;
+        }
+        if (isVisible !== undefined)
+            this.isVisible = isVisible;
+        if (isLearnerCreated !== undefined)
+            this.isLearnerCreated = isLearnerCreated;
+    }
+    get answerPlaceholders() {
+        return this._answerPlaceholders;
+    }
+    set answerPlaceholders(value) {
+        this._answerPlaceholders = [...value];
+    }
+    get task() {
+        if (!this._task) {
+            throw new Error(`Task is null for TaskFile ${this.name}`);
+        }
+        return this._task;
+    }
+    set task(value) {
+        this._task = value;
+    }
+    initTaskFile(task, isRestarted) {
+        this.task = task;
+        for (const answerPlaceholder of this._answerPlaceholders) {
+            answerPlaceholder.init(this, isRestarted);
+        }
+        this.sortAnswerPlaceholders();
+    }
+    addAnswerPlaceholder(answerPlaceholder) {
+        this._answerPlaceholders.push(answerPlaceholder);
+    }
+    removeAnswerPlaceholder(answerPlaceholder) {
+        this._answerPlaceholders = this._answerPlaceholders.filter((item) => item !== answerPlaceholder);
+    }
+    getAnswerPlaceholder(offset) {
+        return this._answerPlaceholders.find((placeholder) => offset >= placeholder.offset && offset <= placeholder.endOffset);
+    }
+    removeAllPlaceholders() {
+        this._answerPlaceholders = [];
+    }
+    sortAnswerPlaceholders() {
+        this._answerPlaceholders.sort(AnswerPlaceholderComparator_1.AnswerPlaceholderComparator.compare);
+        this._answerPlaceholders.forEach((placeholder, index) => {
+            placeholder.index = index;
+        });
+    }
+    hasFailedPlaceholders() {
+        return this._answerPlaceholders.some((placeholder) => placeholder.status === CheckStatus_1.CheckStatus.Failed);
+    }
+    isValid(text) {
+        return this._answerPlaceholders.every((placeholder) => placeholder.isValid(text.length));
+    }
+}
+exports.TaskFile = TaskFile;

package/dist/courseFormat/UserInfo.d.ts

@@ -0,0 +1,3 @@
+export interface UserInfo {
+    getFullName(): string;
+}

package/dist/courseFormat/UserInfo.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/courseFormat/Vendor.d.ts

@@ -0,0 +1,7 @@
+export declare class Vendor {
+    readonly name: string;
+    readonly email?: string;
+    readonly url?: string;
+    constructor(name?: string, email?: string | null, url?: string | null);
+    toString(): string;
+}

package/dist/courseFormat/Vendor.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Vendor = void 0;
+class Vendor {
+    constructor(name = "", email, url) {
+        this.name = name;
+        this.email = email !== null && email !== void 0 ? email : undefined;
+        this.url = url !== null && url !== void 0 ? url : undefined;
+    }
+    toString() {
+        return this.name;
+    }
+}
+exports.Vendor = Vendor;

package/dist/courseFormat/attempts/Attempt.d.ts

@@ -0,0 +1,12 @@
+import { AttemptBase } from "./AttemptBase";
+import { Dataset } from "./Dataset";
+export declare class Attempt extends AttemptBase {
+    step: number;
+    dataset: Dataset | null;
+    status: string | null;
+    user: string | null;
+    get isActive(): boolean;
+    constructor();
+    constructor(step: number);
+    constructor(id: number, time: Date, timeLeft: number);
+}

package/dist/courseFormat/attempts/Attempt.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Attempt = void 0;
+const AttemptBase_1 = require("./AttemptBase");
+class Attempt extends AttemptBase_1.AttemptBase {
+    get isActive() {
+        return this.status === "active";
+    }
+    constructor(stepOrId, time, timeLeft) {
+        super();
+        this.step = 0;
+        this.dataset = null;
+        this.status = null;
+        this.user = null;
+        if (stepOrId !== undefined && time === undefined) {
+            this.step = stepOrId;
+        }
+        else if (stepOrId !== undefined && time !== undefined) {
+            this.id = stepOrId;
+            this.time = time;
+            this.timeLeft = timeLeft !== null && timeLeft !== void 0 ? timeLeft : null;
+        }
+    }
+}
+exports.Attempt = Attempt;

package/dist/courseFormat/attempts/AttemptBase.d.ts

@@ -0,0 +1,9 @@
+export declare abstract class AttemptBase {
+    id: number;
+    time: Date;
+    timeLeft: number | null;
+    get isRunning(): boolean;
+    protected calculateEndDateTime(): Date | null;
+    constructor();
+    constructor(id: number, time: Date, timeLeft: number | null);
+}

package/dist/courseFormat/attempts/AttemptBase.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AttemptBase = void 0;
+class AttemptBase {
+    get isRunning() {
+        const endDateTime = this.calculateEndDateTime();
+        if (endDateTime === null)
+            return true;
+        return new Date() < endDateTime;
+    }
+    calculateEndDateTime() {
+        if (this.timeLeft === null)
+            return null;
+        return new Date(this.time.getTime() + this.timeLeft * 1000);
+    }
+    constructor(id, time, timeLeft) {
+        this.id = 0;
+        this.time = new Date();
+        this.timeLeft = null;
+        if (id !== undefined)
+            this.id = id;
+        if (time !== undefined)
+            this.time = time;
+        if (timeLeft !== undefined)
+            this.timeLeft = timeLeft;
+    }
+}
+exports.AttemptBase = AttemptBase;

package/dist/courseFormat/attempts/DataTaskAttempt.d.ts

@@ -0,0 +1,6 @@
+import { AttemptBase } from "./AttemptBase";
+export declare class DataTaskAttempt extends AttemptBase {
+    endDateTime: Date | null;
+    get isRunning(): boolean;
+    static fromAttempt(attempt: AttemptBase): DataTaskAttempt;
+}

package/dist/courseFormat/attempts/DataTaskAttempt.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataTaskAttempt = void 0;
+const AttemptBase_1 = require("./AttemptBase");
+class DataTaskAttempt extends AttemptBase_1.AttemptBase {
+    constructor() {
+        super(...arguments);
+        this.endDateTime = null;
+    }
+    get isRunning() {
+        if (this.endDateTime === null)
+            return true;
+        return new Date() < this.endDateTime;
+    }
+    static fromAttempt(attempt) {
+        const result = new DataTaskAttempt();
+        result.id = attempt.id;
+        result.time = attempt.time;
+        result.timeLeft = attempt.timeLeft;
+        result.endDateTime = result.calculateEndDateTime();
+        return result;
+    }
+}
+exports.DataTaskAttempt = DataTaskAttempt;

package/dist/courseFormat/attempts/Dataset.d.ts

@@ -0,0 +1,12 @@
+export declare class Dataset {
+    isMultipleChoice: boolean;
+    options: string[] | null;
+    pairs: Pair[] | null;
+    rows: string[] | null;
+    columns: string[] | null;
+    isCheckbox: boolean;
+}
+export declare class Pair {
+    first: string;
+    second: string;
+}

package/dist/courseFormat/attempts/Dataset.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Pair = exports.Dataset = void 0;
+class Dataset {
+    constructor() {
+        this.isMultipleChoice = false;
+        this.options = null;
+        this.pairs = null;
+        this.rows = null;
+        this.columns = null;
+        this.isCheckbox = false;
+    }
+}
+exports.Dataset = Dataset;
+class Pair {
+    constructor() {
+        this.first = "";
+        this.second = "";
+    }
+}
+exports.Pair = Pair;

package/dist/courseFormat/fileUtils.d.ts

@@ -0,0 +1,5 @@
+export declare function isBinary(contentType: string): boolean;
+export declare function mimeFileType(path: string): string | false | undefined;
+export declare function exceedsBase64ContentLimit(base64text: string): boolean;
+export declare function getBinaryFileLimit(): number;
+export declare function getExtension(fileName: string): string;

package/dist/courseFormat/fileUtils.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBinary = isBinary;
+exports.mimeFileType = mimeFileType;
+exports.exceedsBase64ContentLimit = exceedsBase64ContentLimit;
+exports.getBinaryFileLimit = getBinaryFileLimit;
+exports.getExtension = getExtension;
+const mime_types_1 = require("mime-types");
+const loggerUtils_1 = require("./loggerUtils");
+const mimeBinaryTypes = ["image", "audio", "video", "application", "font"].map((type) => `${type}/`);
+function isBinary(contentType) {
+    return mimeBinaryTypes.some((prefix) => contentType.startsWith(prefix));
+}
+function mimeFileType(path) {
+    try {
+        return (0, mime_types_1.lookup)(path);
+    }
+    catch (error) {
+        (0, loggerUtils_1.logger)("fileUtils").error("Failed to determine file mimetype", error);
+        return undefined;
+    }
+}
+function exceedsBase64ContentLimit(base64text) {
+    return Buffer.from(base64text, "utf16le").byteLength > getBinaryFileLimit();
+}
+function getBinaryFileLimit() {
+    return 1024 * 1024;
+}
+function getExtension(fileName) {
+    const index = fileName.lastIndexOf(".");
+    return index < 0 ? "" : fileName.substring(index + 1);
+}

package/dist/courseFormat/hyperskill/HyperskillCourse.d.ts

@@ -0,0 +1,13 @@
+import { Course } from "../Course";
+import { HyperskillProject } from "./HyperskillProject";
+import { HyperskillStage } from "./HyperskillStage";
+import { HyperskillTopic } from "./HyperskillTopic";
+export declare class HyperskillCourse extends Course {
+    taskToTopics: Map<number, HyperskillTopic[]>;
+    stages: HyperskillStage[];
+    hyperskillProject: HyperskillProject | null;
+    selectedStage: number | null;
+    selectedProblem: number | null;
+    get itemType(): string;
+    get isTemplateBased(): boolean;
+}

package/dist/courseFormat/hyperskill/HyperskillCourse.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HyperskillCourse = void 0;
+const Course_1 = require("../Course");
+const EduFormatNames_1 = require("../EduFormatNames");
+class HyperskillCourse extends Course_1.Course {
+    constructor() {
+        super(...arguments);
+        this.taskToTopics = new Map();
+        this.stages = [];
+        this.hyperskillProject = null;
+        this.selectedStage = null;
+        this.selectedProblem = null;
+    }
+    get itemType() {
+        return EduFormatNames_1.HYPERSKILL;
+    }
+    get isTemplateBased() {
+        if (!this.hyperskillProject) {
+            throw new Error("Disconnected Hyperskill project");
+        }
+        return this.hyperskillProject.isTemplateBased;
+    }
+}
+exports.HyperskillCourse = HyperskillCourse;

package/dist/courseFormat/hyperskill/HyperskillProject.d.ts

@@ -0,0 +1,10 @@
+export declare class HyperskillProject {
+    id: number;
+    title: string;
+    description: string;
+    ideFiles: string;
+    useIde: boolean;
+    language: string;
+    environment: string | null;
+    isTemplateBased: boolean;
+}

package/dist/courseFormat/hyperskill/HyperskillProject.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HyperskillProject = void 0;
+class HyperskillProject {
+    constructor() {
+        this.id = -1;
+        this.title = "";
+        this.description = "";
+        this.ideFiles = "";
+        this.useIde = true;
+        this.language = "";
+        this.environment = null;
+        this.isTemplateBased = false;
+    }
+}
+exports.HyperskillProject = HyperskillProject;

package/dist/courseFormat/hyperskill/HyperskillStage.d.ts

@@ -0,0 +1,8 @@
+export declare class HyperskillStage {
+    id: number;
+    title: string;
+    stepId: number;
+    isCompleted: boolean;
+    constructor();
+    constructor(stageId: number, stageTitle: string, stageStepId: number, isStageCompleted: boolean);
+}

package/dist/courseFormat/hyperskill/HyperskillStage.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HyperskillStage = void 0;
+class HyperskillStage {
+    constructor(stageId, stageTitle, stageStepId, isStageCompleted) {
+        this.id = -1;
+        this.title = "";
+        this.stepId = -1;
+        this.isCompleted = false;
+        if (stageId !== undefined)
+            this.id = stageId;
+        if (stageTitle !== undefined)
+            this.title = stageTitle;
+        if (stageStepId !== undefined)
+            this.stepId = stageStepId;
+        if (isStageCompleted !== undefined)
+            this.isCompleted = isStageCompleted;
+    }
+}
+exports.HyperskillStage = HyperskillStage;

package/dist/courseFormat/hyperskill/HyperskillTaskType.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Maps Hyperskill task type IDs to their human-readable labels.
+ */
+export declare const HYPERSKILL_TASK_TYPE_LABELS: Record<string, string>;

package/dist/courseFormat/hyperskill/HyperskillTaskType.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HYPERSKILL_TASK_TYPE_LABELS = void 0;
+/**
+ * Maps Hyperskill task type IDs to their human-readable labels.
+ */
+exports.HYPERSKILL_TASK_TYPE_LABELS = {
+    admin: "Linux",
+    choice: "Quiz",
+    code: "Programming",
+    dataset: "Data",
+    "fill-blanks": "Fill Blanks",
+    "free-answer": "Free Response",
+    "manual-score": "Manual Score",
+    matching: "Matching",
+    math: "Math",
+    number: "Number",
+    parsons: "Parsons",
+    pycharm: "Programming",
+    remote_edu: "Programming",
+    sorting: "Sorting",
+    string: "Text",
+    table: "Table",
+    text: "Theory",
+    video: "Video",
+};

package/dist/courseFormat/hyperskill/HyperskillTopic.d.ts

@@ -0,0 +1,5 @@
+export declare class HyperskillTopic {
+    id: number;
+    title: string;
+    theoryId: number | null;
+}

package/dist/courseFormat/hyperskill/HyperskillTopic.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HyperskillTopic = void 0;
+class HyperskillTopic {
+    constructor() {
+        this.id = -1;
+        this.title = "";
+        this.theoryId = null;
+    }
+}
+exports.HyperskillTopic = HyperskillTopic;

package/dist/courseFormat/loggerUtils.d.ts

@@ -0,0 +1 @@
+export declare function logger(name: string): Console;

package/dist/courseFormat/loggerUtils.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = logger;
+function logger(name) {
+    return console;
+}

package/dist/courseFormat/stepik/StepikCourse.d.ts

@@ -0,0 +1,5 @@
+import { EduCourse } from "../EduCourse";
+export declare class StepikCourse extends EduCourse {
+    isAdaptive: boolean;
+    get itemType(): string;
+}

package/dist/courseFormat/stepik/StepikCourse.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StepikCourse = void 0;
+const EduCourse_1 = require("../EduCourse");
+const EduFormatNames_1 = require("../EduFormatNames");
+class StepikCourse extends EduCourse_1.EduCourse {
+    constructor() {
+        super(...arguments);
+        this.isAdaptive = false;
+    }
+    get itemType() {
+        return EduFormatNames_1.STEPIK;
+    }
+}
+exports.StepikCourse = StepikCourse;

package/dist/courseFormat/stepik/StepikLesson.d.ts

@@ -0,0 +1,6 @@
+import { Lesson } from "../Lesson";
+export declare class StepikLesson extends Lesson {
+    stepIds: number[];
+    unitId: number;
+    get itemType(): string;
+}

package/dist/courseFormat/stepik/StepikLesson.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StepikLesson = void 0;
+const Lesson_1 = require("../Lesson");
+const EduFormatNames_1 = require("../EduFormatNames");
+class StepikLesson extends Lesson_1.Lesson {
+    constructor() {
+        super(...arguments);
+        this.stepIds = [];
+        this.unitId = 0;
+    }
+    get itemType() {
+        return EduFormatNames_1.STEPIK;
+    }
+}
+exports.StepikLesson = StepikLesson;

package/dist/courseFormat/tasks/AnswerTask.d.ts

@@ -0,0 +1,8 @@
+import { CheckStatus } from "../CheckStatus";
+import { Task } from "./Task";
+export declare abstract class AnswerTask extends Task {
+    static ANSWER_FILE_NAME: string;
+    constructor();
+    constructor(name: string);
+    constructor(name: string, id: number, position: number, updateDate: Date, status: CheckStatus);
+}

package/dist/courseFormat/tasks/AnswerTask.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnswerTask = void 0;
+const Task_1 = require("./Task");
+class AnswerTask extends Task_1.Task {
+    constructor(name, id, position, updateDate, status) {
+        super(name, id, position, updateDate, status);
+    }
+}
+exports.AnswerTask = AnswerTask;
+AnswerTask.ANSWER_FILE_NAME = "answer.txt";

package/dist/courseFormat/tasks/CodeTask.d.ts

@@ -0,0 +1,12 @@
+import { CheckStatus } from "../CheckStatus";
+import { Task } from "./Task";
+export declare class CodeTask extends Task {
+    submissionLanguage?: string;
+    constructor();
+    constructor(name: string);
+    constructor(name: string, id: number, position: number, updateDate: Date, status: CheckStatus, submissionLanguage?: string | null);
+    get itemType(): string;
+    get supportSubmissions(): boolean;
+    get isPluginTaskType(): boolean;
+    static CODE_TASK_TYPE: string;
+}

package/dist/courseFormat/tasks/CodeTask.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeTask = void 0;
+const Task_1 = require("./Task");
+class CodeTask extends Task_1.Task {
+    constructor(name, id, position, updateDate, status, submissionLanguage) {
+        super(name, id, position, updateDate, status);
+        this.submissionLanguage = submissionLanguage !== null && submissionLanguage !== void 0 ? submissionLanguage : undefined;
+    }
+    get itemType() {
+        return CodeTask.CODE_TASK_TYPE;
+    }
+    get supportSubmissions() {
+        return true;
+    }
+    get isPluginTaskType() {
+        return false;
+    }
+}
+exports.CodeTask = CodeTask;
+CodeTask.CODE_TASK_TYPE = "code";