css-to-tailwind-react 0.1.0

package/dist/jsxParser.js

@@ -0,0 +1,273 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSXParser = void 0;
+const parser_1 = require("@babel/parser");
+const traverse_1 = __importDefault(require("@babel/traverse"));
+const generator_1 = __importDefault(require("@babel/generator"));
+const t = __importStar(require("@babel/types"));
+const logger_1 = require("./utils/logger");
+class JSXParser {
+    constructor(mapper) {
+        this.mapper = mapper;
+    }
+    parse(code, filePath) {
+        const transformations = [];
+        const warnings = [];
+        let hasChanges = false;
+        try {
+            const ast = (0, parser_1.parse)(code, {
+                sourceType: 'module',
+                allowImportExportEverywhere: true,
+                allowReturnOutsideFunction: true,
+                plugins: [
+                    'jsx',
+                    'typescript',
+                    'decorators-legacy',
+                    'classProperties',
+                    'optionalChaining',
+                    'nullishCoalescingOperator',
+                    'dynamicImport'
+                ]
+            });
+            (0, traverse_1.default)(ast, {
+                JSXOpeningElement: (path) => {
+                    const elementName = this.getElementName(path.node);
+                    // Find style attribute
+                    const styleAttrIndex = path.node.attributes.findIndex(attr => t.isJSXAttribute(attr) &&
+                        t.isJSXIdentifier(attr.name) &&
+                        attr.name.name === 'style');
+                    if (styleAttrIndex === -1) {
+                        return;
+                    }
+                    const styleAttr = path.node.attributes[styleAttrIndex];
+                    // Check if style value is dynamic
+                    if (!this.isStaticStyle(styleAttr)) {
+                        warnings.push(`Skipped dynamic style in ${elementName} (line ${path.node.loc?.start.line})`);
+                        logger_1.logger.warn(`Dynamic style detected in ${filePath} - skipping`);
+                        return;
+                    }
+                    // Extract CSS properties from style
+                    const cssProperties = this.extractCSSProperties(styleAttr);
+                    if (cssProperties.length === 0) {
+                        return;
+                    }
+                    // Convert to Tailwind classes
+                    const { classes, warnings: conversionWarnings } = this.mapper.convertMultiple(cssProperties);
+                    if (classes.length === 0) {
+                        warnings.push(...conversionWarnings);
+                        return;
+                    }
+                    // Find existing className
+                    const classNameAttrIndex = path.node.attributes.findIndex(attr => t.isJSXAttribute(attr) &&
+                        t.isJSXIdentifier(attr.name) &&
+                        attr.name.name === 'className');
+                    const originalStyle = (0, generator_1.default)(styleAttr).code;
+                    if (classNameAttrIndex !== -1) {
+                        // Merge with existing className
+                        const classNameAttr = path.node.attributes[classNameAttrIndex];
+                        if (!this.isStaticClassName(classNameAttr)) {
+                            warnings.push(`Skipped dynamic className in ${elementName} (line ${path.node.loc?.start.line})`);
+                            return;
+                        }
+                        const existingClasses = this.extractClassNameValue(classNameAttr);
+                        const mergedClasses = this.mergeClasses(existingClasses, classes);
+                        // Update className attribute
+                        classNameAttr.value = t.stringLiteral(mergedClasses);
+                    }
+                    else {
+                        // Create new className attribute
+                        const newClassNameAttr = t.jsxAttribute(t.jsxIdentifier('className'), t.stringLiteral(classes.join(' ')));
+                        path.node.attributes.push(newClassNameAttr);
+                    }
+                    // Remove style attribute
+                    path.node.attributes.splice(styleAttrIndex, 1);
+                    // Record transformation
+                    const newCode = (0, generator_1.default)(path.node).code;
+                    transformations.push({
+                        original: originalStyle,
+                        converted: newCode,
+                        classes,
+                        warnings: conversionWarnings
+                    });
+                    hasChanges = true;
+                    warnings.push(...conversionWarnings);
+                }
+            });
+            // Generate new code
+            const output = (0, generator_1.default)(ast, {
+                retainLines: true,
+                retainFunctionParens: true,
+                comments: true
+            });
+            return {
+                code: output.code,
+                hasChanges,
+                transformations,
+                warnings
+            };
+        }
+        catch (error) {
+            logger_1.logger.error(`Failed to parse ${filePath}:`, error);
+            throw new Error(`Parsing failed: ${error}`);
+        }
+    }
+    getElementName(node) {
+        if (t.isJSXIdentifier(node.name)) {
+            return node.name.name;
+        }
+        if (t.isJSXMemberExpression(node.name)) {
+            return this.getMemberExpressionName(node.name);
+        }
+        return 'unknown';
+    }
+    getMemberExpressionName(node) {
+        if (t.isJSXIdentifier(node.object) && t.isJSXIdentifier(node.property)) {
+            return `${node.object.name}.${node.property.name}`;
+        }
+        return 'unknown';
+    }
+    isStaticStyle(attr) {
+        if (!attr.value) {
+            return false;
+        }
+        // Handle style={{ ... }} (object expression)
+        if (t.isJSXExpressionContainer(attr.value)) {
+            const expression = attr.value.expression;
+            // Direct object: style={{ color: 'red' }}
+            if (t.isObjectExpression(expression)) {
+                return true;
+            }
+            // Check if it's a simple object without variables
+            if (t.isIdentifier(expression) || t.isMemberExpression(expression)) {
+                return false; // Variable reference - dynamic
+            }
+        }
+        return false;
+    }
+    isStaticClassName(attr) {
+        if (!attr.value) {
+            return true;
+        }
+        if (t.isStringLiteral(attr.value)) {
+            return true;
+        }
+        if (t.isJSXExpressionContainer(attr.value)) {
+            const expression = attr.value.expression;
+            // String literal in expression: className={"container"}
+            if (t.isStringLiteral(expression)) {
+                return true;
+            }
+            // Template literal without expressions: className={`container`}
+            if (t.isTemplateLiteral(expression) && expression.expressions.length === 0) {
+                return true;
+            }
+            // Anything else is dynamic
+            return false;
+        }
+        return false;
+    }
+    extractCSSProperties(attr) {
+        const properties = [];
+        if (!attr.value || !t.isJSXExpressionContainer(attr.value)) {
+            return properties;
+        }
+        const expression = attr.value.expression;
+        if (!t.isObjectExpression(expression)) {
+            return properties;
+        }
+        expression.properties.forEach(prop => {
+            if (!t.isObjectProperty(prop)) {
+                return;
+            }
+            let propertyName = null;
+            let propertyValue = null;
+            // Get property name
+            if (t.isIdentifier(prop.key)) {
+                propertyName = prop.key.name;
+            }
+            else if (t.isStringLiteral(prop.key)) {
+                propertyName = prop.key.value;
+            }
+            // Get property value
+            if (t.isStringLiteral(prop.value)) {
+                propertyValue = prop.value.value;
+            }
+            else if (t.isNumericLiteral(prop.value)) {
+                propertyValue = `${prop.value.value}px`;
+            }
+            // Handle camelCase to kebab-case conversion for CSS properties
+            if (propertyName && propertyValue) {
+                const cssProperty = this.camelToKebab(propertyName);
+                properties.push({
+                    property: cssProperty,
+                    value: propertyValue
+                });
+            }
+        });
+        return properties;
+    }
+    extractClassNameValue(attr) {
+        if (!attr.value) {
+            return '';
+        }
+        if (t.isStringLiteral(attr.value)) {
+            return attr.value.value;
+        }
+        if (t.isJSXExpressionContainer(attr.value)) {
+            const expression = attr.value.expression;
+            if (t.isStringLiteral(expression)) {
+                return expression.value;
+            }
+            if (t.isTemplateLiteral(expression) && expression.quasis.length > 0) {
+                return expression.quasis[0].value.raw;
+            }
+        }
+        return '';
+    }
+    mergeClasses(existing, newClasses) {
+        const existingSet = new Set(existing.split(/\s+/).filter(Boolean));
+        newClasses.forEach(cls => existingSet.add(cls));
+        return Array.from(existingSet).join(' ');
+    }
+    camelToKebab(str) {
+        return str.replace(/([a-z0-9])([A-Z])/g, '$1-$2').toLowerCase();
+    }
+}
+exports.JSXParser = JSXParser;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"jsxParser.js","sourceRoot":"","sources":["../src/jsxParser.ts"],"names":[],"mappings":"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","sourcesContent":["import { parse } from '@babel/parser';\nimport traverse from '@babel/traverse';\nimport generate from '@babel/generator';\nimport * as t from '@babel/types';\nimport { TailwindMapper, CSSProperty } from './tailwindMapper';\nimport { logger } from './utils/logger';\n\nexport interface JSXTransformation {\n  original: string;\n  converted: string;\n  classes: string[];\n  warnings: string[];\n}\n\nexport interface JSXParseResult {\n  code: string;\n  hasChanges: boolean;\n  transformations: JSXTransformation[];\n  warnings: string[];\n}\n\nexport class JSXParser {\n  private mapper: TailwindMapper;\n\n  constructor(mapper: TailwindMapper) {\n    this.mapper = mapper;\n  }\n\n  parse(code: string, filePath: string): JSXParseResult {\n    const transformations: JSXTransformation[] = [];\n    const warnings: string[] = [];\n    let hasChanges = false;\n\n    try {\n      const ast = parse(code, {\n        sourceType: 'module',\n        allowImportExportEverywhere: true,\n        allowReturnOutsideFunction: true,\n        plugins: [\n          'jsx',\n          'typescript',\n          'decorators-legacy',\n          'classProperties',\n          'optionalChaining',\n          'nullishCoalescingOperator',\n          'dynamicImport'\n        ]\n      });\n\n      traverse(ast, {\n        JSXOpeningElement: (path) => {\n          const elementName = this.getElementName(path.node);\n          \n          // Find style attribute\n          const styleAttrIndex = path.node.attributes.findIndex(\n            attr => t.isJSXAttribute(attr) && \n                    t.isJSXIdentifier(attr.name) && \n                    attr.name.name === 'style'\n          );\n\n          if (styleAttrIndex === -1) {\n            return;\n          }\n\n          const styleAttr = path.node.attributes[styleAttrIndex] as t.JSXAttribute;\n          \n          // Check if style value is dynamic\n          if (!this.isStaticStyle(styleAttr)) {\n            warnings.push(`Skipped dynamic style in ${elementName} (line ${path.node.loc?.start.line})`);\n            logger.warn(`Dynamic style detected in ${filePath} - skipping`);\n            return;\n          }\n\n          // Extract CSS properties from style\n          const cssProperties = this.extractCSSProperties(styleAttr);\n          \n          if (cssProperties.length === 0) {\n            return;\n          }\n\n          // Convert to Tailwind classes\n          const { classes, warnings: conversionWarnings } = this.mapper.convertMultiple(cssProperties);\n\n          if (classes.length === 0) {\n            warnings.push(...conversionWarnings);\n            return;\n          }\n\n          // Find existing className\n          const classNameAttrIndex = path.node.attributes.findIndex(\n            attr => t.isJSXAttribute(attr) && \n                    t.isJSXIdentifier(attr.name) && \n                    attr.name.name === 'className'\n          );\n\n          const originalStyle = generate(styleAttr).code;\n\n          if (classNameAttrIndex !== -1) {\n            // Merge with existing className\n            const classNameAttr = path.node.attributes[classNameAttrIndex] as t.JSXAttribute;\n            \n            if (!this.isStaticClassName(classNameAttr)) {\n              warnings.push(`Skipped dynamic className in ${elementName} (line ${path.node.loc?.start.line})`);\n              return;\n            }\n\n            const existingClasses = this.extractClassNameValue(classNameAttr);\n            const mergedClasses = this.mergeClasses(existingClasses, classes);\n\n            // Update className attribute\n            classNameAttr.value = t.stringLiteral(mergedClasses);\n          } else {\n            // Create new className attribute\n            const newClassNameAttr = t.jsxAttribute(\n              t.jsxIdentifier('className'),\n              t.stringLiteral(classes.join(' '))\n            );\n            path.node.attributes.push(newClassNameAttr);\n          }\n\n          // Remove style attribute\n          path.node.attributes.splice(styleAttrIndex, 1);\n\n          // Record transformation\n          const newCode = generate(path.node).code;\n          transformations.push({\n            original: originalStyle,\n            converted: newCode,\n            classes,\n            warnings: conversionWarnings\n          });\n\n          hasChanges = true;\n          warnings.push(...conversionWarnings);\n        }\n      });\n\n      // Generate new code\n      const output = generate(ast, {\n        retainLines: true,\n        retainFunctionParens: true,\n        comments: true\n      });\n\n      return {\n        code: output.code,\n        hasChanges,\n        transformations,\n        warnings\n      };\n\n    } catch (error) {\n      logger.error(`Failed to parse ${filePath}:`, error);\n      throw new Error(`Parsing failed: ${error}`);\n    }\n  }\n\n  private getElementName(node: t.JSXOpeningElement): string {\n    if (t.isJSXIdentifier(node.name)) {\n      return node.name.name;\n    }\n    if (t.isJSXMemberExpression(node.name)) {\n      return this.getMemberExpressionName(node.name);\n    }\n    return 'unknown';\n  }\n\n  private getMemberExpressionName(node: t.JSXMemberExpression): string {\n    if (t.isJSXIdentifier(node.object) && t.isJSXIdentifier(node.property)) {\n      return `${node.object.name}.${node.property.name}`;\n    }\n    return 'unknown';\n  }\n\n  private isStaticStyle(attr: t.JSXAttribute): boolean {\n    if (!attr.value) {\n      return false;\n    }\n\n    // Handle style={{ ... }} (object expression)\n    if (t.isJSXExpressionContainer(attr.value)) {\n      const expression = attr.value.expression;\n      \n      // Direct object: style={{ color: 'red' }}\n      if (t.isObjectExpression(expression)) {\n        return true;\n      }\n\n      // Check if it's a simple object without variables\n      if (t.isIdentifier(expression) || t.isMemberExpression(expression)) {\n        return false; // Variable reference - dynamic\n      }\n    }\n\n    return false;\n  }\n\n  private isStaticClassName(attr: t.JSXAttribute): boolean {\n    if (!attr.value) {\n      return true;\n    }\n\n    if (t.isStringLiteral(attr.value)) {\n      return true;\n    }\n\n    if (t.isJSXExpressionContainer(attr.value)) {\n      const expression = attr.value.expression;\n      \n      // String literal in expression: className={\"container\"}\n      if (t.isStringLiteral(expression)) {\n        return true;\n      }\n\n      // Template literal without expressions: className={`container`}\n      if (t.isTemplateLiteral(expression) && expression.expressions.length === 0) {\n        return true;\n      }\n\n      // Anything else is dynamic\n      return false;\n    }\n\n    return false;\n  }\n\n  private extractCSSProperties(attr: t.JSXAttribute): CSSProperty[] {\n    const properties: CSSProperty[] = [];\n\n    if (!attr.value || !t.isJSXExpressionContainer(attr.value)) {\n      return properties;\n    }\n\n    const expression = attr.value.expression;\n\n    if (!t.isObjectExpression(expression)) {\n      return properties;\n    }\n\n    expression.properties.forEach(prop => {\n      if (!t.isObjectProperty(prop)) {\n        return;\n      }\n\n      let propertyName: string | null = null;\n      let propertyValue: string | null = null;\n\n      // Get property name\n      if (t.isIdentifier(prop.key)) {\n        propertyName = prop.key.name;\n      } else if (t.isStringLiteral(prop.key)) {\n        propertyName = prop.key.value;\n      }\n\n      // Get property value\n      if (t.isStringLiteral(prop.value)) {\n        propertyValue = prop.value.value;\n      } else if (t.isNumericLiteral(prop.value)) {\n        propertyValue = `${prop.value.value}px`;\n      }\n\n      // Handle camelCase to kebab-case conversion for CSS properties\n      if (propertyName && propertyValue) {\n        const cssProperty = this.camelToKebab(propertyName);\n        properties.push({\n          property: cssProperty,\n          value: propertyValue\n        });\n      }\n    });\n\n    return properties;\n  }\n\n  private extractClassNameValue(attr: t.JSXAttribute): string {\n    if (!attr.value) {\n      return '';\n    }\n\n    if (t.isStringLiteral(attr.value)) {\n      return attr.value.value;\n    }\n\n    if (t.isJSXExpressionContainer(attr.value)) {\n      const expression = attr.value.expression;\n      \n      if (t.isStringLiteral(expression)) {\n        return expression.value;\n      }\n\n      if (t.isTemplateLiteral(expression) && expression.quasis.length > 0) {\n        return expression.quasis[0].value.raw;\n      }\n    }\n\n    return '';\n  }\n\n  private mergeClasses(existing: string, newClasses: string[]): string {\n    const existingSet = new Set(existing.split(/\\s+/).filter(Boolean));\n    newClasses.forEach(cls => existingSet.add(cls));\n    return Array.from(existingSet).join(' ');\n  }\n\n  private camelToKebab(str: string): string {\n    return str.replace(/([a-z0-9])([A-Z])/g, '$1-$2').toLowerCase();\n  }\n}\n"]}

package/dist/scanner.d.ts

@@ -0,0 +1,5 @@
+export interface ScannedFile {
+    path: string;
+    type: 'jsx' | 'css';
+}
+export declare function scanProject(directory: string): Promise<ScannedFile[]>;

package/dist/scanner.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanProject = scanProject;
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const path_1 = __importDefault(require("path"));
+async function scanProject(directory) {
+    const absoluteDir = path_1.default.resolve(directory);
+    // Patterns for React components
+    const jsxPatterns = [
+        '**/*.{js,jsx,ts,tsx}',
+    ];
+    // Patterns for CSS files
+    const cssPatterns = [
+        '**/*.css',
+    ];
+    // Ignore patterns
+    const ignorePatterns = [
+        '**/node_modules/**',
+        '**/.next/**',
+        '**/dist/**',
+        '**/build/**',
+        '**/.git/**',
+        '**/coverage/**',
+        '**/*.d.ts',
+        '**/.*' // hidden files
+    ];
+    try {
+        // Scan for JSX/TSX files
+        const jsxFiles = await (0, fast_glob_1.default)(jsxPatterns, {
+            cwd: absoluteDir,
+            ignore: ignorePatterns,
+            absolute: true,
+            onlyFiles: true
+        });
+        // Scan for CSS files
+        const cssFiles = await (0, fast_glob_1.default)(cssPatterns, {
+            cwd: absoluteDir,
+            ignore: ignorePatterns,
+            absolute: true,
+            onlyFiles: true
+        });
+        const files = [
+            ...jsxFiles.map(file => ({ path: file, type: 'jsx' })),
+            ...cssFiles.map(file => ({ path: file, type: 'css' }))
+        ];
+        return files.sort((a, b) => a.path.localeCompare(b.path));
+    }
+    catch (error) {
+        throw new Error(`Failed to scan directory: ${error}`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/tailwindMapper.d.ts

@@ -0,0 +1,35 @@
+import { TailwindConfig } from './utils/config';
+export interface CSSProperty {
+    property: string;
+    value: string;
+}
+export interface ConversionResult {
+    className: string | null;
+    skipped: boolean;
+    reason?: string;
+}
+export declare class TailwindMapper {
+    private config;
+    private spacingScale;
+    constructor(config: TailwindConfig);
+    private buildSpacingScale;
+    private pxToSpacing;
+    private extractPx;
+    convertProperty(property: string, value: string): ConversionResult;
+    private convertDisplay;
+    private convertMargin;
+    private convertPadding;
+    private convertFontWeight;
+    private convertFontSize;
+    private convertFlexbox;
+    private convertGap;
+    private convertWidth;
+    private convertHeight;
+    private convertBackgroundColor;
+    private convertTextColor;
+    private convertBorderRadius;
+    convertMultiple(properties: CSSProperty[]): {
+        classes: string[];
+        warnings: string[];
+    };
+}