@ethlete/core 5.0.0-next.6 → 5.0.0-next.61

package/generators/migrate-surface-interaction-swatch/migration.js

@@ -0,0 +1,36 @@
+import { formatFiles } from '@nx/devkit';
+import { createMigrationScope } from '../migrate-provider-shape/migration-scope.js';
+import { migrateInteractionSwatchInFile } from './interaction-swatch.js';
+export default async function migrateSurfaceInteractionSwatch(tree, schema) {
+    console.log('\n🔄 Migrating surface interactionColor to the swatch shape...');
+    const scope = createMigrationScope(tree, schema);
+    console.log(`   Scope: ${scope.describe()}`);
+    let filesChanged = 0;
+    let unresolvedCount = 0;
+    scope.visit(tree, (filePath) => {
+        if (!filePath.endsWith('.ts') || filePath.endsWith('.d.ts'))
+            return;
+        const before = tree.read(filePath, 'utf-8');
+        if (!before)
+            return;
+        const result = migrateInteractionSwatchInFile(filePath, before);
+        for (const expression of result.unresolved ?? []) {
+            unresolvedCount++;
+            console.warn(`   ⚠ ${filePath}: could not resolve interactionColor value ${expression}`);
+        }
+        if (!result.changed)
+            return;
+        tree.write(filePath, result.content);
+        filesChanged++;
+        console.log(`   ✓ ${filePath}`);
+    });
+    console.log(filesChanged === 0
+        ? '   Nothing to migrate.\n'
+        : `\n✅ Migrated ${filesChanged} file(s). Regenerate your surface CSS with \`nx g @ethlete/core:tailwind-4-surface-theme\`.\n`);
+    if (unresolvedCount > 0) {
+        console.warn(`   Review ${unresolvedCount} unresolved interactionColor value(s) manually.\n`);
+    }
+    if (!schema.skipFormat) {
+        await formatFiles(tree);
+    }
+}

package/generators/migrate-surface-interaction-swatch/schema.json

@@ -0,0 +1,26 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "$id": "migrate-surface-interaction-swatch",
+  "title": "Migrate surface interactionColor to the swatch shape",
+  "type": "object",
+  "properties": {
+    "projects": {
+      "type": "array",
+      "items": { "type": "string" },
+      "description": "Nx projects to migrate. Defaults to every project in the workspace.",
+      "alias": "project"
+    },
+    "include": {
+      "type": "array",
+      "items": { "type": "string" },
+      "description": "Path prefixes to migrate, relative to the workspace root (e.g. 'apps/web'). Unioned with `projects`. Defaults to the whole workspace.",
+      "alias": "includePath"
+    },
+    "skipFormat": {
+      "type": "boolean",
+      "description": "Skip formatting files after migration",
+      "default": false
+    }
+  },
+  "required": []
+}

package/generators/migrate-to-v5/apply-replacements.js

@@ -0,0 +1,14 @@
+const IDENTIFIER_CHAR = /[\w$]/;
+export function applyReplacements(content, replacements) {
+    return [...replacements]
+        .sort(([a], [b]) => b.length - a.length)
+        .reduce((result, [original, replacement]) => result.replace(snippetPattern(original), () => replacement), content);
+}
+function snippetPattern(snippet) {
+    const start = IDENTIFIER_CHAR.test(snippet.charAt(0)) ? '(?<![\\w$])' : '';
+    const end = IDENTIFIER_CHAR.test(snippet.charAt(snippet.length - 1)) ? '(?![\\w$])' : '';
+    return new RegExp(`${start}${escapeRegExp(snippet)}${end}`, 'g');
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

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

@@ -0,0 +1,124 @@
+import { collectFiles } from './migration-files.js';
+/**
+ * Symbol renames in TypeScript files (imports + usage).
+ */
+const TS_SYMBOL_RENAMES = {
+    ProvideThemeDirective: 'ProvideColorDirective',
+    THEME_PROVIDER: 'COLOR_PROVIDER',
+    ColorThemedDirective: 'ColorInteractiveDirective',
+    ColorThemedStylesComponent: 'ColorInteractiveStylesComponent',
+    SurfaceThemedDirective: 'SurfaceInteractiveDirective',
+    SurfaceThemedStylesComponent: 'SurfaceInteractiveStylesComponent',
+    injectThemesPrefix: 'injectColorThemesPrefix',
+    createCssThemeName: 'createCssColorThemeName',
+};
+/**
+ * String replacements applied to HTML templates and inline templates.
+ */
+const TEMPLATE_REPLACEMENTS = [
+    ['[etProvideTheme]', '[etProvideColor]'],
+    ['etProvideTheme', 'etProvideColor'],
+    ['[etColorThemed]', '[etColorInteractive]'],
+    ['etColorThemed', 'etColorInteractive'],
+    ['[etSurfaceThemed]', '[etSurfaceInteractive]'],
+    ['etSurfaceThemed', 'etSurfaceInteractive'],
+    ['et-theme-alt--', 'et-color-alt--'],
+    ['et-theme--', 'et-color--'],
+];
+/**
+ * CSS class name replacements.
+ */
+const CSS_REPLACEMENTS = [
+    ['.et-color-themed', '.et-color-interactive'],
+    ['.et-surface-themed', '.et-surface-interactive'],
+    ['.et-theme--', '.et-color--'],
+    ['.et-theme-alt--', '.et-color-alt--'],
+];
+/**
+ * Host directive input alias replacements in TypeScript files.
+ */
+const HOST_DIRECTIVE_REPLACEMENTS = [
+    ["'etProvideTheme:theme'", "'etProvideColor:color'"],
+    ["'etProvideTheme:color'", "'etProvideColor:color'"],
+    ['"etProvideTheme:theme"', '"etProvideColor:color"'],
+    ['"etProvideTheme"', '"etProvideColor"'],
+    ["'etProvideTheme: theme'", "'etProvideColor: color'"],
+    ['"etProvideTheme: theme"', '"etProvideColor: color"'],
+];
+export default async function migrateColorNaming(tree, scope) {
+    let filesModified = 0;
+    for (const filePath of collectFiles(tree, scope, ['.ts', '.html', '.css', '.scss'])) {
+        const wasModified = filePath.endsWith('.ts')
+            ? migrateTypeScriptFile(tree, filePath)
+            : filePath.endsWith('.html')
+                ? migrateTemplateFile(tree, filePath)
+                : migrateCssFile(tree, filePath);
+        if (wasModified)
+            filesModified++;
+    }
+    return { filesChanged: filesModified, review: [] };
+}
+function migrateTypeScriptFile(tree, filePath) {
+    let content = tree.read(filePath, 'utf-8');
+    if (!content)
+        return false;
+    const original = content;
+    if (!/from\s+['"]@ethlete\/(?:core|cdk|theming)['"]/.test(content))
+        return false;
+    // Rename symbols
+    for (const [oldName, newName] of Object.entries(TS_SYMBOL_RENAMES)) {
+        content = replaceWholeWord(content, oldName, newName);
+    }
+    // Rename host directive input aliases
+    for (const [oldStr, newStr] of HOST_DIRECTIVE_REPLACEMENTS) {
+        content = content.replaceAll(oldStr, newStr);
+    }
+    // Handle inline templates in TypeScript files
+    for (const [oldStr, newStr] of TEMPLATE_REPLACEMENTS) {
+        content = content.replaceAll(oldStr, newStr);
+    }
+    // Handle CSS in TypeScript files
+    for (const [oldStr, newStr] of CSS_REPLACEMENTS) {
+        content = content.replaceAll(oldStr, newStr);
+    }
+    if (content !== original) {
+        tree.write(filePath, content);
+        return true;
+    }
+    return false;
+}
+function migrateTemplateFile(tree, filePath) {
+    let content = tree.read(filePath, 'utf-8');
+    if (!content)
+        return false;
+    const original = content;
+    for (const [oldStr, newStr] of TEMPLATE_REPLACEMENTS) {
+        content = content.replaceAll(oldStr, newStr);
+    }
+    if (content !== original) {
+        tree.write(filePath, content);
+        return true;
+    }
+    return false;
+}
+function migrateCssFile(tree, filePath) {
+    let content = tree.read(filePath, 'utf-8');
+    if (!content)
+        return false;
+    const original = content;
+    for (const [oldStr, newStr] of CSS_REPLACEMENTS) {
+        content = content.replaceAll(oldStr, newStr);
+    }
+    if (content !== original) {
+        tree.write(filePath, content);
+        return true;
+    }
+    return false;
+}
+function replaceWholeWord(content, oldWord, newWord) {
+    const regex = new RegExp(`\\b${escapeRegex(oldWord)}\\b`, 'g');
+    return content.replace(regex, newWord);
+}
+function escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/generators/migrate-to-v5/create-provider.js

@@ -1,38 +1,65 @@
-import { logger } from '@nx/devkit';
 import * as ts from 'typescript';
-export default async function migrateCreateProvider(tree) {
-    logger.log('\n🔄 Migrating createProvider imports from @ethlete/cdk to @ethlete/core...\n');
-    const tsFiles = [];
-    // Recursively find all TypeScript files
-    function findTsFiles(dir) {
-        const children = tree.children(dir);
-        for (const child of children) {
-            const path = dir === '.' ? child : `${dir}/${child}`;
-            if (tree.isFile(path)) {
-                if (path.endsWith('.ts') && !path.includes('node_modules') && !path.endsWith('.spec.ts')) {
-                    tsFiles.push(path);
-                }
-            }
-            else {
-                findTsFiles(path);
-            }
-        }
-    }
-    findTsFiles('.');
+import { collectFiles } from './migration-files.js';
+export default async function migrateCreateProvider(tree, scope) {
+    const review = [];
     let filesModified = 0;
-    for (const filePath of tsFiles) {
-        const wasModified = migrateCreateProviderInFile(tree, filePath);
-        if (wasModified) {
+    for (const filePath of collectFiles(tree, scope, ['.ts'])) {
+        const reexportsModified = migrateCreateProviderReexports(tree, filePath, review);
+        const wasModified = migrateCreateProviderInFile(tree, filePath) || reexportsModified;
+        if (wasModified)
             filesModified++;
-            logger.log(`  ✓ ${filePath}`);
-        }
     }
-    if (filesModified > 0) {
-        logger.log(`\n✅ Successfully migrated createProvider in ${filesModified} file(s)\n`);
+    return { filesChanged: filesModified, review };
+}
+function migrateCreateProviderReexports(tree, filePath, review) {
+    const content = tree.read(filePath, 'utf-8');
+    if (!content || !content.includes('createProvider'))
+        return false;
+    const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
+    const edits = [];
+    for (const statement of sourceFile.statements) {
+        if (!ts.isImportDeclaration(statement) && !ts.isExportDeclaration(statement))
+            continue;
+        if (!statement.moduleSpecifier || !ts.isStringLiteral(statement.moduleSpecifier))
+            continue;
+        if (statement.moduleSpecifier.text !== '@ethlete/cdk')
+            continue;
+        if (ts.isImportDeclaration(statement)) {
+            const bindings = statement.importClause?.namedBindings;
+            if (bindings && ts.isNamespaceImport(bindings) && content.includes(`${bindings.name.text}.createProvider`)) {
+                review.push(`${filePath}: ${bindings.name.text}.createProvider is used through a namespace import of @ethlete/cdk. Switch it to createProvider from @ethlete/core manually.`);
+            }
+            continue;
+        }
+        const clause = statement.exportClause;
+        if (!clause) {
+            review.push(`${filePath}: "export * from '@ethlete/cdk'" may re-export createProvider. Re-export it from @ethlete/core manually.`);
+            continue;
+        }
+        if (ts.isNamespaceExport(clause))
+            continue;
+        const isCreateProvider = (element) => (element.propertyName?.text ?? element.name.text) === 'createProvider';
+        const moved = clause.elements.filter(isCreateProvider);
+        if (moved.length === 0)
+            continue;
+        const rest = clause.elements.filter((element) => !isCreateProvider(element));
+        const typeOnly = statement.isTypeOnly ? 'type ' : '';
+        const lines = [
+            ...(rest.length > 0
+                ? [`export ${typeOnly}{ ${rest.map((el) => el.getText(sourceFile)).join(', ')} } from '@ethlete/cdk';`]
+                : []),
+            `export ${typeOnly}{ ${moved.map((el) => el.getText(sourceFile)).join(', ')} } from '@ethlete/core';`,
+        ];
+        edits.push({ start: statement.getStart(sourceFile), end: statement.getEnd(), text: lines.join('\n') });
     }
-    else {
-        logger.log('\nℹ️  No files needed migration\n');
+    if (edits.length === 0)
+        return false;
+    let updatedContent = content;
+    for (const edit of edits.reverse()) {
+        updatedContent = updatedContent.slice(0, edit.start) + edit.text + updatedContent.slice(edit.end);
     }
+    tree.write(filePath, updatedContent);
+    return true;
 }
 function migrateCreateProviderInFile(tree, filePath) {
     const content = tree.read(filePath, 'utf-8');
@@ -40,35 +67,30 @@ function migrateCreateProviderInFile(tree, filePath) {
         return false;
     const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
     let cdkImport;
-    let coreImport;
     let hasCreateProviderInCdk = false;
-    // Find relevant imports
+    let createProviderImport = 'createProvider';
     for (const statement of sourceFile.statements) {
         if (ts.isImportDeclaration(statement) && ts.isStringLiteral(statement.moduleSpecifier)) {
             const modulePath = statement.moduleSpecifier.text;
             if (modulePath === '@ethlete/cdk') {
                 cdkImport = statement;
                 if (statement.importClause?.namedBindings && ts.isNamedImports(statement.importClause.namedBindings)) {
-                    hasCreateProviderInCdk = statement.importClause.namedBindings.elements.some((element) => element.name.text === 'createProvider');
+                    const specifier = statement.importClause.namedBindings.elements.find((element) => (element.propertyName?.text ?? element.name.text) === 'createProvider');
+                    hasCreateProviderInCdk = !!specifier;
+                    createProviderImport = specifier?.getText(sourceFile) ?? createProviderImport;
                 }
             }
-            else if (modulePath === '@ethlete/core') {
-                coreImport = statement;
-            }
         }
     }
-    // If createProvider is not imported from @ethlete/cdk, nothing to do
     if (!hasCreateProviderInCdk)
         return false;
     let updatedContent = content;
-    // Remove createProvider from @ethlete/cdk import
     if (cdkImport && cdkImport.importClause?.namedBindings && ts.isNamedImports(cdkImport.importClause.namedBindings)) {
         const namedBindings = cdkImport.importClause.namedBindings;
-        const otherImports = namedBindings.elements.filter((element) => element.name.text !== 'createProvider');
+        const otherImports = namedBindings.elements.filter((element) => (element.propertyName?.text ?? element.name.text) !== 'createProvider');
         const importStart = cdkImport.getStart(sourceFile);
         const importEnd = cdkImport.getEnd();
         if (otherImports.length === 0) {
-            // Remove entire import line including newline
             let lineStart = importStart;
             while (lineStart > 0 && content[lineStart - 1] !== '\n') {
                 lineStart--;
@@ -83,15 +105,12 @@ function migrateCreateProviderInFile(tree, filePath) {
             updatedContent = content.slice(0, lineStart) + content.slice(lineEnd);
         }
         else {
-            // Keep other imports
-            const newImports = otherImports.map((el) => el.name.text).join(', ');
+            const newImports = otherImports.map((el) => el.getText(sourceFile)).join(', ');
             const newImportText = `import { ${newImports} } from '@ethlete/cdk';`;
             updatedContent = content.slice(0, importStart) + newImportText + content.slice(importEnd);
         }
     }
-    // Re-parse after first modification
     const intermediateSourceFile = ts.createSourceFile(filePath, updatedContent, ts.ScriptTarget.Latest, true);
-    // Find @ethlete/core import in the updated content
     let updatedCoreImport;
     for (const statement of intermediateSourceFile.statements) {
         if (ts.isImportDeclaration(statement) && ts.isStringLiteral(statement.moduleSpecifier)) {
@@ -101,26 +120,22 @@ function migrateCreateProviderInFile(tree, filePath) {
             }
         }
     }
-    // Add createProvider to @ethlete/core import
     if (updatedCoreImport?.importClause?.namedBindings &&
         ts.isNamedImports(updatedCoreImport.importClause.namedBindings)) {
         const namedBindings = updatedCoreImport.importClause.namedBindings;
-        // Check if createProvider already exists
-        const hasCreateProvider = namedBindings.elements.some((element) => element.name.text === 'createProvider');
+        const hasCreateProvider = namedBindings.elements.some((element) => (element.propertyName?.text ?? element.name.text) === 'createProvider');
         if (!hasCreateProvider) {
             const importStart = updatedCoreImport.getStart(intermediateSourceFile);
             const importEnd = updatedCoreImport.getEnd();
-            const existingImports = namedBindings.elements.map((el) => el.name.text);
-            const allImports = [...existingImports, 'createProvider'].sort();
+            const existingImports = namedBindings.elements.map((el) => el.getText(intermediateSourceFile));
+            const allImports = [...existingImports, createProviderImport].sort();
             const newImportText = `import { ${allImports.join(', ')} } from '@ethlete/core';`;
             updatedContent = updatedContent.slice(0, importStart) + newImportText + updatedContent.slice(importEnd);
         }
     }
     else {
-        // Add new import from @ethlete/core at the top
         const firstImportIndex = updatedContent.indexOf('import');
         if (firstImportIndex !== -1) {
-            // Add after other imports
             let insertPosition;
             let lastImportEnd = firstImportIndex;
             for (const statement of intermediateSourceFile.statements) {
@@ -132,7 +147,6 @@ function migrateCreateProviderInFile(tree, filePath) {
                 }
             }
             insertPosition = lastImportEnd;
-            // Find end of line
             while (insertPosition < updatedContent.length && updatedContent[insertPosition] !== '\n') {
                 insertPosition++;
             }
@@ -141,12 +155,11 @@ function migrateCreateProviderInFile(tree, filePath) {
             }
             updatedContent =
                 updatedContent.slice(0, insertPosition) +
-                    "import { createProvider } from '@ethlete/core';\n" +
+                    `import { ${createProviderImport} } from '@ethlete/core';\n` +
                     updatedContent.slice(insertPosition);
         }
         else {
-            // No imports, add at the beginning
-            updatedContent = "import { createProvider } from '@ethlete/core';\n\n" + updatedContent;
+            updatedContent = `import { ${createProviderImport} } from '@ethlete/core';\n\n` + updatedContent;
         }
     }
     if (updatedContent !== content) {
@@ -155,4 +168,3 @@ function migrateCreateProviderInFile(tree, filePath) {
     }
     return false;
 }
-//# sourceMappingURL=create-provider.js.map

package/generators/migrate-to-v5/migration-files.js

@@ -0,0 +1,13 @@
+import { createMigrationScope } from '../migrate-provider-shape/migration-scope.js';
+const SKIPPED_DIRECTORIES = new Set(['node_modules', 'dist', '.git', '.angular', '.nx']);
+export const collectFiles = (tree, scope, extensions) => {
+    const files = [];
+    (scope ?? createMigrationScope(tree, {})).visit(tree, (filePath) => {
+        if (filePath.split('/').some((segment) => SKIPPED_DIRECTORIES.has(segment)))
+            return;
+        if (!extensions.some((extension) => filePath.endsWith(extension)))
+            return;
+        files.push(filePath);
+    });
+    return files;
+};

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

@@ -1,28 +1,42 @@
-import { formatFiles } from '@nx/devkit';
+import { formatFiles, logger } from '@nx/devkit';
+import { createMigrationScope, } from '../migrate-provider-shape/migration-scope.js';
+import migrateColorNaming from './color-naming.js';
 import migrateCreateProvider from './create-provider.js';
+import reportRemovedExports from './removed-exports.js';
 import migrateRouterStateService from './router-state-service.js';
 import migrateViewportService from './viewport-service.js';
 export default async function migrate(tree, schema) {
-    console.log('\n🔄 Starting core v5 migration...');
-    const shouldMigrateViewportService = schema.migrateViewportService !== false;
-    const shouldMigrateCreateProvider = schema.migrateCreateProvider !== false;
-    const shouldMigrateRouterStateService = schema.migrateRouterStateService !== false;
-    if (shouldMigrateViewportService) {
-        console.log('  • Migrating viewport service...');
-        await migrateViewportService(tree);
-    }
-    if (shouldMigrateCreateProvider) {
-        console.log('  • Migrating create provider...');
-        await migrateCreateProvider(tree);
-    }
-    if (shouldMigrateRouterStateService) {
-        await migrateRouterStateService(tree);
+    const scope = createMigrationScope(tree, schema);
+    logger.info('\n🔄 Starting core v5 migration...');
+    logger.info(`   Scope: ${scope.describe()}`);
+    const transforms = [
+        { label: 'ViewportService', enabled: schema.migrateViewportService !== false, run: migrateViewportService },
+        { label: 'createProvider', enabled: schema.migrateCreateProvider !== false, run: migrateCreateProvider },
+        {
+            label: 'RouterStateService',
+            enabled: schema.migrateRouterStateService !== false,
+            run: migrateRouterStateService,
+        },
+        { label: 'Theme → color naming', enabled: schema.migrateColorNaming !== false, run: migrateColorNaming },
+        { label: 'Removed exports', enabled: schema.reportRemovedExports !== false, run: reportRemovedExports },
+    ];
+    const reports = [];
+    for (const transform of transforms) {
+        if (!transform.enabled)
+            continue;
+        logger.info(`  • ${transform.label}...`);
+        reports.push([transform.label, await transform.run(tree, scope)]);
     }
     if (!schema.skipFormat) {
-        console.log('  • Formatting files...');
         await formatFiles(tree);
     }
-    console.log('\n✅ Migration completed successfully!');
+    logger.info('\nSummary:');
+    for (const [label, report] of reports) {
+        const review = report.review.length > 0 ? `, ${report.review.length} to review manually` : '';
+        logger.info(`  • ${label}: ${report.filesChanged} file(s) changed${review}`);
+        for (const message of report.review) {
+            logger.warn(`    ⚠ ${message}`);
+        }
+    }
+    logger.info('\n✅ Migration completed. Review the diff before committing.');
 }
-//#endregion
-//# sourceMappingURL=migration.js.map

package/generators/migrate-to-v5/removed-exports.js

@@ -0,0 +1,73 @@
+import * as ts from 'typescript';
+import { collectFiles } from './migration-files.js';
+const REMOVED_EXPORTS = new Map([
+    ...['Memo', 'MemoConfig', 'MemoResolver', 'MapLike'].map((name) => [name, 'the @Memo decorator']),
+    ...[
+        'createProps',
+        'createHostProps',
+        'createPropHandlers',
+        'createSetup',
+        'createDependencyStash',
+        'createElementDictionary',
+        'bindProps',
+        'unbindProps',
+        'PropsDirective',
+        'templateComputed',
+        'ComponentType',
+        'AnyTemplateType',
+        'TemplateRefWithContext',
+        'ComponentTypeWithInputs',
+        'StringTemplate',
+        'NgTemplateTemplate',
+        'ComponentTemplate',
+        'Props',
+        'PropsAttachedElements',
+        'PropsAttachedElementsInternal',
+        'PropsInternal',
+        'CreatePropsOptions',
+        'HostProps',
+        'PropHandlers',
+        'BindPropsOptions',
+        'UnbindPropsOptions',
+    ].map((name) => [name, 'the props module']),
+]);
+const ET_PROPS_ATTRIBUTE = /\betProps\b/;
+export default async function reportRemovedExports(tree, scope) {
+    const review = [];
+    for (const filePath of collectFiles(tree, scope, ['.ts', '.html'])) {
+        const messages = filePath.endsWith('.ts') ? findRemovedImports(tree, filePath) : findEtPropsUsage(tree, filePath);
+        review.push(...messages.map((message) => `${filePath}: ${message}`));
+    }
+    return { filesChanged: 0, review };
+}
+function findRemovedImports(tree, filePath) {
+    const content = tree.read(filePath, 'utf-8');
+    if (!content || !content.includes('@ethlete/core'))
+        return [];
+    const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
+    const messages = [];
+    for (const statement of sourceFile.statements) {
+        if (!ts.isImportDeclaration(statement) && !ts.isExportDeclaration(statement))
+            continue;
+        const specifier = statement.moduleSpecifier;
+        if (!specifier || !ts.isStringLiteral(specifier) || specifier.text !== '@ethlete/core')
+            continue;
+        const bindings = ts.isImportDeclaration(statement) ? statement.importClause?.namedBindings : statement.exportClause;
+        if (!bindings || ts.isNamespaceImport(bindings) || ts.isNamespaceExport(bindings))
+            continue;
+        for (const element of bindings.elements) {
+            const name = (element.propertyName ?? element.name).text;
+            const origin = REMOVED_EXPORTS.get(name);
+            if (origin) {
+                messages.push(`${name} was removed from @ethlete/core together with ${origin} and has no replacement.`);
+            }
+        }
+    }
+    return messages;
+}
+function findEtPropsUsage(tree, filePath) {
+    const content = tree.read(filePath, 'utf-8');
+    if (!content || !ET_PROPS_ATTRIBUTE.test(content))
+        return [];
+    return ['[etProps] (PropsDirective) was removed from @ethlete/core together with the props module.'];
+}