anubis-ui 1.2.15 → 1.2.16

package/src/tools/extraction/extractClasses.ts

@@ -1,56 +1,184 @@
-import { getFiles } from "../fileStuff/file.tools"
-import { mapClassesIntoRules } from "../mapping/mapClassIntoRule"
-import { buildCssRuleFile } from "../fileStuff/cssFile"
-import { config } from "../config.tool"
+import { getFiles } from '@tools/fileStuff/file.tools';
+import { mapClassesIntoRules } from '@tools/mapping/mapClassIntoRule';
+import { writeCssRuleFile } from '@tools/fileStuff/css.file';
+import { config } from '@tools/config.tool';
+import { mapColorsIntoMixinDeclaration } from '@tools/mapping/mapColorIntoDeclaration';
 
-const fs = require('fs')
+import fs from 'fs';
+import {
+		CLASS_COMMENT,
+		COLOR_COMMENT,
+		VARIANT_COMMENT,
+} from '../output/css.output';
+import { log } from '../logger';
+
+// Cache for regex compilation
+let cachedRegex: RegExp | null = null;
+let cachedConfigHash: string | null = null;
+
+// Performance optimization: limit concurrent file reads to avoid overwhelming the system
+const MAX_CONCURRENT_FILE_READS = 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 <T, R>(
+		items: T[],
+		fn: (item: T) => Promise<R>,
+		limit: number
+): Promise<R[]> => {
+		const results: R[] = [];
+		let index = 0;
+
+		const executeNext = async (): Promise<void> => {
+				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;
+};
 
 /** Fetch vue file based on config target patterns */
 const init = async () => {
-  const files = await getFiles(config.files)
+		// console.log({ config })
+		const files = await getFiles(config.files);
+
+		const uniqueClasses = await getUniqueClasses(files);
+		const { rules, variationsFromRules } = mapClassesIntoRules(uniqueClasses);
+
+		// Generate all colors from config (no filtering)
+		const mappedColors = `${COLOR_COMMENT}\n${mapColorsIntoMixinDeclaration(
+				config.colors
+		)}`;
+
+		// Get all variations that should be exported (export-variations: true)
+		const allExportVariations = getAllExportVariations();
+
+		// Merge used variations with all export variations (all export variations take priority)
+		const finalVariations = { ...variationsFromRules, ...allExportVariations };
+
+		// Generate CSS variables for variations
+		const variationsCss = Object.entries(finalVariations)
+				.map(([varName, varValue]) => `  --${varName}: ${varValue};`)
+				.join('\n');
 
-  const uniqueClasses = await getUniqueClasses(files)
-  const mappedRules = mapClassesIntoRules(uniqueClasses)
+		const wrappedVariations = variationsCss
+				? `${VARIANT_COMMENT}\n:root {\n${variationsCss}\n}`
+				: '';
 
-  const file = buildCssRuleFile(mappedRules)
-  return file
-}
+		const wrappedRules = rules ? `${CLASS_COMMENT}\n${rules}` : '';
+
+		const file = writeCssRuleFile(mappedColors, wrappedVariations, wrappedRules);
+		return file;
+};
 
 /** Extract detected class and map into a flat set */
 const getUniqueClasses = async (files: string[]): Promise<string[]> => {
-  const extractedClasses = (await Promise.all(
-    files.map(async file => extractClasses(file))
-  ))
-  ?.flat()
+		// Use concurrency limit to avoid overwhelming the system on large codebases
+		const extractedClasses = (
+				await pLimit(files, extractClasses, MAX_CONCURRENT_FILE_READS)
+		).flat();
+
+		const classes = [...extractedClasses, ...config.force].sort();
+
+		const uniqueClasses = Array.from(new Set(classes));
+		return uniqueClasses;
+};
+
+/** Build regex pattern from config */
+const buildClassDetectionRegex = (): RegExp => {
+		const { states, utilities } = config;
+
+		const partialUtilities = utilities?.map(u => {
+				const { prefix, variations: variationEntries, declaration } = u
+
+				if (!prefix && !variationEntries) {
+					log(`Something doesn't look good -> ${u}`)
+				}
+				const variations = Array.isArray(variationEntries) ? variationEntries : Object.keys(variationEntries || {})
+				const hasVariations = !!variations?.length
+				const hasDefaultVariation = hasVariations && variations.includes('default')
+				const needColor = declaration.includes('${color}')
+
+				/** If variation has default key, it's considered as a standalone - can be used solo */
+				if (hasVariations && hasDefaultVariation && !needColor) {
+					return `${prefix}`
+				}
+
+				return `${prefix}-`
+		})
+
+		const mappedUtilities = [...partialUtilities]?.join('|')
+		const mappedStates = `(${states?.map(s => `${s}:`)?.join('|')})`;
+
+		const regexp = new RegExp(
+				`${mappedStates}?(${mappedUtilities})(-?(\\w+(-+)?)+)?`,
+				'g'
+		);
+
+		return regexp
+};
+
+/** Get cached regex or build a new one if config changed */
+const getClassDetectionRegex = (): RegExp => {
+		const { states, qol, utilitys } = config;
+		const configHash = JSON.stringify({ states, qol, utilitys });
 
-  const classes = [...extractedClasses, ...config.force]?.sort()
+		if (cachedRegex && cachedConfigHash === configHash) {
+				return cachedRegex;
+		}
 
-  const uniqueClasses = Array.from(new Set(classes))
-  return uniqueClasses
-}
+		cachedRegex = buildClassDetectionRegex();
+		cachedConfigHash = configHash;
+		return cachedRegex;
+};
 
 /** Find matching classes from a given file based on config states and prefixes */
 const extractClasses = async (filePath: string): Promise<string[]> => {
-  const file = await fs.promises.readFile(filePath, 'utf-8')
-  if (!file) { return [] }
+		const file = await fs.promises.readFile(filePath, 'utf-8');
+		if (!file) {
+				return [];
+		}
 
-  const { states, qol, presets } = config
+		const classDetectionRegex = getClassDetectionRegex();
+		const matches = file.match(classDetectionRegex) || [];
 
-  const partialPrefixes = presets?.map(p => `${p.prefix}-`)
-  const partialQol = qol?.map(q => q.standalone ? `${q.prefix}` : `${q.prefix}-`)
+		return matches;
+};
 
-  const mappedPrefixes = [
-    ...partialPrefixes,
-    ...partialQol
-  ]?.join('|')
-  const mappedStates = `(${states?.map(s => `${s}:`)?.join('|')})`
+/** Get all variations from utilitys with export-variations: true */
+const getAllExportVariations = (): Record<string, string> => {
+		const allExportVariations: Record<string, string> = {};
+		const allUtilities = [...config.utilities];
 
-  const classDetectionRegex = new RegExp(`${mappedStates}?(${mappedPrefixes})(-?(\\w+(-+)?)+)?`, 'g')
+		for (const utility of allUtilities) {
+				if (utility['export-variations'] === true && utility.variations) {
+						for (const [variantName, variantValue] of Object.entries(
+								utility.variations
+						)) {
+								const variableName = `${utility.prefix}-${variantName}`;
+								allExportVariations[variableName] = variantValue as string;
+						}
+				}
+		}
 
-  const matches = file.match(classDetectionRegex) || []
-  return matches
-}
+		return allExportVariations;
+};
 
-export {
-  init
-}
+export { init };

package/src/tools/fileStuff/config.file.ts

@@ -0,0 +1,44 @@
+import fs from 'fs';
+import path from 'path';
+import { log } from '@tools/logger';
+
+const userConfigPath = path.join(process.cwd(), 'anubis.config.json');
+let userConfig = null;
+
+const readUserConfigFile = () => {
+    const userConfigExists = fs.existsSync(userConfigPath);
+
+    if (!userConfigExists) {
+        log('No user config file found, using default configuration.');
+        return;
+    }
+
+    const config = fs.readFileSync(userConfigPath, { encoding: 'utf-8' });
+    userConfig = JSON.parse(config);
+
+    return userConfig;
+};
+
+/** Print a warning if the config file has unknow keys */
+const checkUserConfigFile = (configFile: string[]): void => {
+    if (!userConfig) {
+        return;
+    }
+
+    // todo - also check values
+    const userConfigKeys = Object.keys(userConfig);
+
+    const unknownKeys = userConfigKeys?.filter(
+        key => !configFile.includes(key) && key !== 'force'
+    );
+    if (!unknownKeys?.length) {
+        return;
+    }
+
+    log(`${unknownKeys?.length} unknown config keys found in user config file`);
+    for (const key of unknownKeys) {
+        log(`- ${key}`);
+    }
+};
+
+export { userConfig, readUserConfigFile, checkUserConfigFile };

package/src/tools/fileStuff/css.file.ts

@@ -0,0 +1,47 @@
+import fs from 'fs';
+import path from 'path';
+
+import { log } from '@tools/logger';
+import { getHeader } from '@tools/output/css.output';
+
+const srcDir = path.join(process.cwd(), 'src', 'css');
+const outputPath = path.join(srcDir, '_anubis.scss');
+
+const checkCssRuleFilePresence = () => {
+    try {
+        fs.mkdirSync(srcDir, { recursive: true });
+
+        if (fs.existsSync(outputPath)) {
+            return;
+        }
+
+        log('Output file missing, generating..');
+        fs.writeFileSync(outputPath, '');
+    } catch (err: any) {
+        throw new Error(
+            `Erreur lors de la vérification du fichier CSS: ${err.message}`
+        );
+    }
+};
+
+const writeCssRuleFile = (
+    colors: string = '',
+    variants: string = '',
+    classes: string = ''
+) => {
+    try {
+        checkCssRuleFilePresence();
+
+        const content = `${getHeader()}\n${colors}\n\n${variants}\n\n${classes}`;
+
+        fs.writeFileSync(outputPath, content);
+
+        return outputPath;
+    } catch (err: any) {
+        throw new Error(
+            `Erreur lors de l'écriture du fichier CSS: ${err.message}`
+        );
+    }
+};
+
+export { writeCssRuleFile };

package/src/tools/fileStuff/file.tools.ts

@@ -1,15 +1,12 @@
-const fg = require('fast-glob')
-
-import { IFileConfig } from '../../interfaces/files.interface'
+import fg from 'fast-glob';
+import { IFileConfig } from '@interfaces/files.interface';
 
 const getFiles = async (routeConfig: IFileConfig) => {
-  return await fg(routeConfig.targets || '*.vue', {
-    absolute: true,
-    onlyFiles: true,
-    ignore: routeConfig.ignore || [],
-  })
-}
+    return await fg(routeConfig.targets || '*.vue', {
+        absolute: true,
+        onlyFiles: true,
+        ignore: routeConfig.ignore || [],
+    });
+};
 
-export {
-  getFiles
-}
+export { getFiles };

package/src/tools/logger.ts

@@ -1,8 +1,8 @@
+import packageJson from '../../package.json';
+
 const logPrefix = '☯︎ [ANUBIS]'
 const log = (str: string) => console.log(`${logPrefix} ${str}`)
 
-const { version } = require('./../../package.json')
-
 const logo = () => {
   log('    ___    _   ____  ______  _________')
   log('   /   |  / | / / / / / __ )/  _/ ___/')
@@ -10,21 +10,14 @@ const logo = () => {
   log(' / ___ |/ /|  / /_/ / /_/ // / ___/ /')
   log('/_/  |_/_/ |_/\\____/_____/___//____/')
   log('')
-  log('Welcome to Anubis 1.0')
+  log(`Welcome to Anubis v${packageJson.version}`)
   log('Autonomous Nominative Utility Based Intuitive Styler')
   log('---')
 }
 
-const cssHeader = `/*!
- * * Anubis v.${version}
- * * Improba
- * * Released under the MIT License.
- * */`
-
 export {
   logo,
-  cssHeader,
 
   log,
   logPrefix
-}
+}