@gravity-ui/app-builder 0.0.1

package/dist/common/library/index.js

@@ -0,0 +1,302 @@
+"use strict";
+/* eslint-disable quotes */
+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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildLibrary = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const child_process_1 = __importDefault(require("child_process"));
+const babel = __importStar(require("@babel/core"));
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const rimraf_1 = __importDefault(require("rimraf"));
+const sass_1 = __importDefault(require("sass"));
+const postcss_1 = __importDefault(require("postcss"));
+const postcss_preset_env_1 = __importDefault(require("postcss-preset-env"));
+const core_1 = require("@svgr/core");
+const paths_1 = __importDefault(require("../../common/paths"));
+const logger_1 = __importDefault(require("../../common/logger"));
+const babel_1 = require("../babel");
+function getFilePath(filePath, { ext, dir } = { dir: paths_1.default.src }) {
+    let filePathWithExt = filePath;
+    if (ext) {
+        filePathWithExt = filePath.replace(path_1.default.extname(filePath), `.${ext}`);
+    }
+    return dir ? path_1.default.resolve(dir, filePathWithExt) : filePathWithExt;
+}
+function errorHandlerFactory(msg) {
+    return (err) => {
+        if (err) {
+            if (msg) {
+                logger_1.default.error(msg);
+            }
+            logger_1.default.error(err.toString());
+            throw err;
+        }
+    };
+}
+function copyToCjs(file, inputDir = paths_1.default.libBuildEsm) {
+    const esmFile = getFilePath(file, { dir: inputDir });
+    const cjsFile = getFilePath(file, { dir: paths_1.default.libBuildCjs });
+    const cjsDir = path_1.default.dirname(cjsFile);
+    fs_1.default.mkdirSync(cjsDir, { recursive: true });
+    fs_1.default.copyFile(esmFile, cjsFile, errorHandlerFactory(`Failed to copy file to cjs ${esmFile}`));
+}
+function compileToCjs(code, file, inputSourceMap, sourceDir = paths_1.default.src, compiledDir = paths_1.default.libBuildCjs) {
+    const sourceFile = getFilePath(file, { dir: sourceDir });
+    const compiledCjsFile = getFilePath(file, { dir: compiledDir, ext: 'js' });
+    const compiledCjsDir = path_1.default.dirname(compiledCjsFile);
+    const sourcemapCjsFile = getFilePath(file, { dir: compiledDir, ext: 'js.map' });
+    const sourcemapCjsUrl = `// #sourceMappingURL=${path_1.default.basename(sourcemapCjsFile)}`;
+    const finalCode = code.replace(/import '(.*)\.css';/g, '');
+    fs_1.default.mkdirSync(compiledCjsDir, { recursive: true });
+    babel.transform(finalCode, {
+        filename: sourceFile,
+        plugins: ['@babel/plugin-transform-modules-commonjs', 'dynamic-import-node'],
+        sourceMaps: true,
+        inputSourceMap,
+    }, (err, transformedCjs) => {
+        var _a;
+        if (err) {
+            logger_1.default.error(`Source compilation errors for ${sourceFile}`);
+            logger_1.default.error(err.toString());
+            throw err;
+        }
+        else if (transformedCjs) {
+            let cjsCode = (_a = transformedCjs.code) !== null && _a !== void 0 ? _a : '';
+            cjsCode += (cjsCode.length ? '\n' : '') + sourcemapCjsUrl;
+            fs_1.default.writeFile(compiledCjsFile, cjsCode, errorHandlerFactory(`Source compilation has failed on writing ${compiledCjsFile}`));
+            if (transformedCjs.map) {
+                fs_1.default.writeFile(sourcemapCjsFile, JSON.stringify(transformedCjs.map), errorHandlerFactory(`Source compilation has failed on writing ${sourcemapCjsFile}`));
+            }
+        }
+    });
+}
+function compileStyles(inputDir, outputDir, onFinish, additionalGlobs = []) {
+    const origStylesStream = fast_glob_1.default.stream(['**/*.{sass,scss,css}', ...additionalGlobs], {
+        cwd: inputDir,
+    });
+    origStylesStream.on('data', (file) => {
+        const origScssFile = getFilePath(file, { dir: inputDir });
+        const scssFile = getFilePath(file, { dir: outputDir });
+        const scssDir = path_1.default.dirname(scssFile);
+        fs_1.default.mkdirSync(scssDir, { recursive: true });
+        if (origScssFile !== scssFile) {
+            const content = fs_1.default
+                .readFileSync(origScssFile, 'utf-8')
+                .replace(/url\(([.]*)..\/assets\//g, 'url($1../../assets/');
+            fs_1.default.writeFileSync(scssFile, content);
+        }
+    });
+    origStylesStream.on('finish', () => {
+        const globs = outputDir === paths_1.default.libBuildEsm
+            ? ['**/*.{sass,scss,css}', '!cjs/**/*']
+            : ['**/*.{sass,scss,css}'];
+        const stylesStream = fast_glob_1.default.stream(globs, { cwd: outputDir });
+        stylesStream.on('data', async (file) => {
+            var _a;
+            const origScssFile = getFilePath(file, { dir: inputDir });
+            const scssFile = getFilePath(file, { dir: outputDir });
+            const cssFile = getFilePath(file, { dir: outputDir, ext: 'css' });
+            const sourceMapFile = getFilePath(file, { dir: outputDir, ext: 'css.map' });
+            try {
+                const sassTransformed = sass_1.default.renderSync({
+                    file: scssFile,
+                    sourceMap: true,
+                    sourceMapContents: true,
+                    outFile: cssFile,
+                    importer: (url) => {
+                        if (url.startsWith('~')) {
+                            return { file: path_1.default.resolve(paths_1.default.appNodeModules, url.replace('~', '')) };
+                        }
+                        return new Error(`Unrecognized import ${url} in ${origScssFile}`);
+                    },
+                });
+                if (sassTransformed === null || sassTransformed === void 0 ? void 0 : sassTransformed.css) {
+                    const postcssTransformed = await (0, postcss_1.default)([(0, postcss_preset_env_1.default)()]).process(sassTransformed.css, {
+                        to: cssFile.split('/').pop(),
+                        map: { prev: (_a = sassTransformed.map) === null || _a === void 0 ? void 0 : _a.toString(), inline: false },
+                    });
+                    fs_1.default.writeFileSync(cssFile, postcssTransformed.css);
+                    if (postcssTransformed.map) {
+                        fs_1.default.writeFileSync(sourceMapFile, JSON.stringify(postcssTransformed.map.toJSON()));
+                    }
+                }
+            }
+            catch (sassErr) {
+                logger_1.default.error(`Style compilation errors for ${scssFile}`);
+                throw sassErr;
+            }
+        });
+        if (onFinish) {
+            stylesStream.on('finish', onFinish);
+        }
+    });
+}
+const svgoPreset = {
+    name: 'preset-default',
+    params: { overrides: { removeViewBox: false } },
+};
+function buildLibrary(config) {
+    var _a, _b, _c;
+    const internalGlobs = (_c = (_b = (_a = config.lib) === null || _a === void 0 ? void 0 : _a.internalDirs) === null || _b === void 0 ? void 0 : _b.map((dir) => `!${dir}/**/*`)) !== null && _c !== void 0 ? _c : [];
+    rimraf_1.default.sync(paths_1.default.libBuild);
+    // sources compilation
+    const sourceStream = fast_glob_1.default.stream(['**/*.{js,jsx,ts,tsx}', '!**/*.d.ts', ...internalGlobs], {
+        cwd: paths_1.default.src,
+    });
+    sourceStream.on('data', (file) => {
+        const sourceFile = getFilePath(file);
+        const compiledFile = getFilePath(file, { dir: paths_1.default.libBuildEsm, ext: 'js' });
+        const compiledDir = path_1.default.dirname(compiledFile);
+        const sourcemapFile = getFilePath(file, { dir: paths_1.default.libBuildEsm, ext: 'js.map' });
+        const sourcemapUrl = `// #sourceMappingURL=${path_1.default.basename(sourcemapFile)}`;
+        const source = fs_1.default.readFileSync(sourceFile, 'utf-8');
+        fs_1.default.mkdirSync(compiledDir, { recursive: true });
+        babel.transform(source, {
+            filename: sourceFile,
+            presets: [(0, babel_1.babelPreset)(config)],
+            plugins: [
+                [
+                    require.resolve('babel-plugin-inline-react-svg'),
+                    {
+                        ignorePattern: /^\./,
+                        svgo: {
+                            plugins: [svgoPreset],
+                        },
+                    },
+                ],
+                require.resolve('babel-plugin-lodash'),
+            ],
+            sourceMaps: true,
+        }, (err, transformed) => {
+            var _a, _b, _c, _d, _e;
+            if (err) {
+                logger_1.default.error(`Source compilation errors for ${sourceFile}`);
+                logger_1.default.error(err.toString());
+                throw err;
+            }
+            else if (transformed) {
+                let code = (_e = (_d = (_c = (_b = (_a = transformed.code) === null || _a === void 0 ? void 0 : _a.replace(/import '\.(.*)\.scss';/g, "import '.$1.css';")) === null || _b === void 0 ? void 0 : _b.replace(/import (\w*) from '\.\.\/(.*)\/assets\/(.*)\.svg';/g, "import $1 from '$2/assets/$3';")) === null || _c === void 0 ? void 0 : _c.replace(/export { *default as (\w*) *} from '\.\.\/(.*)\/assets\/(.*)\.svg';/g, "export { default as $1 } from '$2/assets/$3';")) === null || _d === void 0 ? void 0 : _d.replace(/import\('\.\.\/(.*)\/assets\/(.*)\.svg'\)/g, "import('$1/assets/$2')")) !== null && _e !== void 0 ? _e : '';
+                code += (code.length ? '\n' : '') + sourcemapUrl;
+                fs_1.default.writeFile(compiledFile, code, errorHandlerFactory(`Source compilation has failed on writing ${compiledFile}`));
+                if (transformed.map) {
+                    fs_1.default.writeFile(sourcemapFile, JSON.stringify(transformed.map), errorHandlerFactory(`Source compilation has failed on writing ${sourcemapFile}`));
+                }
+                compileToCjs(code, file, transformed.map);
+            }
+        });
+    });
+    // type definitions compilation and type checking
+    const projectFilePath = path_1.default.resolve(paths_1.default.app, 'tsconfig.publish.json');
+    const tscExec = path_1.default.resolve(paths_1.default.appNodeModules, 'typescript/bin/tsc');
+    child_process_1.default.exec(`${tscExec} -p ${projectFilePath} --declaration --emitDeclarationOnly --outDir build/esm`, (error, stdout, stderr) => {
+        logger_1.default.message(stdout);
+        logger_1.default.error(stderr);
+        if (!error && !stderr) {
+            logger_1.default.message('Typechecking successfully completed');
+            const typingsStream = fast_glob_1.default.stream(['**/*.d.ts', '!cjs/**/*'], {
+                cwd: paths_1.default.libBuildEsm,
+            });
+            typingsStream.on('data', copyToCjs);
+        }
+        else {
+            logger_1.default.error('Errors during library typechecking. Aborting...');
+            process.exit(1);
+        }
+    });
+    // css compilation
+    compileStyles(paths_1.default.libGlobalStyles, paths_1.default.libCompiledGlobalStyles, () => {
+        compileStyles(paths_1.default.src, paths_1.default.libBuildEsm, undefined, internalGlobs);
+    });
+    // icons compilation to js
+    const iconSvgoDefinition = `
+    import React from 'react';
+    const SvgComponent: React.ComponentType<React.SVGProps<SVGSVGElement>>;
+    export default SvgComponent;
+    `;
+    const iconBaseDefinition = `
+    const icon: string;
+    export default icon;
+    `;
+    const svgoRegEx = /assets\/icons/;
+    const iconsStream = fast_glob_1.default.stream(['**/*.svg', ...internalGlobs], { cwd: paths_1.default.libAssets });
+    iconsStream.on('data', async (file) => {
+        const iconFile = getFilePath(file, { dir: paths_1.default.libAssets });
+        const componentFile = getFilePath(file, { dir: paths_1.default.libCompiledAssetsEsm, ext: 'js' });
+        const componentDir = path_1.default.dirname(componentFile);
+        const componentDefFile = getFilePath(file, { dir: paths_1.default.libCompiledAssetsEsm, ext: 'd.ts' });
+        if (svgoRegEx.test(iconFile)) {
+            try {
+                const component = await (0, core_1.transform)(fs_1.default.readFileSync(iconFile, 'utf-8'));
+                babel.transform(component, {
+                    filename: iconFile,
+                    presets: [(0, babel_1.babelPreset)(config)],
+                    sourceMaps: true,
+                }, (err, transformed) => {
+                    if (err) {
+                        logger_1.default.error(`Icons compilation errors for ${iconFile}`);
+                        logger_1.default.error(err.toString());
+                        throw err;
+                    }
+                    else if (transformed) {
+                        if (transformed.code) {
+                            fs_1.default.mkdirSync(componentDir, { recursive: true });
+                            fs_1.default.writeFile(componentFile, transformed.code, errorHandlerFactory(`Icons compilation has failed on writing ${componentFile}`));
+                            fs_1.default.writeFile(componentDefFile, iconBaseDefinition, errorHandlerFactory(`Icons compilations has failed on writing ${componentFile}`));
+                            compileToCjs(transformed.code, file, transformed.map, paths_1.default.libAssets, paths_1.default.libCompiledAssetsCjs);
+                        }
+                    }
+                });
+            }
+            catch (err) {
+                logger_1.default.error(`Svgo compilation errors for ${iconFile}`);
+                throw err;
+            }
+        }
+        else {
+            // eslint-disable-next-line security/detect-new-buffer
+            const encoded = new Buffer(fs_1.default.readFileSync(iconFile, 'utf-8')).toString('base64');
+            const code = `export default 'data:image/svg+xml;base64,${encoded}'`;
+            fs_1.default.mkdirSync(componentDir, { recursive: true });
+            fs_1.default.writeFile(componentFile, code, errorHandlerFactory(`Icons compilation has failed on writing ${componentFile}`));
+            fs_1.default.writeFile(componentDefFile, iconSvgoDefinition, errorHandlerFactory(`Icons compilations has failed on writing ${componentFile}`));
+            compileToCjs(code, file, undefined, paths_1.default.libAssets, paths_1.default.libCompiledAssetsCjs);
+        }
+    });
+    // file assets copying
+    const assetsStream = fast_glob_1.default.stream(['**/*.json', '**/*.d.ts', ...internalGlobs], { cwd: paths_1.default.src });
+    assetsStream.on('data', (file) => {
+        const assetFile = getFilePath(file);
+        const copiedAssetFile = getFilePath(file, { dir: paths_1.default.libBuildEsm });
+        const assetDir = path_1.default.dirname(copiedAssetFile);
+        fs_1.default.mkdirSync(assetDir, { recursive: true });
+        fs_1.default.copyFile(assetFile, copiedAssetFile, errorHandlerFactory(`Failed to copy file ${assetFile}`));
+        copyToCjs(file, paths_1.default.src);
+    });
+}
+exports.buildLibrary = buildLibrary;

package/dist/common/links/link.d.ts

@@ -0,0 +1 @@
+export default function link(packageLocation: string): void;

package/dist/common/links/link.js

@@ -0,0 +1,109 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const semver_1 = __importDefault(require("semver"));
+const lodash_1 = __importDefault(require("lodash"));
+const logger_1 = __importDefault(require("../logger"));
+const package_1 = require("../package");
+const paths_1 = __importDefault(require("../paths"));
+const tempData_1 = __importDefault(require("../tempData"));
+const unlink_1 = require("./unlink");
+function createRecursive(modulePath) {
+    const { dir } = path_1.default.parse(modulePath);
+    if (!fs_extra_1.default.existsSync(dir)) {
+        fs_extra_1.default.mkdirpSync(dir);
+    }
+}
+let unlinkTried = false;
+function link(packageLocation) {
+    const linkedPackageLocation = packageLocation.startsWith('/')
+        ? packageLocation
+        : path_1.default.resolve(paths_1.default.app, packageLocation);
+    if (linkedPackageLocation) {
+        const packageInfo = (0, package_1.readPackage)(linkedPackageLocation);
+        const packNodeModulesDir = path_1.default.resolve(packageInfo.location, 'node_modules');
+        const hiddenNodeModuleDir = path_1.default.resolve(packageInfo.location, '.node_modules');
+        const linkedPackage = {
+            name: packageInfo.name,
+            location: packageInfo.location,
+            nodeModules: [],
+        };
+        try {
+            fs_extra_1.default.moveSync(packNodeModulesDir, hiddenNodeModuleDir);
+            const packNodeModulesInfo = (0, package_1.readNodeModules)(hiddenNodeModuleDir);
+            const appNodeModulesInfo = (0, package_1.readNodeModules)(paths_1.default.appNodeModules);
+            if (packageInfo.peerDependencies) {
+                Object.keys(packageInfo.peerDependencies).forEach((peerDep) => {
+                    if (!appNodeModulesInfo.keys.includes(peerDep)) {
+                        logger_1.default.warning(`Application doesn't have ${peerDep}, required in peerDependencies of linked package`);
+                    }
+                    else {
+                        const appDepVersion = appNodeModulesInfo.data[peerDep].version;
+                        const requiredVersion = packageInfo.peerDependencies[peerDep];
+                        if (!semver_1.default.satisfies(appDepVersion, requiredVersion)) {
+                            logger_1.default.warning(`Application dep ${peerDep} version ${appDepVersion} doesn't satisfy linked package requirement of ${requiredVersion}`);
+                        }
+                    }
+                });
+            }
+            const nodeModulesToLink = packageInfo.devDependencies
+                ? lodash_1.default.difference(packNodeModulesInfo.keys, Object.keys(packageInfo.devDependencies))
+                : packNodeModulesInfo.keys;
+            nodeModulesToLink.forEach((key) => {
+                const nodeModule = packNodeModulesInfo.data[key];
+                if (appNodeModulesInfo.keys.includes(key)) {
+                    if (!semver_1.default.satisfies(appNodeModulesInfo.data[key].version, nodeModule.version)) {
+                        const newPath = path_1.default.resolve(packNodeModulesDir, nodeModule.name);
+                        createRecursive(newPath);
+                        fs_extra_1.default.symlinkSync(nodeModule.location, newPath);
+                        linkedPackage.nodeModules.push(newPath);
+                    }
+                }
+                else {
+                    const newPath = path_1.default.resolve(paths_1.default.appNodeModules, nodeModule.name);
+                    createRecursive(newPath);
+                    fs_extra_1.default.symlinkSync(nodeModule.location, path_1.default.resolve(paths_1.default.appNodeModules, nodeModule.name));
+                    linkedPackage.package = newPath;
+                    linkedPackage.nodeModules.push(newPath);
+                }
+            });
+            const newPath = path_1.default.resolve(paths_1.default.appNodeModules, packageInfo.name);
+            if (fs_extra_1.default.existsSync(newPath)) {
+                const hiddenPackage = path_1.default.resolve(paths_1.default.appNodeModules, `.${packageInfo.name}`);
+                fs_extra_1.default.moveSync(newPath, hiddenPackage);
+                linkedPackage.restorePackageFrom = hiddenPackage;
+            }
+            fs_extra_1.default.symlinkSync(packageInfo.location, newPath);
+            linkedPackage.package = newPath;
+            if (fs_extra_1.default.existsSync(path_1.default.resolve(linkedPackage.location, 'tsconfig.json'))) {
+                linkedPackage.typescript = true;
+            }
+            let { linkedPackages } = tempData_1.default.getSettings();
+            if (!linkedPackages) {
+                linkedPackages = { data: {}, keys: [] };
+            }
+            linkedPackages.data[linkedPackage.name] = linkedPackage;
+            linkedPackages.keys.push(linkedPackage.name);
+            tempData_1.default.saveSettings({ linkedPackages });
+            logger_1.default.success(`Link to ${linkedPackage.name} was successfully created`);
+        }
+        catch (e) {
+            (0, unlink_1.unlinkPackage)(linkedPackage);
+            if (!unlinkTried) {
+                unlinkTried = true;
+                link(packageLocation);
+            }
+            else {
+                logger_1.default.logError(e);
+            }
+        }
+    }
+    else {
+        logger_1.default.error('Package to link should be specified');
+    }
+}
+exports.default = link;

package/dist/common/links/unlink.d.ts

@@ -0,0 +1,3 @@
+import type { LinkedPackage } from '../models';
+export declare function unlinkPackage(linkedPackage: LinkedPackage): void;
+export default function unlink(): void;

package/dist/common/links/unlink.js

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unlinkPackage = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const rimraf_1 = __importDefault(require("rimraf"));
+const path_1 = __importDefault(require("path"));
+const logger_1 = __importDefault(require("../logger"));
+const tempData_1 = __importDefault(require("../tempData"));
+// import paths from '../paths';
+function unlinkPackage(linkedPackage) {
+    logger_1.default.warning('Cleaning up created links...');
+    linkedPackage.nodeModules.forEach(fs_extra_1.default.unlinkSync);
+    if (linkedPackage.package) {
+        fs_extra_1.default.unlinkSync(linkedPackage.package);
+    }
+    if (linkedPackage.package && linkedPackage.restorePackageFrom) {
+        fs_extra_1.default.moveSync(linkedPackage.restorePackageFrom, linkedPackage.package);
+    }
+    const packNodeModulesDir = path_1.default.resolve(linkedPackage.location, 'node_modules');
+    const hiddenNodeModuleDir = path_1.default.resolve(linkedPackage.location, '.node_modules');
+    rimraf_1.default.sync(packNodeModulesDir);
+    fs_extra_1.default.moveSync(hiddenNodeModuleDir, packNodeModulesDir);
+    const { linkedPackages } = tempData_1.default.getSettings();
+    if (linkedPackages) {
+        delete linkedPackages.data[linkedPackage.name];
+        linkedPackages.keys.splice(linkedPackages.keys.indexOf(linkedPackage.name), 1);
+        tempData_1.default.saveSettings({ linkedPackages });
+    }
+    logger_1.default.success(`${linkedPackage.name} package was unlinked`);
+}
+exports.unlinkPackage = unlinkPackage;
+function unlink() {
+    const { linkedPackages } = tempData_1.default.getSettings();
+    if (linkedPackages) {
+        // const packageToUnlink = config.subcommands && config.subcommands[0];
+        //
+        // if (packageToUnlink) {
+        //     let foundPackage: LinkedPackage | undefined;
+        //     if (linkedPackages.data[packageToUnlink]) {
+        //         foundPackage = linkedPackages.data[packageToUnlink];
+        //     } else {
+        //         const locationToFind = packageToUnlink.startsWith('/')
+        //             ? packageToUnlink
+        //             : path.resolve(paths.app, packageToUnlink);
+        //
+        //         foundPackage = linkedPackages.keys
+        //             .map((key) => linkedPackages.data[key])
+        //             .find(({location}) => location === locationToFind);
+        //     }
+        //
+        //     if (foundPackage) {
+        //         unlinkPackage(foundPackage);
+        //     } else {
+        //         logger.error(`Package '${packageToUnlink}' not found`);
+        //     }
+        // } else {
+        const { length } = linkedPackages.keys;
+        linkedPackages.keys.forEach((key) => unlinkPackage(linkedPackages.data[key]));
+        tempData_1.default.clearSetting('linkedPackages');
+        if (length > 1) {
+            logger_1.default.success('All packages were unlinked');
+        }
+        // }
+    }
+    else {
+        logger_1.default.warning('Found no packages to unlink');
+    }
+}
+exports.default = unlink;

package/dist/common/logger/colors.d.ts

@@ -0,0 +1,12 @@
+import chalk from 'chalk';
+export declare const colors: chalk.Chalk & chalk.ChalkFunction & {
+    supportsColor: false | chalk.ColorSupport;
+    Level: chalk.Level;
+    Color: ("black" | "red" | "green" | "yellow" | "blue" | "magenta" | "cyan" | "white" | "gray" | "grey" | "blackBright" | "redBright" | "greenBright" | "yellowBright" | "blueBright" | "magentaBright" | "cyanBright" | "whiteBright") | ("bgBlack" | "bgRed" | "bgGreen" | "bgYellow" | "bgBlue" | "bgMagenta" | "bgCyan" | "bgWhite" | "bgGray" | "bgGrey" | "bgBlackBright" | "bgRedBright" | "bgGreenBright" | "bgYellowBright" | "bgBlueBright" | "bgMagentaBright" | "bgCyanBright" | "bgWhiteBright");
+    ForegroundColor: "black" | "red" | "green" | "yellow" | "blue" | "magenta" | "cyan" | "white" | "gray" | "grey" | "blackBright" | "redBright" | "greenBright" | "yellowBright" | "blueBright" | "magentaBright" | "cyanBright" | "whiteBright";
+    BackgroundColor: "bgBlack" | "bgRed" | "bgGreen" | "bgYellow" | "bgBlue" | "bgMagenta" | "bgCyan" | "bgWhite" | "bgGray" | "bgGrey" | "bgBlackBright" | "bgRedBright" | "bgGreenBright" | "bgYellowBright" | "bgBlueBright" | "bgMagentaBright" | "bgCyanBright" | "bgWhiteBright";
+    Modifiers: "bold" | "reset" | "dim" | "italic" | "underline" | "inverse" | "hidden" | "strikethrough" | "visible";
+    stderr: chalk.Chalk & {
+        supportsColor: false | chalk.ColorSupport;
+    };
+};

package/dist/common/logger/colors.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.colors = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+exports.colors = chalk_1.default;

package/dist/common/logger/index.d.ts

@@ -0,0 +1,47 @@
+import type { ExecException } from 'child_process';
+export interface BaseLogger {
+    message: (msg: string) => void;
+    warning: (msg: string) => void;
+    verbose: (msg: string) => void;
+    success: (msg: string) => void;
+    error: (msg: string) => void;
+}
+export declare class Logger implements BaseLogger {
+    colors: import("chalk").Chalk & import("chalk").ChalkFunction & {
+        supportsColor: false | import("chalk").ColorSupport;
+        Level: import("chalk").Level;
+        Color: ("black" | "red" | "green" | "yellow" | "blue" | "magenta" | "cyan" | "white" | "gray" | "grey" | "blackBright" | "redBright" | "greenBright" | "yellowBright" | "blueBright" | "magentaBright" | "cyanBright" | "whiteBright") | ("bgBlack" | "bgRed" | "bgGreen" | "bgYellow" | "bgBlue" | "bgMagenta" | "bgCyan" | "bgWhite" | "bgGray" | "bgGrey" | "bgBlackBright" | "bgRedBright" | "bgGreenBright" | "bgYellowBright" | "bgBlueBright" | "bgMagentaBright" | "bgCyanBright" | "bgWhiteBright");
+        ForegroundColor: "black" | "red" | "green" | "yellow" | "blue" | "magenta" | "cyan" | "white" | "gray" | "grey" | "blackBright" | "redBright" | "greenBright" | "yellowBright" | "blueBright" | "magentaBright" | "cyanBright" | "whiteBright";
+        BackgroundColor: "bgBlack" | "bgRed" | "bgGreen" | "bgYellow" | "bgBlue" | "bgMagenta" | "bgCyan" | "bgWhite" | "bgGray" | "bgGrey" | "bgBlackBright" | "bgRedBright" | "bgGreenBright" | "bgYellowBright" | "bgBlueBright" | "bgMagentaBright" | "bgCyanBright" | "bgWhiteBright";
+        Modifiers: "bold" | "reset" | "dim" | "italic" | "underline" | "inverse" | "hidden" | "strikethrough" | "visible";
+        stderr: import("chalk").Chalk & {
+            supportsColor: false | import("chalk").ColorSupport;
+        };
+    };
+    private _verbose;
+    private _namespace;
+    private _timestamp;
+    private _color;
+    constructor(namespace?: string, verbose?: boolean);
+    print: (message: string, { verbose, wrap }?: {
+        verbose?: boolean | undefined;
+        wrap?: boolean | undefined;
+    }) => void;
+    printLn: (message: string, { verbose }?: {
+        verbose?: boolean | undefined;
+    }) => void;
+    clearLine: () => void;
+    status: (msg: string) => void;
+    message: (...args: string[]) => void;
+    success: (...args: string[]) => void;
+    warning: (...args: string[]) => void;
+    error: (...args: string[]) => void;
+    logError: (errorMeta: string, error?: Error | ExecException | null) => void;
+    panic: (errorMeta: string, error?: Error) => never;
+    setVerbose: (verbose: boolean) => void;
+    get isVerbose(): boolean;
+    verbose: (...args: string[]) => void;
+    setNamespace: (namespace: string) => void;
+}
+declare const _default: Logger;
+export default _default;