@navikt/aksel 7.17.2 → 7.17.4

package/dist/darkside/config/token-regex.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCompositeTwRegex = createCompositeTwRegex;
+exports.createSingleTwRegex = createSingleTwRegex;
+exports.getFrameworkRegexes = getFrameworkRegexes;
+exports.getTokenRegex = getTokenRegex;
+const translate_token_1 = require("../../codemod/utils/translate-token");
+const createTwRegexForBreakpoints = (token) => new RegExp(`(?<!:)(?<=\\s|^)${token}:(?=\\w)`, "gm");
+function getFrameworkRegexes({ token, twString, legacy = false, }) {
+    const regexes = {
+        css: getTokenRegex(token, "css"),
+        scss: getTokenRegex(token, "scss"),
+        less: getTokenRegex(token, "less"),
+        /* New JS tokens dont have a prefix */
+        js: legacy
+            ? getTokenRegex(token, "js")
+            : getTokenRegex(token.replace("--ax-", ""), "js"),
+        tailwind: null,
+    };
+    if (!twString) {
+        return regexes;
+    }
+    const twTokens = twString.split(",");
+    if (token.includes("breakpoint")) {
+        /* We assume that breakpoint tw token only has a single declaration */
+        regexes.tailwind = createTwRegexForBreakpoints(twTokens[0]);
+    }
+    else {
+        regexes.tailwind = createCompositeTwRegex(twTokens);
+    }
+    return regexes;
+}
+function getTokenRegex(variable, format) {
+    switch (format) {
+        case "css":
+            return new RegExp(`(\\s|^)?(${variable})(?=\\s|$|[^\\w-])`, "gm");
+        case "scss":
+            return new RegExp(`(\\s|^)?(\\${(0, translate_token_1.translateToken)(variable, "scss")})(?=\\s|$|[^\\w-])`, "gm");
+        case "less":
+            return new RegExp(`(\\s|^)?(${(0, translate_token_1.translateToken)(variable, "less")})(?=\\s|$|[^\\w-])`, "gm");
+        case "js":
+            return new RegExp(`(\\s|^)?(${(0, translate_token_1.translateToken)(variable, "js")})(?=\\s|$|[^\\w-])`, "gm");
+    }
+}
+function createCompositeTwRegex(tokens) {
+    return new RegExp(`(?<!:)(\\s|^)?(${tokens.join("|")}|${tokens
+        .map((t) => `:${t}`)
+        .join("|")})(?=\\s|$|[^\\w-])`, "gm");
+}
+function createSingleTwRegex(token) {
+    return new RegExp(`(?<!:)(\\s|^)?(${token})(?=\\s|$|[^\\w-])`, "gm");
+}

package/dist/darkside/config/token.utils.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRoundedTwTags = generateRoundedTwTags;
+exports.generateBgTwTags = generateBgTwTags;
+function generateRoundedTwTags(name, addNewPrefix = false) {
+    const options = [
+        "s",
+        "e",
+        "t",
+        "r",
+        "b",
+        "l",
+        "ss",
+        "se",
+        "ee",
+        "es",
+        "tl",
+        "tr",
+        "br",
+        "bl",
+    ];
+    return `rounded-${name},${options
+        .map((option) => `rounded-${option}-${addNewPrefix ? "ax-" : ""}${name}`)
+        .join(",")}`;
+}
+function generateBgTwTags(name, addNewPrefix = false) {
+    const options = [
+        "bg",
+        "to",
+        "via",
+        "from",
+        "fill",
+        "text",
+        "caret",
+        "ring",
+        "divide",
+        "border",
+        "stroke",
+        "accent",
+        "shadow",
+        "outline",
+        "border-x",
+        "border-y",
+        "border-s",
+        "border-e",
+        "border-t",
+        "border-r",
+        "border-b",
+        "border-l",
+        "decoration",
+        "placeholder",
+        "ring-offset",
+    ];
+    return `${options
+        .map((option) => `${option}-${addNewPrefix ? "ax-" : ""}${name}`)
+        .join(",")}`;
+}

package/dist/darkside/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+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
+        .option("-g, --glob [glob]", "Globbing pattern, overrides --ext! Run with 'noglob' if using zsh-terminal. ")
+        .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");
+    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

@@ -0,0 +1,220 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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.runTooling = runTooling;
+const chalk_1 = __importDefault(require("chalk"));
+const enquirer_1 = __importDefault(require("enquirer"));
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const jscodeshift = __importStar(require("jscodeshift/src/Runner"));
+const path_1 = __importDefault(require("path"));
+const codeshift_utils_1 = require("../codemod/codeshift.utils");
+const validation_1 = require("../codemod/validation");
+const print_remaining_1 = require("./tasks/print-remaining");
+const status_1 = require("./tasks/status");
+// Constants
+const TRANSFORMS = {
+    "css-tokens": "./transforms/darkside-tokens-css",
+    "scss-tokens": "./transforms/darkside-tokens-scss",
+    "less-tokens": "./transforms/darkside-tokens-less",
+    "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;
+        // 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)], {
+            cwd: process.cwd(),
+            ignore: codeshift_utils_1.GLOB_IGNORE_PATTERNS,
+        });
+        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);
+        // Task execution loop
+        let task;
+        while ((task = yield getNextTask()) !== "exit") {
+            console.info("\n\n");
+            try {
+                yield executeTask(task, filepaths, options, program);
+            }
+            catch (error) {
+                program.error(chalk_1.default.red("Error:", error.message));
+            }
+        }
+        process.exit(0);
+    });
+}
+/**
+ * Executes the selected task
+ */
+function executeTask(task, filepaths, options, program) {
+    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;
+            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, {
+                    dryRun: options.dryRun,
+                    force: options.force,
+                });
+                break;
+            }
+            case "run-all-migrations": {
+                const tasks = [
+                    "css-tokens",
+                    "scss-tokens",
+                    "less-tokens",
+                    "js-tokens",
+                    "tailwind-tokens",
+                ];
+                for (const migrationTask of tasks) {
+                    if (!options.force) {
+                        (0, validation_1.validateGit)(options, program);
+                    }
+                    console.info(`\nRunning ${migrationTask}...`);
+                    yield runCodeshift(migrationTask, filepaths, {
+                        dryRun: options.dryRun,
+                        force: true,
+                    });
+                }
+                break;
+            }
+            default:
+                program.error(chalk_1.default.red(`Unknown task: ${task}`));
+        }
+    });
+}
+/**
+ * Filter files based on the selected task
+ */
+function getScopedFilesForTask(task, filepaths, status) {
+    return filepaths.filter((f) => {
+        switch (task) {
+            case "css-tokens":
+                return !!status.css.legacy.find((config) => config.fileName === f);
+            case "scss-tokens":
+                return !!status.scss.legacy.find((config) => config.fileName === f);
+            case "less-tokens":
+                return !!status.less.legacy.find((config) => config.fileName === f);
+            case "js-tokens":
+                return !!status.js.legacy.find((config) => config.fileName === f);
+            case "tailwind-tokens":
+                return !!status.tailwind.legacy.find((config) => config.fileName === f);
+            default:
+                return false;
+        }
+    });
+}
+/**
+ * Runs the jscodeshift codemod for the selected task
+ */
+function runCodeshift(task, filepaths, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!TRANSFORMS[task]) {
+            throw new Error(`No transform found for task: ${task}`);
+        }
+        const codemodPath = path_1.default.join(__dirname, `${TRANSFORMS[task]}.js`);
+        yield jscodeshift.run(codemodPath, filepaths, {
+            babel: true,
+            ignorePattern: codeshift_utils_1.GLOB_IGNORE_PATTERNS,
+            extensions: "tsx,ts,jsx,js",
+            parser: "tsx",
+            verbose: 2,
+            runInBand: true,
+            silent: false,
+            stdin: false,
+            dry: options === null || options === void 0 ? void 0 : options.dryRun,
+            force: options === null || options === void 0 ? void 0 : options.force,
+            print: false,
+        });
+    });
+}
+/**
+ * Prompts the user for the next task to run
+ */
+function getNextTask() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const response = yield enquirer_1.default.prompt([
+                Object.assign(Object.assign({}, TASK_MENU), { onCancel: () => process.exit(1) }),
+            ]);
+            return response.task;
+        }
+        catch (error) {
+            if (error.isTtyError) {
+                console.info("Oops, something went wrong! Looks like @navikt/aksel can't run in this terminal. " +
+                    "Contact Aksel for support if this persists, or try another terminal.");
+            }
+            else {
+                console.error(error);
+            }
+            process.exit(1);
+        }
+    });
+}

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

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printRemaining = printRemaining;
+const path_1 = __importDefault(require("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();
+        }
+        // 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 = path_1.default.resolve(process.cwd(), fileName);
+            const withComment = data.legacy.find((token) => {
+                return token.name === tokenName && token.comment;
+            });
+            if (withComment) {
+                console.info(`\n/* ${withComment.comment} */`);
+            }
+            console.info(`${tokenName}: file://${fullPath}:${lineNumber}:${columnNumber}`);
+        });
+        console.groupEnd();
+    });
+    console.info("\n");
+}

package/dist/darkside/tasks/status.js

@@ -0,0 +1,122 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStatus = getStatus;
+const cli_progress_1 = __importDefault(require("cli-progress"));
+const fs_1 = __importDefault(require("fs"));
+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
+ */
+function getStatus(files, action = "print") {
+    const progressBar = new cli_progress_1.default.SingleBar({
+        clearOnComplete: true,
+        hideCursor: true,
+        format: "{bar} | {value}/{total} | {fileName}",
+    }, cli_progress_1.default.Presets.shades_classic);
+    if (action === "print") {
+        progressBar.start(files.length, 0);
+    }
+    StatusStore.initStatus();
+    files.forEach((fileName, index) => {
+        const fileSrc = fs_1.default.readFileSync(fileName, "utf8");
+        /**
+         * 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)) {
+                continue;
+            }
+            for (const [regexKey, regex] of Object.entries(config.regexes)) {
+                if (!regex) {
+                    continue;
+                }
+                let match;
+                while ((match = regex.exec(fileSrc))) {
+                    const { row, column } = getWordPositionInFile(fileSrc, match.index);
+                    StatusStore.add({
+                        isLegacy: true,
+                        comment: config.comment,
+                        type: regexKey,
+                        columnNumber: column,
+                        lineNumber: row,
+                        canAutoMigrate: regexKey === "tailwind"
+                            ? !!config.twNew
+                            : config.replacement.length > 0,
+                        fileName,
+                        name: match[0],
+                    });
+                }
+            }
+        }
+        const legacyRegex = new RegExp(`(${legacy_component_tokens_1.legacyComponentTokenList.map((t) => `${t}:`).join("|")})`, "gm");
+        let legacyMatch;
+        while ((legacyMatch = legacyRegex.exec(fileSrc)) !== null) {
+            const { row, column } = getWordPositionInFile(fileSrc, legacyMatch.index);
+            StatusStore.add({
+                isLegacy: true,
+                type: "component",
+                columnNumber: column,
+                lineNumber: row,
+                canAutoMigrate: false,
+                fileName,
+                name: legacyMatch[0],
+            });
+        }
+        for (const [newTokenName, config] of Object.entries(darkside_tokens_1.darksideTokenConfig)) {
+            if (!(0, token_regex_1.getTokenRegex)(newTokenName, "css").test(fileSrc)) {
+                continue;
+            }
+            for (const [regexKey, regex] of Object.entries(config.regexes)) {
+                if (!regex) {
+                    continue;
+                }
+                let match;
+                while ((match = regex.exec(fileSrc))) {
+                    const { row, column } = getWordPositionInFile(fileSrc, match.index);
+                    StatusStore.add({
+                        isLegacy: false,
+                        type: regexKey,
+                        columnNumber: column,
+                        lineNumber: row,
+                        fileName,
+                        name: match[0],
+                    });
+                }
+            }
+        }
+        if (action === "print") {
+            progressBar.update(index + 1, { fileName });
+        }
+    });
+    if (action === "no-print") {
+        return StatusStore;
+    }
+    progressBar.stop();
+    StatusStore.printStatus("summary");
+    StatusStore.printStatusForAll();
+    StatusStore.printMigrationHelp();
+    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 };
+        }
+        charCount += lineLength;
+        lineNumber++;
+    }
+    return { row: lineNumber, column: 0 }; // Should not reach here if the index is within the file content range
+}

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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}`);
+        }
+    }
+    return src;
+}

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

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = transformer;
+const imports_1 = require("../../codemod/utils/imports");
+const lineterminator_1 = require("../../codemod/utils/lineterminator");
+const moveAndRenameImport_1 = __importDefault(require("../../codemod/utils/moveAndRenameImport"));
+const translate_token_1 = require("../../codemod/utils/translate-token");
+const legacy_tokens_1 = require("../config/legacy.tokens");
+function transformer(file, api) {
+    let src = file.source;
+    const j = api.jscodeshift;
+    let root = j(file.source);
+    const jsImport = root.find(j.ImportDeclaration).filter((x) => {
+        return ["@navikt/ds-tokens/dist/tokens"].includes(x.node.source.value);
+    });
+    if (jsImport.size() === 0) {
+        return src;
+    }
+    for (const [oldToken, config] of Object.entries(legacy_tokens_1.legacyTokenConfig)) {
+        const oldCSSVar = `--a-${oldToken}`;
+        const oldJsVar = (0, translate_token_1.translateToken)(oldCSSVar, "js");
+        let foundName = null;
+        (0, imports_1.getImportSpecifier)(j, root, oldJsVar, "@navikt/ds-tokens/dist/tokens").forEach((x) => {
+            foundName = x.node.imported.name;
+        });
+        if (!foundName) {
+            continue;
+        }
+        if (config.replacement.length > 0) {
+            /* We remove the prefix */
+            const jsToken = (0, translate_token_1.translateToken)(`--ax-${config.replacement}`, "js").slice(2);
+            const localName = (0, moveAndRenameImport_1.default)(j, root, {
+                fromImport: "@navikt/ds-tokens/dist/tokens",
+                toImport: "@navikt/ds-tokens/darkside-js",
+                fromName: foundName,
+                toName: jsToken,
+                ignoreAlias: true,
+            });
+            let code = root.toSource((0, lineterminator_1.getLineTerminator)(src));
+            const rgx = new RegExp(`(\\s|^)?(${localName})(?=\\s|$|[^\\w-])`, "gm");
+            code = code.replace(rgx, jsToken);
+            src = code;
+            root = j(code);
+            continue;
+        }
+    }
+    return root.toSource((0, lineterminator_1.getLineTerminator)(src));
+}

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = transformer;
+const translate_token_1 = require("../../codemod/utils/translate-token");
+const legacy_tokens_1 = require("../config/legacy.tokens");
+function transformer(file) {
+    let src = file.source;
+    for (const config of Object.values(legacy_tokens_1.legacyTokenConfig)) {
+        if (config.replacement.length > 0) {
+            src = src.replace(config.regexes.less, (0, translate_token_1.translateToken)(`--ax-${config.replacement}`, "less"));
+        }
+    }
+    return src;
+}

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = transformer;
+const translate_token_1 = require("../../codemod/utils/translate-token");
+const legacy_tokens_1 = require("../config/legacy.tokens");
+function transformer(file) {
+    let src = file.source;
+    for (const config of Object.values(legacy_tokens_1.legacyTokenConfig)) {
+        if (config.replacement.length > 0) {
+            src = src.replace(config.regexes.scss, (0, translate_token_1.translateToken)(`--ax-${config.replacement}`, "scss"));
+        }
+    }
+    return src;
+}

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

@@ -0,0 +1,33 @@
+"use strict";
+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) {
+            continue;
+        }
+        const isBreakpoint = name.includes("breakpoint");
+        if (isBreakpoint) {
+            src = src.replace(config.regexes.tailwind, `${config.twNew}:`);
+            continue;
+        }
+        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(":", ""));
+            if (index >= 0) {
+                const withPrefix = match.trim().startsWith(":");
+                const addSpace = match.startsWith(" ");
+                const replacementToken = afterSplit[index];
+                src = src.replace((0, token_regex_1.createSingleTwRegex)(match), withPrefix
+                    ? `:${replacementToken}`
+                    : `${addSpace ? " " : ""}${replacementToken}`);
+            }
+        }
+    }
+    return src;
+}