@craft-ng/dev-tools 0.1.4 → 0.1.5

package/src/scripts/angular-brand-codemod.js

@@ -2,6 +2,7 @@ import { __awaiter } from "tslib";
 import { Node, Project, QuoteKind, SyntaxKind, ts, } from 'ts-morph';
 import { existsSync, readdirSync, statSync } from 'node:fs';
 import { basename, extname, isAbsolute, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
 const SUPPORTED_DECORATORS = {
     Component: 'component',
     Directive: 'directive',
@@ -63,18 +64,17 @@ export function transformSourceFile(sourceFile, options = {}) {
     if (analysis.skipped || !classDeclaration || !angularKind || !className) {
         return result;
     }
-    const exportSafety = getExportRewriteSafety(sourceFile, classDeclaration, className);
-    if (!exportSafety.safe) {
-        return skip(result, exportSafety.warnings);
-    }
     const importSafety = getHelperImportSafety(sourceFile, normalizedOptions.helperImportPath);
     if (!importSafety.safe) {
         return skip(result, importSafety.warnings);
     }
-    removeConflictingExports(sourceFile, classDeclaration, className);
+    const beforeText = sourceFile.getFullText();
+    migrateLegacyBrandExport(sourceFile, classDeclaration, className);
     ensureHelperImports(sourceFile, normalizedOptions.helperImportPath);
-    writeDefaultBrandExport(sourceFile, className, result.dependencyGroups);
-    result.changed = true;
+    ensureGeneratedDependencyTypeImports(sourceFile, result.generatedDependencyGroups);
+    writeGeneratedDepsTypeAlias(sourceFile, className, result.generatedDependencyGroups);
+    sourceFile.organizeImports();
+    result.changed = sourceFile.getFullText() !== beforeText;
     return result;
 }
 export function analyzeSourceFileDependencies(sourceFile, options = {}) {
@@ -84,6 +84,7 @@ export function analyzeSourceFileDependencies(sourceFile, options = {}) {
         warnings: [],
         dependencies: [],
         dependencyGroups: emptyDependencyGroups(),
+        generatedDependencyGroups: emptyGeneratedDependencyGroups(),
     };
     const angularClass = findAngularDecoratedClass(sourceFile);
     result.warnings.push(...angularClass.warnings);
@@ -113,15 +114,20 @@ export function analyzeSourceFileDependencies(sourceFile, options = {}) {
     const metadataDeps = angularKind === 'component' || angularKind === 'directive'
         ? extractDecoratorMetadataDepGroups(classDeclaration, angularKind, normalizedOptions)
         : emptyMetadataDependencyGroups();
+    const providedDeps = angularKind === 'component' || angularKind === 'directive'
+        ? extractProvidedDependencies(sourceFile, classDeclaration, angularKind, normalizedOptions)
+        : { entries: [], warnings: [] };
     const constructorDeps = extractConstructorDeps(classDeclaration);
     const injectCallDeps = extractInjectCallDeps(classDeclaration);
-    result.warnings.push(...metadataDeps.warnings, ...constructorDeps.warnings, ...injectCallDeps.warnings);
+    result.warnings.push(...metadataDeps.warnings, ...providedDeps.warnings, ...constructorDeps.warnings, ...injectCallDeps.warnings);
     result.dependencies = mergeDeps(constructorDeps.dependencies, injectCallDeps.dependencies, metadataDeps.imports, metadataDeps.hostDirectives, metadataDeps.providers, metadataDeps.viewProviders);
     result.dependencyGroups = {
         injected: mergeDeps(constructorDeps.dependencies, injectCallDeps.dependencies),
         importDeps: mergeDeps(metadataDeps.imports, metadataDeps.hostDirectives),
         providers: mergeDeps(metadataDeps.providers, metadataDeps.viewProviders),
     };
+    result.generatedTypeName = getGeneratedDepsTypeName(className);
+    result.generatedDependencyGroups = createGeneratedDependencyGroups(sourceFile, result.dependencyGroups.importDeps, result.dependencyGroups.injected, providedDeps.entries);
     return result;
 }
 export function findAngularDecoratedClass(sourceFile) {
@@ -265,8 +271,199 @@ function emptyDependencyGroups() {
         providers: [],
     };
 }
-function createDepsExpression(dependencyGroups) {
-    return `deps({ injected: [${dependencyGroups.injected.join(', ')}], importDeps: [${dependencyGroups.importDeps.join(', ')}], providers: [${dependencyGroups.providers.join(', ')}] })`;
+function emptyGeneratedDependencyGroups() {
+    return {
+        deps: [],
+        provided: [],
+        missingProvider: [],
+    };
+}
+function getGeneratedDepsTypeName(className) {
+    return `GenDeps_${className}`;
+}
+function createGeneratedDependencyGroups(sourceFile, importDependencies, injectedDependencies, providedEntries) {
+    const deps = mergeGeneratedDependencyEntries(importDependencies.map((dependency) => createGeneratedDependencyEntry(sourceFile, dependency, 'import')), injectedDependencies.map((dependency) => createGeneratedDependencyEntry(sourceFile, dependency, 'inject')));
+    const provided = mergeGeneratedDependencyEntries(providedEntries);
+    const providedKeys = new Set(provided.map((entry) => entry.key));
+    const missingProvider = mergeGeneratedDependencyEntries(injectedDependencies
+        .filter((dependency) => {
+        const dependencyKey = createGeneratedDependencyKey(dependency);
+        return (!providedKeys.has(dependencyKey) &&
+            !isProvidedInInjectableTree(sourceFile, dependency));
+    })
+        .map((dependency) => createGeneratedDependencyEntry(sourceFile, dependency, 'inject')));
+    return {
+        deps,
+        provided,
+        missingProvider,
+    };
+}
+function mergeGeneratedDependencyEntries(...groups) {
+    const entries = new Map();
+    for (const group of groups) {
+        for (const entry of group) {
+            if (!entries.has(entry.key)) {
+                entries.set(entry.key, entry);
+            }
+        }
+    }
+    return [...entries.values()];
+}
+function createGeneratedDependencyEntry(sourceFile, dependencyText, context) {
+    if (context === 'import') {
+        const declarableResolution = resolveAngularDeclarableDependency(sourceFile, dependencyText);
+        if (declarableResolution) {
+            const generatedTypeName = getGeneratedDepsTypeName(declarableResolution.className);
+            return {
+                key: generatedTypeName,
+                typeText: generatedTypeName,
+                typeImport: declarableResolution.moduleSpecifier
+                    ? {
+                        moduleSpecifier: declarableResolution.moduleSpecifier,
+                        name: generatedTypeName,
+                    }
+                    : undefined,
+            };
+        }
+    }
+    return {
+        key: createGeneratedDependencyKey(dependencyText),
+        typeText: createGeneratedDependencyTypeText(sourceFile, dependencyText),
+    };
+}
+function createGeneratedDependencyKey(dependencyText) {
+    var _a;
+    const lastSegment = (_a = dependencyText.split('.').pop()) !== null && _a !== void 0 ? _a : dependencyText;
+    const helperMatch = /^(inject|provide)([A-Z].*)$/.exec(lastSegment);
+    if (helperMatch) {
+        return helperMatch[2];
+    }
+    const toYieldMatch = /^(.*)ToYield$/.exec(lastSegment);
+    if (toYieldMatch === null || toYieldMatch === void 0 ? void 0 : toYieldMatch[1]) {
+        return toYieldMatch[1];
+    }
+    return lastSegment;
+}
+function createGeneratedDependencyTypeText(sourceFile, dependencyText) {
+    if (isHelperLikeDependency(dependencyText)) {
+        return `ReturnType<typeof ${dependencyText}>`;
+    }
+    const resolution = resolveDependencyReference(sourceFile, dependencyText);
+    if (resolution.kind === 'class' || resolution.kind === 'enum') {
+        return dependencyText;
+    }
+    if (resolution.kind === 'unknown') {
+        return dependencyText;
+    }
+    return `typeof ${dependencyText}`;
+}
+function isHelperLikeDependency(dependencyText) {
+    var _a;
+    const lastSegment = (_a = dependencyText.split('.').pop()) !== null && _a !== void 0 ? _a : dependencyText;
+    return (/^(inject|provide)[A-Z].*/.test(lastSegment) || /ToYield$/.test(lastSegment));
+}
+function resolveAngularDeclarableDependency(sourceFile, dependencyText) {
+    const resolution = resolveDependencyReference(sourceFile, dependencyText);
+    if (!resolution.classDeclaration) {
+        return undefined;
+    }
+    const angularKind = getAngularKind(resolution.classDeclaration);
+    if (angularKind !== 'component' &&
+        angularKind !== 'directive' &&
+        angularKind !== 'pipe') {
+        return undefined;
+    }
+    const className = resolution.classDeclaration.getName();
+    if (!className) {
+        return undefined;
+    }
+    const declarationSourceFile = resolution.classDeclaration.getSourceFile();
+    if (declarationSourceFile === sourceFile ||
+        declarationSourceFile.isDeclarationFile()) {
+        return undefined;
+    }
+    return {
+        className,
+        moduleSpecifier: resolution.moduleSpecifier,
+    };
+}
+function ensureGeneratedDependencyTypeImports(sourceFile, generatedDependencyGroups) {
+    var _a;
+    const importsToAdd = new Map();
+    for (const entry of generatedDependencyGroups.deps) {
+        if (!entry.typeImport) {
+            continue;
+        }
+        const importNames = (_a = importsToAdd.get(entry.typeImport.moduleSpecifier)) !== null && _a !== void 0 ? _a : new Set();
+        importNames.add(entry.typeImport.name);
+        importsToAdd.set(entry.typeImport.moduleSpecifier, importNames);
+    }
+    for (const [moduleSpecifier, importNames] of importsToAdd) {
+        const existingImport = sourceFile
+            .getImportDeclarations()
+            .find((importDeclaration) => importDeclaration.getModuleSpecifierValue() === moduleSpecifier);
+        if (existingImport) {
+            existingImport.addNamedImports([...importNames].map((name) => ({ name, isTypeOnly: true })));
+            continue;
+        }
+        sourceFile.addImportDeclaration({
+            moduleSpecifier,
+            namedImports: [...importNames].map((name) => ({
+                name,
+                isTypeOnly: true,
+            })),
+        });
+    }
+}
+function formatGeneratedDependencyType(generatedDependencyGroups) {
+    return [
+        '{',
+        `  deps: ${formatGeneratedDependencyObject(generatedDependencyGroups.deps)};`,
+        `  provided: ${formatGeneratedDependencyObject(generatedDependencyGroups.provided)};`,
+        `  missingProvider: ${formatGeneratedDependencyObject(generatedDependencyGroups.missingProvider)};`,
+        '}',
+    ].join('\n');
+}
+function formatGeneratedDependencyObject(entries) {
+    if (entries.length === 0) {
+        return '{}';
+    }
+    return [
+        '{',
+        ...entries.map((entry) => `    ${formatObjectKey(entry.key)}: ${entry.typeText};`),
+        '  }',
+    ].join('\n');
+}
+function formatObjectKey(key) {
+    return /^[$A-Z_][0-9A-Z_$]*$/i.test(key) ? key : `'${key}'`;
+}
+export function writeGeneratedDepsTypeAlias(sourceFile, className, generatedDependencyGroups) {
+    const generatedTypeName = getGeneratedDepsTypeName(className);
+    const generatedType = `GetDeps<${formatGeneratedDependencyType(generatedDependencyGroups)}>`;
+    const existingTypeAlias = sourceFile.getTypeAlias(generatedTypeName);
+    if (existingTypeAlias) {
+        existingTypeAlias.setIsExported(true);
+        existingTypeAlias.setType(generatedType);
+        return;
+    }
+    sourceFile.addTypeAlias({
+        isExported: true,
+        name: generatedTypeName,
+        type: generatedType,
+    });
+}
+export function migrateLegacyBrandExport(sourceFile, classDeclaration, className) {
+    const existing = readExistingDependencyGroups(sourceFile, className);
+    if (!existing.found || !existing.exportAssignmentNode) {
+        return;
+    }
+    const exportAssignment = existing.exportAssignmentNode.asKind(SyntaxKind.ExportAssignment);
+    exportAssignment === null || exportAssignment === void 0 ? void 0 : exportAssignment.remove();
+    if (!classDeclaration.isDefaultExport() &&
+        !classDeclaration.isExported() &&
+        exportAssignment) {
+        classDeclaration.setIsDefaultExport(true);
+    }
 }
 function invalidExistingDependencyGroups(node, warnings) {
     return {
@@ -327,7 +524,7 @@ function getInjectionHelperDependency(expression) {
     return undefined;
 }
 export function ensureHelperImports(sourceFile, helperImportPath) {
-    const missingImports = ['brandAngularSymbol', 'deps'].filter((importName) => !hasLocalNamedImport(sourceFile, helperImportPath, importName));
+    const missingImports = ['GetDeps'].filter((importName) => !hasLocalNamedImport(sourceFile, helperImportPath, importName));
     if (missingImports.length === 0) {
         return;
     }
@@ -335,35 +532,15 @@ export function ensureHelperImports(sourceFile, helperImportPath) {
         .getImportDeclarations()
         .find((importDeclaration) => importDeclaration.getModuleSpecifierValue() === helperImportPath);
     if (existingImport) {
-        existingImport.addNamedImports(missingImports);
+        existingImport.addNamedImports(missingImports.map((name) => ({ name, isTypeOnly: true })));
         return;
     }
     sourceFile.addImportDeclaration({
         moduleSpecifier: helperImportPath,
-        namedImports: missingImports,
-    });
-}
-export function removeConflictingExports(sourceFile, classDeclaration, className) {
-    if (classDeclaration.isDefaultExport()) {
-        classDeclaration.setIsDefaultExport(false);
-    }
-    if (classDeclaration.isExported()) {
-        classDeclaration.setIsExported(false);
-    }
-    for (const exportAssignment of sourceFile.getExportAssignments()) {
-        if (isDefaultIdentifierExport(exportAssignment, className) ||
-            isDefaultBrandedExport(exportAssignment, className)) {
-            exportAssignment.remove();
-        }
-    }
-    for (const exportDeclaration of sourceFile.getExportDeclarations()) {
-        removeClassFromExportDeclaration(exportDeclaration, className);
-    }
-}
-export function writeDefaultBrandExport(sourceFile, className, dependencyGroups) {
-    sourceFile.addExportAssignment({
-        expression: `brandAngularSymbol(${className}, ${createDepsExpression(dependencyGroups)})`,
-        isExportEquals: false,
+        namedImports: missingImports.map((name) => ({
+            name,
+            isTypeOnly: true,
+        })),
     });
 }
 export function readExistingDependencyGroups(sourceFile, className) {
@@ -594,6 +771,108 @@ function emptyMetadataDependencyGroups() {
         warnings: [],
     };
 }
+function extractProvidedDependencies(sourceFile, classDeclaration, angularKind, options) {
+    const metadata = getDecoratorMetadataObject(classDeclaration);
+    const warnings = [];
+    const entries = [];
+    if (!metadata) {
+        return { entries, warnings };
+    }
+    if (options.includeProviders) {
+        entries.push(...extractProvidedDependencyArrayProperty(sourceFile, metadata, 'providers', warnings));
+    }
+    if (options.includeViewProviders && angularKind === 'component') {
+        entries.push(...extractProvidedDependencyArrayProperty(sourceFile, metadata, 'viewProviders', warnings));
+    }
+    return {
+        entries: mergeGeneratedDependencyEntries(entries),
+        warnings,
+    };
+}
+function extractProvidedDependencyArrayProperty(sourceFile, metadata, propertyName, warnings) {
+    const property = getObjectPropertyAssignment(metadata, propertyName);
+    if (!property) {
+        return [];
+    }
+    const initializer = property.getInitializer();
+    if (!Node.isArrayLiteralExpression(initializer)) {
+        warnings.push(`Skipped metadata property "${propertyName}" because it is not a static array.`);
+        return [];
+    }
+    return extractProvidedDependencyEntriesFromArray(sourceFile, initializer, propertyName, warnings);
+}
+function extractProvidedDependencyEntriesFromArray(sourceFile, arrayLiteral, context, warnings) {
+    const entries = [];
+    for (const element of arrayLiteral.getElements()) {
+        if (Node.isArrayLiteralExpression(element)) {
+            entries.push(...extractProvidedDependencyEntriesFromArray(sourceFile, element, context, warnings));
+            continue;
+        }
+        if (Node.isSpreadElement(element)) {
+            warnings.push(`Skipped spread element in "${context}" metadata providers.`);
+            continue;
+        }
+        if (Node.isCallExpression(element)) {
+            const providerFactory = getStaticExpressionText(element.getExpression());
+            if (!providerFactory) {
+                warnings.push(`Skipped complex provider factory "${element.getText()}" in "${context}".`);
+                continue;
+            }
+            entries.push({
+                key: createGeneratedDependencyKey(providerFactory),
+                typeText: `ReturnType<typeof ${providerFactory}>`,
+            });
+            continue;
+        }
+        const staticExpression = getStaticExpressionText(element);
+        if (staticExpression) {
+            entries.push({
+                key: createGeneratedDependencyKey(staticExpression),
+                typeText: createGeneratedDependencyTypeText(sourceFile, staticExpression),
+            });
+            continue;
+        }
+        if (Node.isObjectLiteralExpression(element)) {
+            const providerEntry = extractProvidedDependencyEntryFromObjectLiteral(sourceFile, element, context, warnings);
+            if (providerEntry) {
+                entries.push(providerEntry);
+            }
+            continue;
+        }
+        warnings.push(`Skipped complex expression "${element.getText()}" in "${context}" metadata providers.`);
+    }
+    return entries;
+}
+function extractProvidedDependencyEntryFromObjectLiteral(sourceFile, objectLiteral, context, warnings) {
+    var _a, _b, _c, _d, _e;
+    const provideProperty = getObjectPropertyAssignment(objectLiteral, 'provide');
+    const provideText = getStaticExpressionText(provideProperty === null || provideProperty === void 0 ? void 0 : provideProperty.getInitializer());
+    if (!provideText) {
+        warnings.push(`Skipped provider object in "${context}" because "provide" is not static.`);
+        return undefined;
+    }
+    const useClass = getStaticExpressionText((_a = getObjectPropertyAssignment(objectLiteral, 'useClass')) === null || _a === void 0 ? void 0 : _a.getInitializer());
+    const useExisting = getStaticExpressionText((_b = getObjectPropertyAssignment(objectLiteral, 'useExisting')) === null || _b === void 0 ? void 0 : _b.getInitializer());
+    const useValue = getStaticExpressionText((_c = getObjectPropertyAssignment(objectLiteral, 'useValue')) === null || _c === void 0 ? void 0 : _c.getInitializer());
+    const useFactory = getStaticExpressionText((_d = getObjectPropertyAssignment(objectLiteral, 'useFactory')) === null || _d === void 0 ? void 0 : _d.getInitializer());
+    if (useFactory) {
+        return {
+            key: createGeneratedDependencyKey(provideText),
+            typeText: `ReturnType<typeof ${useFactory}>`,
+        };
+    }
+    if (useValue) {
+        return {
+            key: createGeneratedDependencyKey(provideText),
+            typeText: `typeof ${useValue}`,
+        };
+    }
+    const valueText = (_e = useClass !== null && useClass !== void 0 ? useClass : useExisting) !== null && _e !== void 0 ? _e : provideText;
+    return {
+        key: createGeneratedDependencyKey(provideText),
+        typeText: createGeneratedDependencyTypeText(sourceFile, valueText),
+    };
+}
 function extractMetadataArrayProperty(metadata, propertyName, context, warnings) {
     const property = getObjectPropertyAssignment(metadata, propertyName);
     if (!property) {
@@ -700,6 +979,134 @@ function getStaticPropertyName(nameNode) {
     }
     return undefined;
 }
+function resolveDependencyReference(sourceFile, dependencyText) {
+    const [rootIdentifier] = dependencyText.split('.');
+    if (!rootIdentifier) {
+        return { kind: 'unknown' };
+    }
+    const importResolution = resolveImportedDependencyReference(sourceFile, dependencyText, rootIdentifier);
+    if (importResolution) {
+        return importResolution;
+    }
+    const localClass = sourceFile.getClass(rootIdentifier);
+    if (localClass) {
+        return { kind: 'class', classDeclaration: localClass };
+    }
+    if (sourceFile.getEnum(rootIdentifier)) {
+        return { kind: 'enum' };
+    }
+    if (sourceFile.getFunction(rootIdentifier)) {
+        return { kind: 'function' };
+    }
+    if (sourceFile
+        .getVariableDeclarations()
+        .some((declaration) => declaration.getName() === rootIdentifier)) {
+        return { kind: 'variable' };
+    }
+    return { kind: 'unknown' };
+}
+function resolveImportedDependencyReference(sourceFile, dependencyText, rootIdentifier) {
+    var _a, _b, _c, _d, _e, _f;
+    for (const importDeclaration of sourceFile.getImportDeclarations()) {
+        const moduleSpecifier = importDeclaration.getModuleSpecifierValue();
+        if (((_a = importDeclaration.getDefaultImport()) === null || _a === void 0 ? void 0 : _a.getText()) === rootIdentifier) {
+            const declaration = getDefaultImportClassDeclaration(importDeclaration);
+            if (declaration) {
+                return {
+                    kind: 'class',
+                    classDeclaration: declaration,
+                    moduleSpecifier,
+                };
+            }
+            return { kind: 'unknown', moduleSpecifier };
+        }
+        if (((_b = importDeclaration.getNamespaceImport()) === null || _b === void 0 ? void 0 : _b.getText()) === rootIdentifier) {
+            const declaration = getNamespaceImportClassDeclaration(importDeclaration, dependencyText);
+            if (declaration) {
+                return {
+                    kind: 'class',
+                    classDeclaration: declaration,
+                    moduleSpecifier,
+                };
+            }
+            return { kind: 'namespace', moduleSpecifier };
+        }
+        const namedImport = importDeclaration
+            .getNamedImports()
+            .find((specifier) => {
+            var _a, _b;
+            const localName = (_b = (_a = specifier.getAliasNode()) === null || _a === void 0 ? void 0 : _a.getText()) !== null && _b !== void 0 ? _b : specifier.getNameNode().getText();
+            return localName === rootIdentifier;
+        });
+        if (!namedImport) {
+            continue;
+        }
+        const localIdentifier = (_c = namedImport.getAliasNode()) !== null && _c !== void 0 ? _c : namedImport.getNameNode();
+        const symbol = (_d = localIdentifier.getSymbol()) !== null && _d !== void 0 ? _d : localIdentifier.getType().getSymbol();
+        const aliasedSymbol = (_e = symbol === null || symbol === void 0 ? void 0 : symbol.getAliasedSymbol()) !== null && _e !== void 0 ? _e : symbol;
+        const declarations = (_f = aliasedSymbol === null || aliasedSymbol === void 0 ? void 0 : aliasedSymbol.getDeclarations()) !== null && _f !== void 0 ? _f : [];
+        const classDeclaration = declarations.find((declaration) => Node.isClassDeclaration(declaration));
+        if (classDeclaration && Node.isClassDeclaration(classDeclaration)) {
+            return {
+                kind: 'class',
+                classDeclaration,
+                moduleSpecifier,
+            };
+        }
+        if (declarations.some((declaration) => Node.isEnumDeclaration(declaration))) {
+            return { kind: 'enum', moduleSpecifier };
+        }
+        if (declarations.some((declaration) => Node.isFunctionDeclaration(declaration))) {
+            return { kind: 'function', moduleSpecifier };
+        }
+        if (declarations.some((declaration) => Node.isVariableDeclaration(declaration))) {
+            return { kind: 'variable', moduleSpecifier };
+        }
+        return { kind: 'unknown', moduleSpecifier };
+    }
+    return undefined;
+}
+function getDefaultImportClassDeclaration(importDeclaration) {
+    var _a;
+    const moduleSourceFile = importDeclaration.getModuleSpecifierSourceFile();
+    if (!moduleSourceFile) {
+        return undefined;
+    }
+    const defaultExportSymbol = moduleSourceFile.getDefaultExportSymbol();
+    const declarations = (_a = defaultExportSymbol === null || defaultExportSymbol === void 0 ? void 0 : defaultExportSymbol.getDeclarations()) !== null && _a !== void 0 ? _a : [];
+    return declarations.find((declaration) => Node.isClassDeclaration(declaration));
+}
+function getNamespaceImportClassDeclaration(importDeclaration, dependencyText) {
+    var _a;
+    const moduleSourceFile = importDeclaration.getModuleSpecifierSourceFile();
+    if (!moduleSourceFile) {
+        return undefined;
+    }
+    const leafIdentifier = dependencyText.split('.').pop();
+    if (!leafIdentifier) {
+        return undefined;
+    }
+    const exportedDeclarations = (_a = moduleSourceFile.getExportedDeclarations().get(leafIdentifier)) !== null && _a !== void 0 ? _a : [];
+    return exportedDeclarations.find((declaration) => Node.isClassDeclaration(declaration));
+}
+function isProvidedInInjectableTree(sourceFile, dependencyText) {
+    const resolution = resolveDependencyReference(sourceFile, dependencyText);
+    const classDeclaration = resolution.classDeclaration;
+    if (!classDeclaration || getAngularKind(classDeclaration) !== 'injectable') {
+        return false;
+    }
+    const metadata = getDecoratorMetadataObject(classDeclaration);
+    const providedInProperty = metadata
+        ? getObjectPropertyAssignment(metadata, 'providedIn')
+        : undefined;
+    const initializer = providedInProperty === null || providedInProperty === void 0 ? void 0 : providedInProperty.getInitializer();
+    if (!initializer) {
+        return false;
+    }
+    return (!Node.isNullLiteral(initializer) &&
+        !Node.isFalseLiteral(initializer) &&
+        !(Node.isIdentifier(initializer) && initializer.getText() === 'undefined'));
+}
 function getDependencyTextFromTypeNode(typeNode) {
     if (isPrimitiveTypeNode(typeNode)) {
         return undefined;
@@ -861,7 +1268,7 @@ function getExportRewriteSafety(sourceFile, classDeclaration, className) {
         : { safe: false, warnings };
 }
 function getHelperImportSafety(sourceFile, helperImportPath) {
-    const warnings = ['brandAngularSymbol', 'deps']
+    const warnings = ['GetDeps']
         .filter((helperName) => hasConflictingTopLevelBinding(sourceFile, helperImportPath, helperName))
         .map((helperName) => `Skipped file because "${helperName}" is already bound to a different top-level symbol.`);
     return warnings.length === 0
@@ -1044,9 +1451,9 @@ function logFileResult(report, log) {
         `file=${report.filePath}`,
         report.angularKind ? `kind=${report.angularKind}` : undefined,
         report.className ? `class=${report.className}` : undefined,
-        `injected=[${report.dependencyGroups.injected.join(', ')}]`,
-        `importDeps=[${report.dependencyGroups.importDeps.join(', ')}]`,
-        `providers=[${report.dependencyGroups.providers.join(', ')}]`,
+        `deps=[${report.generatedDependencyGroups.deps.map((entry) => entry.key).join(', ')}]`,
+        `provided=[${report.generatedDependencyGroups.provided.map((entry) => entry.key).join(', ')}]`,
+        `missingProvider=[${report.generatedDependencyGroups.missingProvider.map((entry) => entry.key).join(', ')}]`,
         `status=${status}`,
     ].filter(Boolean);
     log(details.join(' '));
@@ -1106,16 +1513,19 @@ function printHelpAndExit() {
 Options:
   --root <dir>                                  Project root. Defaults to cwd.
   --tsconfig <path>                            tsconfig path. Defaults to <root>/tsconfig.json.
-  --helper-import <path>                       Import path for brandAngularSymbol and deps.
+  --helper-import <path>                       Import path for GetDeps.
   --transform-only-standalone-declarables      Only transform standalone components/directives.
-  --no-providers                               Do not include metadata providers in deps().
-  --no-view-providers                          Do not include component viewProviders in deps().
+  --no-providers                               Do not include metadata providers in generated types.
+  --no-view-providers                          Do not include component viewProviders in generated types.
   --dry-run                                    Print results without writing files.
   --help                                       Show this help.
 `);
     process.exit(0);
 }
-if (require.main === module) {
+// Check if this module is being run directly (ESM equivalent of require.main === module)
+if (import.meta.url === `file://${process.argv[1]}` ||
+    (import.meta.url.startsWith('file:') &&
+        process.argv[1] === fileURLToPath(import.meta.url))) {
     runAngularBrandCodemod(parseCliArgs(process.argv.slice(2))).catch((error) => {
         console.error(error);
         process.exitCode = 1;