@learnpack/learnpack 2.0.19 → 2.0.21

package/lib/managers/config/defaults.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    config: {
+        port: 3000,
+        editor: {
+            mode: null,
+            agent: null,
+            version: null,
+        },
+        dirPath: './.learn',
+        configPath: './learn.json',
+        outputPath: './.learn/dist',
+        publicPath: '/preview',
+        publicUrl: null,
+        language: 'auto',
+        grading: 'isolated',
+        exercisesPath: './',
+        webpackTemplate: null,
+        disableGrading: false,
+        disabledActions: [],
+        actions: [],
+        entries: {
+            html: 'index.html',
+            vanillajs: 'index.js',
+            react: 'app.jsx',
+            node: 'app.js',
+            python3: 'app.py',
+            java: 'app.java',
+        },
+    },
+    address: 'http://localhost',
+    currentExercise: null,
+    exercises: [],
+};

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

@@ -0,0 +1,36 @@
+import { IConfigObj } from "../../models/config";
+import { IFile } from "../../models/file";
+import { IExercise } from "../../models/exercise-obj";
+export declare const exercise: (path: string, position: number, configObject: IConfigObj) => IExercise;
+export declare const validateExerciseDirectoryName: (str: string) => boolean;
+export declare const isCodable: (str: string) => boolean;
+export declare const shouldBeVisible: (file: IFile) => boolean;
+export declare const isDirectory: (source: string) => boolean;
+export declare const detect: (configObject: IConfigObj | undefined, files: Array<string>) => {
+    language: string;
+    entry: string | undefined;
+} | {
+    language: null;
+    entry: null;
+} | undefined;
+export declare const filterFiles: (files: Array<string>, basePath?: string) => {
+    path: string;
+    name: string;
+    hidden: boolean;
+}[];
+declare const _default: {
+    exercise: (path: string, position: number, configObject: IConfigObj) => IExercise;
+    detect: (configObject: IConfigObj | undefined, files: string[]) => {
+        language: string;
+        entry: string | undefined;
+    } | {
+        language: null;
+        entry: null;
+    } | undefined;
+    filterFiles: (files: string[], basePath?: string) => {
+        path: string;
+        name: string;
+        hidden: boolean;
+    }[];
+};
+export default _default;

package/lib/managers/config/exercise.js

@@ -0,0 +1,230 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterFiles = exports.detect = exports.isDirectory = exports.shouldBeVisible = exports.isCodable = exports.validateExerciseDirectoryName = exports.exercise = void 0;
+const p = require("path");
+// import frontMatter from 'front-matter'
+const fs = require("fs");
+const console_1 = require("../../utils/console");
+const allowed_files_1 = require("./allowed_files");
+// eslint-disable-next-line
+const frontMatter = require("front-matter");
+exports.exercise = (path, position, configObject) => {
+    const { config, exercises } = configObject;
+    let slug = p.basename(path);
+    if (!exports.validateExerciseDirectoryName(slug)) {
+        console_1.default.error(`Exercise directory ${slug} has an invalid name, it has to start with two or three digits followed by words separated by underscors or hyphen (no white spaces). e.g: 01.12-hello-world`);
+    }
+    // get all the files
+    const files = fs.readdirSync(path);
+    /**
+     * build the translation array like:
+     {
+         "us": "path/to/Readme.md",
+          "es": "path/to/Readme.es.md"
+        }
+        */
+    const translations = {};
+    for (const file of files.filter(file => file.toLowerCase().includes("readme"))) {
+        const parts = file.split(".");
+        if (parts.length === 3)
+            translations[parts[1]] = file;
+        else
+            translations.us = file;
+    }
+    // if the slug is a dot, it means there is not "exercises" folder, and its just a single README.md
+    if (slug === ".")
+        slug = "default-index";
+    const detected = exports.detect(configObject, files);
+    const exerciseObj = {
+        position,
+        path,
+        slug,
+        translations,
+        language: detected === null || detected === void 0 ? void 0 : detected.language,
+        entry: (detected === null || detected === void 0 ? void 0 : detected.entry) ? path + "/" + detected.entry : null,
+        title: slug || "Exercise",
+        graded: files.some(file => file.toLowerCase().startsWith("test.") ||
+            file.toLowerCase().startsWith("tests.")),
+        files: exports.filterFiles(files, path),
+        // if the exercises was on the config before I may keep the status done
+        done: Array.isArray(exercises) &&
+            typeof exercises[position] !== "undefined" &&
+            path.slice(Math.max(0, path.indexOf("exercises/") + 10)) ===
+                exercises[position].slug ?
+            exercises[position].done :
+            false,
+        getReadme: function (lang = null) {
+            if (lang === "us")
+                lang = null; // <-- english is default, no need to append it to the file name
+            if (!fs.existsSync(`${this.path}/README${lang ? "." + lang : ""}.md`)) {
+                console_1.default.error(`Language ${lang} not found for exercise ${slug}, switching to default language`);
+                if (lang)
+                    lang = null;
+                if (!fs.existsSync(`${this.path}/README${lang ? "." + lang : ""}.md`))
+                    throw new Error("Readme file not found for exercise: " + this.path + "/README.md");
+            }
+            const content = fs.readFileSync(`${this.path}/README${lang ? "." + lang : ""}.md`, "utf8");
+            const attr = frontMatter(content);
+            return attr;
+        },
+        getFile: function (name) {
+            const file = this.files.find((f) => f.name === name);
+            if (!file || !fs.existsSync(file.path)) {
+                throw new Error(`File not found: + ${file === null || file === void 0 ? void 0 : file.path}`);
+            }
+            else if (fs.lstatSync(file.path).isDirectory()) {
+                return ("Error: This is not a file to be read, but a directory: " + file.path);
+            }
+            // get file content
+            const content = fs.readFileSync(file.path);
+            // create reset folder
+            if (!fs.existsSync(`${config === null || config === void 0 ? void 0 : config.dirPath}/resets`))
+                fs.mkdirSync(`${config === null || config === void 0 ? void 0 : config.dirPath}/resets`);
+            if (!fs.existsSync(`${config === null || config === void 0 ? void 0 : config.dirPath}/resets/` + this.slug)) {
+                fs.mkdirSync(`${config === null || config === void 0 ? void 0 : config.dirPath}/resets/` + this.slug);
+                if (!fs.existsSync(`${config === null || config === void 0 ? void 0 : config.dirPath}/resets/${this.slug}/${name}`)) {
+                    fs.writeFileSync(`${config === null || config === void 0 ? void 0 : config.dirPath}/resets/${this.slug}/${name}`, content);
+                }
+            }
+            return content;
+        },
+        saveFile: function (name, content) {
+            const file = this.files.find((f) => f.name === name);
+            if (file) {
+                if (!fs.existsSync(file.path)) {
+                    throw new Error("File not found: " + file.path);
+                }
+                return fs.writeFileSync(file.path, content, "utf8");
+            }
+        },
+        getTestReport: function () {
+            var _a;
+            const _path = `${(_a = configObject === null || configObject === void 0 ? void 0 : configObject.confPath) === null || _a === void 0 ? void 0 : _a.base}/reports/${this.slug}.json`;
+            if (!fs.existsSync(_path))
+                return {};
+            const content = fs.readFileSync(_path);
+            const data = JSON.parse(`${content}`);
+            return data;
+        },
+    };
+    return exerciseObj;
+};
+exports.validateExerciseDirectoryName = (str) => {
+    if (str === "./")
+        return true;
+    // TODO: Add nameValidationREgex from the config
+    const regex = /^(\d{2,3}(\.\d{1,2})?-([\dA-Za-z]+(-|_)?)+)$/;
+    return regex.test(str);
+};
+exports.isCodable = (str) => {
+    const extension = p.extname(str);
+    return allowed_files_1.default.extensions.includes(extension.slice(1).toLowerCase());
+};
+const isNotConfiguration = (str) => {
+    return !allowed_files_1.default.names.includes(str);
+};
+exports.shouldBeVisible = function (file) {
+    return (
+    // doest not have "test." on their name
+    !file.name.toLocaleLowerCase().includes("test.") &&
+        !file.name.toLocaleLowerCase().includes("tests.") &&
+        !file.name.toLocaleLowerCase().includes(".hide.") &&
+        // ignore hidden files
+        file.name.charAt(0) !== "." &&
+        // ignore learn.json and bc.json
+        !file.name.toLocaleLowerCase().includes("learn.json") &&
+        !file.name.toLocaleLowerCase().includes("bc.json") &&
+        // ignore images, videos, vectors, etc.
+        exports.isCodable(file.name) &&
+        isNotConfiguration(file.name) &&
+        // readme's and directories
+        !file.name.toLowerCase().includes("readme.") &&
+        !exports.isDirectory(file.path) &&
+        file.name.charAt(0) !== "_");
+};
+exports.isDirectory = (source) => {
+    // if(path.basename(source) === path.basename(config.dirPath)) return false
+    return fs.lstatSync(source).isDirectory();
+};
+exports.detect = (configObject, files) => {
+    if (!configObject) {
+        return;
+    }
+    const { config } = configObject;
+    if (!config)
+        throw new Error("No configuration found during the engine detection");
+    if (!config.entries)
+        throw new Error("No configuration found for entries, please add a 'entries' object with the default file name for your exercise entry file that is going to be used while compiling, for example: index.html for html, app.py for python3, etc.");
+    // A language was found on the config object, but this language will only be used as last resort, learnpack will try to guess each exercise language independently based on file extension (js, jsx, html, etc.)
+    let hasFiles = files.filter(f => f.includes(".py"));
+    if (hasFiles.length > 0)
+        return {
+            language: "python3",
+            entry: hasFiles.find(f => config.entries.python3 === f),
+        };
+    hasFiles = files.filter(f => f.includes(".java"));
+    if (hasFiles.length > 0)
+        return {
+            language: "java",
+            entry: hasFiles.find(f => config.entries.java === f),
+        };
+    hasFiles = files.filter(f => f.includes(".jsx"));
+    if (hasFiles.length > 0)
+        return {
+            language: "react",
+            entry: hasFiles.find(f => config.entries.react === f),
+        };
+    const hasHTML = files.filter(f => f.includes("index.html"));
+    const hasIndexJS = files.find(f => f.includes("index.js"));
+    const hasJS = files.filter(f => f.includes(".js"));
+    // angular, vue, vanillajs needs to have at least 2 files (html,css,js),
+    // the test.js and the entry file in js
+    // if not its just another HTML
+    if (hasIndexJS && hasHTML.length > 0)
+        return {
+            language: "vanillajs",
+            entry: hasIndexJS,
+        };
+    if (hasHTML.length > 0)
+        return {
+            language: "html",
+            entry: hasHTML.find(f => config.entries.html === f),
+        };
+    if (hasJS.length > 0)
+        return {
+            language: "node",
+            entry: hasJS.find(f => config.entries.node === f),
+        };
+    return {
+        language: null,
+        entry: null,
+    };
+};
+exports.filterFiles = (files, basePath = ".") => files
+    .map((ex) => ({
+    path: basePath + "/" + ex,
+    name: ex,
+    hidden: !exports.shouldBeVisible({
+        name: ex,
+        path: basePath + "/" + ex,
+    }),
+}))
+    .sort((f1, f2) => {
+    const score = {
+        // sorting priority
+        "index.html": 1,
+        "styles.css": 2,
+        "styles.scss": 2,
+        "style.css": 2,
+        "style.scss": 2,
+        "index.css": 2,
+        "index.scss": 2,
+        "index.js": 3,
+    };
+    return score[f1.name] < score[f2.name] ? -1 : 1;
+});
+exports.default = {
+    exercise: exports.exercise,
+    detect: exports.detect,
+    filterFiles: exports.filterFiles,
+};

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

@@ -0,0 +1,3 @@
+import { IConfigManagerAttributes, IConfigManager } from "../../models/config-manager";
+declare const _default: ({ grading, mode, disableGrading, version, }: IConfigManagerAttributes) => Promise<IConfigManager>;
+export default _default;

package/lib/managers/config/index.js

@@ -0,0 +1,307 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+const fs = require("fs");
+const shell = require("shelljs");
+const console_1 = require("../../utils/console");
+const watcher_1 = require("../../utils/watcher");
+const errors_1 = require("../../utils/errors");
+const defaults_1 = require("./defaults");
+const exercise_1 = require("./exercise");
+const file_1 = require("../file");
+/* exercise folder name standard */
+// eslint-disable-next-line
+const fetch = require("node-fetch");
+// eslint-disable-next-line
+const chalk = require("chalk");
+/* exercise folder name standard */
+const getConfigPath = () => {
+    const possibleFileNames = [
+        "learn.json",
+        ".learn/learn.json",
+        "bc.json",
+        ".breathecode/bc.json",
+    ];
+    const config = possibleFileNames.find(file => fs.existsSync(file)) || null;
+    if (config && fs.existsSync(".breathecode"))
+        return { config, base: ".breathecode" };
+    if (config === null)
+        throw errors_1.NotFoundError("learn.json file not found on current folder, is this a learnpack package?");
+    return { config, base: ".learn" };
+};
+const getExercisesPath = (base) => {
+    const possibleFileNames = ["./exercises", base + "/exercises", "./"];
+    return possibleFileNames.find(file => fs.existsSync(file)) || null;
+};
+const getGitpodAddress = () => {
+    if (shell.exec("gp -h", { silent: true }).code === 0) {
+        return shell
+            .exec("gp url", { silent: true })
+            .stdout.replace(/(\r\n|\n|\r)/gm, "");
+    }
+    console_1.default.debug("Gitpod command line tool not found");
+    return "http://localhost";
+};
+exports.default = async ({ grading, mode, disableGrading, version, }) => {
+    var _a, _b;
+    const confPath = getConfigPath();
+    console_1.default.debug("This is the config path: ", confPath);
+    let configObj = {};
+    if (confPath) {
+        const bcContent = fs.readFileSync(confPath.config);
+        let hiddenBcContent = {};
+        if (fs.existsSync(confPath.base + "/config.json")) {
+            hiddenBcContent = fs.readFileSync(confPath.base + "/config.json");
+            hiddenBcContent = JSON.parse(hiddenBcContent);
+            if (!hiddenBcContent)
+                throw new Error(`Invalid ${confPath.base}/config.json syntax: Unable to parse.`);
+        }
+        const jsonConfig = JSON.parse(`${bcContent}`);
+        if (!jsonConfig)
+            throw new Error(`Invalid ${confPath.config} syntax: Unable to parse.`);
+        let session;
+        // add using id to the installation
+        if (!jsonConfig.session) {
+            session = Math.floor(Math.random() * 10000000000000000000);
+        }
+        else {
+            session = jsonConfig.session;
+            delete jsonConfig.session;
+        }
+        configObj = deepMerge(hiddenBcContent, {
+            config: jsonConfig,
+            session: session,
+        });
+        console_1.default.debug("Content from the configuration .json ", configObj);
+    }
+    else {
+        throw errors_1.ValidationError("No learn.json file has been found, make sure you are in the folder");
+    }
+    configObj = deepMerge(defaults_1.default || {}, configObj, {
+        config: {
+            grading: grading || ((_a = configObj.config) === null || _a === void 0 ? void 0 : _a.grading),
+            configPath: confPath.config,
+        },
+    });
+    if (configObj.config) {
+        configObj.config.outputPath = confPath.base + "/dist";
+    }
+    console_1.default.debug("This is your configuration object: ", Object.assign(Object.assign({}, configObj), { exercises: configObj.exercises ?
+            configObj.exercises.map(e => e.slug) :
+            [] }));
+    // auto detect agent (if possible)
+    if (shell.which("gp") && configObj && configObj.config) {
+        configObj.config.editor.agent = "gitpod";
+        configObj.address = getGitpodAddress();
+        configObj.config.publicUrl = `https://${configObj.config.port}-${(_b = configObj.address) === null || _b === void 0 ? void 0 : _b.slice(8)}`;
+    }
+    else if (configObj.config && !configObj.config.editor.agent) {
+        configObj.config.editor.agent = "localhost";
+    }
+    if (configObj.config && !configObj.config.publicUrl)
+        configObj.config.publicUrl = `${configObj.address}:${configObj.config.port}`;
+    // Assign default editor mode if not set already
+    if (configObj.config && mode !== null) {
+        configObj.config.editor.mode = mode || "vscode";
+    }
+    if (configObj.config && !configObj.config.editor.mode)
+        configObj.config.editor.mode =
+            configObj.config.editor.agent === "localhost" ? "standalone" : "preview";
+    if (version && configObj.config)
+        configObj.config.editor.version = version;
+    else if (configObj.config && configObj.config.editor.version === null) {
+        console_1.default.debug("Config version not found, downloading default.");
+        const resp = await fetch("https://raw.githubusercontent.com/learnpack/coding-ide/learnpack/package.json");
+        const packageJSON = await resp.json();
+        configObj.config.editor.version = packageJSON.version || "1.0.72";
+    }
+    if (configObj.config) {
+        configObj.config.dirPath = "./" + confPath.base;
+        configObj.config.exercisesPath = getExercisesPath(confPath.base) || "./";
+    }
+    return {
+        validLanguages: {},
+        get: () => configObj,
+        validateEngine: function (language, server, socket) {
+            // eslint-disable-next-line
+            const alias = (_l) => {
+                const map = {
+                    python3: "python",
+                };
+                if (map[_l])
+                    return map[_l];
+                return _l;
+            };
+            // decode aliases
+            language = alias(language);
+            if (this.validLanguages[language])
+                return true;
+            console_1.default.debug(`Validating engine for ${language} compilation`);
+            let result = shell.exec("learnpack plugins", { silent: true });
+            if (result.code === 0 &&
+                result.stdout.includes(`learnpack-${language}`)) {
+                this.validLanguages[language] = true;
+                return true;
+            }
+            console_1.default.info(`Language engine for ${language} not found, installing...`);
+            result = shell.exec(`learnpack plugins:install learnpack-${language}`, {
+                silent: true,
+            });
+            if (result.code === 0) {
+                socket.log("compiling", "Installing the python compiler, you will have to reset the exercises after installation by writing on your terminal: $ learnpack run");
+                console_1.default.info(`Successfully installed the ${language} exercise engine, \n please start learnpack again by running the following command: \n ${chalk.white("$ learnpack start")}\n\n `);
+                server.terminate();
+                return false;
+            }
+            this.validLanguages[language] = false;
+            socket.error(`Error installing ${language} exercise engine`);
+            console_1.default.error(`Error installing ${language} exercise engine`);
+            console_1.default.log(result.stdout);
+            throw errors_1.InternalError(`Error installing ${language} exercise engine`);
+        },
+        clean: () => {
+            if (configObj.config) {
+                if (configObj.config.outputPath) {
+                    file_1.rmSync(configObj.config.outputPath);
+                }
+                file_1.rmSync(configObj.config.dirPath + "/_app");
+                file_1.rmSync(configObj.config.dirPath + "/reports");
+                file_1.rmSync(configObj.config.dirPath + "/.session");
+                file_1.rmSync(configObj.config.dirPath + "/resets");
+                // clean tag gz
+                if (fs.existsSync(configObj.config.dirPath + "/app.tar.gz"))
+                    fs.unlinkSync(configObj.config.dirPath + "/app.tar.gz");
+                if (fs.existsSync(configObj.config.dirPath + "/config.json"))
+                    fs.unlinkSync(configObj.config.dirPath + "/config.json");
+                if (fs.existsSync(configObj.config.dirPath + "/vscode_queue.json"))
+                    fs.unlinkSync(configObj.config.dirPath + "/vscode_queue.json");
+            }
+        },
+        getExercise: slug => {
+            console_1.default.debug("ExercisePath Slug", slug);
+            const exercise = (configObj.exercises || []).find(ex => ex.slug === slug);
+            if (!exercise)
+                throw errors_1.ValidationError(`Exercise ${slug} not found`);
+            return exercise;
+        },
+        getAllExercises: () => {
+            return configObj.exercises;
+        },
+        startExercise: function (slug) {
+            const exercise = this.getExercise(slug);
+            // set config.json with current exercise
+            configObj.currentExercise = exercise.slug;
+            this.save();
+            // eslint-disable-next-line
+            exercise.files.forEach((f) => {
+                if (configObj.config) {
+                    const _path = configObj.config.outputPath + "/" + f.name;
+                    if (f.hidden === false && fs.existsSync(_path))
+                        fs.unlinkSync(_path);
+                }
+            });
+            return exercise;
+        },
+        noCurrentExercise: function () {
+            configObj.currentExercise = null;
+            this.save();
+        },
+        reset: slug => {
+            var _a;
+            if (configObj.config &&
+                !fs.existsSync(`${configObj.config.dirPath}/resets/` + slug))
+                throw errors_1.ValidationError("Could not find the original files for " + slug);
+            const exercise = (configObj.exercises || []).find(ex => ex.slug === slug);
+            if (!exercise)
+                throw errors_1.ValidationError(`Exercise ${slug} not found on the configuration`);
+            if (configObj.config) {
+                for (const fileName of fs.readdirSync(`${configObj.config.dirPath}/resets/${slug}/`)) {
+                    const content = fs.readFileSync(`${(_a = configObj.config) === null || _a === void 0 ? void 0 : _a.dirPath}/resets/${slug}/${fileName}`);
+                    fs.writeFileSync(`${exercise.path}/${fileName}`, content);
+                }
+            }
+        },
+        buildIndex: function () {
+            var _a, _b;
+            console_1.default.info("Building the exercise index...");
+            const isDirectory = (source) => {
+                var _a;
+                const name = path.basename(source);
+                if (name === path.basename(((_a = configObj === null || configObj === void 0 ? void 0 : configObj.config) === null || _a === void 0 ? void 0 : _a.dirPath) || ""))
+                    return false;
+                // ignore folders that start with a dot
+                if (name.charAt(0) === "." || name.charAt(0) === "_")
+                    return false;
+                return fs.lstatSync(source).isDirectory();
+            };
+            const getDirectories = (source) => fs
+                .readdirSync(source)
+                .map(name => path.join(source, name))
+                .filter(isDirectory);
+            // add the .learn folder
+            if (!fs.existsSync(confPath.base))
+                fs.mkdirSync(confPath.base);
+            // add the outout folder where webpack will publish the the html/css/js files
+            if (configObj.config &&
+                configObj.config.outputPath &&
+                !fs.existsSync(configObj.config.outputPath))
+                fs.mkdirSync(configObj.config.outputPath);
+            // TODO: we could use npm library front-mater to read the title of the exercises from the README.md
+            const grupedByDirectory = getDirectories(((_a = configObj === null || configObj === void 0 ? void 0 : configObj.config) === null || _a === void 0 ? void 0 : _a.exercisesPath) || "");
+            configObj.exercises =
+                grupedByDirectory.length > 0 ?
+                    grupedByDirectory.map((path, position) => exercise_1.exercise(path, position, configObj)) :
+                    [exercise_1.exercise(((_b = configObj === null || configObj === void 0 ? void 0 : configObj.config) === null || _b === void 0 ? void 0 : _b.exercisesPath) || "", 0, configObj)];
+            this.save();
+        },
+        watchIndex: function (onChange) {
+            var _a;
+            if (configObj.config && !configObj.config.exercisesPath)
+                throw errors_1.ValidationError("No exercises directory to watch: " + configObj.config.exercisesPath);
+            this.buildIndex();
+            watcher_1.default(((_a = configObj === null || configObj === void 0 ? void 0 : configObj.config) === null || _a === void 0 ? void 0 : _a.exercisesPath) || "")
+                .then(( /* eventname, filename */) => {
+                console_1.default.debug("Changes detected on your exercises");
+                this.buildIndex();
+                if (onChange)
+                    onChange();
+            })
+                .catch(error => {
+                throw error;
+            });
+        },
+        save: () => {
+            console_1.default.debug("Saving configuration with: ", configObj);
+            // remove the duplicates form the actions array
+            // configObj.config.actions = [...new Set(configObj.config.actions)];
+            if (configObj.config) {
+                configObj.config.translations = [
+                    ...new Set(configObj.config.translations),
+                ];
+                fs.writeFileSync(configObj.config.dirPath + "/config.json", JSON.stringify(configObj, null, 4));
+            }
+        },
+    };
+};
+function deepMerge(...sources) {
+    let acc = {};
+    for (const source of sources) {
+        if (Array.isArray(source)) {
+            if (!Array.isArray(acc)) {
+                acc = [];
+            }
+            acc = [...source];
+        }
+        else if (source instanceof Object) {
+            // eslint-disable-next-line
+            for (let [key, value] of Object.entries(source)) {
+                if (value instanceof Object && key in acc) {
+                    value = deepMerge(acc[key], value);
+                }
+                if (value !== undefined)
+                    acc = Object.assign(Object.assign({}, acc), { [key]: value });
+            }
+        }
+    }
+    return acc;
+}

package/lib/managers/file.d.ts

@@ -0,0 +1,13 @@
+export declare const decompress: (sourcePath: string, destinationPath: string) => Promise<unknown>;
+export declare const downloadEditor: (version: string | undefined, destination: string) => Promise<unknown>;
+export declare const download: (url: string, dest: string) => Promise<unknown>;
+export declare const clone: (repository?: string, folder?: string) => Promise<unknown>;
+export declare const rmSync: (path: string) => void;
+declare const _default: {
+    download: (url: string, dest: string) => Promise<unknown>;
+    decompress: (sourcePath: string, destinationPath: string) => Promise<unknown>;
+    downloadEditor: (version: string | undefined, destination: string) => Promise<unknown>;
+    clone: (repository?: string, folder?: string) => Promise<unknown>;
+    rmSync: (path: string) => void;
+};
+export default _default;