anubis-ui 1.3.1 → 1.4.0

package/README.md

@@ -92,6 +92,8 @@ AnubisUI automatically generates the CSS classes you need, simply by using them
 - 🔍 Smart class detection and parsing
 - 📦 CSS variable generation for reusable values
 - ⚙️ Export variations as CSS variables for custom styling
+- 🎛️ SCSS tokens generation for global color access
+- 🔧 Quasar/global variable overrides from utility defaults
 
 # Installation
 
@@ -119,20 +121,27 @@ css: [
 ```
 <sup>quasar.config.js</sup>
 
-4. Colors are automatically defined from the configuration
+4. AnubisUI generates the following files automatically in `src/css/`:
+   - `_anubis.scss` - Main stylesheet with all generated rules
+   - `anubis/_mixins.scss` - SCSS mixins for color handling
+   - `anubis/_tokens.scss` - Color token variables (`$primary`, `$primary-dark`, etc.)
+   - `anubis/_overrides.scss` - Quasar variable overrides from utilities
+   - `quasar.variables.scss` - Auto-injected imports for tokens and overrides
+
+5. Colors are automatically defined from the configuration
    - AnubisUI generates CSS variables for all colors defined in `colors.config.json`
    - Colors support light/dark themes automatically
    - Each color is exposed as a CSS variable: `--primary`, `--secondary`, etc.
    - Pre-defined color levels: `lowest`, `lower`, `low`, `medium`, `high`, `higher`, `highest`
 
-5. Start adding classes to your .vue files
+6. Start adding classes to your .vue files
 ```html
 <div class="bg-primary-low border-neutral-medium hover:shadow-wide rounded-lg" />
 <button class="bg-accent text-primary size-lg weight-bold smooth">Click me</button>
 ```
 <sup>any .vue file</sup>
 
-6. Enjoy
+7. Enjoy
 
 > **Note**: Generated CSS variables (from colors and export) are available for custom styling:
 > ```css
@@ -143,6 +152,16 @@ css: [
 > }
 > ```
 
+> **SCSS Tokens**: Color tokens are also available as SCSS variables for compile-time usage:
+> ```scss
+> @use "anubis/_tokens.scss" as tokens;
+> 
+> .custom-class {
+>   border-color: tokens.$primary;
+>   background: tokens.$accent-dark;
+> }
+> ```
+
 ## Configuration
 AnubisUI uses several configuration files located in the `src/config` directory:
 <br />
@@ -180,7 +199,7 @@ For every config you want to change, add the corresponding section in your confi
         "default": "4px",
         "thin": "2px"
       },
-      "export": "variation"
+      "export": "variations"
     },
     {
       "prefix": "rounded",
@@ -297,13 +316,7 @@ Configure all utility classes. This includes both color-based utilities and stan
 - `shadow` - Box shadow with spread variations and color
 
 
----
-### Quality of Life (`qol.config.json`)
-Define simple style rules that can have variations but don't require color values. These are CSS declarations that work independently.
-
-**[View default QoL config →](./src/config/qol.config.json)**
-
-QoL utilities include:
+**Standalone utilities** (no color required):
 - `blur` - Backdrop filter blur effect
 - `smooth` - Transition duration
 - `rounded` - Border radius
@@ -314,15 +327,38 @@ QoL utilities include:
 
 **Configuration options**:
 1. `prefix` - The class name prefix
-2. `declaration` - CSS rule using `${value}` placeholder for variations
+2. `declaration` - CSS rule using `${value}` and/or `${color}` placeholders
 3. `variations` - Key-value pairs of variation names and their CSS values
 4. `export` (optional) - Controls how variations are exported as CSS variables
+5. `overrides` (optional) - List of Quasar/global SCSS variables to override with the default variation
 
 **The `export` flag**:
-- `export: "variation"` → Generates CSS variables every variations
+- `export: "variations"` → Generates CSS variables for every variation
 - `export: "all"` → Generates classes for every possible color
 - These can be used in custom CSS: `font-size: var(--size-xl)`
 
+**The `overrides` option**:
+Override Quasar or global SCSS variables with the `default` variation value:
+```json
+{
+  "prefix": "border",
+  "declaration": "border-width: ${value}; border-color: ${color}; border-style: solid;",
+  "overrides": [
+    "generic-border-radius",
+    "button-border-radius"
+  ],
+  "variations": {
+    "default": "4px",
+    "thin": "2px"
+  }
+}
+```
+This generates in `anubis/_overrides.scss`:
+```scss
+$generic-border-radius: 4px;
+$button-border-radius: 4px;
+```
+
 **Color support**:
 - Use `${color}` in declaration to indicate the utility requires a color
 - Colors are automatically injected as CSS variables: `var(--{color})`
@@ -456,37 +492,54 @@ Examples:
 | size     | `font-size: {value} !important;`              |
 | weight   | `font-weight: {value} !important;`            |
 
-**Note**: When `export: "variation"` is set, `{value}` becomes `var(--{prefix}-{variation})` instead of the direct value.
+**Note**: When `export: "variations"` is set, `{value}` becomes `var(--{prefix}-{variation})` instead of the direct value.
 
 ## Architecture
 
 ### Build Process Flow
 
+The build process is orchestrated by `src/tools/main.ts` which runs the following steps in sequence:
+
 1. **Configuration Initialization** (`src/tools/config.tool.ts`)
    - Loads default configs from `src/config/*.config.json`
    - Merges with user's `anubis.config.json` if present
    - User config completely replaces default sections (no deep merge)
 
-2. **File Scanning** (`src/tools/fileStuff/file.tools.ts`)
-   - Scans files matching glob patterns from `files.config.json`
-   - Concurrent file reading with configurable limit (default: 10 files)
+2. **Mixins Generation** (`src/tools/output/css.output.ts`)
+   - Generates SCSS mixins for color handling (light/dark theme support)
+   - Outputs to `src/css/anubis/_mixins.scss`
+
+3. **Tokens Generation** (`src/tools/mapping/mapColors.ts`)
+   - Maps all colors from config into SCSS token variables
+   - Generates `$colorname`, `$colorname-light`, `$colorname-dark` variables
+   - Outputs to `src/css/anubis/_tokens.scss`
+
+4. **Overrides Generation** (`src/tools/mapping/mapUtilities.ts`)
+   - Maps utilities with `overrides` property to SCSS variable declarations
+   - Allows overriding Quasar/global variables with utility defaults
+   - Outputs to `src/css/anubis/_overrides.scss`
 
-3. **Class Extraction** (`src/tools/extraction/extractClasses.ts`)
+5. **Quasar Variables Injection** (`src/tools/fileStuff/quasar-variables.file.ts`)
+   - Automatically adds `@use` imports for tokens and overrides
+   - Updates `src/css/quasar.variables.scss`
+
+6. **Class Extraction** (`src/tools/extraction/extractClasses.ts`)
+   - Scans files matching glob patterns from `files.config.json`
    - Builds dynamic regex from config (states, utilities prefixes)
    - Extracts classes matching pattern: `(state:)?(prefix-)(-?(color|variation))?`
-   - Merges with forced classes from config
+   - Merges with forced classes and exported classes from config
    - Deduplicates and returns unique classes
 
-4. **Rule Generation** (`src/tools/mapping/mapClassIntoRule.ts`)
+7. **Rule Generation** (`src/tools/mapping/mapClassIntoRule.ts`)
    - Parses each class to identify state, prefix, color, and variation
    - Validates color existence in config
    - Handles utility variations (direct values or CSS variables)
    - Generates CSS rules with proper selectors and declarations
    - Collects variants for CSS variable export
 
-5. **CSS Output** (`src/tools/fileStuff/css.file.ts`)
+8. **CSS Output** (`src/tools/extraction/extractClasses.ts`)
    - Generates color CSS variables with light/dark theme support
-   - Generates variation CSS variables (from `export: "variation"` or `export: "all"`)
+   - Generates variation CSS variables (from `export: "variations"` or `export: "all"`)
    - Writes final CSS rules
    - Outputs to `src/css/_anubis.scss`
 
@@ -499,10 +552,14 @@ The plugin (`index.js`) provides:
 
 ### Core Components
 
-- **Config System**: Manages configuration loading and merging
-- **Class Extractor**: Regex-based pattern matching for class detection
-- **Rule Mapper**: Complex parsing logic for class-to-CSS conversion
-- **CSS Generator**: Generates variables and rules with proper formatting
+- **Main Orchestrator** (`main.ts`): Coordinates all initialization steps with timing
+- **Config System** (`config.tool.ts`): Manages configuration loading and merging
+- **Class Extractor** (`extractClasses.ts`): Regex-based pattern matching for class detection
+- **Color Mapper** (`mapColors.ts`): Generates tokens and mixin declarations from colors
+- **Utilities Mapper** (`mapUtilities.ts`): Generates SCSS overrides from utilities config
+- **Rule Mapper** (`mapClassIntoRule.ts`): Complex parsing logic for class-to-CSS conversion
+- **CSS Generator** (`css.output.ts`): Generates variables, mixins and rules with proper formatting
+- **File Tools** (`file.tools.ts`): Centralized file I/O with concurrency control
 
 ### File Structure
 ```
@@ -511,15 +568,27 @@ The plugin (`index.js`) provides:
 │   ├── config/                     # Default configuration files
 │   │   ├── colors.config.json      # Color palette (light/dark themes)
 │   │   ├── utilities.config.json   # All utility classes (bg, text, border, etc.)
-│   │   ├── states.config.json       # State modifiers
+│   │   ├── states.config.json      # State modifiers
 │   │   ├── files.config.json       # File scan patterns
 │   │   └── force.config.json       # Force specific classes
+│   ├── css/                        # Generated CSS output (in user project)
+│   │   ├── _anubis.scss            # Main generated stylesheet
+│   │   ├── quasar.variables.scss   # Quasar variables with injected imports
+│   │   └── anubis/
+│   │       ├── _mixins.scss        # SCSS mixins for color handling
+│   │       ├── _tokens.scss        # Color token variables
+│   │       └── _overrides.scss     # Quasar/global variable overrides
 │   ├── interfaces/                 # TypeScript type definitions
 │   └── tools/
 │       ├── extraction/             # Class extraction logic
 │       ├── fileStuff/              # File I/O operations
 │       ├── mapping/                # Class-to-CSS mapping
+│       │   ├── mapClassIntoRule.ts # Class to CSS rule conversion
+│       │   ├── mapColors.ts        # Color to tokens/mixins mapping
+│       │   └── mapUtilities.ts     # Utilities to overrides mapping
+│       ├── output/                 # CSS output generation
 │       ├── config.tool.ts          # Configuration loader
+│       ├── main.ts                 # Main orchestration entry point
 │       └── logger.ts               # Logging utilities
 └── index.js                        # Vite plugin entry point
 ```

package/dist/interfaces/color.interface.d.ts

@@ -0,0 +1,8 @@
+export interface IColor {
+    [colorName: string]: {
+        /** @optional Hexadecimal light color code - doesn't include opacity */
+        light?: string[7];
+        /** @optional Hexadecimal dark color code - doesn't include opacity */
+        dark?: string[7];
+    };
+}

package/dist/interfaces/color.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/{src/interfaces/config.interface.ts → dist/interfaces/config.interface.d.ts}

@@ -1,14 +1,11 @@
 import { IColor } from './color.interface';
 import { IUtility } from './preset.interface';
 import { IFileConfig } from './files.interface';
-
 export interface IEnvConfig {
     utilities: IUtility[];
     files: IFileConfig;
-
     /** User-given classes to force the css rule creation */
     force: string[];
-
     colors: IColor;
     states: string[];
     [key: string]: any;

package/dist/interfaces/config.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interfaces/files.interface.d.ts

@@ -0,0 +1,4 @@
+export interface IFileConfig {
+    targets: string | string[];
+    ignore: string[];
+}

package/dist/interfaces/files.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/{src/interfaces/preset.interface.ts → dist/interfaces/preset.interface.d.ts}

@@ -1,27 +1,23 @@
 export interface IVariation {
     [key: string]: string;
 }
-
 export interface IUtility {
-    // [key: string]: string
     prefix: string;
     declaration: string;
-
     /** When true, class can be called without variation, creating a rule with default variation */
     standalone?: boolean;
-
     /**
      * Controls how variations are exported as SCSS variables:
      * - "variation": export every variations
      * - "all": export every possible color class (utility prefix + every colors)
      * - undefined: do not export variations
      */
-    'export'?: 'variations' | 'all';
-
+    export?: 'variations' | 'all';
+    /** Override default global variables with the "default" variation if existing */
+    overrides?: string[];
     /** List of every possible variations */
     variations: IVariation;
 }
-
 export interface IRuleInfo {
     selector: string;
     declaration: string;

package/dist/interfaces/preset.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/tools/config.tool.d.ts

@@ -0,0 +1,4 @@
+import { IEnvConfig } from '../interfaces/config.interface';
+declare const config: IEnvConfig;
+declare const init: () => IEnvConfig;
+export { init, config };

package/dist/tools/config.tool.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = exports.init = void 0;
+const config_file_1 = require("./fileStuff/config.file");
+const logger_1 = require("./logger");
+const color_validation_1 = require("./validation/color.validation");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const anubisConfigFolder = path_1.default.join(__dirname, '..', '..', 'src', 'config');
+const anubisConfigFiles = [
+    'utilities',
+    'files',
+    'colors',
+    'states',
+    'force',
+];
+const config = {
+    utilities: [],
+    force: [],
+    files: { targets: [], ignore: [] },
+    colors: {},
+    states: [],
+};
+exports.config = config;
+const init = () => {
+    (0, config_file_1.readUserConfigFile)();
+    (0, config_file_1.checkUserConfigFile)(anubisConfigFiles);
+    for (const file of anubisConfigFiles) {
+        let configToUse = null;
+        if (config_file_1.userConfig && config_file_1.userConfig[file]) {
+            (0, logger_1.log)(`${file} config found, overriding default.`);
+            configToUse = config_file_1.userConfig[file];
+        }
+        else {
+            const filePath = path_1.default.join(anubisConfigFolder, `${file}.config.json`);
+            const fileExists = fs_1.default.existsSync(filePath);
+            if (!fileExists) {
+                continue;
+            }
+            const configContent = fs_1.default.readFileSync(filePath, { encoding: 'utf-8' });
+            if (!configContent) {
+                continue;
+            }
+            configToUse = JSON.parse(configContent);
+        }
+        config[file] = configToUse;
+        switch (file) {
+            case 'colors':
+                (0, color_validation_1.validateColors)(config.colors);
+                break;
+            case 'force':
+                const forceClasses = config_file_1.userConfig === null || config_file_1.userConfig === void 0 ? void 0 : config_file_1.userConfig['force'];
+                if (forceClasses === null || forceClasses === void 0 ? void 0 : forceClasses.length) {
+                    (0, logger_1.log)(`Forcing the creation of ${forceClasses === null || forceClasses === void 0 ? void 0 : forceClasses.length} classes`);
+                }
+                break;
+        }
+    }
+    return config;
+};
+exports.init = init;

package/dist/tools/extraction/extractClasses.d.ts

@@ -0,0 +1,5 @@
+/** Fetch vue file based on config target patterns */
+export declare const init: () => Promise<string>;
+/** Get all variations from utilities with export: "variations" */
+export declare const getExportedVariations: () => Record<string, string>;
+export declare const handleVariations: (extractedVariations: Record<string, string>) => string;

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[]>;