@ui-entropy/scanner-core 0.1.0

package/dist/crawl.js

@@ -0,0 +1,153 @@
+import fg from 'fast-glob';
+import { readFileSync } from 'fs';
+// import ignore from 'ignore';
+import { resolve, join } from 'path';
+const DEFAULT_CSS_PATTERNS = ['**/*.css', '**/*.scss', '**/*.sass'];
+const DEFAULT_SOURCE_PATTERNS = [
+    '**/*.html',
+    '**/*.tsx',
+    '**/*.ts',
+    '**/*.jsx',
+    '**/*.js',
+    '**/*.vue',
+    '**/*.svelte',
+];
+const DEFAULT_IGNORE_PATTERNS = [
+    'node_modules/**',
+    'dist/**',
+    'build/**',
+    '.git/**',
+    'coverage/**',
+    '.next/**',
+    '.nuxt/**',
+    'out/**',
+    'public/**', // Usually static assets, not source
+    '**/*.min.css',
+    '**/*.min.js',
+];
+/**
+ * Read and parse .gitignore file
+ */
+function readGitignore(baseDir) {
+    try {
+        const gitignorePath = join(baseDir, '.gitignore');
+        const content = readFileSync(gitignorePath, 'utf-8');
+        return content
+            .split('\n')
+            .map(line => line.trim())
+            .filter(line => line && !line.startsWith('#'))
+            .map(line => {
+            // Convert gitignore patterns to glob patterns
+            if (line.endsWith('/')) {
+                return line + '**';
+            }
+            return line;
+        });
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Crawl directory for CSS and source files
+ */
+export async function crawl(options) {
+    const { baseDir, cssPatterns = DEFAULT_CSS_PATTERNS, sourcePatterns = DEFAULT_SOURCE_PATTERNS, ignorePatterns = DEFAULT_IGNORE_PATTERNS, respectGitignore = true, } = options;
+    const absoluteBaseDir = resolve(baseDir);
+    // Build ignore patterns
+    let allIgnorePatterns = [...ignorePatterns];
+    if (respectGitignore) {
+        const gitignorePatterns = readGitignore(absoluteBaseDir);
+        allIgnorePatterns = [...allIgnorePatterns, ...gitignorePatterns];
+    }
+    // Find CSS files
+    const cssPaths = await fg(cssPatterns, {
+        cwd: absoluteBaseDir,
+        ignore: allIgnorePatterns,
+        absolute: false,
+        onlyFiles: true,
+    });
+    // Find source files
+    const sourcePaths = await fg(sourcePatterns, {
+        cwd: absoluteBaseDir,
+        ignore: allIgnorePatterns,
+        absolute: false,
+        onlyFiles: true,
+    });
+    // Read file contents
+    const cssFiles = cssPaths.map(path => {
+        const absolutePath = join(absoluteBaseDir, path);
+        const content = readFileSync(absolutePath, 'utf-8');
+        return { path, content };
+    });
+    const sourceFiles = sourcePaths.map(path => {
+        const absolutePath = join(absoluteBaseDir, path);
+        const content = readFileSync(absolutePath, 'utf-8');
+        return { path, content };
+    });
+    // Calculate stats
+    const totalCssBytes = cssFiles.reduce((sum, f) => sum + Buffer.byteLength(f.content), 0);
+    const totalSourceBytes = sourceFiles.reduce((sum, f) => sum + Buffer.byteLength(f.content), 0);
+    return {
+        cssFiles,
+        sourceFiles,
+        stats: {
+            totalCssFiles: cssFiles.length,
+            totalSourceFiles: sourceFiles.length,
+            totalCssBytes,
+            totalSourceBytes,
+        },
+    };
+}
+/**
+ * Synchronous version of crawl (useful for CLI/simple use cases)
+ */
+export function crawlSync(options) {
+    const { baseDir, cssPatterns = DEFAULT_CSS_PATTERNS, sourcePatterns = DEFAULT_SOURCE_PATTERNS, ignorePatterns = DEFAULT_IGNORE_PATTERNS, respectGitignore = true, } = options;
+    const absoluteBaseDir = resolve(baseDir);
+    // Build ignore patterns
+    let allIgnorePatterns = [...ignorePatterns];
+    if (respectGitignore) {
+        const gitignorePatterns = readGitignore(absoluteBaseDir);
+        allIgnorePatterns = [...allIgnorePatterns, ...gitignorePatterns];
+    }
+    // Find CSS files (sync)
+    const cssPaths = fg.sync(cssPatterns, {
+        cwd: absoluteBaseDir,
+        ignore: allIgnorePatterns,
+        absolute: false,
+        onlyFiles: true,
+    });
+    // Find source files (sync)
+    const sourcePaths = fg.sync(sourcePatterns, {
+        cwd: absoluteBaseDir,
+        ignore: allIgnorePatterns,
+        absolute: false,
+        onlyFiles: true,
+    });
+    // Read file contents
+    const cssFiles = cssPaths.map(path => {
+        const absolutePath = join(absoluteBaseDir, path);
+        const content = readFileSync(absolutePath, 'utf-8');
+        return { path, content };
+    });
+    const sourceFiles = sourcePaths.map(path => {
+        const absolutePath = join(absoluteBaseDir, path);
+        const content = readFileSync(absolutePath, 'utf-8');
+        return { path, content };
+    });
+    // Calculate stats
+    const totalCssBytes = cssFiles.reduce((sum, f) => sum + Buffer.byteLength(f.content), 0);
+    const totalSourceBytes = sourceFiles.reduce((sum, f) => sum + Buffer.byteLength(f.content), 0);
+    return {
+        cssFiles,
+        sourceFiles,
+        stats: {
+            totalCssFiles: cssFiles.length,
+            totalSourceFiles: sourceFiles.length,
+            totalCssBytes,
+            totalSourceBytes,
+        },
+    };
+}
+//# sourceMappingURL=crawl.js.map

package/dist/extract-usage.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Extracts CSS class and ID usage from source code files.
+ * Supports HTML, JSX/TSX, Vue, and Angular templates.
+ */
+export interface UsageExtractionResult {
+    classes: Set<string>;
+    ids: Set<string>;
+    filesScanned: number;
+}
+/**
+ * Extract used classes from a single source file
+ *
+ * @param sourceText - Contents of HTML/JSX/Vue/Angular file
+ * @returns Set of class names found in the source
+ */
+export declare function extractUsedClasses(sourceText: string): Set<string>;
+/**
+ * Extract used IDs from a single source file
+ *
+ * @param sourceText - Contents of HTML/JSX/Vue/Angular file
+ * @returns Set of ID names found in the source
+ */
+export declare function extractUsedIds(sourceText: string): Set<string>;
+/**
+ * Extract all usage from a single source file
+ *
+ * @param sourceText - Contents of source file
+ * @returns Classes and IDs found
+ */
+export declare function extractUsage(sourceText: string): Omit<UsageExtractionResult, 'filesScanned'>;
+/**
+ * Extract usage from multiple source files
+ *
+ * @param sourceFiles - Array of source file contents
+ * @returns Combined usage across all files
+ */
+export declare function extractUsageFromMultiple(sourceFiles: string[]): UsageExtractionResult;
+//# sourceMappingURL=extract-usage.d.ts.map

package/dist/extract-usage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract-usage.d.ts","sourceRoot":"","sources":["../src/extract-usage.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACrB,GAAG,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;CACtB;AA4CD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,CAyBlE;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,CAiB9D;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC,qBAAqB,EAAE,cAAc,CAAC,CAK5F;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,WAAW,EAAE,MAAM,EAAE,GAAG,qBAAqB,CAerF"}

package/dist/extract-usage.js

@@ -0,0 +1,118 @@
+/**
+ * Extracts CSS class and ID usage from source code files.
+ * Supports HTML, JSX/TSX, Vue, and Angular templates.
+ */
+/**
+ * Patterns for extracting class names from different file types
+ */
+const CLASS_PATTERNS = [
+    // HTML: class="btn primary"
+    /class="([^"]+)"/g,
+    /class='([^']+)'/g,
+    // JSX/TSX: className="btn" or className={'btn'}
+    /className="([^"]+)"/g,
+    /className='([^']+)'/g,
+    /className=\{["']([^"']+)["']\}/g,
+    // Vue: :class="..." or class="..." (both in template and data)
+    /:class="([^"]+)"/g,
+    /:class='([^']+)'/g,
+    /cardClass:\s*["']([^"']+)["']/g, // Vue data properties
+    // Angular: [class.btn]="true" or class="btn"
+    /\[class\.([^\]]+)\]/g,
+    // Tailwind clsx/classnames patterns: clsx("btn", "primary")
+    /clsx\(["']([^"']+)["']/g,
+    /classnames\(["']([^"']+)["']/g,
+    /cn\(["']([^"']+)["']/g,
+    // Generic utility function calls with class strings
+    /["']([a-z][\w-]*(?:\s+[a-z][\w-]*)+)["']/g, // Multi-word class strings
+];
+/**
+ * Patterns for extracting IDs
+ */
+const ID_PATTERNS = [
+    // HTML: id="main"
+    /id="([^"]+)"/g,
+    /id='([^']+)'/g,
+    // JSX/TSX: id="main"
+    /id=\{["']([^"']+)["']\}/g,
+];
+/**
+ * Extract used classes from a single source file
+ *
+ * @param sourceText - Contents of HTML/JSX/Vue/Angular file
+ * @returns Set of class names found in the source
+ */
+export function extractUsedClasses(sourceText) {
+    const classes = new Set();
+    for (const pattern of CLASS_PATTERNS) {
+        const matches = sourceText.matchAll(pattern);
+        for (const match of matches) {
+            const classString = match[1];
+            // Split by whitespace to handle multiple classes
+            // "btn btn-primary" -> ["btn", "btn-primary"]
+            const classNames = classString.split(/\s+/).filter(Boolean);
+            classNames.forEach(cls => {
+                // Remove common dynamic indicators but keep the base class
+                // E.g., "btn-${variant}" -> keep as potential match for "btn-primary"
+                // For now, we only keep literal strings
+                if (!cls.includes('${') && !cls.includes('{') && !cls.includes('}')) {
+                    classes.add(cls.trim());
+                }
+            });
+        }
+    }
+    return classes;
+}
+/**
+ * Extract used IDs from a single source file
+ *
+ * @param sourceText - Contents of HTML/JSX/Vue/Angular file
+ * @returns Set of ID names found in the source
+ */
+export function extractUsedIds(sourceText) {
+    const ids = new Set();
+    for (const pattern of ID_PATTERNS) {
+        const matches = sourceText.matchAll(pattern);
+        for (const match of matches) {
+            const idName = match[1];
+            // Only keep literal IDs (no template strings)
+            if (!idName.includes('${') && !idName.includes('{') && !idName.includes('}')) {
+                ids.add(idName.trim());
+            }
+        }
+    }
+    return ids;
+}
+/**
+ * Extract all usage from a single source file
+ *
+ * @param sourceText - Contents of source file
+ * @returns Classes and IDs found
+ */
+export function extractUsage(sourceText) {
+    return {
+        classes: extractUsedClasses(sourceText),
+        ids: extractUsedIds(sourceText),
+    };
+}
+/**
+ * Extract usage from multiple source files
+ *
+ * @param sourceFiles - Array of source file contents
+ * @returns Combined usage across all files
+ */
+export function extractUsageFromMultiple(sourceFiles) {
+    const allClasses = new Set();
+    const allIds = new Set();
+    for (const sourceText of sourceFiles) {
+        const usage = extractUsage(sourceText);
+        usage.classes.forEach(cls => allClasses.add(cls));
+        usage.ids.forEach(id => allIds.add(id));
+    }
+    return {
+        classes: allClasses,
+        ids: allIds,
+        filesScanned: sourceFiles.length,
+    };
+}
+//# sourceMappingURL=extract-usage.js.map

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { extractSelectors, extractSelectorsFromMultiple, type ExtractedSelectors, type ParseWarning, } from './parse-css.js';
+export { extractUsage, extractUsedClasses, extractUsedIds, extractUsageFromMultiple, type UsageExtractionResult, } from './extract-usage.js';
+export { analyzeWaste, estimateWastedBytes, type AnalysisResult, } from './analyze.js';
+export { generateReport, generateJsonReport, generateTextReport, generateSummaryReport, type ReportFormat, type JsonReport, } from './report.js';
+export { crawl, crawlSync, type CrawlOptions, type CrawlResult, } from './crawl.js';
+export { loadConfig, mergeConfig, getConfig, DEFAULT_CONFIG, type Config, } from './config.js';
+export { scan, quickScan, type ScanOptions, type ScanResult, } from './scan.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EACL,gBAAgB,EAChB,4BAA4B,EAC5B,KAAK,kBAAkB,EACvB,KAAK,YAAY,GAClB,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EACL,YAAY,EACZ,kBAAkB,EAClB,cAAc,EACd,wBAAwB,EACxB,KAAK,qBAAqB,GAC3B,MAAM,oBAAoB,CAAC;AAG5B,OAAO,EACL,YAAY,EACZ,mBAAmB,EACnB,KAAK,cAAc,GACpB,MAAM,cAAc,CAAC;AAGtB,OAAO,EACL,cAAc,EACd,kBAAkB,EAClB,kBAAkB,EAClB,qBAAqB,EACrB,KAAK,YAAY,EACjB,KAAK,UAAU,GAChB,MAAM,aAAa,CAAC;AAGrB,OAAO,EACL,KAAK,EACL,SAAS,EACT,KAAK,YAAY,EACjB,KAAK,WAAW,GACjB,MAAM,YAAY,CAAC;AAGpB,OAAO,EACL,UAAU,EACV,WAAW,EACX,SAAS,EACT,cAAc,EACd,KAAK,MAAM,GACZ,MAAM,aAAa,CAAC;AAGrB,OAAO,EACL,IAAI,EACJ,SAAS,EACT,KAAK,WAAW,EAChB,KAAK,UAAU,GAChB,MAAM,WAAW,CAAC"}

package/dist/index.js

@@ -0,0 +1,15 @@
+// CSS Parsing
+export { extractSelectors, extractSelectorsFromMultiple, } from './parse-css.js';
+// Usage Extraction
+export { extractUsage, extractUsedClasses, extractUsedIds, extractUsageFromMultiple, } from './extract-usage.js';
+// Analysis
+export { analyzeWaste, estimateWastedBytes, } from './analyze.js';
+// Reporting
+export { generateReport, generateJsonReport, generateTextReport, generateSummaryReport, } from './report.js';
+// File System
+export { crawl, crawlSync, } from './crawl.js';
+// Configuration
+export { loadConfig, mergeConfig, getConfig, DEFAULT_CONFIG, } from './config.js';
+// Main Scanner
+export { scan, quickScan, } from './scan.js';
+//# sourceMappingURL=index.js.map

package/dist/parse-css.d.ts

@@ -0,0 +1,35 @@
+export interface ParseWarning {
+    type: 'css-parse-error';
+    file?: string;
+    line?: number;
+    column?: number;
+    message: string;
+    severity: 'warning' | 'error';
+}
+export interface ExtractedSelectors {
+    classes: Set<string>;
+    ids: Set<string>;
+    totalRules: number;
+    totalBytes: number;
+    warnings: ParseWarning[];
+}
+/**
+ * Extracts class and ID selectors from CSS text.
+ * This is the core engine for detecting potentially unused CSS.
+ *
+ * @param cssText - Raw CSS content as a string
+ * @param filename - Optional filename for better error reporting
+ * @returns Object containing sets of classes and ids, plus metadata
+ */
+export declare function extractSelectors(cssText: string, filename?: string): ExtractedSelectors;
+/**
+ * Extracts selectors from multiple CSS files/strings
+ *
+ * @param cssFiles - Array of CSS content strings or file objects with path and content
+ * @returns Combined extracted selectors
+ */
+export declare function extractSelectorsFromMultiple(cssFiles: string[] | Array<{
+    path: string;
+    content: string;
+}>): ExtractedSelectors;
+//# sourceMappingURL=parse-css.d.ts.map

package/dist/parse-css.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-css.d.ts","sourceRoot":"","sources":["../src/parse-css.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,iBAAiB,CAAC;IACxB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,SAAS,GAAG,OAAO,CAAC;CAC/B;AAED,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACrB,GAAG,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,YAAY,EAAE,CAAC;CAC1B;AA+CD;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,kBAAkB,CAiHvF;AAED;;;;;GAKG;AACH,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,MAAM,EAAE,GAAG,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,GAC5D,kBAAkB,CAyBpB"}

package/dist/parse-css.js

@@ -0,0 +1,186 @@
+import postcss from 'postcss';
+import selectorParser from 'postcss-selector-parser';
+// Common file extensions that should not be treated as CSS classes
+const FILE_EXTENSIONS = new Set([
+    // JavaScript/TypeScript
+    'js', 'jsx', 'ts', 'tsx', 'mjs', 'cjs', 'mts', 'cts',
+    // Frameworks/Libraries
+    'vue', 'svelte', 'astro', 'mdx',
+    // Markup
+    'html', 'htm', 'xhtml', 'xml', 'svg',
+    // Stylesheets
+    'css', 'scss', 'sass', 'less', 'styl', 'stylus', 'pcss',
+    // Data/Config
+    'json', 'json5', 'jsonc', 'yaml', 'yml', 'toml', 'ini', 'env', 'config', 'conf',
+    // Documentation
+    'md', 'mdx', 'markdown', 'txt', 'rst',
+    // Images
+    'png', 'jpg', 'jpeg', 'gif', 'webp', 'avif', 'svg', 'ico', 'bmp', 'tiff',
+    // Fonts
+    'woff', 'woff2', 'ttf', 'eot', 'otf',
+    // Media
+    'mp4', 'webm', 'ogg', 'mp3', 'wav', 'flac', 'm4a',
+    // Code/Scripts
+    'py', 'rb', 'php', 'java', 'go', 'rs', 'sh', 'bash', 'zsh',
+    // Database/API
+    'sql', 'graphql', 'gql', 'prisma',
+    // Build/Test
+    'map', 'lock', 'test', 'spec', 'stories',
+]);
+/**
+ * Check if a string looks like a file extension or other non-class pattern
+ */
+function isValidCSSClass(value) {
+    // Filter out file extensions
+    if (FILE_EXTENSIONS.has(value.toLowerCase())) {
+        return false;
+    }
+    // Must start with letter, underscore, or hyphen (not a number)
+    if (!/^[a-zA-Z_-]/.test(value)) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Extracts class and ID selectors from CSS text.
+ * This is the core engine for detecting potentially unused CSS.
+ *
+ * @param cssText - Raw CSS content as a string
+ * @param filename - Optional filename for better error reporting
+ * @returns Object containing sets of classes and ids, plus metadata
+ */
+export function extractSelectors(cssText, filename) {
+    const classes = new Set();
+    const ids = new Set();
+    let totalRules = 0;
+    const warnings = [];
+    try {
+        // Preprocess CSS to handle Tailwind directives that PostCSS doesn't understand
+        let processedCss = cssText;
+        // Remove Tailwind v3 directives (@tailwind base/components/utilities)
+        processedCss = processedCss.replace(/@tailwind\s+[^;]+;/g, '');
+        // Remove Tailwind v4 @use directive
+        processedCss = processedCss.replace(/@use\s+["']tailwindcss["'];?/g, '');
+        // Remove SCSS/SASS comments that PostCSS doesn't handle
+        processedCss = processedCss.replace(/\/\/[^\n]*/g, '');
+        const root = postcss.parse(processedCss);
+        root.walkRules((rule) => {
+            totalRules++;
+            // Parse each selector in the rule
+            try {
+                selectorParser((selectors) => {
+                    selectors.each((selector) => {
+                        // Walk through each node in the selector
+                        selector.each((node) => {
+                            if (node.type === 'class') {
+                                if (isValidCSSClass(node.value)) {
+                                    classes.add(node.value);
+                                }
+                            }
+                            else if (node.type === 'id') {
+                                // Filter out hex colors (3, 4, 6, or 8 hex digits)
+                                // Valid hex color: #fff, #ffff, #ffffff, #ffffffff
+                                const isHexColor = /^[0-9a-fA-F]{3}$|^[0-9a-fA-F]{4}$|^[0-9a-fA-F]{6}$|^[0-9a-fA-F]{8}$/.test(node.value);
+                                if (!isHexColor) {
+                                    ids.add(node.value);
+                                }
+                            }
+                        });
+                    });
+                }).processSync(rule.selector);
+            }
+            catch (selectorError) {
+                // Skip invalid selectors but continue processing
+                // This handles edge cases in complex CSS
+            }
+        });
+    }
+    catch (error) {
+        // If PostCSS parsing fails completely, use regex fallback
+        const errorMsg = error instanceof Error ? error.message : 'Unknown error';
+        const fileInfo = filename ? ` in file "${filename}"` : '';
+        // Extract line/column from PostCSS error message (format: "<css input>:LINE:COL: message")
+        let line;
+        let column;
+        const lineColMatch = errorMsg.match(/:?(\d+):(\d+):/);
+        if (lineColMatch) {
+            line = parseInt(lineColMatch[1], 10);
+            column = parseInt(lineColMatch[2], 10);
+        }
+        // Create warning object
+        const warning = {
+            type: 'css-parse-error',
+            file: filename,
+            line,
+            column,
+            message: errorMsg,
+            severity: 'warning',
+        };
+        warnings.push(warning);
+        // Also log to console for immediate feedback
+        console.warn(`⚠️  PostCSS parsing failed${fileInfo}, using regex fallback`);
+        console.warn(`   Error: ${errorMsg}`);
+        if (filename) {
+            console.warn(`   File: ${filename}`);
+        }
+        // Fallback: Extract class selectors using regex
+        // Match class names including Tailwind variants (e.g., hover\:bg-blue-500)
+        // Pattern: . followed by letter/underscore, then any word chars, hyphens, or escaped colons
+        const classMatches = cssText.matchAll(/\.([a-zA-Z_][\w-]*(?:\\:[\w-]+)*)/g);
+        for (const match of classMatches) {
+            // Unescape the class name (remove backslashes before colons)
+            const className = match[1].replace(/\\:/g, ':');
+            if (isValidCSSClass(className)) {
+                classes.add(className);
+            }
+        }
+        // Fallback: Extract ID selectors using regex
+        // Only match valid IDs (start with letter or underscore, not hex colors)
+        const idMatches = cssText.matchAll(/#([a-zA-Z_][\w-]*)/g);
+        for (const match of idMatches) {
+            // Double-check: filter out hex colors
+            const isHexColor = /^[0-9a-fA-F]{3}$|^[0-9a-fA-F]{4}$|^[0-9a-fA-F]{6}$|^[0-9a-fA-F]{8}$/.test(match[1]);
+            if (!isHexColor) {
+                ids.add(match[1]);
+            }
+        }
+    }
+    return {
+        classes,
+        ids,
+        totalRules,
+        totalBytes: Buffer.byteLength(cssText, 'utf8'),
+        warnings,
+    };
+}
+/**
+ * Extracts selectors from multiple CSS files/strings
+ *
+ * @param cssFiles - Array of CSS content strings or file objects with path and content
+ * @returns Combined extracted selectors
+ */
+export function extractSelectorsFromMultiple(cssFiles) {
+    const allClasses = new Set();
+    const allIds = new Set();
+    let totalRules = 0;
+    let totalBytes = 0;
+    const allWarnings = [];
+    for (const file of cssFiles) {
+        const cssText = typeof file === 'string' ? file : file.content;
+        const filename = typeof file === 'string' ? undefined : file.path;
+        const result = extractSelectors(cssText, filename);
+        result.classes.forEach((cls) => allClasses.add(cls));
+        result.ids.forEach((id) => allIds.add(id));
+        totalRules += result.totalRules;
+        totalBytes += result.totalBytes;
+        allWarnings.push(...result.warnings);
+    }
+    return {
+        classes: allClasses,
+        ids: allIds,
+        totalRules,
+        totalBytes,
+        warnings: allWarnings,
+    };
+}
+//# sourceMappingURL=parse-css.js.map

package/dist/report.d.ts

@@ -0,0 +1,55 @@
+import type { AnalysisResult } from './analyze.js';
+import type { ParseWarning } from './parse-css.js';
+/**
+ * Report format options
+ */
+export type ReportFormat = 'json' | 'text' | 'summary';
+/**
+ * JSON report structure (for dashboard ingestion)
+ */
+export interface JsonReport {
+    version: string;
+    timestamp: string;
+    summary: {
+        totalCssBytes: number;
+        totalRules: number;
+        totalSelectors: number;
+        usedSelectors: number;
+        unusedSelectors: number;
+        wastePercentage: number;
+        estimatedWastedBytes: number;
+        filesScanned: number;
+    };
+    details: {
+        classes: {
+            total: number;
+            used: number;
+            unused: number;
+            unusedList: string[];
+        };
+        ids: {
+            total: number;
+            used: number;
+            unused: number;
+            unusedList: string[];
+        };
+    };
+    warnings: ParseWarning[];
+}
+/**
+ * Generate JSON report from analysis
+ */
+export declare function generateJsonReport(analysis: AnalysisResult, warnings?: ParseWarning[]): JsonReport;
+/**
+ * Generate human-readable text report
+ */
+export declare function generateTextReport(analysis: AnalysisResult): string;
+/**
+ * Generate a brief summary report (for CLI output)
+ */
+export declare function generateSummaryReport(analysis: AnalysisResult): string;
+/**
+ * Generate report in specified format
+ */
+export declare function generateReport(analysis: AnalysisResult, format?: ReportFormat, warnings?: ParseWarning[]): string;
+//# sourceMappingURL=report.d.ts.map

package/dist/report.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"report.d.ts","sourceRoot":"","sources":["../src/report.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAEnD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAEnD;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;AAEvD;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE;QACP,aAAa,EAAE,MAAM,CAAC;QACtB,UAAU,EAAE,MAAM,CAAC;QACnB,cAAc,EAAE,MAAM,CAAC;QACvB,aAAa,EAAE,MAAM,CAAC;QACtB,eAAe,EAAE,MAAM,CAAC;QACxB,eAAe,EAAE,MAAM,CAAC;QACxB,oBAAoB,EAAE,MAAM,CAAC;QAC7B,YAAY,EAAE,MAAM,CAAC;KACtB,CAAC;IACF,OAAO,EAAE;QACP,OAAO,EAAE;YACP,KAAK,EAAE,MAAM,CAAC;YACd,IAAI,EAAE,MAAM,CAAC;YACb,MAAM,EAAE,MAAM,CAAC;YACf,UAAU,EAAE,MAAM,EAAE,CAAC;SACtB,CAAC;QACF,GAAG,EAAE;YACH,KAAK,EAAE,MAAM,CAAC;YACd,IAAI,EAAE,MAAM,CAAC;YACb,MAAM,EAAE,MAAM,CAAC;YACf,UAAU,EAAE,MAAM,EAAE,CAAC;SACtB,CAAC;KACH,CAAC;IACF,QAAQ,EAAE,YAAY,EAAE,CAAC;CAC1B;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,cAAc,EAAE,QAAQ,GAAE,YAAY,EAAO,GAAG,UAAU,CAkCtG;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,cAAc,GAAG,MAAM,CA8EnE;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,cAAc,GAAG,MAAM,CAStE;AAED;;GAEG;AACH,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,cAAc,EACxB,MAAM,GAAE,YAAqB,EAC7B,QAAQ,GAAE,YAAY,EAAO,GAC5B,MAAM,CAUR"}