@navikt/aksel 7.34.0 → 7.35.1

package/dist/darkside/run-tooling.js

@@ -63,50 +63,46 @@ const TRANSFORMS = {
     "js-tokens": "./transforms/darkside-tokens-js",
     "tailwind-tokens": "./transforms/darkside-tokens-tailwind",
 };
-const TASK_MENU = {
-    type: "select",
-    name: "task",
-    message: "Task",
-    initial: "status",
-    choices: [
-        { message: "Check status", name: "status" },
-        { message: "Print remaining tokens", name: "print-remaining-tokens" },
-        { message: "Migrate CSS tokens", name: "css-tokens" },
-        { message: "Migrate Scss tokens", name: "scss-tokens" },
-        { message: "Migrate Less tokens", name: "less-tokens" },
-        { message: "Migrate JS tokens", name: "js-tokens" },
-        { message: "Migrate tailwind tokens", name: "tailwind-tokens" },
-        { message: "Run all migrations", name: "run-all-migrations" },
-        { message: "Exit", name: "exit" },
-    ],
-};
 /**
  * Main entry point for the tooling system
  */
 function runTooling(options, program) {
     return __awaiter(this, void 0, void 0, function* () {
         var _a;
+        console.info(chalk_1.default.greenBright.bold("\nWelcome to the Aksel v8 token migration tool!"));
+        const globList = (_a = options.glob) !== null && _a !== void 0 ? _a : (0, codeshift_utils_1.getDefaultGlob)(options === null || options === void 0 ? void 0 : options.ext);
+        console.info(chalk_1.default.gray(`Using glob pattern(s): ${globList}\nWorking directory: ${process.cwd()}\n`));
         // Find matching files based on glob pattern
-        const filepaths = fast_glob_1.default.sync([(_a = options.glob) !== null && _a !== void 0 ? _a : (0, codeshift_utils_1.getDefaultGlob)(options === null || options === void 0 ? void 0 : options.ext)], {
+        const filepaths = yield (0, fast_glob_1.default)(globList, {
             cwd: process.cwd(),
             ignore: codeshift_utils_1.GLOB_IGNORE_PATTERNS,
+            /**
+             * When globbing, do not follow symlinks to avoid processing files outside the directory.
+             * This is most likely to happen in monorepos where node_modules may contain symlinks to packages
+             * in other parts of the repo.
+             *
+             * While node_modules is already ignored via GLOB_IGNORE_PATTERNS, if user globs upwards (e.g., using '../src/**'),
+             * that ignore-pattern may be ignored, leading to unintended file processing.
+             */
+            followSymbolicLinks: false,
         });
         if (options.dryRun) {
             console.info(chalk_1.default.yellow("Running in dry-run mode, no changes will be made"));
         }
         // Show initial status
-        (0, status_1.getStatus)(filepaths);
+        const initialStatus = (0, status_1.getStatus)(filepaths);
         // Task execution loop
-        let task = yield getNextTask();
+        let task = yield getNextTask(initialStatus.status);
+        let currentStatus = initialStatus;
         while (task !== "exit") {
             console.info("\n\n");
             try {
-                yield executeTask(task, filepaths, options, program);
+                currentStatus = yield executeTask(task, filepaths, options, program, currentStatus, () => (0, status_1.getStatus)(filepaths, "no-print"));
             }
             catch (error) {
                 program.error(chalk_1.default.red("Error:", error.message));
             }
-            task = yield getNextTask();
+            task = yield getNextTask(currentStatus.status);
         }
         process.exit(0);
     });
@@ -114,27 +110,34 @@ function runTooling(options, program) {
 /**
  * Executes the selected task
  */
-function executeTask(task, filepaths, options, program) {
+function executeTask(task, filepaths, options, program, statusStore, updateStatus) {
     return __awaiter(this, void 0, void 0, function* () {
         switch (task) {
             case "status":
-                (0, status_1.getStatus)(filepaths);
-                break;
-            case "print-remaining-tokens":
-                (0, print_remaining_1.printRemaining)(filepaths);
-                break;
+                return updateStatus();
+            case "print-remaining-tokens": {
+                const newStatus = updateStatus();
+                yield (0, print_remaining_1.printRemaining)(filepaths, newStatus.status);
+                return newStatus;
+            }
             case "css-tokens":
             case "scss-tokens":
             case "less-tokens":
             case "js-tokens":
             case "tailwind-tokens": {
-                const updatedStatus = (0, status_1.getStatus)(filepaths, "no-print").status;
-                const scopedFiles = getScopedFilesForTask(task, filepaths, updatedStatus);
-                yield runCodeshift(task, scopedFiles, {
+                if (!options.force) {
+                    (0, validation_1.validateGit)(options, program);
+                }
+                const scopedFiles = getScopedFilesForTask(task, filepaths, statusStore.status);
+                const tokensBefore = getTokenCount(statusStore.status, task);
+                const stats = yield runCodeshift(task, scopedFiles, {
                     dryRun: options.dryRun,
                     force: options.force,
                 });
-                break;
+                const newStatus = updateStatus();
+                const tokensAfter = getTokenCount(newStatus.status, task);
+                printSummary(task, stats, tokensBefore, tokensAfter);
+                return newStatus;
             }
             case "run-all-migrations": {
                 const tasks = [
@@ -144,20 +147,45 @@ function executeTask(task, filepaths, options, program) {
                     "js-tokens",
                     "tailwind-tokens",
                 ];
+                if (!options.force) {
+                    (0, validation_1.validateGit)(options, program);
+                }
+                let currentStatus = statusStore;
+                const summaryData = [];
                 for (const migrationTask of tasks) {
-                    if (!options.force) {
-                        (0, validation_1.validateGit)(options, program);
-                    }
                     console.info(`\nRunning ${migrationTask}...`);
-                    yield runCodeshift(migrationTask, filepaths, {
+                    const scopedFiles = getScopedFilesForTask(migrationTask, filepaths, currentStatus.status);
+                    const tokensBefore = getTokenCount(currentStatus.status, migrationTask);
+                    const stats = yield runCodeshift(migrationTask, scopedFiles, {
                         dryRun: options.dryRun,
                         force: true,
                     });
+                    currentStatus = updateStatus();
+                    const tokensAfter = getTokenCount(currentStatus.status, migrationTask);
+                    summaryData.push({
+                        task: migrationTask,
+                        stats,
+                        tokensBefore,
+                        tokensAfter,
+                    });
+                }
+                console.info(chalk_1.default.bold(`\nMigration Summary:`));
+                console.info("-".repeat(60));
+                for (const data of summaryData) {
+                    const replaced = data.tokensBefore - data.tokensAfter;
+                    const remaining = data.tokensAfter;
+                    const icon = remaining === 0 ? "✨" : "⚠️";
+                    console.info(`${chalk_1.default.bold(data.task)}:`);
+                    console.info(`  Files changed: ${data.stats.ok}`);
+                    console.info(`  Tokens replaced: ${replaced}`);
+                    console.info(`  ${icon} Remaining: ${remaining}`);
+                    console.info("");
                 }
-                break;
+                return currentStatus;
             }
             default:
                 program.error(chalk_1.default.red(`Unknown task: ${task}`));
+                return statusStore;
         }
     });
 }
@@ -201,7 +229,7 @@ function runCodeshift(task, filepaths, options) {
             throw new Error(`No transform found for task: ${task}`);
         }
         const codemodPath = node_path_1.default.join(__dirname, `${TRANSFORMS[task]}.js`);
-        yield jscodeshift.run(codemodPath, filepaths, {
+        return yield jscodeshift.run(codemodPath, filepaths, {
             babel: true,
             ignorePattern: codeshift_utils_1.GLOB_IGNORE_PATTERNS,
             parser: "tsx",
@@ -218,12 +246,52 @@ function runCodeshift(task, filepaths, options) {
 /**
  * Prompts the user for the next task to run
  */
-function getNextTask() {
+function getNextTask(status) {
     return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        const getMessage = (base, tokens) => {
+            if (!status)
+                return base;
+            const fileCount = new Set(tokens.map((t) => t.fileName)).size;
+            if (fileCount === 0)
+                return `${base} (Done)`;
+            return `${base} (${fileCount} files)`;
+        };
+        const choices = [
+            { message: "Check status", name: "status" },
+            { message: "Print status", name: "print-remaining-tokens" },
+            {
+                message: getMessage("Migrate CSS tokens", (_b = (_a = status === null || status === void 0 ? void 0 : status.css) === null || _a === void 0 ? void 0 : _a.legacy) !== null && _b !== void 0 ? _b : []),
+                name: "css-tokens",
+            },
+            {
+                message: getMessage("Migrate Scss tokens", (_d = (_c = status === null || status === void 0 ? void 0 : status.scss) === null || _c === void 0 ? void 0 : _c.legacy) !== null && _d !== void 0 ? _d : []),
+                name: "scss-tokens",
+            },
+            {
+                message: getMessage("Migrate Less tokens", (_f = (_e = status === null || status === void 0 ? void 0 : status.less) === null || _e === void 0 ? void 0 : _e.legacy) !== null && _f !== void 0 ? _f : []),
+                name: "less-tokens",
+            },
+            {
+                message: getMessage("Migrate JS tokens", (_h = (_g = status === null || status === void 0 ? void 0 : status.js) === null || _g === void 0 ? void 0 : _g.legacy) !== null && _h !== void 0 ? _h : []),
+                name: "js-tokens",
+            },
+            {
+                message: getMessage("Migrate tailwind tokens", (_k = (_j = status === null || status === void 0 ? void 0 : status.tailwind) === null || _j === void 0 ? void 0 : _j.legacy) !== null && _k !== void 0 ? _k : []),
+                name: "tailwind-tokens",
+            },
+            { message: "Run all migrations", name: "run-all-migrations" },
+            { message: "Exit", name: "exit" },
+        ];
         try {
-            const response = yield enquirer_1.default.prompt([
-                Object.assign(Object.assign({}, TASK_MENU), { onCancel: () => process.exit(1) }),
-            ]);
+            const response = yield enquirer_1.default.prompt({
+                type: "select",
+                name: "task",
+                message: "Task",
+                initial: "status",
+                choices,
+                onCancel: () => process.exit(1),
+            });
             return response.task;
         }
         catch (error) {
@@ -238,3 +306,31 @@ function getNextTask() {
         }
     });
 }
+function getTokenCount(status, task) {
+    switch (task) {
+        case "css-tokens":
+            return status.css.legacy.length;
+        case "scss-tokens":
+            return status.scss.legacy.length;
+        case "less-tokens":
+            return status.less.legacy.length;
+        case "js-tokens":
+            return status.js.legacy.length;
+        case "tailwind-tokens":
+            return status.tailwind.legacy.length;
+        default:
+            return 0;
+    }
+}
+function printSummary(task, stats, tokensBefore, tokensAfter) {
+    console.info(chalk_1.default.bold(`\nMigration Summary for ${task}:`));
+    console.info("-".repeat(40));
+    console.info(`✅ Files changed:    ${stats.ok}`);
+    console.info(`✅ Tokens replaced:  ${tokensBefore - tokensAfter}`);
+    if (tokensAfter > 0) {
+        console.info(chalk_1.default.yellow(`⚠️ Tokens remaining: ${tokensAfter} (manual intervention needed)`));
+    }
+    else {
+        console.info(chalk_1.default.green(`✨ Tokens remaining: ${tokensAfter}`));
+    }
+}

package/dist/darkside/tasks/print-remaining.js

@@ -1,51 +1,156 @@
 "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 __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.printRemaining = printRemaining;
+const clipboardy_1 = __importDefault(require("clipboardy"));
+const enquirer_1 = __importDefault(require("enquirer"));
 const node_path_1 = __importDefault(require("node:path"));
 const status_1 = require("./status");
-function printRemaining(files) {
-    process.stdout.write("\nAnalyzing...");
-    const statusObj = (0, status_1.getStatus)(files, "no-print").status;
-    Object.entries(statusObj).forEach(([tokenType, data]) => {
-        console.group(`\n${tokenType.toUpperCase()}:`);
-        const fileLinks = [];
-        data.legacy.forEach((tokenData) => {
-            fileLinks.push(`${tokenData.name.replace(":", "")}:${tokenData.fileName}:${tokenData.lineNumber}:${tokenData.columnNumber}`);
-        });
-        if (fileLinks.length === 0) {
-            console.info("Nothing to update.");
-            console.groupEnd();
+function printRemaining(files, status) {
+    return __awaiter(this, void 0, void 0, function* () {
+        process.stdout.write("\nAnalyzing...");
+        /**
+         * Skip re-calculating status if already provided
+         */
+        const statusObj = status !== null && status !== void 0 ? status : (0, status_1.getStatus)(files, "no-print").status;
+        /* Flatten all legacy tokens */
+        const allTokens = Object.values(statusObj).flatMap((data) => data.legacy);
+        if (allTokens.length === 0) {
+            console.info("\nNo legacy tokens found!");
+            return;
         }
-        // Ensure every string is unique
-        const uniqueFileLinks = Array.from(new Set(fileLinks));
-        // Sort the unique fileLinks based on fileName first, lineNumber second, and columnNumber third
-        uniqueFileLinks.sort((a, b) => {
-            const [fileA, lineA, columnA] = a.split(":");
-            const [fileB, lineB, columnB] = b.split(":");
-            if (fileA !== fileB) {
-                return fileA.localeCompare(fileB);
-            }
-            if (Number(lineA) !== Number(lineB)) {
-                return Number(lineA) - Number(lineB);
-            }
-            return Number(columnA) - Number(columnB);
-        });
-        // Print the unique and sorted fileLinks as clickable links with full path
-        uniqueFileLinks.forEach((link) => {
-            const [tokenName, fileName, lineNumber, columnNumber] = link.split(":");
-            const fullPath = node_path_1.default.resolve(process.cwd(), fileName);
-            const withComment = data.legacy.find((token) => {
-                return token.name === tokenName && token.comment;
+        const response = yield enquirer_1.default.prompt([
+            {
+                type: "select",
+                name: "groupBy",
+                message: "How would you like to group the remaining tokens?",
+                choices: [
+                    { message: "By File", name: "file" },
+                    { message: "By Token", name: "token" },
+                ],
+            },
+            {
+                type: "confirm",
+                name: "copy",
+                message: "Copy report to clipboard?",
+                initial: true,
+            },
+        ]);
+        const { groupBy, copy } = response;
+        console.info("\n");
+        const log = (str, indent = 0) => {
+            const prefix = "  ".repeat(indent);
+            console.info(prefix + str);
+        };
+        let jsonOutput;
+        /**
+         * Group by filename
+         */
+        if (groupBy === "file") {
+            const byFile = new Map();
+            allTokens.forEach((token) => {
+                if (!byFile.has(token.fileName)) {
+                    byFile.set(token.fileName, []);
+                }
+                byFile.get(token.fileName).push(token);
+            });
+            /* Sort files by number of tokens (descending) */
+            const sortedFiles = Array.from(byFile.entries()).sort((a, b) => b[1].length - a[1].length);
+            const fileOutput = [];
+            sortedFiles.forEach(([fileName, tokens]) => {
+                const fullPath = node_path_1.default.resolve(process.cwd(), fileName);
+                log(`${fileName} (${tokens.length} tokens)`);
+                /* Sort tokens in file by line number */
+                tokens.sort((a, b) => a.lineNumber - b.lineNumber);
+                const fileEntry = {
+                    file: fileName,
+                    fullPath,
+                    count: tokens.length,
+                    tokens: [],
+                };
+                tokens.forEach((token) => {
+                    if (token.comment) {
+                        log(`/* ${token.comment} */`, 1);
+                    }
+                    log(`${token.name}: ${fullPath}:${token.lineNumber}:${token.columnNumber}`, 1);
+                    fileEntry.tokens.push({
+                        name: token.name,
+                        line: token.lineNumber,
+                        column: token.columnNumber,
+                        comment: token.comment,
+                        link: `file://${fullPath}`,
+                    });
+                });
+                /* Empty line */
+                log("");
+                fileOutput.push(fileEntry);
             });
-            if (withComment) {
-                console.info(`\n/* ${withComment.comment} */`);
+            jsonOutput = fileOutput;
+        }
+        else {
+            /* Group by token name */
+            const byToken = new Map();
+            allTokens.forEach((token) => {
+                if (!byToken.has(token.name)) {
+                    byToken.set(token.name, []);
+                }
+                byToken.get(token.name).push(token);
+            });
+            /* Sort tokens by frequency (descending) */
+            const sortedTokens = Array.from(byToken.entries()).sort((a, b) => b[1].length - a[1].length);
+            const tokenOutput = [];
+            sortedTokens.forEach(([tokenName, tokens]) => {
+                var _a;
+                log(`${tokenName} (${tokens.length} occurrences)`);
+                /**
+                 * We can assume all comments are the same for a "tokenName"
+                 */
+                const foundComment = (_a = tokens.find((t) => t.comment)) === null || _a === void 0 ? void 0 : _a.comment;
+                if (foundComment) {
+                    log(`/* ${foundComment} */`, 1);
+                }
+                const tokenEntry = {
+                    token: tokenName,
+                    count: tokens.length,
+                    occurrences: [],
+                };
+                tokens.forEach((token) => {
+                    const fullPath = node_path_1.default.resolve(process.cwd(), token.fileName);
+                    log(`${fullPath}:${token.lineNumber}:${token.columnNumber}`, 1);
+                    tokenEntry.occurrences.push({
+                        file: token.fileName,
+                        fullPath,
+                        line: token.lineNumber,
+                        column: token.columnNumber,
+                        comment: token.comment,
+                        link: `file://${fullPath}`,
+                    });
+                });
+                /* Empty line */
+                log("");
+                tokenOutput.push(tokenEntry);
+            });
+            jsonOutput = tokenOutput;
+        }
+        if (copy) {
+            try {
+                clipboardy_1.default.writeSync(JSON.stringify(jsonOutput, null, 2));
+                console.info("✅ Report (JSON) copied to clipboard!");
             }
-            console.info(`${tokenName}: file://${fullPath}:${lineNumber}:${columnNumber}`);
-        });
-        console.groupEnd();
+            catch (error) {
+                console.error("❌ Failed to copy to clipboard:", error.message);
+            }
+        }
     });
-    console.info("\n");
 }