@craft-ng/dev-tools 0.1.4 → 0.1.6

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,26 @@ 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, [
+        ...constructorDeps.dependencies.map((dependencyText) => ({
+            dependencyText,
+            entry: createGeneratedDependencyEntry(sourceFile, dependencyText, 'inject'),
+        })),
+        ...injectCallDeps.generatedDependencies,
+    ], providedDeps.entries);
     return result;
 }
 export function findAngularDecoratedClass(sourceFile) {
@@ -227,6 +239,8 @@ export function extractInjectCallDeps(classDeclaration) {
     var _a;
     const warnings = [];
     const dependencies = [];
+    const generatedDependencies = [];
+    const sourceFile = classDeclaration.getSourceFile();
     for (const callExpression of classDeclaration.getDescendantsOfKind(SyntaxKind.CallExpression)) {
         const expression = callExpression.getExpression();
         const injectMethodName = getInjectMethodName(expression);
@@ -241,8 +255,18 @@ export function extractInjectCallDeps(classDeclaration) {
             continue;
         }
         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) {
     const seen = new Set();
@@ -265,8 +289,422 @@ 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) => 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) => {
+        var _a;
+        return (_a = injectedEntriesByKey.get(dependency.entry.key)) !== null && _a !== void 0 ? _a : createGeneratedDependencyEntry(sourceFile, dependency.dependencyText, '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 createGeneratedInjectHelperDependencyEntry(sourceFile, callExpression, expression, dependencyText) {
+    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, exposureTracking) {
+    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, properties) {
+    if (properties.length === 0) {
+        return '{}';
+    }
+    return [
+        '{',
+        ...properties.map(({ propertyKey, sourceKey }) => `    ${formatObjectKey(propertyKey)}: ${createTrackedHelperOutputTypeText(dependencyText, sourceKey)};`),
+        '  }',
+    ].join('\n');
+}
+function createTrackedHelperOutputTypeText(dependencyText, sourceKey) {
+    if (sourceKey === '$self') {
+        return `GetServiceOutput<typeof ${dependencyText}>`;
+    }
+    return `GetServiceOutput<typeof ${dependencyText}>[${JSON.stringify(sourceKey)}]`;
+}
+function resolveTrackedInjectHelper(expression) {
+    var _a, _b, _c, _d;
+    const symbol = (_a = expression.getSymbol()) !== null && _a !== void 0 ? _a : expression.getType().getSymbol();
+    const declarations = (_d = (_c = (_b = symbol === null || symbol === void 0 ? void 0 : symbol.getAliasedSymbol()) === null || _b === void 0 ? void 0 : _b.getDeclarations()) !== null && _c !== void 0 ? _c : symbol === null || symbol === void 0 ? void 0 : symbol.getDeclarations()) !== null && _d !== void 0 ? _d : [];
+    for (const declaration of declarations) {
+        const helper = resolveTrackedInjectHelperFromDeclaration(declaration);
+        if (helper) {
+            return helper;
+        }
+    }
+    return undefined;
+}
+function resolveTrackedInjectHelperFromDeclaration(declaration) {
+    var _a, _b;
+    if (!Node.isBindingElement(declaration)) {
+        return undefined;
+    }
+    const objectBindingPattern = declaration.getFirstAncestorByKind(SyntaxKind.ObjectBindingPattern);
+    const variableDeclaration = objectBindingPattern === null || objectBindingPattern === void 0 ? void 0 : objectBindingPattern.getFirstAncestorByKind(SyntaxKind.VariableDeclaration);
+    const initializer = variableDeclaration === null || variableDeclaration === void 0 ? void 0 : variableDeclaration.getInitializer();
+    if (!Node.isCallExpression(initializer) || !isServiceFactoryCall(initializer)) {
+        return undefined;
+    }
+    const [optionsArgument] = initializer.getArguments();
+    if (!Node.isObjectLiteralExpression(optionsArgument)) {
+        return undefined;
+    }
+    const nameInitializer = (_a = getObjectPropertyAssignment(optionsArgument, 'name')) === null || _a === void 0 ? void 0 : _a.getInitializer();
+    const scopeInitializer = (_b = getObjectPropertyAssignment(optionsArgument, 'scope')) === null || _b === void 0 ? void 0 : _b.getInitializer();
+    if (!Node.isStringLiteral(nameInitializer) ||
+        !Node.isStringLiteral(scopeInitializer)) {
+        return undefined;
+    }
+    return {
+        serviceName: nameInitializer.getLiteralText(),
+        scope: scopeInitializer.getLiteralText(),
+    };
+}
+function isServiceFactoryCall(callExpression) {
+    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) {
+    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 === null || parameter === void 0 ? void 0 : 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) {
+    var _a;
+    const bindings = [];
+    for (const element of bindingPattern.getElements()) {
+        const nameNode = element.getNameNode();
+        if (!Node.isIdentifier(nameNode)) {
+            continue;
+        }
+        const propertyNameNode = element.getPropertyNameNode();
+        const sourceKey = (_a = getStaticPropertyName(propertyNameNode !== null && propertyNameNode !== void 0 ? propertyNameNode : nameNode)) !== null && _a !== void 0 ? _a : nameNode.getText();
+        bindings.push({
+            localName: nameNode.getText(),
+            sourceKey,
+        });
+    }
+    return bindings;
+}
+function getExposureReturnObjectLiteral(exposeArgument) {
+    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 === null || returnStatement === void 0 ? void 0 : returnStatement.getExpression();
+    return Node.isObjectLiteralExpression(expression) ? expression : undefined;
+}
+function extractHelperExposedProperties(objectLiteral, bindings) {
+    const bindingMap = new Map(bindings.map((binding) => [binding.localName, binding.sourceKey]));
+    const exposedProperties = [];
+    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, bindings) {
+    const bindingMap = new Map(bindings.map((binding) => [binding.localName, binding.sourceKey]));
+    const yieldedProperties = [];
+    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) {
+    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) => formatGeneratedDependencyEntry(entry)),
+        '  }',
+    ].join('\n');
+}
+function formatGeneratedDependencyEntry(entry) {
+    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) {
+    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 +765,11 @@ function getInjectionHelperDependency(expression) {
     return undefined;
 }
 export function ensureHelperImports(sourceFile, helperImportPath) {
-    const missingImports = ['brandAngularSymbol', 'deps'].filter((importName) => !hasLocalNamedImport(sourceFile, helperImportPath, importName));
+    const missingImports = [
+        'GetDeps',
+        'GetInjectedServiceDependencies',
+        'GetServiceOutput',
+    ].filter((importName) => !hasLocalNamedImport(sourceFile, helperImportPath, importName));
     if (missingImports.length === 0) {
         return;
     }
@@ -335,35 +777,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 +1016,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 +1224,174 @@ 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 isDependencyProvidedElsewhere(sourceFile, dependencyText) {
+    const trackedHelper = resolveTrackedInjectHelperByName(sourceFile, dependencyText);
+    if (trackedHelper) {
+        return trackedHelper.scope === 'global' || trackedHelper.scope === 'function';
+    }
+    return isProvidedInInjectableTree(sourceFile, dependencyText);
+}
+function resolveTrackedInjectHelperByName(sourceFile, dependencyText) {
+    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, rootIdentifier) {
+    var _a, _b, _c, _d;
+    for (const importDeclaration of sourceFile.getImportDeclarations()) {
+        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 identifier = (_a = namedImport.getAliasNode()) !== null && _a !== void 0 ? _a : namedImport.getNameNode();
+        const symbol = (_b = identifier.getSymbol()) !== null && _b !== void 0 ? _b : identifier.getType().getSymbol();
+        const aliasedSymbol = (_c = symbol === null || symbol === void 0 ? void 0 : symbol.getAliasedSymbol()) !== null && _c !== void 0 ? _c : symbol;
+        return (_d = aliasedSymbol === null || aliasedSymbol === void 0 ? void 0 : aliasedSymbol.getDeclarations()) !== null && _d !== void 0 ? _d : [namedImport];
+    }
+    return sourceFile
+        .getDescendantsOfKind(SyntaxKind.BindingElement)
+        .filter((bindingElement) => bindingElement.getName() === rootIdentifier);
+}
 function getDependencyTextFromTypeNode(typeNode) {
     if (isPrimitiveTypeNode(typeNode)) {
         return undefined;
@@ -861,7 +1553,11 @@ function getExportRewriteSafety(sourceFile, classDeclaration, className) {
         : { safe: false, warnings };
 }
 function getHelperImportSafety(sourceFile, helperImportPath) {
-    const warnings = ['brandAngularSymbol', 'deps']
+    const warnings = [
+        'GetDeps',
+        'GetInjectedServiceDependencies',
+        'GetServiceOutput',
+    ]
         .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 +1740,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 +1802,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;