@craft-ng/dev-tools 0.1.9 → 0.4.0-beta.1

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

@@ -1,7 +1,8 @@
 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 { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { basename, dirname, extname, isAbsolute, join, resolve, } from 'node:path';
 import { fileURLToPath } from 'node:url';
 const SUPPORTED_DECORATORS = {
     Component: 'component',
@@ -14,7 +15,53 @@ const DEFAULT_OPTIONS = {
     transformOnlyStandaloneDeclarables: false,
     includeProviders: true,
     includeViewProviders: true,
+    config: undefined,
+    configFilePath: undefined,
 };
+const ANGULAR_BRAND_CONFIG_FILE_NAME = 'craft-brand.config.ts';
+const DEFAULT_ANGULAR_BRAND_METADATA_CONTEXTS = [
+    'imports',
+    'hostDirectives',
+];
+const DEFAULT_ANGULAR_BRAND_CONFIG = defineAngularBrandConfig({
+    importAugmentations: [
+        {
+            match: {
+                module: '@angular/router',
+            },
+            deps: [
+                {
+                    key: 'Router',
+                    symbol: 'Router',
+                    module: '@angular/router',
+                },
+            ],
+            missingProvider: [
+                {
+                    key: 'Router',
+                    symbol: 'Router',
+                    module: '@angular/router',
+                },
+            ],
+        },
+        {
+            match: {
+                module: '@angular/forms/signals',
+                symbols: ['FormField'],
+                metadata: ['imports'],
+            },
+            deps: [
+                {
+                    key: 'FormField',
+                    symbol: 'FormField',
+                    typeText: 'FormField<any>',
+                    module: '@angular/forms/signals',
+                },
+            ],
+        },
+    ],
+});
+const angularBrandConfigCache = new Map();
 const PRIMITIVE_TYPE_TEXTS = new Set([
     'any',
     'bigint',
@@ -56,6 +103,194 @@ const IGNORED_DIRECTORIES = new Set([
     'out-tsc',
     'tmp',
 ]);
+export function defineAngularBrandConfig(config) {
+    return config;
+}
+export function discoverAngularBrandConfigFilePath(searchFromDir, stopDir) {
+    const resolvedStopDir = stopDir ? resolve(stopDir) : undefined;
+    let currentDir = resolve(searchFromDir);
+    while (true) {
+        const candidatePath = join(currentDir, ANGULAR_BRAND_CONFIG_FILE_NAME);
+        if (existsSync(candidatePath) && statSync(candidatePath).isFile()) {
+            return candidatePath;
+        }
+        if (resolvedStopDir && currentDir === resolvedStopDir) {
+            return undefined;
+        }
+        const parentDir = dirname(currentDir);
+        if (parentDir === currentDir) {
+            return undefined;
+        }
+        currentDir = parentDir;
+    }
+}
+export function loadAngularBrandConfigFromFile(configFilePath) {
+    var _a;
+    const resolvedConfigFilePath = resolve(configFilePath);
+    const cachedConfig = angularBrandConfigCache.get(resolvedConfigFilePath);
+    if (cachedConfig) {
+        return cachedConfig;
+    }
+    if (!existsSync(resolvedConfigFilePath) ||
+        !statSync(resolvedConfigFilePath).isFile()) {
+        throw new Error(`Angular brand config file not found at "${resolvedConfigFilePath}".`);
+    }
+    try {
+        const sourceText = readFileSync(resolvedConfigFilePath, 'utf8');
+        const transpiled = ts.transpileModule(sourceText, {
+            compilerOptions: {
+                module: ts.ModuleKind.CommonJS,
+                target: ts.ScriptTarget.ES2022,
+                esModuleInterop: true,
+                allowSyntheticDefaultImports: true,
+            },
+            fileName: resolvedConfigFilePath,
+        });
+        const module = { exports: {} };
+        const moduleRequire = createRequire(resolvedConfigFilePath);
+        const compiledModule = new Function('exports', 'require', 'module', '__filename', '__dirname', transpiled.outputText);
+        compiledModule(module.exports, (specifier) => {
+            if (specifier === '@craft-ng/dev-tools') {
+                return { defineAngularBrandConfig };
+            }
+            return moduleRequire(specifier);
+        }, module, resolvedConfigFilePath, dirname(resolvedConfigFilePath));
+        const exportedConfig = (_a = module.exports['default']) !== null && _a !== void 0 ? _a : (module.exports['__esModule']
+            ? module.exports['default']
+            : module.exports);
+        const validatedConfig = validateAngularBrandConfig(exportedConfig, resolvedConfigFilePath);
+        angularBrandConfigCache.set(resolvedConfigFilePath, validatedConfig);
+        return validatedConfig;
+    }
+    catch (error) {
+        throw new Error(`Invalid Angular brand config at "${resolvedConfigFilePath}": ${getErrorMessage(error)}`);
+    }
+}
+function resolveAngularBrandConfig(sourceFile, options) {
+    var _a;
+    const explicitConfig = (_a = options.config) !== null && _a !== void 0 ? _a : (options.configFilePath
+        ? loadAngularBrandConfigFromFile(options.configFilePath)
+        : loadDiscoveredAngularBrandConfig(dirname(sourceFile.getFilePath())));
+    return normalizeAngularBrandConfig(explicitConfig);
+}
+function loadDiscoveredAngularBrandConfig(searchFromDir, stopDir) {
+    const discoveredConfigPath = discoverAngularBrandConfigFilePath(searchFromDir, stopDir);
+    return discoveredConfigPath
+        ? loadAngularBrandConfigFromFile(discoveredConfigPath)
+        : undefined;
+}
+function normalizeAngularBrandConfig(config) {
+    var _a, _b;
+    const builtInRules = ((_a = DEFAULT_ANGULAR_BRAND_CONFIG.importAugmentations) !== null && _a !== void 0 ? _a : []).map(normalizeAngularBrandImportAugmentationRule);
+    const configuredRules = ((_b = config === null || config === void 0 ? void 0 : config.importAugmentations) !== null && _b !== void 0 ? _b : []).map(normalizeAngularBrandImportAugmentationRule);
+    return {
+        importAugmentations: [...builtInRules, ...configuredRules],
+    };
+}
+function normalizeAngularBrandImportAugmentationRule(rule) {
+    return {
+        match: {
+            module: rule.match.module,
+            symbols: rule.match.symbols ? [...rule.match.symbols] : undefined,
+            metadata: rule.match.metadata
+                ? [...rule.match.metadata]
+                : [...DEFAULT_ANGULAR_BRAND_METADATA_CONTEXTS],
+        },
+        deps: rule.deps ? [...rule.deps] : [],
+        missingProvider: rule.missingProvider ? [...rule.missingProvider] : [],
+    };
+}
+function validateAngularBrandConfig(value, configFilePath) {
+    var _a;
+    if (!isPlainObject(value)) {
+        throw new Error('Expected the default export to be an object.');
+    }
+    const importAugmentations = (_a = readOptionalArray(value['importAugmentations'], 'importAugmentations', configFilePath)) === null || _a === void 0 ? void 0 : _a.map((entry, index) => validateAngularBrandImportAugmentationRule(entry, `importAugmentations[${index}]`, configFilePath));
+    return {
+        importAugmentations: importAugmentations !== null && importAugmentations !== void 0 ? importAugmentations : [],
+    };
+}
+function validateAngularBrandImportAugmentationRule(value, pathLabel, configFilePath) {
+    var _a, _b, _c, _d, _e, _f;
+    if (!isPlainObject(value)) {
+        throw new Error(`${pathLabel} must be an object.`);
+    }
+    if (!isPlainObject(value['match'])) {
+        throw new Error(`${pathLabel}.match must be an object.`);
+    }
+    const match = value['match'];
+    const moduleSpecifier = readRequiredString(match['module'], `${pathLabel}.match.module`, configFilePath);
+    const symbols = readOptionalStringArray(match['symbols'], `${pathLabel}.match.symbols`, configFilePath);
+    const metadata = (_b = (_a = readOptionalStringArray(match['metadata'], `${pathLabel}.match.metadata`, configFilePath)) === null || _a === void 0 ? void 0 : _a.map((context) => validateAngularBrandMetadataContext(context, pathLabel))) !== null && _b !== void 0 ? _b : undefined;
+    return {
+        match: {
+            module: moduleSpecifier,
+            symbols,
+            metadata,
+        },
+        deps: (_d = (_c = readOptionalArray(value['deps'], `${pathLabel}.deps`, configFilePath)) === null || _c === void 0 ? void 0 : _c.map((entry, index) => validateAngularBrandConfigEntry(entry, `${pathLabel}.deps[${index}]`, configFilePath))) !== null && _d !== void 0 ? _d : [],
+        missingProvider: (_f = (_e = readOptionalArray(value['missingProvider'], `${pathLabel}.missingProvider`, configFilePath)) === null || _e === void 0 ? void 0 : _e.map((entry, index) => validateAngularBrandConfigEntry(entry, `${pathLabel}.missingProvider[${index}]`, configFilePath))) !== null && _f !== void 0 ? _f : [],
+    };
+}
+function validateAngularBrandConfigEntry(value, pathLabel, configFilePath) {
+    if (!isPlainObject(value)) {
+        throw new Error(`${pathLabel} must be an object.`);
+    }
+    const key = readRequiredString(value['key'], `${pathLabel}.key`, configFilePath);
+    const symbol = readRequiredString(value['symbol'], `${pathLabel}.symbol`, configFilePath);
+    const typeText = readOptionalString(value['typeText'], `${pathLabel}.typeText`, configFilePath);
+    const moduleSpecifier = readOptionalString(value['module'], `${pathLabel}.module`, configFilePath);
+    return {
+        key,
+        symbol,
+        typeText,
+        module: moduleSpecifier,
+    };
+}
+function validateAngularBrandMetadataContext(value, pathLabel) {
+    if (value === 'imports' || value === 'hostDirectives') {
+        return value;
+    }
+    throw new Error(`${pathLabel}.match.metadata must contain only "imports" or "hostDirectives".`);
+}
+function readOptionalArray(value, pathLabel, configFilePath) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!Array.isArray(value)) {
+        throw new Error(`${pathLabel} in "${configFilePath}" must be an array.`);
+    }
+    return value;
+}
+function readRequiredString(value, pathLabel, configFilePath) {
+    const stringValue = readOptionalString(value, pathLabel, configFilePath);
+    if (!stringValue) {
+        throw new Error(`${pathLabel} in "${configFilePath}" must be a string.`);
+    }
+    return stringValue;
+}
+function readOptionalString(value, pathLabel, configFilePath) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== 'string') {
+        throw new Error(`${pathLabel} in "${configFilePath}" must be a string.`);
+    }
+    return value;
+}
+function readOptionalStringArray(value, pathLabel, configFilePath) {
+    const arrayValue = readOptionalArray(value, pathLabel, configFilePath);
+    if (!arrayValue) {
+        return undefined;
+    }
+    return arrayValue.map((entry, index) => readRequiredString(entry, `${pathLabel}[${index}]`, configFilePath));
+}
+function isPlainObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function getErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
 export function transformSourceFile(sourceFile, options = {}) {
     const normalizedOptions = normalizeOptions(options);
     const analysis = analyzeSourceFileDependencies(sourceFile, options);
@@ -79,6 +314,7 @@ export function transformSourceFile(sourceFile, options = {}) {
 }
 export function analyzeSourceFileDependencies(sourceFile, options = {}) {
     const normalizedOptions = normalizeOptions(options);
+    const angularBrandConfig = resolveAngularBrandConfig(sourceFile, normalizedOptions);
     const result = {
         skipped: false,
         warnings: [],
@@ -118,22 +354,18 @@ export function analyzeSourceFileDependencies(sourceFile, options = {}) {
         ? 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);
-    result.dependencies = mergeDeps(constructorDeps.dependencies, injectCallDeps.dependencies, metadataDeps.imports, metadataDeps.hostDirectives, metadataDeps.providers, metadataDeps.viewProviders);
+    const propertyDeps = extractPropertyDependencies(sourceFile, classDeclaration, className);
+    const generatedDependencyAugmentation = createGeneratedDependencyGroupAugmentation(sourceFile, metadataDeps.occurrences, angularBrandConfig);
+    const syntheticDependencyTexts = mergeDeps(generatedDependencyAugmentation.deps.map((dependency) => dependency.dependencyText), generatedDependencyAugmentation.legacyInjectedDependencies.map((dependency) => dependency.dependencyText));
+    result.warnings.push(...metadataDeps.warnings, ...providedDeps.warnings, ...constructorDeps.warnings, ...propertyDeps.warnings);
+    result.dependencies = mergeDeps(constructorDeps.dependencies, propertyDeps.dependencies, metadataDeps.imports, metadataDeps.hostDirectives, metadataDeps.providers, metadataDeps.viewProviders, syntheticDependencyTexts);
     result.dependencyGroups = {
-        injected: mergeDeps(constructorDeps.dependencies, injectCallDeps.dependencies),
+        injected: mergeDeps(constructorDeps.dependencies, propertyDeps.dependencies, generatedDependencyAugmentation.legacyInjectedDependencies.map((dependency) => dependency.dependencyText)),
         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);
+    result.generatedDependencyGroups = createGeneratedDependencyGroups(sourceFile, className, result.dependencyGroups.importDeps, constructorDeps.dependencies, propertyDeps, providedDeps.entries, generatedDependencyAugmentation);
     return result;
 }
 export function findAngularDecoratedClass(sourceFile) {
@@ -268,6 +500,53 @@ export function extractInjectCallDeps(classDeclaration) {
         generatedDependencies,
     };
 }
+function extractPropertyDependencies(sourceFile, classDeclaration, className) {
+    const warnings = [];
+    const dependencies = [];
+    const entries = [];
+    const missingProvider = [];
+    for (const property of classDeclaration.getProperties()) {
+        if (property.isStatic()) {
+            continue;
+        }
+        const propertyName = getStaticPropertyName(property.getNameNode());
+        if (!propertyName) {
+            warnings.push(`Skipped property dependency tracking for ${property.getText()} because the property name is not static.`);
+            continue;
+        }
+        const initializer = property.getInitializer();
+        if (Node.isCallExpression(initializer)) {
+            const expression = initializer.getExpression();
+            const injectMethodName = getInjectMethodName(expression);
+            if (injectMethodName === null || injectMethodName === void 0 ? void 0 : injectMethodName.startsWith('inject')) {
+                const dependencyText = injectMethodName === 'inject'
+                    ? getAngularInjectCallDependency(initializer)
+                    : getInjectionHelperDependency(expression);
+                if (!dependencyText) {
+                    warnings.push(`Skipped ${injectMethodName}() property dependency tracking for "${propertyName}" because the dependency is not static.`);
+                }
+                else {
+                    dependencies.push(dependencyText);
+                    const dependencyEntry = injectMethodName === 'inject'
+                        ? createGeneratedDependencyEntry(sourceFile, dependencyText, 'inject')
+                        : createGeneratedInjectHelperDependencyEntry(sourceFile, initializer, expression, dependencyText);
+                    entries.push(createGeneratedPropertyDependencyEntry(propertyName, createSingleDependencyMapTypeText(dependencyEntry)));
+                    if (shouldGenerateLocalMissingProvider(sourceFile, dependencyText)) {
+                        missingProvider.push(createGeneratedDependencyEntry(sourceFile, dependencyText, 'inject'));
+                    }
+                    continue;
+                }
+            }
+        }
+        entries.push(createGeneratedPropertyDependencyEntry(propertyName, createExtractDepsTypeText(className, propertyName)));
+    }
+    return {
+        dependencies: mergeDeps(dependencies),
+        warnings,
+        entries,
+        missingProvider: mergeGeneratedDependencyEntries(missingProvider),
+    };
+}
 export function mergeDeps(...dependencyGroups) {
     const seen = new Set();
     const dependencies = [];
@@ -292,44 +571,83 @@ function emptyDependencyGroups() {
 function emptyGeneratedDependencyGroups() {
     return {
         deps: [],
+        propertiesDeps: [],
         provided: [],
         missingProvider: [],
     };
 }
+function emptyGeneratedDependencyGroupAugmentation() {
+    return {
+        deps: [],
+        missingProvider: [],
+        legacyInjectedDependencies: [],
+    };
+}
 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));
+function createGeneratedDependencyGroups(sourceFile, className, importDependencies, constructorDependencies, propertyDependencies, providedEntries, augmentation) {
+    const constructorEntries = constructorDependencies.map((dependency) => createGeneratedDependencyEntry(sourceFile, dependency, 'inject'));
+    const deps = mergeGeneratedDependencyEntries(importDependencies.map((dependency) => createGeneratedDependencyEntry(sourceFile, dependency, 'import')), constructorEntries, augmentation.deps.map((dependency) => dependency.entry));
+    const propertiesDeps = mergeGeneratedDependencyEntries(propertyDependencies.entries);
     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) &&
-            shouldGenerateLocalMissingProvider(sourceFile, dependency.dependencyText));
-    })
-        .map((dependency) => {
-        var _a;
-        return (_a = injectedEntriesByKey.get(dependency.entry.key)) !== null && _a !== void 0 ? _a : createGeneratedDependencyEntry(sourceFile, dependency.dependencyText, 'inject');
-    }));
+    const missingProvider = mergeGeneratedDependencyEntries(constructorDependencies
+        .filter((dependencyText) => shouldGenerateLocalMissingProvider(sourceFile, dependencyText))
+        .map((dependencyText) => createGeneratedDependencyEntry(sourceFile, dependencyText, 'inject')), propertyDependencies.missingProvider, augmentation.missingProvider
+        .map((dependency) => dependency.entry)
+        .filter((entry) => !providedKeys.has(entry.key)));
     return {
         deps,
+        propertiesDeps,
         provided,
         missingProvider,
     };
 }
+function createGeneratedDependencyGroupAugmentation(sourceFile, metadataOccurrences, config) {
+    if (metadataOccurrences.length === 0) {
+        return emptyGeneratedDependencyGroupAugmentation();
+    }
+    const deps = [];
+    const missingProvider = [];
+    const legacyInjectedDependencies = [];
+    for (const rule of config.importAugmentations) {
+        if (!metadataOccurrences.some((occurrence) => ruleMatchesMetadataOccurrence(rule, occurrence))) {
+            continue;
+        }
+        const generatedDeps = rule.deps.map((entry) => createConfiguredGeneratedDependencyDescriptor(sourceFile, entry, rule.match.module));
+        const generatedMissingProviders = rule.missingProvider.map((entry) => createConfiguredGeneratedDependencyDescriptor(sourceFile, entry, rule.match.module));
+        deps.push(...generatedDeps);
+        missingProvider.push(...generatedMissingProviders);
+        legacyInjectedDependencies.push(...generatedMissingProviders);
+    }
+    return {
+        deps,
+        missingProvider,
+        legacyInjectedDependencies,
+    };
+}
+function ruleMatchesMetadataOccurrence(rule, occurrence) {
+    if (occurrence.moduleSpecifier !== rule.match.module) {
+        return false;
+    }
+    if (!rule.match.metadata.includes(occurrence.metadataContext)) {
+        return false;
+    }
+    return (!rule.match.symbols || rule.match.symbols.includes(occurrence.symbolName));
+}
+function createConfiguredGeneratedDependencyDescriptor(sourceFile, entry, defaultModuleSpecifier) {
+    var _a;
+    return {
+        dependencyText: entry.symbol,
+        entry: createSyntheticGeneratedDependencyEntry(sourceFile, entry.symbol, 'inject', (_a = entry.module) !== null && _a !== void 0 ? _a : defaultModuleSpecifier, entry.key, entry.typeText),
+    };
+}
 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);
-            }
+            entries.set(entry.key, entry);
         }
     }
     return [...entries.values()];
@@ -356,6 +674,12 @@ function createGeneratedDependencyEntry(sourceFile, dependencyText, context) {
         typeText: createGeneratedDependencyTypeText(sourceFile, dependencyText),
     };
 }
+function createSyntheticGeneratedDependencyEntry(sourceFile, dependencyText, context, moduleSpecifier, key = createGeneratedDependencyKey(dependencyText), typeText) {
+    return Object.assign(Object.assign({}, createGeneratedDependencyEntry(sourceFile, dependencyText, context)), { key, typeText: typeText !== null && typeText !== void 0 ? typeText : createGeneratedDependencyTypeText(sourceFile, dependencyText), typeImport: {
+            moduleSpecifier,
+            name: dependencyText,
+        } });
+}
 function createGeneratedInjectHelperDependencyEntry(sourceFile, callExpression, expression, dependencyText) {
     const trackedHelper = resolveTrackedInjectHelper(expression);
     if (!trackedHelper) {
@@ -364,11 +688,11 @@ function createGeneratedInjectHelperDependencyEntry(sourceFile, callExpression,
     const exposureTracking = extractHelperExposureTracking(callExpression);
     return {
         key: trackedHelper.serviceName,
-        typeText: createTrackedInjectHelperTypeText(dependencyText, exposureTracking),
+        typeText: createTrackedInjectHelperTypeText(dependencyText, trackedHelper.serviceName, exposureTracking),
     };
 }
-function createTrackedInjectHelperTypeText(dependencyText, exposureTracking) {
-    const baseType = `GetInjectedServiceDependencies<typeof ${dependencyText}>`;
+function createTrackedInjectHelperTypeText(dependencyText, serviceName, exposureTracking) {
+    const baseType = `ExtractDeps<typeof ${dependencyText}>[${JSON.stringify(serviceName)}]`;
     if (!exposureTracking) {
         return baseType;
     }
@@ -385,6 +709,18 @@ function createTrackedInjectHelperTypeText(dependencyText, exposureTracking) {
         '}>',
     ].join('\n');
 }
+function createGeneratedPropertyDependencyEntry(propertyName, typeText) {
+    return {
+        key: propertyName,
+        typeText,
+    };
+}
+function createExtractDepsTypeText(className, propertyName) {
+    return `ExtractDeps<${className}[${JSON.stringify(propertyName)}]>`;
+}
+function createSingleDependencyMapTypeText(entry) {
+    return formatGeneratedDependencyObject([entry]);
+}
 function formatHelperExposurePropertiesType(dependencyText, properties) {
     if (properties.length === 0) {
         return '{}';
@@ -629,7 +965,10 @@ function resolveAngularDeclarableDependency(sourceFile, dependencyText) {
 function ensureGeneratedDependencyTypeImports(sourceFile, generatedDependencyGroups) {
     var _a;
     const importsToAdd = new Map();
-    for (const entry of generatedDependencyGroups.deps) {
+    for (const entry of [
+        ...generatedDependencyGroups.deps,
+        ...generatedDependencyGroups.missingProvider,
+    ]) {
         if (!entry.typeImport) {
             continue;
         }
@@ -640,9 +979,18 @@ function ensureGeneratedDependencyTypeImports(sourceFile, generatedDependencyGro
     for (const [moduleSpecifier, importNames] of importsToAdd) {
         const existingImport = sourceFile
             .getImportDeclarations()
-            .find((importDeclaration) => importDeclaration.getModuleSpecifierValue() === moduleSpecifier);
+            .find((importDeclaration) => importDeclaration.getModuleSpecifierValue() === moduleSpecifier &&
+            !importDeclaration.getNamespaceImport());
         if (existingImport) {
-            existingImport.addNamedImports([...importNames].map((name) => ({ name, isTypeOnly: true })));
+            const existingImportNames = new Set(existingImport.getNamedImports().map((namedImport) => {
+                var _a, _b;
+                return ((_b = (_a = namedImport.getAliasNode()) === null || _a === void 0 ? void 0 : _a.getText()) !== null && _b !== void 0 ? _b : namedImport.getNameNode().getText());
+            }));
+            const namesToAdd = [...importNames].filter((name) => !existingImportNames.has(name));
+            if (namesToAdd.length === 0) {
+                continue;
+            }
+            existingImport.addNamedImports(namesToAdd.map((name) => ({ name, isTypeOnly: true })));
             continue;
         }
         sourceFile.addImportDeclaration({
@@ -658,6 +1006,11 @@ function formatGeneratedDependencyType(angularKind, className, generatedDependen
     return [
         '{',
         `  deps: ${formatGeneratedDependencyObject(generatedDependencyGroups.deps)};`,
+        ...(angularKind === 'component'
+            ? [
+                `  propertiesDeps: ${formatGeneratedDependencyObject(generatedDependencyGroups.propertiesDeps)};`,
+            ]
+            : []),
         `  provided: ${formatGeneratedDependencyObject(generatedDependencyGroups.provided)};`,
         ...(angularKind === 'component'
             ? [`  publicProperties: GetPublicComponentProperties<${className}>;`]
@@ -781,8 +1134,8 @@ function getInjectionHelperDependency(expression) {
 export function ensureHelperImports(sourceFile, helperImportPath) {
     const missingImports = [
         'DerivedService',
+        'ExtractDeps',
         'GetDeps',
-        'GetInjectedServiceDependencies',
         'GetPublicComponentProperties',
         'GetServiceOutput',
     ].filter((importName) => !hasLocalNamedImport(sourceFile, helperImportPath, importName));
@@ -884,8 +1237,11 @@ export function formatDependencyGroups(dependencyGroups) {
 }
 export function runAngularBrandCodemod() {
     return __awaiter(this, arguments, void 0, function* (options = {}) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         const rootDir = resolve((_a = options.rootDir) !== null && _a !== void 0 ? _a : process.cwd());
+        const config = (_b = options.config) !== null && _b !== void 0 ? _b : (options.configFilePath
+            ? loadAngularBrandConfigFromFile(options.configFilePath)
+            : loadDiscoveredAngularBrandConfig(rootDir));
         const tsConfigFilePath = options.tsConfigFilePath
             ? resolve(options.tsConfigFilePath)
             : getDefaultTsConfigPath(rootDir);
@@ -909,7 +1265,7 @@ export function runAngularBrandCodemod() {
             if (!isWithinRoot(sourceFile.getFilePath(), rootDir)) {
                 continue;
             }
-            const result = transformSourceFile(sourceFile, options);
+            const result = transformSourceFile(sourceFile, Object.assign(Object.assign({}, options), { config }));
             const report = Object.assign(Object.assign({}, result), { filePath: sourceFile.getFilePath() });
             summary.files.push(report);
             summary.warnings += result.warnings.length;
@@ -926,9 +1282,9 @@ export function runAngularBrandCodemod() {
             if (result.skipped) {
                 summary.skippedFiles += 1;
             }
-            logFileResult(report, (_b = options.log) !== null && _b !== void 0 ? _b : console.log);
+            logFileResult(report, (_c = options.log) !== null && _c !== void 0 ? _c : console.log);
         }
-        logSummary(summary, (_c = options.log) !== null && _c !== void 0 ? _c : console.log);
+        logSummary(summary, (_d = options.log) !== null && _d !== void 0 ? _d : console.log);
         return summary;
     });
 }
@@ -939,6 +1295,8 @@ function normalizeOptions(options) {
         transformOnlyStandaloneDeclarables: (_b = options.transformOnlyStandaloneDeclarables) !== null && _b !== void 0 ? _b : DEFAULT_OPTIONS.transformOnlyStandaloneDeclarables,
         includeProviders: (_c = options.includeProviders) !== null && _c !== void 0 ? _c : DEFAULT_OPTIONS.includeProviders,
         includeViewProviders: (_d = options.includeViewProviders) !== null && _d !== void 0 ? _d : DEFAULT_OPTIONS.includeViewProviders,
+        config: options.config,
+        configFilePath: options.configFilePath,
     };
 }
 function skip(result, warnings) {
@@ -1008,6 +1366,7 @@ function getObjectPropertyAssignment(objectLiteral, propertyName) {
     return Node.isPropertyAssignment(property) ? property : undefined;
 }
 function extractDecoratorMetadataDepGroups(classDeclaration, angularKind, options) {
+    const sourceFile = classDeclaration.getSourceFile();
     const metadata = getDecoratorMetadataObject(classDeclaration);
     const groups = emptyMetadataDependencyGroups();
     if (!metadata) {
@@ -1021,6 +1380,10 @@ function extractDecoratorMetadataDepGroups(classDeclaration, angularKind, option
     if (options.includeViewProviders && angularKind === 'component') {
         groups.viewProviders = extractMetadataArrayProperty(metadata, 'viewProviders', 'viewProviders', groups.warnings);
     }
+    groups.occurrences = [
+        ...groups.imports.map((dependencyText) => createMetadataDependencyOccurrence(sourceFile, dependencyText, 'imports')),
+        ...groups.hostDirectives.map((dependencyText) => createMetadataDependencyOccurrence(sourceFile, dependencyText, 'hostDirectives')),
+    ];
     return groups;
 }
 function emptyMetadataDependencyGroups() {
@@ -1029,9 +1392,20 @@ function emptyMetadataDependencyGroups() {
         hostDirectives: [],
         providers: [],
         viewProviders: [],
+        occurrences: [],
         warnings: [],
     };
 }
+function createMetadataDependencyOccurrence(sourceFile, dependencyText, metadataContext) {
+    var _a, _b;
+    const resolution = resolveDependencyReference(sourceFile, dependencyText);
+    return {
+        dependencyText,
+        symbolName: (_b = (_a = resolution.importedName) !== null && _a !== void 0 ? _a : dependencyText.split('.').pop()) !== null && _b !== void 0 ? _b : dependencyText,
+        moduleSpecifier: resolution.moduleSpecifier,
+        metadataContext,
+    };
+}
 function extractProvidedDependencies(sourceFile, classDeclaration, angularKind, options) {
     const metadata = getDecoratorMetadataObject(classDeclaration);
     const warnings = [];
@@ -1276,10 +1650,11 @@ function resolveImportedDependencyReference(sourceFile, dependencyText, rootIden
                 return {
                     kind: 'class',
                     classDeclaration: declaration,
+                    importedName: rootIdentifier,
                     moduleSpecifier,
                 };
             }
-            return { kind: 'unknown', moduleSpecifier };
+            return { kind: 'unknown', importedName: rootIdentifier, moduleSpecifier };
         }
         if (((_b = importDeclaration.getNamespaceImport()) === null || _b === void 0 ? void 0 : _b.getText()) === rootIdentifier) {
             const declaration = getNamespaceImportClassDeclaration(importDeclaration, dependencyText);
@@ -1287,10 +1662,15 @@ function resolveImportedDependencyReference(sourceFile, dependencyText, rootIden
                 return {
                     kind: 'class',
                     classDeclaration: declaration,
+                    importedName: dependencyText.split('.').pop(),
                     moduleSpecifier,
                 };
             }
-            return { kind: 'namespace', moduleSpecifier };
+            return {
+                kind: 'namespace',
+                importedName: dependencyText.split('.').pop(),
+                moduleSpecifier,
+            };
         }
         const namedImport = importDeclaration
             .getNamedImports()
@@ -1311,19 +1691,36 @@ function resolveImportedDependencyReference(sourceFile, dependencyText, rootIden
             return {
                 kind: 'class',
                 classDeclaration,
+                importedName: namedImport.getNameNode().getText(),
                 moduleSpecifier,
             };
         }
         if (declarations.some((declaration) => Node.isEnumDeclaration(declaration))) {
-            return { kind: 'enum', moduleSpecifier };
+            return {
+                kind: 'enum',
+                importedName: namedImport.getNameNode().getText(),
+                moduleSpecifier,
+            };
         }
         if (declarations.some((declaration) => Node.isFunctionDeclaration(declaration))) {
-            return { kind: 'function', moduleSpecifier };
+            return {
+                kind: 'function',
+                importedName: namedImport.getNameNode().getText(),
+                moduleSpecifier,
+            };
         }
         if (declarations.some((declaration) => Node.isVariableDeclaration(declaration))) {
-            return { kind: 'variable', moduleSpecifier };
+            return {
+                kind: 'variable',
+                importedName: namedImport.getNameNode().getText(),
+                moduleSpecifier,
+            };
         }
-        return { kind: 'unknown', moduleSpecifier };
+        return {
+            kind: 'unknown',
+            importedName: namedImport.getNameNode().getText(),
+            moduleSpecifier,
+        };
     }
     return undefined;
 }
@@ -1789,6 +2186,9 @@ function parseCliArgs(argv) {
             case '--tsconfig':
                 options.tsConfigFilePath = argv[++index];
                 break;
+            case '--config':
+                options.configFilePath = argv[++index];
+                break;
             case '--helper-import':
                 options.helperImportPath = argv[++index];
                 break;
@@ -1819,6 +2219,7 @@ function printHelpAndExit() {
 Options:
   --root <dir>                                  Project root. Defaults to cwd.
   --tsconfig <path>                            tsconfig path. Defaults to <root>/tsconfig.json.
+  --config <path>                              Explicit angular brand config file path.
   --helper-import <path>                       Import path for GetDeps.
   --transform-only-standalone-declarables      Only transform standalone components/directives.
   --no-providers                               Do not include metadata providers in generated types.