@ts-dev-tools/core 1.12.1 → 1.12.2

package/dist/services/SymlinkDependenciesService.js

@@ -1,143 +1,62 @@
 "use strict";
-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());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SymlinkDependenciesService = void 0;
-var fs_1 = require("fs");
-var path_1 = require("path");
-var PackageJson_1 = require("./PackageJson");
-var PluginService_1 = require("./PluginService");
-var PackageManagerService_1 = require("./PackageManagerService");
-var SymlinkDependenciesService = /** @class */ (function () {
-    function SymlinkDependenciesService() {
+const fs_1 = require("fs");
+const path_1 = require("path");
+const PackageJson_1 = require("./PackageJson");
+const PluginService_1 = require("./PluginService");
+const PackageManagerService_1 = require("./PackageManagerService");
+class SymlinkDependenciesService {
+    static async executeSymlinking(absoluteProjectDir) {
+        console.info(`Symlinking dev dependencies...`);
+        const installedPlugins = PluginService_1.PluginService.getInstalledPlugins(absoluteProjectDir);
+        for (const plugin of installedPlugins) {
+            await SymlinkDependenciesService.symlinkPluginDependencies(absoluteProjectDir, plugin);
+        }
+        console.info(`Symlinking dev dependencies done!`);
     }
-    SymlinkDependenciesService.executeSymlinking = function (absoluteProjectDir) {
-        return __awaiter(this, void 0, void 0, function () {
-            var installedPlugins, _i, installedPlugins_1, plugin;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        console.info("Symlinking dev dependencies...");
-                        installedPlugins = PluginService_1.PluginService.getInstalledPlugins(absoluteProjectDir);
-                        _i = 0, installedPlugins_1 = installedPlugins;
-                        _a.label = 1;
-                    case 1:
-                        if (!(_i < installedPlugins_1.length)) return [3 /*break*/, 4];
-                        plugin = installedPlugins_1[_i];
-                        return [4 /*yield*/, SymlinkDependenciesService.symlinkPluginDependencies(absoluteProjectDir, plugin)];
-                    case 2:
-                        _a.sent();
-                        _a.label = 3;
-                    case 3:
-                        _i++;
-                        return [3 /*break*/, 1];
-                    case 4:
-                        console.info("Symlinking dev dependencies done!");
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    SymlinkDependenciesService.symlinkPluginDependencies = function (absoluteProjectDir, plugin) {
-        return __awaiter(this, void 0, void 0, function () {
-            var pluginDependencies, projectDependencyPath, pluginDependenciesPath, _i, pluginDependencies_1, pluginDependency, pluginDependencyPath, projectPluginDependencyPath;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        pluginDependencies = SymlinkDependenciesService.getPluginDependencies(plugin);
-                        projectDependencyPath = (0, path_1.join)(absoluteProjectDir, SymlinkDependenciesService.DEPENDENCIES_FOLDER);
-                        return [4 /*yield*/, SymlinkDependenciesService.getPluginDependenciesPath(absoluteProjectDir, plugin, pluginDependencies)];
-                    case 1:
-                        pluginDependenciesPath = _a.sent();
-                        if (projectDependencyPath === pluginDependenciesPath) {
-                            console.info("- Skipping symlinking ".concat(plugin.shortname, " dependencies, already in node_modules"));
-                            return [2 /*return*/];
-                        }
-                        for (_i = 0, pluginDependencies_1 = pluginDependencies; _i < pluginDependencies_1.length; _i++) {
-                            pluginDependency = pluginDependencies_1[_i];
-                            pluginDependencyPath = (0, path_1.join)(pluginDependenciesPath, pluginDependency);
-                            if (!(0, fs_1.existsSync)(pluginDependencyPath)) {
-                                continue;
-                            }
-                            projectPluginDependencyPath = (0, path_1.join)(projectDependencyPath, pluginDependency);
-                            if ((0, fs_1.existsSync)(projectPluginDependencyPath)) {
-                                continue;
-                            }
-                            console.info("- Symlinking ".concat(pluginDependency));
-                            SymlinkDependenciesService.symlinkDependency(pluginDependencyPath, projectPluginDependencyPath);
-                        }
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    SymlinkDependenciesService.getPluginDependencies = function (plugin) {
-        var pluginPackageJson = PackageJson_1.PackageJson.fromDirPath(plugin.path);
+    static async symlinkPluginDependencies(absoluteProjectDir, plugin) {
+        const pluginDependencies = SymlinkDependenciesService.getPluginDependencies(plugin);
+        const projectDependencyPath = (0, path_1.join)(absoluteProjectDir, SymlinkDependenciesService.DEPENDENCIES_FOLDER);
+        const pluginDependenciesPath = await SymlinkDependenciesService.getPluginDependenciesPath(absoluteProjectDir, plugin, pluginDependencies);
+        if (projectDependencyPath === pluginDependenciesPath) {
+            console.info(`- Skipping symlinking ${plugin.shortname} dependencies, already in node_modules`);
+            return;
+        }
+        for (const pluginDependency of pluginDependencies) {
+            const pluginDependencyPath = (0, path_1.join)(pluginDependenciesPath, pluginDependency);
+            if (!(0, fs_1.existsSync)(pluginDependencyPath)) {
+                continue;
+            }
+            const projectPluginDependencyPath = (0, path_1.join)(projectDependencyPath, pluginDependency);
+            if ((0, fs_1.existsSync)(projectPluginDependencyPath)) {
+                continue;
+            }
+            console.info(`- Symlinking ${pluginDependency}`);
+            SymlinkDependenciesService.symlinkDependency(pluginDependencyPath, projectPluginDependencyPath);
+        }
+    }
+    static getPluginDependencies(plugin) {
+        const pluginPackageJson = PackageJson_1.PackageJson.fromDirPath(plugin.path);
         return pluginPackageJson.getDependenciesPackageNames();
-    };
-    SymlinkDependenciesService.getPluginDependenciesPath = function (absoluteProjectDir, plugin, pluginDependencies) {
-        return __awaiter(this, void 0, void 0, function () {
-            var pluginDependenciesPath, hasAnyPluginDependency;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        pluginDependenciesPath = (0, path_1.join)(plugin.path, SymlinkDependenciesService.DEPENDENCIES_FOLDER);
-                        if ((0, fs_1.existsSync)(pluginDependenciesPath)) {
-                            hasAnyPluginDependency = pluginDependencies.some(function (pluginDependency) {
-                                return (0, fs_1.existsSync)((0, path_1.join)(pluginDependenciesPath, pluginDependency));
-                            });
-                            if (hasAnyPluginDependency) {
-                                return [2 /*return*/, pluginDependenciesPath];
-                            }
-                        }
-                        return [4 /*yield*/, PackageManagerService_1.PackageManagerService.getNodeModulesPath(absoluteProjectDir)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
-    SymlinkDependenciesService.symlinkDependency = function (pluginDependencyPath, projectPluginDependencyPath) {
-        var pluginDependencyParentFolder = (0, path_1.join)(projectPluginDependencyPath, "..");
+    }
+    static async getPluginDependenciesPath(absoluteProjectDir, plugin, pluginDependencies) {
+        const pluginDependenciesPath = (0, path_1.join)(plugin.path, SymlinkDependenciesService.DEPENDENCIES_FOLDER);
+        if ((0, fs_1.existsSync)(pluginDependenciesPath)) {
+            const hasAnyPluginDependency = pluginDependencies.some((pluginDependency) => (0, fs_1.existsSync)((0, path_1.join)(pluginDependenciesPath, pluginDependency)));
+            if (hasAnyPluginDependency) {
+                return pluginDependenciesPath;
+            }
+        }
+        return await PackageManagerService_1.PackageManagerService.getNodeModulesPath(absoluteProjectDir);
+    }
+    static symlinkDependency(pluginDependencyPath, projectPluginDependencyPath) {
+        const pluginDependencyParentFolder = (0, path_1.join)(projectPluginDependencyPath, "..");
         if (!(0, fs_1.existsSync)(pluginDependencyParentFolder)) {
             (0, fs_1.mkdirSync)(pluginDependencyParentFolder, { recursive: true });
         }
         (0, fs_1.symlinkSync)(pluginDependencyPath, projectPluginDependencyPath);
-    };
-    SymlinkDependenciesService.DEPENDENCIES_FOLDER = "node_modules";
-    return SymlinkDependenciesService;
-}());
+    }
+}
 exports.SymlinkDependenciesService = SymlinkDependenciesService;
+SymlinkDependenciesService.DEPENDENCIES_FOLDER = "node_modules";

package/dist/services/package-manager/AbstractPackageManagerAdapter.js

@@ -1,155 +1,101 @@
 "use strict";
-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());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractPackageManagerAdapter = void 0;
-var child_process_1 = require("child_process");
-var fs_1 = require("fs");
-var AbstractPackageManagerAdapter = /** @class */ (function () {
-    function AbstractPackageManagerAdapter() {
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+class AbstractPackageManagerAdapter {
+    async getVersion(packageManager, dirPath) {
+        const raw = (await this.execCommand([packageManager, "--version"], dirPath, true)).trim();
+        const match = raw.match(/(\d+)\.(\d+)\.(\d+)/);
+        if (!match) {
+            return { raw, major: 0, minor: 0, patch: 0 };
+        }
+        return {
+            raw,
+            major: Number(match[1]),
+            minor: Number(match[2]),
+            patch: Number(match[3]),
+        };
     }
-    AbstractPackageManagerAdapter.prototype.getVersion = function (packageManager, dirPath) {
-        return __awaiter(this, void 0, void 0, function () {
-            var raw, match;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.execCommand([packageManager, "--version"], dirPath, true)];
-                    case 1:
-                        raw = (_a.sent()).trim();
-                        match = raw.match(/(\d+)\.(\d+)\.(\d+)/);
-                        if (!match) {
-                            return [2 /*return*/, { raw: raw, major: 0, minor: 0, patch: 0 }];
-                        }
-                        return [2 /*return*/, {
-                                raw: raw,
-                                major: Number(match[1]),
-                                minor: Number(match[2]),
-                                patch: Number(match[3]),
-                            }];
-                }
+    async execCommand(args, cwd, silent = false) {
+        if (Array.isArray(args) && args.length === 0) {
+            throw new Error("Command args must not be empty");
+        }
+        if (typeof args === "string" && args.trim().length === 0) {
+            throw new Error("Command args must not be empty");
+        }
+        if (cwd && !(0, fs_1.existsSync)(cwd)) {
+            throw new Error(`Directory "${cwd}" does not exist`);
+        }
+        let cmd;
+        let cmdArgs;
+        let useShell = false;
+        if (Array.isArray(args)) {
+            const shellOperators = [">", "|", "&&", "||", ";", "<", ">>", "2>", "&", "$("];
+            const hasShellSyntax = args.some((arg) => {
+                const trimmedArg = arg.trim();
+                return shellOperators.some((op) => trimmedArg.startsWith(op) ||
+                    trimmedArg.endsWith(op) ||
+                    trimmedArg.includes(` ${op} `) ||
+                    trimmedArg.includes(` ${op}`) ||
+                    trimmedArg.includes(`${op} `));
             });
-        });
-    };
-    AbstractPackageManagerAdapter.prototype.execCommand = function (args_1, cwd_1) {
-        return __awaiter(this, arguments, void 0, function (args, cwd, silent) {
-            var cmd, cmdArgs, useShell, shellOperators_1, hasShellSyntax;
-            if (silent === void 0) { silent = false; }
-            return __generator(this, function (_a) {
-                if (Array.isArray(args) && args.length === 0) {
-                    throw new Error("Command args must not be empty");
-                }
-                if (typeof args === "string" && args.trim().length === 0) {
-                    throw new Error("Command args must not be empty");
-                }
-                if (cwd && !(0, fs_1.existsSync)(cwd)) {
-                    throw new Error("Directory \"".concat(cwd, "\" does not exist"));
-                }
-                useShell = false;
-                if (Array.isArray(args)) {
-                    shellOperators_1 = [">", "|", "&&", "||", ";", "<", ">>", "2>", "&", "$("];
-                    hasShellSyntax = args.some(function (arg) {
-                        var trimmedArg = arg.trim();
-                        return shellOperators_1.some(function (op) {
-                            return trimmedArg.startsWith(op) ||
-                                trimmedArg.endsWith(op) ||
-                                trimmedArg.includes(" ".concat(op, " ")) ||
-                                trimmedArg.includes(" ".concat(op)) ||
-                                trimmedArg.includes("".concat(op, " "));
-                        });
-                    });
-                    if (hasShellSyntax) {
-                        cmd = args.join(" ").trim();
-                        cmdArgs = [];
-                        useShell = true;
-                    }
-                    else {
-                        cmd = args[0];
-                        cmdArgs = args.slice(1);
-                    }
-                }
-                else {
-                    cmd = args;
-                    cmdArgs = [];
-                    useShell = true;
+            if (hasShellSyntax) {
+                cmd = args.join(" ").trim();
+                cmdArgs = [];
+                useShell = true;
+            }
+            else {
+                cmd = args[0];
+                cmdArgs = args.slice(1);
+            }
+        }
+        else {
+            cmd = args;
+            cmdArgs = [];
+            useShell = true;
+        }
+        return new Promise((resolve, reject) => {
+            const child = (0, child_process_1.spawn)(cmd, cmdArgs, {
+                stdio: silent ? "pipe" : "inherit",
+                shell: useShell,
+                windowsVerbatimArguments: true,
+                cwd,
+            });
+            let output = "";
+            let error = "";
+            child.on("exit", function (code) {
+                if (code) {
+                    return reject(output.length > 0 ? output : error);
                 }
-                return [2 /*return*/, new Promise(function (resolve, reject) {
-                        var child = (0, child_process_1.spawn)(cmd, cmdArgs, {
-                            stdio: silent ? "pipe" : "inherit",
-                            shell: useShell,
-                            windowsVerbatimArguments: true,
-                            cwd: cwd,
-                        });
-                        var output = "";
-                        var error = "";
-                        child.on("exit", function (code) {
-                            if (code) {
-                                return reject(output.length > 0 ? output : error);
-                            }
-                            resolve(output);
-                        });
-                        if (child.stdout) {
-                            child.stdout.on("data", function (data) {
-                                output += "\n".concat(data);
-                            });
-                        }
-                        if (child.stderr) {
-                            child.stderr.on("data", function (data) {
-                                error += "\n".concat(data);
-                            });
-                        }
-                    })];
+                resolve(output);
             });
+            if (child.stdout) {
+                child.stdout.on("data", (data) => {
+                    output += `\n${data}`;
+                });
+            }
+            if (child.stderr) {
+                child.stderr.on("data", (data) => {
+                    error += `\n${data}`;
+                });
+            }
         });
-    };
-    AbstractPackageManagerAdapter.prototype.parseJsonLines = function (output) {
+    }
+    parseJsonLines(output) {
         return output
             .split(/\r?\n/)
-            .map(function (line) { return line.trim(); })
-            .filter(function (line) { return line.length > 0; })
-            .map(function (line) {
+            .map((line) => line.trim())
+            .filter((line) => line.length > 0)
+            .map((line) => {
             try {
                 return JSON.parse(line);
             }
-            catch (_a) {
+            catch {
                 return undefined;
             }
         })
-            .filter(function (entry) { return entry !== undefined; });
-    };
-    return AbstractPackageManagerAdapter;
-}());
+            .filter((entry) => entry !== undefined);
+    }
+}
 exports.AbstractPackageManagerAdapter = AbstractPackageManagerAdapter;