@styleframe/scanner 2.0.0

package/dist/index.cjs

@@ -0,0 +1,665 @@
+(function(global, factory) {
+  typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("node:fs/promises"), require("fast-glob")) : typeof define === "function" && define.amd ? define(["exports", "node:fs/promises", "fast-glob"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global.index = {}, global.promises, global.fg));
+})(this, (function(exports2, promises, fg) {
+  "use strict";
+  function hashContent(content) {
+    let hash = 0;
+    for (let i = 0; i < content.length; i++) {
+      const char = content.charCodeAt(i);
+      hash = (hash << 5) - hash + char;
+      hash = hash & hash;
+    }
+    return `${hash.toString(16)}-${content.length}`;
+  }
+  function createCache() {
+    const entries = /* @__PURE__ */ new Map();
+    return {
+      get(filePath) {
+        const entry = entries.get(filePath);
+        return entry?.result ?? null;
+      },
+      set(filePath, result, contentHash) {
+        entries.set(filePath, {
+          hash: contentHash,
+          result,
+          timestamp: Date.now()
+        });
+      },
+      isValid(filePath, contentHash) {
+        const entry = entries.get(filePath);
+        return entry !== void 0 && entry.hash === contentHash;
+      },
+      getIfValid(filePath, contentHash) {
+        const entry = entries.get(filePath);
+        if (entry && entry.hash === contentHash) {
+          return entry.result;
+        }
+        return null;
+      },
+      invalidate(filePath) {
+        entries.delete(filePath);
+      },
+      clear() {
+        entries.clear();
+      }
+    };
+  }
+  const UTILITY_CLASS_PATTERN = /_[a-zA-Z][a-zA-Z0-9-]*(?::[a-zA-Z0-9._-]+|:\[[^\]]+\])*/g;
+  const ARBITRARY_VALUE_PATTERN = /^\[(.+)\]$/;
+  const DEFAULT_EXTENSIONS = [
+    "html",
+    "htm",
+    "vue",
+    "svelte",
+    "jsx",
+    "tsx",
+    "js",
+    "ts",
+    "astro",
+    "mdx",
+    "php",
+    "erb",
+    "twig",
+    "blade.php"
+  ];
+  const DEFAULT_IGNORE_PATTERNS = [
+    "**/node_modules/**",
+    "**/.git/**",
+    "**/dist/**",
+    "**/build/**",
+    "**/.next/**",
+    "**/.nuxt/**",
+    "**/coverage/**"
+  ];
+  function parseUtilityClass(className) {
+    if (!className.startsWith("_")) {
+      return null;
+    }
+    const withoutPrefix = className.slice(1);
+    if (!withoutPrefix) {
+      return null;
+    }
+    const segments = splitByColons(withoutPrefix);
+    if (segments.length === 0) {
+      return null;
+    }
+    let name;
+    let value;
+    let modifiers = [];
+    if (segments.length === 1) {
+      name = segments[0];
+      value = "default";
+    } else {
+      value = segments[segments.length - 1];
+      name = segments[segments.length - 2];
+      modifiers = segments.slice(0, -2);
+    }
+    let isArbitrary = false;
+    let arbitraryValue;
+    const arbitraryMatch = value.match(ARBITRARY_VALUE_PATTERN);
+    if (arbitraryMatch) {
+      isArbitrary = true;
+      arbitraryValue = arbitraryMatch[1];
+    }
+    return {
+      raw: className,
+      name,
+      value,
+      modifiers,
+      isArbitrary,
+      arbitraryValue
+    };
+  }
+  function splitByColons(str) {
+    const segments = [];
+    let current = "";
+    let bracketDepth = 0;
+    for (const char of str) {
+      if (char === "[") {
+        bracketDepth++;
+        current += char;
+      } else if (char === "]") {
+        bracketDepth--;
+        current += char;
+      } else if (char === ":" && bracketDepth === 0) {
+        if (current) {
+          segments.push(current);
+        }
+        current = "";
+      } else {
+        current += char;
+      }
+    }
+    if (bracketDepth !== 0) {
+      return [];
+    }
+    if (current) {
+      segments.push(current);
+    }
+    return segments;
+  }
+  function extractUtilityClasses(content) {
+    const matches = content.match(UTILITY_CLASS_PATTERN);
+    return matches ? [...new Set(matches)] : [];
+  }
+  function generateUtilityClassName(name, value, modifiers = []) {
+    const parts = [...modifiers, name];
+    if (value !== "default") {
+      parts.push(value);
+    }
+    return `_${parts.join(":")}`;
+  }
+  const CLASSNAME_EXPR_PATTERN = /\bclassName\s*=\s*\{/g;
+  const CLASS_EXPR_PATTERN = /\bclass\s*=\s*\{/g;
+  const CLASS_ATTR_PATTERN = /\bclass\s*=\s*["']([^"']+)["']/gi;
+  const CLASSNAME_STRING_PATTERN = /\bclassName\s*=\s*["']([^"']+)["']/gi;
+  const SVELTE_CLASS_DIRECTIVE_PATTERN = /\bclass:(_[a-zA-Z][a-zA-Z0-9-:[\]._]*)/g;
+  const SINGLE_QUOTE_PATTERN = /'([^'\\]*(?:\\.[^'\\]*)*)'/g;
+  const DOUBLE_QUOTE_PATTERN = /"([^"\\]*(?:\\.[^"\\]*)*)"/g;
+  const TEMPLATE_LITERAL_PATTERN = /`([^`\\]*(?:\\.[^`\\]*)*)`/g;
+  function extractBracedContent(str) {
+    let depth = 1;
+    let i = 0;
+    while (i < str.length && depth > 0) {
+      const char = str[i];
+      if (char === "{") {
+        depth++;
+      } else if (char === "}") {
+        depth--;
+      }
+      i++;
+    }
+    if (depth !== 0) {
+      return null;
+    }
+    return str.slice(0, i - 1);
+  }
+  function extractClassNameExpressions(content) {
+    const results = [];
+    CLASSNAME_EXPR_PATTERN.lastIndex = 0;
+    let match;
+    while ((match = CLASSNAME_EXPR_PATTERN.exec(content)) !== null) {
+      const startIndex = match.index + match[0].length;
+      const remaining = content.slice(startIndex);
+      const bracedContent = extractBracedContent(remaining);
+      if (bracedContent !== null) {
+        results.push(bracedContent);
+      }
+    }
+    return results;
+  }
+  function extractClassExpressions(content) {
+    const results = [];
+    CLASS_EXPR_PATTERN.lastIndex = 0;
+    let match;
+    while ((match = CLASS_EXPR_PATTERN.exec(content)) !== null) {
+      const startIndex = match.index + match[0].length;
+      const remaining = content.slice(startIndex);
+      const bracedContent = extractBracedContent(remaining);
+      if (bracedContent !== null) {
+        results.push(bracedContent);
+      }
+    }
+    return results;
+  }
+  function extractFromHTML(content) {
+    const classes = [];
+    CLASS_ATTR_PATTERN.lastIndex = 0;
+    let match;
+    while ((match = CLASS_ATTR_PATTERN.exec(content)) !== null) {
+      if (match[1]) {
+        classes.push(...extractUtilityClasses(match[1]));
+      }
+    }
+    return classes;
+  }
+  function extractFromJSX(content) {
+    const classes = [];
+    CLASSNAME_STRING_PATTERN.lastIndex = 0;
+    let match;
+    while ((match = CLASSNAME_STRING_PATTERN.exec(content)) !== null) {
+      if (match[1]) {
+        classes.push(...extractUtilityClasses(match[1]));
+      }
+    }
+    const expressions = extractClassNameExpressions(content);
+    for (const expr of expressions) {
+      classes.push(...extractFromStringLiterals(expr));
+    }
+    return [...new Set(classes)];
+  }
+  function extractFromVue(content) {
+    const classes = [];
+    const templateMatch = content.match(/<template[^>]*>([\s\S]*?)<\/template>/i);
+    if (templateMatch?.[1]) {
+      classes.push(...extractFromHTML(templateMatch[1]));
+      classes.push(...extractFromStringLiterals(templateMatch[1]));
+    }
+    const scriptMatch = content.match(/<script[^>]*>([\s\S]*?)<\/script>/i);
+    if (scriptMatch?.[1]) {
+      classes.push(...extractFromStringLiterals(scriptMatch[1]));
+    }
+    return [...new Set(classes)];
+  }
+  function extractFromSvelte(content) {
+    const classes = [];
+    classes.push(...extractFromHTML(content));
+    const expressions = extractClassExpressions(content);
+    for (const expr of expressions) {
+      classes.push(...extractFromStringLiterals(expr));
+    }
+    SVELTE_CLASS_DIRECTIVE_PATTERN.lastIndex = 0;
+    let match;
+    while ((match = SVELTE_CLASS_DIRECTIVE_PATTERN.exec(content)) !== null) {
+      if (match[1]) {
+        classes.push(match[1]);
+      }
+    }
+    const scriptMatch = content.match(/<script[^>]*>([\s\S]*?)<\/script>/i);
+    if (scriptMatch?.[1]) {
+      classes.push(...extractFromStringLiterals(scriptMatch[1]));
+    }
+    return [...new Set(classes)];
+  }
+  function extractFromAstro(content) {
+    const classes = [];
+    classes.push(...extractFromHTML(content));
+    classes.push(...extractFromJSX(content));
+    const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    if (frontmatterMatch?.[1]) {
+      classes.push(...extractFromStringLiterals(frontmatterMatch[1]));
+    }
+    return [...new Set(classes)];
+  }
+  function extractFromStringLiterals(content) {
+    const classes = [];
+    let match;
+    SINGLE_QUOTE_PATTERN.lastIndex = 0;
+    while ((match = SINGLE_QUOTE_PATTERN.exec(content)) !== null) {
+      if (match[1]) {
+        classes.push(...extractUtilityClasses(match[1]));
+      }
+    }
+    DOUBLE_QUOTE_PATTERN.lastIndex = 0;
+    while ((match = DOUBLE_QUOTE_PATTERN.exec(content)) !== null) {
+      if (match[1]) {
+        classes.push(...extractUtilityClasses(match[1]));
+      }
+    }
+    TEMPLATE_LITERAL_PATTERN.lastIndex = 0;
+    while ((match = TEMPLATE_LITERAL_PATTERN.exec(content)) !== null) {
+      if (match[1]) {
+        classes.push(...extractUtilityClasses(match[1]));
+      }
+    }
+    return classes;
+  }
+  function extractFromMDX(content) {
+    const classes = [];
+    classes.push(...extractFromHTML(content));
+    classes.push(...extractFromJSX(content));
+    return [...new Set(classes)];
+  }
+  const defaultExtractors = {
+    html: extractFromHTML,
+    htm: extractFromHTML,
+    vue: extractFromVue,
+    svelte: extractFromSvelte,
+    jsx: extractFromJSX,
+    tsx: extractFromJSX,
+    js: extractFromStringLiterals,
+    ts: extractFromStringLiterals,
+    astro: extractFromAstro,
+    mdx: extractFromMDX,
+    php: extractFromHTML,
+    erb: extractFromHTML,
+    twig: extractFromHTML,
+    "blade.php": extractFromHTML
+  };
+  function getExtension(filePath) {
+    if (filePath.endsWith(".blade.php")) {
+      return "blade.php";
+    }
+    const parts = filePath.split(".");
+    return parts[parts.length - 1]?.toLowerCase() ?? "";
+  }
+  function extractClasses(content, filePath, customExtractors) {
+    const classes = [];
+    const extension = getExtension(filePath);
+    if (customExtractors) {
+      for (const extractor of customExtractors) {
+        classes.push(...extractor(content, filePath));
+      }
+    }
+    const defaultExtractor = defaultExtractors[extension];
+    if (defaultExtractor) {
+      classes.push(...defaultExtractor(content));
+    } else {
+      classes.push(...extractFromStringLiterals(content));
+    }
+    return [...new Set(classes)];
+  }
+  function generateValueKey(value, modifiers) {
+    if (modifiers.length === 0) {
+      return value;
+    }
+    const sortedModifiers = [...modifiers].sort().join(",");
+    return `${value}|${sortedModifiers}`;
+  }
+  function matchUtilities(parsed, root) {
+    const utilityMap = /* @__PURE__ */ new Map();
+    const modifierMap = /* @__PURE__ */ new Map();
+    const factoryValueSets = /* @__PURE__ */ new Map();
+    for (const utility of root.utilities) {
+      utilityMap.set(utility.name, utility);
+      const valueSet = /* @__PURE__ */ new Set();
+      for (const v of utility.values) {
+        valueSet.add(generateValueKey(v.key, v.modifiers));
+      }
+      factoryValueSets.set(utility, valueSet);
+    }
+    for (const modifier of root.modifiers) {
+      for (const key of modifier.key) {
+        modifierMap.set(key, modifier);
+      }
+    }
+    const matches = [];
+    for (const parsedClass of parsed) {
+      const factory = utilityMap.get(parsedClass.name) ?? null;
+      const matchedModifiers = [];
+      for (const modKey of parsedClass.modifiers) {
+        const modifier = modifierMap.get(modKey);
+        if (modifier) {
+          matchedModifiers.push(modifier);
+        }
+      }
+      let exists = false;
+      if (factory) {
+        const lookupKey = generateValueKey(
+          parsedClass.value,
+          parsedClass.modifiers
+        );
+        const valueSet = factoryValueSets.get(factory);
+        exists = valueSet?.has(lookupKey) ?? false;
+      }
+      matches.push({
+        parsed: parsedClass,
+        factory,
+        modifierFactories: matchedModifiers,
+        exists
+      });
+    }
+    return matches;
+  }
+  function generateUtilitySelector(options) {
+    const { name, value, modifiers } = options;
+    const parts = [
+      ...modifiers,
+      name,
+      ...value === "default" ? [] : [value]
+    ].filter(Boolean);
+    return `._${parts.join("\\:").replace(/[[\].#()%,]/g, "\\$&")}`;
+  }
+  function classNameFromUtilityOptions(options) {
+    const { name, value, modifiers } = options;
+    const parts = [
+      ...modifiers,
+      name,
+      ...value === "default" ? [] : [value]
+    ].filter(Boolean);
+    return `_${parts.join(":")}`;
+  }
+  function createUtilityFilter(usedClasses) {
+    return (utility) => {
+      const className = classNameFromUtilityOptions({
+        name: utility.name,
+        value: utility.value,
+        modifiers: utility.modifiers
+      });
+      return usedClasses.has(className);
+    };
+  }
+  function filterUtilities(root, usedClasses) {
+    const filter = createUtilityFilter(usedClasses);
+    return root.children.filter((child) => {
+      if (child.type !== "utility") {
+        return true;
+      }
+      return filter(child);
+    });
+  }
+  function getUsedClassNames(matches) {
+    const classNames = /* @__PURE__ */ new Set();
+    for (const match of matches) {
+      classNames.add(match.parsed.raw);
+    }
+    return classNames;
+  }
+  function getValidMatches(matches) {
+    return matches.filter((m) => m.factory !== null);
+  }
+  function getExistingMatches(matches) {
+    return matches.filter((m) => m.exists);
+  }
+  function getArbitraryMatches(matches) {
+    return matches.filter((m) => m.parsed.isArbitrary);
+  }
+  const compiledPatternCache = /* @__PURE__ */ new Map();
+  function getCompiledPattern(pattern) {
+    const normalized = pattern.replace(/\\/g, "/");
+    if (compiledPatternCache.has(normalized)) {
+      return compiledPatternCache.get(normalized);
+    }
+    if (!normalized.includes("**") && !normalized.includes("*") && !normalized.includes("?")) {
+      compiledPatternCache.set(normalized, null);
+      return null;
+    }
+    try {
+      const regexStr = globToRegex(normalized);
+      const regex = new RegExp(`^${regexStr}$`);
+      compiledPatternCache.set(normalized, regex);
+      return regex;
+    } catch {
+      compiledPatternCache.set(normalized, null);
+      return null;
+    }
+  }
+  function debounce(fn, delay) {
+    let timeoutId = null;
+    return (...args) => {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+      timeoutId = setTimeout(() => {
+        fn(...args);
+        timeoutId = null;
+      }, delay);
+    };
+  }
+  function createChangeHandler(callback, options = {}) {
+    const { debounce: debounceMs = 100 } = options;
+    const changedFiles = /* @__PURE__ */ new Set();
+    let timeoutId = null;
+    const flush = () => {
+      if (changedFiles.size > 0) {
+        const files = [...changedFiles];
+        changedFiles.clear();
+        callback(files);
+      }
+    };
+    const onChange = (filePath) => {
+      changedFiles.add(filePath);
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+      timeoutId = setTimeout(() => {
+        flush();
+        timeoutId = null;
+      }, debounceMs);
+    };
+    return { onChange, flush };
+  }
+  function escapeRegexChars(str) {
+    return str.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+  }
+  function globToRegex(pattern) {
+    return pattern.replace(/\*\*/g, "<<<GLOBSTAR>>>").replace(/\*/g, "<<<STAR>>>").replace(/\?/g, "<<<QUESTION>>>").split("<<<GLOBSTAR>>>").map(escapeRegexChars).join(".*").replace(/<<<STAR>>>/g, "[^/]*").replace(/<<<QUESTION>>>/g, ".");
+  }
+  function matchesPatterns(filePath, patterns) {
+    const normalizedPath = filePath.replace(/\\/g, "/");
+    for (const pattern of patterns) {
+      const compiledRegex = getCompiledPattern(pattern);
+      if (compiledRegex !== null) {
+        if (compiledRegex.test(normalizedPath)) {
+          return true;
+        }
+      } else {
+        const normalizedPattern = pattern.replace(/\\/g, "/");
+        if (normalizedPath === normalizedPattern) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  function createScanner(config) {
+    const cache = createCache();
+    const cwd = config.cwd ?? process.cwd();
+    const customExtractors = config.extractors;
+    async function getFilePaths() {
+      return fg(config.content, {
+        cwd,
+        absolute: true,
+        ignore: DEFAULT_IGNORE_PATTERNS
+      });
+    }
+    async function scanFile(filePath) {
+      const content = await promises.readFile(filePath, "utf-8");
+      const contentHash = hashContent(content);
+      const cached = cache.getIfValid(filePath, contentHash);
+      if (cached) {
+        return cached;
+      }
+      const classNames = extractClasses(content, filePath, customExtractors);
+      const parsed = classNames.map(parseUtilityClass).filter((p) => p !== null);
+      const result = {
+        path: filePath,
+        classes: new Set(classNames),
+        parsed,
+        lastScanned: Date.now()
+      };
+      cache.set(filePath, result, contentHash);
+      return result;
+    }
+    function scanContent(content, filePath = "inline") {
+      const classNames = extractClasses(content, filePath, customExtractors);
+      return classNames.map(parseUtilityClass).filter((p) => p !== null);
+    }
+    async function scan() {
+      const filePaths = await getFilePaths();
+      const files = /* @__PURE__ */ new Map();
+      const allClasses = /* @__PURE__ */ new Set();
+      const allParsed = [];
+      const results = await Promise.all(
+        filePaths.map(async (filePath) => {
+          try {
+            return await scanFile(filePath);
+          } catch (error) {
+            console.warn(
+              `[styleframe/scanner] Failed to scan ${filePath}:`,
+              error
+            );
+            return null;
+          }
+        })
+      );
+      for (const result of results) {
+        if (result) {
+          files.set(result.path, result);
+          for (const className of result.classes) {
+            allClasses.add(className);
+          }
+          allParsed.push(...result.parsed);
+        }
+      }
+      return {
+        files,
+        allClasses,
+        allParsed
+      };
+    }
+    function match(parsed, root) {
+      return matchUtilities(parsed, root);
+    }
+    function watch(callback) {
+      const { onChange, flush } = createChangeHandler(async (changedFiles) => {
+        for (const filePath of changedFiles) {
+          cache.invalidate(filePath);
+        }
+        const result = await scan();
+        callback(result);
+      });
+      return () => {
+        flush();
+      };
+    }
+    function invalidate(filePath) {
+      if (filePath) {
+        cache.invalidate(filePath);
+      } else {
+        cache.clear();
+      }
+    }
+    return {
+      scan,
+      scanFile,
+      scanContent,
+      match,
+      watch,
+      invalidate
+    };
+  }
+  function quickScan(content, filePath = "inline.html") {
+    const classNames = extractClasses(content, filePath);
+    return classNames.map(parseUtilityClass).filter((p) => p !== null);
+  }
+  function createContentScanner(customExtractors) {
+    return (content, filePath = "inline") => {
+      const classNames = extractClasses(content, filePath, customExtractors);
+      return classNames.map(parseUtilityClass).filter((p) => p !== null);
+    };
+  }
+  exports2.ARBITRARY_VALUE_PATTERN = ARBITRARY_VALUE_PATTERN;
+  exports2.DEFAULT_EXTENSIONS = DEFAULT_EXTENSIONS;
+  exports2.DEFAULT_IGNORE_PATTERNS = DEFAULT_IGNORE_PATTERNS;
+  exports2.UTILITY_CLASS_PATTERN = UTILITY_CLASS_PATTERN;
+  exports2.classNameFromUtilityOptions = classNameFromUtilityOptions;
+  exports2.createCache = createCache;
+  exports2.createChangeHandler = createChangeHandler;
+  exports2.createContentScanner = createContentScanner;
+  exports2.createScanner = createScanner;
+  exports2.createUtilityFilter = createUtilityFilter;
+  exports2.debounce = debounce;
+  exports2.extractClasses = extractClasses;
+  exports2.extractFromAstro = extractFromAstro;
+  exports2.extractFromHTML = extractFromHTML;
+  exports2.extractFromJSX = extractFromJSX;
+  exports2.extractFromMDX = extractFromMDX;
+  exports2.extractFromStringLiterals = extractFromStringLiterals;
+  exports2.extractFromSvelte = extractFromSvelte;
+  exports2.extractFromVue = extractFromVue;
+  exports2.extractUtilityClasses = extractUtilityClasses;
+  exports2.filterUtilities = filterUtilities;
+  exports2.generateUtilityClassName = generateUtilityClassName;
+  exports2.generateUtilitySelector = generateUtilitySelector;
+  exports2.getArbitraryMatches = getArbitraryMatches;
+  exports2.getExistingMatches = getExistingMatches;
+  exports2.getUsedClassNames = getUsedClassNames;
+  exports2.getValidMatches = getValidMatches;
+  exports2.hashContent = hashContent;
+  exports2.matchUtilities = matchUtilities;
+  exports2.matchesPatterns = matchesPatterns;
+  exports2.parseUtilityClass = parseUtilityClass;
+  exports2.quickScan = quickScan;
+  Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+}));