@learnpack/learnpack 2.0.13 → 2.0.14

package/lib/commands/init.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@oclif/command");
+const BaseCommand_1 = require("../utils/BaseCommand");
+// eslint-disable-next-line
+const fs = require("fs-extra");
+const prompts = require("prompts");
+const cli_ux_1 = require("cli-ux");
+const eta = require("eta");
+const console_1 = require("../utils/console");
+const errors_1 = require("../utils/errors");
+const defaults_1 = require("../managers/config/defaults");
+const path = require("path");
+class InitComand extends BaseCommand_1.default {
+    async run() {
+        const { flags } = this.parse(InitComand);
+        // if the folder/file .learn or .breathecode aleady exists
+        await alreadyInitialized();
+        const choices = await prompts([
+            {
+                type: "select",
+                name: "grading",
+                message: "Is the auto-grading going to be isolated or incremental?",
+                choices: [
+                    {
+                        title: "Incremental: Build on top of each other like a tutorial",
+                        value: "incremental",
+                    },
+                    { title: "Isolated: Small separated exercises", value: "isolated" },
+                    {
+                        title: "No grading: No feedback or testing whatsoever",
+                        value: null,
+                    },
+                ],
+            },
+            {
+                type: "text",
+                name: "title",
+                initial: "My Interactive Tutorial",
+                message: "Title for your tutorial? Press enter to leave as it is",
+            },
+            {
+                type: "text",
+                name: "description",
+                initial: "",
+                message: "Description for your tutorial? Press enter to leave blank",
+            },
+            {
+                type: "select",
+                name: "difficulty",
+                message: "How difficulty will be to complete the tutorial?",
+                choices: [
+                    { title: "Begginer (no previous experience)", value: "beginner" },
+                    { title: "Easy (just a bit of experience required)", value: "easy" },
+                    {
+                        title: "Intermediate (you need experience)",
+                        value: "intermediate",
+                    },
+                    { title: "Hard (master the topic)", value: "hard" },
+                ],
+            },
+            {
+                type: "text",
+                name: "duration",
+                initial: "1",
+                message: "How many hours avg it takes to complete (number)?",
+                validate: (value) => {
+                    const n = Math.floor(Number(value));
+                    return (n !== Number.POSITIVE_INFINITY && String(n) === value && n >= 0);
+                },
+            },
+        ]);
+        const packageInfo = Object.assign(Object.assign({}, defaults_1.default.config), { grading: choices.grading, difficulty: choices.difficulty, duration: parseInt(choices.duration), description: choices.description, title: choices.title, slug: choices.title
+                .toLowerCase()
+                .replace(/ /g, "-")
+                .replace(/[^\w-]+/g, "") });
+        cli_ux_1.default.action.start("Initializing package");
+        const languages = ["en", "es"];
+        const templatesDir = path.resolve(__dirname, "../utils/templates/" + choices.grading || "no-grading");
+        if (!fs.existsSync(templatesDir))
+            throw errors_1.ValidationError(`Template ${templatesDir} does not exists`);
+        await fs.copySync(templatesDir, "./");
+        // Creating README files
+        // eslint-disable-next-line
+        languages.forEach((language) => {
+            const readmeFilename = `README${language !== "en" ? `.${language}` : ""}`;
+            fs.writeFileSync(`./${readmeFilename}.md`, eta.render(fs.readFileSync(path.resolve(__dirname, `${templatesDir}/${readmeFilename}.ejs`), "utf-8"), packageInfo));
+            if (fs.existsSync(`./${readmeFilename}.ejs`))
+                fs.removeSync(`./${readmeFilename}.ejs`);
+        });
+        if (!fs.existsSync("./.gitignore"))
+            fs.copyFile(path.resolve(__dirname, "../utils/templates/gitignore.txt"), "./.gitignore");
+        fs.writeFileSync("./learn.json", JSON.stringify(packageInfo, null, 2));
+        cli_ux_1.default.action.stop();
+        console_1.default.success(`😋 Package initialized successfully`);
+        console_1.default.help(`Start the exercises by running the following command on your terminal: $ learnpack start`);
+    }
+}
+InitComand.description = "Create a new learning package: Book, Tutorial or Exercise";
+InitComand.flags = Object.assign(Object.assign({}, BaseCommand_1.default.flags), { grading: command_1.flags.help({ char: "h" }) });
+const alreadyInitialized = () => new Promise((resolve, reject) => {
+    fs.readdir("./", function (err, files) {
+        files = files.filter((f) => [".learn", "learn.json", "bc.json", ".breathecode"].includes(f));
+        if (err) {
+            reject(errors_1.ValidationError(err.message));
+            throw errors_1.ValidationError(err.message);
+        }
+        else if (files.length > 0) {
+            reject(errors_1.ValidationError("It seems the package is already initialized because we've found the following files: " +
+                files.join(",")));
+            throw errors_1.ValidationError("It seems the package is already initialized because we've found the following files: " +
+                files.join(","));
+        }
+        resolve(false);
+    });
+});
+exports.default = InitComand;

package/lib/commands/login.d.ts

@@ -0,0 +1,14 @@
+import SessionCommand from "../utils/SessionCommand";
+declare class LoginCommand extends SessionCommand {
+    static description: string;
+    static flags: any;
+    static args: {
+        name: string;
+        required: boolean;
+        description: string;
+        hidden: boolean;
+    }[];
+    init(): Promise<void>;
+    run(): Promise<void>;
+}
+export default LoginCommand;

package/lib/commands/login.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const SessionCommand_1 = require("../utils/SessionCommand");
+const session_1 = require("../managers/session");
+const console_1 = require("../utils/console");
+class LoginCommand extends SessionCommand_1.default {
+    async init() {
+        const { flags } = this.parse(LoginCommand);
+        await this.initSession(flags);
+    }
+    async run() {
+        /* const {flags, args} = */ this.parse(LoginCommand);
+        try {
+            await session_1.default.login();
+        }
+        catch (error) {
+            console_1.default.error("Error trying to authenticate");
+            console_1.default.error(error.message || error);
+        }
+    }
+}
+LoginCommand.description = `Describe the command here
+  ...
+  Extra documentation goes here
+  `;
+LoginCommand.flags = {
+// name: flags.string({char: 'n', description: 'name to print'}),
+};
+LoginCommand.args = [
+    {
+        name: "package",
+        required: false,
+        description: "The unique string that identifies this package on learnpack",
+        hidden: false,
+    },
+];
+exports.default = LoginCommand;

package/lib/commands/logout.d.ts

@@ -0,0 +1,14 @@
+import SessionCommand from "../utils/SessionCommand";
+declare class LogoutCommand extends SessionCommand {
+    static description: string;
+    static flags: any;
+    static args: {
+        name: string;
+        required: boolean;
+        description: string;
+        hidden: boolean;
+    }[];
+    init(): Promise<void>;
+    run(): Promise<void>;
+}
+export default LogoutCommand;

package/lib/commands/logout.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// import  {Command, flags} from '@oclif/command'
+// import { prompt } from "enquirer"
+// import fetch from 'node-fetch'
+const SessionCommand_1 = require("../utils/SessionCommand");
+const session_1 = require("../managers/session");
+// import Console from '../utils/console'
+// import { replace } from 'node-emoji'
+// import { validURL } from "../utils/validators"
+// const BaseCommand from '../utils/BaseCommand');
+class LogoutCommand extends SessionCommand_1.default {
+    async init() {
+        const { flags } = this.parse(LogoutCommand);
+        await this.initSession(flags);
+    }
+    async run() {
+        // const {flags, args} = this.parse(LogoutCommand)
+        session_1.default.destroy();
+    }
+}
+LogoutCommand.description = `Describe the command here
+  ...
+  Extra documentation goes here
+  `;
+LogoutCommand.flags = {
+// name: flags.string({char: 'n', description: 'name to print'}),
+};
+LogoutCommand.args = [
+    {
+        name: "package",
+        required: false,
+        description: "The unique string that identifies this package on learnpack",
+        hidden: false,
+    },
+];
+exports.default = LogoutCommand;

package/lib/commands/publish.d.ts

@@ -0,0 +1,14 @@
+import SessionCommand from "../utils/SessionCommand";
+declare class PublishCommand extends SessionCommand {
+    static description: string;
+    static flags: any;
+    static args: {
+        name: string;
+        required: boolean;
+        description: string;
+        hidden: boolean;
+    }[];
+    init(): Promise<void>;
+    run(): Promise<void>;
+}
+export default PublishCommand;

package/lib/commands/publish.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const enquirer_1 = require("enquirer");
+const SessionCommand_1 = require("../utils/SessionCommand");
+const console_1 = require("../utils/console");
+const api_1 = require("../utils/api");
+const validators_1 = require("../utils/validators");
+// eslint-disable-next-line
+const fetch = require("node-fetch");
+class PublishCommand extends SessionCommand_1.default {
+    async init() {
+        const { flags } = this.parse(PublishCommand);
+        await this.initSession(flags, true);
+    }
+    async run() {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        const { flags, args } = this.parse(PublishCommand);
+        // avoid annonymus sessions
+        // eslint-disable-next-line
+        if (!this.session)
+            return;
+        console_1.default.info(`Session found for ${this.session.payload.email}, publishing the package...`);
+        const configObject = (_a = this.configManager) === null || _a === void 0 ? void 0 : _a.get();
+        if (((_b = configObject === null || configObject === void 0 ? void 0 : configObject.config) === null || _b === void 0 ? void 0 : _b.slug) === undefined ||
+            !((_c = configObject.config) === null || _c === void 0 ? void 0 : _c.slug)) {
+            throw new Error("The package is missing a slug (unique name identifier), please check your learn.json file and make sure it has a 'slug'");
+        }
+        if (!validators_1.validURL((_e = (_d = configObject === null || configObject === void 0 ? void 0 : configObject.config) === null || _d === void 0 ? void 0 : _d.repository) !== null && _e !== void 0 ? _e : "")) {
+            throw new Error("The package has a missing or invalid 'repository' on the configuration file, it needs to be a Github URL");
+        }
+        else {
+            const validateResp = await fetch((_f = configObject.config) === null || _f === void 0 ? void 0 : _f.repository, {
+                method: "HEAD",
+            });
+            if (!validateResp.ok || validateResp.status !== 200) {
+                throw new Error(`The specified repository URL on the configuration file does not exist or its private, only public repositories are allowed at the moment: ${(_g = configObject.config) === null || _g === void 0 ? void 0 : _g.repository}`);
+            }
+        }
+        // start watching for file changes
+        try {
+            await api_1.default.publish(Object.assign(Object.assign({}, configObject), { author: this.session.payload.user_id }));
+            console_1.default.success(`Package updated and published successfully: ${(_h = configObject.config) === null || _h === void 0 ? void 0 : _h.slug}`);
+        }
+        catch (error) {
+            if (error.status === 404) {
+                const answer = await enquirer_1.prompt([
+                    {
+                        type: "confirm",
+                        name: "create",
+                        message: `Package with slug ${(_j = configObject.config) === null || _j === void 0 ? void 0 : _j.slug} does not exist, do you want to create it?`,
+                    },
+                ]);
+                if (answer) {
+                    await api_1.default.update(Object.assign(Object.assign({}, configObject), { author: this.session.payload.user_id }));
+                    console_1.default.success(`Package created and published successfully: ${(_k = configObject.config) === null || _k === void 0 ? void 0 : _k.slug}`);
+                }
+                else {
+                    console_1.default.error("No answer from server");
+                }
+            }
+            else {
+                console_1.default.error(error.message);
+            }
+        }
+    }
+}
+PublishCommand.description = `Describe the command here
+  ...
+  Extra documentation goes here
+  `;
+PublishCommand.flags = {
+// name: flags.string({char: 'n', description: 'name to print'}),
+};
+PublishCommand.args = [
+    {
+        name: "package",
+        required: false,
+        description: "The unique string that identifies this package on learnpack",
+        hidden: false,
+    },
+];
+exports.default = PublishCommand;

package/lib/commands/start.d.ts

@@ -0,0 +1,7 @@
+import SessionCommand from "../utils/SessionCommand";
+export default class StartCommand extends SessionCommand {
+    static description: string;
+    static flags: any;
+    init(): Promise<void>;
+    run(): Promise<void>;
+}

package/lib/commands/start.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// import path from "path";
+const command_1 = require("@oclif/command");
+const SessionCommand_1 = require("../utils/SessionCommand");
+const console_1 = require("../utils/console");
+const socket_1 = require("../managers/socket");
+const fileQueue_1 = require("../utils/fileQueue");
+const file_1 = require("../managers/file");
+const misc_1 = require("../utils/misc");
+const server_1 = require("../managers/server");
+class StartCommand extends SessionCommand_1.default {
+    // 🛑 IMPORTANT
+    // Every command that will use the configManager needs this init method
+    async init() {
+        const { flags } = this.parse(StartCommand);
+        await this.initSession(flags);
+    }
+    async run() {
+        var _a, _b, _c;
+        // get configuration object
+        const configObject = (_a = this.configManager) === null || _a === void 0 ? void 0 : _a.get();
+        const config = configObject === null || configObject === void 0 ? void 0 : configObject.config;
+        if (configObject) {
+            const { config } = configObject;
+            // build exerises
+            (_b = this.configManager) === null || _b === void 0 ? void 0 : _b.buildIndex();
+            console_1.default.debug(`Grading: ${config === null || config === void 0 ? void 0 : config.grading} ${((_c = config === null || config === void 0 ? void 0 : config.disabledActions) === null || _c === void 0 ? void 0 : _c.includes("test")) ? "(disabled)" : ""}, editor: ${config === null || config === void 0 ? void 0 : config.editor.mode} ${config === null || config === void 0 ? void 0 : config.editor.version}, for ${Array.isArray(configObject === null || configObject === void 0 ? void 0 : configObject.exercises) ? configObject === null || configObject === void 0 ? void 0 : configObject.exercises.length :
+                0} exercises found`);
+            // download app and decompress
+            await file_1.downloadEditor(config === null || config === void 0 ? void 0 : config.editor.version, `${config === null || config === void 0 ? void 0 : config.dirPath}/app.tar.gz`);
+            console_1.default.info("Decompressing LearnPack UI, this may take a minute...");
+            await file_1.decompress(`${config === null || config === void 0 ? void 0 : config.dirPath}/app.tar.gz`, `${config === null || config === void 0 ? void 0 : config.dirPath}/_app/`);
+            // listen to socket commands
+            if (config && this.configManager) {
+                const server = await server_1.default(configObject, this.configManager);
+                const dispatcher = fileQueue_1.default.dispatcher({
+                    create: true,
+                    path: `${config.dirPath}/vscode_queue.json`,
+                });
+                socket_1.default.start(config, server, false);
+                socket_1.default.on("open", (data) => {
+                    console_1.default.debug("Opening these files: ", data);
+                    const files = misc_1.prioritizeHTMLFile(data.files);
+                    dispatcher.enqueue(dispatcher.events.OPEN_FILES, files);
+                    socket_1.default.ready("Ready to compile...");
+                });
+                socket_1.default.on("open_window", (data) => {
+                    console_1.default.debug("Opening window: ", data);
+                    dispatcher.enqueue(dispatcher.events.OPEN_WINDOW, data);
+                    socket_1.default.ready("Ready to compile...");
+                });
+                socket_1.default.on("reset", (exercise) => {
+                    var _a;
+                    try {
+                        (_a = this.configManager) === null || _a === void 0 ? void 0 : _a.reset(exercise.exerciseSlug);
+                        dispatcher.enqueue(dispatcher.events.RESET_EXERCISE, exercise.exerciseSlug);
+                        socket_1.default.ready("Ready to compile...");
+                    }
+                    catch (error) {
+                        socket_1.default.error("compiler-error", error.message ||
+                            "There was an error reseting the exercise");
+                        setTimeout(() => socket_1.default.ready("Ready to compile..."), 2000);
+                    }
+                });
+                // socket.on("preview", (data) => {
+                //   Console.debug("Preview triggered, removing the 'preview' action ")
+                //   socket.removeAllowed("preview")
+                //   socket.log('ready',['Ready to compile...'])
+                // })
+                socket_1.default.on("build", async (data) => {
+                    var _a;
+                    const exercise = (_a = this.configManager) === null || _a === void 0 ? void 0 : _a.getExercise(data.exerciseSlug);
+                    if (!(exercise === null || exercise === void 0 ? void 0 : exercise.language)) {
+                        socket_1.default.error("compiler-error", "Impossible to detect language to build for " +
+                            data.exerciseSlug +
+                            "...");
+                        return;
+                    }
+                    socket_1.default.log("compiling", "Building exercise " +
+                        data.exerciseSlug +
+                        " with " +
+                        exercise.language +
+                        "...");
+                    await this.config.runHook("action", {
+                        action: "compile",
+                        socket: socket_1.default,
+                        configuration: config,
+                        exercise,
+                    });
+                });
+                socket_1.default.on("test", async (data) => {
+                    var _a, _b;
+                    const exercise = (_a = this.configManager) === null || _a === void 0 ? void 0 : _a.getExercise(data.exerciseSlug);
+                    if (!(exercise === null || exercise === void 0 ? void 0 : exercise.language)) {
+                        socket_1.default.error("compiler-error", "Impossible to detect engine language for testing for " +
+                            data.exerciseSlug +
+                            "...");
+                        return;
+                    }
+                    if ((config === null || config === void 0 ? void 0 : config.disabledActions.includes("test")) || (config === null || config === void 0 ? void 0 : config.disableGrading)) {
+                        socket_1.default.ready("Grading is disabled on configuration");
+                        return true;
+                    }
+                    socket_1.default.log("testing", "Testing your exercise using the " + exercise.language + " engine.");
+                    await this.config.runHook("action", {
+                        action: "test",
+                        socket: socket_1.default,
+                        configuration: config,
+                        exercise,
+                    });
+                    (_b = this.configManager) === null || _b === void 0 ? void 0 : _b.save();
+                    return true;
+                });
+                const terminate = () => {
+                    console_1.default.debug("Terminating Learnpack...");
+                    server.terminate(() => {
+                        var _a;
+                        (_a = this.configManager) === null || _a === void 0 ? void 0 : _a.noCurrentExercise();
+                        dispatcher.enqueue(dispatcher.events.END);
+                        process.exit();
+                    });
+                };
+                server.on("close", terminate);
+                process.on("SIGINT", terminate);
+                process.on("SIGTERM", terminate);
+                process.on("SIGHUP", terminate);
+                // finish the server startup
+                setTimeout(() => dispatcher.enqueue(dispatcher.events.RUNNING), 1000);
+                // start watching for file changes
+                if (StartCommand.flags.watch)
+                    this.configManager.watchIndex(_exercises => socket_1.default.reload(null, _exercises));
+            }
+        }
+    }
+}
+exports.default = StartCommand;
+StartCommand.description = "Runs a small server with all the exercise instructions";
+StartCommand.flags = Object.assign(Object.assign({}, SessionCommand_1.default.flags), { port: command_1.flags.string({ char: "p", description: "server port" }), host: command_1.flags.string({ char: "h", description: "server host" }), disableGrading: command_1.flags.boolean({
+        char: "D",
+        description: "disble grading functionality",
+        default: false,
+    }), 
+    // disableGrading: flags.boolean({char: 'dg', description: 'disble grading functionality', default: false }),
+    watch: command_1.flags.boolean({
+        char: "w",
+        description: "Watch for file changes",
+        default: false,
+    }), editor: command_1.flags.string({
+        char: "e",
+        description: "[standalone, gitpod]",
+        options: ["standalone", "gitpod"],
+    }), version: command_1.flags.string({
+        char: "v",
+        description: "E.g: 1.0.1",
+        default: undefined,
+    }), grading: command_1.flags.string({
+        char: "g",
+        description: "[isolated, incremental]",
+        options: ["isolated", "incremental"],
+    }), debug: command_1.flags.boolean({
+        char: "d",
+        description: "debugger mode for more verbage",
+        default: false,
+    }) });

package/lib/commands/test.d.ts

@@ -0,0 +1,6 @@
+import SessionCommand from "../utils/SessionCommand";
+declare class TestCommand extends SessionCommand {
+    init(): Promise<void>;
+    run(): Promise<void>;
+}
+export default TestCommand;

package/lib/commands/test.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const console_1 = require("../utils/console");
+const SessionCommand_1 = require("../utils/SessionCommand");
+const socket_1 = require("../managers/socket");
+const server_1 = require("../managers/server");
+const exercisesQueue_1 = require("../utils/exercisesQueue");
+class TestCommand extends SessionCommand_1.default {
+    async init() {
+        const { flags } = this.parse(TestCommand);
+        await this.initSession(flags);
+    }
+    async run() {
+        var _a, _b, _c;
+        const { args: { exerciseSlug }, } = this.parse(TestCommand);
+        // Build exercises index
+        (_a = this.configManager) === null || _a === void 0 ? void 0 : _a.buildIndex();
+        let exercises = [];
+        // test all exercises
+        !exerciseSlug ?
+            (exercises = (_b = this.configManager) === null || _b === void 0 ? void 0 : _b.getAllExercises()) :
+            (exercises = [this.configManager.getExercise(exerciseSlug)]);
+        const exercisesQueue = new exercisesQueue_1.default(exercises);
+        const configObject = (_c = this.configManager) === null || _c === void 0 ? void 0 : _c.get();
+        let hasFailed = false;
+        let failedTestsCount = 0;
+        let successTestsCount = 0;
+        const testsToRunCount = exercisesQueue.size();
+        configObject.config.testingFinishedCallback = ({ result }) => {
+            if (result === "failed") {
+                hasFailed = true;
+                failedTestsCount++;
+            }
+            else {
+                successTestsCount++;
+            }
+            if (exercisesQueue.isEmpty()) {
+                console_1.default.info(`${testsToRunCount} test${testsToRunCount > 1 ? "s" : ""} runned`);
+                console_1.default.success(`${successTestsCount} test${successTestsCount > 1 ? "s" : ""} passed`);
+                console_1.default.error(`${failedTestsCount} test${failedTestsCount > 1 ? "s" : ""} failed`);
+                process.exit(hasFailed ? 1 : 0);
+            }
+            else {
+                exercisesQueue.pop().test(this.config, config, socket_1.default);
+            }
+        };
+        const config = configObject === null || configObject === void 0 ? void 0 : configObject.config;
+        const server = await server_1.default(configObject, this.configManager, true);
+        socket_1.default.start(config, server, true);
+        exercisesQueue.pop().test(this.config, config, socket_1.default);
+    }
+}
+TestCommand.description = `Test exercises`;
+TestCommand.args = [
+    {
+        name: "exerciseSlug",
+        required: false,
+        description: "The name of the exercise to test",
+        hidden: false,
+    },
+];
+exports.default = TestCommand;

package/lib/index.d.ts

@@ -0,0 +1 @@
+export * from '@oclif/command';

package/lib/managers/config/allowed_files.d.ts

@@ -0,0 +1,5 @@
+declare const extensions: {
+    extensions: string[];
+    names: string[];
+};
+export default extensions;

package/lib/managers/config/allowed_files.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const extensions = {
+    extensions: [
+        "py",
+        "java",
+        "py",
+        "ruby",
+        "html",
+        "css",
+        "htm",
+        "php",
+        "js",
+        "jsx",
+        "ts",
+        "sh",
+        "bash",
+        "json",
+        "yml",
+        "yaml",
+        "csv",
+        "xml",
+        "txt",
+        "text",
+        "markdown",
+        "readme",
+    ],
+    names: ["package.json", "package-lock.json"],
+};
+exports.default = extensions;

package/lib/managers/config/defaults.d.ts

@@ -0,0 +1,34 @@
+declare const _default: {
+    config: {
+        port: number;
+        editor: {
+            mode: null;
+            agent: null;
+            version: null;
+        };
+        dirPath: string;
+        configPath: string;
+        outputPath: string;
+        publicPath: string;
+        publicUrl: null;
+        language: string;
+        grading: string;
+        exercisesPath: string;
+        webpackTemplate: null;
+        disableGrading: boolean;
+        disabledActions: never[];
+        actions: never[];
+        entries: {
+            html: string;
+            vanillajs: string;
+            react: string;
+            node: string;
+            python3: string;
+            java: string;
+        };
+    };
+    address: string;
+    currentExercise: null;
+    exercises: never[];
+};
+export default _default;