css-to-tailwind-react 0.1.0

package/dist/transformer.js

@@ -0,0 +1,259 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformFiles = transformFiles;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const tailwindMapper_1 = require("./tailwindMapper");
+const jsxParser_1 = require("./jsxParser");
+const cssParser_1 = require("./cssParser");
+const fileWriter_1 = require("./fileWriter");
+const logger_1 = require("./utils/logger");
+async function transformFiles(files, options) {
+    const results = {
+        filesScanned: files.length,
+        filesModified: 0,
+        stylesConverted: 0,
+        classesReplaced: 0,
+        warnings: 0
+    };
+    const mapper = new tailwindMapper_1.TailwindMapper(options.tailwindConfig || {});
+    const jsxParser = new jsxParser_1.JSXParser(mapper);
+    const cssParser = new cssParser_1.CSSParser(mapper);
+    const fileWriter = new fileWriter_1.FileWriter({ dryRun: options.dryRun });
+    // PASS 1: Analyze all files WITHOUT modifying anything
+    // Collect CSS mappings and gather info about what can be safely converted
+    const cssClassMap = {};
+    const cssFileResults = new Map();
+    logger_1.logger.info('\n🔍 Phase 1: Analyzing files...');
+    // Analyze CSS files
+    if (!options.skipExternal) {
+        for (const file of files.filter(f => f.type === 'css')) {
+            try {
+                const content = fs_1.default.readFileSync(file.path, 'utf-8');
+                const result = await cssParser.parse(content, file.path);
+                // Check if ALL rules in this file are FULLY converted (all declarations)
+                const totalRules = result.rules.length;
+                const fullyConvertedRules = result.rules.filter(r => r.fullyConverted).length;
+                const partiallyConvertedRules = result.rules.filter(r => r.partialConversion).length;
+                // A file is only "fully convertible" if ALL rules are fully converted (no partial conversions)
+                const fullyConvertible = totalRules > 0 && totalRules === fullyConvertedRules && partiallyConvertedRules === 0;
+                // Build class map (only for fully converted classes - partial conversions keep the CSS)
+                result.rules.forEach(rule => {
+                    if (rule.fullyConverted) {
+                        cssClassMap[rule.className] = {
+                            tailwindClasses: rule.convertedClasses,
+                            sourceFile: file.path,
+                            fullyConvertible: true
+                        };
+                        results.stylesConverted += rule.declarations.length;
+                    }
+                    else if (rule.partialConversion) {
+                        // For partial conversions, we converted some declarations but keep the CSS rule
+                        // Count the converted declarations
+                        results.stylesConverted += rule.convertedClasses.length;
+                        logger_1.logger.verbose(`  Rule .${rule.className}: partial conversion (${rule.convertedClasses.length}/${rule.declarations.length} declarations)`);
+                    }
+                });
+                cssFileResults.set(file.path, {
+                    content,
+                    newContent: result.css,
+                    rules: result.rules,
+                    canDelete: result.canDelete,
+                    hasChanges: result.hasChanges,
+                    fullyConvertible
+                });
+                results.warnings += result.warnings.length;
+                // Log analysis
+                logger_1.logger.verbose(`Analyzed ${file.path}:`);
+                logger_1.logger.verbose(`  - Total rules: ${totalRules}`);
+                logger_1.logger.verbose(`  - Fully converted rules: ${fullyConvertedRules}`);
+                logger_1.logger.verbose(`  - Partially converted rules: ${partiallyConvertedRules}`);
+                logger_1.logger.verbose(`  - Fully convertible: ${fullyConvertible}`);
+                // Log warnings
+                result.warnings.forEach(warning => {
+                    logger_1.logger.verbose(`⚠️  ${file.path}: ${warning}`);
+                });
+            }
+            catch (error) {
+                logger_1.logger.error(`Failed to analyze ${file.path}:`, error);
+                results.warnings++;
+            }
+        }
+    }
+    // PASS 2: Transform JSX/TSX files
+    logger_1.logger.info('\n⚛️  Phase 2: Transforming React components...');
+    const jsxFileResults = new Map();
+    for (const file of files.filter(f => f.type === 'jsx')) {
+        try {
+            let content = fs_1.default.readFileSync(file.path, 'utf-8');
+            const originalContent = content;
+            let hasChanges = false;
+            let fileWarnings = [];
+            // Process inline styles
+            if (!options.skipInline) {
+                try {
+                    const jsxResult = jsxParser.parse(content, file.path);
+                    if (jsxResult.hasChanges) {
+                        content = jsxResult.code;
+                        hasChanges = true;
+                        results.stylesConverted += jsxResult.transformations.reduce((sum, t) => sum + t.classes.length, 0);
+                        fileWarnings.push(...jsxResult.warnings);
+                    }
+                }
+                catch (error) {
+                    logger_1.logger.warn(`Failed to parse JSX inline styles in ${file.path}: ${error}`);
+                    fileWarnings.push(`JSX parse error: ${error}`);
+                }
+            }
+            // Process internal CSS
+            if (!options.skipInternal) {
+                try {
+                    const internalResult = await cssParser.parseInternalCSS(content, file.path);
+                    if (internalResult.hasChanges) {
+                        content = internalResult.html;
+                        hasChanges = true;
+                        // Build class map from internal styles
+                        internalResult.rules.forEach(rule => {
+                            if (rule.convertedClasses.length > 0) {
+                                cssClassMap[rule.className] = {
+                                    tailwindClasses: rule.convertedClasses,
+                                    sourceFile: file.path,
+                                    fullyConvertible: true
+                                };
+                                results.stylesConverted += rule.declarations.length;
+                            }
+                        });
+                        fileWarnings.push(...internalResult.warnings);
+                    }
+                }
+                catch (error) {
+                    logger_1.logger.warn(`Failed to parse internal CSS in ${file.path}: ${error}`);
+                    fileWarnings.push(`Internal CSS parse error: ${error}`);
+                }
+            }
+            jsxFileResults.set(file.path, {
+                content: originalContent,
+                newContent: content,
+                hasChanges
+            });
+            results.warnings += fileWarnings.length;
+            // Log warnings
+            fileWarnings.forEach(warning => {
+                logger_1.logger.verbose(`⚠️  ${file.path}: ${warning}`);
+            });
+        }
+        catch (error) {
+            logger_1.logger.error(`Failed to process ${file.path}:`, error);
+            results.warnings++;
+        }
+    }
+    // PASS 3: Replace className references from external CSS
+    // This must happen after all JSX files are parsed
+    if (Object.keys(cssClassMap).length > 0) {
+        logger_1.logger.info('\n🔄 Phase 3: Replacing className references...');
+        for (const [filePath, fileResult] of jsxFileResults) {
+            let content = fileResult.newContent;
+            let hasChanges = fileResult.hasChanges;
+            // Replace className references
+            const replacementResult = replaceClassNameReferences(content, cssClassMap);
+            if (replacementResult.hasChanges) {
+                content = replacementResult.code;
+                hasChanges = true;
+                results.classesReplaced += replacementResult.replacements;
+                logger_1.logger.verbose(`Replaced ${replacementResult.replacements} class references in ${path_1.default.basename(filePath)}`);
+            }
+            // Update the result
+            jsxFileResults.set(filePath, {
+                ...fileResult,
+                newContent: content,
+                hasChanges
+            });
+        }
+    }
+    // PASS 4: Write all changes
+    logger_1.logger.info('\n💾 Phase 4: Writing changes...');
+    // Write JSX files
+    for (const [filePath, fileResult] of jsxFileResults) {
+        if (fileResult.hasChanges) {
+            const success = await fileWriter.writeFile(filePath, fileResult.newContent, fileResult.content);
+            if (success) {
+                results.filesModified++;
+            }
+        }
+    }
+    // Write CSS files (SAFETY: Only modify if fully convertible or explicitly allowed)
+    if (!options.skipExternal) {
+        for (const [filePath, fileResult] of cssFileResults) {
+            if (!fileResult.hasChanges)
+                continue;
+            // SAFETY RULE 1: Never modify CSS files that aren't fully convertible
+            // unless they only have unconvertible rules (no changes needed)
+            if (!fileResult.fullyConvertible) {
+                logger_1.logger.warn(`⏭️  Skipping ${path_1.default.basename(filePath)} - not fully convertible (would break styles)`);
+                logger_1.logger.warn(`   Convertible: ${fileResult.rules.filter(r => r.convertedClasses.length > 0).length}/${fileResult.rules.length} rules`);
+                continue;
+            }
+            // SAFETY RULE 2: Only delete if ALL rules converted AND --delete-css flag used
+            if (fileResult.canDelete && options.deleteCss) {
+                const success = await fileWriter.deleteFile(filePath);
+                if (success) {
+                    results.filesModified++;
+                    logger_1.logger.info(`🗑️  Deleted ${path_1.default.basename(filePath)} (all rules converted)`);
+                }
+            }
+            else if (fileResult.canDelete && !options.deleteCss) {
+                // File is empty but don't delete without permission
+                logger_1.logger.info(`ℹ️  ${path_1.default.basename(filePath)} is now empty (use --delete-css to remove)`);
+            }
+            else {
+                // Write modified CSS (only if fully convertible)
+                const success = await fileWriter.writeFile(filePath, fileResult.newContent, fileResult.content);
+                if (success) {
+                    results.filesModified++;
+                }
+            }
+        }
+    }
+    return results;
+}
+function replaceClassNameReferences(code, classMap) {
+    let hasChanges = false;
+    let replacements = 0;
+    let modifiedCode = code;
+    Object.entries(classMap).forEach(([oldClass, info]) => {
+        // Skip if not fully convertible
+        if (!info.fullyConvertible) {
+            return;
+        }
+        const tailwindClassString = info.tailwindClasses.join(' ');
+        // Pattern 1: className="oldClass" (simple string)
+        const pattern1 = new RegExp(`className="${oldClass}"`, 'g');
+        if (pattern1.test(modifiedCode)) {
+            modifiedCode = modifiedCode.replace(pattern1, `className="${tailwindClassString}"`);
+            hasChanges = true;
+            replacements++;
+            logger_1.logger.verbose(`Replaced className="${oldClass}" with "${tailwindClassString}"`);
+        }
+        // Pattern 2: className={"oldClass"} (expression with string)
+        const pattern2 = new RegExp(`className=\\{"${oldClass}"\\}`, 'g');
+        if (pattern2.test(modifiedCode)) {
+            modifiedCode = modifiedCode.replace(pattern2, `className="${tailwindClassString}"`);
+            hasChanges = true;
+            replacements++;
+            logger_1.logger.verbose(`Replaced className={"${oldClass}"} with "${tailwindClassString}"`);
+        }
+        // Pattern 3: className={`oldClass`} (simple template literal)
+        const pattern3 = new RegExp(`className=\\{\`\\s*${oldClass}\\s*\`\\}`, 'g');
+        if (pattern3.test(modifiedCode)) {
+            modifiedCode = modifiedCode.replace(pattern3, `className="${tailwindClassString}"`);
+            hasChanges = true;
+            replacements++;
+            logger_1.logger.verbose(`Replaced className={\`${oldClass}\`} with "${tailwindClassString}"`);
+        }
+    });
+    return { code: modifiedCode, hasChanges, replacements };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transformer.js","sourceRoot":"","sources":["../src/transformer.ts"],"names":[],"mappings":"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","sourcesContent":["import fs from 'fs';\nimport path from 'path';\nimport { ScannedFile } from './scanner';\nimport { TailwindMapper } from './tailwindMapper';\nimport { JSXParser } from './jsxParser';\nimport { CSSParser, CSSRule } from './cssParser';\nimport { FileWriter } from './fileWriter';\nimport { TailwindConfig } from './utils/config';\nimport { logger } from './utils/logger';\n\nexport interface TransformOptions {\n  dryRun: boolean;\n  deleteCss: boolean;\n  skipExternal: boolean;\n  skipInline: boolean;\n  skipInternal: boolean;\n  tailwindConfig: TailwindConfig | null;\n  projectRoot: string;\n}\n\nexport interface TransformResults {\n  filesScanned: number;\n  filesModified: number;\n  stylesConverted: number;\n  classesReplaced: number;\n  warnings: number;\n}\n\ninterface CSSClassMap {\n  [className: string]: {\n    tailwindClasses: string[];\n    sourceFile: string;\n    fullyConvertible: boolean;\n  };\n}\n\nexport async function transformFiles(\n  files: ScannedFile[],\n  options: TransformOptions\n): Promise<TransformResults> {\n  const results: TransformResults = {\n    filesScanned: files.length,\n    filesModified: 0,\n    stylesConverted: 0,\n    classesReplaced: 0,\n    warnings: 0\n  };\n\n  const mapper = new TailwindMapper(options.tailwindConfig || {});\n  const jsxParser = new JSXParser(mapper);\n  const cssParser = new CSSParser(mapper);\n  const fileWriter = new FileWriter({ dryRun: options.dryRun });\n\n  // PASS 1: Analyze all files WITHOUT modifying anything\n  // Collect CSS mappings and gather info about what can be safely converted\n  const cssClassMap: CSSClassMap = {};\n  const cssFileResults: Map<string, {\n    content: string;\n    newContent: string;\n    rules: CSSRule[];\n    canDelete: boolean;\n    hasChanges: boolean;\n    fullyConvertible: boolean;\n  }> = new Map();\n\n  logger.info('\\n🔍 Phase 1: Analyzing files...');\n\n  // Analyze CSS files\n  if (!options.skipExternal) {\n    for (const file of files.filter(f => f.type === 'css')) {\n      try {\n        const content = fs.readFileSync(file.path, 'utf-8');\n        const result = await cssParser.parse(content, file.path);\n\n        // Check if ALL rules in this file are FULLY converted (all declarations)\n        const totalRules = result.rules.length;\n        const fullyConvertedRules = result.rules.filter(r => r.fullyConverted).length;\n        const partiallyConvertedRules = result.rules.filter(r => r.partialConversion).length;\n        // A file is only \"fully convertible\" if ALL rules are fully converted (no partial conversions)\n        const fullyConvertible = totalRules > 0 && totalRules === fullyConvertedRules && partiallyConvertedRules === 0;\n\n        // Build class map (only for fully converted classes - partial conversions keep the CSS)\n        result.rules.forEach(rule => {\n          if (rule.fullyConverted) {\n            cssClassMap[rule.className] = {\n              tailwindClasses: rule.convertedClasses,\n              sourceFile: file.path,\n              fullyConvertible: true\n            };\n            results.stylesConverted += rule.declarations.length;\n          } else if (rule.partialConversion) {\n            // For partial conversions, we converted some declarations but keep the CSS rule\n            // Count the converted declarations\n            results.stylesConverted += rule.convertedClasses.length;\n            logger.verbose(`  Rule .${rule.className}: partial conversion (${rule.convertedClasses.length}/${rule.declarations.length} declarations)`);\n          }\n        });\n\n        cssFileResults.set(file.path, {\n          content,\n          newContent: result.css,\n          rules: result.rules,\n          canDelete: result.canDelete,\n          hasChanges: result.hasChanges,\n          fullyConvertible\n        });\n\n        results.warnings += result.warnings.length;\n\n        // Log analysis\n        logger.verbose(`Analyzed ${file.path}:`);\n        logger.verbose(`  - Total rules: ${totalRules}`);\n        logger.verbose(`  - Fully converted rules: ${fullyConvertedRules}`);\n        logger.verbose(`  - Partially converted rules: ${partiallyConvertedRules}`);\n        logger.verbose(`  - Fully convertible: ${fullyConvertible}`);\n\n        // Log warnings\n        result.warnings.forEach(warning => {\n          logger.verbose(`⚠️  ${file.path}: ${warning}`);\n        });\n\n      } catch (error) {\n        logger.error(`Failed to analyze ${file.path}:`, error);\n        results.warnings++;\n      }\n    }\n  }\n\n  // PASS 2: Transform JSX/TSX files\n  logger.info('\\n⚛️  Phase 2: Transforming React components...');\n\n  const jsxFileResults: Map<string, {\n    content: string;\n    newContent: string;\n    hasChanges: boolean;\n  }> = new Map();\n\n  for (const file of files.filter(f => f.type === 'jsx')) {\n    try {\n      let content = fs.readFileSync(file.path, 'utf-8');\n      const originalContent = content;\n      let hasChanges = false;\n      let fileWarnings: string[] = [];\n\n      // Process inline styles\n      if (!options.skipInline) {\n        try {\n          const jsxResult = jsxParser.parse(content, file.path);\n          \n          if (jsxResult.hasChanges) {\n            content = jsxResult.code;\n            hasChanges = true;\n            results.stylesConverted += jsxResult.transformations.reduce(\n              (sum, t) => sum + t.classes.length, 0\n            );\n            fileWarnings.push(...jsxResult.warnings);\n          }\n        } catch (error) {\n          logger.warn(`Failed to parse JSX inline styles in ${file.path}: ${error}`);\n          fileWarnings.push(`JSX parse error: ${error}`);\n        }\n      }\n\n      // Process internal CSS\n      if (!options.skipInternal) {\n        try {\n          const internalResult = await cssParser.parseInternalCSS(content, file.path);\n          \n          if (internalResult.hasChanges) {\n            content = internalResult.html;\n            hasChanges = true;\n            \n            // Build class map from internal styles\n            internalResult.rules.forEach(rule => {\n              if (rule.convertedClasses.length > 0) {\n                cssClassMap[rule.className] = {\n                  tailwindClasses: rule.convertedClasses,\n                  sourceFile: file.path,\n                  fullyConvertible: true\n                };\n                results.stylesConverted += rule.declarations.length;\n              }\n            });\n            \n            fileWarnings.push(...internalResult.warnings);\n          }\n        } catch (error) {\n          logger.warn(`Failed to parse internal CSS in ${file.path}: ${error}`);\n          fileWarnings.push(`Internal CSS parse error: ${error}`);\n        }\n      }\n\n      jsxFileResults.set(file.path, {\n        content: originalContent,\n        newContent: content,\n        hasChanges\n      });\n\n      results.warnings += fileWarnings.length;\n\n      // Log warnings\n      fileWarnings.forEach(warning => {\n        logger.verbose(`⚠️  ${file.path}: ${warning}`);\n      });\n\n    } catch (error) {\n      logger.error(`Failed to process ${file.path}:`, error);\n      results.warnings++;\n    }\n  }\n\n  // PASS 3: Replace className references from external CSS\n  // This must happen after all JSX files are parsed\n  if (Object.keys(cssClassMap).length > 0) {\n    logger.info('\\n🔄 Phase 3: Replacing className references...');\n\n    for (const [filePath, fileResult] of jsxFileResults) {\n      let content = fileResult.newContent;\n      let hasChanges = fileResult.hasChanges;\n\n      // Replace className references\n      const replacementResult = replaceClassNameReferences(content, cssClassMap);\n      if (replacementResult.hasChanges) {\n        content = replacementResult.code;\n        hasChanges = true;\n        results.classesReplaced += replacementResult.replacements;\n        \n        logger.verbose(`Replaced ${replacementResult.replacements} class references in ${path.basename(filePath)}`);\n      }\n\n      // Update the result\n      jsxFileResults.set(filePath, {\n        ...fileResult,\n        newContent: content,\n        hasChanges\n      });\n    }\n  }\n\n  // PASS 4: Write all changes\n  logger.info('\\n💾 Phase 4: Writing changes...');\n\n  // Write JSX files\n  for (const [filePath, fileResult] of jsxFileResults) {\n    if (fileResult.hasChanges) {\n      const success = await fileWriter.writeFile(filePath, fileResult.newContent, fileResult.content);\n      if (success) {\n        results.filesModified++;\n      }\n    }\n  }\n\n  // Write CSS files (SAFETY: Only modify if fully convertible or explicitly allowed)\n  if (!options.skipExternal) {\n    for (const [filePath, fileResult] of cssFileResults) {\n      if (!fileResult.hasChanges) continue;\n\n      // SAFETY RULE 1: Never modify CSS files that aren't fully convertible\n      // unless they only have unconvertible rules (no changes needed)\n      if (!fileResult.fullyConvertible) {\n        logger.warn(`⏭️  Skipping ${path.basename(filePath)} - not fully convertible (would break styles)`);\n        logger.warn(`   Convertible: ${fileResult.rules.filter(r => r.convertedClasses.length > 0).length}/${fileResult.rules.length} rules`);\n        continue;\n      }\n\n      // SAFETY RULE 2: Only delete if ALL rules converted AND --delete-css flag used\n      if (fileResult.canDelete && options.deleteCss) {\n        const success = await fileWriter.deleteFile(filePath);\n        if (success) {\n          results.filesModified++;\n          logger.info(`🗑️  Deleted ${path.basename(filePath)} (all rules converted)`);\n        }\n      } else if (fileResult.canDelete && !options.deleteCss) {\n        // File is empty but don't delete without permission\n        logger.info(`ℹ️  ${path.basename(filePath)} is now empty (use --delete-css to remove)`);\n      } else {\n        // Write modified CSS (only if fully convertible)\n        const success = await fileWriter.writeFile(filePath, fileResult.newContent, fileResult.content);\n        if (success) {\n          results.filesModified++;\n        }\n      }\n    }\n  }\n\n  return results;\n}\n\nfunction replaceClassNameReferences(\n  code: string, \n  classMap: CSSClassMap\n): { \n  code: string; \n  hasChanges: boolean; \n  replacements: number \n} {\n  let hasChanges = false;\n  let replacements = 0;\n  let modifiedCode = code;\n\n  Object.entries(classMap).forEach(([oldClass, info]) => {\n    // Skip if not fully convertible\n    if (!info.fullyConvertible) {\n      return;\n    }\n\n    const tailwindClassString = info.tailwindClasses.join(' ');\n    \n    // Pattern 1: className=\"oldClass\" (simple string)\n    const pattern1 = new RegExp(`className=\"${oldClass}\"`, 'g');\n    if (pattern1.test(modifiedCode)) {\n      modifiedCode = modifiedCode.replace(pattern1, `className=\"${tailwindClassString}\"`);\n      hasChanges = true;\n      replacements++;\n      logger.verbose(`Replaced className=\"${oldClass}\" with \"${tailwindClassString}\"`);\n    }\n\n    // Pattern 2: className={\"oldClass\"} (expression with string)\n    const pattern2 = new RegExp(`className=\\\\{\"${oldClass}\"\\\\}`, 'g');\n    if (pattern2.test(modifiedCode)) {\n      modifiedCode = modifiedCode.replace(pattern2, `className=\"${tailwindClassString}\"`);\n      hasChanges = true;\n      replacements++;\n      logger.verbose(`Replaced className={\"${oldClass}\"} with \"${tailwindClassString}\"`);\n    }\n\n    // Pattern 3: className={`oldClass`} (simple template literal)\n    const pattern3 = new RegExp(`className=\\\\{\\`\\\\s*${oldClass}\\\\s*\\`\\\\}`, 'g');\n    if (pattern3.test(modifiedCode)) {\n      modifiedCode = modifiedCode.replace(pattern3, `className=\"${tailwindClassString}\"`);\n      hasChanges = true;\n      replacements++;\n      logger.verbose(`Replaced className={\\`${oldClass}\\`} with \"${tailwindClassString}\"`);\n    }\n  });\n\n  return { code: modifiedCode, hasChanges, replacements };\n}\n"]}

package/dist/utils/config.d.ts

@@ -0,0 +1,14 @@
+export interface TailwindConfig {
+    theme?: {
+        extend?: Record<string, any>;
+        spacing?: Record<string, string>;
+        colors?: Record<string, any>;
+        fontSize?: Record<string, any>;
+        fontWeight?: Record<string, string>;
+        borderRadius?: Record<string, string>;
+        [key: string]: any;
+    };
+    content?: string[];
+    [key: string]: any;
+}
+export declare function loadTailwindConfig(projectRoot: string): Promise<TailwindConfig | null>;

package/dist/utils/config.js

@@ -0,0 +1,139 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadTailwindConfig = loadTailwindConfig;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const resolve_1 = __importDefault(require("resolve"));
+async function loadTailwindConfig(projectRoot) {
+    const configPaths = [
+        'tailwind.config.js',
+        'tailwind.config.ts',
+        'tailwind.config.mjs',
+        'tailwind.config.cjs'
+    ];
+    for (const configPath of configPaths) {
+        const fullPath = path_1.default.join(projectRoot, configPath);
+        if (fs_1.default.existsSync(fullPath)) {
+            try {
+                // Clear require cache for hot reloading
+                delete require.cache[require.resolve(fullPath)];
+                // Load the config
+                let config;
+                if (configPath.endsWith('.ts')) {
+                    // For TypeScript configs, we need to use a dynamic import
+                    // But for CLI usage, we'll use a simpler approach
+                    // Try to resolve tailwindcss and use its config resolution
+                    const tailwindcssPath = resolve_1.default.sync('tailwindcss', { basedir: projectRoot });
+                    const tailwindcss = require(tailwindcssPath);
+                    if (tailwindcss.resolveConfig) {
+                        const userConfig = require(fullPath);
+                        config = tailwindcss.resolveConfig(userConfig.default || userConfig);
+                    }
+                    else {
+                        config = require(fullPath);
+                    }
+                }
+                else {
+                    const userConfig = require(fullPath);
+                    config = userConfig.default || userConfig;
+                }
+                return config;
+            }
+            catch (error) {
+                console.warn(`Failed to load Tailwind config at ${fullPath}:`, error);
+                continue;
+            }
+        }
+    }
+    // Return default Tailwind-like config
+    return {
+        theme: {
+            spacing: {
+                '0': '0px',
+                '1': '0.25rem',
+                '2': '0.5rem',
+                '3': '0.75rem',
+                '4': '1rem',
+                '5': '1.25rem',
+                '6': '1.5rem',
+                '8': '2rem',
+                '10': '2.5rem',
+                '12': '3rem',
+                '16': '4rem',
+                '20': '5rem',
+                '24': '6rem',
+                '32': '8rem',
+                '40': '10rem',
+                '48': '12rem',
+                '56': '14rem',
+                '64': '16rem'
+            },
+            colors: {
+                transparent: 'transparent',
+                current: 'currentColor',
+                black: '#000000',
+                white: '#ffffff',
+                gray: {
+                    50: '#f9fafb',
+                    100: '#f3f4f6',
+                    200: '#e5e7eb',
+                    300: '#d1d5db',
+                    400: '#9ca3af',
+                    500: '#6b7280',
+                    600: '#4b5563',
+                    700: '#374151',
+                    800: '#1f2937',
+                    900: '#111827'
+                },
+                red: {
+                    500: '#ef4444',
+                    600: '#dc2626'
+                },
+                blue: {
+                    500: '#3b82f6',
+                    600: '#2563eb'
+                },
+                green: {
+                    500: '#22c55e',
+                    600: '#16a34a'
+                }
+            },
+            fontSize: {
+                'xs': ['0.75rem', { lineHeight: '1rem' }],
+                'sm': ['0.875rem', { lineHeight: '1.25rem' }],
+                'base': ['1rem', { lineHeight: '1.5rem' }],
+                'lg': ['1.125rem', { lineHeight: '1.75rem' }],
+                'xl': ['1.25rem', { lineHeight: '1.75rem' }],
+                '2xl': ['1.5rem', { lineHeight: '2rem' }],
+                '3xl': ['1.875rem', { lineHeight: '2.25rem' }],
+                '4xl': ['2.25rem', { lineHeight: '2.5rem' }]
+            },
+            fontWeight: {
+                thin: '100',
+                extralight: '200',
+                light: '300',
+                normal: '400',
+                medium: '500',
+                semibold: '600',
+                bold: '700',
+                extrabold: '800',
+                black: '900'
+            },
+            borderRadius: {
+                'none': '0px',
+                'sm': '0.125rem',
+                'DEFAULT': '0.25rem',
+                'md': '0.375rem',
+                'lg': '0.5rem',
+                'xl': '0.75rem',
+                '2xl': '1rem',
+                '3xl': '1.5rem',
+                'full': '9999px'
+            }
+        }
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config.js","sourceRoot":"","sources":["../../src/utils/config.ts"],"names":[],"mappings":"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","sourcesContent":["import path from 'path';\nimport fs from 'fs';\nimport resolve from 'resolve';\n\nexport interface TailwindConfig {\n  theme?: {\n    extend?: Record<string, any>;\n    spacing?: Record<string, string>;\n    colors?: Record<string, any>;\n    fontSize?: Record<string, any>;\n    fontWeight?: Record<string, string>;\n    borderRadius?: Record<string, string>;\n    [key: string]: any;\n  };\n  content?: string[];\n  [key: string]: any;\n}\n\nexport async function loadTailwindConfig(projectRoot: string): Promise<TailwindConfig | null> {\n  const configPaths = [\n    'tailwind.config.js',\n    'tailwind.config.ts',\n    'tailwind.config.mjs',\n    'tailwind.config.cjs'\n  ];\n\n  for (const configPath of configPaths) {\n    const fullPath = path.join(projectRoot, configPath);\n    \n    if (fs.existsSync(fullPath)) {\n      try {\n        // Clear require cache for hot reloading\n        delete require.cache[require.resolve(fullPath)];\n        \n        // Load the config\n        let config: TailwindConfig;\n        \n        if (configPath.endsWith('.ts')) {\n          // For TypeScript configs, we need to use a dynamic import\n          // But for CLI usage, we'll use a simpler approach\n          // Try to resolve tailwindcss and use its config resolution\n          const tailwindcssPath = resolve.sync('tailwindcss', { basedir: projectRoot });\n          const tailwindcss = require(tailwindcssPath);\n          \n          if (tailwindcss.resolveConfig) {\n            const userConfig = require(fullPath);\n            config = tailwindcss.resolveConfig(userConfig.default || userConfig);\n          } else {\n            config = require(fullPath);\n          }\n        } else {\n          const userConfig = require(fullPath);\n          config = userConfig.default || userConfig;\n        }\n\n        return config;\n      } catch (error) {\n        console.warn(`Failed to load Tailwind config at ${fullPath}:`, error);\n        continue;\n      }\n    }\n  }\n\n  // Return default Tailwind-like config\n  return {\n    theme: {\n      spacing: {\n        '0': '0px',\n        '1': '0.25rem',\n        '2': '0.5rem',\n        '3': '0.75rem',\n        '4': '1rem',\n        '5': '1.25rem',\n        '6': '1.5rem',\n        '8': '2rem',\n        '10': '2.5rem',\n        '12': '3rem',\n        '16': '4rem',\n        '20': '5rem',\n        '24': '6rem',\n        '32': '8rem',\n        '40': '10rem',\n        '48': '12rem',\n        '56': '14rem',\n        '64': '16rem'\n      },\n      colors: {\n        transparent: 'transparent',\n        current: 'currentColor',\n        black: '#000000',\n        white: '#ffffff',\n        gray: {\n          50: '#f9fafb',\n          100: '#f3f4f6',\n          200: '#e5e7eb',\n          300: '#d1d5db',\n          400: '#9ca3af',\n          500: '#6b7280',\n          600: '#4b5563',\n          700: '#374151',\n          800: '#1f2937',\n          900: '#111827'\n        },\n        red: {\n          500: '#ef4444',\n          600: '#dc2626'\n        },\n        blue: {\n          500: '#3b82f6',\n          600: '#2563eb'\n        },\n        green: {\n          500: '#22c55e',\n          600: '#16a34a'\n        }\n      },\n      fontSize: {\n        'xs': ['0.75rem', { lineHeight: '1rem' }],\n        'sm': ['0.875rem', { lineHeight: '1.25rem' }],\n        'base': ['1rem', { lineHeight: '1.5rem' }],\n        'lg': ['1.125rem', { lineHeight: '1.75rem' }],\n        'xl': ['1.25rem', { lineHeight: '1.75rem' }],\n        '2xl': ['1.5rem', { lineHeight: '2rem' }],\n        '3xl': ['1.875rem', { lineHeight: '2.25rem' }],\n        '4xl': ['2.25rem', { lineHeight: '2.5rem' }]\n      },\n      fontWeight: {\n        thin: '100',\n        extralight: '200',\n        light: '300',\n        normal: '400',\n        medium: '500',\n        semibold: '600',\n        bold: '700',\n        extrabold: '800',\n        black: '900'\n      },\n      borderRadius: {\n        'none': '0px',\n        'sm': '0.125rem',\n        'DEFAULT': '0.25rem',\n        'md': '0.375rem',\n        'lg': '0.5rem',\n        'xl': '0.75rem',\n        '2xl': '1rem',\n        '3xl': '1.5rem',\n        'full': '9999px'\n      }\n    }\n  };\n}\n"]}

package/dist/utils/logger.d.ts

@@ -0,0 +1,14 @@
+declare class Logger {
+    private isVerbose;
+    setVerbose(verbose: boolean): void;
+    info(message: string, ...args: any[]): void;
+    success(message: string, ...args: any[]): void;
+    warn(message: string, ...args: any[]): void;
+    error(message: string, error?: any): void;
+    verbose(message: string, ...args: any[]): void;
+    debug(message: string, ...args: any[]): void;
+    file(message: string, filePath: string): void;
+    diff(original: string, converted: string): void;
+}
+export declare const logger: Logger;
+export {};

package/dist/utils/logger.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+class Logger {
+    constructor() {
+        this.isVerbose = false;
+    }
+    setVerbose(verbose) {
+        this.isVerbose = verbose;
+    }
+    info(message, ...args) {
+        console.log(chalk_1.default.blue(message), ...args);
+    }
+    success(message, ...args) {
+        console.log(chalk_1.default.green(message), ...args);
+    }
+    warn(message, ...args) {
+        console.log(chalk_1.default.yellow(`⚠️  ${message}`), ...args);
+    }
+    error(message, error) {
+        console.error(chalk_1.default.red(`❌ ${message}`));
+        if (error && this.isVerbose) {
+            if (error instanceof Error) {
+                console.error(chalk_1.default.red(error.stack || error.message));
+            }
+            else {
+                console.error(chalk_1.default.red(error));
+            }
+        }
+    }
+    verbose(message, ...args) {
+        if (this.isVerbose) {
+            console.log(chalk_1.default.gray(`[verbose] ${message}`), ...args);
+        }
+    }
+    debug(message, ...args) {
+        if (this.isVerbose) {
+            console.log(chalk_1.default.cyan(`[debug] ${message}`), ...args);
+        }
+    }
+    file(message, filePath) {
+        console.log(chalk_1.default.magenta(`${message}:`), chalk_1.default.white(filePath));
+    }
+    diff(original, converted) {
+        if (this.isVerbose) {
+            console.log(chalk_1.default.red('  -'), original);
+            console.log(chalk_1.default.green('  +'), converted);
+        }
+    }
+}
+exports.logger = new Logger();
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "css-to-tailwind-react",
+  "version": "0.1.0",
+  "description": "Convert traditional CSS (inline, internal, and external) into Tailwind CSS utility classes for React-based frameworks",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "bin": {
+    "css-to-tailwind-react": "./bin/index.js"
+  },
+  "files": [
+    "dist/**/*",
+    "bin/**/*",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc && tsc-alias",
+    "build:watch": "tsc --watch",
+    "clean": "rm -rf dist",
+    "prepublishOnly": "npm run clean && npm run build",
+    "test": "echo \"No tests yet\" && exit 0",
+    "lint": "tsc --noEmit"
+  },
+  "keywords": [
+    "tailwindcss",
+    "css",
+    "react",
+    "jsx",
+    "tsx",
+    "converter",
+    "utility-classes",
+    "ast",
+    "babel",
+    "postcss"
+  ],
+  "author": "Rudra Patel",
+  "license": "MIT",
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "dependencies": {
+    "@babel/generator": "^7.23.6",
+    "@babel/parser": "^7.23.6",
+    "@babel/traverse": "^7.23.7",
+    "@babel/types": "^7.23.6",
+    "chalk": "^4.1.2",
+    "commander": "^11.1.0",
+    "fast-glob": "^3.3.2",
+    "postcss": "^8.4.32",
+    "postcss-safe-parser": "^6.0.0",
+    "resolve": "^1.22.8",
+    "tailwindcss": ">=3.0.0"
+  },
+  "devDependencies": {
+    "@types/babel__generator": "^7.6.8",
+    "@types/babel__traverse": "^7.20.5",
+    "@types/node": "^20.10.6",
+    "@types/postcss-safe-parser": "^5.0.4",
+    "@types/resolve": "^1.20.6",
+    "tsc-alias": "^1.8.8",
+    "typescript": "^5.3.3"
+  },
+  "peerDependencies": {
+    "tailwindcss": ">=3.0.0"
+  }
+}