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

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

@@ -1,6 +1,9 @@
+import { logger } from '@nx/devkit';
 import * as ts from 'typescript';
+import { collectFiles } from './migration-files.js';
+import { findSyncObservableConsumers } from './sync-observable-consumers.js';
+import { applyReplacementsInClass, collectClasses, findServiceClasses, getServiceImport, isServiceParameter, isServiceProperty, isServiceStillUsed, removeServiceImport, } from './service-classes.js';
 function getPropertyMaps() {
-    // Property map for signals (getters for latest value)
     const signalPropertyMap = {
         route: 'injectRoute',
         state: 'injectRouterState',
@@ -11,7 +14,6 @@ function getPropertyMaps() {
         fragment: 'injectFragment',
         latestEvent: 'injectRouterEvent',
     };
-    // Property map for observables
     const observablePropertyMap = {
         route$: 'injectRoute',
         state$: 'injectRouterState',
@@ -25,17 +27,15 @@ function getPropertyMaps() {
     };
     return { signalPropertyMap, observablePropertyMap };
 }
-function findRouterStateServiceVariables(sourceFile) {
+function findRouterStateServiceVariables(sourceFile, serviceName) {
     const variables = [];
     function visit(node) {
-        // Check for inject(RouterStateService) pattern
         if (ts.isCallExpression(node) &&
             ts.isIdentifier(node.expression) &&
             node.expression.text === 'inject' &&
             node.arguments.length > 0) {
             const arg = node.arguments[0];
-            if (ts.isIdentifier(arg) && arg.text === 'RouterStateService') {
-                // Find the variable name
+            if (ts.isIdentifier(arg) && arg.text === serviceName) {
                 let parent = node.parent;
                 while (parent) {
                     if (ts.isPropertyDeclaration(parent) && ts.isIdentifier(parent.name)) {
@@ -50,11 +50,10 @@ function findRouterStateServiceVariables(sourceFile) {
                 }
             }
         }
-        // Check for constructor parameter injection
         if (ts.isParameter(node)) {
             const typeNode = node.type;
             if (typeNode && ts.isTypeReferenceNode(typeNode) && ts.isIdentifier(typeNode.typeName)) {
-                if (typeNode.typeName.text === 'RouterStateService' && node.name && ts.isIdentifier(node.name)) {
+                if (typeNode.typeName.text === serviceName && node.name && ts.isIdentifier(node.name)) {
                     variables.push(node.name.text);
                 }
             }
@@ -64,29 +63,6 @@ function findRouterStateServiceVariables(sourceFile) {
     visit(sourceFile);
     return variables;
 }
-function findClassForRouterStateService(sourceFile, routerStateServiceVar) {
-    let classNode = null;
-    function visit(node) {
-        if (ts.isClassDeclaration(node)) {
-            const hasRouterStateService = node.members.some((member) => {
-                if (ts.isPropertyDeclaration(member) && ts.isIdentifier(member.name)) {
-                    return member.name.text === routerStateServiceVar;
-                }
-                if (ts.isConstructorDeclaration(member)) {
-                    return member.parameters.some((param) => ts.isIdentifier(param.name) && param.name.text === routerStateServiceVar);
-                }
-                return false;
-            });
-            if (hasRouterStateService) {
-                classNode = node;
-                return;
-            }
-        }
-        ts.forEachChild(node, visit);
-    }
-    visit(sourceFile);
-    return classNode;
-}
 function analyzeClassMigration(sourceFile, classNode, routerStateServiceVar) {
     const context = {
         routerStateServiceVar,
@@ -94,15 +70,13 @@ function analyzeClassMigration(sourceFile, classNode, routerStateServiceVar) {
         membersToAdd: [],
         replacements: new Map(),
         importsNeeded: new Set(),
-        constructorCalls: [], // Initialize
+        constructorCalls: [],
     };
-    // Collect existing member names and detect property initializers
     const propertyInitializers = new Map();
     classNode.members.forEach((member) => {
         if (ts.isPropertyDeclaration(member) && ts.isIdentifier(member.name)) {
             const memberName = member.name.text;
             context.existingMembers.add(memberName);
-            // Check if this property has an initializer that uses RouterStateService
             if (member.initializer) {
                 const initializerText = member.initializer.getText(sourceFile);
                 if (initializerText.includes(routerStateServiceVar)) {
@@ -115,7 +89,6 @@ function analyzeClassMigration(sourceFile, classNode, routerStateServiceVar) {
         }
     });
     const { signalPropertyMap, observablePropertyMap } = getPropertyMaps();
-    // Method map
     const methodMap = {
         selectQueryParam: { injectFn: 'injectQueryParam', type: 'observable', requiresArgs: true },
         selectPathParam: { injectFn: 'injectPathParam', type: 'observable', requiresArgs: true },
@@ -127,13 +100,10 @@ function analyzeClassMigration(sourceFile, classNode, routerStateServiceVar) {
             needsInjectionContext: true,
         },
     };
-    // Track usages
     const usagesWrappedInToSignal = new Map();
     const usagesOutsideToSignal = new Map();
     const usagesInPropertyInitializers = new Map();
-    // First pass: detect toSignal usages, property initializers, and count all usages
     function detectUsages(node, insideToSignal = false, currentProperty) {
-        // Handle toSignal wrapper
         if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === 'toSignal') {
             const arg = node.arguments[0];
             if (arg) {
@@ -141,7 +111,6 @@ function analyzeClassMigration(sourceFile, classNode, routerStateServiceVar) {
             }
             return;
         }
-        // Track RouterStateService property access
         if (ts.isPropertyAccessExpression(node)) {
             const propertyName = node.name.text;
             const isRouterStateAccess = (ts.isIdentifier(node.expression) && node.expression.text === routerStateServiceVar) ||
@@ -158,7 +127,6 @@ function analyzeClassMigration(sourceFile, classNode, routerStateServiceVar) {
                             usage: fullAccess,
                             propertyDecl,
                         });
-                        // Also track if it's wrapped in toSignal
                         if (insideToSignal) {
                             usagesWrappedInToSignal.set(fullAccess, (usagesWrappedInToSignal.get(fullAccess) || 0) + 1);
                         }
@@ -172,7 +140,6 @@ function analyzeClassMigration(sourceFile, classNode, routerStateServiceVar) {
                 }
             }
         }
-        // Track method calls
         if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression)) {
             const methodName = node.expression.name.text;
             if (methodName !== 'pipe' && methodName !== 'subscribe') {
@@ -190,7 +157,6 @@ function analyzeClassMigration(sourceFile, classNode, routerStateServiceVar) {
                                 usage: fullCall,
                                 propertyDecl,
                             });
-                            // Also track if it's wrapped in toSignal
                             if (insideToSignal) {
                                 usagesWrappedInToSignal.set(fullCall, (usagesWrappedInToSignal.get(fullCall) || 0) + 1);
                             }
@@ -207,7 +173,6 @@ function analyzeClassMigration(sourceFile, classNode, routerStateServiceVar) {
         }
         ts.forEachChild(node, (child) => detectUsages(child, insideToSignal, currentProperty));
     }
-    // Detect usages in property initializers
     classNode.members.forEach((member) => {
         if (ts.isPropertyDeclaration(member) && member.initializer && ts.isIdentifier(member.name)) {
             const propertyName = member.name.text;
@@ -218,17 +183,14 @@ function analyzeClassMigration(sourceFile, classNode, routerStateServiceVar) {
         else if (ts.isPropertyDeclaration(member) &&
             ts.isIdentifier(member.name) &&
             member.name.text === routerStateServiceVar) {
-            // Skip the RouterStateService property itself
             return;
         }
         else {
             detectUsages(member);
         }
     });
-    // Group property initializer usages by usage pattern
     const propertyInitializerUsages = new Map();
     for (const [usage, info] of usagesInPropertyInitializers) {
-        // Determine if this is a property access or method call
         const isMethodCall = usage.includes('(');
         let usageKey;
         let injectFn;
@@ -236,8 +198,6 @@ function analyzeClassMigration(sourceFile, classNode, routerStateServiceVar) {
         let args;
         let genericType = '';
         if (isMethodCall) {
-            // Extract method name, generic type, and args
-            // Remove whitespace and newlines for matching
             const normalizedUsage = usage.replace(/\s+/g, ' ');
             const match = normalizedUsage.match(/\.(\w+)(?:<([^>]+)>)?\(([^)]*)\)/);
             if (!match)
@@ -253,7 +213,6 @@ function analyzeClassMigration(sourceFile, classNode, routerStateServiceVar) {
             type = methodInfo.type;
         }
         else {
-            // Extract property name
             const match = usage.match(/\.(\w+\$?)$/);
             if (!match)
                 continue;
@@ -277,10 +236,8 @@ function analyzeClassMigration(sourceFile, classNode, routerStateServiceVar) {
             wrappedInToSignal,
         });
     }
-    // Process property initializer usages
     for (const [usageKey, usageInfo] of propertyInitializerUsages) {
         const { injectFn, args, type, genericType, properties } = usageInfo;
-        // Check if this same usage is used outside property initializers
         const isUsedOutsideInitializers = usagesOutsideToSignal.has(usageKey) ||
             Array.from(usagesOutsideToSignal.keys()).some((key) => {
                 if (args) {
@@ -289,7 +246,6 @@ function analyzeClassMigration(sourceFile, classNode, routerStateServiceVar) {
                 return key.includes(usageKey);
             });
         if (isUsedOutsideInitializers && type === 'observable') {
-            // Create a shared member
             const baseName = usageKey.endsWith('$') ? usageKey : `${usageKey}$`;
             const memberName = findAvailableMemberName(baseName, context.existingMembers);
             const memberInfo = {
@@ -302,10 +258,8 @@ function analyzeClassMigration(sourceFile, classNode, routerStateServiceVar) {
             };
             context.membersToAdd.push(memberInfo);
             context.existingMembers.add(memberName);
-            // For each property, replace the usage with the member reference
             for (const { propertyDecl } of properties) {
                 const initializerText = propertyDecl.initializer.getText(sourceFile);
-                // Create pattern to match only the RouterStateService access part
                 const isMethodCall = usageKey.includes('(');
                 if (isMethodCall) {
                     const methodNameOnly = usageKey.split(/[<(]/)[0];
@@ -314,7 +268,6 @@ function analyzeClassMigration(sourceFile, classNode, routerStateServiceVar) {
                     const pattern = new RegExp(`(this\\.)?${escapedVar}\\s*\\.\\s*${escapedMethod}(?:<[^>]+>)?\\s*\\([^)]*\\)`, 'gs');
                     const match = initializerText.match(pattern);
                     if (match && match[0]) {
-                        // Check if the original has 'this.' prefix
                         const hasThisPrefix = match[0].startsWith('this.');
                         const replacement = hasThisPrefix ? `this.${memberName}` : memberName;
                         context.replacements.set(match[0], replacement);
@@ -324,7 +277,6 @@ function analyzeClassMigration(sourceFile, classNode, routerStateServiceVar) {
                     const pattern = new RegExp(`(this\\.)?${escapeRegExp(routerStateServiceVar)}\\.${escapeRegExp(usageKey)}`, 'g');
                     const matches = initializerText.match(pattern);
                     if (matches && matches[0]) {
-                        // Check if the original has 'this.' prefix
                         const hasThisPrefix = matches[0].startsWith('this.');
                         const replacement = hasThisPrefix ? `this.${memberName}` : memberName;
                         context.replacements.set(matches[0], replacement);
@@ -334,19 +286,15 @@ function analyzeClassMigration(sourceFile, classNode, routerStateServiceVar) {
             context.importsNeeded.add(injectFn);
         }
         else {
-            // Replace each property initializer directly
             for (const { propertyDecl, wrappedInToSignal } of properties) {
                 const initializerText = propertyDecl.initializer.getText(sourceFile);
                 const injectCall = args ? `${injectFn}${genericType || ''}(${args})` : `${injectFn}()`;
                 const propertyName = ts.isIdentifier(propertyDecl.name) ? propertyDecl.name.text : '';
                 const isObservableProperty = propertyName.endsWith('$');
-                const isPropertyUsedElsewhere = checkIfPropertyIsUsedElsewhere(sourceFile, classNode, propertyName, propertyDecl);
+                const isPropertyUsedElsewhere = checkIfPropertyIsUsedElsewhere(classNode, propertyName, propertyDecl);
                 const hasChainedCalls = initializerText.includes('.pipe(') ||
                     initializerText.includes('.subscribe(') ||
                     initializerText.match(/\)\s*\./);
-                // Determine if we need toObservable wrapper:
-                // 1. If NOT wrapped in toSignal and type is observable and (property ends with $ or used elsewhere)
-                // 2. If wrapped in toSignal but has chained calls (pipe/subscribe), we need toObservable
                 const needsToObservable = (type === 'observable' && !wrappedInToSignal && (isObservableProperty || isPropertyUsedElsewhere)) ||
                     (wrappedInToSignal && hasChainedCalls);
                 const wrappedInjectCall = needsToObservable ? `toObservable(${injectCall})` : injectCall;
@@ -377,7 +325,6 @@ function analyzeClassMigration(sourceFile, classNode, routerStateServiceVar) {
             }
         }
     }
-    // Handle direct usages (not in property initializers)
     for (const [usage] of usagesWrappedInToSignal) {
         if (!usagesInPropertyInitializers.has(usage)) {
             const isMethodCall = usage.includes('(');
@@ -406,9 +353,7 @@ function analyzeClassMigration(sourceFile, classNode, routerStateServiceVar) {
             context.importsNeeded.add(injectFn);
         }
     }
-    // Handle direct usages in method bodies (outside toSignal, not in property initializers)
     for (const [usage] of usagesOutsideToSignal) {
-        // Skip if already handled in property initializers
         if (usagesInPropertyInitializers.has(usage))
             continue;
         const isMethodCall = usage.includes('(');
@@ -432,13 +377,8 @@ function analyzeClassMigration(sourceFile, classNode, routerStateServiceVar) {
             type = methodInfo.type;
             needsInjectionContext = methodInfo.needsInjectionContext || false;
             if (needsInjectionContext) {
-                // Add to constructor calls
                 const injectCall = args ? `${injectFn}${genericType}(${args})` : `${injectFn}()`;
                 context.constructorCalls.push(injectCall);
-                // Create pattern to match the full statement including semicolon and potential whitespace
-                const methodNameOnly = methodName;
-                const pattern = new RegExp(`(this\\.)?${escapeRegExp(routerStateServiceVar)}\\s*\\.\\s*${escapeRegExp(methodNameOnly)}(?:<[^>]+>)?\\s*\\([^)]*\\)\\s*;`, 'gs');
-                // Replace with empty string (removes the entire statement)
                 context.replacements.set(usage + ';', '');
                 context.importsNeeded.add(injectFn);
                 continue; // Don't create a member for this
@@ -452,7 +392,6 @@ function analyzeClassMigration(sourceFile, classNode, routerStateServiceVar) {
             injectFn = signalPropertyMap[propertyName] || observablePropertyMap[propertyName];
             type = propertyName.endsWith('$') ? 'observable' : 'signal';
         }
-        // For properties used in method bodies, create a shared member
         const baseName = usage.split('.').pop();
         const memberName = findAvailableMemberName(baseName, context.existingMembers);
         const memberInfo = {
@@ -465,10 +404,6 @@ function analyzeClassMigration(sourceFile, classNode, routerStateServiceVar) {
         };
         context.membersToAdd.push(memberInfo);
         context.existingMembers.add(memberName);
-        // Replace usage with member reference
-        // For signals (non-observable), we need to call them: this.route()
-        // For observables, we just reference them: this.route$
-        // Check if the original usage has 'this.' prefix
         const hasThisPrefix = usage.includes('this.');
         const baseReplacement = type === 'signal' ? `${memberName}()` : `${memberName}`;
         const replacement = hasThisPrefix ? `this.${baseReplacement}` : baseReplacement;
@@ -480,20 +415,17 @@ function analyzeClassMigration(sourceFile, classNode, routerStateServiceVar) {
 function addOrUpdateConstructor(sourceFile, content, classNode, constructorCalls) {
     if (constructorCalls.length === 0)
         return content;
-    // Find existing constructor
     const existingConstructor = classNode.members.find((member) => ts.isConstructorDeclaration(member));
     const callStatements = constructorCalls.map((call) => `    ${call};`).join('\n');
     if (existingConstructor) {
-        // Add calls to existing constructor
         const constructorBody = existingConstructor.body;
         if (!constructorBody)
             return content;
-        const insertPos = constructorBody.getStart(sourceFile) + 1; // After opening brace
+        const insertPos = constructorBody.getStart(sourceFile) + 1;
         const indent = '\n    ';
         return content.slice(0, insertPos) + indent + callStatements + content.slice(insertPos);
     }
     else {
-        // Create new constructor
         const firstMethod = classNode.members.find((member) => ts.isMethodDeclaration(member) || ts.isGetAccessor(member) || ts.isSetAccessor(member));
         const constructorText = `\n\n  constructor() {\n${callStatements}\n  }`;
         if (firstMethod) {
@@ -501,18 +433,11 @@ function addOrUpdateConstructor(sourceFile, content, classNode, constructorCalls
             return content.slice(0, insertPos) + constructorText + '\n\n  ' + content.slice(insertPos);
         }
         else {
-            // Insert at end of class, before closing brace
             const classEnd = classNode.getEnd() - 1;
             return content.slice(0, classEnd) + constructorText + '\n' + content.slice(classEnd);
         }
     }
 }
-function generateNameFromArgs(usageKey, args, type) {
-    const baseName = usageKey.split('(')[0].replace(/^\w/, (c) => c.toUpperCase());
-    const cleanArgs = args.replace(/['"]/g, '').replace(/[^\w]/g, '_').replace(/_+/g, '_').replace(/^_|_$/g, '');
-    const name = `${baseName.charAt(0).toLowerCase()}${baseName.slice(1)}${cleanArgs.charAt(0).toUpperCase()}${cleanArgs.slice(1)}`;
-    return type === 'observable' ? `${name}$` : name;
-}
 function findAvailableMemberName(baseName, existingMembers) {
     let name = baseName;
     let counter = 1;
@@ -522,23 +447,7 @@ function findAvailableMemberName(baseName, existingMembers) {
     }
     return name;
 }
-function createReplacementsForMember(sourceFile, classNode, routerStateServiceVar, usageKey, memberName, type, context, args) {
-    // Find all occurrences outside property initializers
-    classNode.members.forEach((member) => {
-        if (ts.isMethodDeclaration(member) || ts.isGetAccessor(member) || ts.isSetAccessor(member)) {
-            // Search in method bodies
-            const searchPattern = args
-                ? `${routerStateServiceVar}.${usageKey.split('(')[0]}(${args})`
-                : `${routerStateServiceVar}.${usageKey}`;
-            const memberText = member.getText(sourceFile);
-            if (memberText.includes(searchPattern)) {
-                context.replacements.set(searchPattern, `this.${memberName}`);
-                context.replacements.set(`this.${searchPattern}`, `this.${memberName}`);
-            }
-        }
-    });
-}
-function checkIfPropertyIsUsedElsewhere(sourceFile, classNode, propertyName, propertyDecl) {
+function checkIfPropertyIsUsedElsewhere(classNode, propertyName, propertyDecl) {
     let usedElsewhere = false;
     function visit(node) {
         if (node === propertyDecl)
@@ -560,15 +469,13 @@ function checkIfPropertyIsUsedElsewhere(sourceFile, classNode, propertyName, pro
 function escapeRegExp(string) {
     return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
-function addMembersToClass(sourceFile, content, classNode, members, routerStateServiceVar) {
-    // Find the RouterStateService property to insert after
+function addMembersToClass(content, classNode, members, routerStateServiceVar) {
     const routerStateProperty = classNode.members.find((member) => ts.isPropertyDeclaration(member) && ts.isIdentifier(member.name) && member.name.text === routerStateServiceVar);
     if (!routerStateProperty) {
-        console.warn('Could not find RouterStateService property to insert new members after');
+        logger.warn('Could not find RouterStateService property to insert new members after');
         return content;
     }
     const insertPosition = routerStateProperty.getEnd();
-    // Generate member declarations
     const memberDeclarations = members.map((member) => {
         const injectCall = member.args ? `${member.injectFn}(${member.args})` : `${member.injectFn}()`;
         const value = member.type === 'observable' ? `toObservable(${injectCall})` : injectCall;
@@ -576,11 +483,10 @@ function addMembersToClass(sourceFile, content, classNode, members, routerStateS
     });
     return content.slice(0, insertPosition) + memberDeclarations.join('') + content.slice(insertPosition);
 }
-function handleInlineInjectPatterns(sourceFile, content) {
+function handleInlineInjectPatterns(sourceFile, content, serviceName) {
     const importsNeeded = new Set();
-    let updatedContent = content;
+    const edits = [];
     const { signalPropertyMap, observablePropertyMap } = getPropertyMaps();
-    // Method map
     const methodMap = {
         selectQueryParam: { injectFn: 'injectQueryParam', type: 'observable', requiresArgs: true },
         selectPathParam: { injectFn: 'injectPathParam', type: 'observable', requiresArgs: true },
@@ -592,7 +498,6 @@ function handleInlineInjectPatterns(sourceFile, content) {
             needsInjectionContext: true,
         },
     };
-    // Track which nodes are already inside toSignal to avoid double processing
     const processedNodes = new Set();
     function isInsideToSignal(node) {
         let current = node.parent;
@@ -607,7 +512,6 @@ function handleInlineInjectPatterns(sourceFile, content) {
         return false;
     }
     function visitNode(node) {
-        // Look for: toSignal(inject(RouterStateService).property)
         if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === 'toSignal') {
             const arg = node.arguments[0];
             if (arg && ts.isPropertyAccessExpression(arg)) {
@@ -617,20 +521,17 @@ function handleInlineInjectPatterns(sourceFile, content) {
                     arg.expression.expression.text === 'inject' &&
                     arg.expression.arguments.length > 0) {
                     const injectArg = arg.expression.arguments[0];
-                    if (ts.isIdentifier(injectArg) && injectArg.text === 'RouterStateService') {
+                    if (ts.isIdentifier(injectArg) && injectArg.text === serviceName) {
                         const injectFn = signalPropertyMap[propertyName] || observablePropertyMap[propertyName];
                         if (injectFn) {
-                            const oldText = node.getText(sourceFile);
                             const newText = `${injectFn}()`;
-                            updatedContent = updatedContent.replace(oldText, newText);
+                            edits.push({ start: node.getStart(sourceFile), end: node.getEnd(), text: newText });
                             importsNeeded.add(injectFn);
-                            // Mark this property access as processed
                             processedNodes.add(arg);
                         }
                     }
                 }
             }
-            // NEW: Look for: toSignal(inject(RouterStateService).methodCall(...))
             if (arg && ts.isCallExpression(arg) && ts.isPropertyAccessExpression(arg.expression)) {
                 const methodName = arg.expression.name.text;
                 const methodInfo = methodMap[methodName];
@@ -640,28 +541,21 @@ function handleInlineInjectPatterns(sourceFile, content) {
                     arg.expression.expression.expression.text === 'inject' &&
                     arg.expression.expression.arguments.length > 0) {
                     const injectArg = arg.expression.expression.arguments[0];
-                    if (ts.isIdentifier(injectArg) && injectArg.text === 'RouterStateService') {
-                        const oldText = node.getText(sourceFile);
-                        // Extract generic type and args
+                    if (ts.isIdentifier(injectArg) && injectArg.text === serviceName) {
                         const innerCallText = arg.getText(sourceFile);
                         const genericMatch = innerCallText.match(new RegExp(`${methodName}<([^>]+)>`));
                         const genericType = genericMatch ? `<${genericMatch[1]}>` : '';
-                        // Get the arguments from the call
                         const args = arg.arguments.map((a) => a.getText(sourceFile)).join(', ');
                         const injectCall = `${methodInfo.injectFn}${genericType}(${args})`;
-                        // Since it's wrapped in toSignal and returns a signal, no need for toObservable
                         const newText = injectCall;
-                        updatedContent = updatedContent.replace(oldText, newText);
+                        edits.push({ start: node.getStart(sourceFile), end: node.getEnd(), text: newText });
                         importsNeeded.add(methodInfo.injectFn);
-                        // Mark this call as processed
                         processedNodes.add(arg);
                     }
                 }
             }
         }
-        // Look for: inject(RouterStateService).selectQueryParam() or other method calls (NOT inside toSignal)
         if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression)) {
-            // Skip if already processed by toSignal handler
             if (processedNodes.has(node)) {
                 ts.forEachChild(node, visitNode);
                 return;
@@ -674,21 +568,18 @@ function handleInlineInjectPatterns(sourceFile, content) {
                 node.expression.expression.expression.text === 'inject' &&
                 node.expression.expression.arguments.length > 0) {
                 const injectArg = node.expression.expression.arguments[0];
-                if (ts.isIdentifier(injectArg) && injectArg.text === 'RouterStateService') {
-                    // Check if inside toSignal
+                if (ts.isIdentifier(injectArg) && injectArg.text === serviceName) {
                     if (isInsideToSignal(node)) {
                         ts.forEachChild(node, visitNode);
                         return;
                     }
                     const oldText = node.getText(sourceFile);
-                    // Extract generic type and args
                     const genericMatch = oldText.match(new RegExp(`${methodName}<([^>]+)>`));
                     const genericType = genericMatch ? `<${genericMatch[1]}>` : '';
-                    // Get the arguments from the call
                     const args = node.arguments.map((arg) => arg.getText(sourceFile)).join(', ');
                     const injectCall = `${methodInfo.injectFn}${genericType}(${args})`;
                     const newText = methodInfo.type === 'observable' ? `toObservable(${injectCall})` : injectCall;
-                    updatedContent = updatedContent.replace(oldText, newText);
+                    edits.push({ start: node.getStart(sourceFile), end: node.getEnd(), text: newText });
                     importsNeeded.add(methodInfo.injectFn);
                     if (methodInfo.type === 'observable') {
                         importsNeeded.add('toObservable');
@@ -696,10 +587,7 @@ function handleInlineInjectPatterns(sourceFile, content) {
                 }
             }
         }
-        // Look for: inject(RouterStateService).property (not wrapped in toSignal)
-        // This handles: inject(RouterStateService).pathParams$.pipe(...)
         if (ts.isPropertyAccessExpression(node)) {
-            // Skip if already processed by toSignal handler
             if (processedNodes.has(node)) {
                 ts.forEachChild(node, visitNode);
                 return;
@@ -710,21 +598,18 @@ function handleInlineInjectPatterns(sourceFile, content) {
                 node.expression.expression.text === 'inject' &&
                 node.expression.arguments.length > 0) {
                 const injectArg = node.expression.arguments[0];
-                if (ts.isIdentifier(injectArg) && injectArg.text === 'RouterStateService') {
+                if (ts.isIdentifier(injectArg) && injectArg.text === serviceName) {
                     const injectFn = signalPropertyMap[propertyName] || observablePropertyMap[propertyName];
                     if (injectFn) {
-                        // Check if this is inside a toSignal wrapper
                         const insideToSignal = isInsideToSignal(node);
-                        // Skip if inside toSignal - it will be handled by the toSignal pattern above
                         if (insideToSignal) {
                             ts.forEachChild(node, visitNode);
                             return;
                         }
-                        const oldText = node.getText(sourceFile);
                         const type = observablePropertyMap[propertyName] ? 'observable' : 'signal';
                         const injectCall = `${injectFn}()`;
                         const newText = type === 'observable' ? `toObservable(${injectCall})` : injectCall;
-                        updatedContent = updatedContent.replace(oldText, newText);
+                        edits.push({ start: node.getStart(sourceFile), end: node.getEnd(), text: newText });
                         importsNeeded.add(injectFn);
                         if (type === 'observable') {
                             importsNeeded.add('toObservable');
@@ -736,11 +621,10 @@ function handleInlineInjectPatterns(sourceFile, content) {
         ts.forEachChild(node, visitNode);
     }
     sourceFile.forEachChild(visitNode);
-    return { content: updatedContent, importsNeeded };
+    return { content: applyInlineEdits(content, edits), importsNeeded };
 }
 function addImportsToPackage(sourceFile, content, imports, packageName) {
     const importsList = Array.from(imports).sort();
-    // Check if import already exists
     let existingImport;
     sourceFile.forEachChild((node) => {
         if (ts.isImportDeclaration(node) &&
@@ -750,18 +634,18 @@ 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();
         const newImportText = `import { ${allImports.join(', ')} } from '${packageName}';`;
         const oldImportText = existingImport.getText(sourceFile);
-        return content.replace(oldImportText, newImportText);
+        return content.replace(oldImportText, () => newImportText);
     }
     else {
-        // Add new import at the top
         const newImportText = `import { ${importsList.join(', ')} } from '${packageName}';\n`;
         const firstImport = sourceFile.statements.find((stmt) => ts.isImportDeclaration(stmt));
         if (firstImport) {
@@ -773,65 +657,54 @@ function addImportsToPackage(sourceFile, content, imports, packageName) {
         }
     }
 }
-function removeRouterStateServiceInjection(sourceFile, content, routerStateServiceVars, filePath) {
+function removeRouterStateServiceInjection(sourceFile, content, serviceName, filePath) {
     let updatedContent = content;
     const modifications = [];
-    sourceFile.forEachChild((node) => {
-        if (ts.isClassDeclaration(node)) {
-            // Collect property removals
-            node.members.forEach((member) => {
-                if (ts.isPropertyDeclaration(member) && ts.isIdentifier(member.name)) {
-                    const memberName = member.name.text;
-                    if (routerStateServiceVars.includes(memberName)) {
-                        const memberStart = member.getStart(sourceFile, true);
-                        const memberEnd = member.getEnd();
-                        let lineStart = memberStart;
-                        while (lineStart > 0 && content[lineStart - 1] !== '\n') {
-                            lineStart--;
-                        }
-                        let lineEnd = memberEnd;
-                        while (lineEnd < content.length && content[lineEnd] !== '\n') {
-                            lineEnd++;
-                        }
-                        if (content[lineEnd] === '\n') {
-                            lineEnd++;
-                        }
-                        modifications.push({ start: lineStart, end: lineEnd, replacement: '' });
+    collectClasses(sourceFile).forEach((node) => {
+        node.members.forEach((member) => {
+            if (ts.isPropertyDeclaration(member) && ts.isIdentifier(member.name)) {
+                if (isServiceProperty(member, serviceName)) {
+                    const memberStart = member.getStart(sourceFile, true);
+                    const memberEnd = member.getEnd();
+                    let lineStart = memberStart;
+                    while (lineStart > 0 && content[lineStart - 1] !== '\n') {
+                        lineStart--;
                     }
-                }
-            });
-            // Collect constructor parameter modifications
-            node.members.forEach((member) => {
-                if (ts.isConstructorDeclaration(member) && member.parameters.length > 0) {
-                    const newParams = [];
-                    member.parameters.forEach((param) => {
-                        if (ts.isIdentifier(param.name)) {
-                            const paramName = param.name.text;
-                            if (routerStateServiceVars.includes(paramName)) {
-                                return;
-                            }
-                        }
-                        newParams.push(param.getText(sourceFile));
-                    });
-                    const constructorText = member.getText(sourceFile);
-                    const openParenIndex = constructorText.indexOf('(');
-                    const closeParenIndex = findMatchingParen(constructorText, openParenIndex);
-                    if (openParenIndex === -1 || closeParenIndex === -1) {
-                        console.warn(`Could not find constructor parameters in ${filePath}`);
-                        return;
+                    let lineEnd = memberEnd;
+                    while (lineEnd < content.length && content[lineEnd] !== '\n') {
+                        lineEnd++;
+                    }
+                    if (content[lineEnd] === '\n') {
+                        lineEnd++;
                     }
-                    const constructorStart = member.getStart(sourceFile);
-                    const paramListStart = constructorStart + openParenIndex + 1;
-                    const paramListEnd = constructorStart + closeParenIndex;
-                    const newParamsText = newParams.join(', ');
-                    modifications.push({
-                        start: paramListStart,
-                        end: paramListEnd,
-                        replacement: newParamsText,
-                    });
+                    modifications.push({ start: lineStart, end: lineEnd, replacement: '' });
                 }
-            });
-        }
+            }
+        });
+        node.members.forEach((member) => {
+            if (ts.isConstructorDeclaration(member) &&
+                member.parameters.some((param) => isServiceParameter(param, serviceName))) {
+                const newParams = member.parameters
+                    .filter((param) => !isServiceParameter(param, serviceName))
+                    .map((param) => param.getText(sourceFile));
+                const constructorText = member.getText(sourceFile);
+                const openParenIndex = constructorText.indexOf('(');
+                const closeParenIndex = findMatchingParen(constructorText, openParenIndex);
+                if (openParenIndex === -1 || closeParenIndex === -1) {
+                    logger.warn(`Could not find constructor parameters in ${filePath}`);
+                    return;
+                }
+                const constructorStart = member.getStart(sourceFile);
+                const paramListStart = constructorStart + openParenIndex + 1;
+                const paramListEnd = constructorStart + closeParenIndex;
+                const newParamsText = newParams.join(', ');
+                modifications.push({
+                    start: paramListStart,
+                    end: paramListEnd,
+                    replacement: newParamsText,
+                });
+            }
+        });
     });
     modifications.sort((a, b) => b.start - a.start);
     for (const mod of modifications) {
@@ -853,70 +726,8 @@ function findMatchingParen(text, openIndex) {
     }
     return depth === 0 ? i - 1 : -1;
 }
-function removeRouterStateServiceImport(sourceFile, content) {
-    let updatedContent = content;
-    sourceFile.forEachChild((node) => {
-        if (ts.isImportDeclaration(node)) {
-            const moduleSpecifier = node.moduleSpecifier;
-            if (ts.isStringLiteral(moduleSpecifier)) {
-                if (!node.importClause?.namedBindings)
-                    return;
-                if (ts.isNamedImports(node.importClause.namedBindings)) {
-                    const imports = node.importClause.namedBindings.elements;
-                    const routerStateServiceImport = imports.find((imp) => ts.isImportSpecifier(imp) && imp.name.text === 'RouterStateService');
-                    if (!routerStateServiceImport)
-                        return;
-                    if (imports.length === 1) {
-                        const importStart = node.getStart(sourceFile);
-                        let lineEnd = node.getEnd();
-                        while (lineEnd < content.length && content[lineEnd] !== '\n') {
-                            lineEnd++;
-                        }
-                        if (content[lineEnd] === '\n') {
-                            lineEnd++;
-                        }
-                        updatedContent = content.slice(0, importStart) + content.slice(lineEnd);
-                    }
-                    else {
-                        const namedImportsText = node.importClause.namedBindings.getText(sourceFile);
-                        const patterns = [
-                            new RegExp(`RouterStateService,\\s*`, 'g'),
-                            new RegExp(`,\\s*RouterStateService`, 'g'),
-                            new RegExp(`\\s*RouterStateService\\s*`, 'g'),
-                        ];
-                        let newNamedImports = namedImportsText;
-                        for (const pattern of patterns) {
-                            const temp = newNamedImports.replace(pattern, '');
-                            if (temp !== newNamedImports) {
-                                newNamedImports = temp;
-                                break;
-                            }
-                        }
-                        newNamedImports = newNamedImports.replace(/,\s*,/g, ',').replace(/{\s*,/g, '{').replace(/,\s*}/g, '}');
-                        updatedContent = updatedContent.replace(namedImportsText, newNamedImports);
-                    }
-                }
-            }
-        }
-    });
-    return updatedContent;
-}
-function checkIfRouterStateServiceStillUsed(sourceFile, routerStateServiceVars) {
-    let stillUsed = false;
-    function visit(node) {
-        if (ts.isIdentifier(node) && routerStateServiceVars.includes(node.text)) {
-            stillUsed = true;
-        }
-        if (!stillUsed) {
-            ts.forEachChild(node, visit);
-        }
-    }
-    sourceFile.forEachChild(visit);
-    return stillUsed;
-}
 function removeUnusedImports(sourceFile, content) {
     let updatedContent = content;
-    // Check if toSignal is still used
     const hasToSignal = content.includes('toSignal(');
     if (!hasToSignal) {
         sourceFile.forEachChild((node) => {
@@ -943,44 +754,31 @@ function removeUnusedImports(sourceFile, content) {
     }
     return updatedContent;
 }
-export default async function migrateRouterStateService(tree) {
-    console.log('\n🔄 Migrating RouterStateService usage...\n');
-    const tsFiles = [];
-    function findFiles(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.includes('.spec.ts')) {
-                    tsFiles.push(path);
-                }
-            }
-            else {
-                findFiles(path);
-            }
-        }
-    }
-    findFiles('.');
+export default async function migrateRouterStateService(tree, scope) {
+    const tsFiles = collectFiles(tree, scope, ['.ts']);
+    const review = [];
     let filesModified = 0;
-    let routerStateServiceUsed = false;
     for (const filePath of tsFiles) {
         const content = tree.read(filePath, 'utf-8');
         if (!content)
             continue;
         if (!content.includes('RouterStateService'))
             continue;
-        console.log(`Processing: ${filePath}`);
         const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
-        const inlineResult = handleInlineInjectPatterns(sourceFile, content);
+        const serviceImport = getServiceImport(sourceFile, 'RouterStateService');
+        if (!serviceImport?.packageName.startsWith('@ethlete/'))
+            continue;
+        const serviceName = serviceImport.localName;
+        const inlineResult = handleInlineInjectPatterns(sourceFile, content, serviceName);
         let updatedContent = inlineResult.content;
         const updatedSourceFile = updatedContent !== content
             ? ts.createSourceFile(filePath, updatedContent, ts.ScriptTarget.Latest, true)
             : sourceFile;
-        const routerStateServiceVars = findRouterStateServiceVariables(updatedSourceFile);
+        const routerStateServiceVars = findRouterStateServiceVariables(updatedSourceFile, serviceName);
+        const serviceClasses = findServiceClasses(updatedSourceFile, serviceName);
         if (routerStateServiceVars.length === 0 && inlineResult.importsNeeded.size === 0) {
             continue;
         }
-        routerStateServiceUsed = true;
         const allImportsNeeded = {
             '@ethlete/core': new Set(),
             '@angular/core/rxjs-interop': new Set(),
@@ -993,42 +791,34 @@ export default async function migrateRouterStateService(tree) {
                 allImportsNeeded['@ethlete/core'].add(importName);
             }
         }
-        for (const routerStateServiceVar of routerStateServiceVars) {
-            const classNode = findClassForRouterStateService(updatedSourceFile, routerStateServiceVar);
-            if (!classNode)
-                continue;
-            const context = analyzeClassMigration(updatedSourceFile, classNode, routerStateServiceVar);
-            context.importsNeeded.forEach((imp) => allImportsNeeded['@ethlete/core'].add(imp));
-            context.membersToAdd.forEach((member) => {
-                allImportsNeeded['@ethlete/core'].add(member.injectFn);
-                if (member.type === 'observable' && !member.wrappedInToSignal) {
-                    allImportsNeeded['@angular/core/rxjs-interop'].add('toObservable');
+        for (const { index, fields } of serviceClasses) {
+            for (const routerStateServiceVar of fields) {
+                const currentSourceFile = ts.createSourceFile(filePath, updatedContent, ts.ScriptTarget.Latest, true);
+                const classNode = collectClasses(currentSourceFile)[index];
+                const context = analyzeClassMigration(currentSourceFile, classNode, routerStateServiceVar);
+                context.importsNeeded.forEach((imp) => allImportsNeeded['@ethlete/core'].add(imp));
+                context.membersToAdd.forEach((member) => {
+                    allImportsNeeded['@ethlete/core'].add(member.injectFn);
+                    if (member.type === 'observable' && !member.wrappedInToSignal) {
+                        allImportsNeeded['@angular/core/rxjs-interop'].add('toObservable');
+                    }
+                });
+                for (const replacement of context.replacements.values()) {
+                    if (replacement.includes('toObservable(')) {
+                        allImportsNeeded['@angular/core/rxjs-interop'].add('toObservable');
+                    }
+                    if (replacement.includes('toSignal(')) {
+                        allImportsNeeded['@angular/core/rxjs-interop'].add('toSignal');
+                    }
                 }
-            });
-            for (const [original, replacement] of context.replacements) {
-                if (replacement.includes('toObservable(')) {
-                    allImportsNeeded['@angular/core/rxjs-interop'].add('toObservable');
+                updatedContent = applyReplacementsInClass(updatedContent, currentSourceFile, classNode, context.replacements);
+                if (context.membersToAdd.length > 0) {
+                    const sourceFileUpdated = ts.createSourceFile(filePath, updatedContent, ts.ScriptTarget.Latest, true);
+                    updatedContent = addMembersToClass(updatedContent, collectClasses(sourceFileUpdated)[index], context.membersToAdd, routerStateServiceVar);
                 }
-                if (replacement.includes('toSignal(')) {
-                    allImportsNeeded['@angular/core/rxjs-interop'].add('toSignal');
-                }
-            }
-            for (const [original, replacement] of context.replacements) {
-                const regex = new RegExp(escapeRegExp(original), 'g');
-                updatedContent = updatedContent.replace(regex, replacement);
-            }
-            if (context.membersToAdd.length > 0) {
-                const sourceFileUpdated = ts.createSourceFile(filePath, updatedContent, ts.ScriptTarget.Latest, true);
-                const classNodeUpdated = findClassForRouterStateService(sourceFileUpdated, routerStateServiceVar);
-                if (classNodeUpdated) {
-                    updatedContent = addMembersToClass(sourceFileUpdated, updatedContent, classNodeUpdated, context.membersToAdd, routerStateServiceVar);
-                }
-            }
-            if (context.constructorCalls.length > 0) {
-                const sourceFileUpdated = ts.createSourceFile(filePath, updatedContent, ts.ScriptTarget.Latest, true);
-                const classNodeUpdated = findClassForRouterStateService(sourceFileUpdated, routerStateServiceVar);
-                if (classNodeUpdated) {
-                    updatedContent = addOrUpdateConstructor(sourceFileUpdated, updatedContent, classNodeUpdated, context.constructorCalls);
+                if (context.constructorCalls.length > 0) {
+                    const sourceFileUpdated = ts.createSourceFile(filePath, updatedContent, ts.ScriptTarget.Latest, true);
+                    updatedContent = addOrUpdateConstructor(sourceFileUpdated, updatedContent, collectClasses(sourceFileUpdated)[index], context.constructorCalls);
                 }
             }
         }
@@ -1039,26 +829,31 @@ export default async function migrateRouterStateService(tree) {
             }
         }
         const sourceFileFinal = ts.createSourceFile(filePath, updatedContent, ts.ScriptTarget.Latest, true);
-        updatedContent = removeRouterStateServiceInjection(sourceFileFinal, updatedContent, routerStateServiceVars, filePath);
+        updatedContent = removeRouterStateServiceInjection(sourceFileFinal, updatedContent, serviceName, filePath);
         const sourceFileAfterRemoval = ts.createSourceFile(filePath, updatedContent, ts.ScriptTarget.Latest, true);
-        if (!checkIfRouterStateServiceStillUsed(sourceFileAfterRemoval, routerStateServiceVars)) {
-            updatedContent = removeRouterStateServiceImport(sourceFileAfterRemoval, updatedContent);
+        if (isServiceStillUsed(sourceFileAfterRemoval, serviceName, serviceClasses)) {
+            review.push(`${filePath}: RouterStateService is still used. Migrate the remaining usages manually.`);
+        }
+        else {
+            updatedContent = removeServiceImport(sourceFileAfterRemoval, updatedContent, 'RouterStateService');
         }
         const sourceFileAfterCleanup = ts.createSourceFile(filePath, updatedContent, ts.ScriptTarget.Latest, true);
         updatedContent = removeUnusedImports(sourceFileAfterCleanup, updatedContent);
+        review.push(...findSyncObservableConsumers(filePath, content, updatedContent));
         if (updatedContent !== content) {
             tree.write(filePath, updatedContent);
             filesModified++;
         }
     }
-    if (filesModified > 0) {
-        console.log(`\n✅ Successfully migrated RouterStateService in ${filesModified} file(s)\n`);
-    }
-    else if (routerStateServiceUsed) {
-        console.log('\nℹ️  RouterStateService detected but no migrations needed\n');
-    }
-    else {
-        console.log('\nℹ️  No RouterStateService usage found\n');
+    return { filesChanged: filesModified, review };
+}
+function applyInlineEdits(content, edits) {
+    const accepted = [];
+    for (const edit of [...edits].sort((a, b) => a.start - b.start || b.end - a.end)) {
+        const last = accepted.at(-1);
+        if (last && edit.start < last.end)
+            continue;
+        accepted.push(edit);
     }
+    return accepted.reduceRight((result, edit) => result.slice(0, edit.start) + edit.text + result.slice(edit.end), content);
 }
-//# sourceMappingURL=router-state-service.js.map