@ts-dev-tools/core 1.8.9 → 1.9.1

package/README.md

@@ -68,7 +68,7 @@
 ### _1_. Install
 
 ```sh
-npm install --include=dev @ts-dev-tools/core
+npm install --save-dev @ts-dev-tools/core
 ```
 
 Or
@@ -77,10 +77,16 @@ Or
 yarn add --dev @ts-dev-tools/core
 ```
 
+Or
+
+```sh
+pnpm add -D @ts-dev-tools/core
+```
+
 ### _2_. Enable ts-dev-tools
 
 ```sh
-npx ts-dev-tools install
+npm exec ts-dev-tools install
 ```
 
 Or
@@ -89,4 +95,10 @@ Or
 yarn ts-dev-tools install
 ```
 
-⚠️ If your package is not private and you're publishing it on a registry like npmjs.com, you need to disable postinstall script using [pinst](https://github.com/typicode/pinst). Otherwise, postinstall will run when someone installs your package and result in an error.
+Or
+
+```sh
+pnpm ts-dev-tools install
+```
+
+⚠️ If your package is using yarn, is not private and you're publishing it on a registry like npmjs.com, you need to disable postinstall script using [pinst](https://github.com/typicode/pinst). Otherwise, postinstall will run when someone installs your package and result in an error.

package/dist/install/command.js

@@ -68,7 +68,9 @@ function install(_a) {
                     return [4 /*yield*/, MigrationsService_1.MigrationsService.executeMigrations(absoluteProjectDir, currentVersion)];
                 case 1:
                     _d.sent();
-                    SymlinkDependenciesService_1.SymlinkDependenciesService.executeSymlinking(absoluteProjectDir);
+                    return [4 /*yield*/, SymlinkDependenciesService_1.SymlinkDependenciesService.executeSymlinking(absoluteProjectDir)];
+                case 2:
+                    _d.sent();
                     DuplicateDependenciesService_1.DuplicateDependenciesService.executeDeduplication(absoluteProjectDir);
                     console.info("Installation done!");
                     return [2 /*return*/];

package/dist/services/DuplicateDependenciesService.js

@@ -41,12 +41,17 @@ var DuplicateDependenciesService = /** @class */ (function () {
         }
     };
     DuplicateDependenciesService.printDuplicatedDependencies = function (duplicateDependencies) {
+        var hasDuplicates = false;
         duplicateDependencies.forEach(function (pluginDuplicateDependencies, plugin) {
             if (pluginDuplicateDependencies.size) {
                 var pluginDuplicateDependenciesValue = Array.from(pluginDuplicateDependencies);
+                hasDuplicates = true;
                 console.info("Some dev dependencies are unnecessarily installed as their are already required by \"".concat(plugin, "\":\n  - ").concat(pluginDuplicateDependenciesValue.join("\n  - "), "\n"));
             }
         });
+        if (!hasDuplicates) {
+            console.info("No duplicate dev dependencies found.");
+        }
     };
     return DuplicateDependenciesService;
 }());

package/dist/services/PackageManagerService.d.ts

@@ -7,5 +7,6 @@ export declare class PackageManagerService {
     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;
 }

package/dist/services/PackageManagerService.js

@@ -149,6 +149,35 @@ var PackageManagerService = /** @class */ (function () {
             });
         });
     };
+    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;

package/dist/services/SymlinkDependenciesService.d.ts

@@ -1,7 +1,8 @@
 export declare class SymlinkDependenciesService {
     static DEPENDENCIES_FOLDER: string;
-    static executeSymlinking(absoluteProjectDir: string): void;
+    static executeSymlinking(absoluteProjectDir: string): Promise<void>;
     private static symlinkPluginDependencies;
     private static getPluginDependencies;
+    private static getPluginDependenciesPath;
     private static symlinkDependency;
 }

package/dist/services/SymlinkDependenciesService.js

@@ -1,47 +1,130 @@
 "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() {
     }
     SymlinkDependenciesService.executeSymlinking = function (absoluteProjectDir) {
-        console.info("Symlinking dev dependencies...");
-        var installedPlugins = PluginService_1.PluginService.getInstalledPlugins(absoluteProjectDir);
-        for (var _i = 0, installedPlugins_1 = installedPlugins; _i < installedPlugins_1.length; _i++) {
-            var plugin = installedPlugins_1[_i];
-            SymlinkDependenciesService.symlinkPluginDependencies(absoluteProjectDir, plugin);
-        }
-        console.info("Symlinking dev dependencies done!");
+        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) {
-        var pluginDependencies = SymlinkDependenciesService.getPluginDependencies(plugin);
-        var pluginDependenciesPath = (0, path_1.join)(plugin.path, SymlinkDependenciesService.DEPENDENCIES_FOLDER);
-        if (!(0, fs_1.existsSync)(pluginDependenciesPath)) {
-            throw new Error("Plugin dependencies folder not found: ".concat(pluginDependenciesPath));
-        }
-        for (var _i = 0, pluginDependencies_1 = pluginDependencies; _i < pluginDependencies_1.length; _i++) {
-            var pluginDependency = pluginDependencies_1[_i];
-            var pluginDependencyPath = (0, path_1.join)(pluginDependenciesPath, pluginDependency);
-            if (!(0, fs_1.existsSync)(pluginDependencyPath)) {
-                continue;
-            }
-            var projectDependencyPath = (0, path_1.join)(absoluteProjectDir, SymlinkDependenciesService.DEPENDENCIES_FOLDER);
-            var projectPluginDependencyPath = (0, path_1.join)(projectDependencyPath, pluginDependency);
-            if ((0, fs_1.existsSync)(projectPluginDependencyPath)) {
-                continue;
-            }
-            console.info("- Symlinking ".concat(pluginDependency));
-            SymlinkDependenciesService.symlinkDependency(pluginDependencyPath, projectPluginDependencyPath);
-        }
+        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)];
+                    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);
         return pluginPackageJson.getDependenciesPackageNames();
     };
+    SymlinkDependenciesService.getPluginDependenciesPath = function (absoluteProjectDir, plugin) {
+        return __awaiter(this, void 0, void 0, function () {
+            var pluginDependenciesPath;
+            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)) {
+                            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, "..");
         if (!(0, fs_1.existsSync)(pluginDependencyParentFolder)) {

package/dist/tests/console.d.ts

@@ -1,3 +1,4 @@
 export declare function mockConsoleInfo(): void;
 export declare function resetMockedConsoleInfo(): void;
 export declare function getConsoleInfoContent(): string;
+export declare function stripAnsi(input: string): string;

package/dist/tests/console.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.mockConsoleInfo = mockConsoleInfo;
 exports.resetMockedConsoleInfo = resetMockedConsoleInfo;
 exports.getConsoleInfoContent = getConsoleInfoContent;
+exports.stripAnsi = stripAnsi;
 var info = console.info;
 function mockConsoleInfo() {
     console.info = jest.fn();
@@ -15,3 +16,12 @@ function getConsoleInfoContent() {
     var calls = (_a = console.info) === null || _a === void 0 ? void 0 : _a.mock.calls;
     return calls.flat().join("\n");
 }
+function stripAnsi(input) {
+    // Valid string terminator sequences are BEL, ESC\, and 0x9c
+    var ST = "(?:\\u0007|\\u001B\\u005C|\\u009C)";
+    var pattern = [
+        "[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?".concat(ST, ")"),
+        "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]))",
+    ].join("|");
+    return input.replace(new RegExp(pattern, "g"), "");
+}

package/dist/tests/file-system.d.ts

@@ -1,2 +1,3 @@
-export declare function deleteFolderRecursive(path: string): void;
-export declare function copyFolderSync(from: string, to: string): void;
+export declare function recreateFolderRecursive(path: string): Promise<void>;
+export declare function deleteFolderRecursive(path: string): Promise<void>;
+export declare function copyFolder(src: string, dest: string): Promise<void>;

package/dist/tests/file-system.js

@@ -1,35 +1,100 @@
 "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.recreateFolderRecursive = recreateFolderRecursive;
 exports.deleteFolderRecursive = deleteFolderRecursive;
-exports.copyFolderSync = copyFolderSync;
+exports.copyFolder = copyFolder;
 var fs_1 = require("fs");
-var path_1 = require("path");
-function deleteFolderRecursive(path) {
-    if ((0, fs_1.existsSync)(path)) {
-        (0, fs_1.readdirSync)(path).forEach(function (file) {
-            var curPath = (0, path_1.join)(path, file);
-            if ((0, fs_1.lstatSync)(curPath).isDirectory()) {
-                // recurse
-                deleteFolderRecursive(curPath);
+var cli_1 = require("./cli");
+function recreateFolderRecursive(path) {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!(0, fs_1.existsSync)(path)) return [3 /*break*/, 2];
+                    return [4 /*yield*/, deleteFolderRecursive(path)];
+                case 1:
+                    _a.sent();
+                    _a.label = 2;
+                case 2:
+                    (0, fs_1.mkdirSync)(path, { recursive: true });
+                    return [2 /*return*/];
             }
-            else {
-                // delete file
-                (0, fs_1.unlinkSync)(curPath);
+        });
+    });
+}
+function deleteFolderRecursive(path) {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!(0, fs_1.existsSync)(path)) return [3 /*break*/, 2];
+                    return [4 /*yield*/, (0, cli_1.safeExec)(path, "rm -rf ".concat(path))];
+                case 1:
+                    _a.sent();
+                    _a.label = 2;
+                case 2: return [2 /*return*/];
             }
         });
-        (0, fs_1.rmdirSync)(path);
-    }
+    });
 }
-function copyFolderSync(from, to) {
-    if (!(0, fs_1.existsSync)(to)) {
-        (0, fs_1.mkdirSync)(to);
-    }
-    (0, fs_1.readdirSync)(from).forEach(function (element) {
-        if ((0, fs_1.lstatSync)((0, path_1.join)(from, element)).isFile()) {
-            (0, fs_1.copyFileSync)((0, path_1.join)(from, element), (0, path_1.join)(to, element));
-        }
-        else {
-            copyFolderSync((0, path_1.join)(from, element), (0, path_1.join)(to, element));
-        }
+function copyFolder(src, dest) {
+    return __awaiter(this, void 0, void 0, function () {
+        var command;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, recreateFolderRecursive(dest)];
+                case 1:
+                    _a.sent();
+                    command = [
+                        "rsync -a",
+                        "--include='/.git/'",
+                        "--include='/.git/hooks/'",
+                        "--include='/.git/hooks/**'",
+                        "--exclude='/.git/**'",
+                        "\"".concat(src, "/\""),
+                        "\"".concat(dest, "/\""),
+                    ].join(" ");
+                    return [4 /*yield*/, (0, cli_1.safeExec)(src, command)];
+                case 2:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
     });
 }

package/dist/tests/test-cache.d.ts

@@ -0,0 +1,2 @@
+export declare function getTestCacheDirPath(packageName: string, cacheName: string): string;
+export declare function testCacheDirExists(packageName: string, cacheName: string): boolean;

package/dist/tests/test-cache.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTestCacheDirPath = getTestCacheDirPath;
+exports.testCacheDirExists = testCacheDirExists;
+var fs_1 = require("fs");
+var path_1 = require("path");
+var rootDirPath = (0, path_1.resolve)(__dirname, "../../../..");
+function getTestCacheDirPath(packageName, cacheName) {
+    if (!packageName) {
+        throw new Error("Package name must be provided");
+    }
+    if (!cacheName) {
+        throw new Error("Cache name must be provided");
+    }
+    var cacheDirPath = (0, path_1.resolve)((0, path_1.join)(rootDirPath, "node_modules/.cache/ts-dev-tools", packageName), cacheName.toLowerCase().replace(/[^a-z0-9]/g, "-"));
+    return cacheDirPath;
+}
+function testCacheDirExists(packageName, cacheName) {
+    var cacheDirPath = getTestCacheDirPath(packageName, cacheName);
+    return (0, fs_1.existsSync)(cacheDirPath);
+}

package/dist/tests/test-packages.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Create a full file structure for testing ts-dev-tools packages installation
+ * This function is not using cache to prevents drift between current code and test code
+ * @param projectDir path where to prepare packages
+ * @returns packages directory path
+ */
+export declare function createTestPackagesDir(filename: string): Promise<string>;

package/dist/tests/test-packages.js

@@ -0,0 +1,107 @@
+"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.createTestPackagesDir = createTestPackagesDir;
+var fs_1 = require("fs");
+var path_1 = require("path");
+var PackageJson_1 = require("../services/PackageJson");
+var PluginService_1 = require("../services/PluginService");
+var test_project_1 = require("./test-project");
+var file_system_1 = require("./file-system");
+var cli_1 = require("./cli");
+function createTestPackagesProject(projectDir) {
+    return __awaiter(this, void 0, void 0, function () {
+        var originalPackagesPath, projectDirPackages, projectDirPackagesFiles, _i, projectDirPackagesFiles_1, projectDirPackagesFile, packagePath, packageJson, content, _a, _b, packageName, pluginShortName, dependencyPath;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    originalPackagesPath = (0, path_1.resolve)(__dirname, "../../..");
+                    projectDirPackages = (0, path_1.resolve)(projectDir, "packages");
+                    return [4 /*yield*/, (0, file_system_1.copyFolder)(originalPackagesPath, projectDirPackages)];
+                case 1:
+                    _c.sent();
+                    projectDirPackagesFiles = (0, fs_1.readdirSync)(projectDirPackages);
+                    _i = 0, projectDirPackagesFiles_1 = projectDirPackagesFiles;
+                    _c.label = 2;
+                case 2:
+                    if (!(_i < projectDirPackagesFiles_1.length)) return [3 /*break*/, 5];
+                    projectDirPackagesFile = projectDirPackagesFiles_1[_i];
+                    packagePath = (0, path_1.resolve)(projectDirPackages, projectDirPackagesFile);
+                    if (!(0, fs_1.lstatSync)(packagePath).isDirectory()) {
+                        return [3 /*break*/, 4];
+                    }
+                    packageJson = PackageJson_1.PackageJson.fromDirPath(packagePath);
+                    content = packageJson.getContent();
+                    if (content.dependencies) {
+                        for (_a = 0, _b = Object.keys(content.dependencies); _a < _b.length; _a++) {
+                            packageName = _b[_a];
+                            if (PluginService_1.PluginService.packageNameIsPlugin(packageName)) {
+                                pluginShortName = PluginService_1.PluginService.getPluginShortname(packageName);
+                                dependencyPath = (0, path_1.resolve)((0, path_1.join)(packagePath, "..", pluginShortName));
+                                content.dependencies[packageName] = "file://".concat(dependencyPath);
+                            }
+                        }
+                        packageJson.setContent(content);
+                    }
+                    return [4 /*yield*/, (0, cli_1.safeExec)(packagePath, "npm install")];
+                case 3:
+                    _c.sent();
+                    _c.label = 4;
+                case 4:
+                    _i++;
+                    return [3 /*break*/, 2];
+                case 5: return [2 /*return*/];
+            }
+        });
+    });
+}
+/**
+ * Create a full file structure for testing ts-dev-tools packages installation
+ * This function is not using cache to prevents drift between current code and test code
+ * @param projectDir path where to prepare packages
+ * @returns packages directory path
+ */
+function createTestPackagesDir(filename) {
+    return __awaiter(this, void 0, void 0, function () {
+        var testPackagesFileName;
+        return __generator(this, function (_a) {
+            testPackagesFileName = filename.replace(".spec.ts", "-test-packages.spec.ts");
+            return [2 /*return*/, (0, test_project_1.createProjectForTestFile)(testPackagesFileName, false, createTestPackagesProject)];
+        });
+    });
+}

package/dist/tests/test-project-monorepo.d.ts

@@ -0,0 +1,2 @@
+import { TestProjectGenerator } from "./test-project";
+export declare const createTestMonorepoProject: (filepath: string, useCache: boolean, testProjectGenerator: TestProjectGenerator) => Promise<string>;

package/dist/tests/test-project-monorepo.js

@@ -0,0 +1,97 @@
+"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.createTestMonorepoProject = void 0;
+var path_1 = require("path");
+var PackageJson_1 = require("../services/PackageJson");
+var cli_1 = require("./cli");
+var test_project_1 = require("./test-project");
+function generateProjectInMonorepoProject(packageName, projectDir, useCache, testProjectGenerator) {
+    return __awaiter(this, void 0, void 0, function () {
+        var packageDir;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, cli_1.safeExec)(projectDir, "npm init --yes")];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, (0, cli_1.safeExec)(projectDir, "npm install")];
+                case 2:
+                    _a.sent();
+                    return [4 /*yield*/, (0, cli_1.safeExec)(projectDir, "npm install --save-dev -W typescript")];
+                case 3:
+                    _a.sent();
+                    return [4 /*yield*/, (0, cli_1.safeExec)(projectDir, "npm exec tsc -- --init")];
+                case 4:
+                    _a.sent();
+                    PackageJson_1.PackageJson.fromDirPath(projectDir).merge({
+                        private: true,
+                        workspaces: ["packages/*"],
+                    });
+                    packageDir = (0, path_1.join)(projectDir, "packages/test-package");
+                    return [4 /*yield*/, (0, test_project_1.createTestProject)(packageName, packageDir, useCache, testProjectGenerator)];
+                case 5:
+                    _a.sent();
+                    return [4 /*yield*/, (0, cli_1.safeExec)(projectDir, "npm exec lerna -- init --no-progress --skipInstall")];
+                case 6:
+                    _a.sent();
+                    return [4 /*yield*/, (0, cli_1.safeExec)(projectDir, "npm install")];
+                case 7:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+function generateMonorepoProject(packageName, useCache, testProjectGenerator) {
+    var projectGenerator = function (projectDir) {
+        return generateProjectInMonorepoProject(packageName, projectDir, useCache, testProjectGenerator);
+    };
+    Object.defineProperty(projectGenerator, "name", {
+        value: "monorepo-project-generator-".concat(testProjectGenerator.name),
+        configurable: true,
+    });
+    return projectGenerator;
+}
+var createTestMonorepoProject = function (filepath, useCache, testProjectGenerator) { return __awaiter(void 0, void 0, void 0, function () {
+    var packageName;
+    return __generator(this, function (_a) {
+        packageName = (0, test_project_1.getPackageNameFromFilepath)(filepath);
+        return [2 /*return*/, (0, test_project_1.createProjectForTestFile)(filepath, useCache, generateMonorepoProject(packageName, useCache, testProjectGenerator))];
+    });
+}); };
+exports.createTestMonorepoProject = createTestMonorepoProject;

package/dist/tests/test-project.d.ts

@@ -0,0 +1,5 @@
+export declare const getPackageNameFromFilepath: (filepath: string) => string;
+export type TestProjectGenerator = (testProjectDir: string) => Promise<void>;
+export declare function createTestProject(packageName: string, testDirPath: string, useCache: boolean, testProjectGenerator?: TestProjectGenerator): Promise<string>;
+export declare function createProjectForTestFile(filepath: string, useCache: boolean, testProjectGenerator?: TestProjectGenerator): Promise<string>;
+export declare function deleteTestProject(filepath: string): Promise<void>;

package/dist/tests/test-project.js

@@ -0,0 +1,148 @@
+"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.getPackageNameFromFilepath = void 0;
+exports.createTestProject = createTestProject;
+exports.createProjectForTestFile = createProjectForTestFile;
+exports.deleteTestProject = deleteTestProject;
+var fs_1 = require("fs");
+var path_1 = require("path");
+var test_cache_1 = require("./test-cache");
+var file_system_1 = require("./file-system");
+var os_1 = require("os");
+var rootDirPath = (0, path_1.resolve)(__dirname, "../../../..");
+var corePackageDirPath = (0, path_1.resolve)(__dirname, "..", "..");
+var testProjectDir = (0, path_1.resolve)("__tests__/test-project");
+var defaultPackageJsonPath = (0, path_1.join)(testProjectDir, "package.json");
+var getPackageNameFromFilepath = function (filepath) {
+    var relativeFilepath = (0, path_1.relative)(rootDirPath, filepath);
+    var parts = relativeFilepath.split("/");
+    if (parts.length < 2) {
+        throw new Error("Invalid filepath: " + filepath);
+    }
+    var packageName = parts[1];
+    if (!packageName) {
+        throw new Error("Package name could not be determined from the filepath: " + filepath);
+    }
+    return packageName;
+};
+exports.getPackageNameFromFilepath = getPackageNameFromFilepath;
+var getTestProjectDirPath = function (filename) {
+    var testProjectRootDirPath = (0, path_1.join)((0, os_1.tmpdir)(), "ts-dev-tools");
+    var relativeFilepath = (0, path_1.relative)(rootDirPath, filename);
+    var testProjectDirName = "test-" + relativeFilepath.toLowerCase().replace(/[^a-z0-9]/g, "-");
+    return (0, path_1.join)(testProjectRootDirPath, testProjectDirName);
+};
+function defaultProjectGenerator(testProjectDirPath) {
+    return __awaiter(this, void 0, void 0, function () {
+        var corePackageRootPath, tsDevToolsDistPath;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    corePackageRootPath = (0, path_1.join)(testProjectDirPath, "node_modules/@ts-dev-tools/core");
+                    return [4 /*yield*/, (0, file_system_1.recreateFolderRecursive)(corePackageRootPath)];
+                case 1:
+                    _a.sent();
+                    (0, fs_1.copyFileSync)((0, path_1.join)(corePackageDirPath, "package.json"), (0, path_1.join)(corePackageRootPath, "package.json"));
+                    tsDevToolsDistPath = (0, path_1.join)(corePackageRootPath, "dist");
+                    (0, fs_1.symlinkSync)((0, path_1.resolve)(__dirname, ".."), tsDevToolsDistPath);
+                    (0, fs_1.copyFileSync)(defaultPackageJsonPath, (0, path_1.join)(testProjectDirPath, "package.json"));
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+function createTestProject(packageName_1, testDirPath_1, useCache_1) {
+    return __awaiter(this, arguments, void 0, function (packageName, testDirPath, useCache, testProjectGenerator) {
+        var cacheName, testCacheDirPath, gitHooksDirPath;
+        if (testProjectGenerator === void 0) { testProjectGenerator = defaultProjectGenerator; }
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, file_system_1.recreateFolderRecursive)(testDirPath)];
+                case 1:
+                    _a.sent();
+                    cacheName = testProjectGenerator.name;
+                    testCacheDirPath = (0, test_cache_1.getTestCacheDirPath)(packageName, cacheName);
+                    if (!(useCache && (0, test_cache_1.testCacheDirExists)(packageName, cacheName))) return [3 /*break*/, 3];
+                    return [4 /*yield*/, (0, file_system_1.copyFolder)(testCacheDirPath, testDirPath)];
+                case 2:
+                    _a.sent();
+                    return [2 /*return*/, testDirPath];
+                case 3: return [4 /*yield*/, testProjectGenerator(testDirPath)];
+                case 4:
+                    _a.sent();
+                    gitHooksDirPath = (0, path_1.join)(testDirPath, ".git/hooks");
+                    return [4 /*yield*/, (0, file_system_1.recreateFolderRecursive)(gitHooksDirPath)];
+                case 5:
+                    _a.sent();
+                    if (!useCache) return [3 /*break*/, 7];
+                    return [4 /*yield*/, (0, file_system_1.copyFolder)(testDirPath, testCacheDirPath)];
+                case 6:
+                    _a.sent();
+                    _a.label = 7;
+                case 7: return [2 /*return*/, testDirPath];
+            }
+        });
+    });
+}
+function createProjectForTestFile(filepath_1, useCache_1) {
+    return __awaiter(this, arguments, void 0, function (filepath, useCache, testProjectGenerator) {
+        var testDirPath, packageName;
+        if (testProjectGenerator === void 0) { testProjectGenerator = defaultProjectGenerator; }
+        return __generator(this, function (_a) {
+            testDirPath = getTestProjectDirPath(filepath);
+            packageName = (0, exports.getPackageNameFromFilepath)(filepath);
+            return [2 /*return*/, createTestProject(packageName, testDirPath, useCache, testProjectGenerator)];
+        });
+    });
+}
+function deleteTestProject(filepath) {
+    return __awaiter(this, void 0, void 0, function () {
+        var testProjectDirPath;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    testProjectDirPath = getTestProjectDirPath(filepath);
+                    return [4 /*yield*/, (0, file_system_1.deleteFolderRecursive)(testProjectDirPath)];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ts-dev-tools/core",
-  "version": "1.8.9",
+  "version": "1.9.1",
   "description": "TS dev tools Core",
   "keywords": [
     "linter",
@@ -28,17 +28,15 @@
     "url": "git+https://github.com/escemi-tech/ts-dev-tools.git"
   },
   "scripts": {
-    "start": "yarn link && tsc -w",
-    "stop": "yarn unlink",
+    "start": "npm link && tsc -w",
+    "stop": "npm unlink",
     "build": "rimraf dist && tsc",
     "jest": "jest --detectOpenHandles --forceExit",
-    "test": "yarn jest --maxWorkers=50%",
-    "test:unit": "yarn test --testPathPattern \".+spec\\.ts\"",
-    "test:e2e": "yarn test --testPathPattern \".+spec\\.e2e\\.ts\"",
-    "test:coverage": "yarn test --coverage",
-    "lint": "eslint \"src/**/*.{ts,tsx}\"",
-    "prepublishOnly": "pinst --disable",
-    "postpublish": "pinst --enable"
+    "test": "npm run jest -- --maxWorkers=50%",
+    "test:unit": "npm run test -- --testPathPattern \".+spec\\.ts\"",
+    "test:e2e": "npm run test -- --testPathPattern \".+e2e\\.spec\\.ts\"",
+    "test:coverage": "npm run test -- --coverage",
+    "lint": "eslint \"src/**/*.{ts,tsx}\""
   },
   "bugs": {
     "url": "https://github.com/escemi-tech/ts-dev-tools/issues"
@@ -46,24 +44,23 @@
   "dependencies": {
     "@commitlint/cli": "^19.4.0",
     "@commitlint/config-conventional": "^19.0.3",
-    "@eslint/js": "^9.9.1",
+    "@eslint/js": "^9.25.0",
     "@types/jest": "^29.5.2",
-    "@types/node": "^22.5.0",
-    "eslint": "^9.9.1",
-    "eslint-config-prettier": "^10.0.1",
+    "@types/node": "^22.14.1",
+    "eslint": "^9.25.0",
+    "eslint-config-prettier": "^10.1.2",
     "eslint-plugin-jest": "^28.8.0",
     "import-sort-style-module": "^6.0.0",
     "jest": "^29.5.0",
-    "lint-staged": "^15.2.9",
+    "lint-staged": "^15.5.1",
     "prettier": "^3.3.3",
     "prettier-plugin-import-sort": "^0.0.7",
     "pretty-quick": "^4.0.0",
     "ts-jest": "^29.2.5",
-    "typescript": "^5.5.4",
-    "typescript-eslint": "^8.3.0"
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.30.1"
   },
   "devDependencies": {
-    "pinst": "^3.0.0",
     "ts-node": "^10.9.1"
   },
   "prettier": {
@@ -91,5 +88,5 @@
       "github-actions"
     ]
   },
-  "gitHead": "1b6d5858642b90c7125e80b3cf37fa190d469bcf"
+  "gitHead": "cec0352615e50a8aa5716e057abbd970bccbddd7"
 }

package/dist/tests/project.d.ts

@@ -1,13 +0,0 @@
-export declare const testProjectDir: string;
-export declare function createTestProjectDir(filename: string): string;
-export declare function createTestProjectDirWithFixtures(filename: string): string;
-export declare function getCorePackageRootPath(filename: string): string;
-export declare function restorePackageJson(filename: string): void;
-export declare function removeTestProjectDir(filename: string): void;
-export declare const createTestMonorepoProjectDir: (projectDir: string, createProject: (projectDir: string) => Promise<void>) => Promise<void>;
-/**
- * Create a full file structure for testing ts-dev-tools packages installation
- * @param projectDir path where to prepare packages
- * @returns packages directory path
- */
-export declare const createTestPackagesDir: (projectDir: string) => Promise<string>;

package/dist/tests/project.js

@@ -1,159 +0,0 @@
-"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.createTestPackagesDir = exports.createTestMonorepoProjectDir = exports.testProjectDir = void 0;
-exports.createTestProjectDir = createTestProjectDir;
-exports.createTestProjectDirWithFixtures = createTestProjectDirWithFixtures;
-exports.getCorePackageRootPath = getCorePackageRootPath;
-exports.restorePackageJson = restorePackageJson;
-exports.removeTestProjectDir = removeTestProjectDir;
-var fs_1 = require("fs");
-var path_1 = require("path");
-var PackageJson_1 = require("../services/PackageJson");
-var PluginService_1 = require("../services/PluginService");
-var cli_1 = require("./cli");
-var test_dir_1 = require("./test-dir");
-exports.testProjectDir = (0, path_1.resolve)("__tests__/test-project");
-var defaultPackageJsonPath = (0, path_1.join)(exports.testProjectDir, "package.json");
-var getTestProjectDirPath = function (filename) { return (0, test_dir_1.getTestDirPath)("test", filename); };
-function createTestProjectDir(filename) {
-    var testDirPath = getTestProjectDirPath(filename);
-    return (0, test_dir_1.createTestDir)(testDirPath, true);
-}
-function createTestProjectDirWithFixtures(filename) {
-    var testProjectDirPath = createTestProjectDir(filename);
-    (0, fs_1.mkdirSync)((0, path_1.join)(testProjectDirPath, ".git/hooks"), { recursive: true });
-    // Fake node_modules
-    var corePackageRootPath = getCorePackageRootPath(filename);
-    (0, fs_1.mkdirSync)(corePackageRootPath, { recursive: true });
-    (0, fs_1.copyFileSync)((0, path_1.resolve)(__dirname, "../../package.json"), (0, path_1.join)(corePackageRootPath, "package.json"));
-    // Fake migrations
-    var tsDevToolsDistPath = (0, path_1.join)(corePackageRootPath, "dist");
-    (0, fs_1.symlinkSync)((0, path_1.resolve)(__dirname, ".."), tsDevToolsDistPath);
-    restorePackageJson(filename);
-    return testProjectDirPath;
-}
-function getCorePackageRootPath(filename) {
-    var testProjectDirPath = getTestProjectDirPath(filename);
-    if (!(0, fs_1.existsSync)(testProjectDirPath)) {
-        throw new Error("Test project dir \"".concat(testProjectDirPath, "\" does not exist"));
-    }
-    return (0, path_1.join)(testProjectDirPath, "node_modules/@ts-dev-tools/core");
-}
-function restorePackageJson(filename) {
-    var testProjectDirPath = getTestProjectDirPath(filename);
-    if (!(0, fs_1.existsSync)(testProjectDirPath)) {
-        throw new Error("Test project dir \"".concat(testProjectDirPath, "\" does not exist"));
-    }
-    (0, fs_1.copyFileSync)(defaultPackageJsonPath, (0, path_1.join)(testProjectDirPath, "package.json"));
-}
-function removeTestProjectDir(filename) {
-    var testProjectDirPath = getTestProjectDirPath(filename);
-    (0, test_dir_1.removeTestDir)(testProjectDirPath);
-}
-var createTestMonorepoProjectDir = function (projectDir, createProject) { return __awaiter(void 0, void 0, void 0, function () {
-    var packageDir;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0: return [4 /*yield*/, (0, cli_1.safeExec)(projectDir, "yarn init --yes")];
-            case 1:
-                _a.sent();
-                return [4 /*yield*/, (0, cli_1.safeExec)(projectDir, "yarn install")];
-            case 2:
-                _a.sent();
-                return [4 /*yield*/, (0, cli_1.safeExec)(projectDir, "yarn add -W --dev typescript")];
-            case 3:
-                _a.sent();
-                return [4 /*yield*/, (0, cli_1.safeExec)(projectDir, "yarn tsc --init")];
-            case 4:
-                _a.sent();
-                PackageJson_1.PackageJson.fromDirPath(projectDir).merge({
-                    private: true,
-                    workspaces: ["packages/*"],
-                });
-                packageDir = (0, path_1.join)(projectDir, "packages/test-package");
-                (0, fs_1.mkdirSync)(packageDir, { recursive: true });
-                return [4 /*yield*/, createProject(packageDir)];
-            case 5:
-                _a.sent();
-                return [2 /*return*/];
-        }
-    });
-}); };
-exports.createTestMonorepoProjectDir = createTestMonorepoProjectDir;
-/**
- * Create a full file structure for testing ts-dev-tools packages installation
- * @param projectDir path where to prepare packages
- * @returns packages directory path
- */
-var createTestPackagesDir = function (projectDir) { return __awaiter(void 0, void 0, void 0, function () {
-    var originalPackagesPath, projectDirPackages, projectDirPackagesFiles, _i, projectDirPackagesFiles_1, projectDirPackagesFile, packagePath, packageJson, content, _a, _b, packageName;
-    return __generator(this, function (_c) {
-        switch (_c.label) {
-            case 0:
-                originalPackagesPath = (0, path_1.resolve)(__dirname, "../../..");
-                projectDirPackages = (0, path_1.join)(projectDir, "tmp-packages");
-                (0, fs_1.mkdirSync)(projectDirPackages);
-                return [4 /*yield*/, (0, cli_1.safeExec)(projectDir, "cp -R ".concat(originalPackagesPath, " ").concat(projectDirPackages, "/"))];
-            case 1:
-                _c.sent();
-                projectDirPackages = (0, path_1.resolve)(projectDirPackages, "packages");
-                projectDirPackagesFiles = (0, fs_1.readdirSync)(projectDirPackages);
-                for (_i = 0, projectDirPackagesFiles_1 = projectDirPackagesFiles; _i < projectDirPackagesFiles_1.length; _i++) {
-                    projectDirPackagesFile = projectDirPackagesFiles_1[_i];
-                    packagePath = (0, path_1.resolve)(projectDirPackages, projectDirPackagesFile);
-                    if (!(0, fs_1.lstatSync)(packagePath).isDirectory()) {
-                        continue;
-                    }
-                    packageJson = PackageJson_1.PackageJson.fromDirPath(packagePath);
-                    content = packageJson.getContent();
-                    if (content.dependencies) {
-                        for (_a = 0, _b = Object.keys(content.dependencies); _a < _b.length; _a++) {
-                            packageName = _b[_a];
-                            if (PluginService_1.PluginService.packageNameIsPlugin(packageName)) {
-                                content.dependencies[packageName] = "file:../".concat(PluginService_1.PluginService.getPluginShortname(packageName));
-                            }
-                        }
-                        packageJson.setContent(content);
-                    }
-                }
-                return [2 /*return*/, projectDirPackages];
-        }
-    });
-}); };
-exports.createTestPackagesDir = createTestPackagesDir;

package/dist/tests/test-dir.d.ts

@@ -1,3 +0,0 @@
-export declare const getTestDirPath: (dirName: string, filename: string) => string;
-export declare function createTestDir(testDirPath: string, removeIfExists?: boolean): string;
-export declare function removeTestDir(testDirPath: string): void;

package/dist/tests/test-dir.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTestDirPath = void 0;
-exports.createTestDir = createTestDir;
-exports.removeTestDir = removeTestDir;
-var fs_1 = require("fs");
-var os_1 = require("os");
-var path_1 = require("path");
-var file_system_1 = require("./file-system");
-var getTestDirPath = function (dirName, filename) {
-    return (0, path_1.join)((0, os_1.tmpdir)(), dirName + "-" + (0, path_1.basename)(filename).split(".")[0]);
-};
-exports.getTestDirPath = getTestDirPath;
-function createTestDir(testDirPath, removeIfExists) {
-    if (removeIfExists === void 0) { removeIfExists = false; }
-    if ((0, fs_1.existsSync)(testDirPath)) {
-        if (!removeIfExists) {
-            return testDirPath;
-        }
-        (0, file_system_1.deleteFolderRecursive)(testDirPath);
-    }
-    (0, fs_1.mkdirSync)(testDirPath);
-    return testDirPath;
-}
-function removeTestDir(testDirPath) {
-    if (!(0, fs_1.existsSync)(testDirPath)) {
-        throw new Error("Test project dir \"".concat(testDirPath, "\" does not exist"));
-    }
-    (0, file_system_1.deleteFolderRecursive)(testDirPath);
-}