@navikt/aksel 7.35.0 → 7.35.1

package/dist/codemod/codeshift.utils.js

@@ -17,7 +17,15 @@ exports.GLOB_IGNORE_PATTERNS = GLOB_IGNORE_PATTERNS;
  */
 function getDefaultGlob(ext) {
     const defaultExt = "js,ts,jsx,tsx,css,scss,less";
-    return `**/*.{${cleanExtensions(ext !== null && ext !== void 0 ? ext : defaultExt).join(",")}}`;
+    const extensions = cleanExtensions(ext !== null && ext !== void 0 ? ext : defaultExt);
+    /**
+     * Single-item braces are treated as a literal string by some globbing libraries,
+     * so we only use them when there are multiple extensions
+     */
+    if (extensions.length > 1) {
+        return `**/*.{${extensions.join(",")}}`;
+    }
+    return `**/*.${extensions[0]}`;
 }
 /**
  * Utility function to clean file extensions

package/dist/codemod/run-codeshift.js

@@ -63,12 +63,23 @@ function runCodeshift(input, options, program) {
     return __awaiter(this, void 0, void 0, function* () {
         var _a;
         const codemodPath = node_path_1.default.join(__dirname, `./transforms/${(0, migrations_1.getMigrationPath)(input)}.js`);
-        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)], {
+        console.info(chalk_1.default.greenBright.bold("\nWelcome to Aksel codemods!"));
+        console.info("\nRunning migration:", chalk_1.default.green(input));
+        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`));
+        const filepaths = fast_glob_1.default.sync(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,
         });
-        console.info("\nRunning migration:", chalk_1.default.green("input"));
-        (options === null || options === void 0 ? void 0 : options.glob) && console.info(`Using glob: ${chalk_1.default.green(options.glob)}\n`);
         const warning = (0, migrations_1.getWarning)(input);
         const unsafeExtensions = (0, migrations_1.getIgnoredFileExtensions)(input);
         let safeFilepaths = filepaths;

package/dist/codemod/transforms/v8.0.0/box/box.js

@@ -33,15 +33,22 @@ function transformer(file, api) {
             },
         },
     });
+    const predefinedReplacents = predefinedReplacentset();
     const tokenComments = [];
     for (const astElement of astElements.paths()) {
         for (const prop of propsAffected) {
             (0, ast_1.findProps)({ j, path: astElement, name: prop }).forEach((attr) => {
                 const attrvalue = attr.value.value;
                 if (attrvalue.type === "StringLiteral") {
+                    /**
+                     * Skips if the replacement token already set
+                     */
+                    if (predefinedReplacents.has(addPrefix(attrvalue.value, prop))) {
+                        return;
+                    }
                     const config = legacy_tokens_1.legacyTokenConfig[attrvalue.value];
                     if (config === null || config === void 0 ? void 0 : config.replacement) {
-                        attrvalue.value = config.replacement;
+                        attrvalue.value = cleanReplacementToken(config.replacement, prop);
                     }
                     else {
                         const tokenComment = {
@@ -57,9 +64,15 @@ function transformer(file, api) {
                 else if (attrvalue.type === "JSXExpressionContainer" &&
                     attrvalue.expression.type === "StringLiteral") {
                     const literal = attrvalue.expression;
+                    /**
+                     * Skips if the replacement token already set
+                     */
+                    if (predefinedReplacents.has(addPrefix(literal.value, prop))) {
+                        return;
+                    }
                     const config = legacy_tokens_1.legacyTokenConfig[literal.value];
                     if (config === null || config === void 0 ? void 0 : config.replacement) {
-                        literal.value = config.replacement;
+                        literal.value = cleanReplacementToken(config.replacement, prop);
                     }
                     else {
                         const tokenComment = {
@@ -149,3 +162,38 @@ function convertBorderRadiusToRadius(oldValue) {
     }
     return newRadius.join(" ");
 }
+/**
+ * New props in Box do not have bg- or border- prefixes
+ * This function removes those prefixes from the tokens
+ */
+function cleanReplacementToken(token, type) {
+    if (type === "background") {
+        return token.replace("bg-", "");
+    }
+    if (type === "borderColor") {
+        return token.replace("border-", "");
+    }
+    return token;
+}
+/**
+ * Adds bg- or border- prefixes to tokens for comparison with existing replacements
+ */
+function addPrefix(token, type) {
+    if (type === "background") {
+        return `bg-${token}`;
+    }
+    if (type === "borderColor") {
+        return `border-${token}`;
+    }
+    return token;
+}
+function predefinedReplacentset() {
+    const set = new Set();
+    for (const key in legacy_tokens_1.legacyTokenConfig) {
+        const config = legacy_tokens_1.legacyTokenConfig[key];
+        if (config.replacement) {
+            set.add(config.replacement);
+        }
+    }
+    return set;
+}

package/dist/codemod/utils/ast.js

@@ -64,7 +64,7 @@ function findJSXElement(input) {
  */
 function findProps(input) {
     const { j, path, name } = input;
-    return j(path).find(j.JSXAttribute, {
+    return j(path.get("openingElement")).find(j.JSXAttribute, {
         name: {
             name,
         },

package/dist/darkside/index.js

@@ -6,23 +6,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.darksideCommand = darksideCommand;
 const chalk_1 = __importDefault(require("chalk"));
 const commander_1 = require("commander");
-const validation_js_1 = require("../codemod/validation.js");
-// import figlet from "figlet";
-// import { getMigrationString } from "./migrations.js";
 const run_tooling_js_1 = require("./run-tooling.js");
 const program = new commander_1.Command();
 function darksideCommand() {
-    program.name(`${chalk_1.default.blueBright(`npx @navikt/aksel`)}`);
+    program.name(`${chalk_1.default.blueBright(`npx @navikt/aksel v8-tokens`)}`);
     program
         .option("-g, --glob [glob]", "Globbing pattern, overrides --ext! Run with 'noglob' if using zsh-terminal. ")
+        .option("-e, --ext [ext]", "File extensions to include, defaults to 'js,ts,jsx,tsx,css,scss,less'")
         .option("-d, --dry-run", "Dry run, no changes will be made")
         .option("-f, --force", "Forcibly run updates without checking git-changes")
-        .description("Update tool for darkside token updates");
+        .description("Update tool for v8 token updates");
     program.parse();
     const options = program.opts();
-    /* Makes sure that you don't migrate lots of files while having other uncommitted changes */
-    if (!options.force) {
-        (0, validation_js_1.validateGit)(options, program);
-    }
     (0, run_tooling_js_1.runTooling)(options, program);
 }

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");
 }

package/dist/darkside/tasks/status.js

@@ -4,13 +4,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getStatus = getStatus;
+exports.getCharacterPositionInFile = getCharacterPositionInFile;
+exports.getLineStarts = getLineStarts;
 const cli_progress_1 = __importDefault(require("cli-progress"));
 const node_fs_1 = __importDefault(require("node:fs"));
+const translate_token_1 = require("../../codemod/utils/translate-token");
 const TokenStatus_1 = require("../config/TokenStatus");
 const darkside_tokens_1 = require("../config/darkside.tokens");
 const legacy_component_tokens_1 = require("../config/legacy-component.tokens");
 const legacy_tokens_1 = require("../config/legacy.tokens");
-const token_regex_1 = require("../config/token-regex");
 const StatusStore = new TokenStatus_1.TokenStatus();
 /**
  * Get the status of the tokens in the files
@@ -25,13 +27,57 @@ function getStatus(files, action = "print") {
         progressBar.start(files.length, 0);
     }
     StatusStore.initStatus();
+    /**
+     * Prepare search terms for legacy and darkside tokens.
+     * By pre-computing these sets, we save re-calculating them for each file,
+     * improving performance when processing large numbers of files.
+     */
+    const legacySearchTerms = getLegacySearchTerms();
+    const darksideSearchTerms = getDarksideSearchTerms();
+    const legacyComponentTokensSet = new Set(legacy_component_tokens_1.legacyComponentTokenList);
+    /**
+     * Pre-computed regex for legacy component tokens
+     */
+    const legacyRegex = new RegExp(`(${legacy_component_tokens_1.legacyComponentTokenList.map((t) => `${t}:`).join("|")})`, "gm");
+    /**
+     * Process each file to find and record token usages
+     */
     files.forEach((fileName, index) => {
         const fileSrc = node_fs_1.default.readFileSync(fileName, "utf8");
+        /**
+         * Create a set of all words in the file to quickly check for potential matches
+         */
+        const fileWords = new Set(fileSrc.match(/[a-zA-Z0-9_@$-]+/g) || []);
+        let lineStarts;
+        /**
+         * Gets line-start positions for the file, caching the result.
+         * We only calculate this if we actually find a token match, saving processing time.
+         */
+        const getLineStartsLazy = () => {
+            if (!lineStarts) {
+                lineStarts = getLineStarts(fileSrc);
+            }
+            return lineStarts;
+        };
         /**
          * We first parse trough all legacy tokens (--a-) prefixed tokens
          */
         for (const [legacyToken, config] of Object.entries(legacy_tokens_1.legacyTokenConfig)) {
-            if (!(0, token_regex_1.getTokenRegex)(legacyToken, "css").test(fileSrc)) {
+            const terms = legacySearchTerms.get(legacyToken);
+            /**
+             * Optimization: Check if any of the search terms exist in the file words set
+             * before running expensive regex operations.
+             */
+            let found = false;
+            if (terms) {
+                for (const term of terms) {
+                    if (fileWords.has(term)) {
+                        found = true;
+                        break;
+                    }
+                }
+            }
+            if (!found) {
                 continue;
             }
             for (const [regexKey, regex] of Object.entries(config.regexes)) {
@@ -40,7 +86,7 @@ function getStatus(files, action = "print") {
                 }
                 let match = regex.exec(fileSrc);
                 while (match) {
-                    const { row, column } = getWordPositionInFile(fileSrc, match.index);
+                    const { row, column } = getCharacterPositionInFile(match.index, getLineStartsLazy());
                     StatusStore.add({
                         isLegacy: true,
                         comment: config.comment,
@@ -57,23 +103,43 @@ function getStatus(files, action = "print") {
                 }
             }
         }
-        const legacyRegex = new RegExp(`(${legacy_component_tokens_1.legacyComponentTokenList.map((t) => `${t}:`).join("|")})`, "gm");
-        let legacyMatch = legacyRegex.exec(fileSrc);
-        while (legacyMatch !== null) {
-            const { row, column } = getWordPositionInFile(fileSrc, legacyMatch.index);
-            StatusStore.add({
-                isLegacy: true,
-                type: "component",
-                columnNumber: column,
-                lineNumber: row,
-                canAutoMigrate: false,
-                fileName,
-                name: legacyMatch[0],
-            });
-            legacyMatch = legacyRegex.exec(fileSrc);
+        let hasLegacyComponentToken = false;
+        for (const token of legacyComponentTokensSet) {
+            if (fileWords.has(token)) {
+                hasLegacyComponentToken = true;
+                break;
+            }
+        }
+        if (hasLegacyComponentToken) {
+            legacyRegex.lastIndex = 0;
+            let legacyMatch = legacyRegex.exec(fileSrc);
+            while (legacyMatch !== null) {
+                const { row, column } = getCharacterPositionInFile(legacyMatch.index, getLineStartsLazy());
+                StatusStore.add({
+                    isLegacy: true,
+                    type: "component",
+                    columnNumber: column,
+                    lineNumber: row,
+                    canAutoMigrate: false,
+                    fileName,
+                    name: legacyMatch[0],
+                });
+                legacyMatch = legacyRegex.exec(fileSrc);
+            }
         }
         for (const [newTokenName, config] of Object.entries(darkside_tokens_1.darksideTokenConfig)) {
-            if (!(0, token_regex_1.getTokenRegex)(newTokenName, "css").test(fileSrc)) {
+            const terms = darksideSearchTerms.get(newTokenName);
+            /* Optimization: Check if any of the search terms exist in the file words set */
+            let found = false;
+            if (terms) {
+                for (const term of terms) {
+                    if (fileWords.has(term)) {
+                        found = true;
+                        break;
+                    }
+                }
+            }
+            if (!found) {
                 continue;
             }
             for (const [regexKey, regex] of Object.entries(config.regexes)) {
@@ -82,7 +148,7 @@ function getStatus(files, action = "print") {
                 }
                 let match = regex.exec(fileSrc);
                 while (match) {
-                    const { row, column } = getWordPositionInFile(fileSrc, match.index);
+                    const { row, column } = getCharacterPositionInFile(match.index, getLineStartsLazy());
                     StatusStore.add({
                         isLegacy: false,
                         type: regexKey,
@@ -109,17 +175,68 @@ function getStatus(files, action = "print") {
     console.info("\n");
     return StatusStore;
 }
-function getWordPositionInFile(fileContent, index) {
-    const lines = fileContent.split("\n");
-    let lineNumber = 1;
-    let charCount = 0;
-    for (let i = 0; i < lines.length; i++) {
-        const lineLength = lines[i].length + 1; // +1 to account for the newline character that was removed by split
-        if (charCount + lineLength > index) {
-            return { row: lineNumber, column: index - charCount + 1 };
+function getLegacySearchTerms() {
+    const legacySearchTerms = new Map();
+    for (const [legacyToken, config] of Object.entries(legacy_tokens_1.legacyTokenConfig)) {
+        const terms = new Set();
+        const tokenName = `--a-${legacyToken}`;
+        terms.add(tokenName);
+        terms.add((0, translate_token_1.translateToken)(tokenName, "scss"));
+        terms.add((0, translate_token_1.translateToken)(tokenName, "less"));
+        terms.add((0, translate_token_1.translateToken)(tokenName, "js"));
+        if (config.twOld) {
+            config.twOld.split(",").forEach((t) => terms.add(t.trim()));
+        }
+        legacySearchTerms.set(legacyToken, terms);
+    }
+    return legacySearchTerms;
+}
+function getDarksideSearchTerms() {
+    const darksideSearchTerms = new Map();
+    for (const [newTokenName, config] of Object.entries(darkside_tokens_1.darksideTokenConfig)) {
+        const terms = new Set();
+        const tokenName = `--ax-${newTokenName}`;
+        terms.add(tokenName);
+        terms.add((0, translate_token_1.translateToken)(tokenName, "scss"));
+        terms.add((0, translate_token_1.translateToken)(tokenName, "less"));
+        terms.add((0, translate_token_1.translateToken)(newTokenName, "js"));
+        terms.add(newTokenName);
+        if (config.tw) {
+            config.tw.split(",").forEach((t) => terms.add(t.trim()));
+        }
+        darksideSearchTerms.set(newTokenName, terms);
+    }
+    return darksideSearchTerms;
+}
+/**
+ * Given the content of a file, returns an array of line start positions.
+ */
+function getLineStarts(content) {
+    const starts = [0];
+    let lineIndex = content.indexOf("\n", 0);
+    while (lineIndex !== -1) {
+        starts.push(lineIndex + 1);
+        lineIndex = content.indexOf("\n", lineIndex + 1);
+    }
+    return starts;
+}
+/**
+ * Given a character index and an array of line start positions,
+ * returns the corresponding row and column numbers.
+ */
+function getCharacterPositionInFile(index, lineStarts) {
+    let low = 0;
+    let high = lineStarts.length - 1;
+    let lineIndex = 0;
+    while (low <= high) {
+        const mid = (low + high) >>> 1;
+        if (lineStarts[mid] <= index) {
+            lineIndex = mid;
+            low = mid + 1;
+        }
+        else {
+            high = mid - 1;
         }
-        charCount += lineLength;
-        lineNumber++;
     }
-    return { row: lineNumber, column: 0 }; // Should not reach here if the index is within the file content range
+    return { row: lineIndex + 1, column: index - lineStarts[lineIndex] + 1 };
 }

package/dist/darkside/transforms/darkside-tokens-css.js

@@ -4,14 +4,29 @@ exports.default = transformer;
 const legacy_tokens_1 = require("../config/legacy.tokens");
 function transformer(file) {
     let src = file.source;
-    for (const [oldToken, config] of Object.entries(legacy_tokens_1.legacyTokenConfig)) {
-        const oldCSSVar = `--a-${oldToken}`;
-        /* We update all re-definitions of a token to a "legacy" version */
-        const replaceRegex = new RegExp("(" + `${oldCSSVar}:` + ")", "gm");
-        src = src.replace(replaceRegex, `--aksel-legacy${oldCSSVar.replace("--", "__")}:`);
-        if (config.replacement.length > 0) {
-            src = src.replace(config.regexes.css, `--ax-${config.replacement}`);
+    /*
+      1. Replace definitions: --a-token: -> --aksel-legacy__a-token:
+      Matches "--a-token" followed by optional whitespace and a colon.
+      Uses negative lookbehind to ensure we don't match "--not-a-token".
+    */
+    src = src.replace(/(?<![\w-])(--a-[\w-]+)(\s*:)/g, (match, tokenName, suffix) => {
+        const key = tokenName.replace("--a-", "");
+        if (legacy_tokens_1.legacyTokenConfig[key]) {
+            return `--aksel-legacy${tokenName.replace("--", "__")}${suffix}`;
         }
-    }
+        return match;
+    });
+    /*
+      2. Replace usages: --a-token -> --ax-replacement
+      Matches "--a-token" with word boundaries.
+    */
+    src = src.replace(/(?<![\w-])(--a-[\w-]+)(?![\w-])/g, (match, tokenName) => {
+        const key = tokenName.replace("--a-", "");
+        const config = legacy_tokens_1.legacyTokenConfig[key];
+        if (config === null || config === void 0 ? void 0 : config.replacement) {
+            return `--ax-${config.replacement}`;
+        }
+        return match;
+    });
     return src;
 }

package/dist/darkside/transforms/darkside-tokens-tailwind.js

@@ -2,11 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = transformer;
 const legacy_tokens_1 = require("../config/legacy.tokens");
-const token_regex_1 = require("../config/token-regex");
 function transformer(file) {
     let src = file.source;
     for (const [name, config] of Object.entries(legacy_tokens_1.legacyTokenConfig)) {
-        if (!config.twOld || !config.twNew) {
+        if (!config.twOld || !config.twNew || !config.regexes.tailwind) {
             continue;
         }
         const isBreakpoint = name.includes("breakpoint");
@@ -16,18 +15,18 @@ function transformer(file) {
         }
         const beforeSplit = config.twOld.split(",");
         const afterSplit = config.twNew.split(",");
-        const matches = src.match(config.regexes.tailwind) || [];
-        for (const match of matches) {
-            const index = beforeSplit.indexOf(match.trim().replace(":", ""));
+        src = src.replace(config.regexes.tailwind, (match) => {
+            const trimmed = match.trim();
+            const cleanToken = trimmed.replace(":", "");
+            const index = beforeSplit.indexOf(cleanToken);
             if (index >= 0) {
-                const withPrefix = match.trim().startsWith(":");
+                const withPrefix = trimmed.startsWith(":");
                 const addSpace = match.startsWith(" ");
                 const replacementToken = afterSplit[index];
-                src = src.replace((0, token_regex_1.createSingleTwRegex)(match), withPrefix
-                    ? `:${replacementToken}`
-                    : `${addSpace ? " " : ""}${replacementToken}`);
+                return `${addSpace ? " " : ""}${withPrefix ? ":" : ""}${replacementToken}`;
             }
-        }
+            return match;
+        });
     }
     return src;
 }

package/dist/index.js

@@ -14,6 +14,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const chalk_1 = __importDefault(require("chalk"));
+const commander_1 = require("commander");
 const node_fs_1 = __importDefault(require("node:fs"));
 const index_1 = require("./codemod/index");
 const darkside_1 = require("./darkside");
@@ -21,26 +22,24 @@ const help_1 = require("./help");
 run();
 function run() {
     return __awaiter(this, void 0, void 0, function* () {
-        if (!process.argv[2] || process.argv[2] === "help") {
+        const pkg = JSON.parse(node_fs_1.default.readFileSync("./package.json").toString()).version;
+        const program = new commander_1.Command();
+        program.version(pkg, "-v, --version");
+        program.allowUnknownOption().helpOption(false);
+        program.parse();
+        const args = program.args;
+        if (args.length === 0 || args[0] === "help") {
             (0, help_1.helpCommand)();
             return;
         }
-        /**
-         * Runs custom tooling for migrating to v8 tokens
-         */
-        if (process.argv[2] === "codemod" && process.argv[3] === "v8-tokens") {
-            (0, darkside_1.darksideCommand)();
-            return;
-        }
-        if (process.argv[2] === "codemod") {
+        if (args[0] === "codemod") {
+            if (args.includes("v8-tokens")) {
+                (0, darkside_1.darksideCommand)();
+                return;
+            }
             (0, index_1.codemodCommand)();
             return;
         }
-        if (process.argv[2] === "-v" || process.argv[2] === "--version") {
-            const pkg = JSON.parse(node_fs_1.default.readFileSync("./package.json").toString()).version;
-            console.info(pkg);
-            return;
-        }
-        console.info(chalk_1.default.red(`Unknown command: ${process.argv[2]}.\nRun ${chalk_1.default.cyan("npx @navikt/aksel help")} for all available commands.`));
+        console.info(chalk_1.default.red(`Unknown command: ${args[0]}.\nRun ${chalk_1.default.cyan("npx @navikt/aksel help")} for all available commands.`));
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@navikt/aksel",
-  "version": "7.35.0",
+  "version": "7.35.1",
   "description": "Aksel command line interface. Codemods and other utilities for Aksel users.",
   "author": "Aksel | Nav designsystem team",
   "license": "MIT",
@@ -32,11 +32,12 @@
     "url": "https://github.com/navikt/aksel/issues"
   },
   "dependencies": {
-    "@navikt/ds-css": "^7.35.0",
-    "@navikt/ds-tokens": "^7.35.0",
+    "@navikt/ds-css": "^7.35.1",
+    "@navikt/ds-tokens": "^7.35.1",
     "axios": "1.13.2",
-    "chalk": "4.1.0",
+    "chalk": "5.6.2",
     "cli-progress": "^3.12.0",
+    "clipboardy": "^5.0.0",
     "commander": "10.0.1",
     "enquirer": "^2.3.6",
     "fast-glob": "3.2.11",
@@ -55,7 +56,7 @@
   },
   "sideEffects": false,
   "engines": {
-    "node": ">=16.0.0"
+    "node": ">=20.0.0"
   },
   "publishConfig": {
     "access": "public",