course-format-ts 1.0.0

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

@@ -0,0 +1,18 @@
+import { CheckStatus } from "../CheckStatus";
+import { Task } from "./Task";
+import type { DataTaskAttempt } from "../attempts/DataTaskAttempt";
+export declare class DataTask extends Task {
+    attempt?: DataTaskAttempt;
+    get isTimeLimited(): boolean;
+    constructor();
+    constructor(name: string);
+    constructor(name: string, id: number, position: number, updateDate: Date, status: CheckStatus);
+    get itemType(): string;
+    get supportSubmissions(): boolean;
+    isRunning(): boolean;
+    static DATA_TASK_TYPE: string;
+    static DATA_FOLDER_NAME: string;
+    static DATA_SAMPLE_FOLDER_NAME: string;
+    static DATASET_FOLDER_NAME: string;
+    static INPUT_FILE_NAME: string;
+}

package/dist/courseFormat/tasks/DataTask.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataTask = void 0;
+const CheckStatus_1 = require("../CheckStatus");
+const Task_1 = require("./Task");
+class DataTask extends Task_1.Task {
+    get isTimeLimited() {
+        var _a;
+        return ((_a = this.attempt) === null || _a === void 0 ? void 0 : _a.endDateTime) !== undefined;
+    }
+    constructor(name, id, position, updateDate, status) {
+        super(name, id, position, updateDate, status);
+    }
+    get itemType() {
+        return DataTask.DATA_TASK_TYPE;
+    }
+    get supportSubmissions() {
+        return false;
+    }
+    isRunning() {
+        var _a, _b;
+        if (this.status !== CheckStatus_1.CheckStatus.Unchecked)
+            return false;
+        return (_b = (_a = this.attempt) === null || _a === void 0 ? void 0 : _a.isRunning) !== null && _b !== void 0 ? _b : false;
+    }
+}
+exports.DataTask = DataTask;
+DataTask.DATA_TASK_TYPE = "dataset";
+DataTask.DATA_FOLDER_NAME = "data";
+DataTask.DATA_SAMPLE_FOLDER_NAME = "sample";
+DataTask.DATASET_FOLDER_NAME = "dataset";
+DataTask.INPUT_FILE_NAME = "input.txt";

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

@@ -0,0 +1,12 @@
+import { CheckStatus } from "../CheckStatus";
+import { Task } from "./Task";
+export declare class EduTask extends Task {
+    constructor();
+    constructor(name: string);
+    constructor(name: string, id: number, position: number, updateDate: Date, status: CheckStatus);
+    get itemType(): string;
+    get isToSubmitToRemote(): boolean;
+    get supportSubmissions(): boolean;
+    static EDU_TASK_TYPE: string;
+    static PYCHARM_TASK_TYPE: string;
+}

package/dist/courseFormat/tasks/EduTask.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EduTask = void 0;
+const CheckStatus_1 = require("../CheckStatus");
+const Task_1 = require("./Task");
+class EduTask extends Task_1.Task {
+    constructor(name, id, position, updateDate, status) {
+        super(name, id, position, updateDate, status);
+    }
+    get itemType() {
+        return EduTask.EDU_TASK_TYPE;
+    }
+    get isToSubmitToRemote() {
+        return this.checkStatus !== CheckStatus_1.CheckStatus.Unchecked;
+    }
+    get supportSubmissions() {
+        return true;
+    }
+}
+exports.EduTask = EduTask;
+EduTask.EDU_TASK_TYPE = "edu";
+EduTask.PYCHARM_TASK_TYPE = "pycharm";

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

@@ -0,0 +1,9 @@
+import { CheckStatus } from "../CheckStatus";
+import { Task } from "./Task";
+export declare class IdeTask extends Task {
+    constructor();
+    constructor(name: string);
+    constructor(name: string, id: number, position: number, updateDate: Date, status: CheckStatus);
+    get itemType(): string;
+    static IDE_TASK_TYPE: string;
+}

package/dist/courseFormat/tasks/IdeTask.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdeTask = void 0;
+const Task_1 = require("./Task");
+class IdeTask extends Task_1.Task {
+    constructor(name, id, position, updateDate, status) {
+        super(name, id, position, updateDate, status);
+    }
+    get itemType() {
+        return IdeTask.IDE_TASK_TYPE;
+    }
+}
+exports.IdeTask = IdeTask;
+IdeTask.IDE_TASK_TYPE = "ide";

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

@@ -0,0 +1,9 @@
+import { CheckStatus } from "../CheckStatus";
+import { AnswerTask } from "./AnswerTask";
+export declare class NumberTask extends AnswerTask {
+    constructor();
+    constructor(name: string);
+    constructor(name: string, id: number, position: number, updateDate: Date, status: CheckStatus);
+    get itemType(): string;
+    static NUMBER_TASK_TYPE: string;
+}

package/dist/courseFormat/tasks/NumberTask.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NumberTask = void 0;
+const AnswerTask_1 = require("./AnswerTask");
+class NumberTask extends AnswerTask_1.AnswerTask {
+    constructor(name, id, position, updateDate, status) {
+        super(name, id, position, updateDate, status);
+    }
+    get itemType() {
+        return NumberTask.NUMBER_TASK_TYPE;
+    }
+}
+exports.NumberTask = NumberTask;
+NumberTask.NUMBER_TASK_TYPE = "number";

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

@@ -0,0 +1,10 @@
+import { CheckStatus } from "../CheckStatus";
+import { OutputTaskBase } from "./OutputTaskBase";
+export declare class OutputTask extends OutputTaskBase {
+    constructor();
+    constructor(name: string);
+    constructor(name: string, id: number, position: number, updateDate: Date, status: CheckStatus);
+    get itemType(): string;
+    get isToSubmitToRemote(): boolean;
+    static OUTPUT_TASK_TYPE: string;
+}

package/dist/courseFormat/tasks/OutputTask.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OutputTask = void 0;
+const CheckStatus_1 = require("../CheckStatus");
+const OutputTaskBase_1 = require("./OutputTaskBase");
+class OutputTask extends OutputTaskBase_1.OutputTaskBase {
+    constructor(name, id, position, updateDate, status) {
+        super(name, id, position, updateDate, status);
+    }
+    get itemType() {
+        return OutputTask.OUTPUT_TASK_TYPE;
+    }
+    get isToSubmitToRemote() {
+        return this.checkStatus !== CheckStatus_1.CheckStatus.Unchecked;
+    }
+}
+exports.OutputTask = OutputTask;
+OutputTask.OUTPUT_TASK_TYPE = "output";

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

@@ -0,0 +1,14 @@
+import { CheckStatus } from "../CheckStatus";
+import { Task } from "./Task";
+export declare abstract class OutputTaskBase extends Task {
+    inputFileName: string;
+    outputFileName: string;
+    latestOutputFileName: string;
+    constructor();
+    constructor(name: string);
+    constructor(name: string, id: number, position: number, updateDate: Date, status: CheckStatus);
+    get supportSubmissions(): boolean;
+    static OUTPUT_PATTERN_NAME: string;
+    static INPUT_PATTERN_NAME: string;
+    static LATEST_OUTPUT_PATTERN_NAME: string;
+}

package/dist/courseFormat/tasks/OutputTaskBase.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OutputTaskBase = void 0;
+const Task_1 = require("./Task");
+class OutputTaskBase extends Task_1.Task {
+    constructor(name, id, position, updateDate, status) {
+        super(name, id, position, updateDate, status);
+        this.inputFileName = OutputTaskBase.INPUT_PATTERN_NAME;
+        this.outputFileName = OutputTaskBase.OUTPUT_PATTERN_NAME;
+        this.latestOutputFileName = OutputTaskBase.LATEST_OUTPUT_PATTERN_NAME;
+    }
+    get supportSubmissions() {
+        return true;
+    }
+}
+exports.OutputTaskBase = OutputTaskBase;
+OutputTaskBase.OUTPUT_PATTERN_NAME = "output.txt";
+OutputTaskBase.INPUT_PATTERN_NAME = "input.txt";
+OutputTaskBase.LATEST_OUTPUT_PATTERN_NAME = "latest_output.txt";

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

@@ -0,0 +1,9 @@
+import { CheckStatus } from "../CheckStatus";
+import { EduTask } from "./EduTask";
+export declare class RemoteEduTask extends EduTask {
+    checkProfile: string;
+    constructor();
+    constructor(name: string, id: number, position: number, updateDate: Date, status: CheckStatus);
+    get itemType(): string;
+    static REMOTE_EDU_TASK_TYPE: string;
+}

package/dist/courseFormat/tasks/RemoteEduTask.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemoteEduTask = void 0;
+const EduTask_1 = require("./EduTask");
+class RemoteEduTask extends EduTask_1.EduTask {
+    constructor(name, id, position, updateDate, status) {
+        super(name, id, position, updateDate, status);
+        this.checkProfile = "";
+    }
+    get itemType() {
+        return RemoteEduTask.REMOTE_EDU_TASK_TYPE;
+    }
+}
+exports.RemoteEduTask = RemoteEduTask;
+RemoteEduTask.REMOTE_EDU_TASK_TYPE = "remote_edu";

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

@@ -0,0 +1,9 @@
+import { CheckStatus } from "../CheckStatus";
+import { AnswerTask } from "./AnswerTask";
+export declare class StringTask extends AnswerTask {
+    constructor();
+    constructor(name: string);
+    constructor(name: string, id: number, position: number, updateDate: Date, status: CheckStatus);
+    get itemType(): string;
+    static STRING_TASK_TYPE: string;
+}

package/dist/courseFormat/tasks/StringTask.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringTask = void 0;
+const AnswerTask_1 = require("./AnswerTask");
+class StringTask extends AnswerTask_1.AnswerTask {
+    constructor(name, id, position, updateDate, status) {
+        super(name, id, position, updateDate, status);
+    }
+    get itemType() {
+        return StringTask.STRING_TASK_TYPE;
+    }
+}
+exports.StringTask = StringTask;
+StringTask.STRING_TASK_TYPE = "string";

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

@@ -0,0 +1,17 @@
+import { CheckStatus } from "../CheckStatus";
+import { Task } from "./Task";
+export declare class TableTask extends Task {
+    isMultipleChoice: boolean;
+    rows: string[];
+    columns: string[];
+    selected: boolean[][];
+    constructor();
+    constructor(name: string);
+    constructor(name: string, id: number, position: number, updateDate: Date, status: CheckStatus);
+    get itemType(): string;
+    choose(rowIndex: number, columnIndex: number): void;
+    clearSelectedVariants(): void;
+    private clearSelectedInRow;
+    createTable(rows: string[], columns: string[], isCheckbox?: boolean): void;
+    static TABLE_TASK_TYPE: string;
+}

package/dist/courseFormat/tasks/TableTask.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TableTask = void 0;
+const Task_1 = require("./Task");
+const loggerUtils_1 = require("../loggerUtils");
+class TableTask extends Task_1.Task {
+    constructor(name, id, position, updateDate, status) {
+        super(name, id, position, updateDate, status);
+        this.isMultipleChoice = false;
+        this.rows = [];
+        this.columns = [];
+        this.selected = [];
+    }
+    get itemType() {
+        return TableTask.TABLE_TASK_TYPE;
+    }
+    choose(rowIndex, columnIndex) {
+        if (rowIndex < 0 || rowIndex >= this.rows.length || columnIndex < 0 || columnIndex >= this.columns.length) {
+            (0, loggerUtils_1.logger)("TableTask").error("There was an attempt to choose a cell with invalid indices");
+            return;
+        }
+        if (!this.isMultipleChoice) {
+            this.clearSelectedInRow(rowIndex);
+        }
+        this.selected[rowIndex][columnIndex] = !this.selected[rowIndex][columnIndex];
+    }
+    clearSelectedVariants() {
+        for (let rowIndex = 0; rowIndex < this.selected.length; rowIndex += 1) {
+            this.clearSelectedInRow(rowIndex);
+        }
+    }
+    clearSelectedInRow(rowIndex) {
+        this.selected[rowIndex] = this.selected[rowIndex].map(() => false);
+    }
+    createTable(rows, columns, isCheckbox = false) {
+        this.rows = rows;
+        this.columns = columns;
+        this.isMultipleChoice = isCheckbox;
+        this.selected = rows.map(() => columns.map(() => false));
+    }
+}
+exports.TableTask = TableTask;
+TableTask.TABLE_TASK_TYPE = "table";

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

@@ -0,0 +1,45 @@
+import { CheckFeedback } from "../CheckFeedback";
+import { CheckStatus } from "../CheckStatus";
+import { DescriptionFormat } from "../DescriptionFormat";
+import { ItemContainer } from "../ItemContainer";
+import type { Lesson } from "../Lesson";
+import { Course } from "../Course";
+import { TaskFile } from "../TaskFile";
+import { StudyItem } from "../StudyItem";
+export declare abstract class Task extends StudyItem {
+    private _taskFiles;
+    get taskFiles(): Map<string, TaskFile>;
+    set taskFiles(value: Map<string, TaskFile>);
+    feedback?: CheckFeedback;
+    descriptionText: string;
+    descriptionFormat: DescriptionFormat;
+    feedbackLink?: string;
+    solutionHidden?: boolean;
+    record: number;
+    isUpToDate: boolean;
+    protected checkStatus: CheckStatus;
+    get status(): CheckStatus;
+    set status(status: CheckStatus);
+    get lesson(): Lesson;
+    get isPluginTaskType(): boolean;
+    get supportSubmissions(): boolean;
+    get isToSubmitToRemote(): boolean;
+    get isChangedOnFailed(): boolean;
+    get course(): Course;
+    get files(): TaskFile[];
+    constructor();
+    constructor(name: string);
+    constructor(name: string, id: number, position: number, updateDate: Date, status: CheckStatus);
+    init(parentItem: ItemContainer, isRestarted: boolean): void;
+    getTaskFile(name: string): TaskFile | undefined;
+    addTaskFile(name: string, isVisible?: boolean): TaskFile;
+    addTaskFileInstance(taskFile: TaskFile): void;
+    addTaskFileAt(taskFile: TaskFile, position: number): void;
+    setTaskFileValues(taskFiles: TaskFile[]): void;
+    getTaskFileValues(): TaskFile[];
+    removeTaskFile(taskFile: string): TaskFile | undefined;
+    taskFileIndex(taskFile: string): number | undefined;
+    equals(other: Task): boolean;
+    hashCode(): number;
+    static LOG: Console;
+}

package/dist/courseFormat/tasks/Task.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Task = void 0;
+const CheckStatus_1 = require("../CheckStatus");
+const DescriptionFormat_1 = require("../DescriptionFormat");
+const TaskFile_1 = require("../TaskFile");
+const StudyItem_1 = require("../StudyItem");
+const loggerUtils_1 = require("../loggerUtils");
+function getLessonModuleLazy() {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    return require("../Lesson");
+}
+class Task extends StudyItem_1.StudyItem {
+    get taskFiles() {
+        return this._taskFiles;
+    }
+    set taskFiles(value) {
+        this._taskFiles = value;
+    }
+    get status() {
+        return this.checkStatus;
+    }
+    set status(status) {
+        for (const taskFile of this._taskFiles.values()) {
+            for (const placeholder of taskFile.answerPlaceholders) {
+                placeholder.status = status;
+            }
+        }
+        if (this.checkStatus !== status) {
+            this.feedback = undefined;
+        }
+        this.checkStatus = status;
+    }
+    get lesson() {
+        const LessonClass = getLessonModuleLazy().Lesson;
+        if (!(this.parent instanceof LessonClass)) {
+            throw new Error(`Lesson is null for task ${this.name}`);
+        }
+        return this.parent;
+    }
+    get isPluginTaskType() {
+        return true;
+    }
+    get supportSubmissions() {
+        return false;
+    }
+    get isToSubmitToRemote() {
+        return false;
+    }
+    get isChangedOnFailed() {
+        return false;
+    }
+    get course() {
+        return this.lesson.course;
+    }
+    get files() {
+        return this.getTaskFileValues();
+    }
+    constructor(name, id, position, updateDate, status) {
+        super(name);
+        this._taskFiles = new Map();
+        this.descriptionText = "";
+        this.descriptionFormat = DescriptionFormat_1.DescriptionFormat.MD;
+        this.record = -1;
+        this.isUpToDate = true;
+        this.checkStatus = CheckStatus_1.CheckStatus.Unchecked;
+        if (id !== undefined)
+            this.id = id;
+        if (position !== undefined)
+            this.index = position;
+        if (updateDate !== undefined)
+            this.updateDate = updateDate;
+        if (status !== undefined)
+            this.checkStatus = status;
+    }
+    init(parentItem, isRestarted) {
+        this.parent = parentItem;
+        for (const taskFile of this._taskFiles.values()) {
+            taskFile.initTaskFile(this, isRestarted);
+        }
+    }
+    getTaskFile(name) {
+        return this._taskFiles.get(name);
+    }
+    addTaskFile(name, isVisible = true) {
+        const taskFile = new TaskFile_1.TaskFile();
+        taskFile.task = this;
+        taskFile.name = name;
+        taskFile.isVisible = isVisible;
+        this._taskFiles.set(name, taskFile);
+        return taskFile;
+    }
+    addTaskFileInstance(taskFile) {
+        taskFile.task = this;
+        this._taskFiles.set(taskFile.name, taskFile);
+    }
+    addTaskFileAt(taskFile, position) {
+        taskFile.task = this;
+        if (position < 0 || position > this._taskFiles.size) {
+            throw new Error("IndexOutOfBounds");
+        }
+        const entries = Array.from(this._taskFiles.entries());
+        entries.splice(position, 0, [taskFile.name, taskFile]);
+        this._taskFiles = new Map(entries);
+    }
+    setTaskFileValues(taskFiles) {
+        this._taskFiles.clear();
+        for (const taskFile of taskFiles) {
+            this._taskFiles.set(taskFile.name, taskFile);
+        }
+    }
+    getTaskFileValues() {
+        return Array.from(this._taskFiles.values());
+    }
+    removeTaskFile(taskFile) {
+        const value = this._taskFiles.get(taskFile);
+        this._taskFiles.delete(taskFile);
+        return value;
+    }
+    taskFileIndex(taskFile) {
+        const index = Array.from(this._taskFiles.keys()).indexOf(taskFile);
+        return index === -1 ? undefined : index;
+    }
+    equals(other) {
+        if (this === other)
+            return true;
+        if (this.index !== other.index)
+            return false;
+        if (this.name !== other.name)
+            return false;
+        if (this._taskFiles !== other._taskFiles)
+            return false;
+        if (this.descriptionText !== other.descriptionText)
+            return false;
+        return this.descriptionFormat === other.descriptionFormat;
+    }
+    hashCode() {
+        let result = hashString(this.name);
+        result = 31 * result + this.index;
+        result = 31 * result + this._taskFiles.size;
+        result = 31 * result + hashString(this.descriptionText);
+        result = 31 * result + hashString(this.descriptionFormat);
+        return result;
+    }
+}
+exports.Task = Task;
+Task.LOG = (0, loggerUtils_1.logger)("Task");
+function hashString(value) {
+    let hash = 0;
+    for (let i = 0; i < value.length; i += 1) {
+        hash = (hash << 5) - hash + value.charCodeAt(i);
+        hash |= 0;
+    }
+    return hash;
+}

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

@@ -0,0 +1,10 @@
+import { CheckStatus } from "../CheckStatus";
+import { Task } from "./Task";
+export declare class TheoryTask extends Task {
+    postSubmissionOnOpen: boolean;
+    constructor();
+    constructor(name: string);
+    constructor(name: string, id: number, position: number, updateDate: Date, status: CheckStatus);
+    get itemType(): string;
+    static THEORY_TASK_TYPE: string;
+}

package/dist/courseFormat/tasks/TheoryTask.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TheoryTask = void 0;
+const Task_1 = require("./Task");
+class TheoryTask extends Task_1.Task {
+    constructor(name, id, position, updateDate, status) {
+        super(name, id, position, updateDate, status);
+        this.postSubmissionOnOpen = true;
+    }
+    get itemType() {
+        return TheoryTask.THEORY_TASK_TYPE;
+    }
+}
+exports.TheoryTask = TheoryTask;
+TheoryTask.THEORY_TASK_TYPE = "theory";

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

@@ -0,0 +1,9 @@
+import { CheckStatus } from "../CheckStatus";
+import { Task } from "./Task";
+export declare class UnsupportedTask extends Task {
+    constructor();
+    constructor(name: string);
+    constructor(name: string, id: number, position: number, updateDate: Date, status: CheckStatus);
+    get itemType(): string;
+    static UNSUPPORTED_TASK_TYPE: string;
+}

package/dist/courseFormat/tasks/UnsupportedTask.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnsupportedTask = void 0;
+const Task_1 = require("./Task");
+class UnsupportedTask extends Task_1.Task {
+    constructor(name, id, position, updateDate, status) {
+        super(name, id, position, updateDate, status);
+    }
+    get itemType() {
+        return UnsupportedTask.UNSUPPORTED_TASK_TYPE;
+    }
+}
+exports.UnsupportedTask = UnsupportedTask;
+UnsupportedTask.UNSUPPORTED_TASK_TYPE = "unsupported";

package/dist/courseFormat/tasks/choice/ChoiceOption.d.ts

@@ -0,0 +1,10 @@
+import { ChoiceOptionStatus } from "./ChoiceOptionStatus";
+export declare class ChoiceOption {
+    text: string;
+    status: ChoiceOptionStatus;
+    constructor();
+    constructor(text: string);
+    constructor(text: string, status: ChoiceOptionStatus);
+    equals(other: ChoiceOption): boolean;
+    hashCode(): number;
+}

package/dist/courseFormat/tasks/choice/ChoiceOption.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChoiceOption = void 0;
+const ChoiceOptionStatus_1 = require("./ChoiceOptionStatus");
+class ChoiceOption {
+    constructor(text, status) {
+        this.text = "";
+        this.status = ChoiceOptionStatus_1.ChoiceOptionStatus.UNKNOWN;
+        if (text !== undefined) {
+            this.text = text;
+        }
+        if (status !== undefined) {
+            this.status = status;
+        }
+    }
+    equals(other) {
+        return this.text === other.text && this.status === other.status;
+    }
+    hashCode() {
+        let result = hashString(this.text);
+        result = 31 * result + hashString(this.status);
+        return result;
+    }
+}
+exports.ChoiceOption = ChoiceOption;
+function hashString(value) {
+    let hash = 0;
+    for (let i = 0; i < value.length; i += 1) {
+        hash = (hash << 5) - hash + value.charCodeAt(i);
+        hash |= 0;
+    }
+    return hash;
+}

package/dist/courseFormat/tasks/choice/ChoiceOptionStatus.d.ts

@@ -0,0 +1,5 @@
+export declare enum ChoiceOptionStatus {
+    CORRECT = "CORRECT",
+    INCORRECT = "INCORRECT",
+    UNKNOWN = "UNKNOWN"
+}

package/dist/courseFormat/tasks/choice/ChoiceOptionStatus.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChoiceOptionStatus = void 0;
+var ChoiceOptionStatus;
+(function (ChoiceOptionStatus) {
+    ChoiceOptionStatus["CORRECT"] = "CORRECT";
+    ChoiceOptionStatus["INCORRECT"] = "INCORRECT";
+    ChoiceOptionStatus["UNKNOWN"] = "UNKNOWN";
+})(ChoiceOptionStatus || (exports.ChoiceOptionStatus = ChoiceOptionStatus = {}));

package/dist/courseFormat/tasks/choice/ChoiceTask.d.ts

@@ -0,0 +1,23 @@
+import { CheckStatus } from "../../CheckStatus";
+import { Task } from "../Task";
+import { ChoiceOption } from "./ChoiceOption";
+export declare class ChoiceTask extends Task {
+    choiceOptions: ChoiceOption[];
+    isMultipleChoice: boolean;
+    selectedVariants: number[];
+    messageCorrect: string;
+    messageIncorrect: string;
+    quizHeader?: string;
+    canCheckLocally: boolean;
+    constructor();
+    constructor(name: string, id: number, position: number, updateDate: Date, status: CheckStatus);
+    get itemType(): string;
+    get isPluginTaskType(): boolean;
+    get isChangedOnFailed(): boolean;
+    get isToSubmitToRemote(): boolean;
+    get presentableQuizHeader(): string;
+    addSelectedVariant(variant: number): void;
+    removeSelectedVariant(variant: number): void;
+    clearSelectedVariants(): void;
+    static CHOICE_TASK_TYPE: string;
+}