@craft-ng/dev-tools 0.1.4 → 0.1.6

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,44 @@ type MetadataDependencyGroups = {
   warnings: string[];
 };
 
+type ProvidedDependencyExtractionResult = {
+  entries: GeneratedDependencyEntry[];
+  warnings: string[];
+};
+
+type InjectedDependencyDescriptor = {
+  dependencyText: string;
+  entry: GeneratedDependencyEntry;
+};
+
+type InjectCallDependencyExtractionResult = DependencyExtractionResult & {
+  generatedDependencies: InjectedDependencyDescriptor[];
+};
+
+type DependencyReferenceResolution = {
+  kind: 'class' | 'enum' | 'function' | 'variable' | 'namespace' | 'unknown';
+  classDeclaration?: ClassDeclaration;
+  moduleSpecifier?: string;
+};
+
+type TrackedHelperResolution = {
+  serviceName: string;
+  scope: string;
+};
+
+type HelperExposureBinding = {
+  localName: string;
+  sourceKey: string;
+};
+
+type HelperExposureTracking = {
+  usedProperties: string[];
+  exposedProperties: Array<{
+    exposedKey: string;
+    sourceKey: string;
+  }>;
+};
+
 type NormalizedOptions = Required<AngularBrandCodemodOptions>;
 
 type InjectDecoratorTokenResult =
@@ -170,15 +226,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 +234,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 +263,7 @@ export function analyzeSourceFileDependencies(
     warnings: [],
     dependencies: [],
     dependencyGroups: emptyDependencyGroups(),
+    generatedDependencyGroups: emptyGeneratedDependencyGroups(),
   };
 
   const angularClass = findAngularDecoratedClass(sourceFile);
@@ -250,11 +309,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 +343,19 @@ 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,
+    [
+      ...constructorDeps.dependencies.map((dependencyText) => ({
+        dependencyText,
+        entry: createGeneratedDependencyEntry(sourceFile, dependencyText, 'inject'),
+      })),
+      ...injectCallDeps.generatedDependencies,
+    ],
+    providedDeps.entries,
+  );
 
   return result;
 }
@@ -436,9 +518,11 @@ export function extractConstructorDeps(
 
 export function extractInjectCallDeps(
   classDeclaration: ClassDeclaration,
-): DependencyExtractionResult {
+): InjectCallDependencyExtractionResult {
   const warnings: string[] = [];
   const dependencies: string[] = [];
+  const generatedDependencies: InjectedDependencyDescriptor[] = [];
+  const sourceFile = classDeclaration.getSourceFile();
 
   for (const callExpression of classDeclaration.getDescendantsOfKind(
     SyntaxKind.CallExpression,
@@ -462,9 +546,25 @@ export function extractInjectCallDeps(
     }
 
     dependencies.push(dependency);
+    generatedDependencies.push({
+      dependencyText: dependency,
+      entry:
+        injectMethodName === 'inject'
+          ? createGeneratedDependencyEntry(sourceFile, dependency, 'inject')
+          : createGeneratedInjectHelperDependencyEntry(
+              sourceFile,
+              callExpression,
+              expression,
+              dependency,
+            ),
+    });
   }
 
-  return { dependencies: mergeDeps(dependencies), warnings };
+  return {
+    dependencies: mergeDeps(dependencies),
+    warnings,
+    generatedDependencies,
+  };
 }
 
 export function mergeDeps(...dependencyGroups: readonly string[][]): string[] {
@@ -493,8 +593,651 @@ 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: InjectedDependencyDescriptor[],
+  providedEntries: GeneratedDependencyEntry[],
+): GeneratedDependencyGroups {
+  const deps = mergeGeneratedDependencyEntries(
+    importDependencies.map((dependency) =>
+      createGeneratedDependencyEntry(sourceFile, dependency, 'import'),
+    ),
+    injectedDependencies.map((dependency) => dependency.entry),
+  );
+  const provided = mergeGeneratedDependencyEntries(providedEntries);
+  const providedKeys = new Set(provided.map((entry) => entry.key));
+  const injectedEntriesByKey = new Map(
+    injectedDependencies.map((dependency) => [dependency.entry.key, dependency.entry]),
+  );
+  const missingProvider = mergeGeneratedDependencyEntries(
+    injectedDependencies
+      .filter((dependency) => {
+        const dependencyKey = dependency.entry.key;
+        return (
+          !providedKeys.has(dependencyKey) &&
+          !isDependencyProvidedElsewhere(sourceFile, dependency.dependencyText)
+        );
+      })
+      .map((dependency) =>
+        injectedEntriesByKey.get(dependency.entry.key) ??
+        createGeneratedDependencyEntry(
+          sourceFile,
+          dependency.dependencyText,
+          '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 createGeneratedInjectHelperDependencyEntry(
+  sourceFile: SourceFile,
+  callExpression: import('ts-morph').CallExpression,
+  expression: Node,
+  dependencyText: string,
+): GeneratedDependencyEntry {
+  const trackedHelper = resolveTrackedInjectHelper(expression);
+  if (!trackedHelper) {
+    return createGeneratedDependencyEntry(sourceFile, dependencyText, 'inject');
+  }
+
+  const exposureTracking = extractHelperExposureTracking(callExpression);
+
+  return {
+    key: trackedHelper.serviceName,
+    typeText: createTrackedInjectHelperTypeText(
+      dependencyText,
+      exposureTracking,
+    ),
+  };
+}
+
+function createTrackedInjectHelperTypeText(
+  dependencyText: string,
+  exposureTracking: HelperExposureTracking | undefined,
+): string {
+  const baseType = `GetInjectedServiceDependencies<typeof ${dependencyText}>`;
+  if (!exposureTracking) {
+    return [baseType + ' & {', '  usesWholeService: true;', '}'].join('\n');
+  }
+
+  return [
+    `${baseType} & {`,
+    `  derivedPropertiesUsed: ${formatHelperExposurePropertiesType(
+      dependencyText,
+      exposureTracking.usedProperties.map((sourceKey) => ({
+        propertyKey: sourceKey,
+        sourceKey,
+      })),
+    )};`,
+    `  derivedPropertiesExposed: ${formatHelperExposurePropertiesType(
+      dependencyText,
+      exposureTracking.exposedProperties.map(
+        ({ exposedKey, sourceKey }) => ({
+          propertyKey: exposedKey,
+          sourceKey,
+        }),
+      ),
+    )};`,
+    '}',
+  ].join('\n');
+}
+
+function formatHelperExposurePropertiesType(
+  dependencyText: string,
+  properties: Array<{ propertyKey: string; sourceKey: string }>,
+): string {
+  if (properties.length === 0) {
+    return '{}';
+  }
+
+  return [
+    '{',
+    ...properties.map(
+      ({ propertyKey, sourceKey }) =>
+        `    ${formatObjectKey(propertyKey)}: ${createTrackedHelperOutputTypeText(
+          dependencyText,
+          sourceKey,
+        )};`,
+    ),
+    '  }',
+  ].join('\n');
+}
+
+function createTrackedHelperOutputTypeText(
+  dependencyText: string,
+  sourceKey: string,
+): string {
+  if (sourceKey === '$self') {
+    return `GetServiceOutput<typeof ${dependencyText}>`;
+  }
+
+  return `GetServiceOutput<typeof ${dependencyText}>[${JSON.stringify(sourceKey)}]`;
+}
+
+function resolveTrackedInjectHelper(
+  expression: Node,
+): TrackedHelperResolution | undefined {
+  const symbol = expression.getSymbol() ?? expression.getType().getSymbol();
+  const declarations =
+    symbol?.getAliasedSymbol()?.getDeclarations() ?? symbol?.getDeclarations() ?? [];
+
+  for (const declaration of declarations) {
+    const helper = resolveTrackedInjectHelperFromDeclaration(declaration);
+    if (helper) {
+      return helper;
+    }
+  }
+
+  return undefined;
+}
+
+function resolveTrackedInjectHelperFromDeclaration(
+  declaration: Node,
+): TrackedHelperResolution | undefined {
+  if (!Node.isBindingElement(declaration)) {
+    return undefined;
+  }
+
+  const objectBindingPattern = declaration.getFirstAncestorByKind(
+    SyntaxKind.ObjectBindingPattern,
+  );
+  const variableDeclaration =
+    objectBindingPattern?.getFirstAncestorByKind(SyntaxKind.VariableDeclaration);
+  const initializer = variableDeclaration?.getInitializer();
+  if (!Node.isCallExpression(initializer) || !isServiceFactoryCall(initializer)) {
+    return undefined;
+  }
+
+  const [optionsArgument] = initializer.getArguments();
+  if (!Node.isObjectLiteralExpression(optionsArgument)) {
+    return undefined;
+  }
+
+  const nameInitializer = getObjectPropertyAssignment(
+    optionsArgument,
+    'name',
+  )?.getInitializer();
+  const scopeInitializer = getObjectPropertyAssignment(
+    optionsArgument,
+    'scope',
+  )?.getInitializer();
+
+  if (
+    !Node.isStringLiteral(nameInitializer) ||
+    !Node.isStringLiteral(scopeInitializer)
+  ) {
+    return undefined;
+  }
+
+  return {
+    serviceName: nameInitializer.getLiteralText(),
+    scope: scopeInitializer.getLiteralText(),
+  };
+}
+
+function isServiceFactoryCall(
+  callExpression: import('ts-morph').CallExpression,
+): boolean {
+  const expression = callExpression.getExpression();
+  if (Node.isIdentifier(expression)) {
+    return expression.getText() === 'craftService' || expression.getText() === 'toCraftService';
+  }
+
+  if (Node.isPropertyAccessExpression(expression)) {
+    const methodName = expression.getName();
+    return methodName === 'craftService' || methodName === 'toCraftService';
+  }
+
+  return false;
+}
+
+function extractHelperExposureTracking(
+  callExpression: import('ts-morph').CallExpression,
+): HelperExposureTracking | undefined {
+  const exposeArgument = [...callExpression.getArguments()]
+    .reverse()
+    .find(
+      (argument) =>
+        Node.isArrowFunction(argument) || Node.isFunctionExpression(argument),
+    );
+
+  if (
+    !exposeArgument ||
+    (!Node.isArrowFunction(exposeArgument) &&
+      !Node.isFunctionExpression(exposeArgument))
+  ) {
+    return undefined;
+  }
+
+  const parameter = exposeArgument.getParameters()[0];
+  const nameNode = parameter?.getNameNode();
+  if (!nameNode || !Node.isObjectBindingPattern(nameNode)) {
+    return undefined;
+  }
+
+  const bindings = extractHelperExposureBindings(nameNode);
+  if (bindings.length === 0) {
+    return undefined;
+  }
+
+  const returnObjectLiteral = getExposureReturnObjectLiteral(exposeArgument);
+  if (!returnObjectLiteral) {
+    return undefined;
+  }
+
+  const exposedProperties = extractHelperExposedProperties(
+    returnObjectLiteral,
+    bindings,
+  );
+  const usedProperties = mergeDeps(
+    exposedProperties.map(({ sourceKey }) => sourceKey),
+    extractHelperYieldedProperties(exposeArgument, bindings),
+  );
+
+  return {
+    usedProperties,
+    exposedProperties,
+  };
+}
+
+function extractHelperExposureBindings(
+  bindingPattern: import('ts-morph').ObjectBindingPattern,
+): HelperExposureBinding[] {
+  const bindings: HelperExposureBinding[] = [];
+
+  for (const element of bindingPattern.getElements()) {
+    const nameNode = element.getNameNode();
+    if (!Node.isIdentifier(nameNode)) {
+      continue;
+    }
+
+    const propertyNameNode = element.getPropertyNameNode();
+    const sourceKey =
+      getStaticPropertyName(propertyNameNode ?? nameNode) ?? nameNode.getText();
+
+    bindings.push({
+      localName: nameNode.getText(),
+      sourceKey,
+    });
+  }
+
+  return bindings;
+}
+
+function getExposureReturnObjectLiteral(
+  exposeArgument: import('ts-morph').ArrowFunction | import('ts-morph').FunctionExpression,
+): ObjectLiteralExpression | undefined {
+  const body = exposeArgument.getBody();
+  if (Node.isObjectLiteralExpression(body)) {
+    return body;
+  }
+
+  if (Node.isParenthesizedExpression(body)) {
+    const expression = body.getExpression();
+    return Node.isObjectLiteralExpression(expression) ? expression : undefined;
+  }
+
+  if (!Node.isBlock(body)) {
+    return undefined;
+  }
+
+  const returnStatement = [...body.getDescendantsOfKind(SyntaxKind.ReturnStatement)]
+    .reverse()
+    .find((statement) => Node.isObjectLiteralExpression(statement.getExpression()));
+
+  const expression = returnStatement?.getExpression();
+  return Node.isObjectLiteralExpression(expression) ? expression : undefined;
+}
+
+function extractHelperExposedProperties(
+  objectLiteral: ObjectLiteralExpression,
+  bindings: HelperExposureBinding[],
+): Array<{ exposedKey: string; sourceKey: string }> {
+  const bindingMap = new Map(
+    bindings.map((binding) => [binding.localName, binding.sourceKey]),
+  );
+  const exposedProperties: Array<{ exposedKey: string; sourceKey: string }> = [];
+
+  for (const property of objectLiteral.getProperties()) {
+    if (Node.isShorthandPropertyAssignment(property)) {
+      const sourceKey = bindingMap.get(property.getName());
+      if (sourceKey) {
+        exposedProperties.push({
+          exposedKey: property.getName(),
+          sourceKey,
+        });
+      }
+      continue;
+    }
+
+    if (!Node.isPropertyAssignment(property)) {
+      continue;
+    }
+
+    const exposedKey = getStaticPropertyName(property.getNameNode());
+    const initializer = property.getInitializer();
+    if (!exposedKey || !Node.isIdentifier(initializer)) {
+      continue;
+    }
+
+    const sourceKey = bindingMap.get(initializer.getText());
+    if (!sourceKey) {
+      continue;
+    }
+
+    exposedProperties.push({
+      exposedKey,
+      sourceKey,
+    });
+  }
+
+  return exposedProperties;
+}
+
+function extractHelperYieldedProperties(
+  exposeArgument: import('ts-morph').ArrowFunction | import('ts-morph').FunctionExpression,
+  bindings: HelperExposureBinding[],
+): string[] {
+  const bindingMap = new Map(
+    bindings.map((binding) => [binding.localName, binding.sourceKey]),
+  );
+  const yieldedProperties: string[] = [];
+
+  for (const yieldExpression of exposeArgument.getDescendantsOfKind(
+    SyntaxKind.YieldExpression,
+  )) {
+    const expression = yieldExpression.getExpression();
+    if (!Node.isCallExpression(expression)) {
+      continue;
+    }
+
+    const target = expression.getExpression();
+    if (!Node.isIdentifier(target)) {
+      continue;
+    }
+
+    const sourceKey = bindingMap.get(target.getText());
+    if (sourceKey) {
+      yieldedProperties.push(sourceKey);
+    }
+  }
+
+  return yieldedProperties;
+}
+
+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) => formatGeneratedDependencyEntry(entry)),
+    '  }',
+  ].join('\n');
+}
+
+function formatGeneratedDependencyEntry(entry: GeneratedDependencyEntry): string {
+  const typeLines = entry.typeText.split('\n');
+  const lines = [
+    `    ${formatObjectKey(entry.key)}: ${typeLines[0]}`,
+    ...typeLines.slice(1).map((line) => `    ${line}`),
+  ];
+  lines[lines.length - 1] += ';';
+  return lines.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,68 +1328,39 @@ export function ensureHelperImports(
   sourceFile: SourceFile,
   helperImportPath: string,
 ): void {
-  const missingImports = ['brandAngularSymbol', 'deps'].filter(
+  const missingImports = [
+    'GetDeps',
+    'GetInjectedServiceDependencies',
+    'GetServiceOutput',
+  ].filter(
     (importName) =>
       !hasLocalNamedImport(sourceFile, helperImportPath, importName),
   );
 
-  if (missingImports.length === 0) {
-    return;
-  }
-
-  const existingImport = sourceFile
-    .getImportDeclarations()
-    .find(
-      (importDeclaration) =>
-        importDeclaration.getModuleSpecifierValue() === helperImportPath,
-    );
-
-  if (existingImport) {
-    existingImport.addNamedImports(missingImports);
-    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);
+  if (missingImports.length === 0) {
+    return;
   }
 
-  for (const exportAssignment of sourceFile.getExportAssignments()) {
-    if (
-      isDefaultIdentifierExport(exportAssignment, className) ||
-      isDefaultBrandedExport(exportAssignment, className)
-    ) {
-      exportAssignment.remove();
-    }
-  }
+  const existingImport = sourceFile
+    .getImportDeclarations()
+    .find(
+      (importDeclaration) =>
+        importDeclaration.getModuleSpecifierValue() === helperImportPath,
+    );
 
-  for (const exportDeclaration of sourceFile.getExportDeclarations()) {
-    removeClassFromExportDeclaration(exportDeclaration, className);
+  if (existingImport) {
+    existingImport.addNamedImports(
+      missingImports.map((name) => ({ name, isTypeOnly: true })),
+    );
+    return;
   }
-}
 
-export function writeDefaultBrandExport(
-  sourceFile: SourceFile,
-  className: string,
-  dependencyGroups: DependencyGroups,
-): void {
-  sourceFile.addExportAssignment({
-    expression: `brandAngularSymbol(${className}, ${createDepsExpression(dependencyGroups)})`,
-    isExportEquals: false,
+  sourceFile.addImportDeclaration({
+    moduleSpecifier: helperImportPath,
+    namedImports: missingImports.map((name) => ({
+      name,
+      isTypeOnly: true,
+    })),
   });
 }
 
@@ -996,6 +1710,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 +2078,268 @@ 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 isDependencyProvidedElsewhere(
+  sourceFile: SourceFile,
+  dependencyText: string,
+): boolean {
+  const trackedHelper = resolveTrackedInjectHelperByName(sourceFile, dependencyText);
+  if (trackedHelper) {
+    return trackedHelper.scope === 'global' || trackedHelper.scope === 'function';
+  }
+
+  return isProvidedInInjectableTree(sourceFile, dependencyText);
+}
+
+function resolveTrackedInjectHelperByName(
+  sourceFile: SourceFile,
+  dependencyText: string,
+): TrackedHelperResolution | undefined {
+  const [rootIdentifier] = dependencyText.split('.');
+  if (!rootIdentifier) {
+    return undefined;
+  }
+
+  for (const declaration of resolveDependencyIdentifierDeclarations(
+    sourceFile,
+    rootIdentifier,
+  )) {
+    const helper = resolveTrackedInjectHelperFromDeclaration(declaration);
+    if (helper) {
+      return helper;
+    }
+  }
+
+  return undefined;
+}
+
+function resolveDependencyIdentifierDeclarations(
+  sourceFile: SourceFile,
+  rootIdentifier: string,
+): Node[] {
+  for (const importDeclaration of sourceFile.getImportDeclarations()) {
+    const namedImport = importDeclaration.getNamedImports().find((specifier) => {
+      const localName =
+        specifier.getAliasNode()?.getText() ?? specifier.getNameNode().getText();
+      return localName === rootIdentifier;
+    });
+
+    if (!namedImport) {
+      continue;
+    }
+
+    const identifier = namedImport.getAliasNode() ?? namedImport.getNameNode();
+    const symbol = identifier.getSymbol() ?? identifier.getType().getSymbol();
+    const aliasedSymbol = symbol?.getAliasedSymbol() ?? symbol;
+    return aliasedSymbol?.getDeclarations() ?? [namedImport];
+  }
+
+  return sourceFile
+    .getDescendantsOfKind(SyntaxKind.BindingElement)
+    .filter((bindingElement) => bindingElement.getName() === rootIdentifier);
+}
+
 function getDependencyTextFromTypeNode(typeNode: TypeNode): string | undefined {
   if (isPrimitiveTypeNode(typeNode)) {
     return undefined;
@@ -1415,7 +2589,11 @@ function getHelperImportSafety(
   sourceFile: SourceFile,
   helperImportPath: string,
 ): { safe: true; warnings: [] } | { safe: false; warnings: string[] } {
-  const warnings = ['brandAngularSymbol', 'deps']
+  const warnings = [
+    'GetDeps',
+    'GetInjectedServiceDependencies',
+    'GetServiceOutput',
+  ]
     .filter((helperName) =>
       hasConflictingTopLevelBinding(sourceFile, helperImportPath, helperName),
     )
@@ -1680,9 +2858,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 +2938,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);