@ts-dev-tools/core 1.9.14 → 1.11.0

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

@@ -0,0 +1,321 @@
+"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, lastOutput, hasRecognizedOutput, hasSuccessfulCommand, _i, yarnCommands_1, args, output, analysis, _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"],
+                        ];
+                        hasRecognizedOutput = false;
+                        hasSuccessfulCommand = false;
+                        _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();
+                        hasSuccessfulCommand = true;
+                        lastOutput = output;
+                        analysis = this.analyzeYarnWorkspacesOutput(output);
+                        if (analysis.hasEntries) {
+                            return [2 /*return*/, true];
+                        }
+                        if (analysis.hasRecognizedData) {
+                            hasRecognizedOutput = true;
+                        }
+                        return [3 /*break*/, 6];
+                    case 5:
+                        _a = _b.sent();
+                        return [3 /*break*/, 6];
+                    case 6:
+                        _i++;
+                        return [3 /*break*/, 2];
+                    case 7:
+                        if (hasSuccessfulCommand && !hasRecognizedOutput) {
+                            throw new Error("Unexpected output from \"yarn workspaces\": ".concat(lastOutput !== null && lastOutput !== void 0 ? lastOutput : "<empty>"));
+                        }
+                        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.analyzeYarnWorkspacesOutput = function (output) {
+        var _a;
+        var entries = this.parseJsonLines(output);
+        if (entries.length === 0) {
+            var jsonBlock = this.extractJsonBlock(output);
+            if (jsonBlock && typeof jsonBlock === "object") {
+                entries = [jsonBlock];
+            }
+        }
+        if (entries.length === 0) {
+            return { hasEntries: false, hasRecognizedData: false };
+        }
+        var workspaceListCount = 0;
+        var hasRecognizedData = false;
+        for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {
+            var entry = entries_1[_i];
+            if (!entry || typeof entry !== "object") {
+                continue;
+            }
+            var type = entry.type;
+            if (type === "error" || type === "warning") {
+                continue;
+            }
+            var data = (_a = entry.data) !== null && _a !== void 0 ? _a : entry;
+            var parsedData = this.parseMaybeJsonString(data);
+            if (parsedData && typeof parsedData === "object") {
+                hasRecognizedData = true;
+                if (this.hasWorkspaceMap(parsedData)) {
+                    return { hasEntries: true, hasRecognizedData: hasRecognizedData };
+                }
+                if (this.isWorkspaceInfoMap(parsedData)) {
+                    return { hasEntries: true, hasRecognizedData: hasRecognizedData };
+                }
+                if (this.isWorkspaceListEntry(parsedData)) {
+                    workspaceListCount += 1;
+                }
+            }
+        }
+        if (workspaceListCount > 0) {
+            return { hasEntries: true, hasRecognizedData: hasRecognizedData };
+        }
+        return { hasEntries: false, hasRecognizedData: hasRecognizedData };
+    };
+    YarnPackageManagerAdapter.prototype.parseMaybeJsonString = function (value) {
+        if (typeof value !== "string") {
+            return value;
+        }
+        try {
+            return JSON.parse(value);
+        }
+        catch (_a) {
+            return undefined;
+        }
+    };
+    YarnPackageManagerAdapter.prototype.extractJsonBlock = function (output) {
+        var start = output.indexOf("{");
+        var end = output.lastIndexOf("}");
+        if (start === -1 || end === -1 || end <= start) {
+            return undefined;
+        }
+        var candidate = output.slice(start, end + 1).trim();
+        if (candidate.length === 0) {
+            return undefined;
+        }
+        try {
+            return JSON.parse(candidate);
+        }
+        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.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.isWorkspaceInfoMap = function (value) {
+        if (!value || typeof value !== "object") {
+            return false;
+        }
+        var entries = Object.values(value);
+        if (entries.length === 0) {
+            return false;
+        }
+        return entries.some(function (entry) {
+            if (!entry || typeof entry !== "object") {
+                return false;
+            }
+            var location = entry.location;
+            return typeof location === "string" && location.length > 0 && 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) {
+                var children = entry.children;
+                if (children) {
+                    var childKeys = Object.keys(children);
+                    if (childKeys.some(function (key) { return key.startsWith(packageName + "@"); })) {
+                        return true;
+                    }
+                }
+                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.11.0",
   "description": "TS dev tools Core",
   "keywords": [
     "linter",
@@ -93,5 +93,5 @@
       "github-actions"
     ]
   },
-  "gitHead": "094bbfc6b7dc24b7efab8dddad55598ff7a36ae9"
+  "gitHead": "9181a105b83523716cb8579991fd77f21a0e9ef6"
 }