course-format-ts 1.0.0

package/dist/index.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CheckStatus = exports.SortingTask = exports.MatchingTask = exports.ChoiceTask = exports.RemoteEduTask = exports.UnsupportedTask = exports.IdeTask = exports.TheoryTask = exports.TableTask = exports.DataTask = exports.OutputTask = exports.StringTask = exports.NumberTask = exports.AnswerTask = exports.CodeTask = exports.EduTask = exports.Task = exports.TaskFile = exports.Section = exports.FrameworkLesson = exports.StepikLesson = exports.Lesson = exports.CourseMode = exports.Course = exports.StepikCourse = exports.HyperskillCourse = exports.CourseraCourse = exports.EduCourse = exports.loadCourseProjectFromZip = exports.loadCourseProject = void 0;
+var disk_loader_1 = require("./disk-loader");
+Object.defineProperty(exports, "loadCourseProject", { enumerable: true, get: function () { return disk_loader_1.loadCourseProject; } });
+var zip_loader_1 = require("./zip-loader");
+Object.defineProperty(exports, "loadCourseProjectFromZip", { enumerable: true, get: function () { return zip_loader_1.loadCourseProjectFromZip; } });
+// Core models
+var EduCourse_1 = require("./courseFormat/EduCourse");
+Object.defineProperty(exports, "EduCourse", { enumerable: true, get: function () { return EduCourse_1.EduCourse; } });
+var CourseraCourse_1 = require("./courseFormat/CourseraCourse");
+Object.defineProperty(exports, "CourseraCourse", { enumerable: true, get: function () { return CourseraCourse_1.CourseraCourse; } });
+var HyperskillCourse_1 = require("./courseFormat/hyperskill/HyperskillCourse");
+Object.defineProperty(exports, "HyperskillCourse", { enumerable: true, get: function () { return HyperskillCourse_1.HyperskillCourse; } });
+var StepikCourse_1 = require("./courseFormat/stepik/StepikCourse");
+Object.defineProperty(exports, "StepikCourse", { enumerable: true, get: function () { return StepikCourse_1.StepikCourse; } });
+var Course_1 = require("./courseFormat/Course");
+Object.defineProperty(exports, "Course", { enumerable: true, get: function () { return Course_1.Course; } });
+var CourseMode_1 = require("./courseFormat/CourseMode");
+Object.defineProperty(exports, "CourseMode", { enumerable: true, get: function () { return CourseMode_1.CourseMode; } });
+var Lesson_1 = require("./courseFormat/Lesson");
+Object.defineProperty(exports, "Lesson", { enumerable: true, get: function () { return Lesson_1.Lesson; } });
+var StepikLesson_1 = require("./courseFormat/stepik/StepikLesson");
+Object.defineProperty(exports, "StepikLesson", { enumerable: true, get: function () { return StepikLesson_1.StepikLesson; } });
+var FrameworkLesson_1 = require("./courseFormat/FrameworkLesson");
+Object.defineProperty(exports, "FrameworkLesson", { enumerable: true, get: function () { return FrameworkLesson_1.FrameworkLesson; } });
+var Section_1 = require("./courseFormat/Section");
+Object.defineProperty(exports, "Section", { enumerable: true, get: function () { return Section_1.Section; } });
+var TaskFile_1 = require("./courseFormat/TaskFile");
+Object.defineProperty(exports, "TaskFile", { enumerable: true, get: function () { return TaskFile_1.TaskFile; } });
+var Task_1 = require("./courseFormat/tasks/Task");
+Object.defineProperty(exports, "Task", { enumerable: true, get: function () { return Task_1.Task; } });
+var EduTask_1 = require("./courseFormat/tasks/EduTask");
+Object.defineProperty(exports, "EduTask", { enumerable: true, get: function () { return EduTask_1.EduTask; } });
+var CodeTask_1 = require("./courseFormat/tasks/CodeTask");
+Object.defineProperty(exports, "CodeTask", { enumerable: true, get: function () { return CodeTask_1.CodeTask; } });
+var AnswerTask_1 = require("./courseFormat/tasks/AnswerTask");
+Object.defineProperty(exports, "AnswerTask", { enumerable: true, get: function () { return AnswerTask_1.AnswerTask; } });
+var NumberTask_1 = require("./courseFormat/tasks/NumberTask");
+Object.defineProperty(exports, "NumberTask", { enumerable: true, get: function () { return NumberTask_1.NumberTask; } });
+var StringTask_1 = require("./courseFormat/tasks/StringTask");
+Object.defineProperty(exports, "StringTask", { enumerable: true, get: function () { return StringTask_1.StringTask; } });
+var OutputTask_1 = require("./courseFormat/tasks/OutputTask");
+Object.defineProperty(exports, "OutputTask", { enumerable: true, get: function () { return OutputTask_1.OutputTask; } });
+var DataTask_1 = require("./courseFormat/tasks/DataTask");
+Object.defineProperty(exports, "DataTask", { enumerable: true, get: function () { return DataTask_1.DataTask; } });
+var TableTask_1 = require("./courseFormat/tasks/TableTask");
+Object.defineProperty(exports, "TableTask", { enumerable: true, get: function () { return TableTask_1.TableTask; } });
+var TheoryTask_1 = require("./courseFormat/tasks/TheoryTask");
+Object.defineProperty(exports, "TheoryTask", { enumerable: true, get: function () { return TheoryTask_1.TheoryTask; } });
+var IdeTask_1 = require("./courseFormat/tasks/IdeTask");
+Object.defineProperty(exports, "IdeTask", { enumerable: true, get: function () { return IdeTask_1.IdeTask; } });
+var UnsupportedTask_1 = require("./courseFormat/tasks/UnsupportedTask");
+Object.defineProperty(exports, "UnsupportedTask", { enumerable: true, get: function () { return UnsupportedTask_1.UnsupportedTask; } });
+var RemoteEduTask_1 = require("./courseFormat/tasks/RemoteEduTask");
+Object.defineProperty(exports, "RemoteEduTask", { enumerable: true, get: function () { return RemoteEduTask_1.RemoteEduTask; } });
+var ChoiceTask_1 = require("./courseFormat/tasks/choice/ChoiceTask");
+Object.defineProperty(exports, "ChoiceTask", { enumerable: true, get: function () { return ChoiceTask_1.ChoiceTask; } });
+var MatchingTask_1 = require("./courseFormat/tasks/matching/MatchingTask");
+Object.defineProperty(exports, "MatchingTask", { enumerable: true, get: function () { return MatchingTask_1.MatchingTask; } });
+var SortingTask_1 = require("./courseFormat/tasks/matching/SortingTask");
+Object.defineProperty(exports, "SortingTask", { enumerable: true, get: function () { return SortingTask_1.SortingTask; } });
+var CheckStatus_1 = require("./courseFormat/CheckStatus");
+Object.defineProperty(exports, "CheckStatus", { enumerable: true, get: function () { return CheckStatus_1.CheckStatus; } });

package/dist/loader.d.ts

@@ -0,0 +1,7 @@
+import { Course } from "./courseFormat/Course";
+/**
+ * Load a course from an in-memory file map (used by zip loader).
+ * The map must contain the same directory structure as a course project
+ * on disk (with course-info.yaml at the root).
+ */
+export declare function loadCourseFromZip(zipBuffer: Uint8Array, _options?: unknown): Promise<Course>;

package/dist/loader.js

@@ -0,0 +1,435 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadCourseFromZip = loadCourseFromZip;
+const yaml_1 = require("yaml");
+const CheckStatus_1 = require("./courseFormat/CheckStatus");
+const CourseMode_1 = require("./courseFormat/CourseMode");
+const Lesson_1 = require("./courseFormat/Lesson");
+const EduCourse_1 = require("./courseFormat/EduCourse");
+const CourseraCourse_1 = require("./courseFormat/CourseraCourse");
+const HyperskillCourse_1 = require("./courseFormat/hyperskill/HyperskillCourse");
+const StepikCourse_1 = require("./courseFormat/stepik/StepikCourse");
+const StepikLesson_1 = require("./courseFormat/stepik/StepikLesson");
+const EduTask_1 = require("./courseFormat/tasks/EduTask");
+const CodeTask_1 = require("./courseFormat/tasks/CodeTask");
+const NumberTask_1 = require("./courseFormat/tasks/NumberTask");
+const StringTask_1 = require("./courseFormat/tasks/StringTask");
+const OutputTask_1 = require("./courseFormat/tasks/OutputTask");
+const DataTask_1 = require("./courseFormat/tasks/DataTask");
+const TableTask_1 = require("./courseFormat/tasks/TableTask");
+const TheoryTask_1 = require("./courseFormat/tasks/TheoryTask");
+const IdeTask_1 = require("./courseFormat/tasks/IdeTask");
+const UnsupportedTask_1 = require("./courseFormat/tasks/UnsupportedTask");
+const RemoteEduTask_1 = require("./courseFormat/tasks/RemoteEduTask");
+const ChoiceTask_1 = require("./courseFormat/tasks/choice/ChoiceTask");
+const ChoiceOption_1 = require("./courseFormat/tasks/choice/ChoiceOption");
+const ChoiceOptionStatus_1 = require("./courseFormat/tasks/choice/ChoiceOptionStatus");
+const MatchingTask_1 = require("./courseFormat/tasks/matching/MatchingTask");
+const SortingTask_1 = require("./courseFormat/tasks/matching/SortingTask");
+const TaskFile_1 = require("./courseFormat/TaskFile");
+/**
+ * Simple path joining (works in browser).
+ */
+function pathJoin(...parts) {
+    return parts.filter(p => p.length > 0).join("/");
+}
+/**
+ * Cross-platform base64 encoding from Uint8Array.
+ * Uses btoa which is available in modern browsers and Node.js.
+ */
+function uint8ArrayToBase64(data) {
+    let binary = "";
+    const bytes = new Uint8Array(data);
+    for (let i = 0; i < bytes.length; i++) {
+        binary += String.fromCharCode(bytes[i]);
+    }
+    return btoa(binary);
+}
+class MemoryFileSystem {
+    constructor(files) {
+        this.files = files;
+    }
+    readFile(filePath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const content = this.files.get(filePath);
+            if (content === undefined) {
+                throw new Error(`File not found: ${filePath}`);
+            }
+            return content;
+        });
+    }
+    readFileSync(filePath) {
+        var _a;
+        return (_a = this.files.get(filePath)) !== null && _a !== void 0 ? _a : null;
+    }
+}
+const COURSE_CONFIG = "course-info.yaml";
+const LESSON_CONFIG = "lesson-info.yaml";
+const TASK_CONFIG = "task-info.yaml";
+function createCourse(type) {
+    switch (type) {
+        case "hyperskill":
+            return new HyperskillCourse_1.HyperskillCourse();
+        case "coursera":
+            return new CourseraCourse_1.CourseraCourse();
+        case "stepik":
+            return new StepikCourse_1.StepikCourse();
+        default:
+            const course = new EduCourse_1.EduCourse();
+            return course;
+    }
+}
+function hydrateCourse(course, yaml) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+    course.name = (_a = yaml.title) !== null && _a !== void 0 ? _a : "";
+    course.description = (_b = yaml.summary) !== null && _b !== void 0 ? _b : "";
+    course.programmingLanguage = (_c = yaml.programming_language) !== null && _c !== void 0 ? _c : "";
+    course.languageVersion = yaml.programming_language_version;
+    course.environment = (_d = yaml.environment) !== null && _d !== void 0 ? _d : course.environment;
+    course.solutionsHidden = (_e = yaml.solutions_hidden) !== null && _e !== void 0 ? _e : course.solutionsHidden;
+    course.environmentSettings = (_f = yaml.environment_settings) !== null && _f !== void 0 ? _f : course.environmentSettings;
+    course.customContentPath = (_g = yaml.custom_content_path) !== null && _g !== void 0 ? _g : course.customContentPath;
+    course.disabledFeatures = (_h = yaml.disabled_features) !== null && _h !== void 0 ? _h : course.disabledFeatures;
+    course.vendor = (_j = yaml.vendor) !== null && _j !== void 0 ? _j : course.vendor;
+    if (yaml.is_private !== undefined)
+        course.isMarketplacePrivate = yaml.is_private;
+    if (yaml.mode) {
+        course.courseMode = CourseMode_1.CourseMode.STUDENT;
+    }
+    else {
+        course.courseMode = CourseMode_1.CourseMode.EDUCATOR;
+    }
+}
+/**
+ * Load a course from an in-memory file map (used by zip loader).
+ * The map must contain the same directory structure as a course project
+ * on disk (with course-info.yaml at the root).
+ */
+function loadCourseFromZip(zipBuffer, _options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const zipFiles = yield parseZipToBufferMap(zipBuffer);
+        const memoryFs = new MemoryFileSystem(zipFiles);
+        return loadCourseProjectInternal("", memoryFs);
+    });
+}
+function loadCourseProjectInternal(projectPath, fileSystem) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const courseConfigPath = pathJoin(projectPath, COURSE_CONFIG);
+        const courseYaml = yield readRawYamlFile(courseConfigPath, fileSystem);
+        if (!courseYaml.title) {
+            throw new Error(`Missing 'title' in ${courseConfigPath}`);
+        }
+        if (!courseYaml.language) {
+            throw new Error(`Missing 'language' in ${courseConfigPath}`);
+        }
+        if (!courseYaml.programming_language) {
+            throw new Error(`Missing 'programming_language' in ${courseConfigPath}`);
+        }
+        const contentNames = ensureNamedContent(courseYaml.content, courseConfigPath);
+        const course = createCourse(courseYaml.type);
+        hydrateCourse(course, courseYaml);
+        course.languageCode = courseYaml.language;
+        const lessons = yield Promise.all(contentNames.map((lessonName) => loadLesson(projectPath, lessonName, courseYaml.type, fileSystem)));
+        for (const lesson of lessons) {
+            course.addLesson(lesson);
+        }
+        return course;
+    });
+}
+function createLesson(courseType) {
+    if (courseType === "stepik") {
+        return new StepikLesson_1.StepikLesson();
+    }
+    return new Lesson_1.Lesson();
+}
+function hydrateLesson(lesson, lessonName, yaml) {
+    lesson.name = lessonName;
+    if (yaml.custom_name) {
+        lesson.customPresentableName = yaml.custom_name;
+    }
+    if (yaml.tags) {
+        lesson.contentTags = yaml.tags;
+    }
+}
+function loadLesson(coursePath, lessonName, courseType, fileSystem) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const lessonPath = pathJoin(coursePath, lessonName);
+        const lessonConfigPath = pathJoin(lessonPath, LESSON_CONFIG);
+        const lessonYaml = yield readRawYamlFile(lessonConfigPath, fileSystem);
+        const taskNames = ensureNamedContent(lessonYaml.content, lessonConfigPath);
+        const tasks = yield Promise.all(taskNames.map((taskName) => loadTask(lessonPath, taskName, fileSystem)));
+        const lesson = createLesson(courseType);
+        hydrateLesson(lesson, lessonName, lessonYaml);
+        for (const task of tasks) {
+            lesson.addTask(task);
+        }
+        return lesson;
+    });
+}
+function createTask(taskType) {
+    switch (taskType) {
+        case "edu":
+        case "pycharm":
+            return new EduTask_1.EduTask();
+        case "code":
+            return new CodeTask_1.CodeTask();
+        case "number":
+            return new NumberTask_1.NumberTask();
+        case "string":
+            return new StringTask_1.StringTask();
+        case "output":
+            return new OutputTask_1.OutputTask();
+        case "dataset":
+            return new DataTask_1.DataTask();
+        case "table":
+            return new TableTask_1.TableTask();
+        case "theory":
+            return new TheoryTask_1.TheoryTask();
+        case "ide":
+            return new IdeTask_1.IdeTask();
+        case "unsupported":
+            return new UnsupportedTask_1.UnsupportedTask();
+        case "remote_edu":
+            return new RemoteEduTask_1.RemoteEduTask();
+        case "choice":
+            return new ChoiceTask_1.ChoiceTask();
+        case "matching":
+            return new MatchingTask_1.MatchingTask();
+        case "sorting":
+            return new SortingTask_1.SortingTask();
+        default:
+            return null;
+    }
+}
+function hydrateTask(task, taskName, yaml) {
+    var _a;
+    task.name = taskName;
+    if (yaml.status !== undefined && yaml.status !== null) {
+        const statusStr = String(yaml.status);
+        const statusMap = {
+            Unchecked: CheckStatus_1.CheckStatus.Unchecked,
+            Solved: CheckStatus_1.CheckStatus.Solved,
+            Failed: CheckStatus_1.CheckStatus.Failed,
+        };
+        task.status = (_a = statusMap[statusStr]) !== null && _a !== void 0 ? _a : CheckStatus_1.CheckStatus.Unchecked;
+    }
+    if (typeof yaml.record === "number") {
+        task.record = yaml.record;
+    }
+    if (yaml.feedback_link !== undefined) {
+        task.feedbackLink = String(yaml.feedback_link);
+    }
+    if (yaml.solution_hidden !== undefined) {
+        task.solutionHidden = Boolean(yaml.solution_hidden);
+    }
+    if (Array.isArray(yaml.tags)) {
+        task.contentTags = yaml.tags.map(String);
+    }
+}
+function hydrateChoiceTask(task, yaml) {
+    if (yaml.is_multiple_choice !== undefined) {
+        task.isMultipleChoice = Boolean(yaml.is_multiple_choice);
+    }
+    if (Array.isArray(yaml.options)) {
+        task.choiceOptions = yaml.options.map((opt) => {
+            var _a;
+            const option = new ChoiceOption_1.ChoiceOption();
+            option.text = String((_a = opt.text) !== null && _a !== void 0 ? _a : "");
+            if (opt.is_correct === true) {
+                option.status = ChoiceOptionStatus_1.ChoiceOptionStatus.CORRECT;
+            }
+            else if (opt.is_correct === false) {
+                option.status = ChoiceOptionStatus_1.ChoiceOptionStatus.INCORRECT;
+            }
+            return option;
+        });
+    }
+}
+function hydrateMatchingTask(task, yaml) {
+    if (Array.isArray(yaml.captions)) {
+        const captions = yaml.captions;
+        task.captions = captions.map((c) => {
+            var _a, _b;
+            const first = String((_a = c.first) !== null && _a !== void 0 ? _a : "");
+            const second = String((_b = c.second) !== null && _b !== void 0 ? _b : "");
+            return `${first} : ${second}`;
+        });
+    }
+    if (Array.isArray(yaml.options)) {
+        const opts = yaml.options;
+        task.options = opts.map(String);
+    }
+}
+function hydrateSortingTask(task, yaml) {
+    if (Array.isArray(yaml.options)) {
+        const opts = yaml.options;
+        task.options = opts.map(String);
+    }
+}
+function hydrateTableTask(task, yaml) {
+    if (yaml.is_multiple_choice !== undefined) {
+        task.isMultipleChoice = Boolean(yaml.is_multiple_choice);
+    }
+    if (Array.isArray(yaml.rows)) {
+        task.rows = yaml.rows.map(String);
+    }
+    if (Array.isArray(yaml.columns)) {
+        task.columns = yaml.columns.map(String);
+    }
+    if (Array.isArray(yaml.selected)) {
+        const sel = yaml.selected;
+        task.selected = sel.map((row) => row.map(Boolean));
+    }
+}
+function loadTask(lessonPath, taskName, fileSystem) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const taskPath = pathJoin(lessonPath, taskName);
+        const taskConfigPath = pathJoin(taskPath, TASK_CONFIG);
+        const rawYaml = yield readRawYamlFile(taskConfigPath, fileSystem);
+        if (!rawYaml.type) {
+            throw new Error(`Missing 'type' in ${taskConfigPath}`);
+        }
+        const task = createTask(rawYaml.type);
+        if (!task) {
+            throw new Error(`Unknown task type '${rawYaml.type}' in ${taskConfigPath}`);
+        }
+        hydrateTask(task, taskName, rawYaml);
+        const files = rawYaml.files
+            ? yield Promise.all(rawYaml.files.map((file) => loadTaskFile(taskPath, file, fileSystem)))
+            : [];
+        for (const taskFile of files) {
+            task.addTaskFileInstance(taskFile);
+        }
+        // Hydrate task-specific fields
+        if (task instanceof ChoiceTask_1.ChoiceTask) {
+            hydrateChoiceTask(task, rawYaml);
+        }
+        else if (task instanceof MatchingTask_1.MatchingTask) {
+            hydrateMatchingTask(task, rawYaml);
+        }
+        else if (task instanceof SortingTask_1.SortingTask) {
+            hydrateSortingTask(task, rawYaml);
+        }
+        else if (task instanceof TableTask_1.TableTask) {
+            hydrateTableTask(task, rawYaml);
+        }
+        return task;
+    });
+}
+function loadTaskFile(ownerPath, fileYaml, fileSystem) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d, _e;
+        if (!fileYaml.name) {
+            throw new Error(`Task file without name in ${ownerPath}`);
+        }
+        const isBinary = (_a = fileYaml.is_binary) !== null && _a !== void 0 ? _a : false;
+        const text = yield resolveTaskFileText(ownerPath, fileYaml, isBinary, fileSystem);
+        const taskFile = new TaskFile_1.TaskFile();
+        taskFile.name = fileYaml.name;
+        taskFile.text = text !== null && text !== void 0 ? text : "";
+        taskFile.isVisible = (_b = fileYaml.visible) !== null && _b !== void 0 ? _b : true;
+        taskFile.isEditable = (_c = fileYaml.editable) !== null && _c !== void 0 ? _c : true;
+        taskFile.isPropagatable = (_d = fileYaml.propagatable) !== null && _d !== void 0 ? _d : true;
+        taskFile.isLearnerCreated = (_e = fileYaml.learner_created) !== null && _e !== void 0 ? _e : false;
+        return taskFile;
+    });
+}
+function resolveTaskFileText(ownerPath, fileYaml, isBinary, fileSystem) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (fileYaml.text !== undefined) {
+            return fileYaml.text;
+        }
+        return readTaskFile(ownerPath, fileYaml.name, isBinary, fileSystem);
+    });
+}
+function readTaskFile(ownerPath, name, isBinary, fileSystem) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!name)
+            return undefined;
+        const filePath = pathJoin(ownerPath, name);
+        try {
+            const data = yield fileSystem.readFile(filePath);
+            return isBinary ? uint8ArrayToBase64(data) : new TextDecoder().decode(data);
+        }
+        catch (_a) {
+            return undefined;
+        }
+    });
+}
+function ensureNamedContent(content, configPath) {
+    if (!content)
+        return [];
+    return content.map((name, index) => {
+        if (!name) {
+            throw new Error(`Unnamed item at position ${index + 1} in ${configPath}`);
+        }
+        return name;
+    });
+}
+function readRawYamlFile(filePath, fileSystem) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const data = yield fileSystem.readFile(filePath);
+        return (0, yaml_1.parse)(new TextDecoder().decode(data));
+    });
+}
+/**
+ * Parse a zip buffer into a map of file paths to their contents.
+ * Uses fflate which is pure JS and works in both Node.js and browser environments.
+ */
+function parseZipToBufferMap(zipBuffer) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { unzipSync } = yield Promise.resolve().then(() => __importStar(require("fflate")));
+        const unzipped = unzipSync(new Uint8Array(zipBuffer));
+        const files = new Map();
+        for (const [entryPath, data] of Object.entries(unzipped)) {
+            // Normalize path: strip leading "/" or "./", replace backslashes
+            const normalized = entryPath.replace(/^\.?[\\/]+/, "").replace(/\\/g, "/");
+            if (normalized) {
+                files.set(normalized, data);
+            }
+        }
+        return files;
+    });
+}

package/dist/models.d.ts

@@ -0,0 +1,49 @@
+export interface Vendor {
+    name: string;
+    url?: string;
+    email?: string;
+}
+export type CourseMode = "STUDENT" | "EDUCATOR";
+export interface TaskFile {
+    name: string;
+    text?: string;
+    visible: boolean;
+    editable: boolean;
+    propagatable: boolean;
+    isBinary: boolean;
+    learnerCreated: boolean;
+}
+export interface Task {
+    name: string;
+    type: string;
+    status?: string;
+    record?: number;
+    files: TaskFile[];
+    feedbackLink?: string;
+    solutionHidden?: boolean;
+    tags?: string[];
+}
+export interface Lesson {
+    name: string;
+    customName?: string;
+    tags?: string[];
+    content: Task[];
+}
+export interface Course {
+    type: string;
+    title: string;
+    summary: string;
+    language: string;
+    programmingLanguage: string;
+    programmingLanguageVersion?: string;
+    environment?: string;
+    solutionsHidden?: boolean;
+    environmentSettings: Record<string, string>;
+    additionalFiles: TaskFile[];
+    customContentPath?: string;
+    disabledFeatures: string[];
+    vendor?: Vendor;
+    isPrivate?: boolean;
+    courseMode: CourseMode;
+    content: Lesson[];
+}

package/dist/models.js

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

package/dist/zip-loader.d.ts

@@ -0,0 +1,4 @@
+import { Course } from "./courseFormat/Course";
+export declare function loadCourseProjectFromZip(data: Uint8Array, options?: {
+    aesKey?: string;
+}): Promise<Course>;