anubis-ui 1.3.0 → 1.4.0

package/dist/tools/extraction/extractClasses.js

@@ -0,0 +1,134 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleVariations = exports.getExportedVariations = exports.init = void 0;
+const file_tools_1 = require("../fileStuff/file.tools");
+const mapClassIntoRule_1 = require("../mapping/mapClassIntoRule");
+const config_tool_1 = require("../config.tool");
+const mapColors_1 = require("../mapping/mapColors");
+const fs_1 = __importDefault(require("fs"));
+const css_output_1 = require("../output/css.output");
+const logger_1 = require("../logger");
+// Cache for regex compilation
+let cachedRegex = null;
+let cachedConfigHash = null;
+/** Fetch vue file based on config target patterns */
+const init = async () => {
+    const files = await (0, file_tools_1.getFiles)(config_tool_1.config.files);
+    const uniqueClasses = await getUniqueClasses(files);
+    const { rules, variationsFromRules } = (0, mapClassIntoRule_1.mapClassesIntoRules)(uniqueClasses);
+    const colors = `${css_output_1.comments.colors}\n${(0, mapColors_1.mapColorsIntoMixinDeclaration)(config_tool_1.config.colors)}`;
+    const skipVariations = false;
+    const variations = skipVariations ? '' : (0, exports.handleVariations)(variationsFromRules);
+    const wrappedRules = rules ? `${css_output_1.comments.rules}\n${rules}` : '';
+    const fileContent = `${(0, css_output_1.getHeader)()}\n${colors}\n\n${variations}\n\n${wrappedRules}`;
+    const file = (0, file_tools_1.writeFile)(file_tools_1.outputFile, fileContent);
+    return file;
+};
+exports.init = init;
+/** Extract detected class and map into a flat set */
+const getUniqueClasses = async (files) => {
+    /** Find matching classes from a given file based on config states and prefixes */
+    const extractClasses = async (filePath) => {
+        const file = await fs_1.default.promises.readFile(filePath, 'utf-8');
+        if (!file) {
+            return [];
+        }
+        const classDetectionRegex = getClassDetectionRegex();
+        const matches = file.match(classDetectionRegex) || [];
+        return matches;
+    };
+    const extractedClasses = (await (0, file_tools_1.pLimit)(files, extractClasses)).flat();
+    const exportedClasses = getExportedClasses();
+    const classes = [
+        ...extractedClasses,
+        ...exportedClasses,
+        ...config_tool_1.config.force,
+    ].sort();
+    const uniqueClasses = Array.from(new Set(classes));
+    return uniqueClasses;
+};
+/** Build regex pattern from config */
+const buildClassDetectionRegex = () => {
+    var _a, _b;
+    const { states, utilities } = config_tool_1.config;
+    const partialUtilities = utilities === null || utilities === void 0 ? void 0 : utilities.map(u => {
+        const { prefix, variations: variationEntries, declaration } = u;
+        if (!prefix && !variationEntries) {
+            (0, logger_1.log)(`Something doesn't look good -> ${u}`);
+        }
+        const variations = Array.isArray(variationEntries) ? variationEntries : Object.keys(variationEntries || {});
+        const hasVariations = !!(variations === null || variations === void 0 ? void 0 : variations.length);
+        const hasDefaultVariation = hasVariations && variations.includes('default');
+        const needColor = declaration.includes('${color}');
+        /** If variation has default key and doesn't need color, can be used solo */
+        if (hasVariations && hasDefaultVariation && !needColor) {
+            return `${prefix}`;
+        }
+        return `${prefix}-`;
+    });
+    const mappedUtilities = (_a = [...partialUtilities]) === null || _a === void 0 ? void 0 : _a.join('|');
+    const mappedStates = `(${(_b = states === null || states === void 0 ? void 0 : states.map(s => `${s}:`)) === null || _b === void 0 ? void 0 : _b.join('|')})`;
+    const regexp = new RegExp(`${mappedStates}?(${mappedUtilities})(-?(\\w+(-+)?)+)?`, 'g');
+    return regexp;
+};
+/** Get cached regex or build a new one if config changed */
+const getClassDetectionRegex = () => {
+    const { states, utilities } = config_tool_1.config;
+    const configHash = JSON.stringify({ states, utilities });
+    if (cachedRegex && cachedConfigHash === configHash) {
+        return cachedRegex;
+    }
+    cachedRegex = buildClassDetectionRegex();
+    cachedConfigHash = configHash;
+    return cachedRegex;
+};
+/** Get all variations from utilities with export: "all" */
+const getExportedClasses = () => {
+    const possiblesClasses = [];
+    const utilities = [...config_tool_1.config.utilities];
+    const colors = Object.keys(config_tool_1.config.colors);
+    for (const utility of utilities) {
+        const exportValue = utility['export'];
+        /** export every possible colors variations */
+        if (exportValue === 'all') {
+            possiblesClasses.push(...colors.map(color => `${utility.prefix}-${color}`));
+        }
+    }
+    return possiblesClasses;
+};
+/** Get all variations from utilities with export: "variations" */
+const getExportedVariations = () => {
+    const exportAllVariations = {};
+    const utilities = [...config_tool_1.config.utilities];
+    for (const utility of utilities) {
+        const exportValue = utility['export'];
+        // Pour "variations", exporter toutes les variations
+        if (exportValue === 'variations' && utility.variations) {
+            for (const [variantName, variantValue] of Object.entries(utility.variations)) {
+                const variableName = `${utility.prefix}-${variantName}`;
+                exportAllVariations[variableName] = variantValue;
+            }
+        }
+    }
+    return exportAllVariations;
+};
+exports.getExportedVariations = getExportedVariations;
+const handleVariations = (extractedVariations) => {
+    const exportedVariations = (0, exports.getExportedVariations)();
+    const variations = {
+        ...extractedVariations,
+        ...exportedVariations
+    };
+    // Generate CSS variables for variations
+    const variationsCss = Object.entries(variations)
+        .map(([varName, varValue]) => `	--${varName}: ${varValue};`)
+        .join('\n');
+    const wrappedVariations = variationsCss
+        ? `${css_output_1.comments.variations}\n:root {\n${variationsCss}\n}`
+        : '';
+    return wrappedVariations;
+};
+exports.handleVariations = handleVariations;

package/dist/tools/fileStuff/config.file.d.ts

@@ -0,0 +1,5 @@
+declare let userConfig: any;
+declare const readUserConfigFile: () => any;
+/** Print a warning if the config file has unknow keys */
+declare const checkUserConfigFile: (configFile: string[]) => void;
+export { userConfig, readUserConfigFile, checkUserConfigFile };

package/dist/tools/fileStuff/config.file.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkUserConfigFile = exports.readUserConfigFile = exports.userConfig = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const logger_1 = require("../logger");
+const userConfigPath = path_1.default.join(process.cwd(), 'anubis.config.json');
+let userConfig = null;
+exports.userConfig = userConfig;
+const readUserConfigFile = () => {
+    const userConfigExists = fs_1.default.existsSync(userConfigPath);
+    if (!userConfigExists) {
+        (0, logger_1.log)('No user config file found, using default configuration.');
+        (0, logger_1.log)('---');
+        return;
+    }
+    const config = fs_1.default.readFileSync(userConfigPath, { encoding: 'utf-8' });
+    exports.userConfig = userConfig = JSON.parse(config);
+    return userConfig;
+};
+exports.readUserConfigFile = readUserConfigFile;
+/** Print a warning if the config file has unknow keys */
+const checkUserConfigFile = (configFile) => {
+    if (!userConfig) {
+        return;
+    }
+    // todo - also check values
+    const userConfigKeys = Object.keys(userConfig);
+    const unknownKeys = userConfigKeys === null || userConfigKeys === void 0 ? void 0 : userConfigKeys.filter(key => !configFile.includes(key) && key !== 'force');
+    if (!(unknownKeys === null || unknownKeys === void 0 ? void 0 : unknownKeys.length)) {
+        return;
+    }
+    (0, logger_1.log)(`${unknownKeys === null || unknownKeys === void 0 ? void 0 : unknownKeys.length} unknown config keys found in user config file`);
+    for (const key of unknownKeys) {
+        (0, logger_1.log)(`- ${key}`);
+    }
+};
+exports.checkUserConfigFile = checkUserConfigFile;

package/dist/tools/fileStuff/file.tools.d.ts

@@ -0,0 +1,19 @@
+import { IFileConfig } from '../../interfaces/files.interface';
+export declare const srcDir: string;
+export declare const outputDir: string;
+export declare const quasarFile = "quasar.variables.scss";
+export declare const outputFile = "_anubis.scss";
+export declare const tokensFile = "anubis/_tokens.scss";
+export declare const mixinsFile = "anubis/_mixins.scss";
+export declare const overridesFile = "anubis/_overrides.scss";
+export declare const checkOrCreateFile: (filePath: string) => boolean;
+export declare const getFiles: (routeConfig: IFileConfig) => Promise<string[]>;
+export declare const readFile: (fileName: string) => string;
+export declare const writeFile: (fileName: string, content: string) => string;
+/**
+ * Execute promises with concurrency limit
+ * @param items - Items to process
+ * @param fn - Async function to execute for each item
+ * @param limit - Maximum number of concurrent operations
+ */
+export declare const pLimit: <T, R>(items: T[], fn: (item: T) => Promise<R>, limit?: number) => Promise<R[]>;

package/dist/tools/fileStuff/file.tools.js

@@ -0,0 +1,88 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pLimit = exports.writeFile = exports.readFile = exports.getFiles = exports.checkOrCreateFile = exports.overridesFile = exports.mixinsFile = exports.tokensFile = exports.outputFile = exports.quasarFile = exports.outputDir = exports.srcDir = void 0;
+const fs_1 = __importDefault(require("fs"));
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const path_1 = __importDefault(require("path"));
+const logger_1 = require("../logger");
+exports.srcDir = path_1.default.join(process.cwd(), 'src', 'css');
+exports.outputDir = path_1.default.join(exports.srcDir, 'anubis');
+exports.quasarFile = 'quasar.variables.scss';
+exports.outputFile = '_anubis.scss';
+exports.tokensFile = 'anubis/_tokens.scss';
+exports.mixinsFile = 'anubis/_mixins.scss';
+exports.overridesFile = 'anubis/_overrides.scss';
+const checkOrCreateFile = (filePath) => {
+    try {
+        fs_1.default.mkdirSync(exports.outputDir, { recursive: true });
+        if (fs_1.default.existsSync(filePath)) {
+            return true;
+        }
+        (0, logger_1.log)(`Generating missing file ${filePath}`);
+        fs_1.default.writeFileSync(filePath, '');
+        return true;
+    }
+    catch (err) {
+        throw new Error(`Erreur lors de la vérification du fichier: ${err.message}`);
+    }
+};
+exports.checkOrCreateFile = checkOrCreateFile;
+const getFiles = async (routeConfig) => {
+    return await (0, fast_glob_1.default)(routeConfig.targets || '*.vue', {
+        absolute: true,
+        onlyFiles: true,
+        ignore: routeConfig.ignore || [],
+    });
+};
+exports.getFiles = getFiles;
+const readFile = (fileName) => {
+    const filePath = path_1.default.join(exports.srcDir, fileName);
+    (0, exports.checkOrCreateFile)(filePath);
+    return fs_1.default.readFileSync(filePath, { encoding: 'utf-8' });
+};
+exports.readFile = readFile;
+const writeFile = (fileName, content) => {
+    try {
+        const filePath = path_1.default.join(exports.srcDir, fileName);
+        (0, exports.checkOrCreateFile)(filePath);
+        fs_1.default.writeFileSync(filePath, content);
+        return filePath;
+    }
+    catch (err) {
+        throw new Error(`Erreur lors de l'écriture du fichier: ${err.message}`);
+    }
+};
+exports.writeFile = writeFile;
+// Performance optimization: limit concurrent file reads to avoid overwhelming the system
+const maxConcurrrentFiles = 10;
+/**
+ * Execute promises with concurrency limit
+ * @param items - Items to process
+ * @param fn - Async function to execute for each item
+ * @param limit - Maximum number of concurrent operations
+ */
+const pLimit = async (items, fn, limit = maxConcurrrentFiles) => {
+    const results = [];
+    let index = 0;
+    const executeNext = async () => {
+        if (index >= items.length)
+            return;
+        const currentIndex = index++;
+        const item = items[currentIndex];
+        const result = await fn(item);
+        results[currentIndex] = result;
+    };
+    const workers = Array(Math.min(limit, items.length))
+        .fill(null)
+        .map(async () => {
+        while (index < items.length) {
+            await executeNext();
+        }
+    });
+    await Promise.all(workers);
+    return results;
+};
+exports.pLimit = pLimit;

package/dist/tools/fileStuff/quasar-variables.file.d.ts

@@ -0,0 +1 @@
+export declare const init: () => void;

package/dist/tools/fileStuff/quasar-variables.file.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = void 0;
+const file_tools_1 = require("./file.tools");
+const init = () => {
+    var _a, _b, _c, _d, _e;
+    const currentFileContent = (0, file_tools_1.readFile)(file_tools_1.quasarFile);
+    const imports = (_d = (_c = (_b = (_a = [file_tools_1.overridesFile, file_tools_1.tokensFile]) === null || _a === void 0 ? void 0 : _a.filter(Boolean)) === null || _b === void 0 ? void 0 : _b.map(i => `@use "${i}";`)) === null || _c === void 0 ? void 0 : _c.filter(i => !currentFileContent.includes(i))) === null || _d === void 0 ? void 0 : _d.join('\n');
+    const newContent = (_e = `${imports}\n${currentFileContent}`) === null || _e === void 0 ? void 0 : _e.trim();
+    (0, file_tools_1.writeFile)(file_tools_1.quasarFile, newContent);
+};
+exports.init = init;

package/dist/tools/logger.d.ts

@@ -0,0 +1,5 @@
+export declare const logPrefix = "\u262F\uFE0E [ANUBIS]";
+export declare const log: (str: string) => void;
+export declare const logo: () => void;
+/** Execute a callback function and measure it's duration */
+export declare const measureDuration: (section: string, cb: () => any, linebreak?: boolean) => Promise<void>;

package/dist/tools/logger.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.measureDuration = exports.logo = exports.log = exports.logPrefix = void 0;
+const version_1 = require("../version");
+exports.logPrefix = '☯︎ [ANUBIS]';
+const log = (str) => console.log(`${exports.logPrefix} ${str}`);
+exports.log = log;
+const logo = () => {
+    (0, exports.log)('    ___    _   ____  ______  _________');
+    (0, exports.log)('   /   |  / | / / / / / __ )/  _/ ___/');
+    (0, exports.log)('  / /| | /  |/ / / / / __  |/ / \\__ \\');
+    (0, exports.log)(' / ___ |/ /|  / /_/ / /_/ // / ___/ /');
+    (0, exports.log)('/_/  |_/_/ |_/\\____/_____/___//____/');
+    (0, exports.log)('');
+    (0, exports.log)(`Welcome to Anubis v${version_1.version}`);
+    (0, exports.log)('Autonomous Nominative Utility Based Intuitive Styler');
+    (0, exports.log)('---');
+};
+exports.logo = logo;
+/** Execute a callback function and measure it's duration */
+const measureDuration = async (section, cb, linebreak = true) => {
+    console.time(`${exports.logPrefix} ${section} initialized in`);
+    await cb();
+    console.timeEnd(`${exports.logPrefix} ${section} initialized in`);
+    linebreak && (0, exports.log)('---');
+};
+exports.measureDuration = measureDuration;

package/dist/tools/main.d.ts

@@ -0,0 +1 @@
+export declare const init: () => Promise<void>;

package/dist/tools/main.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = void 0;
+const file_tools_1 = require("./fileStuff/file.tools");
+const logger_1 = require("./logger");
+const mapColors_1 = require("./mapping/mapColors");
+const mapUtilities_1 = require("./mapping/mapUtilities");
+const css_output_1 = require("./output/css.output");
+const { init: initClassExtraction } = require('./extraction/extractClasses');
+const { init: initConfig } = require('./config.tool');
+const { init: initQuasarVariables } = require('./fileStuff/quasar-variables.file');
+const init = async () => {
+    /** Extract and set global configurations */
+    await (0, logger_1.measureDuration)('Config', initConfig, false);
+    /**
+     * Write static mixins to designated file
+     * @output anubis/_mixins.scss
+     */
+    await (0, logger_1.measureDuration)('Mixins', initMixins, false);
+    /**
+     * Map every colors entries from the config into tokens
+     * @output anubis/_tokens.scss
+     *  */
+    await (0, logger_1.measureDuration)('Tokens', initTokens, false);
+    /**
+     * Map configured utilities overrides into a file
+     * @output anubis/_overrides.scss
+     */
+    await (0, logger_1.measureDuration)('Overrides', initOverrides, false);
+    /**
+     * Add imports to quasar.variables.scss file
+     * @imports tokens, overrides
+     * @output quasar.variables.scss
+     */
+    await (0, logger_1.measureDuration)('Quasar imports', initQuasarVariables, false);
+    /**
+     * Extract classes from the project to remap them into css declaration
+     * @output _anubis.scss
+     * */
+    await (0, logger_1.measureDuration)('Rules', initClassExtraction);
+    return;
+};
+exports.init = init;
+const initMixins = () => {
+    (0, file_tools_1.writeFile)(file_tools_1.mixinsFile, css_output_1.mixins);
+};
+const initTokens = () => {
+    const tokenizedColors = (0, mapColors_1.mapColorsIntoTokens)();
+    (0, file_tools_1.writeFile)(file_tools_1.tokensFile, tokenizedColors);
+};
+const initOverrides = () => {
+    const mappedOverrides = (0, mapUtilities_1.mapUtilitiesIntoOverride)();
+    (0, file_tools_1.writeFile)(file_tools_1.overridesFile, mappedOverrides);
+};

package/dist/tools/mapping/mapClassIntoRule.d.ts

@@ -0,0 +1,5 @@
+declare const mapClassesIntoRules: (classes: string[]) => {
+    rules: string;
+    variationsFromRules: Record<string, string>;
+};
+export { mapClassesIntoRules };

package/dist/tools/mapping/mapClassIntoRule.js

@@ -0,0 +1,256 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapClassesIntoRules = void 0;
+const config_tool_1 = require("../config.tool");
+const logger_1 = require("../logger");
+const mapClassesIntoRules = (classes) => {
+    const usedVariations = new Map();
+    const ruleInfos = classes
+        .map(cssClass => mapClassIntoRule(cssClass))
+        .filter(ruleInfo => ruleInfo !== null);
+    // Collecter les variations utilisés dans les règles générées
+    ruleInfos.forEach(ruleInfo => {
+        if (ruleInfo.variant && ruleInfo.variant.shouldExport) {
+            const variableName = `${ruleInfo.variant.prefix}-${ruleInfo.variant.variantName}`;
+            usedVariations.set(variableName, ruleInfo.variant.variantValue);
+        }
+    });
+    // Générer les règles CSS
+    const rules = generateCssRules(ruleInfos);
+    (0, logger_1.log)(`${ruleInfos.length} rules generated`);
+    return {
+        rules,
+        variationsFromRules: Object.fromEntries(usedVariations),
+    };
+};
+exports.mapClassesIntoRules = mapClassesIntoRules;
+const generateCssRules = (ruleInfos) => {
+    return ruleInfos
+        .map(ruleInfo => `.${ruleInfo.selector} { ${ruleInfo.declaration} }`)
+        .join('\n');
+};
+const mapClassIntoRule = (stringClass) => {
+    var _a, _b, _c, _d;
+    const params = getClassInfos(stringClass);
+    if (!params.utility) {
+        return null;
+    }
+    const needsColor = (_b = (_a = params.utility) === null || _a === void 0 ? void 0 : _a.declaration) === null || _b === void 0 ? void 0 : _b.includes('${color}');
+    const usesVariation = params.variationName;
+    const hasDefaultVariation = !((_c = params.utility) === null || _c === void 0 ? void 0 : _c.variations) || Object.keys(((_d = params.utility) === null || _d === void 0 ? void 0 : _d.variations) || []).includes('default');
+    /**
+     * If need color but doesn't have one or if need a variation but doesn't have one either
+     * this is a no go
+    */
+    if ((needsColor && !params.color) || (!hasDefaultVariation && !usesVariation)) {
+        return null;
+    }
+    const ruleInfo = buildRuleInfo(params);
+    return ruleInfo;
+};
+const getClassInfos = (stringClass) => {
+    const { cleanedClass, state } = getStateInfos(stringClass);
+    const { cleanedColor, prefix } = getPrefixInfos(cleanedClass);
+    const { color, baseColor, utility, variation, variationName } = getUtilityInfos({
+        cleanedColor,
+        prefix,
+    });
+    return {
+        state,
+        color,
+        baseColor,
+        prefix,
+        utility,
+        variation,
+        variationName,
+    };
+};
+const getStateInfos = (stringClass) => {
+    const state = config_tool_1.config.states.find(configState => stringClass.startsWith(configState));
+    const cleanedClass = state
+        ? stringClass.slice(state.length + 1)
+        : stringClass;
+    return {
+        cleanedClass,
+        state,
+    };
+};
+const getPrefixInfos = (stringClass) => {
+    const prefixes = [
+        ...config_tool_1.config.utilities.map(u => u.prefix)
+    ];
+    for (const prefix of prefixes) {
+        if (!stringClass.startsWith(prefix)) {
+            continue;
+        }
+        return {
+            cleanedColor: stringClass.slice(prefix.length + 1),
+            prefix,
+        };
+    }
+    (0, logger_1.log)(`No matching prefix found for class: ${stringClass}`);
+    return { cleanedColor: stringClass, prefix: null };
+};
+const getUtilityInfos = ({ cleanedColor, prefix, }) => {
+    /**
+     * Find utility variations matching the prefix from the config
+     * Since a prefix can be in multiple utilities, filter every matching prefixes
+     */
+    const possibleUtility = [...config_tool_1.config.utilities].filter(p => p.prefix === prefix);
+    if (!possibleUtility.length) {
+        return { matchingUtility: null, variation: null };
+    }
+    const { colorExists } = getColorInfos(cleanedColor);
+    const possibleUtilityVariations = possibleUtility.filter(({ variations }) => { var _a; return (_a = Object.keys(variations || {})) === null || _a === void 0 ? void 0 : _a.length; });
+    /**
+     * Find the utility where the variations exist
+     * Logic:
+     * 1. If
+     * 		OR we have a valid color
+     * 		OR no color specified
+     * 		OR no possible utilities have variation
+     *   Then use the first utility
+     * 2. Otherwise, find a utility with a matching variation
+     */
+    let matchingUtility;
+    if (colorExists || !cleanedColor || (possibleUtilityVariations === null || possibleUtilityVariations === void 0 ? void 0 : possibleUtilityVariations.length) <= 0) {
+        matchingUtility = possibleUtility[0];
+    }
+    else {
+        // Find utility with matching variation
+        matchingUtility = possibleUtilityVariations.find(({ variations }) => {
+            if (!variations)
+                return true;
+            const mappedVariations = Array.isArray(variations) ? variations : Object.keys(variations);
+            return mappedVariations.some(v => cleanedColor === v || cleanedColor.endsWith(v));
+        });
+    }
+    if (!matchingUtility) {
+        // log(`No utility found for ${cleanedColor || prefix}`);
+        return {
+            matchingUtility,
+            variation: null,
+        };
+    }
+    if (!colorExists && !matchingUtility.variations) {
+        // log(`Unknow stuff -> ${[prefix, cleanedColor].join('-')}`);
+        return {
+            matchingUtility,
+            variation: null,
+        };
+    }
+    const possibleVariations = matchingUtility.variations || { default: '' };
+    const defaultVariation = 'default';
+    /**
+     * Variation matching logic:
+     * 1. Check for exact match first (prevents "xl" matching when looking for "2xl")
+     * 2. Fall back to endsWith for edge cases where variation is a suffix
+     */
+    const exactVariation = Object.keys(possibleVariations).find(v => cleanedColor === v);
+    const closestVariation = Object.keys(possibleVariations).find(v => cleanedColor.endsWith(v));
+    const matchingVariation = exactVariation || closestVariation;
+    const variation = possibleVariations[matchingVariation || defaultVariation];
+    const color = matchingVariation
+        ? cleanedColor.slice(0, -matchingVariation.length - 1)
+        : cleanedColor;
+    const { baseColor } = getColorInfos(color);
+    return {
+        color,
+        baseColor,
+        utility: matchingUtility,
+        variationName: matchingVariation,
+        variation,
+    };
+};
+// Map state names to CSS pseudo-selectors
+const stateSelectors = {
+    hover: ':hover',
+    'not-hover': ':not(:hover)',
+};
+const buildRuleInfo = ({ state, prefix, color, baseColor, utility, variation, variationName, }) => {
+    // Get state selector from mapping
+    const stateSelector = state ? stateSelectors[state] || '' : '';
+    let selector = `${prefix}${color ? `-${color}` : ''}${variationName ? `-${variationName}` : ''}`;
+    if (state) {
+        selector = `${state}\\:${selector}${stateSelector}`;
+    }
+    // Vérifier que la couleur existe dans la config
+    if (baseColor && !config_tool_1.config.colors[baseColor]) {
+        (0, logger_1.log)(`Color '${baseColor}' not found in colors config - skipping rule generation`);
+        return null;
+    }
+    // Gérer les variations avec variables CSS ou valeurs directes
+    let variableToUse = variation;
+    let variantInfo = undefined;
+    // Vérifier si on doit exporter les variations en tant que variables CSS
+    const exportVariations = utility['export'];
+    const useVariables = exportVariations === 'variations' || exportVariations === 'all';
+    if (variationName && variationName !== 'default') {
+        const variablePrefix = prefix;
+        const variableName = `${variablePrefix}-${variationName}`;
+        // Si export-variations: true, utiliser une variable CSS, sinon la valeur directe
+        if (useVariables) {
+            variableToUse = `var(--${variableName})`;
+            variantInfo = {
+                prefix,
+                variantName: variationName,
+                variantValue: variation,
+                shouldExport: true,
+            };
+        }
+        else {
+            // Utiliser la valeur directe, pas de variable CSS
+            variableToUse = variation;
+        }
+    }
+    else if (variation && variationName === 'default') {
+        // Pour les variations par défaut
+        const variableName = `${prefix}-default`;
+        if (useVariables) {
+            variableToUse = `var(--${variableName})`;
+            variantInfo = {
+                prefix,
+                variantName: 'default',
+                variantValue: variation,
+                shouldExport: true,
+            };
+        }
+        else {
+            variableToUse = variation;
+        }
+    }
+    let declaration = utility.declaration
+        .replace('${value}', variableToUse)
+        .replace('${color}', color ? `var(--${color})` : '');
+    if (!declaration.endsWith(';')) {
+        declaration += ';';
+    }
+    if (!declaration.includes('!important')) {
+        declaration = declaration.replace(';', ' !important;');
+    }
+    return {
+        selector,
+        declaration,
+        color: color || undefined,
+        variant: variantInfo,
+    };
+};
+/**
+ * _ Check if a color includes opacity (ends with 2 digits)
+ * * Opacity is included in the color name during mixin declaration
+ * */
+// Cache regex outside function to avoid recompilation on every call
+const OPACITY_DETECTION_REGEX = /(?:(\w-?)+)-\d{2}$/; // Strings that end with two digits (e.g., primary-50)
+const OPACITY_SUFFIX_LENGTH = 3; // Length of "-NN" format
+const getColorInfos = (color) => {
+    const isOpacity = OPACITY_DETECTION_REGEX.test(color);
+    const baseColor = isOpacity
+        ? color.slice(0, -OPACITY_SUFFIX_LENGTH)
+        : color;
+    const colorExists = Object.keys(config_tool_1.config.colors).some(configColor => configColor === baseColor);
+    return {
+        colorExists,
+        isOpacity,
+        baseColor,
+    };
+};

package/dist/tools/mapping/mapColors.d.ts

@@ -0,0 +1,3 @@
+import { IColor } from "../../interfaces/color.interface";
+export declare const mapColorsIntoMixinDeclaration: (colors: IColor) => string;
+export declare const mapColorsIntoTokens: () => string;