@ts-dev-tools/core 1.5.10 → 1.5.14

package/dist/bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin.js

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+"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;
+    return g = { next: verb(0), "throw": verb(1), "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 (_) 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 });
+var path_1 = require("path");
+var command_1 = require("./install/command");
+var PackageJson_1 = require("./services/PackageJson");
+function bin() {
+    return __awaiter(this, void 0, void 0, function () {
+        var _a, arg, params, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    _a = process.argv, arg = _a[2], params = _a.slice(3);
+                    _b = true;
+                    switch (_b) {
+                        case arg === "install": return [3 /*break*/, 1];
+                        case ["--version", "-v"].includes(arg): return [3 /*break*/, 3];
+                    }
+                    return [3 /*break*/, 4];
+                case 1:
+                    // Check if script is not run by the package himself
+                    if (process.cwd() === (0, path_1.dirname)(__dirname)) {
+                        console.info("Do not install itself!");
+                        return [3 /*break*/, 5];
+                    }
+                    return [4 /*yield*/, (0, command_1.install)({
+                            cwd: process.cwd(),
+                            dir: params[0],
+                        })];
+                case 2:
+                    _c.sent();
+                    return [3 /*break*/, 5];
+                case 3:
+                    console.info(PackageJson_1.PackageJson.fromDirPath((0, path_1.join)(__dirname, "..")).getPackageVersion());
+                    return [3 /*break*/, 5];
+                case 4:
+                    console.info("Usage\n    ts-dev-tools install [path from project root]\n  ");
+                    _c.label = 5;
+                case 5: return [2 /*return*/];
+            }
+        });
+    });
+}
+bin()
+    .then()
+    .catch(function (error) { return console.error(error); });

package/dist/install/command.d.ts

@@ -0,0 +1,4 @@
+export declare function install({ cwd, dir }: {
+    cwd: string;
+    dir: string;
+}): Promise<void>;

package/dist/install/command.js

@@ -0,0 +1,74 @@
+"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;
+    return g = { next: verb(0), "throw": verb(1), "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 (_) 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.install = void 0;
+var path_1 = require("path");
+var DuplicateDependenciesService_1 = require("../services/DuplicateDependenciesService");
+var MigrationsService_1 = require("../services/MigrationsService");
+var PackageJson_1 = require("../services/PackageJson");
+function install(_a) {
+    var cwd = _a.cwd, _b = _a.dir, dir = _b === void 0 ? "." : _b;
+    return __awaiter(this, void 0, void 0, function () {
+        var tsDevToolsRootPath, packageName, absoluteProjectDir, currentVersion;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    tsDevToolsRootPath = (0, path_1.resolve)(__dirname, "../..");
+                    packageName = PackageJson_1.PackageJson.fromDirPath(tsDevToolsRootPath).getPackageName();
+                    absoluteProjectDir = (0, path_1.resolve)(cwd, dir);
+                    if (!absoluteProjectDir.startsWith(cwd)) {
+                        throw new Error(".. not allowed");
+                    }
+                    currentVersion = PackageJson_1.PackageJson.fromDirPath(absoluteProjectDir).getTsDevToolsVersion();
+                    if (currentVersion) {
+                        console.info("Updating ".concat(packageName, " installation..."));
+                    }
+                    else {
+                        console.info("Installing ".concat(packageName, "..."));
+                    }
+                    return [4 /*yield*/, MigrationsService_1.MigrationsService.executeMigrations(tsDevToolsRootPath, absoluteProjectDir, currentVersion)];
+                case 1:
+                    _c.sent();
+                    DuplicateDependenciesService_1.DuplicateDependenciesService.duplicateDependencies(tsDevToolsRootPath, absoluteProjectDir);
+                    console.info("Installation done!");
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.install = install;

package/dist/install/migrations/20201024173398-init.d.ts

@@ -0,0 +1,2 @@
+import { MigrationUpFunction } from "../../services/MigrationsService";
+export declare const up: MigrationUpFunction;

package/dist/install/migrations/20201024173398-init.js

@@ -0,0 +1,144 @@
+"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;
+    return g = { next: verb(0), "throw": verb(1), "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 (_) 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.up = void 0;
+var GitService_1 = require("../../services/GitService");
+var PackageJson_1 = require("../../services/PackageJson");
+var PackageManagerService_1 = require("../../services/PackageManagerService");
+var up = function (absoluteProjectDir) { return __awaiter(void 0, void 0, void 0, function () {
+    var jest, eslintConfig, prettier, commitlint, lintStaged, importSort, scripts, packageJson, isGitRepository, packageManager, gitHooks, _i, _a, gitHookName, gitHookCommand;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0:
+                jest = {
+                    preset: "ts-jest",
+                    testEnvironment: "node",
+                    testMatch: ["**/__tests__/**/*.[jt]s?(x)", "**/?(*.)+(spec|test).+(ts|tsx|js)"],
+                };
+                eslintConfig = {
+                    root: true,
+                    parser: "@typescript-eslint/parser",
+                    plugins: ["@typescript-eslint", "jest"],
+                    extends: [
+                        "eslint:recommended",
+                        "plugin:@typescript-eslint/recommended",
+                        "plugin:jest/recommended",
+                        "prettier",
+                    ],
+                    env: {
+                        es2021: true,
+                    },
+                    parserOptions: {
+                        ecmaFeatures: {
+                            jsx: true,
+                        },
+                        ecmaVersion: 12,
+                        sourceType: "module",
+                    },
+                    settings: {
+                        jest: {
+                            version: "detect",
+                        },
+                    },
+                };
+                prettier = {
+                    semi: true,
+                    printWidth: 100,
+                    trailingComma: "es5",
+                };
+                commitlint = {
+                    extends: ["@commitlint/config-conventional"],
+                };
+                lintStaged = {
+                    "*.{js,ts,tsx}": ["eslint --fix"],
+                };
+                importSort = {
+                    ".js, .jsx, .ts, .tsx": {
+                        style: "module",
+                        parser: "typescript",
+                    },
+                };
+                scripts = {
+                    build: "tsc --noEmit",
+                    format: "prettier --write '**/*.js'",
+                    lint: 'eslint "src/**/*.{ts,tsx}"',
+                    jest: "jest --detectOpenHandles --forceExit",
+                    test: "yarn jest --maxWorkers=50%",
+                    "test:watch": "yarn jest --watch --maxWorkers=25%",
+                    "test:cov": "yarn jest --coverage",
+                    "test:ci": "yarn test:cov --runInBand",
+                    prepare: "ts-dev-tools install",
+                };
+                packageJson = PackageJson_1.PackageJson.fromDirPath(absoluteProjectDir);
+                packageJson.merge({
+                    eslintConfig: eslintConfig,
+                    prettier: prettier,
+                    commitlint: commitlint,
+                    "lint-staged": lintStaged,
+                    importSort: importSort,
+                    scripts: scripts,
+                    jest: jest,
+                });
+                return [4 /*yield*/, GitService_1.GitService.isGitRepository(absoluteProjectDir)];
+            case 1:
+                isGitRepository = _b.sent();
+                if (!isGitRepository) return [3 /*break*/, 5];
+                packageManager = PackageManagerService_1.PackageManagerService.detectPackageManager(absoluteProjectDir);
+                gitHooks = {
+                    "pre-commit": "npx --no-install lint-staged && npx --no-install pretty-quick --staged",
+                    "commit-msg": "npx --no-install commitlint --edit $1",
+                    "pre-push": "".concat(packageManager, " run lint && ").concat(packageManager, " run build && ").concat(packageManager, " run test"),
+                };
+                _i = 0, _a = Object.keys(gitHooks);
+                _b.label = 2;
+            case 2:
+                if (!(_i < _a.length)) return [3 /*break*/, 5];
+                gitHookName = _a[_i];
+                gitHookCommand = gitHooks[gitHookName];
+                return [4 /*yield*/, GitService_1.GitService.addGitHook(absoluteProjectDir, gitHookName, gitHookCommand)];
+            case 3:
+                _b.sent();
+                _b.label = 4;
+            case 4:
+                _i++;
+                return [3 /*break*/, 2];
+            case 5: return [2 /*return*/];
+        }
+    });
+}); };
+exports.up = up;

package/dist/services/CmdService.d.ts

@@ -0,0 +1,3 @@
+export declare class CmdService {
+    static execCmd(args: string | string[], cwd?: string, silent?: boolean): Promise<string>;
+}

package/dist/services/CmdService.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CmdService = void 0;
+var child_process_1 = require("child_process");
+var fs_1 = require("fs");
+var CmdService = /** @class */ (function () {
+    function CmdService() {
+    }
+    CmdService.execCmd = function (args, cwd, silent) {
+        if (silent === void 0) { silent = false; }
+        if (!args.length) {
+            throw new Error("Command args must not be empty");
+        }
+        if (cwd) {
+            if (!(0, fs_1.existsSync)(cwd) || !(0, fs_1.statSync)(cwd).isDirectory()) {
+                throw new Error("Directory \"".concat(cwd, "\" does not exist"));
+            }
+        }
+        var cmd;
+        if (Array.isArray(args)) {
+            cmd = args.shift() || "";
+        }
+        else {
+            cmd = args;
+            args = [];
+        }
+        return new Promise(function (resolve, reject) {
+            var child = (0, child_process_1.spawn)(cmd, args, {
+                stdio: silent ? "pipe" : "inherit",
+                shell: true,
+                windowsVerbatimArguments: true,
+                cwd: cwd,
+            });
+            var output = "";
+            var error = "";
+            child.on("exit", function (code) {
+                if (code) {
+                    return reject(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 CmdService;
+}());
+exports.CmdService = CmdService;

package/dist/services/DuplicateDependenciesService.d.ts

@@ -0,0 +1,6 @@
+export declare class DuplicateDependenciesService {
+    static duplicateDependencies(tsDevToolsRootPath: string, absoluteProjectDir: string): void;
+    private static getProjectDuplicateDependencies;
+    private static getPluginDuplicateDependencies;
+    private static printDuplicateDependencies;
+}

package/dist/services/DuplicateDependenciesService.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuplicateDependenciesService = void 0;
+var path_1 = require("path");
+var PackageJson_1 = require("./PackageJson");
+var DuplicateDependenciesService = /** @class */ (function () {
+    function DuplicateDependenciesService() {
+    }
+    DuplicateDependenciesService.duplicateDependencies = function (tsDevToolsRootPath, absoluteProjectDir) {
+        console.info("Checking for duplicate dev dependencies...");
+        var duplicateDependencies = new Map();
+        DuplicateDependenciesService.getProjectDuplicateDependencies(tsDevToolsRootPath, absoluteProjectDir, duplicateDependencies);
+        DuplicateDependenciesService.printDuplicateDependencies(duplicateDependencies);
+        console.info("Check for duplicate dev dependencies done!");
+    };
+    DuplicateDependenciesService.getProjectDuplicateDependencies = function (tsDevToolsRootPath, absoluteProjectDir, duplicateDependencies) {
+        var projectPackageJson = PackageJson_1.PackageJson.fromDirPath(absoluteProjectDir);
+        var installedPlugins = projectPackageJson.getInstalledPlugins();
+        var projectDevDependencies = projectPackageJson.getDevDependenciesPackageNames();
+        for (var _i = 0, installedPlugins_1 = installedPlugins; _i < installedPlugins_1.length; _i++) {
+            var plugin = installedPlugins_1[_i];
+            DuplicateDependenciesService.getPluginDuplicateDependencies(tsDevToolsRootPath, plugin, projectDevDependencies, duplicateDependencies);
+        }
+        return duplicateDependencies;
+    };
+    DuplicateDependenciesService.getPluginDuplicateDependencies = function (tsDevToolsRootPath, plugin, projectDevDependencies, duplicateDependencies) {
+        var absolutePluginDir = (0, path_1.resolve)(tsDevToolsRootPath, "../../", plugin);
+        // First check for duplicate of inherited plugins
+        DuplicateDependenciesService.getProjectDuplicateDependencies(tsDevToolsRootPath, absolutePluginDir, duplicateDependencies);
+        var pluginPackageJson = PackageJson_1.PackageJson.fromDirPath(absolutePluginDir);
+        var pluginDependencies = pluginPackageJson.getDependenciesPackageNames();
+        var pluginDuplicateDependencies = duplicateDependencies.get(plugin);
+        if (!pluginDuplicateDependencies) {
+            pluginDuplicateDependencies = new Set();
+            duplicateDependencies.set(plugin, pluginDuplicateDependencies);
+        }
+        for (var _i = 0, projectDevDependencies_1 = projectDevDependencies; _i < projectDevDependencies_1.length; _i++) {
+            var projectDevDependency = projectDevDependencies_1[_i];
+            if (pluginDependencies.includes(projectDevDependency)) {
+                pluginDuplicateDependencies.add(projectDevDependency);
+            }
+        }
+    };
+    DuplicateDependenciesService.printDuplicateDependencies = function (duplicateDependencies) {
+        duplicateDependencies.forEach(function (pluginDuplicateDependencies, plugin) {
+            if (pluginDuplicateDependencies.size) {
+                var pluginDuplicateDependenciesValue = Array.from(pluginDuplicateDependencies);
+                console.info("Some dev dependencies are unnecessarily installed as their are already required by \"".concat(plugin, "\":\"\n  - \"").concat(pluginDuplicateDependenciesValue.join("\n  - "), "\n"));
+            }
+        });
+    };
+    return DuplicateDependenciesService;
+}());
+exports.DuplicateDependenciesService = DuplicateDependenciesService;

package/dist/services/GitService.d.ts

@@ -0,0 +1,7 @@
+export declare class GitService {
+    static GIT_HOOK_MODE: number;
+    static GIT_HOOK_TEMPLATE: string;
+    static isGitRepository(absoluteProjectDir: string): Promise<boolean>;
+    static addGitHook(absoluteProjectDir: string, gitHookName: string, gitHookCommand: string): Promise<void>;
+    private static getFilePermissions;
+}

package/dist/services/GitService.js

@@ -0,0 +1,89 @@
+"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;
+    return g = { next: verb(0), "throw": verb(1), "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 (_) 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.GitService = void 0;
+var fs_1 = require("fs");
+var path_1 = require("path");
+var CmdService_1 = require("./CmdService");
+var GitService = /** @class */ (function () {
+    function GitService() {
+    }
+    GitService.isGitRepository = function (absoluteProjectDir) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, CmdService_1.CmdService.execCmd("git rev-parse", absoluteProjectDir, true)
+                            .then(function () { return true; })
+                            .catch(function () { return false; })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    GitService.addGitHook = function (absoluteProjectDir, gitHookName, gitHookCommand) {
+        return __awaiter(this, void 0, void 0, function () {
+            var gitHookDirPath, gitHookFilePath, mode;
+            return __generator(this, function (_a) {
+                gitHookDirPath = (0, path_1.join)(absoluteProjectDir, ".git/hooks");
+                gitHookFilePath = (0, path_1.join)(gitHookDirPath, gitHookName);
+                if ((0, fs_1.existsSync)(gitHookFilePath)) {
+                    mode = GitService.getFilePermissions(gitHookFilePath);
+                    if (mode !== GitService.GIT_HOOK_MODE) {
+                        (0, fs_1.chmodSync)(gitHookFilePath, GitService.GIT_HOOK_MODE);
+                    }
+                    return [2 /*return*/];
+                }
+                return [2 /*return*/, new Promise(function (resolve, reject) {
+                        var stream = (0, fs_1.createWriteStream)(gitHookFilePath, { mode: GitService.GIT_HOOK_MODE });
+                        stream.on("close", function () { return resolve(undefined); });
+                        stream.on("error", function (error) { return reject(error); });
+                        stream.write(GitService.GIT_HOOK_TEMPLATE.replace("%gitHookCommand%", gitHookCommand));
+                        stream.end();
+                    })];
+            });
+        });
+    };
+    GitService.getFilePermissions = function (filePath) {
+        var mode = (0, fs_1.statSync)(filePath).mode;
+        return mode & parseInt("777", 8);
+    };
+    GitService.GIT_HOOK_MODE = 493;
+    GitService.GIT_HOOK_TEMPLATE = "#!/bin/sh\n\n# Created by ts-dev-tools (https://escemi-tech.github.io/ts-dev-tools/)\n\n%gitHookCommand%";
+    return GitService;
+}());
+exports.GitService = GitService;

package/dist/services/MigrationsService.d.ts

@@ -0,0 +1,10 @@
+export declare type Migration = {
+    name: string;
+    path: string;
+};
+export declare type MigrationUpFunction = (absoluteProjectDir: string) => Promise<void>;
+export declare class MigrationsService {
+    static executeMigrations(tsDevToolsRootPath: string, absoluteProjectDir: string, currentVersion: string | undefined): Promise<void>;
+    private static getAvailableMigrations;
+    private static getPluginMigrations;
+}

package/dist/services/MigrationsService.js

@@ -0,0 +1,132 @@
+"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;
+    return g = { next: verb(0), "throw": verb(1), "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 (_) 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.MigrationsService = void 0;
+var fs_1 = require("fs");
+var path_1 = require("path");
+var PackageJson_1 = require("../services/PackageJson");
+var MigrationsService = /** @class */ (function () {
+    function MigrationsService() {
+    }
+    MigrationsService.executeMigrations = function (tsDevToolsRootPath, absoluteProjectDir, currentVersion) {
+        return __awaiter(this, void 0, void 0, function () {
+            var migrations, packageJson, packageJsonBackupPath, _i, migrations_1, migration, up, error_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        migrations = MigrationsService.getAvailableMigrations(tsDevToolsRootPath, absoluteProjectDir, currentVersion);
+                        packageJson = PackageJson_1.PackageJson.fromDirPath(absoluteProjectDir);
+                        packageJsonBackupPath = packageJson.backup();
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 6, , 7]);
+                        _i = 0, migrations_1 = migrations;
+                        _a.label = 2;
+                    case 2:
+                        if (!(_i < migrations_1.length)) return [3 /*break*/, 5];
+                        migration = migrations_1[_i];
+                        console.info("Applying migration \"".concat(migration.name, "\"..."));
+                        up = require(migration.path).up;
+                        // Apply migration
+                        return [4 /*yield*/, up(absoluteProjectDir)];
+                    case 3:
+                        // Apply migration
+                        _a.sent();
+                        // Upgrade current version
+                        PackageJson_1.PackageJson.fromDirPath(absoluteProjectDir).merge({
+                            tsDevTools: { version: migration.name },
+                        });
+                        console.info("Migration \"".concat(migration.name, "\" applied!"));
+                        _a.label = 4;
+                    case 4:
+                        _i++;
+                        return [3 /*break*/, 2];
+                    case 5: return [3 /*break*/, 7];
+                    case 6:
+                        error_1 = _a.sent();
+                        // Rollback package.json
+                        packageJson.restore(packageJsonBackupPath);
+                        throw error_1;
+                    case 7:
+                        (0, fs_1.unlinkSync)(packageJsonBackupPath);
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    MigrationsService.getAvailableMigrations = function (tsDevToolsRootPath, absoluteProjectDir, currentVersion) {
+        var packageJson = PackageJson_1.PackageJson.fromDirPath(absoluteProjectDir);
+        var installedPlugins = packageJson.getInstalledPlugins();
+        var migrationFiles = [];
+        for (var _i = 0, installedPlugins_1 = installedPlugins; _i < installedPlugins_1.length; _i++) {
+            var installedPlugin = installedPlugins_1[_i];
+            migrationFiles.push.apply(migrationFiles, MigrationsService.getPluginMigrations(tsDevToolsRootPath, installedPlugin, currentVersion));
+        }
+        migrationFiles.sort(function (_a, _b) {
+            var nameA = _a.name;
+            var nameB = _b.name;
+            return nameA.localeCompare(nameB);
+        });
+        return Array.from(new Set(migrationFiles));
+    };
+    MigrationsService.getPluginMigrations = function (tsDevToolsRootPath, plugin, currentVersion) {
+        var pluginDirPath = (0, path_1.resolve)(tsDevToolsRootPath, "../../", plugin);
+        // First retrieve migration of inherited plugins
+        var migrationFiles = MigrationsService.getAvailableMigrations(tsDevToolsRootPath, pluginDirPath, currentVersion);
+        // Then retrieve
+        var pluginMigrationsDirPath = (0, path_1.resolve)(pluginDirPath, "dist/install/migrations");
+        for (var _i = 0, _a = (0, fs_1.readdirSync)(pluginMigrationsDirPath); _i < _a.length; _i++) {
+            var migrationFile = _a[_i];
+            if (!migrationFile.match(/^[0-9]{14}-[a-z]+\.(js|ts)$/)) {
+                continue;
+            }
+            var migrationName = migrationFile.split(".").slice(0, -1).join(".");
+            var shouldApplyMigration = !currentVersion || currentVersion.localeCompare(migrationName) < 0;
+            if (!shouldApplyMigration) {
+                continue;
+            }
+            migrationFiles.push({
+                name: migrationName,
+                path: (0, path_1.resolve)(pluginMigrationsDirPath, migrationFile),
+            });
+        }
+        return migrationFiles;
+    };
+    return MigrationsService;
+}());
+exports.MigrationsService = MigrationsService;

package/dist/services/PackageJson.d.ts

@@ -0,0 +1,28 @@
+import { PackageJson as PackageJsonType } from "type-fest";
+export declare type JsonArray = boolean[] | number[] | string[] | JsonFileData[] | Date[];
+export declare type AnyJson = boolean | number | string | JsonFileData | Date | JsonArray | JsonArray[];
+export declare type JsonFileData = {
+    [key: string]: AnyJson | undefined;
+};
+export declare type PackageJsonContent = JsonFileData & PackageJsonType;
+export declare class PackageJson {
+    private path;
+    private content?;
+    constructor(path: string);
+    getPath(): string;
+    getContent(): PackageJsonContent;
+    setContent(content: PackageJsonContent): void;
+    getPackageName(): string | undefined;
+    getPackageVersion(): string | undefined;
+    isPrivate(): boolean;
+    getTsDevToolsVersion(): string | undefined;
+    getInstalledPlugins(): string[];
+    getDependenciesPackageNames(): string[];
+    getDevDependenciesPackageNames(): string[];
+    getAllDependenciesPackageNames(): string[];
+    merge(update: PackageJsonContent): void;
+    backup(): string;
+    restore(backupPath: string): void;
+    private write;
+    static fromDirPath(dirPath: string): PackageJson;
+}

package/dist/services/PackageJson.js

@@ -0,0 +1,99 @@
+"use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PackageJson = void 0;
+var fs_1 = require("fs");
+var path_1 = require("path");
+var PackageJsonMerge_1 = require("./PackageJsonMerge");
+var PackageJson = /** @class */ (function () {
+    function PackageJson(path) {
+        this.path = path;
+        this.content = undefined;
+        if (!(0, fs_1.existsSync)(this.path)) {
+            throw new Error("Package.json \"".concat(this.path, "\" does not exist"));
+        }
+    }
+    PackageJson.prototype.getPath = function () {
+        return this.path;
+    };
+    PackageJson.prototype.getContent = function () {
+        if (this.content) {
+            return this.content;
+        }
+        return (this.content = JSON.parse((0, fs_1.readFileSync)(this.path, "utf-8")));
+    };
+    PackageJson.prototype.setContent = function (content) {
+        this.content = content;
+        this.write();
+    };
+    PackageJson.prototype.getPackageName = function () {
+        return this.getContent().name;
+    };
+    PackageJson.prototype.getPackageVersion = function () {
+        return this.getContent().version;
+    };
+    PackageJson.prototype.isPrivate = function () {
+        return this.getContent().private === true;
+    };
+    PackageJson.prototype.getTsDevToolsVersion = function () {
+        var tsDevToolsConfig = this.getContent().tsDevTools;
+        var version = tsDevToolsConfig === null || tsDevToolsConfig === void 0 ? void 0 : tsDevToolsConfig.version;
+        return version;
+    };
+    PackageJson.prototype.getInstalledPlugins = function () {
+        var allDependenciesPackageNames = this.getAllDependenciesPackageNames();
+        if (!allDependenciesPackageNames.length) {
+            return [];
+        }
+        var plugins = allDependenciesPackageNames.filter(function (packageName) {
+            return packageName.match(/^@ts-dev-tools\/.*$/);
+        });
+        var sortPlugins = function (pluginA, pluginB) { return pluginA.localeCompare(pluginB); };
+        plugins.sort(sortPlugins);
+        return plugins;
+    };
+    PackageJson.prototype.getDependenciesPackageNames = function () {
+        var dependencies = this.getContent().dependencies;
+        return dependencies ? Object.keys(dependencies) : [];
+    };
+    PackageJson.prototype.getDevDependenciesPackageNames = function () {
+        var devDependencies = this.getContent().devDependencies;
+        return devDependencies ? Object.keys(devDependencies) : [];
+    };
+    PackageJson.prototype.getAllDependenciesPackageNames = function () {
+        return Array.from(new Set(__spreadArray(__spreadArray([], this.getDependenciesPackageNames(), true), this.getDevDependenciesPackageNames(), true)));
+    };
+    PackageJson.prototype.merge = function (update) {
+        this.content = PackageJsonMerge_1.PackageJsonMerge.merge(this.getContent(), update);
+        this.write();
+    };
+    PackageJson.prototype.backup = function () {
+        var backupPath = this.path + ".backup";
+        (0, fs_1.copyFileSync)(this.path, backupPath);
+        return backupPath;
+    };
+    PackageJson.prototype.restore = function (backupPath) {
+        (0, fs_1.copyFileSync)(backupPath, this.path);
+        this.content = undefined;
+    };
+    PackageJson.prototype.write = function () {
+        (0, fs_1.writeFileSync)(this.path, JSON.stringify(this.content, null, 2));
+    };
+    PackageJson.fromDirPath = function (dirPath) {
+        var packageJsonPath = (0, path_1.join)(dirPath, "package.json");
+        if (!(0, fs_1.existsSync)(packageJsonPath)) {
+            throw new Error("No package.json found in directory \"".concat(dirPath, "\""));
+        }
+        return new PackageJson(packageJsonPath);
+    };
+    return PackageJson;
+}());
+exports.PackageJson = PackageJson;

package/dist/services/PackageJsonMerge.d.ts

@@ -0,0 +1,8 @@
+import { PackageJsonContent } from "./PackageJson";
+export declare class PackageJsonMerge {
+    static merge(source: PackageJsonContent, update: PackageJsonContent): PackageJsonContent;
+    private static mergeValues;
+    private static mergeObjects;
+    private static mergeArrays;
+    private static typesEqual;
+}

package/dist/services/PackageJsonMerge.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PackageJsonMerge = void 0;
+var PackageJsonMerge = /** @class */ (function () {
+    function PackageJsonMerge() {
+    }
+    PackageJsonMerge.merge = function (source, update) {
+        return PackageJsonMerge.mergeObjects(source, update);
+    };
+    PackageJsonMerge.mergeValues = function (source, update) {
+        if (source === undefined) {
+            return update;
+        }
+        if (!PackageJsonMerge.typesEqual(source, update)) {
+            throw new Error("Unable to merge package json value because types are different");
+        }
+        // Deal with arrays
+        if (Array.isArray(update)) {
+            return PackageJsonMerge.mergeArrays(source, update);
+        }
+        // Deal with objects
+        if (typeof update === "object") {
+            return PackageJsonMerge.mergeObjects(source, update);
+        }
+        return update;
+    };
+    PackageJsonMerge.mergeObjects = function (source, update) {
+        for (var updateKey in update) {
+            source[updateKey] = PackageJsonMerge.mergeValues(source[updateKey], update[updateKey]);
+        }
+        return source;
+    };
+    PackageJsonMerge.mergeArrays = function (source, update) {
+        for (var _i = 0, update_1 = update; _i < update_1.length; _i++) {
+            var item = update_1[_i];
+            if (!source.includes(item)) {
+                source.push(item);
+            }
+        }
+        return source;
+    };
+    PackageJsonMerge.typesEqual = function (sourceValue, updateValue) {
+        if (Array.isArray(sourceValue) && !Array.isArray(updateValue)) {
+            return false;
+        }
+        return typeof sourceValue === typeof updateValue;
+    };
+    return PackageJsonMerge;
+}());
+exports.PackageJsonMerge = PackageJsonMerge;

package/dist/services/PackageManagerService.d.ts

@@ -0,0 +1,7 @@
+export declare enum PackageManagerType {
+    yarn = "yarn",
+    npm = "npm"
+}
+export declare class PackageManagerService {
+    static detectPackageManager(dirPath: string): PackageManagerType;
+}

package/dist/services/PackageManagerService.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PackageManagerService = exports.PackageManagerType = void 0;
+var fs_1 = require("fs");
+var path_1 = require("path");
+var PackageManagerType;
+(function (PackageManagerType) {
+    PackageManagerType["yarn"] = "yarn";
+    PackageManagerType["npm"] = "npm";
+})(PackageManagerType = exports.PackageManagerType || (exports.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.npm;
+    };
+    return PackageManagerService;
+}());
+exports.PackageManagerService = PackageManagerService;

package/dist/tests/console.d.ts

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

package/dist/tests/console.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConsoleInfoContent = exports.resetMockedConsoleInfo = exports.mockConsoleInfo = void 0;
+var info = console.info;
+function mockConsoleInfo() {
+    console.info = jest.fn();
+}
+exports.mockConsoleInfo = mockConsoleInfo;
+function resetMockedConsoleInfo() {
+    console.info = info;
+}
+exports.resetMockedConsoleInfo = resetMockedConsoleInfo;
+function getConsoleInfoContent() {
+    var _a;
+    var calls = (_a = console.info) === null || _a === void 0 ? void 0 : _a.mock.calls;
+    return calls.flat().join("\n");
+}
+exports.getConsoleInfoContent = getConsoleInfoContent;

package/dist/tests/utils.d.ts

@@ -0,0 +1,5 @@
+export declare const testProjectDir: string;
+export declare function createTestProjectDir(filename: string): string;
+export declare function getTsDevToolsRootPath(filename: string): string;
+export declare function restorePackageJson(filename: string): void;
+export declare function removeTestProjectDir(filename: string): void;

package/dist/tests/utils.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeTestProjectDir = exports.restorePackageJson = exports.getTsDevToolsRootPath = exports.createTestProjectDir = exports.testProjectDir = void 0;
+var fs_1 = require("fs");
+var os_1 = require("os");
+var path_1 = require("path");
+exports.testProjectDir = (0, path_1.resolve)("__tests__/test-project");
+var getTestProjectDirPath = function (filename) {
+    return (0, path_1.join)((0, os_1.tmpdir)(), (0, path_1.basename)(filename).split(".")[0]);
+};
+var defaultPackageJsonPath = (0, path_1.join)(exports.testProjectDir, "package.json");
+function createTestProjectDir(filename) {
+    var testProjectDirPath = getTestProjectDirPath(filename);
+    if ((0, fs_1.existsSync)(testProjectDirPath)) {
+        deleteFolderRecursive(testProjectDirPath);
+    }
+    (0, fs_1.mkdirSync)(testProjectDirPath);
+    (0, fs_1.mkdirSync)((0, path_1.join)(testProjectDirPath, ".git/hooks"), { recursive: true });
+    // Fake node_modules
+    var tsDevToolsRootPath = getTsDevToolsRootPath(filename);
+    (0, fs_1.mkdirSync)(tsDevToolsRootPath, { recursive: true });
+    (0, fs_1.copyFileSync)((0, path_1.resolve)(__dirname, "../../package.json"), (0, path_1.join)(tsDevToolsRootPath, "package.json"));
+    // Fake migrations
+    var tsDevToolsDistPath = (0, path_1.join)(tsDevToolsRootPath, "dist");
+    (0, fs_1.symlinkSync)((0, path_1.resolve)(__dirname, ".."), tsDevToolsDistPath);
+    restorePackageJson(filename);
+    return testProjectDirPath;
+}
+exports.createTestProjectDir = createTestProjectDir;
+function getTsDevToolsRootPath(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");
+}
+exports.getTsDevToolsRootPath = getTsDevToolsRootPath;
+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"));
+}
+exports.restorePackageJson = restorePackageJson;
+function removeTestProjectDir(filename) {
+    var testProjectDirPath = getTestProjectDirPath(filename);
+    if (!(0, fs_1.existsSync)(testProjectDirPath)) {
+        throw new Error("Test project dir \"".concat(testProjectDirPath, "\" does not exist"));
+    }
+    deleteFolderRecursive(testProjectDirPath);
+}
+exports.removeTestProjectDir = removeTestProjectDir;
+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);
+            }
+            else {
+                // delete file
+                (0, fs_1.unlinkSync)(curPath);
+            }
+        });
+        (0, fs_1.rmdirSync)(path);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ts-dev-tools/core",
-  "version": "1.5.10",
+  "version": "1.5.14",
   "description": "TS dev tools Core",
   "keywords": [
     "linter",
@@ -41,26 +41,26 @@
     "url": "https://github.com/escemi-tech/ts-dev-tools/issues"
   },
   "dependencies": {
-    "@commitlint/cli": "^16.0.2",
+    "@commitlint/cli": "^16.1.0",
     "@commitlint/config-conventional": "^16.0.0",
     "@types/jest": "^27.4.0",
-    "@types/node": "^17.0.8",
-    "@typescript-eslint/eslint-plugin": "^5.9.1",
-    "@typescript-eslint/parser": "^5.9.1",
-    "eslint": "^8.6.0",
+    "@types/node": "^17.0.10",
+    "@typescript-eslint/eslint-plugin": "^5.10.0",
+    "@typescript-eslint/parser": "^5.10.0",
+    "eslint": "^8.7.0",
     "eslint-config-prettier": "^8.3.0",
     "eslint-plugin-import": "^2.25.4",
-    "eslint-plugin-jest": "^25.3.4",
+    "eslint-plugin-jest": "^25.7.0",
     "eslint-plugin-node": "^11.1.0",
     "eslint-plugin-promise": "^6.0.0",
     "import-sort-style-module": "^6.0.0",
     "jest": "^27.4.7",
-    "lint-staged": "^12.1.7",
+    "lint-staged": "^12.2.2",
     "prettier": "^2.5.1",
     "prettier-plugin-import-sort": "^0.0.7",
     "pretty-quick": "^3.1.3",
-    "ts-jest": "^27.1.2",
-    "typescript": "^4.5.4"
+    "ts-jest": "^27.1.3",
+    "typescript": "^4.5.5"
   },
   "devDependencies": {
     "pinst": "^2.1.6"
@@ -106,5 +106,5 @@
       "**/?(*.)+(spec|test).+(ts|tsx|js)"
     ]
   },
-  "gitHead": "275f1411aef5f77caf7fdd21f871f94bf9661bba"
+  "gitHead": "532cde30efabc0e8fe34350565d6cba2605a0919"
 }