@ethlete/core 5.0.0-next.7 → 5.0.0-next.70

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,161 @@
+import * as ts from 'typescript';
+import { collectFiles } from './migration-files.js';
+export const REMOVED_EXPORTS = new Map([
+    ...['Memo', 'MemoConfig', 'MemoResolver', 'MapLike'].map((name) => [name, 'together with the @Memo decorator and has no replacement.']),
+    ...[
+        '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, 'together with the props module and has no replacement.']),
+    ...['LetDirective', 'LetContext'].map((name) => [
+        name,
+        "in v5. Use Angular's `@let`. `@ethlete/cdk:migrate-to-v5` rewrites `*etLet` templates; without the cdk, rewrite them by hand.",
+    ]),
+    ...['IsActiveElementDirective', 'IS_ACTIVE_ELEMENT', 'IsElementDirective', 'IS_ELEMENT'].map((name) => [
+        name,
+        'in v5. Inside a scrollable, use `ScrollableIsActiveChildDirective`; `@ethlete/cdk:migrate-to-v5` rewrites it.',
+    ]),
+    ...['ObserveResizeDirective', 'ResizeObserverService', 'ResizeObserverFactory', 'createResizeObservable'].map((name) => [name, 'in v5. Use `signalElementDimensions()`.']),
+    ...['ObserveContentDirective', 'ContentObserverService', 'MutationObserverFactory', 'createMutationObservable'].map((name) => [name, 'in v5. Use `signalElementMutations()`.']),
+    ...[
+        'ObserveVisibilityDirective',
+        'OBSERVE_VISIBILITY_TOKEN',
+        'ObserveVisibilityChange',
+        'IntersectionObserverService',
+        'IntersectionObserverFactory',
+        'getIntersectionInfo',
+        'signalVisibilityChangeClasses',
+    ].map((name) => [name, 'in v5. Use `signalElementIntersection()`.']),
+    ...[
+        'ObserveScrollStateDirective',
+        'OBSERVE_SCROLL_STATE',
+        'ScrollObserverFirstElementDirective',
+        'ScrollObserverLastElementDirective',
+        'ScrollObserverIgnoreTargetDirective',
+        'SCROLL_OBSERVER_FIRST_ELEMENT_CLASS',
+        'SCROLL_OBSERVER_IGNORE_TARGET_CLASS',
+        'SCROLL_OBSERVER_LAST_ELEMENT_CLASS',
+        'SCROLL_OBSERVER_OBSERVING_FIRST_ELEMENT_CLASS',
+        'SCROLL_OBSERVER_OBSERVING_LAST_ELEMENT_CLASS',
+        'ScrollObserverScrollState',
+        'ObservedScrollableChild',
+        'areScrollStatesEqual',
+    ].map((name) => [
+        name,
+        'in v5. Use `signalElementScrollState()`, or `ScrollableScrollState` of the `@ethlete/components` scrollable.',
+    ]),
+    ...['CursorDragScrollDirective', 'CURSOR_DRAG_SCROLLING_CLASS', 'CURSOR_DRAG_SCROLLING_PREPARED_CLASS'].map((name) => [name, 'in v5. Use `useCursorDragScroll()`.']),
+    ...['RootBoundaryDirective', 'ROOT_BOUNDARY_TOKEN'].map((name) => [name, 'in v5. Use `provideBoundaryElement()`.']),
+    ...['DelayableDirective', 'DELAYABLE_TOKEN'].map((name) => [name, 'in v5. Use `provideInfinityQueryResponseDelay()` from `@ethlete/query`.']),
+    ...[
+        'SeoDirective',
+        'SEO_DIRECTIVE_TOKEN',
+        'SeoConfig',
+        'mergeSeoConfig',
+        'OpenGraph',
+        'TwitterCard',
+        'FacebookCard',
+        'AlternateLink',
+    ].map((name) => [name, 'in v5. Use the `apply*Binding` functions; the SEO guide has a per-key migration table.']),
+    ...['AnimatedOverlayDirective', 'AnimatedOverlayComponentBase'].map((name) => [
+        name,
+        'in v5. It moved to `@ethlete/cdk`; `@ethlete/components` overlays use the overlay strategy controller.',
+    ]),
+    ...[
+        'SelectionModel',
+        'ActiveSelectionModel',
+        'SelectionModelBinding',
+        'SelectionModelOptionValueFn',
+        'SelectionModelPropertyPath',
+        'SelectionModelTypes',
+    ].map((name) => [name, 'in v5. It moved into the `@ethlete/cdk` select and has no public replacement.']),
+    ...['FocusVisibleService'].map((name) => [name, 'in v5. Use `injectFocusVisibleTracker()`.']),
+    ...['createMediaQueryObservable'].map((name) => [name, 'in v5. Use `injectBreakpointIsMatched()` or the other media query signals.']),
+    ...['createReactiveBindings', 'ReactiveAttributes', 'ReactiveBindingResult'].map((name) => [name, 'in v5. Use `signalHostClasses()` / `signalHostAttributes()`.']),
+    ...['debouncedControlValueSignal', 'DebouncedControlValueSignalOptions'].map((name) => [name, 'in v5. Debounce the `controlValueSignal()` value with `toObservable()` and `debounceTime()`.']),
+    ...['ProviderResult', 'RootProviderResult', 'StaticProviderResult', 'CreateProviderOptions'].map((name) => [
+        name,
+        'in v5. It belonged to the removed `create*Provider` factories, which `@ethlete/core:migrate-provider-shape` rewrites.',
+    ]),
+    ...['VIEWPORT_CONFIG'].map((name) => [name, 'in v5. Use `provideViewportConfig()`.']),
+    ...[
+        'ClickObserverService',
+        'ClickObserverFactory',
+        'DebugDirective',
+        'DEBUG_TOKEN',
+        'HostDirective',
+        'MaybeObservable',
+        'Primitive',
+        'Reference',
+        'Size',
+        'Validators',
+        'isEmptyArray',
+        'isObjectArray',
+        'isPrimitiveArray',
+        'ScrollEnhancementsConfig',
+        'SmartBlockScrollStrategy',
+    ].map((name) => [name, 'in v5. It has no replacement.']),
+]);
+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 successor = REMOVED_EXPORTS.get(name);
+            if (successor) {
+                messages.push(`${name} was removed from @ethlete/core ${successor}`);
+            }
+        }
+    }
+    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.'];
+}