anubis-ui 1.3.1 → 1.4.0

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;

package/dist/tools/mapping/mapColors.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapColorsIntoTokens = exports.mapColorsIntoMixinDeclaration = void 0;
+const css_output_1 = require("../output/css.output");
+const config_tool_1 = require("../config.tool");
+const mapColorsIntoMixinDeclaration = (colors) => {
+    var _a, _b;
+    const mappedColors = (_b = (_a = Object.entries(colors)) === null || _a === void 0 ? void 0 : _a.map(([colorName, { light, dark }]) => (0, css_output_1.defineColor)(colorName, light, dark))) === null || _b === void 0 ? void 0 : _b.join('\n');
+    return mappedColors;
+};
+exports.mapColorsIntoMixinDeclaration = mapColorsIntoMixinDeclaration;
+const mapColorsIntoTokens = () => {
+    var _a, _b;
+    const colors = config_tool_1.config.colors;
+    const tokenizedColors = (_b = (_a = Object.entries(colors)) === null || _a === void 0 ? void 0 : _a.map(([colorName, { light, dark }]) => (0, css_output_1.defineToken)(colorName, light, dark))) === null || _b === void 0 ? void 0 : _b.join('\n\n');
+    return tokenizedColors;
+};
+exports.mapColorsIntoTokens = mapColorsIntoTokens;

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

@@ -0,0 +1 @@
+export declare const mapUtilitiesIntoOverride: () => string;

package/dist/tools/mapping/mapUtilities.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapUtilitiesIntoOverride = void 0;
+const config_tool_1 = require("../config.tool");
+const mapUtilitiesIntoOverride = () => {
+    var _a, _b;
+    const utilities = (_a = [...config_tool_1.config.utilities]) === null || _a === void 0 ? void 0 : _a.filter(u => { var _a; return ((_a = u.overrides) === null || _a === void 0 ? void 0 : _a.length) >= 1; });
+    const overrides = (_b = utilities === null || utilities === void 0 ? void 0 : utilities.map(u => {
+        var _a, _b, _c;
+        const { variations, overrides } = u;
+        const defaultVariation = (_b = (_a = Object.entries(variations)) === null || _a === void 0 ? void 0 : _a.find(([key]) => key === 'default')) === null || _b === void 0 ? void 0 : _b[1];
+        const mappedOverrides = (_c = overrides === null || overrides === void 0 ? void 0 : overrides.map(o => `$${o}: ${defaultVariation};`)) === null || _c === void 0 ? void 0 : _c.join('\n');
+        return mappedOverrides;
+    })) === null || _b === void 0 ? void 0 : _b.join('\n');
+    return overrides;
+};
+exports.mapUtilitiesIntoOverride = mapUtilitiesIntoOverride;

package/dist/tools/output/css.output.d.ts

@@ -0,0 +1,11 @@
+export declare const mixins = "@use \"sass:color\";\n\n$background-opacity: (\n  10: 0.1,\n  20: 0.2,\n  30: 0.3,\n  40: 0.4,\n  50: 0.5,\n  60: 0.6,\n  70: 0.7,\n  80: 0.8,\n  90: 0.9\n);\n\n// Mixin that will automatically generate colors for light and/or dark themes (with opacity variations)\n@mixin setRootColors ($name, $lightColor: null, $darkColor: null) {\n  :root {\n    @if $lightColor != null {\n      body.body--light {\n        #{\"--\"+$name}: $lightColor;\n\n        // Only generate opacity variations for non transparent colors\n        @if $lightColor != transparent {\n          @each $opacity, $multiplier in $background-opacity {\n            #{\"--\"+$name+\"-\"+$opacity}: #{color.change($lightColor, $alpha: $multiplier)};\n          }\n        }\n      }\n    }\n\n    @if $darkColor != null {\n      body.body--dark {\n        #{\"--\"+$name}: $darkColor;\n\n        // Only generate opacity variations for non transparent colors\n        @if $darkColor != transparent {\n          @each $opacity, $multiplier in $background-opacity {\n            #{\"--\"+$name+\"-\"+$opacity}: #{color.change($darkColor, $alpha: $multiplier)};\n          }\n        }\n      }\n    }\n  }\n}\n";
+export declare const getHeader: () => string;
+export declare const comments: {
+    colors: string;
+    variations: string;
+    rules: string;
+};
+/** Map a colorName and hex into mixins function call */
+export declare const defineColor: (colorName: string, light?: string, dark?: string) => string;
+/** Map a color name and hex into token declaration for global usage */
+export declare const defineToken: (colorName: string, light?: string, dark?: string) => string;

package/dist/tools/output/css.output.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineToken = exports.defineColor = exports.comments = exports.getHeader = exports.mixins = void 0;
+const version_1 = require("../../version");
+const file_tools_1 = require("../fileStuff/file.tools");
+const header = `/**
+ * Anubis v.${version_1.version}
+ * Improba
+ * Released under the MIT License.
+ */
+@use "${file_tools_1.mixinsFile}";
+@use "${file_tools_1.tokensFile}";
+`;
+exports.mixins = `@use "sass:color";
+
+$background-opacity: (
+  10: 0.1,
+  20: 0.2,
+  30: 0.3,
+  40: 0.4,
+  50: 0.5,
+  60: 0.6,
+  70: 0.7,
+  80: 0.8,
+  90: 0.9
+);
+
+// Mixin that will automatically generate colors for light and/or dark themes (with opacity variations)
+@mixin setRootColors ($name, $lightColor: null, $darkColor: null) {
+  :root {
+    @if $lightColor != null {
+      body.body--light {
+        #{"--"+$name}: $lightColor;
+
+        // Only generate opacity variations for non transparent colors
+        @if $lightColor != transparent {
+          @each $opacity, $multiplier in $background-opacity {
+            #{"--"+$name+"-"+$opacity}: #{color.change($lightColor, $alpha: $multiplier)};
+          }
+        }
+      }
+    }
+
+    @if $darkColor != null {
+      body.body--dark {
+        #{"--"+$name}: $darkColor;
+
+        // Only generate opacity variations for non transparent colors
+        @if $darkColor != transparent {
+          @each $opacity, $multiplier in $background-opacity {
+            #{"--"+$name+"-"+$opacity}: #{color.change($darkColor, $alpha: $multiplier)};
+          }
+        }
+      }
+    }
+  }
+}
+`;
+const getHeader = () => {
+    return `${header}`;
+};
+exports.getHeader = getHeader;
+exports.comments = {
+    colors: `/**
+   * These colors will be mapped to css variables in
+   * the :root element on the html page.
+   *
+   * It allows you to write custom css/scss classes in your web
+   * components.
+   */`,
+    variations: `/**
+   * These css variables are generated automatically when Anubis
+   * detects that they are used in utilities in your config.
+   *
+   * It allows you to write custom css/scss classes in your web
+   * components like:
+   *
+   * .paragraph-small {
+   *    font-size: var(--size-xs);
+   *    font-weight: var(--weight-light);
+   * }
+   *
+   * (You can also force the generation of all variants from a
+   * utility by setting the 'export' to 'variations')
+   */`,
+    rules: `/**
+   * These are the css classes generated by Anubis based on your config
+   * and what was detected in your source files.
+   */`,
+};
+/** Map a colorName and hex into mixins function call */
+const defineColor = (colorName, light, dark) => {
+    var _a, _b;
+    const useToken = true;
+    const lightColor = useToken ? `$${colorName}` : light;
+    const darkColor = useToken ? `$${colorName}-dark` : dark;
+    // _ only dark
+    if (!light && dark) {
+        return `@include setRootColors('${colorName}', null, ${darkColor});`;
+    }
+    // _ light and/or dark
+    return `@include setRootColors('${colorName}', ${(_b = (_a = [lightColor, darkColor]) === null || _a === void 0 ? void 0 : _a.filter(Boolean)) === null || _b === void 0 ? void 0 : _b.join(', ')});`;
+};
+exports.defineColor = defineColor;
+/** Map a color name and hex into token declaration for global usage */
+const defineToken = (colorName, light, dark) => {
+    let tokens = [];
+    if (light) {
+        tokens.push(`$${colorName}: ${light};`);
+        tokens.push(`$${colorName}-light: ${light};`);
+    }
+    if (dark) {
+        tokens.push(`$${colorName}-dark: ${dark};`);
+    }
+    const stringifiedTokens = tokens === null || tokens === void 0 ? void 0 : tokens.join('\n');
+    return stringifiedTokens;
+};
+exports.defineToken = defineToken;

package/dist/tools/validation/color.validation.d.ts

@@ -0,0 +1,12 @@
+import { IColor } from '../../interfaces/color.interface';
+/**
+ * Validates a single color value (hex color or 'transparent')
+ */
+declare const isValidColorValue: (value: string) => boolean;
+/**
+ * Validates the colors configuration
+ * Ensures each color has at least one valid theme (light or dark)
+ * @throws Error if validation fails
+ */
+declare const validateColors: (colors: IColor) => void;
+export { validateColors, isValidColorValue };