@ts-dev-tools/core 1.5.30 → 1.5.33

package/dist/install/command.js

@@ -39,36 +39,37 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.install = void 0;
 var fs_1 = require("fs");
 var path_1 = require("path");
-var CorePackageService_1 = require("../services/CorePackageService");
+var constants_1 = require("../constants");
 var DuplicateDependenciesService_1 = require("../services/DuplicateDependenciesService");
 var MigrationsService_1 = require("../services/MigrationsService");
 var PackageJson_1 = require("../services/PackageJson");
+var SymlinkDependenciesService_1 = require("../services/SymlinkDependenciesService");
 function install(_a) {
     var cwd = _a.cwd, _b = _a.dir, dir = _b === void 0 ? "." : _b;
     return __awaiter(this, void 0, void 0, function () {
-        var packageName, absoluteProjectDir, currentVersion;
+        var absoluteProjectDir, currentVersion;
         return __generator(this, function (_c) {
             switch (_c.label) {
                 case 0:
-                    packageName = CorePackageService_1.CorePackageService.getPackageName();
                     absoluteProjectDir = (0, path_1.resolve)(cwd, dir);
                     if (!(0, fs_1.existsSync)(absoluteProjectDir)) {
-                        throw new Error("Unable to install ".concat(packageName, " in given directory ").concat((0, path_1.join)(cwd, dir)));
+                        throw new Error("Unable to install ".concat(constants_1.PROJECT_NAME, " in given directory ").concat((0, path_1.join)(cwd, dir)));
                     }
                     if (!absoluteProjectDir.startsWith(cwd)) {
-                        throw new Error("Unable to install ".concat(packageName, " in a different folder than current process"));
+                        throw new Error("Unable to install ".concat(constants_1.PROJECT_NAME, " in a different folder than current process"));
                     }
                     currentVersion = PackageJson_1.PackageJson.fromDirPath(absoluteProjectDir).getTsDevToolsVersion();
                     if (currentVersion) {
-                        console.info("Updating ".concat(packageName, " installation..."));
+                        console.info("Updating ".concat(constants_1.PROJECT_NAME, " installation..."));
                     }
                     else {
-                        console.info("Installing ".concat(packageName, "..."));
+                        console.info("Installing ".concat(constants_1.PROJECT_NAME, "..."));
                     }
                     return [4 /*yield*/, MigrationsService_1.MigrationsService.executeMigrations(absoluteProjectDir, currentVersion)];
                 case 1:
                     _c.sent();
-                    DuplicateDependenciesService_1.DuplicateDependenciesService.duplicateDependencies(absoluteProjectDir);
+                    SymlinkDependenciesService_1.SymlinkDependenciesService.executeSymlinking(absoluteProjectDir);
+                    DuplicateDependenciesService_1.DuplicateDependenciesService.executeDeduplication(absoluteProjectDir);
                     console.info("Installation done!");
                     return [2 /*return*/];
             }

package/dist/install/migrations/20220617100200-prettier-cache.d.ts

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

package/dist/install/migrations/20220617100200-prettier-cache.js

@@ -0,0 +1,54 @@
+"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 PackageJson_1 = require("../../services/PackageJson");
+var up = function (absoluteProjectDir) { return __awaiter(void 0, void 0, void 0, function () {
+    var scripts, packageJson;
+    return __generator(this, function (_a) {
+        scripts = {
+            format: "prettier --cache --write '**/*.ts'",
+        };
+        packageJson = PackageJson_1.PackageJson.fromDirPath(absoluteProjectDir);
+        packageJson.merge({
+            scripts: scripts,
+        });
+        return [2 /*return*/];
+    });
+}); };
+exports.up = up;

package/dist/services/DuplicateDependenciesService.d.ts

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

package/dist/services/DuplicateDependenciesService.js

@@ -6,11 +6,11 @@ var PluginService_1 = require("./PluginService");
 var DuplicateDependenciesService = /** @class */ (function () {
     function DuplicateDependenciesService() {
     }
-    DuplicateDependenciesService.duplicateDependencies = function (absoluteProjectDir) {
+    DuplicateDependenciesService.executeDeduplication = function (absoluteProjectDir) {
         console.info("Checking for duplicate dev dependencies...");
         var duplicateDependencies = new Map();
         DuplicateDependenciesService.getProjectDuplicateDependencies(absoluteProjectDir, duplicateDependencies);
-        DuplicateDependenciesService.printDuplicateDependencies(duplicateDependencies);
+        DuplicateDependenciesService.printDuplicatedDependencies(duplicateDependencies);
         console.info("Check for duplicate dev dependencies done!");
     };
     DuplicateDependenciesService.getProjectDuplicateDependencies = function (absoluteProjectDir, duplicateDependencies) {
@@ -40,11 +40,11 @@ var DuplicateDependenciesService = /** @class */ (function () {
             }
         }
     };
-    DuplicateDependenciesService.printDuplicateDependencies = function (duplicateDependencies) {
+    DuplicateDependenciesService.printDuplicatedDependencies = 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"));
+                console.info("Some dev dependencies are unnecessarily installed as their are already required by \"".concat(plugin, "\":\n  - ").concat(pluginDuplicateDependenciesValue.join("\n  - "), "\n"));
             }
         });
     };

package/dist/services/MigrationsService.d.ts

@@ -1,10 +1,14 @@
 export declare type Migration = {
-    name: string;
+    fullname: string;
+    shortname: string;
     path: string;
 };
 export declare type MigrationUpFunction = (absoluteProjectDir: string) => Promise<void>;
 export declare class MigrationsService {
+    static MIGRATION_BUILT_PATH: string;
     static executeMigrations(absoluteProjectDir: string, currentVersion: string | undefined): Promise<void>;
     private static getAvailableMigrations;
     private static getPluginMigrations;
+    static getMigrationNameFromFile(migrationFile: string): string;
+    static migrationIsAfterCurrentVersion(migrationName: string, currentVersion?: string): boolean;
 }

package/dist/services/MigrationsService.js

@@ -61,7 +61,7 @@ var MigrationsService = /** @class */ (function () {
                     case 2:
                         if (!(_i < migrations_1.length)) return [3 /*break*/, 5];
                         migration = migrations_1[_i];
-                        console.info("Applying migration \"".concat(migration.name, "\"..."));
+                        console.info("Applying migration \"".concat(migration.fullname, "\"..."));
                         up = require(migration.path).up;
                         // Apply migration
                         return [4 /*yield*/, up(absoluteProjectDir)];
@@ -70,9 +70,9 @@ var MigrationsService = /** @class */ (function () {
                         _a.sent();
                         // Upgrade current version
                         PackageJson_1.PackageJson.fromDirPath(absoluteProjectDir).merge({
-                            tsDevTools: { version: migration.name },
+                            tsDevTools: { version: migration.shortname },
                         });
-                        console.info("Migration \"".concat(migration.name, "\" applied!"));
+                        console.info("Migration \"".concat(migration.fullname, "\" applied!"));
                         _a.label = 4;
                     case 4:
                         _i++;
@@ -98,34 +98,41 @@ var MigrationsService = /** @class */ (function () {
             migrationFiles.push.apply(migrationFiles, MigrationsService.getPluginMigrations(installedPlugin, currentVersion));
         }
         migrationFiles.sort(function (_a, _b) {
-            var nameA = _a.name;
-            var nameB = _b.name;
+            var nameA = _a.shortname;
+            var nameB = _b.shortname;
             return nameA.localeCompare(nameB);
         });
         return Array.from(new Set(migrationFiles));
     };
     MigrationsService.getPluginMigrations = function (plugin, currentVersion) {
-        // First retrieve migration of inherited plugins
-        var migrationFiles = MigrationsService.getAvailableMigrations(plugin.path, currentVersion);
-        // Then retrieve
-        var pluginMigrationsDirPath = (0, path_1.resolve)(plugin.path, "dist/install/migrations");
+        var migrationFiles = [];
+        var pluginMigrationsDirPath = (0, path_1.resolve)(plugin.path, MigrationsService.MIGRATION_BUILT_PATH);
         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)$/)) {
+            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;
+            var migrationName = MigrationsService.getMigrationNameFromFile(migrationFile);
+            var shouldApplyMigration = MigrationsService.migrationIsAfterCurrentVersion(migrationName, currentVersion);
             if (!shouldApplyMigration) {
                 continue;
             }
             migrationFiles.push({
-                name: migrationName,
+                shortname: migrationName,
+                fullname: "".concat(plugin.shortname, " - ").concat(migrationName),
                 path: (0, path_1.resolve)(pluginMigrationsDirPath, migrationFile),
             });
         }
         return migrationFiles;
     };
+    MigrationsService.getMigrationNameFromFile = function (migrationFile) {
+        var migrationName = migrationFile.split(".").slice(0, -1).join(".");
+        return migrationName;
+    };
+    MigrationsService.migrationIsAfterCurrentVersion = function (migrationName, currentVersion) {
+        return !currentVersion || currentVersion.localeCompare(migrationName) < 0;
+    };
+    MigrationsService.MIGRATION_BUILT_PATH = "dist/install/migrations";
     return MigrationsService;
 }());
 exports.MigrationsService = MigrationsService;

package/dist/services/PluginService.js

@@ -18,12 +18,23 @@ var PluginService = /** @class */ (function () {
         if (!allDependenciesPackageNames.length) {
             return [];
         }
-        var plugins = allDependenciesPackageNames.filter(function (packageName) {
+        var pluginsFullname = allDependenciesPackageNames.filter(function (packageName) {
             return PluginService.packageNameIsPlugin(packageName);
         });
         var sortPlugins = function (pluginA, pluginB) { return pluginA.localeCompare(pluginB); };
-        plugins.sort(sortPlugins);
-        return plugins.map(PluginService.getPluginFromFullname);
+        pluginsFullname.sort(sortPlugins);
+        var plugins = new Map();
+        for (var _i = 0, pluginsFullname_1 = pluginsFullname; _i < pluginsFullname_1.length; _i++) {
+            var pluginFullname = pluginsFullname_1[_i];
+            var plugin = PluginService.getPluginFromFullname(pluginFullname);
+            plugins.set(pluginFullname, plugin);
+            var pluginParents = PluginService.getInstalledPlugins(plugin.path);
+            for (var _a = 0, pluginParents_1 = pluginParents; _a < pluginParents_1.length; _a++) {
+                var pluginParent = pluginParents_1[_a];
+                plugins.set(pluginParent.fullname, pluginParent);
+            }
+        }
+        return Array.from(plugins.values());
     };
     PluginService.getPluginShortname = function (fullname) {
         var shortname = fullname.replace("".concat(constants_1.PACKAGE_BASE_NAME, "/"), "");

package/dist/services/SymlinkDependenciesService.d.ts

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

package/dist/services/SymlinkDependenciesService.js

@@ -0,0 +1,46 @@
+"use strict";
+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 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!");
+    };
+    SymlinkDependenciesService.symlinkPluginDependencies = function (absoluteProjectDir, plugin) {
+        var pluginDependencies = SymlinkDependenciesService.getPluginDependencies(plugin);
+        for (var _i = 0, pluginDependencies_1 = pluginDependencies; _i < pluginDependencies_1.length; _i++) {
+            var pluginDependency = pluginDependencies_1[_i];
+            var pluginDependencyPath = (0, path_1.join)(plugin.path, SymlinkDependenciesService.DEPENDENCIES_FOLDER, pluginDependency);
+            if (!(0, fs_1.existsSync)(pluginDependencyPath)) {
+                continue;
+            }
+            var projectPluginDependencyPath = (0, path_1.join)(absoluteProjectDir, SymlinkDependenciesService.DEPENDENCIES_FOLDER, pluginDependency);
+            if ((0, fs_1.existsSync)(projectPluginDependencyPath)) {
+                continue;
+            }
+            console.info("- Symlinking ".concat(pluginDependency));
+            SymlinkDependenciesService.symlinkDependency(pluginDependencyPath, projectPluginDependencyPath);
+        }
+    };
+    SymlinkDependenciesService.getPluginDependencies = function (plugin) {
+        var pluginPackageJson = PackageJson_1.PackageJson.fromDirPath(plugin.path);
+        return pluginPackageJson.getDependenciesPackageNames();
+    };
+    SymlinkDependenciesService.symlinkDependency = function (pluginDependencyPath, projectPluginDependencyPath) {
+        (0, fs_1.symlinkSync)(pluginDependencyPath, projectPluginDependencyPath);
+    };
+    SymlinkDependenciesService.DEPENDENCIES_FOLDER = "node_modules";
+    return SymlinkDependenciesService;
+}());
+exports.SymlinkDependenciesService = SymlinkDependenciesService;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ts-dev-tools/core",
-  "version": "1.5.30",
+  "version": "1.5.33",
   "description": "TS dev tools Core",
   "keywords": [
     "linter",
@@ -44,26 +44,26 @@
     "url": "https://github.com/escemi-tech/ts-dev-tools/issues"
   },
   "dependencies": {
-    "@commitlint/cli": "^17.0.1",
-    "@commitlint/config-conventional": "^17.0.0",
-    "@types/jest": "^27.5.1",
-    "@types/node": "^17.0.36",
-    "@typescript-eslint/eslint-plugin": "^5.26.0",
-    "@typescript-eslint/parser": "^5.26.0",
-    "eslint": "^8.16.0",
+    "@commitlint/cli": "^17.0.3",
+    "@commitlint/config-conventional": "^17.0.3",
+    "@types/jest": "^28.1.6",
+    "@types/node": "^18.0.6",
+    "@typescript-eslint/eslint-plugin": "^5.30.7",
+    "@typescript-eslint/parser": "^5.30.7",
+    "eslint": "^8.20.0",
     "eslint-config-prettier": "^8.5.0",
     "eslint-plugin-import": "^2.26.0",
-    "eslint-plugin-jest": "^26.4.2",
+    "eslint-plugin-jest": "^26.6.0",
     "eslint-plugin-node": "^11.1.0",
     "eslint-plugin-promise": "^6.0.0",
     "import-sort-style-module": "^6.0.0",
-    "jest": "^28.1.0",
-    "lint-staged": "^12.4.2",
-    "prettier": "^2.6.2",
+    "jest": "^28.1.3",
+    "lint-staged": "^13.0.3",
+    "prettier": "^2.7.1",
     "prettier-plugin-import-sort": "^0.0.7",
     "pretty-quick": "^3.1.3",
-    "ts-jest": "^28.0.3",
-    "typescript": "^4.7.2"
+    "ts-jest": "^28.0.7",
+    "typescript": "^4.7.4"
   },
   "devDependencies": {
     "pinst": "^3.0.0"
@@ -116,5 +116,5 @@
       "github-actions"
     ]
   },
-  "gitHead": "31c4817cf54e93e2d02159b37e837209e175a51d"
+  "gitHead": "1c97067b6ad520879a21f15d8fce6ef964a579a3"
 }