course-format-ts 1.0.0

package/dist/courseFormat/EduTestInfo.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EduTestInfo = void 0;
+class EduTestInfo {
+    constructor(name = "", status = -1, message = "", details, isFinishedSuccessfully, checkResultDiff) {
+        this.name = name;
+        this.status = status;
+        this.message = message;
+        this.details = details !== null && details !== void 0 ? details : undefined;
+        this.checkResultDiff = checkResultDiff !== null && checkResultDiff !== void 0 ? checkResultDiff : undefined;
+        this.isSuccessInternal =
+            isFinishedSuccessfully === true ||
+                (EduTestInfo.get(status) !== undefined && EduTestInfo.isSuccess(EduTestInfo.get(status)));
+    }
+    get isSuccess() {
+        return this.isSuccessInternal;
+    }
+    toString() {
+        return `[${EduTestInfo.getPresentableStatus(this.status)}] ${this.name}`;
+    }
+    static firstFailed(tests) {
+        return tests.find((test) => !test.isSuccess);
+    }
+}
+exports.EduTestInfo = EduTestInfo;
+(function (EduTestInfo) {
+    let PresentableStatus;
+    (function (PresentableStatus) {
+        PresentableStatus[PresentableStatus["SKIPPED"] = 0] = "SKIPPED";
+        PresentableStatus[PresentableStatus["COMPLETED"] = 1] = "COMPLETED";
+        PresentableStatus[PresentableStatus["NOT_RUN"] = 2] = "NOT_RUN";
+        PresentableStatus[PresentableStatus["RUNNING"] = 3] = "RUNNING";
+        PresentableStatus[PresentableStatus["TERMINATED"] = 4] = "TERMINATED";
+        PresentableStatus[PresentableStatus["IGNORED"] = 5] = "IGNORED";
+        PresentableStatus[PresentableStatus["FAILED"] = 6] = "FAILED";
+        PresentableStatus[PresentableStatus["ERROR"] = 8] = "ERROR";
+    })(PresentableStatus = EduTestInfo.PresentableStatus || (EduTestInfo.PresentableStatus = {}));
+    const STATUS_TITLES = {
+        [PresentableStatus.SKIPPED]: "Skipped",
+        [PresentableStatus.COMPLETED]: "Completed",
+        [PresentableStatus.NOT_RUN]: "Not run",
+        [PresentableStatus.RUNNING]: "Running",
+        [PresentableStatus.TERMINATED]: "Terminated",
+        [PresentableStatus.IGNORED]: "Ignored",
+        [PresentableStatus.FAILED]: "Failed",
+        [PresentableStatus.ERROR]: "Error",
+    };
+    function get(status) {
+        return Object.values(PresentableStatus)
+            .filter((value) => typeof value === "number")
+            .map((value) => value)
+            .includes(status)
+            ? status
+            : undefined;
+    }
+    EduTestInfo.get = get;
+    function getPresentableStatus(status) {
+        const value = get(status);
+        return value === undefined ? "Unknown" : STATUS_TITLES[value];
+    }
+    EduTestInfo.getPresentableStatus = getPresentableStatus;
+    function isSuccess(status) {
+        return (status === PresentableStatus.COMPLETED ||
+            status === PresentableStatus.SKIPPED ||
+            status === PresentableStatus.IGNORED);
+    }
+    EduTestInfo.isSuccess = isSuccess;
+})(EduTestInfo || (exports.EduTestInfo = EduTestInfo = {}));

package/dist/courseFormat/EduVersions.d.ts

@@ -0,0 +1,2 @@
+export declare const JSON_FORMAT_VERSION = 22;
+export declare const JSON_FORMAT_VERSION_WITH_NEW_LANGUAGE_VERSION = 16;

package/dist/courseFormat/EduVersions.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSON_FORMAT_VERSION_WITH_NEW_LANGUAGE_VERSION = exports.JSON_FORMAT_VERSION = void 0;
+exports.JSON_FORMAT_VERSION = 22;
+exports.JSON_FORMAT_VERSION_WITH_NEW_LANGUAGE_VERSION = 16;

package/dist/courseFormat/FileContents.d.ts

@@ -0,0 +1,36 @@
+export interface FileContents {
+    readonly textualRepresentation: string;
+}
+export interface DeterminedContents extends FileContents {
+}
+export interface TextualContents extends DeterminedContents {
+    readonly text: string;
+}
+export interface BinaryContents extends DeterminedContents {
+    readonly bytes: Uint8Array;
+}
+export interface UndeterminedContents extends FileContents {
+    readonly textualRepresentation: string;
+    readonly text: string;
+    readonly bytes: Uint8Array;
+}
+export declare const TextualContentsEmpty: TextualContents;
+export declare const BinaryContentsEmpty: BinaryContents;
+export declare const UndeterminedContentsEmpty: UndeterminedContents;
+export declare class InMemoryBinaryContents implements BinaryContents {
+    readonly bytes: Uint8Array;
+    constructor(bytes: Uint8Array);
+    get textualRepresentation(): string;
+    static parseBase64Encoding(base64: string): InMemoryBinaryContents;
+}
+export declare class InMemoryTextualContents implements TextualContents {
+    readonly text: string;
+    constructor(text: string);
+    get textualRepresentation(): string;
+}
+export declare class InMemoryUndeterminedContents implements UndeterminedContents {
+    readonly textualRepresentation: string;
+    constructor(textualRepresentation: string);
+    get text(): string;
+    get bytes(): Uint8Array;
+}

package/dist/courseFormat/FileContents.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryUndeterminedContents = exports.InMemoryTextualContents = exports.InMemoryBinaryContents = exports.UndeterminedContentsEmpty = exports.BinaryContentsEmpty = exports.TextualContentsEmpty = void 0;
+exports.TextualContentsEmpty = {
+    text: "",
+    get textualRepresentation() {
+        return this.text;
+    },
+};
+exports.BinaryContentsEmpty = {
+    bytes: new Uint8Array(),
+    get textualRepresentation() {
+        return Buffer.from(this.bytes).toString("base64");
+    },
+};
+exports.UndeterminedContentsEmpty = {
+    textualRepresentation: "",
+    get text() {
+        return this.textualRepresentation;
+    },
+    get bytes() {
+        try {
+            return Buffer.from(this.textualRepresentation, "base64");
+        }
+        catch (_a) {
+            return new Uint8Array();
+        }
+    },
+};
+class InMemoryBinaryContents {
+    constructor(bytes) {
+        this.bytes = bytes;
+    }
+    get textualRepresentation() {
+        return Buffer.from(this.bytes).toString("base64");
+    }
+    static parseBase64Encoding(base64) {
+        return new InMemoryBinaryContents(Buffer.from(base64, "base64"));
+    }
+}
+exports.InMemoryBinaryContents = InMemoryBinaryContents;
+class InMemoryTextualContents {
+    constructor(text) {
+        this.text = text;
+    }
+    get textualRepresentation() {
+        return this.text;
+    }
+}
+exports.InMemoryTextualContents = InMemoryTextualContents;
+class InMemoryUndeterminedContents {
+    constructor(textualRepresentation) {
+        this.textualRepresentation = textualRepresentation;
+    }
+    get text() {
+        return this.textualRepresentation;
+    }
+    get bytes() {
+        try {
+            return Buffer.from(this.textualRepresentation, "base64");
+        }
+        catch (_a) {
+            return new Uint8Array();
+        }
+    }
+}
+exports.InMemoryUndeterminedContents = InMemoryUndeterminedContents;

package/dist/courseFormat/FileContentsFactory.d.ts

@@ -0,0 +1,17 @@
+import type { EduFile } from "./EduFile";
+import type { BinaryContents, TextualContents } from "./FileContents";
+/**
+ * Factory used to create file contents during deserialization of EduFile, TaskFile.
+ * Used when json or yaml do not have the contents themselves (text field is empty).
+ */
+export interface FileContentsFactory {
+    /**
+     * [file] is the EduFile object that will contain these contents.
+     * This file may not be fully initialized at the moment of the call.
+     */
+    createBinaryContents(file: EduFile): BinaryContents;
+    /**
+     * see createBinaryContents
+     */
+    createTextualContents(file: EduFile): TextualContents;
+}

package/dist/courseFormat/FileContentsFactory.js

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

package/dist/courseFormat/FrameworkLesson.d.ts

@@ -0,0 +1,9 @@
+import { Lesson } from "./Lesson";
+import { Task } from "./tasks/Task";
+export declare class FrameworkLesson extends Lesson {
+    currentTaskIndex: number;
+    isTemplateBased: boolean;
+    constructor(lesson?: Lesson);
+    currentTask(): Task | undefined;
+    get itemType(): string;
+}

package/dist/courseFormat/FrameworkLesson.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FrameworkLesson = void 0;
+const Lesson_1 = require("./Lesson");
+const EduFormatNames_1 = require("./EduFormatNames");
+class FrameworkLesson extends Lesson_1.Lesson {
+    constructor(lesson) {
+        super();
+        this.currentTaskIndex = 0;
+        this.isTemplateBased = true;
+        if (lesson) {
+            this.id = lesson.id;
+            this.updateDate = lesson.updateDate;
+            this.name = lesson.name;
+            this.items = lesson.items;
+            this.parent = lesson.parent;
+            this.index = lesson.index;
+            this.customPresentableName = lesson.customPresentableName;
+        }
+    }
+    currentTask() {
+        return this.taskList[this.currentTaskIndex];
+    }
+    get itemType() {
+        return EduFormatNames_1.FRAMEWORK;
+    }
+}
+exports.FrameworkLesson = FrameworkLesson;

package/dist/courseFormat/ItemContainer.d.ts

@@ -0,0 +1,13 @@
+import { StudyItem } from "./StudyItem";
+export declare abstract class ItemContainer extends StudyItem {
+    private _items;
+    get items(): StudyItem[];
+    set items(value: StudyItem[]);
+    init(parentItem: ItemContainer, isRestarted: boolean): void;
+    getItem(name: string): StudyItem | undefined;
+    addItem(item: StudyItem): void;
+    addItemAt(index: number, item: StudyItem): void;
+    replaceItem(existingItem: StudyItem, newItem: StudyItem): void;
+    removeItem(item: StudyItem): void;
+    sortItems(): void;
+}

package/dist/courseFormat/ItemContainer.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ItemContainer = void 0;
+const StudyItem_1 = require("./StudyItem");
+class ItemContainer extends StudyItem_1.StudyItem {
+    constructor() {
+        super(...arguments);
+        this._items = [];
+    }
+    get items() {
+        return this._items;
+    }
+    set items(value) {
+        this._items = [...value];
+    }
+    init(parentItem, isRestarted) {
+        this.parent = parentItem;
+        this.items.forEach((item, index) => {
+            item.index = index + 1;
+            item.init(this, isRestarted);
+        });
+    }
+    getItem(name) {
+        return this.items.find((item) => item.name === name);
+    }
+    addItem(item) {
+        this._items.push(item);
+    }
+    addItemAt(index, item) {
+        this._items.splice(index, 0, item);
+    }
+    replaceItem(existingItem, newItem) {
+        const index = this._items.indexOf(existingItem);
+        if (index < 0)
+            return;
+        this._items[index] = newItem;
+    }
+    removeItem(item) {
+        this._items = this._items.filter((value) => value !== item);
+    }
+    sortItems() {
+        this._items.sort((a, b) => a.index - b.index);
+    }
+}
+exports.ItemContainer = ItemContainer;

package/dist/courseFormat/JBAccountUserInfo.d.ts

@@ -0,0 +1,9 @@
+import { UserInfo } from "./UserInfo";
+export declare class JBAccountUserInfo implements UserInfo {
+    email: string;
+    name: string;
+    jbaLogin: string;
+    constructor(userName?: string);
+    getFullName(): string;
+    toString(): string;
+}

package/dist/courseFormat/JBAccountUserInfo.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JBAccountUserInfo = void 0;
+class JBAccountUserInfo {
+    constructor(userName) {
+        this.email = "";
+        this.name = "";
+        this.jbaLogin = "";
+        if (userName) {
+            this.name = userName;
+        }
+    }
+    getFullName() {
+        return this.name;
+    }
+    toString() {
+        return this.getFullName();
+    }
+}
+exports.JBAccountUserInfo = JBAccountUserInfo;

package/dist/courseFormat/Language.d.ts

@@ -0,0 +1,4 @@
+export declare const Language: {
+    findLanguageByID(id: string): string | undefined;
+    findLanguageByName(name: string): string | undefined;
+};

package/dist/courseFormat/Language.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Language = void 0;
+const languages = {
+    Python: "Python",
+    "C++": "C/C++",
+    ObjectiveC: "C/C++",
+    go: "Go",
+    JAVA: "Java",
+    kotlin: "Kotlin",
+    Scala: "Scala",
+    JavaScript: "JavaScript",
+    Rust: "Rust",
+    PHP: "PHP",
+    "Shell Script": "Shell Script",
+    SQL: "SQL",
+    "C#": "C#",
+    unity: "unity",
+    TEXT: "Plain text",
+    FakeGradleBasedLanguage: "FakeGradleBasedLanguage",
+};
+exports.Language = {
+    findLanguageByID(id) {
+        return languages[id];
+    },
+    findLanguageByName(name) {
+        if (name === "C/C++") {
+            return "C++";
+        }
+        const entry = Object.entries(languages).find(([, value]) => value === name);
+        return entry ? entry[0] : undefined;
+    },
+};

package/dist/courseFormat/Lesson.d.ts

@@ -0,0 +1,20 @@
+import { LessonContainer } from "./LessonContainer";
+import type { Course } from "./Course";
+import type { Section } from "./Section";
+import { Task } from "./tasks/Task";
+import { ItemContainer } from "./ItemContainer";
+export declare class Lesson extends LessonContainer {
+    init(parentItem: ItemContainer, isRestarted: boolean): void;
+    get taskList(): Task[];
+    get course(): Course;
+    get section(): Section | undefined;
+    get content(): Task[];
+    get itemType(): string;
+    addTask(task: Task): void;
+    addTaskAt(index: number, task: Task): void;
+    removeTask(task: Task): void;
+    getTask(name: string): Task | undefined;
+    getTask(id: number): Task | undefined;
+    get container(): LessonContainer;
+    visitTasks(visit: (task: Task) => void): void;
+}

package/dist/courseFormat/Lesson.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Lesson = void 0;
+const LessonContainer_1 = require("./LessonContainer");
+const Task_1 = require("./tasks/Task");
+const EduFormatNames_1 = require("./EduFormatNames");
+function getLessonContainerModule() {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    return require("./Section");
+}
+class Lesson extends LessonContainer_1.LessonContainer {
+    init(parentItem, isRestarted) {
+        if (!(parentItem instanceof LessonContainer_1.LessonContainer)) {
+            throw new Error(`Parent for lesson ${this.name} should be either course or section`);
+        }
+        super.init(parentItem, isRestarted);
+    }
+    get taskList() {
+        return this.items.filter((item) => item instanceof Task_1.Task);
+    }
+    get course() {
+        return this.parent.course;
+    }
+    get section() {
+        return this.parent instanceof getLessonContainerModule().Section ? this.parent : undefined;
+    }
+    get content() {
+        return this.items.filter((item) => item instanceof Task_1.Task);
+    }
+    get itemType() {
+        return EduFormatNames_1.LESSON;
+    }
+    addTask(task) {
+        this.addItem(task);
+    }
+    addTaskAt(index, task) {
+        this.addItemAt(index, task);
+    }
+    removeTask(task) {
+        this.removeItem(task);
+    }
+    getTask(param) {
+        if (typeof param === "string") {
+            return this.taskList.find((task) => task.name === param);
+        }
+        return this.taskList.find((task) => task.id === param);
+    }
+    get container() {
+        var _a;
+        return (_a = this.section) !== null && _a !== void 0 ? _a : this.course;
+    }
+    visitTasks(visit) {
+        this.taskList.forEach(visit);
+    }
+}
+exports.Lesson = Lesson;

package/dist/courseFormat/LessonContainer.d.ts

@@ -0,0 +1,16 @@
+import { ItemContainer } from "./ItemContainer";
+import type { Lesson } from "./Lesson";
+import type { Section } from "./Section";
+import { Task } from "./tasks/Task";
+export declare abstract class LessonContainer extends ItemContainer {
+    get lessons(): Lesson[];
+    getLesson(name: string): Lesson | undefined;
+    getLesson(id: number): Lesson | undefined;
+    getLesson(check: (lesson: Lesson) => boolean): Lesson | undefined;
+    addLessons(lessons: Lesson[]): void;
+    addLesson(lesson: Lesson): void;
+    removeLesson(lesson: Lesson): void;
+    visitLessons(visit: (lesson: Lesson) => void): void;
+    visitSections(visit: (section: Section) => void): void;
+    visitTasks(visit: (task: Task) => void): void;
+}

package/dist/courseFormat/LessonContainer.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LessonContainer = void 0;
+const ItemContainer_1 = require("./ItemContainer");
+function getLessonModule() {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const SectionModule = require("./Section");
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const LessonModule = require("./Lesson");
+    return { Lesson: LessonModule.Lesson, Section: SectionModule.Section };
+}
+class LessonContainer extends ItemContainer_1.ItemContainer {
+    get lessons() {
+        const mod = getLessonModule();
+        return this.items.filter((item) => item instanceof mod.Lesson);
+    }
+    getLesson(param) {
+        if (typeof param === "string") {
+            return this.getLesson((lesson) => lesson.name === param);
+        }
+        if (typeof param === "number") {
+            return this.getLesson((lesson) => lesson.id === param);
+        }
+        return this.lessons.find(param);
+    }
+    addLessons(lessons) {
+        lessons.forEach((lesson) => this.addItem(lesson));
+    }
+    addLesson(lesson) {
+        this.addItem(lesson);
+    }
+    removeLesson(lesson) {
+        this.removeItem(lesson);
+    }
+    visitLessons(visit) {
+        const mod = getLessonModule();
+        for (const item of this.items) {
+            if (item instanceof mod.Lesson) {
+                visit(item);
+            }
+            else if (item instanceof mod.Section) {
+                item.lessons.forEach(visit);
+            }
+        }
+    }
+    visitSections(visit) {
+        const mod = getLessonModule();
+        this.items.filter((item) => item instanceof mod.Section).forEach(visit);
+    }
+    visitTasks(visit) {
+        this.visitLessons((lesson) => lesson.visitTasks(visit));
+    }
+}
+exports.LessonContainer = LessonContainer;

package/dist/courseFormat/PluginInfo.d.ts

@@ -0,0 +1,7 @@
+export declare class PluginInfo {
+    stringId: string;
+    displayName?: string;
+    minVersion?: string;
+    maxVersion?: string;
+    constructor(stringId?: string, displayName?: string | null, minVersion?: string | null, maxVersion?: string | null);
+}

package/dist/courseFormat/PluginInfo.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginInfo = void 0;
+class PluginInfo {
+    constructor(stringId, displayName, minVersion, maxVersion) {
+        this.stringId = "";
+        if (stringId !== undefined) {
+            this.stringId = stringId;
+        }
+        this.displayName = displayName !== null && displayName !== void 0 ? displayName : undefined;
+        this.minVersion = minVersion !== null && minVersion !== void 0 ? minVersion : undefined;
+        this.maxVersion = maxVersion !== null && maxVersion !== void 0 ? maxVersion : undefined;
+    }
+}
+exports.PluginInfo = PluginInfo;

package/dist/courseFormat/Section.d.ts

@@ -0,0 +1,8 @@
+import { LessonContainer } from "./LessonContainer";
+import type { Course } from "./Course";
+import { ItemContainer } from "./ItemContainer";
+export declare class Section extends LessonContainer {
+    init(parentItem: ItemContainer, isRestarted: boolean): void;
+    get course(): Course;
+    get itemType(): string;
+}

package/dist/courseFormat/Section.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Section = void 0;
+const LessonContainer_1 = require("./LessonContainer");
+const EduFormatNames_1 = require("./EduFormatNames");
+function getCourseModule() {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    return require("./Course");
+}
+class Section extends LessonContainer_1.LessonContainer {
+    init(parentItem, isRestarted) {
+        if (!(parentItem instanceof getCourseModule().Course)) {
+            throw new Error(`Course is null for section ${this.name}`);
+        }
+        super.init(parentItem, isRestarted);
+    }
+    get course() {
+        if (!(this.parent instanceof getCourseModule().Course)) {
+            throw new Error(`Course is null for section ${this.name}`);
+        }
+        return this.parent;
+    }
+    get itemType() {
+        return EduFormatNames_1.SECTION;
+    }
+}
+exports.Section = Section;

package/dist/courseFormat/StudyItem.d.ts

@@ -0,0 +1,20 @@
+import { ItemContainer } from "./ItemContainer";
+import type { Course } from "./Course";
+export declare abstract class StudyItem {
+    index: number;
+    name: string;
+    updateDate: Date;
+    id: number;
+    contentTags: string[];
+    customPresentableName?: string;
+    protected _parent?: ItemContainer;
+    constructor(name?: string);
+    get parent(): ItemContainer;
+    set parent(value: ItemContainer);
+    get presentableName(): string;
+    abstract get course(): Course;
+    abstract get itemType(): string;
+    abstract init(parentItem: ItemContainer, isRestarted: boolean): void;
+    getRelativePath(root: StudyItem): string;
+    get pathInCourse(): string;
+}

package/dist/courseFormat/StudyItem.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StudyItem = void 0;
+class StudyItem {
+    constructor(name) {
+        this.index = -1;
+        this.name = "";
+        this.updateDate = new Date(0);
+        this.id = 0;
+        this.contentTags = [];
+        if (name) {
+            this.name = name;
+        }
+    }
+    get parent() {
+        if (!this._parent) {
+            throw new Error(`Parent is null for StudyItem ${this.name}`);
+        }
+        return this._parent;
+    }
+    set parent(value) {
+        this._parent = value;
+    }
+    get presentableName() {
+        var _a;
+        return (_a = this.customPresentableName) !== null && _a !== void 0 ? _a : this.name;
+    }
+    getRelativePath(root) {
+        if (this === root)
+            return "";
+        const parents = [];
+        let currentParent = this.parent;
+        while (currentParent !== root) {
+            parents.push(currentParent.name);
+            currentParent = currentParent.parent;
+        }
+        parents.reverse();
+        if (parents.length === 0)
+            return this.name;
+        parents.push(this.name);
+        return parents.join("/");
+    }
+    get pathInCourse() {
+        return this.getRelativePath(this.course);
+    }
+}
+exports.StudyItem = StudyItem;