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

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/color-naming.js

@@ -0,0 +1,170 @@
+import { logger } from '@nx/devkit';
+/**
+ * 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) {
+    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')) {
+                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;
+    if (!/from\s+['"]@ethlete\/(?:core|cdk)['"]/.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

@@ -9,11 +9,13 @@ export default async function migrateCreateProvider(tree) {
         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')) {
+                if (path.endsWith('.ts') && !path.includes('node_modules')) {
                     tsFiles.push(path);
                 }
             }
             else {
+                if (child === 'node_modules')
+                    continue;
                 findTsFiles(path);
             }
         }
@@ -40,8 +42,8 @@ function migrateCreateProviderInFile(tree, filePath) {
         return false;
     const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
     let cdkImport;
-    let coreImport;
     let hasCreateProviderInCdk = false;
+    let createProviderImport = 'createProvider';
     // Find relevant imports
     for (const statement of sourceFile.statements) {
         if (ts.isImportDeclaration(statement) && ts.isStringLiteral(statement.moduleSpecifier)) {
@@ -49,12 +51,11 @@ function migrateCreateProviderInFile(tree, filePath) {
             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
@@ -64,7 +65,7 @@ function migrateCreateProviderInFile(tree, filePath) {
     // 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) {
@@ -84,7 +85,7 @@ function migrateCreateProviderInFile(tree, filePath) {
         }
         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);
         }
@@ -106,12 +107,12 @@ function migrateCreateProviderInFile(tree, filePath) {
         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);
         }
@@ -141,12 +142,12 @@ 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 +156,3 @@ function migrateCreateProviderInFile(tree, filePath) {
     }
     return false;
 }
-//# sourceMappingURL=create-provider.js.map

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

@@ -1,5 +1,7 @@
 import { formatFiles } from '@nx/devkit';
+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) {
@@ -18,6 +20,15 @@ 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.reportRemovedExports !== false) {
+        console.log('  • Reporting removed exports...');
+        await reportRemovedExports(tree);
+    }
     if (!schema.skipFormat) {
         console.log('  • Formatting files...');
         await formatFiles(tree);
@@ -25,4 +36,3 @@ export default async function migrate(tree, schema) {
     console.log('\n✅ Migration completed successfully!');
 }
 //#endregion
-//# sourceMappingURL=migration.js.map

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

@@ -0,0 +1,93 @@
+import * as ts from 'typescript';
+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) {
+    const findings = new Map();
+    function walkFiles(dir) {
+        for (const child of tree.children(dir)) {
+            if (child === 'node_modules')
+                continue;
+            const path = dir === '.' ? child : `${dir}/${child}`;
+            if (!tree.isFile(path)) {
+                walkFiles(path);
+                continue;
+            }
+            const messages = path.endsWith('.ts')
+                ? findRemovedImports(tree, path)
+                : path.endsWith('.html')
+                    ? findEtPropsUsage(tree, path)
+                    : [];
+            if (messages.length > 0)
+                findings.set(path, messages);
+        }
+    }
+    walkFiles('.');
+    if (findings.size === 0)
+        return;
+    console.log('\n⚠️  Manual migration required for the following files:');
+    findings.forEach((messages, file) => {
+        console.log(`\n📄 ${file}:`);
+        messages.forEach((message) => console.log(`   - ${message}`));
+    });
+}
+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.'];
+}

package/generators/migrate-to-v5/router-state-service.js

@@ -67,6 +67,8 @@ function findRouterStateServiceVariables(sourceFile) {
 function findClassForRouterStateService(sourceFile, routerStateServiceVar) {
     let classNode = null;
     function visit(node) {
+        if (classNode)
+            return;
         if (ts.isClassDeclaration(node)) {
             const hasRouterStateService = node.members.some((member) => {
                 if (ts.isPropertyDeclaration(member) && ts.isIdentifier(member.name)) {
@@ -750,9 +752,10 @@ function addImportsToPackage(sourceFile, content, imports, packageName) {
         }
     });
     if (existingImport?.importClause?.namedBindings && ts.isNamedImports(existingImport.importClause.namedBindings)) {
-        // Add to existing import
-        const existingImports = existingImport.importClause.namedBindings.elements.map((el) => el.name.text);
-        const newImports = importsList.filter((imp) => !existingImports.includes(imp));
+        const existingElements = existingImport.importClause.namedBindings.elements;
+        const existingImportedNames = existingElements.map((el) => el.propertyName?.text ?? el.name.text);
+        const existingImports = existingElements.map((el) => el.getText(sourceFile));
+        const newImports = importsList.filter((imp) => !existingImportedNames.includes(imp));
         if (newImports.length === 0)
             return content;
         const allImports = [...existingImports, ...newImports].sort();
@@ -782,7 +785,16 @@ function removeRouterStateServiceInjection(sourceFile, content, routerStateServi
             node.members.forEach((member) => {
                 if (ts.isPropertyDeclaration(member) && ts.isIdentifier(member.name)) {
                     const memberName = member.name.text;
-                    if (routerStateServiceVars.includes(memberName)) {
+                    const injectsRouterState = member.initializer &&
+                        ts.isCallExpression(member.initializer) &&
+                        ts.isIdentifier(member.initializer.expression) &&
+                        member.initializer.expression.text === 'inject' &&
+                        member.initializer.arguments.some((argument) => ts.isIdentifier(argument) && argument.text === 'RouterStateService');
+                    const hasRouterStateType = member.type &&
+                        ts.isTypeReferenceNode(member.type) &&
+                        ts.isIdentifier(member.type.typeName) &&
+                        member.type.typeName.text === 'RouterStateService';
+                    if (routerStateServiceVars.includes(memberName) && (injectsRouterState || hasRouterStateType)) {
                         const memberStart = member.getStart(sourceFile, true);
                         const memberEnd = member.getEnd();
                         let lineStart = memberStart;
@@ -807,7 +819,11 @@ function removeRouterStateServiceInjection(sourceFile, content, routerStateServi
                     member.parameters.forEach((param) => {
                         if (ts.isIdentifier(param.name)) {
                             const paramName = param.name.text;
-                            if (routerStateServiceVars.includes(paramName)) {
+                            const hasRouterStateType = param.type &&
+                                ts.isTypeReferenceNode(param.type) &&
+                                ts.isIdentifier(param.type.typeName) &&
+                                param.type.typeName.text === 'RouterStateService';
+                            if (routerStateServiceVars.includes(paramName) && hasRouterStateType) {
                                 return;
                             }
                         }
@@ -951,11 +967,13 @@ export default async function migrateRouterStateService(tree) {
         for (const child of children) {
             const path = dir === '.' ? child : `${dir}/${child}`;
             if (tree.isFile(path)) {
-                if (path.endsWith('.ts') && !path.includes('node_modules') && !path.includes('.spec.ts')) {
+                if (path.endsWith('.ts') && !path.includes('node_modules')) {
                     tsFiles.push(path);
                 }
             }
             else {
+                if (child === 'node_modules')
+                    continue;
                 findFiles(path);
             }
         }
@@ -971,6 +989,14 @@ export default async function migrateRouterStateService(tree) {
             continue;
         console.log(`Processing: ${filePath}`);
         const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
+        const hasEthleteImport = sourceFile.statements.some((statement) => ts.isImportDeclaration(statement) &&
+            ts.isStringLiteral(statement.moduleSpecifier) &&
+            statement.moduleSpecifier.text.startsWith('@ethlete/') &&
+            !!statement.importClause?.namedBindings &&
+            ts.isNamedImports(statement.importClause.namedBindings) &&
+            statement.importClause.namedBindings.elements.some((element) => (element.propertyName?.text ?? element.name.text) === 'RouterStateService'));
+        if (!hasEthleteImport)
+            continue;
         const inlineResult = handleInlineInjectPatterns(sourceFile, content);
         let updatedContent = inlineResult.content;
         const updatedSourceFile = updatedContent !== content
@@ -1005,7 +1031,7 @@ export default async function migrateRouterStateService(tree) {
                     allImportsNeeded['@angular/core/rxjs-interop'].add('toObservable');
                 }
             });
-            for (const [original, replacement] of context.replacements) {
+            for (const [original, replacement] of [...context.replacements].sort((a, b) => b[0].length - a[0].length)) {
                 if (replacement.includes('toObservable(')) {
                     allImportsNeeded['@angular/core/rxjs-interop'].add('toObservable');
                 }
@@ -1061,4 +1087,3 @@ export default async function migrateRouterStateService(tree) {
         console.log('\nℹ️  No RouterStateService usage found\n');
     }
 }
-//# sourceMappingURL=router-state-service.js.map

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

@@ -23,6 +23,16 @@
       "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
+    },
+    "reportRemovedExports": {
+      "type": "boolean",
+      "description": "List imports of exports removed in v5 without a replacement (Memo, the props module)",
+      "default": true
     }
   },
   "required": []