@hugeicons/migrate-core 0.1.0

package/dist/engine/transformer.js

@@ -0,0 +1,874 @@
+/**
+ * Code Transformer
+ * AST-based code transformations for migrating icons
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { Project, Node, } from 'ts-morph';
+import { HUGEICONS_REACT_PACKAGE, getIconPackage, FA_PROP_CONVERSIONS, SUPPORTED_LIBRARIES } from '../constants.js';
+import { hugeIconExists } from '../data/mappings.js';
+/**
+ * Apply migration plan to source files
+ */
+export async function applyPlan(scanResult, plan, options) {
+    const { root, dryRun, backup, patch } = options;
+    const transformations = [];
+    let backupPath;
+    // Create backup if requested and not dry run
+    if (backup && !dryRun) {
+        backupPath = await createBackup(root, plan.filesToModify);
+    }
+    // Create ts-morph project
+    const project = new Project({
+        skipAddingFilesFromTsConfig: true,
+        skipFileDependencyResolution: true,
+    });
+    // Process each file
+    for (const filePath of plan.filesToModify) {
+        const absolutePath = path.join(root, filePath);
+        const fileAnalysis = scanResult.files.find((f) => f.filePath === filePath);
+        if (!fileAnalysis)
+            continue;
+        try {
+            const sourceFile = project.addSourceFileAtPath(absolutePath);
+            const original = sourceFile.getFullText();
+            const result = transformFile(sourceFile, fileAnalysis, plan, options.style || 'stroke');
+            if (!dryRun && result.success) {
+                sourceFile.saveSync();
+            }
+            transformations.push({
+                ...result,
+                original,
+            });
+        }
+        catch (error) {
+            transformations.push({
+                filePath,
+                original: '',
+                transformed: '',
+                changes: [],
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    // Calculate summary
+    const summary = {
+        filesModified: transformations.filter((t) => t.success && t.changes.length > 0).length,
+        totalReplacements: transformations.reduce((sum, t) => sum + t.changes.filter((c) => c.type === 'jsx-replace').length, 0),
+        totalImportEdits: transformations.reduce((sum, t) => sum +
+            t.changes.filter((c) => ['import-add', 'import-remove', 'import-modify'].includes(c.type)).length, 0),
+        errors: transformations.filter((t) => !t.success).length,
+    };
+    // Generate patch if requested
+    let patchContent;
+    if (patch) {
+        patchContent = generatePatch(transformations);
+    }
+    return {
+        transformations,
+        summary,
+        dryRun,
+        patch: patchContent,
+        backupPath,
+    };
+}
+/**
+ * Collect all identifiers used in the file that are NOT from icon libraries
+ * This helps detect naming conflicts when adding icon imports
+ */
+function collectExistingIdentifiers(sourceFile, iconLibraries) {
+    const identifiers = new Set();
+    // Collect from non-icon imports
+    for (const importDecl of sourceFile.getImportDeclarations()) {
+        const moduleSpecifier = importDecl.getModuleSpecifierValue();
+        // Skip icon library imports
+        if (iconLibraries.has(moduleSpecifier) ||
+            Array.from(iconLibraries).some(lib => moduleSpecifier.startsWith(lib))) {
+            continue;
+        }
+        // Get all named imports
+        const namedImports = importDecl.getNamedImports();
+        for (const named of namedImports) {
+            const alias = named.getAliasNode();
+            identifiers.add(alias ? alias.getText() : named.getName());
+        }
+        // Get default import
+        const defaultImport = importDecl.getDefaultImport();
+        if (defaultImport) {
+            identifiers.add(defaultImport.getText());
+        }
+        // Get namespace import
+        const namespaceImport = importDecl.getNamespaceImport();
+        if (namespaceImport) {
+            identifiers.add(namespaceImport.getText());
+        }
+    }
+    // Collect function declarations
+    for (const func of sourceFile.getFunctions()) {
+        const name = func.getName();
+        if (name)
+            identifiers.add(name);
+    }
+    // Collect class declarations
+    for (const cls of sourceFile.getClasses()) {
+        const name = cls.getName();
+        if (name)
+            identifiers.add(name);
+    }
+    // Collect variable declarations
+    for (const varDecl of sourceFile.getVariableDeclarations()) {
+        identifiers.add(varDecl.getName());
+    }
+    // Collect type aliases
+    for (const typeAlias of sourceFile.getTypeAliases()) {
+        identifiers.add(typeAlias.getName());
+    }
+    // Collect interfaces
+    for (const iface of sourceFile.getInterfaces()) {
+        identifiers.add(iface.getName());
+    }
+    // Collect exported declarations from export statements
+    for (const exportDecl of sourceFile.getExportDeclarations()) {
+        for (const named of exportDecl.getNamedExports()) {
+            identifiers.add(named.getName());
+        }
+    }
+    return identifiers;
+}
+/**
+ * Transform a single source file with comprehensive validation
+ */
+function transformFile(sourceFile, fileAnalysis, plan, style) {
+    const changes = [];
+    const filePath = fileAnalysis.filePath;
+    // ============================================================================
+    // STEP 1: Capture ALL old icon imports BEFORE any changes
+    // ============================================================================
+    const oldIconImports = [];
+    // Build set of icon library module specifiers
+    const iconLibraryModules = new Set();
+    for (const lib of SUPPORTED_LIBRARIES) {
+        iconLibraryModules.add(lib.name);
+        for (const alias of lib.aliases) {
+            iconLibraryModules.add(alias);
+        }
+    }
+    // Scan ALL import declarations to find icon imports
+    for (const importDecl of sourceFile.getImportDeclarations()) {
+        const moduleSpecifier = importDecl.getModuleSpecifierValue();
+        // Check if this is from a supported icon library
+        const matchedLibrary = SUPPORTED_LIBRARIES.find((lib) => moduleSpecifier === lib.name ||
+            lib.aliases.includes(moduleSpecifier) ||
+            lib.aliases.some((alias) => moduleSpecifier.startsWith(alias)));
+        if (matchedLibrary) {
+            // Get all named imports
+            const namedImports = importDecl.getNamedImports();
+            for (const namedImport of namedImports) {
+                const importedName = namedImport.getName();
+                const aliasNode = namedImport.getAliasNode();
+                const localName = aliasNode ? aliasNode.getText() : importedName;
+                oldIconImports.push({
+                    localName,
+                    importedName,
+                    library: matchedLibrary.name,
+                    moduleSpecifier,
+                });
+            }
+            // Also check for default imports (rare but possible)
+            const defaultImport = importDecl.getDefaultImport();
+            if (defaultImport) {
+                oldIconImports.push({
+                    localName: defaultImport.getText(),
+                    importedName: defaultImport.getText(),
+                    library: matchedLibrary.name,
+                    moduleSpecifier,
+                });
+            }
+        }
+    }
+    const originalIconCount = oldIconImports.length;
+    // ============================================================================
+    // STEP 2: Build mappings for ALL old icons
+    // ============================================================================
+    // Build a map of icons to their mappings from the plan
+    const mappingMap = new Map();
+    for (const mapping of plan.mappings) {
+        const key = `${mapping.source.library}:${mapping.source.icon}`;
+        mappingMap.set(key, mapping);
+    }
+    // Collect existing identifiers to detect conflicts
+    const existingIdentifiers = collectExistingIdentifiers(sourceFile, iconLibraryModules);
+    // Build import tracking - maps hugeicon component name to the alias we'll use
+    const hugeIconsToImport = new Map(); // hugeIconName -> aliasOrOriginal
+    // Track which local names map to which hugeicons names
+    const iconReplacements = new Map(); // oldLocalName -> newHugeiconName
+    // Track unmapped icons
+    const unmappedIcons = [];
+    /**
+     * Get a non-conflicting name for an icon
+     */
+    function getIconImportName(iconComponent) {
+        if (hugeIconsToImport.has(iconComponent)) {
+            return hugeIconsToImport.get(iconComponent);
+        }
+        let importName = iconComponent;
+        if (existingIdentifiers.has(iconComponent)) {
+            const baseName = iconComponent.replace(/Icon$/, '');
+            importName = `Huge${baseName}Icon`;
+            let counter = 2;
+            while (existingIdentifiers.has(importName)) {
+                importName = `Huge${baseName}${counter}Icon`;
+                counter++;
+            }
+        }
+        hugeIconsToImport.set(iconComponent, importName);
+        existingIdentifiers.add(importName);
+        return importName;
+    }
+    // Track icons that should be KEPT as original imports (no valid Hugeicons replacement)
+    const iconsToKeepAsOriginal = new Set(); // localName -> keep original
+    // Process EVERY old icon import and create a mapping
+    for (const oldImport of oldIconImports) {
+        const key = `${oldImport.library}:${oldImport.importedName}`;
+        const mapping = mappingMap.get(key);
+        if (mapping?.target) {
+            const iconComponent = mapping.target.component;
+            // VALIDATE: Make sure this icon actually exists (check both primary names AND aliases)
+            if (hugeIconExists(iconComponent)) {
+                const iconImportName = getIconImportName(iconComponent);
+                iconReplacements.set(oldImport.localName, iconImportName);
+            }
+            else {
+                // The mapped icon doesn't exist! This is a bug in our mappings
+                console.warn(`[KEEP ORIGINAL] ${oldImport.importedName} -> mapped to ${iconComponent} but it doesn't exist in Hugeicons. Keeping original.`);
+                unmappedIcons.push(`${oldImport.importedName} (mapped to non-existent ${iconComponent})`);
+                iconsToKeepAsOriginal.add(oldImport.localName);
+            }
+        }
+        else {
+            // No mapping found - try to find if the icon exists with same name + "Icon" suffix
+            const fallbackName = oldImport.importedName.endsWith('Icon')
+                ? oldImport.importedName
+                : `${oldImport.importedName}Icon`;
+            if (hugeIconExists(fallbackName)) {
+                const iconImportName = getIconImportName(fallbackName);
+                iconReplacements.set(oldImport.localName, iconImportName);
+            }
+            else if (hugeIconExists(oldImport.importedName)) {
+                // The exact name exists
+                const iconImportName = getIconImportName(oldImport.importedName);
+                iconReplacements.set(oldImport.localName, iconImportName);
+            }
+            else {
+                // No valid Hugeicons replacement found - KEEP THE ORIGINAL LUCIDE ICON
+                console.warn(`[KEEP ORIGINAL] No Hugeicons equivalent for: ${oldImport.importedName}. Keeping original Lucide import.`);
+                unmappedIcons.push(oldImport.importedName);
+                iconsToKeepAsOriginal.add(oldImport.localName);
+            }
+        }
+    }
+    // ============================================================================
+    // STEP 3: Replace ALL identifier references in the code
+    // ============================================================================
+    let needsHugeiconsIcon = false;
+    let needsIconSvgElementType = false;
+    const processedIdentifiers = new Set();
+    // Multiple passes to ensure we catch everything
+    for (let pass = 0; pass < 3; pass++) {
+        sourceFile.forEachDescendant((node) => {
+            // Skip if already processed
+            if (processedIdentifiers.has(node))
+                return;
+            // Handle JSX elements
+            if (Node.isJsxOpeningElement(node) || Node.isJsxSelfClosingElement(node)) {
+                const tagName = node.getTagNameNode().getText();
+                // Handle FontAwesomeIcon specially
+                if (tagName === 'FontAwesomeIcon') {
+                    const localToImported = new Map();
+                    for (const imp of oldIconImports) {
+                        localToImported.set(imp.localName, { library: imp.library, importedName: imp.importedName });
+                    }
+                    const transformed = transformFontAwesomeElement(node, mappingMap, localToImported, hugeIconsToImport, existingIdentifiers, changes, filePath);
+                    if (transformed)
+                        needsHugeiconsIcon = true;
+                    processedIdentifiers.add(node);
+                    return;
+                }
+                // Handle direct icon components
+                const replacement = iconReplacements.get(tagName);
+                if (replacement) {
+                    const original = node.getText();
+                    needsHugeiconsIcon = true;
+                    const propsToKeep = [];
+                    for (const attr of node.getAttributes()) {
+                        if (Node.isJsxAttribute(attr)) {
+                            propsToKeep.push(attr.getText());
+                        }
+                        else if (Node.isJsxSpreadAttribute(attr)) {
+                            propsToKeep.push(attr.getText());
+                        }
+                    }
+                    const propsString = propsToKeep.length > 0 ? ' ' + propsToKeep.join(' ') : '';
+                    let replacementText;
+                    if (Node.isJsxSelfClosingElement(node)) {
+                        replacementText = `<HugeiconsIcon icon={${replacement}}${propsString} />`;
+                    }
+                    else {
+                        replacementText = `<HugeiconsIcon icon={${replacement}}${propsString}>`;
+                    }
+                    node.replaceWithText(replacementText);
+                    processedIdentifiers.add(node);
+                    changes.push({
+                        type: 'jsx-replace',
+                        filePath,
+                        line: node.getStartLineNumber(),
+                        original,
+                        replacement: replacementText,
+                    });
+                    return;
+                }
+                // Handle dynamic icon patterns like <item.icon /> or <props.icon />
+                // These need to be transformed to <HugeiconsIcon icon={item.icon} />
+                // because Hugeicons are data objects, not React components
+                const tagNameNode = node.getTagNameNode();
+                if (Node.isPropertyAccessExpression(tagNameNode)) {
+                    // This is a member expression like item.icon or props.icon
+                    const propertyName = tagNameNode.getName();
+                    const objectExpr = tagNameNode.getExpression();
+                    const objectName = objectExpr.getText();
+                    // SKIP if the object is a PascalCase namespace (UI library component)
+                    // e.g., SelectPrimitive.Icon, DialogPrimitive.Close, etc.
+                    // These are React components, NOT icon data objects
+                    const isPascalCase = /^[A-Z]/.test(objectName);
+                    const isUiLibraryPattern = objectName.includes('Primitive') ||
+                        objectName.includes('Radix') ||
+                        objectName.includes('Component');
+                    if (isPascalCase || isUiLibraryPattern) {
+                        // This is a UI library component like SelectPrimitive.Icon
+                        // Don't transform it
+                        return;
+                    }
+                    // Check if this looks like an icon property (common patterns)
+                    // Only transform lowercase object properties like item.icon, props.icon
+                    if (propertyName === 'icon' || propertyName === 'Icon' ||
+                        propertyName.endsWith('Icon') || propertyName.endsWith('icon')) {
+                        const original = node.getText();
+                        const dynamicIconExpr = tagNameNode.getText(); // e.g., "item.icon"
+                        needsHugeiconsIcon = true;
+                        const propsToKeep = [];
+                        for (const attr of node.getAttributes()) {
+                            if (Node.isJsxAttribute(attr)) {
+                                propsToKeep.push(attr.getText());
+                            }
+                            else if (Node.isJsxSpreadAttribute(attr)) {
+                                propsToKeep.push(attr.getText());
+                            }
+                        }
+                        const propsString = propsToKeep.length > 0 ? ' ' + propsToKeep.join(' ') : '';
+                        let replacementText;
+                        if (Node.isJsxSelfClosingElement(node)) {
+                            replacementText = `<HugeiconsIcon icon={${dynamicIconExpr}}${propsString} />`;
+                        }
+                        else {
+                            replacementText = `<HugeiconsIcon icon={${dynamicIconExpr}}${propsString}>`;
+                        }
+                        node.replaceWithText(replacementText);
+                        processedIdentifiers.add(node);
+                        changes.push({
+                            type: 'jsx-replace',
+                            filePath,
+                            line: node.getStartLineNumber(),
+                            original,
+                            replacement: replacementText,
+                        });
+                    }
+                }
+                return;
+            }
+            // Handle TypeScript type references like "LucideIcon" -> "IconSvgElement"
+            if (Node.isTypeReference(node)) {
+                const fullTypeText = node.getText();
+                const typeName = node.getTypeName().getText();
+                // Handle shadcn-style SVG component props: React.ComponentProps<"svg"> or ComponentProps<"svg">
+                // Transform to: Omit<React.ComponentProps<typeof HugeiconsIcon>, "icon">
+                if ((typeName === 'React.ComponentProps' || typeName === 'ComponentProps') &&
+                    (fullTypeText.includes('<"svg">') || fullTypeText.includes("<'svg'>"))) {
+                    try {
+                        const original = node.getText();
+                        const prefix = typeName.startsWith('React.') ? 'React.' : '';
+                        const replacement = `Omit<${prefix}ComponentProps<typeof HugeiconsIcon>, "icon">`;
+                        node.replaceWithText(replacement);
+                        needsHugeiconsIcon = true;
+                        changes.push({
+                            type: 'identifier-replace',
+                            filePath,
+                            line: node.getStartLineNumber(),
+                            original,
+                            replacement,
+                        });
+                    }
+                    catch {
+                        // Node might have been modified
+                    }
+                    return;
+                }
+                // Handle SVGProps<SVGSVGElement> -> Omit<React.ComponentProps<typeof HugeiconsIcon>, "icon">
+                if ((typeName === 'SVGProps' || typeName === 'React.SVGProps') &&
+                    fullTypeText.includes('SVGSVGElement')) {
+                    try {
+                        const original = node.getText();
+                        const replacement = `Omit<React.ComponentProps<typeof HugeiconsIcon>, "icon">`;
+                        node.replaceWithText(replacement);
+                        needsHugeiconsIcon = true;
+                        changes.push({
+                            type: 'identifier-replace',
+                            filePath,
+                            line: node.getStartLineNumber(),
+                            original,
+                            replacement,
+                        });
+                    }
+                    catch {
+                        // Node might have been modified
+                    }
+                    return;
+                }
+                // Replace Lucide type references with Hugeicons type
+                if (typeName === 'LucideIcon' || typeName === 'Icon') {
+                    try {
+                        const original = node.getText();
+                        node.replaceWithText('IconSvgElement');
+                        needsIconSvgElementType = true;
+                        changes.push({
+                            type: 'identifier-replace',
+                            filePath,
+                            line: node.getStartLineNumber(),
+                            original,
+                            replacement: 'IconSvgElement',
+                        });
+                    }
+                    catch {
+                        // Node might have been modified
+                    }
+                }
+                // Replace LucideProps with HugeiconsIcon props type
+                if (typeName === 'LucideProps') {
+                    try {
+                        const original = node.getText();
+                        const replacement = `Omit<React.ComponentProps<typeof HugeiconsIcon>, "icon">`;
+                        node.replaceWithText(replacement);
+                        needsHugeiconsIcon = true;
+                        changes.push({
+                            type: 'identifier-replace',
+                            filePath,
+                            line: node.getStartLineNumber(),
+                            original,
+                            replacement,
+                        });
+                    }
+                    catch {
+                        // Node might have been modified
+                    }
+                }
+                return;
+            }
+            // Handle identifier references (for props, object values, etc.)
+            if (Node.isIdentifier(node)) {
+                const identifierName = node.getText();
+                const replacement = iconReplacements.get(identifierName);
+                if (replacement) {
+                    const parent = node.getParent();
+                    // Skip import declarations
+                    if (parent && (Node.isImportSpecifier(parent) || Node.isImportClause(parent))) {
+                        return;
+                    }
+                    // Skip JSX tag names (handled above)
+                    if (parent && (Node.isJsxOpeningElement(parent) || Node.isJsxSelfClosingElement(parent))) {
+                        try {
+                            const tagNameNode = parent.getTagNameNode();
+                            if (tagNameNode === node || tagNameNode.getText() === identifierName) {
+                                return;
+                            }
+                        }
+                        catch {
+                            // Node might have been modified
+                            return;
+                        }
+                    }
+                    // Replace the identifier
+                    try {
+                        const original = node.getText();
+                        node.replaceWithText(replacement);
+                        processedIdentifiers.add(node);
+                        changes.push({
+                            type: 'identifier-replace',
+                            filePath,
+                            line: node.getStartLineNumber(),
+                            original,
+                            replacement,
+                        });
+                    }
+                    catch {
+                        // Node might have been modified in a previous pass
+                    }
+                }
+            }
+        });
+    }
+    // ============================================================================
+    // STEP 4: Handle old icon library imports
+    // - Remove imports that have been migrated
+    // - KEEP imports that don't have valid Hugeicons replacements
+    // ============================================================================
+    for (const importDecl of sourceFile.getImportDeclarations()) {
+        const moduleSpecifier = importDecl.getModuleSpecifierValue();
+        const isIconLibrary = SUPPORTED_LIBRARIES.some((lib) => moduleSpecifier === lib.name ||
+            lib.aliases.includes(moduleSpecifier) ||
+            lib.aliases.some((alias) => moduleSpecifier.startsWith(alias)));
+        if (isIconLibrary) {
+            const namedImports = importDecl.getNamedImports();
+            // Separate imports: ones to keep (unmapped) vs ones to remove (migrated)
+            const importsToKeep = [];
+            const importsToRemoveFromDecl = [];
+            for (const namedImport of namedImports) {
+                const importedName = namedImport.getName();
+                const aliasNode = namedImport.getAliasNode();
+                const localName = aliasNode ? aliasNode.getText() : importedName;
+                if (iconsToKeepAsOriginal.has(localName)) {
+                    // This icon has no valid Hugeicons replacement - KEEP IT
+                    importsToKeep.push(namedImport.getText());
+                }
+                else {
+                    // This icon was migrated - remove it
+                    importsToRemoveFromDecl.push(localName);
+                }
+            }
+            if (importsToKeep.length === 0) {
+                // All imports from this declaration are migrated - remove the whole statement
+                changes.push({
+                    type: 'import-remove',
+                    filePath,
+                    line: importDecl.getStartLineNumber(),
+                    original: importDecl.getText(),
+                    replacement: '',
+                });
+                try {
+                    importDecl.remove();
+                }
+                catch {
+                    // Already removed
+                }
+            }
+            else if (importsToRemoveFromDecl.length > 0) {
+                // Some imports migrated, some kept - update the import statement
+                const originalText = importDecl.getText();
+                // Remove the migrated imports, keep the unmapped ones
+                for (const namedImport of namedImports) {
+                    const aliasNode = namedImport.getAliasNode();
+                    const localName = aliasNode ? aliasNode.getText() : namedImport.getName();
+                    if (!iconsToKeepAsOriginal.has(localName)) {
+                        try {
+                            namedImport.remove();
+                        }
+                        catch {
+                            // Already removed
+                        }
+                    }
+                }
+                changes.push({
+                    type: 'import-modify',
+                    filePath,
+                    line: importDecl.getStartLineNumber(),
+                    original: originalText,
+                    replacement: importDecl.getText(),
+                });
+            }
+            // else: all imports are unmapped - keep the whole statement as is
+        }
+    }
+    // ============================================================================
+    // STEP 5: Add Hugeicons imports
+    // ============================================================================
+    if (hugeIconsToImport.size > 0 || needsHugeiconsIcon || needsIconSvgElementType) {
+        const iconPackage = getIconPackage(style);
+        // Build the new imports
+        const imports = [];
+        // Build react package imports (HugeiconsIcon and/or IconSvgElement type)
+        const reactPackageImports = [];
+        if (needsHugeiconsIcon) {
+            reactPackageImports.push('HugeiconsIcon');
+        }
+        if (needsIconSvgElementType) {
+            reactPackageImports.push('type IconSvgElement');
+        }
+        if (reactPackageImports.length > 0) {
+            imports.push(`import { ${reactPackageImports.join(', ')} } from "${HUGEICONS_REACT_PACKAGE}";`);
+        }
+        // Import icons from the style-specific package (if any)
+        if (hugeIconsToImport.size > 0) {
+            const iconSpecifiers = Array.from(hugeIconsToImport.entries())
+                .sort((a, b) => a[0].localeCompare(b[0]))
+                .map(([original, alias]) => {
+                if (original === alias) {
+                    return original;
+                }
+                return `${original} as ${alias}`;
+            })
+                .join(', ');
+            imports.push(`import { ${iconSpecifiers} } from "${iconPackage}";`);
+        }
+        const newImport = imports.join('\n');
+        // Find the best position for the new import (after removing old ones)
+        const remainingImports = sourceFile.getImportDeclarations();
+        if (remainingImports.length > 0) {
+            // Insert before the first remaining import
+            remainingImports[0].replaceWithText(newImport + '\n' + remainingImports[0].getText());
+        }
+        else {
+            // No imports left, add at the beginning
+            sourceFile.insertText(0, newImport + '\n\n');
+        }
+        changes.push({
+            type: 'import-add',
+            filePath,
+            line: 1,
+            original: '',
+            replacement: newImport,
+        });
+    }
+    // ============================================================================
+    // STEP 6: Validation - Check for any leftover old library references
+    // ============================================================================
+    const finalIconCount = hugeIconsToImport.size;
+    const fileContent = sourceFile.getFullText();
+    // Check for any remaining old library imports
+    const remainingOldImports = [];
+    for (const lib of SUPPORTED_LIBRARIES) {
+        // Check for import statements
+        if (fileContent.includes(`from "${lib.name}"`) || fileContent.includes(`from '${lib.name}'`)) {
+            remainingOldImports.push(lib.name);
+        }
+        for (const alias of lib.aliases) {
+            if (fileContent.includes(`from "${alias}"`) || fileContent.includes(`from '${alias}'`)) {
+                remainingOldImports.push(alias);
+            }
+        }
+    }
+    // Check for any remaining identifier references to old icons
+    const remainingOldReferences = [];
+    for (const oldImport of oldIconImports) {
+        // Use regex to find standalone identifier references (not part of new imports)
+        const identifierRegex = new RegExp(`\\b${oldImport.localName}\\b`, 'g');
+        const matches = fileContent.match(identifierRegex);
+        if (matches && matches.length > 0) {
+            // Check if this is not in the new hugeicons import
+            const newImportName = iconReplacements.get(oldImport.localName);
+            if (newImportName && !fileContent.includes(newImportName)) {
+                remainingOldReferences.push(oldImport.localName);
+            }
+        }
+    }
+    // Log validation results
+    if (remainingOldImports.length > 0 || remainingOldReferences.length > 0 || unmappedIcons.length > 0) {
+        console.warn(`[${filePath}] Migration validation warnings:`);
+        if (originalIconCount !== finalIconCount) {
+            console.warn(`  - Icon count mismatch: ${originalIconCount} original -> ${finalIconCount} new`);
+        }
+        if (unmappedIcons.length > 0) {
+            console.warn(`  - Unmapped icons (using fallback): ${unmappedIcons.join(', ')}`);
+        }
+        if (remainingOldImports.length > 0) {
+            console.warn(`  - Remaining old imports: ${remainingOldImports.join(', ')}`);
+        }
+        if (remainingOldReferences.length > 0) {
+            console.warn(`  - Possible remaining old references: ${remainingOldReferences.join(', ')}`);
+        }
+    }
+    return {
+        filePath,
+        original: '', // Will be set by caller
+        transformed: sourceFile.getFullText(),
+        changes,
+        success: true,
+    };
+}
+/**
+ * Transform FontAwesomeIcon element
+ * Returns true if transformation was applied
+ */
+function transformFontAwesomeElement(element, mappingMap, localToImported, hugeIconsToImport, existingIdentifiers, changes, filePath) {
+    // Find the icon prop
+    const iconAttr = element.getAttribute('icon');
+    if (!iconAttr || !Node.isJsxAttribute(iconAttr))
+        return false;
+    const initializer = iconAttr.getInitializer();
+    if (!initializer || !Node.isJsxExpression(initializer))
+        return false;
+    const expression = initializer.getExpression();
+    if (!expression || !Node.isIdentifier(expression))
+        return false;
+    const iconName = expression.getText();
+    const importInfo = localToImported.get(iconName);
+    if (!importInfo)
+        return false;
+    const key = `${importInfo.library}:${importInfo.importedName}`;
+    const mapping = mappingMap.get(key);
+    if (!mapping?.target)
+        return false;
+    const targetComponent = mapping.target.component;
+    // Get non-conflicting import name
+    let iconImportName = targetComponent;
+    if (hugeIconsToImport.has(targetComponent)) {
+        iconImportName = hugeIconsToImport.get(targetComponent);
+    }
+    else {
+        if (existingIdentifiers.has(targetComponent)) {
+            const baseName = targetComponent.replace(/Icon$/, '');
+            iconImportName = `Huge${baseName}Icon`;
+            let counter = 2;
+            while (existingIdentifiers.has(iconImportName)) {
+                iconImportName = `Huge${baseName}${counter}Icon`;
+                counter++;
+            }
+        }
+        hugeIconsToImport.set(targetComponent, iconImportName);
+        existingIdentifiers.add(iconImportName);
+    }
+    // Collect props to keep and convert
+    const propsToKeep = [];
+    const classNames = [];
+    for (const attr of element.getAttributes()) {
+        if (!Node.isJsxAttribute(attr))
+            continue;
+        const propName = attr.getNameNode().getText();
+        // Skip the icon prop
+        if (propName === 'icon')
+            continue;
+        // Check if it's a FA-specific prop that needs conversion
+        const conversion = FA_PROP_CONVERSIONS[propName];
+        if (conversion) {
+            if (conversion.type === 'class' && conversion.value) {
+                classNames.push(conversion.value);
+            }
+            // Remove or warn for other types
+            continue;
+        }
+        // Keep the prop as-is
+        propsToKeep.push(attr.getText());
+    }
+    // Add converted classes to className if we have any
+    if (classNames.length > 0) {
+        const existingClassName = element.getAttribute('className');
+        if (existingClassName && Node.isJsxAttribute(existingClassName)) {
+            const init = existingClassName.getInitializer();
+            if (init && Node.isStringLiteral(init)) {
+                const existing = init.getLiteralValue();
+                propsToKeep.push(`className="${existing} ${classNames.join(' ')}"`);
+            }
+            else {
+                propsToKeep.push(`className="${classNames.join(' ')}"`);
+            }
+            // Remove the original className from propsToKeep
+            const idx = propsToKeep.findIndex((p) => p.startsWith('className'));
+            if (idx > 0)
+                propsToKeep.splice(idx - 1, 1);
+        }
+        else {
+            propsToKeep.push(`className="${classNames.join(' ')}"`);
+        }
+    }
+    // Build the replacement JSX with HugeiconsIcon wrapper
+    const propsString = propsToKeep.length > 0 ? ' ' + propsToKeep.join(' ') : '';
+    const original = element.getText();
+    let replacement;
+    if (Node.isJsxSelfClosingElement(element)) {
+        replacement = `<HugeiconsIcon icon={${iconImportName}}${propsString} />`;
+    }
+    else {
+        replacement = `<HugeiconsIcon icon={${iconImportName}}${propsString}>`;
+    }
+    // Replace the element
+    element.replaceWithText(replacement);
+    // If this was an opening element, we need to handle the closing tag
+    if (Node.isJsxOpeningElement(element)) {
+        const parent = element.getParent();
+        if (parent && Node.isJsxElement(parent)) {
+            const closingElement = parent.getClosingElement();
+            if (closingElement) {
+                closingElement.replaceWithText(`</HugeiconsIcon>`);
+            }
+        }
+    }
+    changes.push({
+        type: 'jsx-replace',
+        filePath,
+        line: element.getStartLineNumber(),
+        original,
+        replacement,
+    });
+    return true;
+}
+/**
+ * Create backup of files to be modified
+ */
+async function createBackup(root, filesToModify) {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const backupDir = path.join(root, `hugeicons-migrate-backup-${timestamp}`);
+    fs.mkdirSync(backupDir, { recursive: true });
+    for (const filePath of filesToModify) {
+        const sourcePath = path.join(root, filePath);
+        const targetPath = path.join(backupDir, filePath);
+        // Create directory structure
+        fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+        // Copy file
+        fs.copyFileSync(sourcePath, targetPath);
+    }
+    return backupDir;
+}
+/**
+ * Generate unified diff patch
+ */
+function generatePatch(transformations) {
+    const lines = [];
+    for (const transform of transformations) {
+        if (!transform.success || transform.changes.length === 0)
+            continue;
+        lines.push(`--- a/${transform.filePath}`);
+        lines.push(`+++ b/${transform.filePath}`);
+        // Generate simple diff representation
+        for (const change of transform.changes) {
+            if (change.original) {
+                lines.push(`@@ -${change.line} @@`);
+                lines.push(`-${change.original}`);
+            }
+            if (change.replacement) {
+                if (!change.original) {
+                    lines.push(`@@ +${change.line} @@`);
+                }
+                lines.push(`+${change.replacement}`);
+            }
+        }
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+/**
+ * Check git status
+ */
+export function checkGitStatus(root) {
+    try {
+        const gitDir = path.join(root, '.git');
+        const isRepo = fs.existsSync(gitDir);
+        if (!isRepo) {
+            return { isRepo: false, isDirty: false, modifiedFiles: [] };
+        }
+        // Try to check status via simple file check
+        // In a real implementation, we'd use git commands
+        return { isRepo: true, isDirty: false, modifiedFiles: [] };
+    }
+    catch {
+        return { isRepo: false, isDirty: false, modifiedFiles: [] };
+    }
+}
+//# sourceMappingURL=transformer.js.map