xatriumcss 1.0.0

package/src/collectClasses.js

@@ -0,0 +1,477 @@
+const fs = require('fs');
+const { glob } = require('glob');
+
+let nativeScanner;
+try {
+  nativeScanner = require('../scripts/index.js'); 
+} catch (e) {
+  console.warn('⚠️  Native scanner not available, falling back to JavaScript');
+  nativeScanner = null;
+}
+
+function smartSplitNoBrace(str, ...splitChars) {
+    if (splitChars.length === 0) splitChars = [' '];
+
+    const result = [];
+    let current = '';
+    let bracketDepth = 0;
+    let parenDepth = 0;
+    let braceDepth = 0;
+    let inQuote = null;
+
+    for (let i = 0; i < str.length; i++) {
+        const char = str[i];
+        const prevChar = str[i - 1];
+
+        // Handle quotes (not escaped)
+        if ((char === "'" || char === '"') && prevChar !== '\\') {
+            if (!inQuote) {
+                inQuote = char;
+            } else if (inQuote === char) {
+                inQuote = null;
+            }
+            current += char;
+            continue;
+        }
+
+        // Track depths only when not in quotes
+        if (!inQuote) {
+            if (char === '[') bracketDepth++;
+            if (char === ']' && bracketDepth > 0) bracketDepth--;
+            if (char === '(') parenDepth++;
+            if (char === ')' && parenDepth > 0) parenDepth--;
+
+            // Track brace depth with prefix check
+            if (char === '{') {
+                // Check if there's content in current token (means there's a prefix)
+                const hasPrefix = current.trim().length > 0;
+
+                // Always increment brace depth
+                braceDepth++;
+
+                // But if there's a prefix, we're in "keep together" mode
+                // The depth will prevent splitting until we hit the closing }
+            }
+
+            if (char === '}' && braceDepth > 0) {
+                braceDepth--;
+            }
+        }
+
+        // ✅ Split on specified characters only if all depths are 0 and not in quotes
+        let shouldSplit = false;
+        if (bracketDepth === 0 && parenDepth === 0 && braceDepth === 0) {
+            // Check single character splits
+            if (splitChars.includes(char)) {
+                shouldSplit = true;
+            }
+            // Check multi-character splits (like "::")
+            for (let splitStr of splitChars) {
+                if (splitStr.length > 1 && str.slice(i, i + splitStr.length) === splitStr) {
+                    shouldSplit = true;
+                    i += splitStr.length - 1; // Skip ahead
+                    break;
+                }
+            }
+        }
+
+        if (shouldSplit) {
+            if (current) result.push(current);
+            current = '';
+        } else {
+            current += char;
+        }
+    }
+
+    if (current) result.push(current);
+    return result;
+}
+
+function collectClasses(contentPaths) {
+  const sourceConfig = global.xatriumSourceConfig || {
+    basePath: null,
+    disableAuto: false,
+    explicitPaths: [],
+    ignorePaths: []
+  };
+
+  // Use native scanner if available
+  if (nativeScanner) {
+    try {
+      const scanner = new nativeScanner.Scanner();
+      
+      // Add patterns
+      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));
+      
+      console.log('🚀 Using native scanner (Rust)');
+      const rawClasses = scanner.scanAndExtract();
+      
+      return processClasses(rawClasses);
+    } catch (error) {
+      console.warn('⚠️  Native scanner failed, falling back:', error.message);
+    }
+  }
+  
+  // Fallback to JavaScript implementation
+  return collectClassesJS(contentPaths);
+}
+
+function processClasses(rawClasses) {
+  const allClasses = new Set();
+  
+  rawClasses.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);
+}
+
+function collectClassesJS(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);
+}
+
+module.exports = collectClasses;

package/src/index.js

@@ -0,0 +1,26 @@
+// scripts/index.js
+const { platform, arch } = process;
+
+const platformMap = {
+  'win32-x64': 'win32-x64-msvc',
+  'darwin-x64': 'darwin-x64',
+  'darwin-arm64': 'darwin-arm64',
+  'linux-x64': 'linux-x64-gnu',
+  'linux-arm64': 'linux-arm64-gnu'
+};
+
+const platformKey = `${platform}-${arch}`;
+const nativeName = platformMap[platformKey];
+
+if (!nativeName) {
+  throw new Error(`Unsupported platform: ${platformKey}`);
+}
+
+let native;
+try {
+  native = require(`./xatriumcss.${nativeName}.node`);
+} catch (err) {
+  throw new Error(`Failed to load native module for ${platformKey}: ${err.message}`);
+}
+
+module.exports = native;