xatriumcss 1.0.3 → 1.0.6

package/package.json

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

package/src/cli.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
 const { runParser, hasXatriumImport } = require('./parser');
 const path = require('path');

package/src/collectClasses.js

@@ -3,9 +3,11 @@ const { glob } = require('glob');
 
 let nativeScanner;
 try {
-  nativeScanner = require('../scripts/index.js'); 
+  nativeScanner = require('../index'); 
+  console.log("using native scanner")
 } catch (e) {
-  console.warn('⚠️  Native scanner not available, falling back to JavaScript');
+  console.log("using fallback scanner")
+  console.log("ERROR:", e.message);
   nativeScanner = null;
 }
 
@@ -98,22 +100,68 @@ function collectClasses(contentPaths) {
   // Use native scanner if available
   if (nativeScanner) {
     try {
-      const scanner = new nativeScanner.Scanner();
-      
-      // Add patterns
+      // Build paths array
       let pathsArray = sourceConfig.disableAuto 
         ? sourceConfig.explicitPaths 
         : [...(Array.isArray(contentPaths) ? contentPaths : [contentPaths]), ...sourceConfig.explicitPaths];
       
-      pathsArray.forEach(pattern => scanner.addPattern(pattern));
-      sourceConfig.ignorePaths.forEach(pattern => scanner.addIgnorePattern(pattern));
+      // Filter out any null/undefined values
+      pathsArray = pathsArray.filter(p => p != null);
+      
+      if (pathsArray.length === 0) {
+        console.warn('⚠️  No valid patterns to scan, falling back to JS scanner');
+        throw new Error('No patterns provided');
+      }
+      
+      // Convert patterns to SourceEntry format
+      const sources = [];
+      
+      // Add positive patterns
+      pathsArray.forEach(pattern => {
+        sources.push({
+          base: process.cwd(),
+          pattern: pattern,
+          negated: false
+        });
+      });
+      
+      // Add negative patterns (ignore paths)
+      sourceConfig.ignorePaths.forEach(pattern => {
+        sources.push({
+          base: process.cwd(),
+          pattern: pattern,
+          negated: true
+        });
+      });
+      
+      console.log('🚀 Using native scanner (Rust) for file discovery');
+      console.log('📋 Patterns:', pathsArray);
+      
+      // Create scanner with options
+      let scanner;
+      try {
+        scanner = new nativeScanner.Scanner({ sources });
+      } catch (error) {
+        console.warn('⚠️  Native scanner failed, falling back to JS:', error.message);
+      }
+      
+      // Get the files that were matched by the scanner
+      const files = scanner.files;
+      
+      if (!files || files.length === 0) {
+        console.warn('⚠️  Native scanner found no files');
+        throw new Error('No files found');
+      }
+      
+      console.log(`📄 Native scanner found ${files.length} files`);
       
-      console.log('🚀 Using native scanner (Rust)');
-      const rawClasses = scanner.scanAndExtract();
+      // Read files and extract quoted strings manually to preserve grouping
+      const quotedStrings = scanner.scan();  // Rust does EVERYTHING!
       
-      return processClasses(rawClasses);
+      console.log(`✅ Extracted ${quotedStrings.length} quoted strings from files`);
+      return processClasses(quotedStrings);
     } catch (error) {
-      console.warn('⚠️  Native scanner failed, falling back:', error.message);
+      console.warn('⚠️  Native scanner failed, falling back to JS:', error.message);
     }
   }
   
@@ -122,9 +170,21 @@ function collectClasses(contentPaths) {
 }
 
 function processClasses(rawClasses) {
+  // Additional safety check
+  if (!rawClasses || !Array.isArray(rawClasses)) {
+    console.warn('⚠️  processClasses received invalid input:', typeof rawClasses);
+    return [];
+  }
+
   const allClasses = new Set();
   
   rawClasses.forEach(part => {
+    // Ensure part is a string
+    if (typeof part !== 'string') {
+      console.warn('⚠️  Skipping non-string class:', typeof part, part);
+      return;
+    }
+
     let cls = part.trim();
     if (!cls) return;
 
@@ -330,8 +390,8 @@ function collectClassesJS(contentPaths) {
   files.forEach(filePath => {
     const fileContent = fs.readFileSync(filePath, 'utf8');
 
-    // Grab only strings inside single or double quotes
-    const parts = Array.from(fileContent.matchAll(/(['"])(.*?)\1/g), m => m[2]);
+    // Grab only strings inside single quotes, double quotes, or backticks
+    const parts = Array.from(fileContent.matchAll(/(['"`])(.*?)\1/gs), m => m[2]);
 
     parts.forEach(part => {
       let cls = part.trim();

package/src/parser.js

@@ -1,5 +1,6 @@
 const fs = require('fs');
 const { glob } = require('glob');
+const collectClasses = require('./collectClasses.js');
 
 // --- 1. Fill this array with all your CSS properties ---
 const allCSSProperties = [
@@ -22876,216 +22877,6 @@ function parseXatriumCSSConfig(inputCssPath) {
     xatriumSourceInlines.notInline = Array.from(new Set(xatriumSourceInlines.notInline));
 }
 
-function collectClasses(contentPaths) {
-    const allClasses = new Set();
-    
-    // Get source configuration
-    const sourceConfig = global.xatriumSourceConfig || {
-        basePath: null,
-        disableAuto: false,
-        explicitPaths: [],
-        ignorePaths: []
-    };
-
-    let pathsArray = [];
-
-    // If source(none) is set, only use explicit paths
-    if (sourceConfig.disableAuto) {
-        pathsArray = sourceConfig.explicitPaths;
-        console.log('🔒 Auto-detection disabled - using explicit paths only:', pathsArray);
-    } else {
-        // Use provided contentPaths or defaults
-        pathsArray = Array.isArray(contentPaths) ? contentPaths : (contentPaths ? [contentPaths] : []);
-        
-        // Add explicit paths from @source directives
-        if (sourceConfig.explicitPaths.length > 0) {
-            pathsArray = [...pathsArray, ...sourceConfig.explicitPaths];
-            console.log('➕ Added explicit paths:', sourceConfig.explicitPaths);
-        }
-    }
-
-    // Apply base path if set
-    if (sourceConfig.basePath) {
-        const path = require('path');
-        pathsArray = pathsArray.map(p => {
-            const resolved = path.resolve(path.dirname(process.cwd()), sourceConfig.basePath, p);
-            return resolved;
-        });
-        console.log('📂 Applied base path:', sourceConfig.basePath);
-    }
-
-    console.log('🔍 Scanning paths:', pathsArray);
-
-    // Scan all files matching the patterns
-    let files = [];
-    pathsArray.forEach(pattern => {
-        try {
-            const matches = glob.sync(pattern, {
-                ignore: sourceConfig.ignorePaths.length > 0 ? sourceConfig.ignorePaths : undefined
-            });
-            files.push(...matches);
-            
-            if (sourceConfig.ignorePaths.length > 0) {
-                console.log(`🚫 Ignoring paths:`, sourceConfig.ignorePaths);
-            }
-        } catch (err) {
-            console.error(`❌ Error scanning pattern ${pattern}:`, err.message);
-        }
-    });
-
-    console.log(`📄 Found ${files.length} files to scan`);
-
-    if (files.length === 0) {
-        return [];
-    }
-
-    files.forEach(filePath => {
-        const fileContent = fs.readFileSync(filePath, 'utf8');
-
-        // Grab only strings inside single or double quotes
-        const parts = Array.from(fileContent.matchAll(/(['"])(.*?)\1/g), m => m[2]);
-
-        parts.forEach(part => {
-            let cls = part.trim();
-            if (!cls) return;
-
-            // Normalize whitespace to single spaces, but preserve inside ( [ { " '
-            let normalizedCls = "";
-            let parenDepth = 0;
-            let bracketDepth = 0;
-            let braceDepth = 0;
-            let inSingleQuote = false;
-            let inDoubleQuote = false;
-
-            for (let i = 0; i < cls.length; i++) {
-                const char = cls[i];
-
-                // Track quote state
-                if (char === "'" && !inDoubleQuote) inSingleQuote = !inSingleQuote;
-                else if (char === '"' && !inSingleQuote) inDoubleQuote = !inDoubleQuote;
-
-                const inQuotes = inSingleQuote || inDoubleQuote;
-
-                // Track bracket depths (only if not in quotes)
-                if (!inQuotes) {
-                    if (char === "(") parenDepth++;
-                    else if (char === ")") parenDepth--;
-                    else if (char === "[") bracketDepth++;
-                    else if (char === "]") bracketDepth--;
-                    else if (char === "{") braceDepth++;
-                    else if (char === "}") braceDepth--;
-                }
-
-                const insideGroup = parenDepth > 0 || bracketDepth > 0 || braceDepth > 0 || inQuotes;
-
-                // Normalize whitespace only when NOT inside groups
-                if (/\s/.test(char)) {
-                    if (insideGroup) {
-                        normalizedCls += char;
-                    } else {
-                        // Collapse consecutive whitespace to single space
-                        if (normalizedCls.length > 0 && !/\s/.test(normalizedCls[normalizedCls.length - 1])) {
-                            normalizedCls += " ";
-                        }
-                    }
-                } else {
-                    normalizedCls += char;
-                }
-            }
-
-            normalizedCls = normalizedCls.trim();
-            const innerParts = smartSplitNoBrace(normalizedCls, " ");
-
-            const spawnShorthandRegex = /^(.*?:)?spawn-((?:from|to|back|half|\[[^\]]+\])(?:\/(?:from|to|back|half|\[[^\]]+\]))*):(.+)$/;
-            const scrollShorthandRegex = /^(.*?:)?scroll-((?:from|to|back|half|\[[^\]]+\])(?:\/(?:from|to|back|half|\[[^\]]+\]))*):(.+)$/;
-            const scrollPrefixRegex = /^(.*?:)?scroll:(.+)$/;
-
-            // Group by prefix for spawn/scroll classes
-            const spawnByPrefix = {};
-            const scrollByPrefix = {};
-            const nonShorthandParts = [];
-
-            innerParts.forEach(part => {
-                if (spawnShorthandRegex.test(part)) {
-                    const match = part.match(spawnShorthandRegex);
-                    const prefix = match[1] || ''; // Empty string for no prefix
-
-                    if (!spawnByPrefix[prefix]) {
-                        spawnByPrefix[prefix] = [];
-                    }
-                    spawnByPrefix[prefix].push(part);
-                } else if (scrollShorthandRegex.test(part) || scrollPrefixRegex.test(part)) {
-                    const match = part.match(scrollShorthandRegex) || part.match(scrollPrefixRegex);
-                    const prefix = match[1] || ''; // Empty string for no prefix
-
-                    if (!scrollByPrefix[prefix]) {
-                        scrollByPrefix[prefix] = [];
-                    }
-                    scrollByPrefix[prefix].push(part);
-                } else {
-                    nonShorthandParts.push(part);
-                }
-            });
-
-            // Add non-shorthand classes normally
-            nonShorthandParts.forEach(c => allClasses.add(c));
-
-            // Add spawn classes grouped by prefix
-            Object.values(spawnByPrefix).forEach(group => {
-                if (group.length > 0) {
-                    allClasses.add(group.join(' '));
-                }
-            });
-
-            // Add scroll classes grouped by prefix
-            Object.values(scrollByPrefix).forEach(group => {
-                if (group.length > 0) {
-                    allClasses.add(group.join(' '));
-                }
-            });
-        });
-    });
-
-    // Group and sort motion classes by prefix length
-    const motionRegex = /^(.*?)motion-\[([^\]]+)\]:/;
-    const motionByName = {};
-    const nonMotionClasses = [];
-
-    Array.from(allClasses).forEach(cls => {
-        const match = cls.match(motionRegex);
-        if (match) {
-            const prefix = match[1]; // Everything before "motion-["
-            const animName = match[2];
-
-            if (!motionByName[animName]) {
-                motionByName[animName] = [];
-            }
-
-            motionByName[animName].push({
-                cls: cls,
-                prefix: prefix,
-                prefixLength: prefix.length
-            });
-        } else {
-            nonMotionClasses.push(cls);
-        }
-    });
-
-    // Sort each animation's classes by prefix length (shortest first)
-    const sortedMotionClasses = [];
-    Object.values(motionByName).forEach(group => {
-        group.sort((a, b) => a.prefixLength - b.prefixLength);
-        sortedMotionClasses.push(...group.map(item => item.cls));
-    });
-
-    // Rebuild allClasses: non-motion first, then sorted motion
-    allClasses.clear();
-    nonMotionClasses.forEach(c => allClasses.add(c));
-    sortedMotionClasses.forEach(c => allClasses.add(c));
-
-    return Array.from(allClasses);
-}
-
 const parseMediaConditions = (input, isContainer = false, isSupports = false) => {
     // ✅ Detect custom: prefix at the start and return as-is
     if (input.startsWith('custom:')) {
@@ -25952,7 +25743,7 @@ function runParser(config) {
             isFirstRun = true;
             previouslyParsedClasses = [];
             previouslyGeneratedProps.clear();
-            const fullResult = generateCSSString(collectClasses(), false, isFirstRun);
+            const fullResult = generateCSSString(collectClasses(config.content), false, isFirstRun);
             const finalCSS = removeNewlines(fullResult.css);  // ← Use fullResult, not result
             fs.writeFileSync(outputPath, finalCSS, 'utf8');
             isFirstRun = false;  // ← Reset the flag after rebuild