@craft-ng/dev-tools 0.1.4 → 0.1.5

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

@@ -17,6 +17,7 @@ import {
 } from 'ts-morph';
 import { existsSync, readdirSync, statSync } from 'node:fs';
 import { basename, extname, isAbsolute, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
 
 export type AngularKind = 'component' | 'directive' | 'pipe' | 'injectable';
 
@@ -28,6 +29,8 @@ export type TransformResult = {
   className?: string;
   dependencies: string[];
   dependencyGroups: DependencyGroups;
+  generatedTypeName?: string;
+  generatedDependencyGroups: GeneratedDependencyGroups;
 };
 
 export type AngularBrandCodemodOptions = {
@@ -56,6 +59,21 @@ export type DependencyGroups = {
   providers: string[];
 };
 
+export type GeneratedDependencyEntry = {
+  key: string;
+  typeText: string;
+  typeImport?: {
+    moduleSpecifier: string;
+    name: string;
+  };
+};
+
+export type GeneratedDependencyGroups = {
+  deps: GeneratedDependencyEntry[];
+  provided: GeneratedDependencyEntry[];
+  missingProvider: GeneratedDependencyEntry[];
+};
+
 export type DependencyAnalysisResult = Omit<TransformResult, 'changed'> & {
   classDeclaration?: ClassDeclaration;
 };
@@ -77,6 +95,17 @@ type MetadataDependencyGroups = {
   warnings: string[];
 };
 
+type ProvidedDependencyExtractionResult = {
+  entries: GeneratedDependencyEntry[];
+  warnings: string[];
+};
+
+type DependencyReferenceResolution = {
+  kind: 'class' | 'enum' | 'function' | 'variable' | 'namespace' | 'unknown';
+  classDeclaration?: ClassDeclaration;
+  moduleSpecifier?: string;
+};
+
 type NormalizedOptions = Required<AngularBrandCodemodOptions>;
 
 type InjectDecoratorTokenResult =
@@ -170,15 +199,6 @@ export function transformSourceFile(
     return result;
   }
 
-  const exportSafety = getExportRewriteSafety(
-    sourceFile,
-    classDeclaration,
-    className,
-  );
-  if (!exportSafety.safe) {
-    return skip(result, exportSafety.warnings);
-  }
-
   const importSafety = getHelperImportSafety(
     sourceFile,
     normalizedOptions.helperImportPath,
@@ -187,11 +207,22 @@ export function transformSourceFile(
     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);
+  ensureGeneratedDependencyTypeImports(
+    sourceFile,
+    result.generatedDependencyGroups,
+  );
+  writeGeneratedDepsTypeAlias(
+    sourceFile,
+    className,
+    result.generatedDependencyGroups,
+  );
+  sourceFile.organizeImports();
 
-  result.changed = true;
+  result.changed = sourceFile.getFullText() !== beforeText;
   return result;
 }
 
@@ -205,6 +236,7 @@ export function analyzeSourceFileDependencies(
     warnings: [],
     dependencies: [],
     dependencyGroups: emptyDependencyGroups(),
+    generatedDependencyGroups: emptyGeneratedDependencyGroups(),
   };
 
   const angularClass = findAngularDecoratedClass(sourceFile);
@@ -250,11 +282,21 @@ export function analyzeSourceFileDependencies(
           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,
+    ...providedDeps.warnings,
     ...constructorDeps.warnings,
     ...injectCallDeps.warnings,
   );
@@ -274,6 +316,13 @@ export function analyzeSourceFileDependencies(
     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;
 }
@@ -493,8 +542,301 @@ function emptyDependencyGroups(): DependencyGroups {
   };
 }
 
-function createDepsExpression(dependencyGroups: DependencyGroups): string {
-  return `deps({ injected: [${dependencyGroups.injected.join(', ')}], importDeps: [${dependencyGroups.importDeps.join(', ')}], providers: [${dependencyGroups.providers.join(', ')}] })`;
+function emptyGeneratedDependencyGroups(): GeneratedDependencyGroups {
+  return {
+    deps: [],
+    provided: [],
+    missingProvider: [],
+  };
+}
+
+function getGeneratedDepsTypeName(className: string): string {
+  return `GenDeps_${className}`;
+}
+
+function createGeneratedDependencyGroups(
+  sourceFile: SourceFile,
+  importDependencies: string[],
+  injectedDependencies: string[],
+  providedEntries: GeneratedDependencyEntry[],
+): GeneratedDependencyGroups {
+  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: readonly GeneratedDependencyEntry[][]
+): GeneratedDependencyEntry[] {
+  const entries = new Map<string, GeneratedDependencyEntry>();
+
+  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: SourceFile,
+  dependencyText: string,
+  context: 'import' | 'inject',
+): GeneratedDependencyEntry {
+  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: string): string {
+  const lastSegment = dependencyText.split('.').pop() ?? dependencyText;
+  const helperMatch = /^(inject|provide)([A-Z].*)$/.exec(lastSegment);
+  if (helperMatch) {
+    return helperMatch[2];
+  }
+
+  const toYieldMatch = /^(.*)ToYield$/.exec(lastSegment);
+  if (toYieldMatch?.[1]) {
+    return toYieldMatch[1];
+  }
+
+  return lastSegment;
+}
+
+function createGeneratedDependencyTypeText(
+  sourceFile: SourceFile,
+  dependencyText: string,
+): string {
+  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: string): boolean {
+  const lastSegment = dependencyText.split('.').pop() ?? dependencyText;
+  return (
+    /^(inject|provide)[A-Z].*/.test(lastSegment) || /ToYield$/.test(lastSegment)
+  );
+}
+
+function resolveAngularDeclarableDependency(
+  sourceFile: SourceFile,
+  dependencyText: string,
+): { className: string; moduleSpecifier?: string } | undefined {
+  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: SourceFile,
+  generatedDependencyGroups: GeneratedDependencyGroups,
+): void {
+  const importsToAdd = new Map<string, Set<string>>();
+
+  for (const entry of generatedDependencyGroups.deps) {
+    if (!entry.typeImport) {
+      continue;
+    }
+
+    const importNames =
+      importsToAdd.get(entry.typeImport.moduleSpecifier) ?? new Set<string>();
+    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: GeneratedDependencyGroups,
+): string {
+  return [
+    '{',
+    `  deps: ${formatGeneratedDependencyObject(generatedDependencyGroups.deps)};`,
+    `  provided: ${formatGeneratedDependencyObject(generatedDependencyGroups.provided)};`,
+    `  missingProvider: ${formatGeneratedDependencyObject(generatedDependencyGroups.missingProvider)};`,
+    '}',
+  ].join('\n');
+}
+
+function formatGeneratedDependencyObject(
+  entries: GeneratedDependencyEntry[],
+): string {
+  if (entries.length === 0) {
+    return '{}';
+  }
+
+  return [
+    '{',
+    ...entries.map(
+      (entry) => `    ${formatObjectKey(entry.key)}: ${entry.typeText};`,
+    ),
+    '  }',
+  ].join('\n');
+}
+
+function formatObjectKey(key: string): string {
+  return /^[$A-Z_][0-9A-Z_$]*$/i.test(key) ? key : `'${key}'`;
+}
+
+export function writeGeneratedDepsTypeAlias(
+  sourceFile: SourceFile,
+  className: string,
+  generatedDependencyGroups: GeneratedDependencyGroups,
+): void {
+  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: SourceFile,
+  classDeclaration: ClassDeclaration,
+  className: string,
+): void {
+  const existing = readExistingDependencyGroups(sourceFile, className);
+  if (!existing.found || !existing.exportAssignmentNode) {
+    return;
+  }
+
+  const exportAssignment = existing.exportAssignmentNode.asKind(
+    SyntaxKind.ExportAssignment,
+  );
+  exportAssignment?.remove();
+
+  if (
+    !classDeclaration.isDefaultExport() &&
+    !classDeclaration.isExported() &&
+    exportAssignment
+  ) {
+    classDeclaration.setIsDefaultExport(true);
+  }
 }
 
 function invalidExistingDependencyGroups(
@@ -585,7 +927,7 @@ export function ensureHelperImports(
   sourceFile: SourceFile,
   helperImportPath: string,
 ): void {
-  const missingImports = ['brandAngularSymbol', 'deps'].filter(
+  const missingImports = ['GetDeps'].filter(
     (importName) =>
       !hasLocalNamedImport(sourceFile, helperImportPath, importName),
   );
@@ -602,51 +944,18 @@ export function ensureHelperImports(
     );
 
   if (existingImport) {
-    existingImport.addNamedImports(missingImports);
+    existingImport.addNamedImports(
+      missingImports.map((name) => ({ name, isTypeOnly: true })),
+    );
     return;
   }
 
   sourceFile.addImportDeclaration({
     moduleSpecifier: helperImportPath,
-    namedImports: missingImports,
-  });
-}
-
-export function removeConflictingExports(
-  sourceFile: SourceFile,
-  classDeclaration: ClassDeclaration,
-  className: string,
-): void {
-  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: SourceFile,
-  className: string,
-  dependencyGroups: DependencyGroups,
-): void {
-  sourceFile.addExportAssignment({
-    expression: `brandAngularSymbol(${className}, ${createDepsExpression(dependencyGroups)})`,
-    isExportEquals: false,
+    namedImports: missingImports.map((name) => ({
+      name,
+      isTypeOnly: true,
+    })),
   });
 }
 
@@ -996,6 +1305,204 @@ function emptyMetadataDependencyGroups(): MetadataDependencyGroups {
   };
 }
 
+function extractProvidedDependencies(
+  sourceFile: SourceFile,
+  classDeclaration: ClassDeclaration,
+  angularKind: AngularKind,
+  options: NormalizedOptions,
+): ProvidedDependencyExtractionResult {
+  const metadata = getDecoratorMetadataObject(classDeclaration);
+  const warnings: string[] = [];
+  const entries: GeneratedDependencyEntry[] = [];
+
+  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: SourceFile,
+  metadata: ObjectLiteralExpression,
+  propertyName: 'providers' | 'viewProviders',
+  warnings: string[],
+): GeneratedDependencyEntry[] {
+  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: SourceFile,
+  arrayLiteral: ArrayLiteralExpression,
+  context: 'providers' | 'viewProviders',
+  warnings: string[],
+): GeneratedDependencyEntry[] {
+  const entries: GeneratedDependencyEntry[] = [];
+
+  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: SourceFile,
+  objectLiteral: ObjectLiteralExpression,
+  context: 'providers' | 'viewProviders',
+  warnings: string[],
+): GeneratedDependencyEntry | undefined {
+  const provideProperty = getObjectPropertyAssignment(objectLiteral, 'provide');
+  const provideText = getStaticExpressionText(
+    provideProperty?.getInitializer(),
+  );
+
+  if (!provideText) {
+    warnings.push(
+      `Skipped provider object in "${context}" because "provide" is not static.`,
+    );
+    return undefined;
+  }
+
+  const useClass = getStaticExpressionText(
+    getObjectPropertyAssignment(objectLiteral, 'useClass')?.getInitializer(),
+  );
+  const useExisting = getStaticExpressionText(
+    getObjectPropertyAssignment(objectLiteral, 'useExisting')?.getInitializer(),
+  );
+  const useValue = getStaticExpressionText(
+    getObjectPropertyAssignment(objectLiteral, 'useValue')?.getInitializer(),
+  );
+  const useFactory = getStaticExpressionText(
+    getObjectPropertyAssignment(objectLiteral, 'useFactory')?.getInitializer(),
+  );
+
+  if (useFactory) {
+    return {
+      key: createGeneratedDependencyKey(provideText),
+      typeText: `ReturnType<typeof ${useFactory}>`,
+    };
+  }
+
+  if (useValue) {
+    return {
+      key: createGeneratedDependencyKey(provideText),
+      typeText: `typeof ${useValue}`,
+    };
+  }
+
+  const valueText = useClass ?? useExisting ?? provideText;
+  return {
+    key: createGeneratedDependencyKey(provideText),
+    typeText: createGeneratedDependencyTypeText(sourceFile, valueText),
+  };
+}
+
 function extractMetadataArrayProperty(
   metadata: ObjectLiteralExpression,
   propertyName: string,
@@ -1166,6 +1673,208 @@ function getStaticPropertyName(nameNode: Node): string | undefined {
   return undefined;
 }
 
+function resolveDependencyReference(
+  sourceFile: SourceFile,
+  dependencyText: string,
+): DependencyReferenceResolution {
+  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: SourceFile,
+  dependencyText: string,
+  rootIdentifier: string,
+): DependencyReferenceResolution | undefined {
+  for (const importDeclaration of sourceFile.getImportDeclarations()) {
+    const moduleSpecifier = importDeclaration.getModuleSpecifierValue();
+
+    if (importDeclaration.getDefaultImport()?.getText() === rootIdentifier) {
+      const declaration = getDefaultImportClassDeclaration(importDeclaration);
+      if (declaration) {
+        return {
+          kind: 'class',
+          classDeclaration: declaration,
+          moduleSpecifier,
+        };
+      }
+
+      return { kind: 'unknown', moduleSpecifier };
+    }
+
+    if (importDeclaration.getNamespaceImport()?.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) => {
+        const localName =
+          specifier.getAliasNode()?.getText() ??
+          specifier.getNameNode().getText();
+        return localName === rootIdentifier;
+      });
+
+    if (!namedImport) {
+      continue;
+    }
+
+    const localIdentifier =
+      namedImport.getAliasNode() ?? namedImport.getNameNode();
+    const symbol =
+      localIdentifier.getSymbol() ?? localIdentifier.getType().getSymbol();
+    const aliasedSymbol = symbol?.getAliasedSymbol() ?? symbol;
+    const declarations = aliasedSymbol?.getDeclarations() ?? [];
+    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: import('ts-morph').ImportDeclaration,
+): ClassDeclaration | undefined {
+  const moduleSourceFile = importDeclaration.getModuleSpecifierSourceFile();
+  if (!moduleSourceFile) {
+    return undefined;
+  }
+
+  const defaultExportSymbol = moduleSourceFile.getDefaultExportSymbol();
+  const declarations = defaultExportSymbol?.getDeclarations() ?? [];
+  return declarations.find((declaration) =>
+    Node.isClassDeclaration(declaration),
+  ) as ClassDeclaration | undefined;
+}
+
+function getNamespaceImportClassDeclaration(
+  importDeclaration: import('ts-morph').ImportDeclaration,
+  dependencyText: string,
+): ClassDeclaration | undefined {
+  const moduleSourceFile = importDeclaration.getModuleSpecifierSourceFile();
+  if (!moduleSourceFile) {
+    return undefined;
+  }
+
+  const leafIdentifier = dependencyText.split('.').pop();
+  if (!leafIdentifier) {
+    return undefined;
+  }
+
+  const exportedDeclarations =
+    moduleSourceFile.getExportedDeclarations().get(leafIdentifier) ?? [];
+  return exportedDeclarations.find((declaration) =>
+    Node.isClassDeclaration(declaration),
+  ) as ClassDeclaration | undefined;
+}
+
+function isProvidedInInjectableTree(
+  sourceFile: SourceFile,
+  dependencyText: string,
+): boolean {
+  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?.getInitializer();
+
+  if (!initializer) {
+    return false;
+  }
+
+  return (
+    !Node.isNullLiteral(initializer) &&
+    !Node.isFalseLiteral(initializer) &&
+    !(Node.isIdentifier(initializer) && initializer.getText() === 'undefined')
+  );
+}
+
 function getDependencyTextFromTypeNode(typeNode: TypeNode): string | undefined {
   if (isPrimitiveTypeNode(typeNode)) {
     return undefined;
@@ -1415,7 +2124,7 @@ function getHelperImportSafety(
   sourceFile: SourceFile,
   helperImportPath: string,
 ): { safe: true; warnings: [] } | { safe: false; warnings: string[] } {
-  const warnings = ['brandAngularSymbol', 'deps']
+  const warnings = ['GetDeps']
     .filter((helperName) =>
       hasConflictingTopLevelBinding(sourceFile, helperImportPath, helperName),
     )
@@ -1680,9 +2389,9 @@ function logFileResult(
     `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);
 
@@ -1760,17 +2469,22 @@ function printHelpAndExit(): never {
 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: unknown) => {
       console.error(error);