@ts-dev-tools/core 1.9.14 → 1.10.0

package/dist/services/PackageManagerService.d.ts

@@ -1,12 +1,10 @@
-export declare enum PackageManagerType {
-    yarn = "yarn",
-    npm = "npm"
-}
+import { PackageManagerType } from "./package-manager/PackageManagerType";
+export { PackageManagerType } from "./package-manager/PackageManagerType";
 export declare class PackageManagerService {
     static detectPackageManager(dirPath: string): PackageManagerType;
     static addDevPackage(packageName: string, dirPath: string): Promise<void>;
     static isMonorepo(dirPath: string): Promise<boolean>;
     static isPackageInstalled(packageName: string, dirPath: string): Promise<boolean>;
     static getNodeModulesPath(dirPath: string): Promise<string>;
-    private static execCommand;
+    private static getAdapter;
 }

package/dist/services/PackageManagerService.js

@@ -37,246 +37,61 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PackageManagerService = exports.PackageManagerType = void 0;
-var child_process_1 = require("child_process");
 var fs_1 = require("fs");
 var path_1 = require("path");
-var PackageManagerType;
-(function (PackageManagerType) {
-    PackageManagerType["yarn"] = "yarn";
-    PackageManagerType["npm"] = "npm";
-})(PackageManagerType || (exports.PackageManagerType = PackageManagerType = {}));
+var NpmPackageManagerAdapter_1 = require("./package-manager/NpmPackageManagerAdapter");
+var PackageManagerType_1 = require("./package-manager/PackageManagerType");
+var YarnPackageManagerAdapter_1 = require("./package-manager/YarnPackageManagerAdapter");
+var PackageManagerType_2 = require("./package-manager/PackageManagerType");
+Object.defineProperty(exports, "PackageManagerType", { enumerable: true, get: function () { return PackageManagerType_2.PackageManagerType; } });
 var PackageManagerService = /** @class */ (function () {
     function PackageManagerService() {
     }
     PackageManagerService.detectPackageManager = function (dirPath) {
         if ((0, fs_1.existsSync)((0, path_1.join)(dirPath, "yarn.lock"))) {
-            return PackageManagerType.yarn;
+            return PackageManagerType_1.PackageManagerType.yarn;
         }
-        return PackageManagerType.npm;
+        return PackageManagerType_1.PackageManagerType.npm;
     };
     PackageManagerService.addDevPackage = function (packageName, dirPath) {
         return __awaiter(this, void 0, void 0, function () {
-            var packageManager, isMonorepo, args;
             return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        packageManager = PackageManagerService.detectPackageManager(dirPath);
-                        return [4 /*yield*/, PackageManagerService.isMonorepo(dirPath)];
-                    case 1:
-                        isMonorepo = _a.sent();
-                        args = [packageManager];
-                        switch (packageManager) {
-                            case PackageManagerType.yarn:
-                                args.push("add", "--dev");
-                                if (isMonorepo) {
-                                    args.push("--ignore-workspace-root-check");
-                                }
-                                break;
-                            case PackageManagerType.npm:
-                                args.push("install", "--save-dev");
-                                if (isMonorepo) {
-                                    args.push("--no-workspaces");
-                                }
-                                break;
-                        }
-                        args.push(packageName);
-                        return [4 /*yield*/, PackageManagerService.execCommand(args, dirPath, true)];
-                    case 2:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
+                return [2 /*return*/, PackageManagerService.getAdapter(dirPath).addDevPackage(packageName, dirPath)];
             });
         });
     };
     PackageManagerService.isMonorepo = function (dirPath) {
         return __awaiter(this, void 0, void 0, function () {
-            var packageManager, args, output;
             return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        packageManager = PackageManagerService.detectPackageManager(dirPath);
-                        args = [packageManager];
-                        switch (packageManager) {
-                            case PackageManagerType.yarn:
-                                args.push("workspaces", "info");
-                                break;
-                            case PackageManagerType.npm:
-                                args.push("--workspaces", "list");
-                                break;
-                        }
-                        args.push("> /dev/null 2>&1 && echo true || echo false;");
-                        return [4 /*yield*/, PackageManagerService.execCommand(args, dirPath, true)];
-                    case 1:
-                        output = _a.sent();
-                        return [2 /*return*/, output.trim() === "true"];
-                }
+                return [2 /*return*/, PackageManagerService.getAdapter(dirPath).isMonorepo(dirPath)];
             });
         });
     };
     PackageManagerService.isPackageInstalled = function (packageName, dirPath) {
         return __awaiter(this, void 0, void 0, function () {
-            var packageManager, args, output, error_1, installedPackages;
-            var _a, _b;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        packageManager = PackageManagerService.detectPackageManager(dirPath);
-                        args = [packageManager, "list", "--depth=1", "--json"];
-                        switch (packageManager) {
-                            case PackageManagerType.yarn:
-                                args.push("--pattern=".concat(packageName));
-                                break;
-                            case PackageManagerType.npm:
-                                args.push("--no-progress", "--non-interactive", packageName);
-                                break;
-                        }
-                        _c.label = 1;
-                    case 1:
-                        _c.trys.push([1, 3, , 4]);
-                        return [4 /*yield*/, PackageManagerService.execCommand(args, dirPath, true)];
-                    case 2:
-                        output = _c.sent();
-                        return [3 /*break*/, 4];
-                    case 3:
-                        error_1 = _c.sent();
-                        // npm returns non-zero exit code when package is not found, but still outputs valid JSON
-                        if (typeof error_1 === "string") {
-                            try {
-                                // Try to parse as JSON - if successful, use it as output
-                                JSON.parse(error_1.trim());
-                                output = error_1;
-                            }
-                            catch (_d) {
-                                // If it's not valid JSON, the package is not installed
-                                return [2 /*return*/, false];
-                            }
-                        }
-                        else {
-                            return [2 /*return*/, false];
-                        }
-                        return [3 /*break*/, 4];
-                    case 4:
-                        installedPackages = JSON.parse(output);
-                        switch (packageManager) {
-                            case PackageManagerType.yarn:
-                                return [2 /*return*/, (_b = (_a = installedPackages === null || installedPackages === void 0 ? void 0 : installedPackages.data) === null || _a === void 0 ? void 0 : _a.trees) === null || _b === void 0 ? void 0 : _b.some(function (tree) {
-                                        return tree.name.startsWith(packageName + "@");
-                                    })];
-                            case PackageManagerType.npm:
-                                return [2 /*return*/, installedPackages.dependencies
-                                        ? Object.prototype.hasOwnProperty.call(installedPackages.dependencies, packageName)
-                                        : false];
-                        }
-                        return [2 /*return*/];
-                }
+            return __generator(this, function (_a) {
+                return [2 /*return*/, PackageManagerService.getAdapter(dirPath).isPackageInstalled(packageName, dirPath)];
             });
         });
     };
     PackageManagerService.getNodeModulesPath = function (dirPath) {
         return __awaiter(this, void 0, void 0, function () {
-            var packageManager, nodeModulesPath, _a;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        packageManager = PackageManagerService.detectPackageManager(dirPath);
-                        _a = packageManager;
-                        switch (_a) {
-                            case PackageManagerType.yarn: return [3 /*break*/, 1];
-                            case PackageManagerType.npm: return [3 /*break*/, 2];
-                        }
-                        return [3 /*break*/, 4];
-                    case 1:
-                        nodeModulesPath = (0, path_1.join)(dirPath, "node_modules");
-                        return [3 /*break*/, 4];
-                    case 2: return [4 /*yield*/, PackageManagerService.execCommand([packageManager, "root", "--no-progress", "--non-interactive"], dirPath, true)];
-                    case 3:
-                        nodeModulesPath = (_b.sent()).trim();
-                        return [3 /*break*/, 4];
-                    case 4:
-                        if (nodeModulesPath) {
-                            return [2 /*return*/, nodeModulesPath];
-                        }
-                        throw new Error("Node modules path not found for package manager ".concat(packageManager));
-                }
-            });
-        });
-    };
-    PackageManagerService.execCommand = function (args_1, cwd_1) {
-        return __awaiter(this, arguments, void 0, function (args, cwd, silent) {
-            var cmd, cmdArgs, useShell, SHELL_OPERATORS_1, hasShellSyntax;
-            if (silent === void 0) { silent = false; }
             return __generator(this, function (_a) {
-                // Handle empty args check for both string and array
-                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)) {
-                    SHELL_OPERATORS_1 = [">", "|", "&&", "||", ";", "<", ">>", "2>", "&", "$("];
-                    hasShellSyntax = args.some(function (arg) {
-                        var trimmedArg = arg.trim();
-                        return SHELL_OPERATORS_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) {
-                        // Use shell mode for commands with shell syntax
-                        cmd = args.join(" ").trim();
-                        cmdArgs = [];
-                        useShell = true;
-                    }
-                    else {
-                        // Use array mode for normal commands
-                        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) {
-                                // For commands that output to stdout even on error (like npm list),
-                                // reject with the output so caller can handle it
-                                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);
-                            });
-                        }
-                    })];
+                return [2 /*return*/, PackageManagerService.getAdapter(dirPath).getNodeModulesPath(dirPath)];
             });
         });
     };
+    PackageManagerService.getAdapter = function (dirPath) {
+        var packageManager = PackageManagerService.detectPackageManager(dirPath);
+        switch (packageManager) {
+            case PackageManagerType_1.PackageManagerType.yarn:
+                return new YarnPackageManagerAdapter_1.YarnPackageManagerAdapter();
+            case PackageManagerType_1.PackageManagerType.npm:
+                return new NpmPackageManagerAdapter_1.NpmPackageManagerAdapter();
+            default:
+                throw new Error("Unsupported package manager: ".concat(packageManager));
+        }
+    };
     return PackageManagerService;
 }());
 exports.PackageManagerService = PackageManagerService;

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

@@ -0,0 +1,16 @@
+import { PackageManagerType } from "./PackageManagerType";
+import type { PackageManagerAdapter } from "./PackageManagerAdapter";
+export declare abstract class AbstractPackageManagerAdapter implements PackageManagerAdapter {
+    abstract addDevPackage(packageName: string, dirPath: string): Promise<void>;
+    abstract isMonorepo(dirPath: string): Promise<boolean>;
+    abstract isPackageInstalled(packageName: string, dirPath: string): Promise<boolean>;
+    abstract getNodeModulesPath(dirPath: string): Promise<string>;
+    protected getVersion(packageManager: PackageManagerType, dirPath?: string): Promise<{
+        raw: string;
+        major: number;
+        minor: number;
+        patch: number;
+    }>;
+    protected execCommand(args: string | string[], cwd?: string, silent?: boolean): Promise<string>;
+    protected parseJsonLines(output: string): unknown[];
+}

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,13 @@
+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 yarnWorkspacesOutputHasEntries;
+    private parseMaybeJsonString;
+    private hasWorkspaceMap;
+    private parseJsonObjectFromOutput;
+    private isWorkspaceListEntry;
+    private yarnListOutputHasPackage;
+}

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

@@ -0,0 +1,269 @@
+"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.YarnPackageManagerAdapter = void 0;
+var path_1 = require("path");
+var AbstractPackageManagerAdapter_1 = require("./AbstractPackageManagerAdapter");
+var PackageManagerType_1 = require("./PackageManagerType");
+var YarnPackageManagerAdapter = /** @class */ (function (_super) {
+    __extends(YarnPackageManagerAdapter, _super);
+    function YarnPackageManagerAdapter() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    YarnPackageManagerAdapter.prototype.addDevPackage = function (packageName, dirPath) {
+        return __awaiter(this, void 0, void 0, function () {
+            var isMonorepo, major, args, error_1, retryArgs;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.isMonorepo(dirPath)];
+                    case 1:
+                        isMonorepo = _a.sent();
+                        return [4 /*yield*/, this.getVersion(PackageManagerType_1.PackageManagerType.yarn, dirPath)];
+                    case 2:
+                        major = (_a.sent()).major;
+                        args = ["yarn", "add", "--dev"];
+                        if (isMonorepo) {
+                            args.push(major >= 2 ? "-W" : "--ignore-workspace-root-check");
+                        }
+                        args.push(packageName);
+                        _a.label = 3;
+                    case 3:
+                        _a.trys.push([3, 5, , 8]);
+                        return [4 /*yield*/, this.execCommand(args, dirPath, true)];
+                    case 4:
+                        _a.sent();
+                        return [3 /*break*/, 8];
+                    case 5:
+                        error_1 = _a.sent();
+                        if (!(isMonorepo && typeof error_1 === "string" && error_1.includes("Unsupported option name"))) return [3 /*break*/, 7];
+                        retryArgs = args
+                            .filter(function (arg) { return arg !== "--ignore-workspace-root-check" && arg !== "-W"; })
+                            .concat(major >= 2 ? "--ignore-workspace-root-check" : "-W");
+                        return [4 /*yield*/, this.execCommand(retryArgs, dirPath, true)];
+                    case 6:
+                        _a.sent();
+                        return [2 /*return*/];
+                    case 7: throw error_1;
+                    case 8: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    YarnPackageManagerAdapter.prototype.isMonorepo = function (dirPath) {
+        return __awaiter(this, void 0, void 0, function () {
+            var major, primary, fallback, yarnCommands, _i, yarnCommands_1, args, output, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.getVersion(PackageManagerType_1.PackageManagerType.yarn, dirPath)];
+                    case 1:
+                        major = (_b.sent()).major;
+                        primary = major >= 2 ? "list" : "info";
+                        fallback = primary === "list" ? "info" : "list";
+                        yarnCommands = [
+                            ["yarn", "workspaces", primary, "--json"],
+                            ["yarn", "workspaces", fallback, "--json"],
+                        ];
+                        _i = 0, yarnCommands_1 = yarnCommands;
+                        _b.label = 2;
+                    case 2:
+                        if (!(_i < yarnCommands_1.length)) return [3 /*break*/, 7];
+                        args = yarnCommands_1[_i];
+                        _b.label = 3;
+                    case 3:
+                        _b.trys.push([3, 5, , 6]);
+                        return [4 /*yield*/, this.execCommand(args, dirPath, true)];
+                    case 4:
+                        output = _b.sent();
+                        if (this.yarnWorkspacesOutputHasEntries(output)) {
+                            return [2 /*return*/, true];
+                        }
+                        return [3 /*break*/, 6];
+                    case 5:
+                        _a = _b.sent();
+                        return [3 /*break*/, 6];
+                    case 6:
+                        _i++;
+                        return [3 /*break*/, 2];
+                    case 7: return [2 /*return*/, false];
+                }
+            });
+        });
+    };
+    YarnPackageManagerAdapter.prototype.isPackageInstalled = function (packageName, dirPath) {
+        return __awaiter(this, void 0, void 0, function () {
+            var output, _a, output, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        _c.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.execCommand(["yarn", "list", "--depth=1", "--json", "--pattern", packageName], dirPath, true)];
+                    case 1:
+                        output = _c.sent();
+                        if (this.yarnListOutputHasPackage(output, packageName)) {
+                            return [2 /*return*/, true];
+                        }
+                        return [3 /*break*/, 3];
+                    case 2:
+                        _a = _c.sent();
+                        return [3 /*break*/, 3];
+                    case 3:
+                        _c.trys.push([3, 5, , 6]);
+                        return [4 /*yield*/, this.execCommand(["yarn", "why", "--json", packageName], dirPath, true)];
+                    case 4:
+                        output = _c.sent();
+                        return [2 /*return*/, this.yarnListOutputHasPackage(output, packageName)];
+                    case 5:
+                        _b = _c.sent();
+                        return [2 /*return*/, false];
+                    case 6: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    YarnPackageManagerAdapter.prototype.getNodeModulesPath = function (dirPath) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, (0, path_1.join)(dirPath, "node_modules")];
+            });
+        });
+    };
+    YarnPackageManagerAdapter.prototype.yarnWorkspacesOutputHasEntries = function (output) {
+        var _a;
+        var entries = this.parseJsonLines(output);
+        var workspaceListCount = 0;
+        for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {
+            var entry = entries_1[_i];
+            if (!entry || typeof entry !== "object") {
+                continue;
+            }
+            var data = (_a = entry.data) !== null && _a !== void 0 ? _a : entry;
+            var parsedData = this.parseMaybeJsonString(data);
+            if (parsedData && typeof parsedData === "object") {
+                if (this.hasWorkspaceMap(parsedData)) {
+                    return true;
+                }
+                if (this.isWorkspaceListEntry(parsedData)) {
+                    workspaceListCount += 1;
+                }
+            }
+        }
+        if (workspaceListCount > 0) {
+            return true;
+        }
+        var parsedOutput = this.parseJsonObjectFromOutput(output);
+        if (parsedOutput && typeof parsedOutput === "object") {
+            return Object.keys(parsedOutput).length > 0;
+        }
+        return false;
+    };
+    YarnPackageManagerAdapter.prototype.parseMaybeJsonString = function (value) {
+        if (typeof value !== "string") {
+            return value;
+        }
+        try {
+            return JSON.parse(value);
+        }
+        catch (_a) {
+            return undefined;
+        }
+    };
+    YarnPackageManagerAdapter.prototype.hasWorkspaceMap = function (value) {
+        if (!value || typeof value !== "object") {
+            return false;
+        }
+        var workspaces = value.workspaces;
+        return !!workspaces && Object.keys(workspaces).length > 0;
+    };
+    YarnPackageManagerAdapter.prototype.parseJsonObjectFromOutput = function (output) {
+        var start = output.indexOf("{");
+        var end = output.lastIndexOf("}");
+        if (start < 0 || end <= start) {
+            return undefined;
+        }
+        var slice = output.slice(start, end + 1).trim();
+        try {
+            return JSON.parse(slice);
+        }
+        catch (_a) {
+            return undefined;
+        }
+    };
+    YarnPackageManagerAdapter.prototype.isWorkspaceListEntry = function (value) {
+        if (!value || typeof value !== "object") {
+            return false;
+        }
+        var entry = value;
+        return typeof entry.name === "string" && typeof entry.location === "string" && entry.location !== ".";
+    };
+    YarnPackageManagerAdapter.prototype.yarnListOutputHasPackage = function (output, packageName) {
+        var _a;
+        var entries = this.parseJsonLines(output);
+        for (var _i = 0, entries_2 = entries; _i < entries_2.length; _i++) {
+            var entry = entries_2[_i];
+            if (!entry || typeof entry !== "object") {
+                continue;
+            }
+            var data = entry.data;
+            var trees = (_a = data === null || data === void 0 ? void 0 : data.trees) !== null && _a !== void 0 ? _a : entry.trees;
+            if (!trees) {
+                continue;
+            }
+            if (trees.some(function (tree) { return tree.name.startsWith(packageName + "@"); })) {
+                return true;
+            }
+        }
+        return false;
+    };
+    return YarnPackageManagerAdapter;
+}(AbstractPackageManagerAdapter_1.AbstractPackageManagerAdapter));
+exports.YarnPackageManagerAdapter = YarnPackageManagerAdapter;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ts-dev-tools/core",
-  "version": "1.9.14",
+  "version": "1.10.0",
   "description": "TS dev tools Core",
   "keywords": [
     "linter",
@@ -93,5 +93,5 @@
       "github-actions"
     ]
   },
-  "gitHead": "094bbfc6b7dc24b7efab8dddad55598ff7a36ae9"
+  "gitHead": "e45076a10f72cd59f296dc30abdbe692aa8684b1"
 }