@ethlete/core 5.0.0-next.4 → 5.0.0-next.40

package/generators/generators.json

@@ -5,10 +5,20 @@
       "schema": "./migrate-to-v5/schema.json",
       "description": "Migrate to v5"
     },
-    "tailwind-4-theme": {
-      "factory": "./tailwind-4-theme/generator",
-      "schema": "./tailwind-4-theme/schema.json",
-      "description": "Generate theming for Tailwind CSS v4"
+    "migrate-provider-shape": {
+      "factory": "./migrate-provider-shape/migration",
+      "schema": "./migrate-provider-shape/schema.json",
+      "description": "Rewrite destructured provider tuples into the tree-shakeable definition shape"
+    },
+    "tailwind-4-color-theme": {
+      "factory": "./tailwind-4-color-theme/generator",
+      "schema": "./tailwind-4-color-theme/schema.json",
+      "description": "Generate color theming for Tailwind CSS v4"
+    },
+    "tailwind-4-surface-theme": {
+      "factory": "./tailwind-4-surface-theme/generator",
+      "schema": "./tailwind-4-surface-theme/schema.json",
+      "description": "Generate surface theming for Tailwind CSS v4"
     }
   }
 }

package/generators/migrate-provider-shape/migration-scope.js

@@ -0,0 +1,35 @@
+import { getProjects, visitNotIgnoredFiles } from '@nx/devkit';
+const stripTrailingSlash = (value) => (value.endsWith('/') ? value.slice(0, -1) : value);
+/**
+ * Limits the migration to a set of projects or paths. Unlike the query v3 migration there is no
+ * cross-file coupling here - every provider declaration is rewritten on its own - so any scope is safe;
+ * this exists to keep the diff reviewable.
+ */
+export const createMigrationScope = (tree, options) => {
+    const roots = [];
+    for (const projectName of options.projects ?? []) {
+        const project = getProjects(tree).get(projectName);
+        if (!project) {
+            throw new Error(`Unknown project "${projectName}". Pass names as they appear in \`nx show projects\`, or use --include with a path prefix.`);
+        }
+        roots.push(stripTrailingSlash(project.root));
+    }
+    for (const includePath of options.include ?? []) {
+        roots.push(stripTrailingSlash(includePath));
+    }
+    if (roots.length === 0) {
+        return {
+            visit: (targetTree, callback) => visitNotIgnoredFiles(targetTree, '', callback),
+            describe: () => 'the whole workspace',
+        };
+    }
+    return {
+        visit: (targetTree, callback) => {
+            for (const root of roots) {
+                visitNotIgnoredFiles(targetTree, root, callback);
+            }
+        },
+        describe: () => roots.join(', '),
+    };
+};
+//# sourceMappingURL=migration-scope.js.map

package/generators/migrate-provider-shape/migration.js

@@ -0,0 +1,51 @@
+import { formatFiles } from '@nx/devkit';
+import { createMigrationScope } from './migration-scope.js';
+import { migrateProviderShapeInFile } from './provider-shape.js';
+export const PROVIDER_SHAPE_REPORT_PATH = 'provider-shape-migration-tasks.md';
+const renderReport = (tasks) => [
+    '# Provider-shape migration tasks',
+    '',
+    'The codemod rewrote every destructured provider declaration into a definition plus one extractor per',
+    'binding. The sites below are **not** plain module-scope declarations, so they were left alone - each',
+    'needs a decision a codemod cannot make.',
+    '',
+    'Recipes:',
+    '',
+    '- A factory of your own that returned a `[provide, inject, token]` tuple: return the definition from',
+    '  `define*Provider(…)` directly, and let its callers use the extractors.',
+    '- A call inside a function: read `.provide` / `.inject` / `.token` off the definition.',
+    '',
+    ...tasks.map((task) => [`## \`${task.id}\``, '', `- ${task.file}:${task.line}`, `- ${task.message}`, ''].join('\n')),
+].join('\n');
+export default async function migrateProviderShape(tree, schema) {
+    console.log('\n🔄 Migrating provider tuples to the definition shape...');
+    const scope = createMigrationScope(tree, schema);
+    console.log(`   Scope: ${scope.describe()}`);
+    const tasks = [];
+    let filesChanged = 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 = migrateProviderShapeInFile(filePath, before);
+        tasks.push(...result.tasks);
+        if (result.changed) {
+            tree.write(filePath, result.content);
+            filesChanged++;
+            console.log(`   ✓ ${filePath}`);
+        }
+    });
+    if (tasks.length > 0) {
+        tree.write(PROVIDER_SHAPE_REPORT_PATH, renderReport(tasks));
+    }
+    if (!schema.skipFormat) {
+        await formatFiles(tree);
+    }
+    console.log(`\n✅ Rewrote ${filesChanged} file(s).`);
+    if (tasks.length > 0) {
+        console.log(`⚠️  ${tasks.length} site(s) need a manual decision - see ${PROVIDER_SHAPE_REPORT_PATH}.`);
+    }
+}
+//# sourceMappingURL=migration.js.map

package/generators/migrate-provider-shape/provider-shape.js

@@ -0,0 +1,217 @@
+import * as ts from 'typescript';
+/**
+ * `export const [provideX, injectX] = createRootProvider(…)` is undroppable by construction: array
+ * destructuring invokes the iterator protocol, so no bundler will remove the statement, and everything
+ * the factory's closure names is retained with it. The definition shape is droppable per binding.
+ *
+ * Two families need rewriting. The `create*Provider` / `createLabels` helpers were replaced by
+ * `define*`, and their declarations take a pure annotation because they sit in library source. The
+ * runtime factories below kept their names - only their return shape changed from tuple to definition -
+ * and their call sites are application code, where an annotation would be noise.
+ */
+const FACTORY_TO_DEFINE = {
+    createProvider: 'defineProvider',
+    createRootProvider: 'defineRootProvider',
+    createStaticProvider: 'defineStaticProvider',
+    createStaticRootProvider: 'defineStaticRootProvider',
+    createLabels: 'defineLabels',
+};
+const REF_FACTORIES = new Set([
+    'createQueryClient',
+    'createBearerAuthProvider',
+    'createWebSocketClient',
+    'createQueryContext',
+]);
+const isKnownFactory = (name) => FACTORY_TO_DEFINE[name] !== undefined || REF_FACTORIES.has(name);
+/** Which extractor names the three tuple positions become. */
+const POSITION_TO_EXTRACTOR = ['toProvideFn', 'toInjectFn', 'toToken'];
+const PURE = '/* @__PURE__ */';
+/** `injectFooBar` / `provideFooBar` / `FOO_BAR_TOKEN` → `FOO_BAR`. */
+const toDefinitionBaseName = (bindingName) => {
+    const withoutPrefix = bindingName
+        .replace(/^ɵ/, '')
+        .replace(/^(provide|inject)/i, '')
+        .replace(/_TOKEN$/, '');
+    const screaming = withoutPrefix
+        .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2')
+        .toUpperCase();
+    return screaming.replace(/^_+|_+$/g, '') || 'PROVIDER';
+};
+const uniqueDefinitionName = (bindingNames, taken) => {
+    const base = `${toDefinitionBaseName(bindingNames[1] ?? bindingNames[0] ?? bindingNames[2] ?? 'provider')}_DEF`;
+    let candidate = base;
+    let suffix = 2;
+    while (taken.has(candidate)) {
+        candidate = `${base}_${suffix++}`;
+    }
+    taken.add(candidate);
+    return candidate;
+};
+const findTupleSites = (sourceFile) => {
+    const sites = [];
+    for (const statement of sourceFile.statements) {
+        if (!ts.isVariableStatement(statement) || statement.declarationList.declarations.length !== 1)
+            continue;
+        const declaration = statement.declarationList.declarations[0];
+        if (!declaration || !ts.isArrayBindingPattern(declaration.name))
+            continue;
+        const call = declaration.initializer;
+        if (!call || !ts.isCallExpression(call) || !ts.isIdentifier(call.expression))
+            continue;
+        const factory = call.expression.text;
+        if (!isKnownFactory(factory))
+            continue;
+        const bindings = declaration.name.elements.map((element) => {
+            if (ts.isOmittedExpression(element) || !ts.isIdentifier(element.name))
+                return null;
+            return element.name.text;
+        });
+        sites.push({
+            statement,
+            call,
+            factory,
+            bindings,
+            isExported: !!statement.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword),
+        });
+    }
+    return sites;
+};
+/** The offset the replacement starts at: before the declaration's own JSDoc, if it has one. */
+const declarationStart = (content, statement, sourceFile) => {
+    const start = statement.getStart(sourceFile);
+    const comments = ts.getLeadingCommentRanges(content, statement.getFullStart());
+    const first = comments?.[0];
+    // Only treat comments as the declaration's own when nothing but whitespace separates them from it.
+    if (!first || /\S/.test(content.slice(comments[comments.length - 1].end, start)))
+        return start;
+    return first.pos;
+};
+const rewriteSite = (content, sourceFile, site, definitionName) => {
+    const start = declarationStart(content, site.statement, sourceFile);
+    const statementStart = site.statement.getStart(sourceFile);
+    const doc = content.slice(start, statementStart);
+    const replacement = FACTORY_TO_DEFINE[site.factory];
+    const annotation = replacement ? `${PURE} ` : '';
+    const callTail = content.slice(site.call.expression.getEnd(), site.call.getEnd());
+    const definition = `const ${definitionName} = ${annotation}${replacement ?? site.factory}${callTail};`;
+    const exportKeyword = site.isExported ? 'export ' : '';
+    const extractions = site.bindings
+        .map((binding, index) => binding === null
+        ? null
+        : `${exportKeyword}const ${binding} = ${annotation}${POSITION_TO_EXTRACTOR[index]}(${definitionName});`)
+        .filter((line) => line !== null);
+    // The JSDoc documented the pair, so it belongs on the first binding a consumer can reach.
+    const documented = extractions.length > 0 ? [definition, '', doc + extractions[0], ...extractions.slice(1)] : [doc + definition];
+    return { start, end: site.statement.getEnd(), text: documented.join('\n') };
+};
+const rewriteImports = (sourceFile, factoriesUsed, extractorsUsed) => {
+    const rewrites = [];
+    const imports = sourceFile.statements.filter(ts.isImportDeclaration);
+    /** The declaration the extractors join: the one that already provides them, else any core import. */
+    const extractorHost = imports.find((statement) => namedImportsOf(statement, sourceFile)?.some((name) => extractorsUsed.has(name))) ??
+        imports.find((statement) => {
+            const names = namedImportsOf(statement, sourceFile);
+            return names?.some((name) => FACTORY_TO_DEFINE[name] !== undefined) || isCoreImport(statement);
+        });
+    for (const statement of imports) {
+        const bindings = statement.importClause?.namedBindings;
+        if (!bindings || !ts.isNamedImports(bindings))
+            continue;
+        const names = bindings.elements.map((element) => element.getText(sourceFile));
+        // A ref factory keeps its name and its import; only a replaced factory is swapped out.
+        const replaced = names.filter((name) => factoriesUsed.has(name) && FACTORY_TO_DEFINE[name] !== undefined);
+        const extractors = statement === extractorHost ? [...extractorsUsed] : [];
+        if (replaced.length === 0 && extractors.length === 0)
+            continue;
+        const kept = names.filter((name) => !replaced.includes(name));
+        const merged = [
+            ...new Set([...kept, ...replaced.map((factory) => FACTORY_TO_DEFINE[factory]), ...extractors]),
+        ].sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
+        rewrites.push({
+            start: bindings.getStart(sourceFile),
+            end: bindings.getEnd(),
+            text: `{ ${merged.join(', ')} }`,
+        });
+    }
+    if (extractorHost)
+        return rewrites;
+    // Nothing to join - the file only imported a ref factory from another package, so add a core import.
+    const anchor = imports[imports.length - 1];
+    const position = anchor ? anchor.getEnd() : 0;
+    const statement = `import { ${[...extractorsUsed].sort().join(', ')} } from '@ethlete/core';`;
+    rewrites.push({ start: position, end: position, text: anchor ? `\n${statement}` : `${statement}\n` });
+    return rewrites;
+};
+const namedImportsOf = (statement, sourceFile) => {
+    const bindings = statement.importClause?.namedBindings;
+    if (!bindings || !ts.isNamedImports(bindings))
+        return undefined;
+    return bindings.elements.map((element) => element.getText(sourceFile));
+};
+const isCoreImport = (statement) => ts.isStringLiteral(statement.moduleSpecifier) && statement.moduleSpecifier.text === '@ethlete/core';
+/**
+ * Rewrites every top-level destructured provider tuple in one file into a descriptor plus one pure
+ * extractor per exported binding. Returns the file unchanged when there is nothing to do.
+ */
+export const migrateProviderShapeInFile = (filePath, content) => {
+    if (![...Object.keys(FACTORY_TO_DEFINE), ...REF_FACTORIES].some((factory) => content.includes(factory))) {
+        return { content, changed: false, tasks: [] };
+    }
+    const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
+    const sites = findTupleSites(sourceFile);
+    const tasks = collectTasks(filePath, sourceFile, sites);
+    if (sites.length === 0)
+        return { content, changed: false, tasks };
+    const taken = new Set(sourceFile.statements
+        .filter(ts.isVariableStatement)
+        .flatMap((statement) => statement.declarationList.declarations)
+        .flatMap((declaration) => (ts.isIdentifier(declaration.name) ? [declaration.name.text] : [])));
+    const factoriesUsed = new Set(sites.map((site) => site.factory));
+    const extractorsUsed = new Set(sites.flatMap((site) => site.bindings.flatMap((binding, index) => (binding === null ? [] : [POSITION_TO_EXTRACTOR[index]]))));
+    const edits = [
+        ...sites.map((site) => rewriteSite(content, sourceFile, site, uniqueDefinitionName(site.bindings.filter((b) => b !== null), taken))),
+        ...rewriteImports(sourceFile, factoriesUsed, extractorsUsed),
+    ].sort((a, b) => b.start - a.start);
+    let updated = content;
+    for (const edit of edits) {
+        updated = updated.slice(0, edit.start) + edit.text + updated.slice(edit.end);
+    }
+    return { content: updated, changed: updated !== content, tasks };
+};
+/** Call sites the codemod cannot safely rewrite - a factory result that is not a plain tuple binding. */
+const collectTasks = (filePath, sourceFile, sites) => {
+    const rewritten = new Set(sites.map((site) => site.statement));
+    const tasks = [];
+    const visit = (node) => {
+        if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && isKnownFactory(node.expression.text)) {
+            const statement = enclosingStatement(node);
+            if (!statement || !rewritten.has(statement)) {
+                const { line } = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+                const factory = node.expression.text;
+                const replacement = FACTORY_TO_DEFINE[factory];
+                tasks.push({
+                    id: `provider-shape:${filePath}:${line + 1}`,
+                    file: filePath,
+                    line: line + 1,
+                    message: replacement
+                        ? `\`${factory}\` is gone. Replace it with \`${replacement}\` and read the halves with \`toProvideFn\` / \`toInjectFn\` / \`toToken\`.`
+                        : `\`${factory}\` returns a provider definition now, not a \`[provide, inject, token]\` tuple. Read the halves with \`toProvideFn\` / \`toInjectFn\` / \`toToken\`, or \`.provide\` / \`.inject\` / \`.token\` inside a function.`,
+                });
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return tasks;
+};
+const enclosingStatement = (node) => {
+    let current = node;
+    while (current && !ts.isSourceFile(current)) {
+        if (ts.isVariableStatement(current))
+            return current;
+        current = current.parent;
+    }
+    return undefined;
+};
+//# sourceMappingURL=provider-shape.js.map

package/generators/migrate-provider-shape/schema.json

@@ -0,0 +1,26 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "$id": "migrate-provider-shape",
+  "title": "Migrate provider tuples to the definition shape",
+  "type": "object",
+  "properties": {
+    "projects": {
+      "type": "array",
+      "items": { "type": "string" },
+      "description": "Nx projects to migrate. Defaults to every project in the workspace. Every declaration is rewritten independently, so any scope is safe - use this to keep the diff reviewable.",
+      "alias": "project"
+    },
+    "include": {
+      "type": "array",
+      "items": { "type": "string" },
+      "description": "Path prefixes to migrate, relative to the workspace root (e.g. 'libs/ui'). 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/color-naming.js

@@ -0,0 +1,175 @@
+import { logger } from '@nx/devkit';
+/**
+ * Symbol renames in TypeScript files (imports + usage).
+ */
+const TS_SYMBOL_RENAMES = {
+    ProvideThemeDirective: 'ProvideColorDirective',
+    THEME_PROVIDER: 'COLOR_PROVIDER',
+    ColorThemedDirective: 'ColoredDirective',
+    ColorThemedStylesComponent: 'ColoredStylesComponent',
+    SurfaceThemedDirective: 'SurfacedDirective',
+    SurfaceThemedStylesComponent: 'SurfacedStylesComponent',
+    injectThemesPrefix: 'injectColorThemesPrefix',
+    createCssThemeName: 'createCssColorThemeName',
+};
+/**
+ * String replacements applied to HTML templates and inline templates.
+ */
+const TEMPLATE_REPLACEMENTS = [
+    ['[etProvideTheme]', '[etProvideColor]'],
+    ['etProvideTheme', 'etProvideColor'],
+    ['[etProvideAltTheme]', '[etProvideAltColor]'],
+    ['etProvideAltTheme', 'etProvideAltColor'],
+    ['[etColorThemed]', '[etColored]'],
+    ['etColorThemed', 'etColored'],
+    ['[etSurfaceThemed]', '[etSurfaced]'],
+    ['etSurfaceThemed', 'etSurfaced'],
+    ['[theme]=', '[color]='],
+    ['[altTheme]=', '[altColor]='],
+    ['et-theme-alt--', 'et-color-alt--'],
+    ['et-theme--', 'et-color--'],
+];
+/**
+ * CSS class name replacements.
+ */
+const CSS_REPLACEMENTS = [
+    ['.et-color-themed', '.et-colored'],
+    ['.et-surface-themed', '.et-surfaced'],
+    ['.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'"],
+    ["'etProvideAltTheme:altTheme'", "'etProvideAltColor:altColor'"],
+    ["'etProvideTheme:color'", "'etProvideColor:color'"],
+    ["'etProvideAltTheme:altColor'", "'etProvideAltColor:altColor'"],
+    ['"etProvideTheme:theme"', '"etProvideColor:color"'],
+    ['"etProvideAltTheme:altTheme"', '"etProvideAltColor:altColor"'],
+    ['"etProvideTheme"', '"etProvideColor"'],
+    ['"etProvideAltTheme"', '"etProvideAltColor"'],
+];
+export default async function migrateColorNaming(tree) {
+    logger.log('\n🔄 Migrating theme → color naming...\n');
+    const tsFiles = [];
+    const htmlFiles = [];
+    const cssFiles = [];
+    findFiles('.', tree, tsFiles, htmlFiles, cssFiles);
+    let filesModified = 0;
+    for (const filePath of tsFiles) {
+        const wasModified = migrateTypeScriptFile(tree, filePath);
+        if (wasModified) {
+            filesModified++;
+            logger.log(`  ✓ ${filePath}`);
+        }
+    }
+    for (const filePath of htmlFiles) {
+        const wasModified = migrateTemplateFile(tree, filePath);
+        if (wasModified) {
+            filesModified++;
+            logger.log(`  ✓ ${filePath}`);
+        }
+    }
+    for (const filePath of cssFiles) {
+        const wasModified = migrateCssFile(tree, filePath);
+        if (wasModified) {
+            filesModified++;
+            logger.log(`  ✓ ${filePath}`);
+        }
+    }
+    if (filesModified > 0) {
+        logger.log(`\n✅ Successfully migrated color naming in ${filesModified} file(s)\n`);
+    }
+    else {
+        logger.log('\nℹ️  No files needed migration\n');
+    }
+}
+function findFiles(dir, tree, tsFiles, htmlFiles, cssFiles) {
+    const children = tree.children(dir);
+    for (const child of children) {
+        const path = dir === '.' ? child : `${dir}/${child}`;
+        if (tree.isFile(path)) {
+            if (path.includes('node_modules'))
+                continue;
+            if (path.endsWith('.ts') && !path.endsWith('.spec.ts')) {
+                tsFiles.push(path);
+            }
+            else if (path.endsWith('.html')) {
+                htmlFiles.push(path);
+            }
+            else if (path.endsWith('.css') || path.endsWith('.scss')) {
+                cssFiles.push(path);
+            }
+        }
+        else {
+            if (child === 'node_modules')
+                continue;
+            findFiles(path, tree, tsFiles, htmlFiles, cssFiles);
+        }
+    }
+}
+function migrateTypeScriptFile(tree, filePath) {
+    let content = tree.read(filePath, 'utf-8');
+    if (!content)
+        return false;
+    const original = content;
+    // 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, '\\$&');
+}
+//# sourceMappingURL=color-naming.js.map

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

@@ -40,7 +40,6 @@ 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
     for (const statement of sourceFile.statements) {
@@ -52,9 +51,6 @@ function migrateCreateProviderInFile(tree, filePath) {
                     hasCreateProviderInCdk = statement.importClause.namedBindings.elements.some((element) => element.name.text === 'createProvider');
                 }
             }
-            else if (modulePath === '@ethlete/core') {
-                coreImport = statement;
-            }
         }
     }
     // If createProvider is not imported from @ethlete/cdk, nothing to do

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

@@ -1,4 +1,5 @@
 import { formatFiles } from '@nx/devkit';
+import migrateColorNaming from './color-naming.js';
 import migrateCreateProvider from './create-provider.js';
 import migrateRouterStateService from './router-state-service.js';
 import migrateViewportService from './viewport-service.js';
@@ -18,6 +19,11 @@ export default async function migrate(tree, schema) {
     if (shouldMigrateRouterStateService) {
         await migrateRouterStateService(tree);
     }
+    const shouldMigrateColorNaming = schema.migrateColorNaming !== false;
+    if (shouldMigrateColorNaming) {
+        console.log('  • Migrating theme → color naming...');
+        await migrateColorNaming(tree);
+    }
     if (!schema.skipFormat) {
         console.log('  • Formatting files...');
         await formatFiles(tree);

package/generators/migrate-to-v5/schema.json

@@ -23,6 +23,11 @@
       "type": "boolean",
       "description": "Migrate router state service to v5",
       "default": true
+    },
+    "migrateColorNaming": {
+      "type": "boolean",
+      "description": "Migrate theme naming to color naming (ProvideThemeDirective -> ProvideColorDirective, etc.)",
+      "default": true
     }
   },
   "required": []

package/generators/migrate-to-v5/viewport-service.js

@@ -1,5 +1,4 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
 import { logger } from '@nx/devkit';
 import * as ts from 'typescript';
 export default async function migrateViewportService(tree) {