@ethlete/cdk 4.70.0 → 5.0.0-next.0

package/generators/generators.json

@@ -0,0 +1,9 @@
+{
+  "generators": {
+    "migrate-to-v5": {
+      "factory": "./migrate-to-v5/migration",
+      "schema": "./migrate-to-v5/schema.json",
+      "description": "A migration to update the cdk to version 5"
+    }
+  }
+}

package/generators/migrate-to-v5/cdk-menu.js

@@ -0,0 +1,259 @@
+const SYMBOL_MAP = {
+    CdkMenuTrigger: 'MenuTriggerDirective',
+    CdkMenuItem: 'MenuItemDirective',
+    CdkMenu: 'MenuComponent',
+    CdkMenuGroup: 'MenuGroupDirective',
+    CdkMenuItemCheckbox: 'MenuCheckboxItemComponent',
+    CdkMenuItemRadio: 'MenuRadioItemComponent',
+    CdkMenuModule: 'MenuImports',
+};
+const CDK_MENU_SYMBOLS = Object.keys(SYMBOL_MAP);
+// These are the et menu symbols that should be consolidated into MenuImports in decorators
+const ET_MENU_SYMBOLS = new Set([
+    'MenuGroupDirective',
+    'MenuCheckboxItemComponent',
+    'MenuRadioItemComponent',
+    'MenuGroupTitleDirective',
+    'MenuItemDirective',
+    'MenuTriggerDirective',
+    'MenuCheckboxGroupDirective',
+    'MenuRadioGroupDirective',
+    'MenuComponent',
+    'MenuSearchTemplateDirective',
+]);
+export default async function migrateCdkMenu(tree) {
+    console.log('\n🔄 Migrating from CDK menu to et menu');
+    const files = tree.children('.');
+    const warnings = new Map();
+    function walkFiles(path) {
+        const entries = tree.children(path);
+        entries.forEach((entry) => {
+            const fullPath = `${path}/${entry}`.replace(/^\//, '');
+            if (tree.isFile(fullPath)) {
+                if (fullPath.endsWith('.ts') && !fullPath.endsWith('.spec.ts')) {
+                    migrateTypeScriptFile(fullPath);
+                }
+                else if (fullPath.endsWith('.html')) {
+                    migrateHtmlFile(fullPath, warnings);
+                }
+            }
+            else {
+                walkFiles(fullPath);
+            }
+        });
+    }
+    walkFiles('.');
+    // Print warnings at the end
+    if (warnings.size > 0) {
+        console.log('\n⚠️  Manual migration required for the following files:');
+        warnings.forEach((msgs, file) => {
+            console.log(`\n📄 ${file}:`);
+            msgs.forEach((msg) => console.log(`   - ${msg}`));
+        });
+    }
+    function migrateTypeScriptFile(filePath) {
+        let content = tree.read(filePath, 'utf-8');
+        if (!content)
+            return;
+        const originalContent = content;
+        // Find all @ethlete/cdk imports
+        const importRegex = /import\s*{([^}]*)}\s*from\s*['"]@ethlete\/cdk['"]/g;
+        const imports = Array.from(content.matchAll(importRegex));
+        if (imports.length === 0)
+            return;
+        // Process imports and build replacement
+        let hasMenuSymbols = false;
+        let hasMenuImports = false;
+        const importedSymbols = new Set();
+        imports.forEach((match) => {
+            const importList = match[1];
+            const symbols = importList
+                .split(',')
+                .map((s) => s.trim())
+                .filter((s) => s);
+            symbols.forEach((symbol) => {
+                importedSymbols.add(symbol);
+                if (CDK_MENU_SYMBOLS.includes(symbol)) {
+                    hasMenuSymbols = true;
+                }
+                if (symbol === 'MenuImports') {
+                    hasMenuImports = true;
+                }
+            });
+        });
+        if (!hasMenuSymbols && !Array.from(importedSymbols).some((s) => ET_MENU_SYMBOLS.has(s)))
+            return;
+        // Handle decorator imports arrays FIRST (before replacing symbols in code)
+        const decoratorRegex = /imports\s*:\s*\[([\s\S]*?)\]/g;
+        let usesMenuInDecorator = false;
+        const menuSymbolsInDecorator = new Set();
+        content = content.replace(decoratorRegex, (match) => {
+            let hasMenuSymbol = false;
+            let result = match;
+            // Check for CDK menu symbols
+            CDK_MENU_SYMBOLS.forEach((symbol) => {
+                if (result.includes(symbol)) {
+                    hasMenuSymbol = true;
+                    menuSymbolsInDecorator.add(symbol);
+                    result = result.replace(new RegExp(`\\b${symbol}\\b`, 'g'), '');
+                }
+            });
+            // Check for et menu symbols
+            ET_MENU_SYMBOLS.forEach((symbol) => {
+                if (result.includes(symbol)) {
+                    hasMenuSymbol = true;
+                    menuSymbolsInDecorator.add(symbol);
+                    result = result.replace(new RegExp(`\\b${symbol}\\b`, 'g'), '');
+                }
+            });
+            if (hasMenuSymbol) {
+                usesMenuInDecorator = true;
+                // Extract the array content and clean it up
+                const arrayMatch = result.match(/imports\s*:\s*\[([\s\S]*?)\]/);
+                if (arrayMatch) {
+                    const arrayContent = arrayMatch[1];
+                    // Split by comma, trim, filter empty strings
+                    const items = arrayContent
+                        .split(',')
+                        .map((item) => item.trim())
+                        .filter((item) => item && item !== 'MenuImports');
+                    // Reconstruct with MenuImports
+                    if (items.length === 0) {
+                        result = result.replace(/imports\s*:\s*\[([\s\S]*?)\]/, 'imports: [MenuImports]');
+                    }
+                    else {
+                        const newContent = `MenuImports, ${items.join(', ')}`;
+                        result = result.replace(/imports\s*:\s*\[([\s\S]*?)\]/, `imports: [${newContent}]`);
+                    }
+                }
+            }
+            return result;
+        });
+        // Replace imports
+        content = content.replace(importRegex, (match, importList) => {
+            const symbols = importList
+                .split(',')
+                .map((s) => s.trim())
+                .filter((s) => s);
+            const replaced = symbols
+                .filter((symbol) => !menuSymbolsInDecorator.has(symbol))
+                .map((symbol) => {
+                if (CDK_MENU_SYMBOLS.includes(symbol)) {
+                    return SYMBOL_MAP[symbol];
+                }
+                return symbol;
+            });
+            // Add MenuImports if used in decorator and not already present
+            if (usesMenuInDecorator && !replaced.includes('MenuImports')) {
+                replaced.push('MenuImports');
+            }
+            // Deduplicate
+            const unique = Array.from(new Set(replaced));
+            return `import { ${unique.join(', ')} } from '@ethlete/cdk'`;
+        });
+        // Replace symbol usages in code
+        CDK_MENU_SYMBOLS.forEach((oldSymbol) => {
+            if (importedSymbols.has(oldSymbol) && !menuSymbolsInDecorator.has(oldSymbol)) {
+                const newSymbol = SYMBOL_MAP[oldSymbol];
+                content = content.replace(new RegExp(`\\b${oldSymbol}\\b`, 'g'), newSymbol);
+            }
+        });
+        if (content !== originalContent) {
+            tree.write(filePath, content);
+        }
+    }
+    function migrateHtmlFile(filePath, warnings) {
+        let content = tree.read(filePath, 'utf-8');
+        if (!content)
+            return;
+        const originalContent = content;
+        const fileWarnings = [];
+        // 1. Replace [cdkMenuTriggerFor] binding with [etMenuTrigger]
+        if (content.includes('[cdkMenuTriggerFor]')) {
+            content = content.replace(/\[cdkMenuTriggerFor\]/g, '[etMenuTrigger]');
+        }
+        const cdkMenuRegex = /<(\w+)([^>]*?)\bcdkMenu\b([^>]*)>/g;
+        const matches = Array.from(content.matchAll(cdkMenuRegex));
+        if (matches.length > 0) {
+            fileWarnings.push(`Found ${matches.length} element(s) with cdkMenu directive. ` +
+                'Replaced with <et-menu> component. Verify all attributes and bindings are preserved.');
+            // Collect replacements for entire elements
+            const replacements = [];
+            for (const match of matches) {
+                const tagName = match[1];
+                const beforeAttrs = match[2];
+                const afterAttrs = match[3];
+                const allAttrs = (beforeAttrs + afterAttrs)
+                    .replace(/\s+cdkMenu\s+/, ' ')
+                    .replace(/\bcdkMenu\b/, '')
+                    .trim();
+                const spacer = allAttrs ? ' ' : '';
+                const openingStart = match.index;
+                const openingEnd = match.index + match[0].length;
+                let count = 1;
+                let pos = openingEnd;
+                while (pos < content.length && count > 0) {
+                    if (content.startsWith(`<${tagName}`, pos)) {
+                        count++;
+                    }
+                    else if (content.startsWith(`</${tagName}>`, pos)) {
+                        count--;
+                        if (count === 0) {
+                            const closingStart = pos;
+                            const closingEnd = pos + `</${tagName}>`.length;
+                            const innerContent = content.slice(openingEnd, closingStart);
+                            const replacement = `<et-menu${spacer}${allAttrs}>${innerContent}</et-menu>`;
+                            replacements.push({ start: openingStart, end: closingEnd, replacement });
+                            break;
+                        }
+                    }
+                    pos++;
+                }
+            }
+            // Replace in reverse order to maintain positions
+            replacements.sort((a, b) => b.start - a.start);
+            for (const rep of replacements) {
+                content = content.slice(0, rep.start) + rep.replacement + content.slice(rep.end);
+            }
+        }
+        // 3. Replace cdkMenuItem directive with etMenuItem
+        if (content.includes('cdkMenuItem')) {
+            content = content.replace(/\bcdkMenuItem\b/g, 'etMenuItem');
+        }
+        // 4. Replace cdkMenuItemCheckbox with et-menu-checkbox-item
+        if (content.includes('cdkMenuItemCheckbox')) {
+            const checkboxRegex = /<(\w+)([^>]*?)\bcdkMenuItemCheckbox\b([^>]*)>([\s\S]*?)<\/\1>/g;
+            content = content.replace(checkboxRegex, (match, tagName, beforeAttrs, afterAttrs, inner) => {
+                const allAttrs = (beforeAttrs + afterAttrs)
+                    .replace(/\s+cdkMenuItemCheckbox\s+/, ' ')
+                    .replace(/\bcdkMenuItemCheckbox\b/, '')
+                    .trim();
+                const spacer = allAttrs ? ' ' : '';
+                return `<et-menu-checkbox-item${spacer}${allAttrs}>${inner}</et-menu-checkbox-item>`;
+            });
+        }
+        // 5. Replace cdkMenuItemRadio with et-menu-radio-item and add warning
+        if (content.includes('cdkMenuItemRadio')) {
+            const radioRegex = /<(\w+)([^>]*?)\bcdkMenuItemRadio\b([^>]*)>([\s\S]*?)<\/\1>/g;
+            content = content.replace(radioRegex, (match, tagName, beforeAttrs, afterAttrs, inner) => {
+                const allAttrs = (beforeAttrs + afterAttrs)
+                    .replace(/\s+cdkMenuItemRadio\s+/, ' ')
+                    .replace(/\bcdkMenuItemRadio\b/, '')
+                    .trim();
+                const spacer = allAttrs ? ' ' : '';
+                fileWarnings.push('Manual migration required: Wrap et-menu-radio-item elements in <div etMenuRadioGroup> and add appropriate value attributes.');
+                return `<et-menu-radio-item${spacer}${allAttrs} value="TODO">${inner}</et-menu-radio-item>`;
+            });
+        }
+        if (content !== originalContent) {
+            tree.write(filePath, content);
+        }
+        if (fileWarnings.length > 0) {
+            if (!warnings.has(filePath)) {
+                warnings.set(filePath, []);
+            }
+            warnings.get(filePath).push(...fileWarnings);
+        }
+    }
+}
+//# sourceMappingURL=cdk-menu.js.map

package/generators/migrate-to-v5/color-themes.js

@@ -0,0 +1,221 @@
+import { logger, readJson, visitNotIgnoredFiles, writeJson } from '@nx/devkit';
+// Theming-related exports that moved from @ethlete/theming and @ethlete/cdk to @ethlete/core
+const THEMING_EXPORTS = new Set([
+    'ProvideThemeDirective',
+    'THEME_PROVIDER',
+    'Theme',
+    'ThemeSwatch',
+    'OnThemeColorMap',
+    'ThemeColorMap',
+    'ThemeColor',
+    'ThemeHSLColor',
+    'ThemeRGBColor',
+    'provideThemes',
+    'provideColorThemes',
+]);
+export default async function migrateColorThemes(tree) {
+    console.log('\n🔄 Migrating provideThemes to provideColorThemes and imports to @ethlete/core');
+    let filesModified = 0;
+    let functionReplacements = 0;
+    let importsMoved = 0;
+    let importsMerged = 0;
+    let packagesRemoved = 0;
+    // Migrate TypeScript files
+    visitNotIgnoredFiles(tree, '', (filePath) => {
+        if (!filePath.endsWith('.ts')) {
+            return;
+        }
+        const content = tree.read(filePath, 'utf-8');
+        if (!content) {
+            return;
+        }
+        // Check if file contains provideThemes or imports from @ethlete/theming or @ethlete/cdk
+        if (!content.includes('provideThemes') &&
+            !content.includes('@ethlete/theming') &&
+            !content.includes('@ethlete/cdk')) {
+            return;
+        }
+        let modified = content;
+        let fileChanges = 0;
+        // Replace provideThemes with provideColorThemes
+        const beforeProvideThemesCount = (modified.match(/\bprovideThemes\b/g) || []).length;
+        modified = modified.replace(/\bprovideThemes\b/g, 'provideColorThemes');
+        fileChanges += beforeProvideThemesCount;
+        functionReplacements += beforeProvideThemesCount;
+        // Handle import merging from @ethlete/theming and @ethlete/cdk to @ethlete/core
+        const themingImportPattern = /import\s*{([^}]*)}\s*from\s*['"]@ethlete\/theming['"]/g;
+        const cdkImportPattern = /import\s*{([^}]*)}\s*from\s*['"]@ethlete\/cdk['"]/g;
+        const coreImportPattern = /import\s*{([^}]*)}\s*from\s*['"]@ethlete\/core['"]/;
+        const themingImportsToMove = [];
+        const cdkThemingImportsToMove = [];
+        const cdkNonThemingImports = [];
+        let themingMatch;
+        let cdkMatch;
+        // Collect all imports from @ethlete/theming (all should be moved)
+        while ((themingMatch = themingImportPattern.exec(modified)) !== null) {
+            const imports = themingMatch[1]
+                .split(',')
+                .map((imp) => imp.trim())
+                .filter((imp) => imp.length > 0);
+            // Keep the full import string including 'type' keyword and aliases
+            themingImportsToMove.push(...imports);
+        }
+        // Collect imports from @ethlete/cdk and separate theming vs non-theming
+        while ((cdkMatch = cdkImportPattern.exec(modified)) !== null) {
+            const imports = cdkMatch[1]
+                .split(',')
+                .map((imp) => imp.trim())
+                .filter((imp) => imp.length > 0);
+            imports.forEach((imp) => {
+                // Extract the actual import name (without 'type' keyword and alias)
+                // Handle patterns like: "type Theme as EthleteTheme", "Theme", "type Theme"
+                const typeKeywordMatch = imp.match(/^type\s+/);
+                const hasTypeKeyword = !!typeKeywordMatch;
+                const withoutType = imp.replace(/^type\s+/, '').trim();
+                const importName = withoutType.split(/\s+as\s+/)[0]?.trim() || withoutType;
+                if (THEMING_EXPORTS.has(importName)) {
+                    cdkThemingImportsToMove.push(imp); // Keep the original import with type keyword and alias
+                }
+                else {
+                    cdkNonThemingImports.push(imp); // Keep the original import with type keyword and alias
+                }
+            });
+        }
+        const allThemingImports = [...themingImportsToMove, ...cdkThemingImportsToMove];
+        if (allThemingImports.length > 0) {
+            // Check if there's already a @ethlete/core import
+            const existingCoreImport = modified.match(coreImportPattern);
+            if (existingCoreImport) {
+                // Merge theming imports with existing @ethlete/core import
+                const existingImports = existingCoreImport[1]
+                    .split(',')
+                    .map((imp) => imp.trim())
+                    .filter((imp) => imp.length > 0);
+                const allImports = [...existingImports, ...allThemingImports];
+                // Remove duplicates while preserving order and type keywords
+                // We need to compare the actual import names (without type and aliases) for deduplication
+                const seen = new Set();
+                const uniqueImports = allImports.filter((imp) => {
+                    const withoutType = imp.replace(/^type\s+/, '').trim();
+                    const importName = withoutType.split(/\s+as\s+/)[0]?.trim() || withoutType;
+                    if (seen.has(importName)) {
+                        return false;
+                    }
+                    seen.add(importName);
+                    return true;
+                });
+                // Replace the existing @ethlete/core import with merged imports
+                modified = modified.replace(coreImportPattern, `import { ${uniqueImports.join(', ')} } from '@ethlete/core'`);
+                importsMerged++;
+                fileChanges++;
+            }
+            else {
+                // No existing @ethlete/core import, create a new one
+                const uniqueImports = Array.from(new Set(allThemingImports));
+                // Find the position of the first theming import to replace
+                const firstThemingImport = modified.match(/import\s*{[^}]*}\s*from\s*['"]@ethlete\/theming['"];?\s*\n?/);
+                if (firstThemingImport) {
+                    // Replace first theming import with core import
+                    modified = modified.replace(/import\s*{[^}]*}\s*from\s*['"]@ethlete\/theming['"];?\s*\n?/, `import { ${uniqueImports.join(', ')} } from '@ethlete/core';\n`);
+                }
+                else {
+                    // Add new @ethlete/core import at the beginning (after first import)
+                    const firstImportMatch = modified.match(/import\s+[^;]+;/);
+                    if (firstImportMatch) {
+                        const insertPosition = firstImportMatch.index + firstImportMatch[0].length;
+                        modified =
+                            modified.slice(0, insertPosition) +
+                                `\nimport { ${uniqueImports.join(', ')} } from '@ethlete/core';` +
+                                modified.slice(insertPosition);
+                    }
+                }
+                importsMoved++;
+                fileChanges++;
+            }
+            // Remove all @ethlete/theming imports
+            modified = modified.replace(/import\s*{[^}]*}\s*from\s*['"]@ethlete\/theming['"];?\s*\n?/g, '');
+            // Handle @ethlete/cdk imports - only process if we found theming imports to move
+            if (cdkThemingImportsToMove.length > 0) {
+                // Remove all existing @ethlete/cdk imports first
+                modified = modified.replace(/import\s*{[^}]*}\s*from\s*['"]@ethlete\/cdk['"];?\s*\n?/g, '');
+                if (cdkNonThemingImports.length > 0) {
+                    // Add back only the non-theming imports after the @ethlete/core import
+                    const cdkImportStatement = `import { ${cdkNonThemingImports.join(', ')} } from '@ethlete/cdk';\n`;
+                    const coreImportMatch = modified.match(/import\s*{[^}]*}\s*from\s*['"]@ethlete\/core['"];?\s*\n?/);
+                    if (coreImportMatch) {
+                        const insertPosition = coreImportMatch.index + coreImportMatch[0].length;
+                        modified = modified.slice(0, insertPosition) + cdkImportStatement + modified.slice(insertPosition);
+                    }
+                    else {
+                        // If no core import exists, add after the first import
+                        const firstImportMatch = modified.match(/import\s+[^;]+;/);
+                        if (firstImportMatch) {
+                            const insertPosition = firstImportMatch.index + firstImportMatch[0].length;
+                            modified = modified.slice(0, insertPosition) + '\n' + cdkImportStatement + modified.slice(insertPosition);
+                        }
+                    }
+                }
+                // Clean up any resulting double newlines
+                modified = modified.replace(/\n\n\n+/g, '\n\n');
+                fileChanges++;
+            }
+        }
+        if (modified !== content) {
+            tree.write(filePath, modified);
+            filesModified++;
+            console.log(`   ✓ ${filePath} (${fileChanges} change${fileChanges !== 1 ? 's' : ''})`);
+        }
+    });
+    // Remove @ethlete/theming from package.json files (but keep @ethlete/cdk)
+    const packageJsonFiles = ['package.json'];
+    // Also check for package.json in apps and libs
+    visitNotIgnoredFiles(tree, '', (filePath) => {
+        if (filePath.endsWith('package.json') && !packageJsonFiles.includes(filePath)) {
+            packageJsonFiles.push(filePath);
+        }
+    });
+    for (const packageJsonPath of packageJsonFiles) {
+        if (!tree.exists(packageJsonPath)) {
+            continue;
+        }
+        try {
+            const packageJson = readJson(tree, packageJsonPath);
+            let modified = false;
+            // Remove @ethlete/theming from dependencies
+            if (packageJson.dependencies && packageJson.dependencies['@ethlete/theming']) {
+                delete packageJson.dependencies['@ethlete/theming'];
+                modified = true;
+                console.log(`   ✓ Removed @ethlete/theming from ${packageJsonPath} dependencies`);
+            }
+            // Remove @ethlete/theming from devDependencies
+            if (packageJson.devDependencies && packageJson.devDependencies['@ethlete/theming']) {
+                delete packageJson.devDependencies['@ethlete/theming'];
+                modified = true;
+                console.log(`   ✓ Removed @ethlete/theming from ${packageJsonPath} devDependencies`);
+            }
+            // Remove @ethlete/theming from peerDependencies
+            if (packageJson.peerDependencies && packageJson.peerDependencies['@ethlete/theming']) {
+                delete packageJson.peerDependencies['@ethlete/theming'];
+                modified = true;
+                console.log(`   ✓ Removed @ethlete/theming from ${packageJsonPath} peerDependencies`);
+            }
+            if (modified) {
+                writeJson(tree, packageJsonPath, packageJson);
+                packagesRemoved++;
+            }
+        }
+        catch (error) {
+            logger.warn(`Failed to process ${packageJsonPath}: ${error}`);
+        }
+    }
+    console.log(`\n✅ Color themes migration complete:`);
+    console.log(`   📝 Files modified: ${filesModified}`);
+    console.log(`   🔄 Function replacements: ${functionReplacements}`);
+    console.log(`   📦 Imports moved: ${importsMoved}`);
+    console.log(`   🔗 Imports merged: ${importsMerged}`);
+    console.log(`   🗑️  Package.json files updated: ${packagesRemoved}`);
+    if (packagesRemoved > 0) {
+        console.log(`\n⚠️  Don't forget to run 'yarn install' to update your lock file!`);
+    }
+}
+//# sourceMappingURL=color-themes.js.map

package/generators/migrate-to-v5/combobox.js

@@ -0,0 +1,186 @@
+import { visitNotIgnoredFiles } from '@nx/devkit';
+import * as ts from 'typescript';
+export function migrateCombobox(tree) {
+    console.log('\n🔄 Migrating <et-combobox> components...');
+    migrateInputs(tree);
+    migrateProvideComboboxConfig(tree);
+}
+function migrateInputs(tree) {
+    let filesModified = 0;
+    let propertiesRenamed = 0;
+    visitNotIgnoredFiles(tree, '', (filePath) => {
+        if (!filePath.endsWith('.html') && !filePath.endsWith('.component.ts')) {
+            return;
+        }
+        const content = tree.read(filePath, 'utf-8');
+        if (!content)
+            return;
+        const newContent = migrateEmptyTextProperty(content, filePath);
+        if (newContent !== content) {
+            tree.write(filePath, newContent);
+            filesModified++;
+        }
+    });
+    function migrateEmptyTextProperty(content, filePath) {
+        let result = content;
+        let filePropertiesRenamed = 0;
+        // HTML template files
+        if (filePath.endsWith('.html')) {
+            // Find all <et-combobox> tags and only replace emptyText within them
+            const comboboxRegex = /<et-combobox\s[^>]*>/g;
+            result = content.replace(comboboxRegex, (match) => {
+                let modified = match;
+                let localRenames = 0;
+                // Replace [emptyText] with [bodyEmptyText]
+                const propertyBindingCount = (modified.match(/\[emptyText\]/g) || []).length;
+                modified = modified.replace(/\[emptyText\]/g, '[bodyEmptyText]');
+                localRenames += propertyBindingCount;
+                // Replace emptyText= with bodyEmptyText= (attribute binding)
+                const attributeCount = (modified.match(/(\s)emptyText=/g) || []).length;
+                modified = modified.replace(/(\s)emptyText=/g, '$1bodyEmptyText=');
+                localRenames += attributeCount;
+                if (localRenames > 0) {
+                    filePropertiesRenamed += localRenames;
+                }
+                return modified;
+            });
+        }
+        // TypeScript component files (inline templates)
+        if (filePath.endsWith('.component.ts')) {
+            const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
+            const replacements = [];
+            function visit(node) {
+                // Handle template strings in @Component decorator
+                if (ts.isPropertyAssignment(node)) {
+                    if (ts.isIdentifier(node.name) &&
+                        node.name.text === 'template' &&
+                        (ts.isStringLiteral(node.initializer) || ts.isNoSubstitutionTemplateLiteral(node.initializer))) {
+                        const templateContent = node.initializer.getText(sourceFile);
+                        const templateText = templateContent.slice(1, -1); // Remove quotes
+                        // Only process if template contains et-combobox
+                        if (templateText.includes('<et-combobox') && templateText.includes('emptyText')) {
+                            let newTemplate = templateText;
+                            let localRenames = 0;
+                            // Find all <et-combobox> tags and only replace emptyText within them
+                            const comboboxRegex = /<et-combobox\s[^>]*>/g;
+                            newTemplate = newTemplate.replace(comboboxRegex, (match) => {
+                                let modified = match;
+                                // Replace [emptyText] with [bodyEmptyText]
+                                const propertyBindingCount = (modified.match(/\[emptyText\]/g) || []).length;
+                                modified = modified.replace(/\[emptyText\]/g, '[bodyEmptyText]');
+                                localRenames += propertyBindingCount;
+                                // Replace emptyText= with bodyEmptyText=
+                                const attributeCount = (modified.match(/(\s)emptyText=/g) || []).length;
+                                modified = modified.replace(/(\s)emptyText=/g, '$1bodyEmptyText=');
+                                localRenames += attributeCount;
+                                return modified;
+                            });
+                            if (localRenames > 0) {
+                                const quote = templateContent[0];
+                                replacements.push({
+                                    start: node.initializer.getStart(sourceFile),
+                                    end: node.initializer.getEnd(),
+                                    replacement: `${quote}${newTemplate}${quote}`,
+                                });
+                                filePropertiesRenamed += localRenames;
+                            }
+                        }
+                    }
+                }
+                ts.forEachChild(node, visit);
+            }
+            visit(sourceFile);
+            // Apply replacements in reverse order
+            if (replacements.length > 0) {
+                replacements.sort((a, b) => b.start - a.start);
+                for (const { start, end, replacement } of replacements) {
+                    result = result.slice(0, start) + replacement + result.slice(end);
+                }
+            }
+        }
+        if (filePropertiesRenamed > 0) {
+            console.log(`   ✓ ${filePath}: renamed ${filePropertiesRenamed} property(ies)`);
+            propertiesRenamed += filePropertiesRenamed;
+        }
+        return result;
+    }
+    if (filesModified > 0) {
+        console.log(`\n✅ Migrated ${filesModified} file(s), renamed ${propertiesRenamed} emptyText property(ies) to bodyEmptyText`);
+    }
+    else {
+        console.log('\n✅ No <et-combobox> components found that need migration');
+    }
+}
+function migrateProvideComboboxConfig(tree) {
+    let filesModified = 0;
+    let configCallsUpdated = 0;
+    visitNotIgnoredFiles(tree, '', (filePath) => {
+        if (!filePath.endsWith('.ts')) {
+            return;
+        }
+        const content = tree.read(filePath, 'utf-8');
+        if (!content)
+            return;
+        const result = migrateConfigCalls(content, filePath);
+        if (result.content !== content) {
+            tree.write(filePath, result.content);
+            filesModified++;
+            configCallsUpdated += result.updatedCount;
+        }
+    });
+    function migrateConfigCalls(content, filePath) {
+        const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
+        const replacements = [];
+        let configsUpdated = 0;
+        function visit(node) {
+            // Find provideComboboxConfig() calls
+            if (ts.isCallExpression(node)) {
+                if (ts.isIdentifier(node.expression) &&
+                    node.expression.text === 'provideComboboxConfig' &&
+                    node.arguments.length > 0) {
+                    const configArg = node.arguments[0];
+                    // Check if the argument is an object literal
+                    if (ts.isObjectLiteralExpression(configArg)) {
+                        const emptyTextProp = configArg.properties.find((p) => ts.isPropertyAssignment(p) && ts.isIdentifier(p.name) && p.name.text === 'emptyText');
+                        if (emptyTextProp) {
+                            // Check if bodyEmptyText already exists
+                            const bodyEmptyTextProp = configArg.properties.find((p) => ts.isPropertyAssignment(p) && ts.isIdentifier(p.name) && p.name.text === 'bodyEmptyText');
+                            if (!bodyEmptyTextProp) {
+                                // Rename emptyText to bodyEmptyText
+                                const propStart = emptyTextProp.name.getStart(sourceFile);
+                                const propEnd = emptyTextProp.name.getEnd();
+                                replacements.push({
+                                    start: propStart,
+                                    end: propEnd,
+                                    replacement: 'bodyEmptyText',
+                                });
+                                configsUpdated++;
+                            }
+                        }
+                    }
+                }
+            }
+            ts.forEachChild(node, visit);
+        }
+        visit(sourceFile);
+        let result = content;
+        // Apply replacements in reverse order
+        if (replacements.length > 0) {
+            replacements.sort((a, b) => b.start - a.start);
+            for (const { start, end, replacement } of replacements) {
+                result = result.slice(0, start) + replacement + result.slice(end);
+            }
+        }
+        if (configsUpdated > 0) {
+            console.log(`   ✓ ${filePath}: updated ${configsUpdated} provideComboboxConfig call(s)`);
+        }
+        return { content: result, updatedCount: configsUpdated };
+    }
+    if (filesModified > 0) {
+        console.log(`\n✅ Migrated ${filesModified} file(s), updated ${configCallsUpdated} config call(s)`);
+    }
+    else {
+        console.log('\n✅ No provideComboboxConfig calls found that need migration');
+    }
+}
+//# sourceMappingURL=combobox.js.map