xatriumcss 1.0.27 → 1.0.28

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "xatriumcss",
-    "version": "1.0.27",
+    "version": "1.0.28",
     "description": "Ultra-fast utility-first CSS framework",
     "main": "./src/index.js",
     "files": [

package/src/cli.js

@@ -42,7 +42,7 @@ const config = {
 config.input = path.resolve(projectRoot, config.input);
 config.output = path.resolve(projectRoot, config.output);
 
-function build() {
+async function build() {
     const startTime = process.hrtime.bigint();
 
     console.log('🔍 Checking for @import "xatriumcss"...');
@@ -64,7 +64,7 @@ function build() {
         return;
     }
 
-    runParser(config);
+    await runParser(config);
 
     const endTime = process.hrtime.bigint();
     const duration = endTime - startTime;
@@ -82,10 +82,10 @@ function formatTime(nanoseconds) {
 // Initial build
 (async () => {
     try {
-        build();
+        await build();
     } catch (error) {
-        console.error('❌ Build failed:', error.message);
         console.error('Stack:', error.stack);
+        console.error('❌ Build failed:', error.message);
         process.exit(1);
     }
 
@@ -96,25 +96,21 @@ function formatTime(nanoseconds) {
 
         const changedFiles = new Set();
         let rebuildTimer = null;
-        let isBuilding = false;  // ← ADD THIS FLAG
 
         function scheduleRebuild() {
-            if (rebuildTimer || isBuilding) return;  // ← Check if building
+            if (rebuildTimer) return;
 
-            rebuildTimer = setTimeout(() => {
+            rebuildTimer = setTimeout(async () => {
                 const files = Array.from(changedFiles);
                 changedFiles.clear();
                 rebuildTimer = null;
 
-                isBuilding = true;  // ← Set flag
                 try {
                     build();
                 } catch (error) {
                     console.error('❌ Build error:', error.message);
-                } finally {
-                    isBuilding = false;  // ← Clear flag
                 }
-            }, 100);  // ← Increase to 100ms
+            }, 10);
         }
 
         // Get directories to watch

package/src/collectClasses.js

@@ -47,25 +47,47 @@ export async function collectClasses(contentPaths) {
 
     const allClasses = await extractClassesFromFiles(files);
     
+    // Ensure allClasses is an array
+    if (!Array.isArray(allClasses)) {
+      console.warn('⚠️ extractClassesFromFiles did not return an array, got:', typeof allClasses);
+      console.warn('Value:', allClasses);
+      return [];
+    }
+    
     console.log(`✅ Extracted ${allClasses.length} classes`);
     return allClasses;
   } catch (error) {
     console.error('❌ Error during class collection:', error.message);
+    console.error('Stack:', error.stack);
     return [];
   }
 }
 
 async function scanFiles(patterns, ignorePaths = []) {
   const files = new Set();
-  const ignoreSet = new Set(ignorePaths.map(p => p.toLowerCase()));
+  const ignoreSet = new Set((ignorePaths || []).map(p => p.toLowerCase()));
 
   for (const pattern of patterns) {
     if (pattern.includes('*') || pattern.includes('?')) {
-      const dir = path.dirname(pattern);
-      const glob = path.basename(pattern);
-      
+      // Normalize path separators to forward slashes for consistent splitting
+      const normalizedPattern = pattern.replace(/\\/g, '/');
+      const parts = normalizedPattern.split('/');
+      let baseDir = '.';
+      let globPattern = pattern;
+
+      // Find the first non-glob part to determine base directory
+      for (let i = 0; i < parts.length; i++) {
+        if (parts[i].includes('*') || parts[i].includes('?')) {
+          baseDir = parts.slice(0, i).join('/') || '.';
+          // Convert baseDir back to system-specific path
+          baseDir = path.resolve(baseDir);
+          globPattern = parts.slice(i).join('/');
+          break;
+        }
+      }
+
       try {
-        const matched = await globWalk(dir, glob);
+        const matched = await globWalk(baseDir, globPattern);
         matched.forEach(f => {
           const lowerF = f.toLowerCase();
           if (!ignoreSet.has(lowerF)) {
@@ -88,9 +110,16 @@ async function scanFiles(patterns, ignorePaths = []) {
   return Array.from(files);
 }
 
-async function globWalk(dir, pattern) {
+async function globWalk(baseDir, pattern) {
   const files = [];
-  const regexPattern = globToRegex(pattern);
+  
+  // Normalize the pattern to use forward slashes
+  const normalizedPattern = pattern.replace(/\\/g, '/');
+  const parts = normalizedPattern.split('/');
+  
+  // Last part is the file pattern (e.g., "*.html")
+  const filePattern = parts[parts.length - 1];
+  const regexPattern = globToRegex(filePattern);
 
   function walk(currentPath) {
     try {
@@ -99,9 +128,13 @@ async function globWalk(dir, pattern) {
       for (const entry of entries) {
         const fullPath = path.join(currentPath, entry.name);
         
-        if (entry.isFile() && regexPattern.test(entry.name)) {
-          files.push(fullPath);
+        if (entry.isFile()) {
+          // Check if filename matches the pattern
+          if (regexPattern.test(entry.name)) {
+            files.push(fullPath);
+          }
         } else if (entry.isDirectory() && !entry.name.startsWith('.')) {
+          // Recursively walk all subdirectories
           walk(fullPath);
         }
       }
@@ -110,8 +143,8 @@ async function globWalk(dir, pattern) {
     }
   }
 
-  if (fs.existsSync(dir)) {
-    walk(dir);
+  if (fs.existsSync(baseDir)) {
+    walk(baseDir);
   }
 
   return files;
@@ -234,6 +267,12 @@ function smartSplit(str, delimiter = ' ') {
 }
 
 function sortMotionClasses(classes) {
+  // Ensure input is an array
+  if (!Array.isArray(classes)) {
+    console.warn('⚠️ sortMotionClasses received non-array input:', typeof classes);
+    return [];
+  }
+
   const motionRegex = /^(.*?)motion-\[([^\]]+)\]:/;
   const motionByName = {};
   const nonMotionClasses = [];
@@ -264,5 +303,13 @@ function sortMotionClasses(classes) {
     sortedMotion.push(...group.map(item => item.cls));
   });
 
-  return [...nonMotionClasses, ...sortedMotion];
+  // Ensure we always return an array
+  const result = [...nonMotionClasses, ...sortedMotion];
+  
+  if (!Array.isArray(result)) {
+    console.error('❌ sortMotionClasses failed to return array');
+    return [];
+  }
+  
+  return result;
 }

package/src/parser.js

@@ -1,8 +1,7 @@
 import fs from 'fs';
 import { glob } from 'glob';
-import { collectClasses } from './src/collectClasses.js';
+import { collectClasses } from './collectClasses.js';
 
-// --- 1. Fill this array with all your CSS properties ---
 const allCSSProperties = [
     // Display & Visibility
     "display",
@@ -11667,7 +11666,7 @@ function _parseClassInternal(cls, isFromGrouped = false, needed, isGlobal) {
                 }
                 if (i < cls.length && cls[i] === closeBracket) i++; // skip ) or ]
                 if (i < cls.length && (cls[i] === '-' || cls[i] === ':')) i++; // skip dash/colon before pct
-            
+
             } else if (/\d/.test(nextChar)) {
                 // Could be <num>-<pct> OR just malformed
                 // Look ahead for dash
@@ -15071,7 +15070,7 @@ function _parseClassInternal(cls, isFromGrouped = false, needed, isGlobal) {
                 ];
             }
 
-            return buildParsed(prop,value)
+            return buildParsed(prop, value)
         }
     }
 
@@ -24266,14 +24265,14 @@ function expandBracePattern(pattern) {
 function expandRangePattern(pattern) {
     const rangeRegex = /^(-?\d+)\.\.(-?\d+)(?:\.\.(-?\d+))?$/;
     const P = [];
-    
+
     function splitByDelimiter(str, delimiter) {
         let depth = 0,
             parts = [],
             startIndex = 0,
             length = str.length,
             delimiterCode = delimiter.charCodeAt(0);
-        
+
         for (let i = 0; i < length; i++) {
             let charCode = str.charCodeAt(i);
             if (0 !== depth || charCode !== delimiterCode)
@@ -24308,16 +24307,16 @@ function expandRangePattern(pattern) {
         }
         return parts.push(str.slice(startIndex)), parts;
     }
-    
+
     let openBraceIndex = pattern.indexOf("{");
     if (openBraceIndex === -1) return [pattern];
-    
+
     let results = [],
         prefix = pattern.slice(0, openBraceIndex),
         remaining = pattern.slice(openBraceIndex),
         braceDepth = 0,
         closeBraceIndex = remaining.lastIndexOf("}");
-    
+
     for (let i = 0; i < remaining.length; i++) {
         let char = remaining[i];
         if ("{" === char) braceDepth++;
@@ -24326,13 +24325,13 @@ function expandRangePattern(pattern) {
             break;
         }
     }
-    
+
     if (-1 === closeBraceIndex) throw new Error(`The pattern \`${pattern}\` is not balanced.`);
-    
+
     let expandedItems,
         braceContent = remaining.slice(1, closeBraceIndex),
         suffix = remaining.slice(closeBraceIndex + 1);
-    
+
     (expandedItems = rangeRegex.test(braceContent)
         ? (function (rangeStr) {
             let match = rangeStr.match(rangeRegex);
@@ -24352,7 +24351,7 @@ function expandRangePattern(pattern) {
         })(braceContent)
         : splitByDelimiter(braceContent, ",")),
         (expandedItems = expandedItems.flatMap((item) => expandRangePattern(item)));
-    
+
     let expandedSuffixes = expandRangePattern(suffix);
     for (let suffixPart of expandedSuffixes) for (let item of expandedItems) results.push(prefix + item + suffixPart);
     return results;
@@ -24468,35 +24467,31 @@ function extractLayersFromCSS(css) {
 }
 
 function generateCSSString(classes, generateWithoutSelector = false, isFirstRun = false) {
-    // Expand xatriumSourceInlines
-    const expandedInlineClasses = [];
-    const expandedNotInlineClasses = [];
-
-    xatriumSourceInlines.inline.forEach(pattern => {
-        const expanded = expandBracePattern(pattern);
-        expandedInlineClasses.push(...expanded);
-    });
+    // Cache expanded patterns to avoid re-expanding every run
+    if (!global._expandedInlineCache) {
+        global._expandedInlineCache = {
+            inline: xatriumSourceInlines.inline.flatMap(expandBracePattern),
+            notInline: xatriumSourceInlines.notInline.flatMap(expandBracePattern)
+        };
+    }
+    const expandedInlineClasses = global._expandedInlineCache.inline;
+    const expandedNotInlineClasses = global._expandedInlineCache.notInline;
 
-    xatriumSourceInlines.notInline.forEach(pattern => {
-        const expanded = expandBracePattern(pattern);
-        expandedNotInlineClasses.push(...expanded);
-    });
-
-    classes = Array.from(new Set(classes));
+    const notInlineSet = new Set(expandedNotInlineClasses);
+    const classesSet = new Set(classes);
 
     const classesToParse = isFirstRun
-        ? Array.from(new Set(classes)).filter(cls => {
-            if (expandedNotInlineClasses.includes(cls)) return false;
+        ? Array.from(classesSet).filter(cls => {
+            if (notInlineSet.has(cls)) return false;
             // Check if ...allVariants:cls exists in notInline
             const baseClass = cls.includes(':') ? cls.split(':').pop() : cls;
-            if (expandedNotInlineClasses.includes(`...allVariants:${baseClass}`)) return false;
+            if (notInlineSet.has(`...allVariants:${baseClass}`)) return false;
             return true;
         })
-        : Array.from(new Set(classes)).filter(cls => {
-            if (previouslyParsedClasses.includes(cls) || expandedNotInlineClasses.includes(cls)) return false;
-            // Check if ...allVariants:cls exists in notInline
+        : Array.from(classesSet).filter(cls => {
+            if (previouslyParsedClasses.includes(cls) || notInlineSet.has(cls)) return false;
             const baseClass = cls.includes(':') ? cls.split(':').pop() : cls;
-            if (expandedNotInlineClasses.includes(`...allVariants:${baseClass}`)) return false;
+            if (notInlineSet.has(`...allVariants:${baseClass}`)) return false;
             return true;
         });
     // Update tracker
@@ -24537,6 +24532,10 @@ function generateCSSString(classes, generateWithoutSelector = false, isFirstRun
         previouslyParsedClasses.push(...inlineToAdd);
     }
 
+    // Check if it's a spawn/scroll SHORTHAND (with from/to/back/half/[])
+    const spawnShorthandRegex = /^(.*?:)?spawn-(from|to|back|half|\[[^\]]+\])(\/(?:from|to|back|half|\[[^\]]+\]))*:/;
+    const scrollShorthandRegex = /^(.*?:)?scroll-(from|to|back|half|\[[^\]]+\])(\/(?:from|to|back|half|\[[^\]]+\]))*:/;
+
     function mergeNestedStructures(bodies) {
         // Parse each body into a tree structure
         const parseBody = (body) => {
@@ -24688,10 +24687,6 @@ function generateCSSString(classes, generateWithoutSelector = false, isFirstRun
         const firstActual = firstSplit[0];
         const original = firstSplit[1] || '';
 
-        // Check if it's a spawn/scroll SHORTHAND (with from/to/back/half/[])
-        const spawnShorthandRegex = /^(.*?:)?spawn-(from|to|back|half|\[[^\]]+\])(\/(?:from|to|back|half|\[[^\]]+\]))*:/;
-        const scrollShorthandRegex = /^(.*?:)?scroll-(from|to|back|half|\[[^\]]+\])(\/(?:from|to|back|half|\[[^\]]+\]))*:/;
-
         const isSpawnShorthand = checkIfOutside(firstActual, "spawn-") && spawnShorthandRegex.test(firstActual);
         const isScrollShorthand = checkIfOutside(firstActual, "scroll-") && scrollShorthandRegex.test(firstActual);
 
@@ -25688,7 +25683,7 @@ function formatCSS(raw) {
         .trim();
 }
 
-export function runParser(config) {
+export async function runParser(config) {
     // Reset source config for each run
     global.xatriumSourceConfig = {
         basePath: null,
@@ -25699,10 +25694,32 @@ export function runParser(config) {
     parseXatriumCSSConfig(config.input || './src/input.css');
     useRangeSyntax = xatriumConfig.settings?.query !== "min-max";
 
-    const classes = collectClasses(config.content);
 
-    const result = generateCSSString(classes, false, isFirstRun);
-    // Skip if no changes in incremental mode
+    // Ensure config.content is an array
+    let contentPatterns = config.content;
+    if (!Array.isArray(contentPatterns)) {
+        if (typeof contentPatterns === 'string') {
+            contentPatterns = [contentPatterns];
+        } else if (contentPatterns && typeof contentPatterns === 'object') {
+            contentPatterns = Object.values(contentPatterns);
+        } else {
+            contentPatterns = [];
+        }
+    }
+
+    console.log('📋 Content patterns:', contentPatterns);
+
+    let classes = await collectClasses(contentPatterns);
+
+    // Ensure classes is an array
+    if (!Array.isArray(classes)) {
+        console.warn('⚠️  collectClasses returned non-array:', typeof classes);
+        classes = [];
+    }
+
+    console.log('📊 Classes found:', classes.length);
+
+    const result = generateCSSString(classes, false, isFirstRun)    // Skip if no changes in incremental mode
     if (result.type === 'incremental' && result.layers.length === 0) {
         return;
     }
@@ -25713,6 +25730,7 @@ export function runParser(config) {
     if (!fs.existsSync(outputDir)) {
         fs.mkdirSync(outputDir, { recursive: true });
     }
+    console.log("classes",classes)
 
     if (result.type === 'first') {
         const finalCSS = removeNewlines(result.css);
@@ -25725,15 +25743,17 @@ export function runParser(config) {
 
         // If CSS is empty or missing critical structure, force full rebuild
         if (!currentCSS || !currentCSS.includes('@layer base') || !currentCSS.includes('@layer utilities')) {
-            // Force full rebuild
             isFirstRun = true;
             previouslyParsedClasses = [];
             previouslyGeneratedProps.clear();
-            const fullResult = generateCSSString(collectClasses(config.content), false, isFirstRun);
-            const finalCSS = removeNewlines(fullResult.css);  // ← Use fullResult, not result
+            
+            const rebuiltClasses = await collectClasses(config.content);
+            const fullResult = generateCSSString(rebuiltClasses, false, isFirstRun);
+            
+            const finalCSS = removeNewlines(fullResult.css);
             fs.writeFileSync(outputPath, finalCSS, 'utf8');
-            isFirstRun = false;  // ← Reset the flag after rebuild
-            return finalCSS;  // ← Return the CSS instead of undefined
+            isFirstRun = false;
+            return finalCSS;
         }
 
         result.layers.forEach(layer => {
@@ -25885,7 +25905,7 @@ export function runParser(config) {
         });
 
         fs.writeFileSync(outputPath, removeNewlines(currentCSS), 'utf8');
-        return removeNewlines(currentCSS); // ← ADD THIS
+        return removeNewlines(currentCSS);
     }
 }
 
@@ -26608,9 +26628,9 @@ export function hasXatriumImport(inputCssPath) {
     }
 
     const content = fs.readFileSync(inputCssPath, 'utf8');
-    
+
     // Match any @import "xatriumcss" with or without source()
     const importRegex = /@import\s+['"]xatriumcss['"]/gi;
-    
+
     return importRegex.test(content);
 }