@ts-dev-tools/core 1.9.14 → 1.11.0

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

@@ -0,0 +1,155 @@
+"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() {
+    }
+    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]),
+                            }];
+                }
+            });
+        });
+    };
+    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;
+                }
+                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);
+                            });
+                        }
+                    })];
+            });
+        });
+    };
+    AbstractPackageManagerAdapter.prototype.parseJsonLines = function (output) {
+        return output
+            .split(/\r?\n/)
+            .map(function (line) { return line.trim(); })
+            .filter(function (line) { return line.length > 0; })
+            .map(function (line) {
+            try {
+                return JSON.parse(line);
+            }
+            catch (_a) {
+                return undefined;
+            }
+        })
+            .filter(function (entry) { return entry !== undefined; });
+    };
+    return AbstractPackageManagerAdapter;
+}());
+exports.AbstractPackageManagerAdapter = AbstractPackageManagerAdapter;

package/dist/services/package-manager/NpmPackageManagerAdapter.d.ts

@@ -0,0 +1,7 @@
+import { AbstractPackageManagerAdapter } from "./AbstractPackageManagerAdapter";
+export declare class NpmPackageManagerAdapter extends AbstractPackageManagerAdapter {
+    addDevPackage(packageName: string, dirPath: string): Promise<void>;
+    isMonorepo(dirPath: string): Promise<boolean>;
+    isPackageInstalled(packageName: string, dirPath: string): Promise<boolean>;
+    getNodeModulesPath(dirPath: string): Promise<string>;
+}

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

@@ -0,0 +1,165 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+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.NpmPackageManagerAdapter = void 0;
+var AbstractPackageManagerAdapter_1 = require("./AbstractPackageManagerAdapter");
+var NpmPackageManagerAdapter = /** @class */ (function (_super) {
+    __extends(NpmPackageManagerAdapter, _super);
+    function NpmPackageManagerAdapter() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    NpmPackageManagerAdapter.prototype.addDevPackage = function (packageName, dirPath) {
+        return __awaiter(this, void 0, void 0, function () {
+            var isMonorepo, args;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.isMonorepo(dirPath)];
+                    case 1:
+                        isMonorepo = _a.sent();
+                        args = ["npm", "install", "--save-dev"];
+                        if (isMonorepo) {
+                            args.push("--no-workspaces");
+                        }
+                        args.push(packageName);
+                        return [4 /*yield*/, this.execCommand(args, dirPath, true)];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    NpmPackageManagerAdapter.prototype.isMonorepo = function (dirPath) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.execCommand(["npm", "--workspaces", "list", "--json"], dirPath, true)];
+                    case 1:
+                        _b.sent();
+                        return [2 /*return*/, true];
+                    case 2:
+                        _a = _b.sent();
+                        return [2 /*return*/, false];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    NpmPackageManagerAdapter.prototype.isPackageInstalled = function (packageName, dirPath) {
+        return __awaiter(this, void 0, void 0, function () {
+            var args, output, error_1, installedPackages;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        args = [
+                            "npm",
+                            "list",
+                            "--depth=1",
+                            "--json",
+                            "--no-progress",
+                            "--non-interactive",
+                            packageName,
+                        ];
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.execCommand(args, dirPath, true)];
+                    case 2:
+                        output = _a.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        error_1 = _a.sent();
+                        if (typeof error_1 === "string") {
+                            try {
+                                JSON.parse(error_1.trim());
+                                output = error_1;
+                            }
+                            catch (_b) {
+                                return [2 /*return*/, false];
+                            }
+                        }
+                        else {
+                            return [2 /*return*/, false];
+                        }
+                        return [3 /*break*/, 4];
+                    case 4:
+                        installedPackages = JSON.parse(output);
+                        return [2 /*return*/, installedPackages.dependencies
+                                ? Object.prototype.hasOwnProperty.call(installedPackages.dependencies, packageName)
+                                : false];
+                }
+            });
+        });
+    };
+    NpmPackageManagerAdapter.prototype.getNodeModulesPath = function (dirPath) {
+        return __awaiter(this, void 0, void 0, function () {
+            var nodeModulesPath;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.execCommand(["npm", "root", "--no-progress", "--non-interactive"], dirPath, true)];
+                    case 1:
+                        nodeModulesPath = (_a.sent()).trim();
+                        if (nodeModulesPath) {
+                            return [2 /*return*/, nodeModulesPath];
+                        }
+                        throw new Error("Node modules path not found for package manager npm");
+                }
+            });
+        });
+    };
+    return NpmPackageManagerAdapter;
+}(AbstractPackageManagerAdapter_1.AbstractPackageManagerAdapter));
+exports.NpmPackageManagerAdapter = NpmPackageManagerAdapter;

package/dist/services/package-manager/PackageManagerAdapter.d.ts

@@ -0,0 +1,6 @@
+export interface PackageManagerAdapter {
+    addDevPackage(packageName: string, dirPath: string): Promise<void>;
+    isMonorepo(dirPath: string): Promise<boolean>;
+    isPackageInstalled(packageName: string, dirPath: string): Promise<boolean>;
+    getNodeModulesPath(dirPath: string): Promise<string>;
+}

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

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

package/dist/services/package-manager/PackageManagerType.d.ts

@@ -0,0 +1,4 @@
+export declare enum PackageManagerType {
+    yarn = "yarn",
+    npm = "npm"
+}

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

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PackageManagerType = void 0;
+var PackageManagerType;
+(function (PackageManagerType) {
+    PackageManagerType["yarn"] = "yarn";
+    PackageManagerType["npm"] = "npm";
+})(PackageManagerType || (exports.PackageManagerType = PackageManagerType = {}));

package/dist/services/package-manager/YarnPackageManagerAdapter.d.ts

@@ -0,0 +1,14 @@
+import { AbstractPackageManagerAdapter } from "./AbstractPackageManagerAdapter";
+export declare class YarnPackageManagerAdapter extends AbstractPackageManagerAdapter {
+    addDevPackage(packageName: string, dirPath: string): Promise<void>;
+    isMonorepo(dirPath: string): Promise<boolean>;
+    isPackageInstalled(packageName: string, dirPath: string): Promise<boolean>;
+    getNodeModulesPath(dirPath: string): Promise<string>;
+    private analyzeYarnWorkspacesOutput;
+    private parseMaybeJsonString;
+    private extractJsonBlock;
+    private hasWorkspaceMap;
+    private isWorkspaceListEntry;
+    private isWorkspaceInfoMap;
+    private yarnListOutputHasPackage;
+}