css-to-tailwind-react 0.1.0

package/dist/cssParser.js

@@ -0,0 +1,215 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CSSParser = void 0;
+const postcss_1 = __importDefault(require("postcss"));
+const postcss_safe_parser_1 = __importDefault(require("postcss-safe-parser"));
+const logger_1 = require("./utils/logger");
+class CSSParser {
+    constructor(mapper) {
+        this.mapper = mapper;
+    }
+    async parse(css, filePath) {
+        const rules = [];
+        const warnings = [];
+        let hasChanges = false;
+        try {
+            const root = await (0, postcss_1.default)().process(css, {
+                parser: postcss_safe_parser_1.default,
+                from: filePath
+            }).then(result => result.root);
+            // Process each rule
+            root.walkRules((rule) => {
+                // Skip rules inside @media, @supports, etc.
+                if (rule.parent && rule.parent.type === 'atrule') {
+                    warnings.push(`Skipped rule with at-rule parent: ${rule.selector}`);
+                    logger_1.logger.verbose(`Skipping at-rule: ${rule.selector}`);
+                    return;
+                }
+                // Skip pseudo-selectors
+                if (rule.selector.includes(':')) {
+                    warnings.push(`Skipped pseudo-selector: ${rule.selector}`);
+                    logger_1.logger.verbose(`Skipping pseudo-selector: ${rule.selector}`);
+                    return;
+                }
+                // Only process simple class selectors
+                const classNameMatch = rule.selector.match(/^\.([a-zA-Z_-][a-zA-Z0-9_-]*)$/);
+                if (!classNameMatch) {
+                    warnings.push(`Skipped complex selector: ${rule.selector}`);
+                    logger_1.logger.verbose(`Skipping complex selector: ${rule.selector}`);
+                    return;
+                }
+                const className = classNameMatch[1];
+                const declarations = [];
+                rule.walkDecls((decl) => {
+                    // Skip CSS variables
+                    if (decl.prop.startsWith('--')) {
+                        warnings.push(`Skipped CSS variable: ${decl.prop}`);
+                        return;
+                    }
+                    // Skip calc()
+                    if (decl.value.includes('calc(')) {
+                        warnings.push(`Skipped calc() value: ${decl.value}`);
+                        return;
+                    }
+                    declarations.push({
+                        property: decl.prop,
+                        value: decl.value
+                    });
+                });
+                if (declarations.length === 0) {
+                    return;
+                }
+                // Convert to Tailwind classes - track which specific declarations were converted
+                const conversionResults = [];
+                const conversionWarnings = [];
+                declarations.forEach(decl => {
+                    const result = this.mapper.convertProperty(decl.property, decl.value);
+                    conversionResults.push({
+                        declaration: decl,
+                        converted: !result.skipped && result.className !== null,
+                        className: result.className
+                    });
+                    if (result.skipped && result.reason) {
+                        conversionWarnings.push(result.reason);
+                    }
+                });
+                const convertedClasses = conversionResults
+                    .filter(r => r.converted && r.className)
+                    .map(r => r.className);
+                const allDeclarationsConverted = conversionResults.every(r => r.converted);
+                const someDeclarationsConverted = convertedClasses.length > 0;
+                const cssRule = {
+                    selector: rule.selector,
+                    className,
+                    declarations,
+                    convertedClasses,
+                    skipped: !someDeclarationsConverted,
+                    fullyConverted: allDeclarationsConverted,
+                    partialConversion: someDeclarationsConverted && !allDeclarationsConverted,
+                    reason: !someDeclarationsConverted ? 'No convertible declarations' : undefined
+                };
+                rules.push(cssRule);
+                warnings.push(...conversionWarnings);
+                // CRITICAL FIX: Only remove declarations that were successfully converted
+                // Never remove the entire rule unless ALL declarations are converted
+                if (someDeclarationsConverted) {
+                    hasChanges = true;
+                    if (allDeclarationsConverted) {
+                        // All declarations converted - safe to remove entire rule
+                        rule.remove();
+                        logger_1.logger.verbose(`Removed rule .${className} (all ${declarations.length} declarations converted)`);
+                    }
+                    else {
+                        // Partial conversion - only remove the converted declarations
+                        let removedCount = 0;
+                        rule.walkDecls((decl) => {
+                            const wasConverted = conversionResults.some(r => r.converted &&
+                                r.declaration.property === decl.prop &&
+                                r.declaration.value === decl.value);
+                            if (wasConverted) {
+                                decl.remove();
+                                removedCount++;
+                            }
+                        });
+                        logger_1.logger.verbose(`Partial conversion of .${className}: removed ${removedCount}/${declarations.length} declarations`);
+                    }
+                }
+            });
+            // Clean up empty at-rules
+            root.walkAtRules((atRule) => {
+                if (atRule.nodes && atRule.nodes.length === 0) {
+                    atRule.remove();
+                }
+            });
+            const canDelete = root.nodes.length === 0;
+            const newCss = root.toString();
+            return {
+                css: newCss,
+                rules,
+                hasChanges,
+                canDelete,
+                warnings
+            };
+        }
+        catch (error) {
+            logger_1.logger.error(`Failed to parse CSS ${filePath}:`, error);
+            throw new Error(`CSS parsing failed: ${error}`);
+        }
+    }
+    parseInternalStyle(html) {
+        const styles = [];
+        const warnings = [];
+        // Simple regex to find style tags (this is safe for finding tags, not for parsing content)
+        const styleRegex = /<style[^>]*>([\s\S]*?)<\/style>/gi;
+        let match;
+        while ((match = styleRegex.exec(html)) !== null) {
+            styles.push({
+                content: match[1].trim(),
+                start: match.index,
+                end: match.index + match[0].length
+            });
+        }
+        return { styles, warnings };
+    }
+    async parseInternalCSS(html, filePath) {
+        const allRules = [];
+        const allWarnings = [];
+        let modifiedHtml = html;
+        let hasChanges = false;
+        const { styles } = this.parseInternalStyle(html);
+        // Process styles in reverse order to preserve indices
+        for (let i = styles.length - 1; i >= 0; i--) {
+            const style = styles[i];
+            try {
+                const result = await this.parse(style.content, filePath);
+                allRules.push(...result.rules);
+                allWarnings.push(...result.warnings);
+                if (result.hasChanges) {
+                    hasChanges = true;
+                    if (result.canDelete || result.css.trim() === '') {
+                        // Remove entire style tag
+                        modifiedHtml = modifiedHtml.slice(0, style.start) + modifiedHtml.slice(style.end);
+                    }
+                    else {
+                        // Replace style content
+                        const before = modifiedHtml.slice(0, style.start);
+                        const after = modifiedHtml.slice(style.end);
+                        const tagStart = html.slice(style.start).match(/<style[^>]*>/)?.[0] || '<style>';
+                        const tagEnd = '</style>';
+                        modifiedHtml = before + tagStart + '\n' + result.css + '\n' + tagEnd + after;
+                    }
+                }
+            }
+            catch (error) {
+                logger_1.logger.warn(`Failed to parse internal style block: ${error}`);
+                allWarnings.push(`Failed to parse internal style: ${error}`);
+            }
+        }
+        return {
+            html: modifiedHtml,
+            rules: allRules,
+            hasChanges,
+            warnings: allWarnings
+        };
+    }
+    extractImportPaths(code) {
+        const imports = [];
+        // Match CSS imports
+        const importRegex = /import\s+['"]([^'"]+\.css)['"];?/g;
+        let match;
+        while ((match = importRegex.exec(code)) !== null) {
+            imports.push(match[1]);
+        }
+        // Match require statements
+        const requireRegex = /require\s*\(\s*['"]([^'"]+\.css)['"]\s*\)/g;
+        while ((match = requireRegex.exec(code)) !== null) {
+            imports.push(match[1]);
+        }
+        return imports;
+    }
+}
+exports.CSSParser = CSSParser;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cssParser.js","sourceRoot":"","sources":["../src/cssParser.ts"],"names":[],"mappings":"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","sourcesContent":["import postcss, { Root, Rule, Declaration, AtRule } from 'postcss';\nimport safeParser from 'postcss-safe-parser';\nimport { TailwindMapper, CSSProperty } from './tailwindMapper';\nimport { logger } from './utils/logger';\n\nexport interface CSSRule {\n  selector: string;\n  className: string;\n  declarations: CSSProperty[];\n  convertedClasses: string[];\n  skipped: boolean;\n  fullyConverted: boolean; // NEW: true if ALL declarations in this rule were converted\n  partialConversion: boolean; // NEW: true if SOME but not all declarations were converted\n  reason?: string;\n}\n\nexport interface CSSParseResult {\n  css: string;\n  rules: CSSRule[];\n  hasChanges: boolean;\n  canDelete: boolean;\n  warnings: string[];\n}\n\nexport interface CSSUsageMap {\n  [className: string]: string[]; // className -> file paths\n}\n\nexport class CSSParser {\n  private mapper: TailwindMapper;\n\n  constructor(mapper: TailwindMapper) {\n    this.mapper = mapper;\n  }\n\n  async parse(css: string, filePath: string): Promise<CSSParseResult> {\n    const rules: CSSRule[] = [];\n    const warnings: string[] = [];\n    let hasChanges = false;\n\n    try {\n      const root = await postcss().process(css, {\n        parser: safeParser,\n        from: filePath\n      }).then(result => result.root);\n\n      // Process each rule\n      root.walkRules((rule) => {\n        // Skip rules inside @media, @supports, etc.\n        if (rule.parent && rule.parent.type === 'atrule') {\n          warnings.push(`Skipped rule with at-rule parent: ${rule.selector}`);\n          logger.verbose(`Skipping at-rule: ${rule.selector}`);\n          return;\n        }\n\n        // Skip pseudo-selectors\n        if (rule.selector.includes(':')) {\n          warnings.push(`Skipped pseudo-selector: ${rule.selector}`);\n          logger.verbose(`Skipping pseudo-selector: ${rule.selector}`);\n          return;\n        }\n\n        // Only process simple class selectors\n        const classNameMatch = rule.selector.match(/^\\.([a-zA-Z_-][a-zA-Z0-9_-]*)$/);\n        if (!classNameMatch) {\n          warnings.push(`Skipped complex selector: ${rule.selector}`);\n          logger.verbose(`Skipping complex selector: ${rule.selector}`);\n          return;\n        }\n\n        const className = classNameMatch[1];\n        const declarations: CSSProperty[] = [];\n\n        rule.walkDecls((decl) => {\n          // Skip CSS variables\n          if (decl.prop.startsWith('--')) {\n            warnings.push(`Skipped CSS variable: ${decl.prop}`);\n            return;\n          }\n\n          // Skip calc()\n          if (decl.value.includes('calc(')) {\n            warnings.push(`Skipped calc() value: ${decl.value}`);\n            return;\n          }\n\n          declarations.push({\n            property: decl.prop,\n            value: decl.value\n          });\n        });\n\n        if (declarations.length === 0) {\n          return;\n        }\n\n        // Convert to Tailwind classes - track which specific declarations were converted\n        const conversionResults: Array<{\n          declaration: CSSProperty;\n          converted: boolean;\n          className: string | null;\n        }> = [];\n        const conversionWarnings: string[] = [];\n\n        declarations.forEach(decl => {\n          const result = this.mapper.convertProperty(decl.property, decl.value);\n          conversionResults.push({\n            declaration: decl,\n            converted: !result.skipped && result.className !== null,\n            className: result.className\n          });\n          if (result.skipped && result.reason) {\n            conversionWarnings.push(result.reason);\n          }\n        });\n\n        const convertedClasses = conversionResults\n          .filter(r => r.converted && r.className)\n          .map(r => r.className!);\n        \n        const allDeclarationsConverted = conversionResults.every(r => r.converted);\n        const someDeclarationsConverted = convertedClasses.length > 0;\n\n        const cssRule: CSSRule = {\n          selector: rule.selector,\n          className,\n          declarations,\n          convertedClasses,\n          skipped: !someDeclarationsConverted,\n          fullyConverted: allDeclarationsConverted,\n          partialConversion: someDeclarationsConverted && !allDeclarationsConverted,\n          reason: !someDeclarationsConverted ? 'No convertible declarations' : undefined\n        };\n\n        rules.push(cssRule);\n        warnings.push(...conversionWarnings);\n\n        // CRITICAL FIX: Only remove declarations that were successfully converted\n        // Never remove the entire rule unless ALL declarations are converted\n        if (someDeclarationsConverted) {\n          hasChanges = true;\n          \n          if (allDeclarationsConverted) {\n            // All declarations converted - safe to remove entire rule\n            rule.remove();\n            logger.verbose(`Removed rule .${className} (all ${declarations.length} declarations converted)`);\n          } else {\n            // Partial conversion - only remove the converted declarations\n            let removedCount = 0;\n            rule.walkDecls((decl) => {\n              const wasConverted = conversionResults.some(r => \n                r.converted && \n                r.declaration.property === decl.prop && \n                r.declaration.value === decl.value\n              );\n              \n              if (wasConverted) {\n                decl.remove();\n                removedCount++;\n              }\n            });\n            \n            logger.verbose(`Partial conversion of .${className}: removed ${removedCount}/${declarations.length} declarations`);\n          }\n        }\n      });\n\n      // Clean up empty at-rules\n      root.walkAtRules((atRule) => {\n        if (atRule.nodes && atRule.nodes.length === 0) {\n          atRule.remove();\n        }\n      });\n\n      const canDelete = root.nodes.length === 0;\n      const newCss = root.toString();\n\n      return {\n        css: newCss,\n        rules,\n        hasChanges,\n        canDelete,\n        warnings\n      };\n\n    } catch (error) {\n      logger.error(`Failed to parse CSS ${filePath}:`, error);\n      throw new Error(`CSS parsing failed: ${error}`);\n    }\n  }\n\n  parseInternalStyle(html: string): { \n    styles: Array<{ content: string; start: number; end: number }>;\n    warnings: string[];\n  } {\n    const styles: Array<{ content: string; start: number; end: number }> = [];\n    const warnings: string[] = [];\n\n    // Simple regex to find style tags (this is safe for finding tags, not for parsing content)\n    const styleRegex = /<style[^>]*>([\\s\\S]*?)<\\/style>/gi;\n    let match;\n\n    while ((match = styleRegex.exec(html)) !== null) {\n      styles.push({\n        content: match[1].trim(),\n        start: match.index,\n        end: match.index + match[0].length\n      });\n    }\n\n    return { styles, warnings };\n  }\n\n  async parseInternalCSS(html: string, filePath: string): Promise<{\n    html: string;\n    rules: CSSRule[];\n    hasChanges: boolean;\n    warnings: string[];\n  }> {\n    const allRules: CSSRule[] = [];\n    const allWarnings: string[] = [];\n    let modifiedHtml = html;\n    let hasChanges = false;\n\n    const { styles } = this.parseInternalStyle(html);\n\n    // Process styles in reverse order to preserve indices\n    for (let i = styles.length - 1; i >= 0; i--) {\n      const style = styles[i];\n      \n      try {\n        const result = await this.parse(style.content, filePath);\n        \n        allRules.push(...result.rules);\n        allWarnings.push(...result.warnings);\n\n        if (result.hasChanges) {\n          hasChanges = true;\n\n          if (result.canDelete || result.css.trim() === '') {\n            // Remove entire style tag\n            modifiedHtml = modifiedHtml.slice(0, style.start) + modifiedHtml.slice(style.end);\n          } else {\n            // Replace style content\n            const before = modifiedHtml.slice(0, style.start);\n            const after = modifiedHtml.slice(style.end);\n            const tagStart = html.slice(style.start).match(/<style[^>]*>/)?.[0] || '<style>';\n            const tagEnd = '</style>';\n            modifiedHtml = before + tagStart + '\\n' + result.css + '\\n' + tagEnd + after;\n          }\n        }\n      } catch (error) {\n        logger.warn(`Failed to parse internal style block: ${error}`);\n        allWarnings.push(`Failed to parse internal style: ${error}`);\n      }\n    }\n\n    return {\n      html: modifiedHtml,\n      rules: allRules,\n      hasChanges,\n      warnings: allWarnings\n    };\n  }\n\n  extractImportPaths(code: string): string[] {\n    const imports: string[] = [];\n    \n    // Match CSS imports\n    const importRegex = /import\\s+['\"]([^'\"]+\\.css)['\"];?/g;\n    let match;\n    \n    while ((match = importRegex.exec(code)) !== null) {\n      imports.push(match[1]);\n    }\n\n    // Match require statements\n    const requireRegex = /require\\s*\\(\\s*['\"]([^'\"]+\\.css)['\"]\\s*\\)/g;\n    while ((match = requireRegex.exec(code)) !== null) {\n      imports.push(match[1]);\n    }\n\n    return imports;\n  }\n}\n"]}

package/dist/fileWriter.d.ts

@@ -0,0 +1,14 @@
+export interface FileWriteOptions {
+    dryRun: boolean;
+    backup?: boolean;
+}
+export declare class FileWriter {
+    private dryRun;
+    private backupDir;
+    constructor(options: FileWriteOptions);
+    writeFile(filePath: string, content: string, originalContent: string): Promise<boolean>;
+    deleteFile(filePath: string): Promise<boolean>;
+    private createBackup;
+    private showDiff;
+    static restoreBackups(): void;
+}

package/dist/fileWriter.js

@@ -0,0 +1,128 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileWriter = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const logger_1 = require("./utils/logger");
+class FileWriter {
+    constructor(options) {
+        this.dryRun = options.dryRun;
+        this.backupDir = path_1.default.join(process.cwd(), '.css-to-tailwind-backups');
+    }
+    async writeFile(filePath, content, originalContent) {
+        if (this.dryRun) {
+            this.showDiff(filePath, originalContent, content);
+            return true;
+        }
+        try {
+            // Create backup
+            await this.createBackup(filePath, originalContent);
+            // Write file
+            fs_1.default.writeFileSync(filePath, content, 'utf-8');
+            logger_1.logger.success(`✏️  Modified: ${path_1.default.relative(process.cwd(), filePath)}`);
+            return true;
+        }
+        catch (error) {
+            logger_1.logger.error(`Failed to write ${filePath}:`, error);
+            return false;
+        }
+    }
+    async deleteFile(filePath) {
+        if (this.dryRun) {
+            logger_1.logger.info(`🗑️  Would delete: ${path_1.default.relative(process.cwd(), filePath)}`);
+            return true;
+        }
+        try {
+            // Create backup before deletion
+            const content = fs_1.default.readFileSync(filePath, 'utf-8');
+            await this.createBackup(filePath, content);
+            fs_1.default.unlinkSync(filePath);
+            logger_1.logger.success(`🗑️  Deleted: ${path_1.default.relative(process.cwd(), filePath)}`);
+            return true;
+        }
+        catch (error) {
+            logger_1.logger.error(`Failed to delete ${filePath}:`, error);
+            return false;
+        }
+    }
+    async createBackup(filePath, content) {
+        try {
+            // Create backup directory if it doesn't exist
+            if (!fs_1.default.existsSync(this.backupDir)) {
+                fs_1.default.mkdirSync(this.backupDir, { recursive: true });
+            }
+            const relativePath = path_1.default.relative(process.cwd(), filePath);
+            const backupPath = path_1.default.join(this.backupDir, relativePath);
+            const backupDir = path_1.default.dirname(backupPath);
+            // Create subdirectory structure
+            if (!fs_1.default.existsSync(backupDir)) {
+                fs_1.default.mkdirSync(backupDir, { recursive: true });
+            }
+            // Write backup
+            fs_1.default.writeFileSync(backupPath, content, 'utf-8');
+            logger_1.logger.verbose(`Created backup: ${backupPath}`);
+        }
+        catch (error) {
+            logger_1.logger.warn(`Failed to create backup for ${filePath}:`, error);
+        }
+    }
+    showDiff(filePath, original, modified) {
+        const relativePath = path_1.default.relative(process.cwd(), filePath);
+        logger_1.logger.info(`\n📄 ${relativePath} (dry-run)`);
+        const originalLines = original.split('\n');
+        const modifiedLines = modified.split('\n');
+        // Simple diff - show first few changed lines
+        const maxLines = Math.max(originalLines.length, modifiedLines.length);
+        let changes = 0;
+        for (let i = 0; i < maxLines && changes < 10; i++) {
+            const orig = originalLines[i] || '';
+            const mod = modifiedLines[i] || '';
+            if (orig !== mod) {
+                changes++;
+                console.log(chalk_1.default.red(`  - ${orig}`));
+                console.log(chalk_1.default.green(`  + ${mod}`));
+            }
+        }
+        if (changes === 0) {
+            logger_1.logger.verbose('  (no visible changes)');
+        }
+    }
+    static restoreBackups() {
+        const backupDir = path_1.default.join(process.cwd(), '.css-to-tailwind-backups');
+        if (!fs_1.default.existsSync(backupDir)) {
+            logger_1.logger.warn('No backups found to restore');
+            return;
+        }
+        logger_1.logger.info('🔄 Restoring files from backup...');
+        // Recursively restore files
+        const restoreRecursive = (dir) => {
+            const items = fs_1.default.readdirSync(dir);
+            for (const item of items) {
+                const fullPath = path_1.default.join(dir, item);
+                const stat = fs_1.default.statSync(fullPath);
+                if (stat.isDirectory()) {
+                    restoreRecursive(fullPath);
+                }
+                else {
+                    const relativePath = path_1.default.relative(backupDir, fullPath);
+                    const originalPath = path_1.default.join(process.cwd(), relativePath);
+                    try {
+                        fs_1.default.copyFileSync(fullPath, originalPath);
+                        logger_1.logger.success(`Restored: ${relativePath}`);
+                    }
+                    catch (error) {
+                        logger_1.logger.error(`Failed to restore ${relativePath}:`, error);
+                    }
+                }
+            }
+        };
+        restoreRecursive(backupDir);
+        logger_1.logger.success('✅ Restore complete');
+    }
+}
+exports.FileWriter = FileWriter;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fileWriter.js","sourceRoot":"","sources":["../src/fileWriter.ts"],"names":[],"mappings":"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","sourcesContent":["import fs from 'fs';\nimport path from 'path';\nimport chalk from 'chalk';\nimport { logger } from './utils/logger';\n\nexport interface FileWriteOptions {\n  dryRun: boolean;\n  backup?: boolean;\n}\n\nexport class FileWriter {\n  private dryRun: boolean;\n  private backupDir: string;\n\n  constructor(options: FileWriteOptions) {\n    this.dryRun = options.dryRun;\n    this.backupDir = path.join(process.cwd(), '.css-to-tailwind-backups');\n  }\n\n  async writeFile(filePath: string, content: string, originalContent: string): Promise<boolean> {\n    if (this.dryRun) {\n      this.showDiff(filePath, originalContent, content);\n      return true;\n    }\n\n    try {\n      // Create backup\n      await this.createBackup(filePath, originalContent);\n\n      // Write file\n      fs.writeFileSync(filePath, content, 'utf-8');\n      logger.success(`✏️  Modified: ${path.relative(process.cwd(), filePath)}`);\n      return true;\n    } catch (error) {\n      logger.error(`Failed to write ${filePath}:`, error);\n      return false;\n    }\n  }\n\n  async deleteFile(filePath: string): Promise<boolean> {\n    if (this.dryRun) {\n      logger.info(`🗑️  Would delete: ${path.relative(process.cwd(), filePath)}`);\n      return true;\n    }\n\n    try {\n      // Create backup before deletion\n      const content = fs.readFileSync(filePath, 'utf-8');\n      await this.createBackup(filePath, content);\n\n      fs.unlinkSync(filePath);\n      logger.success(`🗑️  Deleted: ${path.relative(process.cwd(), filePath)}`);\n      return true;\n    } catch (error) {\n      logger.error(`Failed to delete ${filePath}:`, error);\n      return false;\n    }\n  }\n\n  private async createBackup(filePath: string, content: string): Promise<void> {\n    try {\n      // Create backup directory if it doesn't exist\n      if (!fs.existsSync(this.backupDir)) {\n        fs.mkdirSync(this.backupDir, { recursive: true });\n      }\n\n      const relativePath = path.relative(process.cwd(), filePath);\n      const backupPath = path.join(this.backupDir, relativePath);\n      const backupDir = path.dirname(backupPath);\n\n      // Create subdirectory structure\n      if (!fs.existsSync(backupDir)) {\n        fs.mkdirSync(backupDir, { recursive: true });\n      }\n\n      // Write backup\n      fs.writeFileSync(backupPath, content, 'utf-8');\n      logger.verbose(`Created backup: ${backupPath}`);\n    } catch (error) {\n      logger.warn(`Failed to create backup for ${filePath}:`, error);\n    }\n  }\n\n  private showDiff(filePath: string, original: string, modified: string): void {\n    const relativePath = path.relative(process.cwd(), filePath);\n    logger.info(`\\n📄 ${relativePath} (dry-run)`);\n    \n    const originalLines = original.split('\\n');\n    const modifiedLines = modified.split('\\n');\n\n    // Simple diff - show first few changed lines\n    const maxLines = Math.max(originalLines.length, modifiedLines.length);\n    let changes = 0;\n\n    for (let i = 0; i < maxLines && changes < 10; i++) {\n      const orig = originalLines[i] || '';\n      const mod = modifiedLines[i] || '';\n\n      if (orig !== mod) {\n        changes++;\n        console.log(chalk.red(`  - ${orig}`));\n        console.log(chalk.green(`  + ${mod}`));\n      }\n    }\n\n    if (changes === 0) {\n      logger.verbose('  (no visible changes)');\n    }\n  }\n\n  static restoreBackups(): void {\n    const backupDir = path.join(process.cwd(), '.css-to-tailwind-backups');\n    \n    if (!fs.existsSync(backupDir)) {\n      logger.warn('No backups found to restore');\n      return;\n    }\n\n    logger.info('🔄 Restoring files from backup...');\n    \n    // Recursively restore files\n    const restoreRecursive = (dir: string) => {\n      const items = fs.readdirSync(dir);\n\n      for (const item of items) {\n        const fullPath = path.join(dir, item);\n        const stat = fs.statSync(fullPath);\n\n        if (stat.isDirectory()) {\n          restoreRecursive(fullPath);\n        } else {\n          const relativePath = path.relative(backupDir, fullPath);\n          const originalPath = path.join(process.cwd(), relativePath);\n          \n          try {\n            fs.copyFileSync(fullPath, originalPath);\n            logger.success(`Restored: ${relativePath}`);\n          } catch (error) {\n            logger.error(`Failed to restore ${relativePath}:`, error);\n          }\n        }\n      }\n    };\n\n    restoreRecursive(backupDir);\n    logger.success('✅ Restore complete');\n  }\n}\n"]}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { scanProject, ScannedFile } from './scanner';
+export { transformFiles, TransformOptions, TransformResults } from './transformer';
+export { TailwindMapper, CSSProperty, ConversionResult } from './tailwindMapper';
+export { JSXParser, JSXTransformation, JSXParseResult } from './jsxParser';
+export { CSSParser, CSSRule, CSSParseResult } from './cssParser';
+export { FileWriter, FileWriteOptions } from './fileWriter';
+export { loadTailwindConfig, TailwindConfig } from './utils/config';
+export { logger } from './utils/logger';

package/dist/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = exports.loadTailwindConfig = exports.FileWriter = exports.CSSParser = exports.JSXParser = exports.TailwindMapper = exports.transformFiles = exports.scanProject = void 0;
+// Export public API
+var scanner_1 = require("./scanner");
+Object.defineProperty(exports, "scanProject", { enumerable: true, get: function () { return scanner_1.scanProject; } });
+var transformer_1 = require("./transformer");
+Object.defineProperty(exports, "transformFiles", { enumerable: true, get: function () { return transformer_1.transformFiles; } });
+var tailwindMapper_1 = require("./tailwindMapper");
+Object.defineProperty(exports, "TailwindMapper", { enumerable: true, get: function () { return tailwindMapper_1.TailwindMapper; } });
+var jsxParser_1 = require("./jsxParser");
+Object.defineProperty(exports, "JSXParser", { enumerable: true, get: function () { return jsxParser_1.JSXParser; } });
+var cssParser_1 = require("./cssParser");
+Object.defineProperty(exports, "CSSParser", { enumerable: true, get: function () { return cssParser_1.CSSParser; } });
+var fileWriter_1 = require("./fileWriter");
+Object.defineProperty(exports, "FileWriter", { enumerable: true, get: function () { return fileWriter_1.FileWriter; } });
+var config_1 = require("./utils/config");
+Object.defineProperty(exports, "loadTailwindConfig", { enumerable: true, get: function () { return config_1.loadTailwindConfig; } });
+var logger_1 = require("./utils/logger");
+Object.defineProperty(exports, "logger", { enumerable: true, get: function () { return logger_1.logger; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsb0JBQW9CO0FBQ3BCLHFDQUFxRDtBQUE1QyxzR0FBQSxXQUFXLE9BQUE7QUFDcEIsNkNBQW1GO0FBQTFFLDZHQUFBLGNBQWMsT0FBQTtBQUN2QixtREFBaUY7QUFBeEUsZ0hBQUEsY0FBYyxPQUFBO0FBQ3ZCLHlDQUEyRTtBQUFsRSxzR0FBQSxTQUFTLE9BQUE7QUFDbEIseUNBQWlFO0FBQXhELHNHQUFBLFNBQVMsT0FBQTtBQUNsQiwyQ0FBNEQ7QUFBbkQsd0dBQUEsVUFBVSxPQUFBO0FBQ25CLHlDQUFvRTtBQUEzRCw0R0FBQSxrQkFBa0IsT0FBQTtBQUMzQix5Q0FBd0M7QUFBL0IsZ0dBQUEsTUFBTSxPQUFBIiwic291cmNlc0NvbnRlbnQiOlsiLy8gRXhwb3J0IHB1YmxpYyBBUElcbmV4cG9ydCB7IHNjYW5Qcm9qZWN0LCBTY2FubmVkRmlsZSB9IGZyb20gJy4vc2Nhbm5lcic7XG5leHBvcnQgeyB0cmFuc2Zvcm1GaWxlcywgVHJhbnNmb3JtT3B0aW9ucywgVHJhbnNmb3JtUmVzdWx0cyB9IGZyb20gJy4vdHJhbnNmb3JtZXInO1xuZXhwb3J0IHsgVGFpbHdpbmRNYXBwZXIsIENTU1Byb3BlcnR5LCBDb252ZXJzaW9uUmVzdWx0IH0gZnJvbSAnLi90YWlsd2luZE1hcHBlcic7XG5leHBvcnQgeyBKU1hQYXJzZXIsIEpTWFRyYW5zZm9ybWF0aW9uLCBKU1hQYXJzZVJlc3VsdCB9IGZyb20gJy4vanN4UGFyc2VyJztcbmV4cG9ydCB7IENTU1BhcnNlciwgQ1NTUnVsZSwgQ1NTUGFyc2VSZXN1bHQgfSBmcm9tICcuL2Nzc1BhcnNlcic7XG5leHBvcnQgeyBGaWxlV3JpdGVyLCBGaWxlV3JpdGVPcHRpb25zIH0gZnJvbSAnLi9maWxlV3JpdGVyJztcbmV4cG9ydCB7IGxvYWRUYWlsd2luZENvbmZpZywgVGFpbHdpbmRDb25maWcgfSBmcm9tICcuL3V0aWxzL2NvbmZpZyc7XG5leHBvcnQgeyBsb2dnZXIgfSBmcm9tICcuL3V0aWxzL2xvZ2dlcic7XG4iXX0=

package/dist/jsxParser.d.ts

@@ -0,0 +1,26 @@
+import { TailwindMapper } from './tailwindMapper';
+export interface JSXTransformation {
+    original: string;
+    converted: string;
+    classes: string[];
+    warnings: string[];
+}
+export interface JSXParseResult {
+    code: string;
+    hasChanges: boolean;
+    transformations: JSXTransformation[];
+    warnings: string[];
+}
+export declare class JSXParser {
+    private mapper;
+    constructor(mapper: TailwindMapper);
+    parse(code: string, filePath: string): JSXParseResult;
+    private getElementName;
+    private getMemberExpressionName;
+    private isStaticStyle;
+    private isStaticClassName;
+    private extractCSSProperties;
+    private extractClassNameValue;
+    private mergeClasses;
+    private camelToKebab;
+}