@ethlete/core 4.30.0 → 5.0.0-next.0

package/generators/generators.json

@@ -0,0 +1,14 @@
+{
+  "generators": {
+    "migrate-to-v5": {
+      "factory": "./migrate-to-v5/migration",
+      "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"
+    }
+  }
+}

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

@@ -0,0 +1,158 @@
+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('.');
+    let filesModified = 0;
+    for (const filePath of tsFiles) {
+        const wasModified = migrateCreateProviderInFile(tree, filePath);
+        if (wasModified) {
+            filesModified++;
+            logger.log(`  ✓ ${filePath}`);
+        }
+    }
+    if (filesModified > 0) {
+        logger.log(`\n✅ Successfully migrated createProvider in ${filesModified} file(s)\n`);
+    }
+    else {
+        logger.log('\nℹ️  No files needed migration\n');
+    }
+}
+function migrateCreateProviderInFile(tree, filePath) {
+    const content = tree.read(filePath, 'utf-8');
+    if (!content || !content.includes('createProvider'))
+        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) {
+        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');
+                }
+            }
+            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 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--;
+            }
+            let lineEnd = importEnd;
+            while (lineEnd < content.length && content[lineEnd] !== '\n') {
+                lineEnd++;
+            }
+            if (content[lineEnd] === '\n') {
+                lineEnd++;
+            }
+            updatedContent = content.slice(0, lineStart) + content.slice(lineEnd);
+        }
+        else {
+            // Keep other imports
+            const newImports = otherImports.map((el) => el.name.text).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)) {
+            if (statement.moduleSpecifier.text === '@ethlete/core') {
+                updatedCoreImport = statement;
+                break;
+            }
+        }
+    }
+    // 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');
+        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 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) {
+                if (ts.isImportDeclaration(statement)) {
+                    lastImportEnd = statement.getEnd();
+                }
+                else {
+                    break;
+                }
+            }
+            insertPosition = lastImportEnd;
+            // Find end of line
+            while (insertPosition < updatedContent.length && updatedContent[insertPosition] !== '\n') {
+                insertPosition++;
+            }
+            if (updatedContent[insertPosition] === '\n') {
+                insertPosition++;
+            }
+            updatedContent =
+                updatedContent.slice(0, insertPosition) +
+                    "import { createProvider } from '@ethlete/core';\n" +
+                    updatedContent.slice(insertPosition);
+        }
+        else {
+            // No imports, add at the beginning
+            updatedContent = "import { createProvider } from '@ethlete/core';\n\n" + updatedContent;
+        }
+    }
+    if (updatedContent !== content) {
+        tree.write(filePath, updatedContent);
+        return true;
+    }
+    return false;
+}
+//# sourceMappingURL=create-provider.js.map

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

@@ -0,0 +1,28 @@
+import { formatFiles } from '@nx/devkit';
+import migrateCreateProvider from './create-provider.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);
+    }
+    if (!schema.skipFormat) {
+        console.log('  • Formatting files...');
+        await formatFiles(tree);
+    }
+    console.log('\n✅ Migration completed successfully!');
+}
+//#endregion
+//# sourceMappingURL=migration.js.map