@craft-ng/dev-tools 0.1.0

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

@@ -0,0 +1,1124 @@
+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';
+const SUPPORTED_DECORATORS = {
+    Component: 'component',
+    Directive: 'directive',
+    Pipe: 'pipe',
+    Injectable: 'injectable',
+};
+const DEFAULT_OPTIONS = {
+    helperImportPath: '@craft-ng/core',
+    transformOnlyStandaloneDeclarables: false,
+    includeProviders: true,
+    includeViewProviders: true,
+};
+const PRIMITIVE_TYPE_TEXTS = new Set([
+    'any',
+    'bigint',
+    'boolean',
+    'false',
+    'never',
+    'null',
+    'number',
+    'object',
+    'string',
+    'symbol',
+    'true',
+    'undefined',
+    'unknown',
+    'void',
+    'Array',
+    'Boolean',
+    'Number',
+    'Object',
+    'ReadonlyArray',
+    'String',
+]);
+const GENERATED_FILE_SUFFIXES = [
+    '.d.ts',
+    '.gen.ts',
+    '.generated.ts',
+    '.ngfactory.ts',
+    '.ngsummary.ts',
+    '.ngtypecheck.ts',
+];
+const IGNORED_DIRECTORIES = new Set([
+    '.angular',
+    '.git',
+    '.nx',
+    '.turbo',
+    'coverage',
+    'dist',
+    'node_modules',
+    'out-tsc',
+    'tmp',
+]);
+export function transformSourceFile(sourceFile, options = {}) {
+    const normalizedOptions = normalizeOptions(options);
+    const analysis = analyzeSourceFileDependencies(sourceFile, options);
+    const result = Object.assign(Object.assign({}, analysis), { changed: false });
+    const { angularKind, classDeclaration, className } = analysis;
+    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);
+    ensureHelperImports(sourceFile, normalizedOptions.helperImportPath);
+    writeDefaultBrandExport(sourceFile, className, result.dependencyGroups);
+    result.changed = true;
+    return result;
+}
+export function analyzeSourceFileDependencies(sourceFile, options = {}) {
+    const normalizedOptions = normalizeOptions(options);
+    const result = {
+        skipped: false,
+        warnings: [],
+        dependencies: [],
+        dependencyGroups: emptyDependencyGroups(),
+    };
+    const angularClass = findAngularDecoratedClass(sourceFile);
+    result.warnings.push(...angularClass.warnings);
+    result.angularKind = angularClass.angularKind;
+    result.className = angularClass.className;
+    result.classDeclaration = angularClass.classDeclaration;
+    if (angularClass.skipped) {
+        result.skipped = true;
+        return result;
+    }
+    if (!angularClass.classDeclaration) {
+        return result;
+    }
+    const { angularKind, classDeclaration, className } = angularClass;
+    if (!angularKind || !className) {
+        result.skipped = true;
+        result.warnings.push('Angular class name or kind could not be resolved.');
+        return result;
+    }
+    if (normalizedOptions.transformOnlyStandaloneDeclarables &&
+        (angularKind === 'component' || angularKind === 'directive') &&
+        !isStandaloneDeclarable(classDeclaration)) {
+        result.skipped = true;
+        result.warnings.push(`${decoratorLabel(angularKind)} ${className} is not standalone and transformOnlyStandaloneDeclarables is enabled.`);
+        return result;
+    }
+    const metadataDeps = angularKind === 'component' || angularKind === 'directive'
+        ? extractDecoratorMetadataDepGroups(classDeclaration, angularKind, normalizedOptions)
+        : emptyMetadataDependencyGroups();
+    const constructorDeps = extractConstructorDeps(classDeclaration);
+    const injectCallDeps = extractInjectCallDeps(classDeclaration);
+    result.warnings.push(...metadataDeps.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),
+    };
+    return result;
+}
+export function findAngularDecoratedClass(sourceFile) {
+    const decoratedClasses = sourceFile
+        .getClasses()
+        .map((classDeclaration) => {
+        const angularKind = getAngularKind(classDeclaration);
+        return angularKind ? { classDeclaration, angularKind } : undefined;
+    })
+        .filter((entry) => Boolean(entry));
+    if (decoratedClasses.length === 0) {
+        return { skipped: false, warnings: [] };
+    }
+    if (decoratedClasses.length > 1) {
+        return {
+            skipped: true,
+            warnings: [
+                `Skipped file because it contains ${decoratedClasses.length} supported Angular classes.`,
+            ],
+        };
+    }
+    const [{ classDeclaration, angularKind }] = decoratedClasses;
+    const className = classDeclaration.getName();
+    if (!className) {
+        return {
+            classDeclaration,
+            angularKind,
+            skipped: true,
+            warnings: ['Skipped anonymous default-exported Angular class.'],
+        };
+    }
+    return {
+        classDeclaration,
+        angularKind,
+        className,
+        skipped: false,
+        warnings: [],
+    };
+}
+export function getAngularKind(classDeclaration) {
+    for (const decorator of classDeclaration.getDecorators()) {
+        const decoratorName = getDecoratorName(decorator);
+        if (decoratorName && decoratorName in SUPPORTED_DECORATORS) {
+            return SUPPORTED_DECORATORS[decoratorName];
+        }
+    }
+    return undefined;
+}
+export function isStandaloneDeclarable(classDeclaration) {
+    const angularKind = getAngularKind(classDeclaration);
+    if (angularKind !== 'component' && angularKind !== 'directive') {
+        return false;
+    }
+    const metadata = getDecoratorMetadataObject(classDeclaration);
+    const standaloneProperty = metadata
+        ? getObjectPropertyAssignment(metadata, 'standalone')
+        : undefined;
+    const initializer = standaloneProperty === null || standaloneProperty === void 0 ? void 0 : standaloneProperty.getInitializer();
+    return Node.isTrueLiteral(initializer);
+}
+export function extractDecoratorMetadataDeps(classDeclaration, angularKind = getAngularKind(classDeclaration), options = {}) {
+    if (angularKind !== 'component' && angularKind !== 'directive') {
+        return { dependencies: [], warnings: [] };
+    }
+    const groups = extractDecoratorMetadataDepGroups(classDeclaration, angularKind, normalizeOptions(options));
+    return {
+        dependencies: mergeDeps(groups.imports, groups.hostDirectives, groups.providers, groups.viewProviders),
+        warnings: groups.warnings,
+    };
+}
+export function extractConstructorDeps(classDeclaration) {
+    const warnings = [];
+    const dependencies = [];
+    for (const constructorDeclaration of classDeclaration.getConstructors()) {
+        for (const parameter of constructorDeclaration.getParameters()) {
+            const injectToken = getInjectDecoratorToken(parameter.getDecorators(), warnings);
+            if (injectToken.found) {
+                if (injectToken.dependency) {
+                    dependencies.push(injectToken.dependency);
+                }
+                continue;
+            }
+            const typeNode = parameter.getTypeNode();
+            if (!typeNode) {
+                warnings.push(`Skipped constructor parameter "${parameter.getName()}" because it has no type.`);
+                continue;
+            }
+            const dependency = getDependencyTextFromTypeNode(typeNode);
+            if (!dependency) {
+                warnings.push(`Skipped constructor parameter "${parameter.getName()}" because type "${typeNode.getText()}" is not a static Angular dependency.`);
+                continue;
+            }
+            if (!isRuntimeSafeTypeDependency(typeNode, dependency)) {
+                warnings.push(`Skipped constructor dependency "${dependency}" because it is unresolved, type-only, or not a runtime value.`);
+                continue;
+            }
+            dependencies.push(dependency);
+        }
+    }
+    return { dependencies: mergeDeps(dependencies), warnings };
+}
+export function extractInjectCallDeps(classDeclaration) {
+    var _a;
+    const warnings = [];
+    const dependencies = [];
+    for (const callExpression of classDeclaration.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+        const expression = callExpression.getExpression();
+        const injectMethodName = getInjectMethodName(expression);
+        if (!(injectMethodName === null || injectMethodName === void 0 ? void 0 : injectMethodName.startsWith('inject'))) {
+            continue;
+        }
+        const dependency = injectMethodName === 'inject'
+            ? getAngularInjectCallDependency(callExpression)
+            : getInjectionHelperDependency(expression);
+        if (!dependency) {
+            warnings.push(`Skipped ${injectMethodName}() call in ${(_a = classDeclaration.getName()) !== null && _a !== void 0 ? _a : 'anonymous class'} because the injection dependency is not static.`);
+            continue;
+        }
+        dependencies.push(dependency);
+    }
+    return { dependencies: mergeDeps(dependencies), warnings };
+}
+export function mergeDeps(...dependencyGroups) {
+    const seen = new Set();
+    const dependencies = [];
+    for (const group of dependencyGroups) {
+        for (const dependency of group) {
+            if (seen.has(dependency)) {
+                continue;
+            }
+            seen.add(dependency);
+            dependencies.push(dependency);
+        }
+    }
+    return dependencies;
+}
+function emptyDependencyGroups() {
+    return {
+        injected: [],
+        importDeps: [],
+        providers: [],
+    };
+}
+function createDepsExpression(dependencyGroups) {
+    return `deps({ injected: [${dependencyGroups.injected.join(', ')}], importDeps: [${dependencyGroups.importDeps.join(', ')}], providers: [${dependencyGroups.providers.join(', ')}] })`;
+}
+function invalidExistingDependencyGroups(node, warnings) {
+    return {
+        found: true,
+        warnings,
+        dependencyGroups: emptyDependencyGroups(),
+        exportAssignmentNode: node,
+        depsObjectNode: node,
+        propertyNodes: {},
+    };
+}
+function readExistingDependencyGroupProperty(objectLiteral, propertyName, warnings, propertyNodes) {
+    const property = getObjectPropertyAssignment(objectLiteral, propertyName);
+    if (!property) {
+        warnings.push(`deps(...) is missing the "${propertyName}" array.`);
+        return [];
+    }
+    propertyNodes[propertyName] = property;
+    const initializer = property.getInitializer();
+    if (!Node.isArrayLiteralExpression(initializer)) {
+        warnings.push(`deps.${propertyName} must be a static array.`);
+        return [];
+    }
+    const dependencies = [];
+    for (const element of initializer.getElements()) {
+        const dependency = getStaticExpressionText(element);
+        if (!dependency) {
+            warnings.push(`deps.${propertyName} contains a non-static expression: ${element.getText()}`);
+            continue;
+        }
+        dependencies.push(dependency);
+    }
+    return dependencies;
+}
+function getInjectMethodName(expression) {
+    if (Node.isIdentifier(expression)) {
+        return expression.getText();
+    }
+    if (Node.isPropertyAccessExpression(expression)) {
+        return expression.getName();
+    }
+    return undefined;
+}
+function getAngularInjectCallDependency(callExpression) {
+    const [token] = callExpression.getArguments();
+    return getStaticExpressionText(token);
+}
+function getInjectionHelperDependency(expression) {
+    if (Node.isIdentifier(expression)) {
+        return expression.getText();
+    }
+    if (Node.isPropertyAccessExpression(expression)) {
+        const left = expression.getExpression();
+        if (Node.isIdentifier(left)) {
+            return expression.getText();
+        }
+    }
+    return undefined;
+}
+export function ensureHelperImports(sourceFile, helperImportPath) {
+    const missingImports = ['brandAngularSymbol', 'deps'].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, 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,
+    });
+}
+export function readExistingDependencyGroups(sourceFile, className) {
+    const defaultExport = sourceFile
+        .getExportAssignments()
+        .find((exportAssignment) => {
+        if (exportAssignment.isExportEquals()) {
+            return false;
+        }
+        const expression = exportAssignment.getExpression();
+        if (!Node.isCallExpression(expression)) {
+            return false;
+        }
+        const callTarget = expression.getExpression();
+        if (!Node.isIdentifier(callTarget) ||
+            callTarget.getText() !== 'brandAngularSymbol') {
+            return false;
+        }
+        if (!className) {
+            return true;
+        }
+        const [targetClass] = expression.getArguments();
+        return (Node.isIdentifier(targetClass) && targetClass.getText() === className);
+    });
+    if (!defaultExport) {
+        return {
+            found: false,
+            warnings: [],
+            dependencyGroups: emptyDependencyGroups(),
+            propertyNodes: {},
+        };
+    }
+    const expression = defaultExport.getExpression();
+    if (!Node.isCallExpression(expression)) {
+        return invalidExistingDependencyGroups(defaultExport, [
+            'Default export must call brandAngularSymbol(ClassName, deps({ ... })).',
+        ]);
+    }
+    const [, depsArgument] = expression.getArguments();
+    if (!Node.isCallExpression(depsArgument)) {
+        return invalidExistingDependencyGroups(defaultExport, [
+            'brandAngularSymbol must receive deps({ injected, importDeps, providers }).',
+        ]);
+    }
+    const depsCallTarget = depsArgument.getExpression();
+    if (!Node.isIdentifier(depsCallTarget) ||
+        depsCallTarget.getText() !== 'deps') {
+        return invalidExistingDependencyGroups(depsArgument, [
+            'brandAngularSymbol second argument must be a deps(...) call.',
+        ]);
+    }
+    const [depsObject] = depsArgument.getArguments();
+    if (!Node.isObjectLiteralExpression(depsObject)) {
+        return invalidExistingDependencyGroups(depsArgument, [
+            'deps(...) must be called with an object literal.',
+        ]);
+    }
+    const warnings = [];
+    const propertyNodes = {};
+    const dependencyGroups = {
+        injected: readExistingDependencyGroupProperty(depsObject, 'injected', warnings, propertyNodes),
+        importDeps: readExistingDependencyGroupProperty(depsObject, 'importDeps', warnings, propertyNodes),
+        providers: readExistingDependencyGroupProperty(depsObject, 'providers', warnings, propertyNodes),
+    };
+    return {
+        found: true,
+        warnings,
+        dependencyGroups,
+        exportAssignmentNode: defaultExport,
+        depsObjectNode: depsObject,
+        propertyNodes,
+    };
+}
+export function formatDependencyGroups(dependencyGroups) {
+    return [
+        `injected=[${dependencyGroups.injected.join(', ')}]`,
+        `importDeps=[${dependencyGroups.importDeps.join(', ')}]`,
+        `providers=[${dependencyGroups.providers.join(', ')}]`,
+    ].join(' ');
+}
+export function runAngularBrandCodemod() {
+    return __awaiter(this, arguments, void 0, function* (options = {}) {
+        var _a, _b, _c;
+        const rootDir = resolve((_a = options.rootDir) !== null && _a !== void 0 ? _a : process.cwd());
+        const tsConfigFilePath = options.tsConfigFilePath
+            ? resolve(options.tsConfigFilePath)
+            : getDefaultTsConfigPath(rootDir);
+        const project = createProject(tsConfigFilePath);
+        const files = collectTypeScriptFiles(rootDir);
+        project.addSourceFilesAtPaths(files);
+        setProjectQuoteKind(project);
+        const summary = {
+            transformedFiles: 0,
+            skippedFiles: 0,
+            warnings: 0,
+            countByAngularKind: {
+                component: 0,
+                directive: 0,
+                injectable: 0,
+                pipe: 0,
+            },
+            files: [],
+        };
+        for (const sourceFile of project.getSourceFiles()) {
+            if (!isWithinRoot(sourceFile.getFilePath(), rootDir)) {
+                continue;
+            }
+            const result = transformSourceFile(sourceFile, options);
+            const report = Object.assign(Object.assign({}, result), { filePath: sourceFile.getFilePath() });
+            summary.files.push(report);
+            summary.warnings += result.warnings.length;
+            if (result.changed) {
+                summary.transformedFiles += 1;
+                if (result.angularKind &&
+                    result.angularKind in summary.countByAngularKind) {
+                    summary.countByAngularKind[result.angularKind] += 1;
+                }
+                if (!options.dryRun) {
+                    yield sourceFile.save();
+                }
+            }
+            if (result.skipped) {
+                summary.skippedFiles += 1;
+            }
+            logFileResult(report, (_b = options.log) !== null && _b !== void 0 ? _b : console.log);
+        }
+        logSummary(summary, (_c = options.log) !== null && _c !== void 0 ? _c : console.log);
+        return summary;
+    });
+}
+function normalizeOptions(options) {
+    var _a, _b, _c, _d;
+    return {
+        helperImportPath: (_a = options.helperImportPath) !== null && _a !== void 0 ? _a : DEFAULT_OPTIONS.helperImportPath,
+        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,
+    };
+}
+function skip(result, warnings) {
+    result.skipped = true;
+    result.warnings.push(...warnings);
+    return result;
+}
+function getDecoratorName(decorator) {
+    const expression = decorator.getExpression();
+    if (Node.isCallExpression(expression)) {
+        const callTarget = expression.getExpression();
+        if (Node.isIdentifier(callTarget)) {
+            return callTarget.getText();
+        }
+        if (Node.isPropertyAccessExpression(callTarget)) {
+            return callTarget.getName();
+        }
+        return undefined;
+    }
+    if (Node.isIdentifier(expression)) {
+        return expression.getText();
+    }
+    if (Node.isPropertyAccessExpression(expression)) {
+        return expression.getName();
+    }
+    return undefined;
+}
+function decoratorLabel(angularKind) {
+    switch (angularKind) {
+        case 'component':
+            return '@Component';
+        case 'directive':
+            return '@Directive';
+        case 'pipe':
+            return '@Pipe';
+        case 'injectable':
+            return '@Injectable';
+    }
+}
+function getDecoratorMetadataObject(classDeclaration) {
+    var _a;
+    for (const decorator of classDeclaration.getDecorators()) {
+        if (!getAngularKindFromDecorator(decorator)) {
+            continue;
+        }
+        const callExpression = decorator.getCallExpression();
+        const [metadata] = (_a = callExpression === null || callExpression === void 0 ? void 0 : callExpression.getArguments()) !== null && _a !== void 0 ? _a : [];
+        if (Node.isObjectLiteralExpression(metadata)) {
+            return metadata;
+        }
+    }
+    return undefined;
+}
+function getAngularKindFromDecorator(decorator) {
+    const decoratorName = getDecoratorName(decorator);
+    return decoratorName && decoratorName in SUPPORTED_DECORATORS
+        ? SUPPORTED_DECORATORS[decoratorName]
+        : undefined;
+}
+function getObjectPropertyAssignment(objectLiteral, propertyName) {
+    const property = objectLiteral.getProperties().find((objectProperty) => {
+        if (!Node.isPropertyAssignment(objectProperty)) {
+            return false;
+        }
+        return getStaticPropertyName(objectProperty.getNameNode()) === propertyName;
+    });
+    return Node.isPropertyAssignment(property) ? property : undefined;
+}
+function extractDecoratorMetadataDepGroups(classDeclaration, angularKind, options) {
+    const metadata = getDecoratorMetadataObject(classDeclaration);
+    const groups = emptyMetadataDependencyGroups();
+    if (!metadata) {
+        return groups;
+    }
+    groups.imports = extractMetadataArrayProperty(metadata, 'imports', 'imports', groups.warnings);
+    groups.hostDirectives = extractMetadataArrayProperty(metadata, 'hostDirectives', 'hostDirectives', groups.warnings);
+    if (options.includeProviders) {
+        groups.providers = extractMetadataArrayProperty(metadata, 'providers', 'providers', groups.warnings);
+    }
+    if (options.includeViewProviders && angularKind === 'component') {
+        groups.viewProviders = extractMetadataArrayProperty(metadata, 'viewProviders', 'viewProviders', groups.warnings);
+    }
+    return groups;
+}
+function emptyMetadataDependencyGroups() {
+    return {
+        imports: [],
+        hostDirectives: [],
+        providers: [],
+        viewProviders: [],
+        warnings: [],
+    };
+}
+function extractMetadataArrayProperty(metadata, propertyName, context, 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 extractStaticArrayElements(initializer, context, warnings);
+}
+function extractStaticArrayElements(arrayLiteral, context, warnings) {
+    const dependencies = [];
+    for (const element of arrayLiteral.getElements()) {
+        if (Node.isArrayLiteralExpression(element)) {
+            dependencies.push(...extractStaticArrayElements(element, context, warnings));
+            continue;
+        }
+        if (Node.isSpreadElement(element)) {
+            warnings.push(`Skipped spread element in "${context}" metadata dependencies.`);
+            continue;
+        }
+        if (isProviderContext(context) && Node.isCallExpression(element)) {
+            const providerFactory = getStaticExpressionText(element.getExpression());
+            if (providerFactory) {
+                dependencies.push(providerFactory);
+                continue;
+            }
+        }
+        const dependency = getStaticExpressionText(element);
+        if (dependency) {
+            dependencies.push(dependency);
+            continue;
+        }
+        if (Node.isObjectLiteralExpression(element)) {
+            dependencies.push(...extractStaticObjectElementDependencies(element, context, warnings));
+            continue;
+        }
+        warnings.push(`Skipped complex expression "${element.getText()}" in "${context}" metadata dependencies.`);
+    }
+    return dependencies;
+}
+function isProviderContext(context) {
+    return context === 'providers' || context === 'viewProviders';
+}
+function extractStaticObjectElementDependencies(objectLiteral, context, warnings) {
+    const dependencies = [];
+    const knownValueProperties = context === 'hostDirectives'
+        ? new Set(['directive'])
+        : new Set(['provide', 'useClass', 'useExisting']);
+    for (const property of objectLiteral.getProperties()) {
+        if (!Node.isPropertyAssignment(property)) {
+            warnings.push(`Skipped complex object member in "${context}" metadata dependencies.`);
+            continue;
+        }
+        const propertyName = getStaticPropertyName(property.getNameNode());
+        if (!propertyName || !knownValueProperties.has(propertyName)) {
+            continue;
+        }
+        const dependency = getStaticExpressionText(property.getInitializer());
+        if (dependency) {
+            dependencies.push(dependency);
+            continue;
+        }
+        warnings.push(`Skipped complex "${propertyName}" value in "${context}" metadata dependencies.`);
+    }
+    return dependencies;
+}
+function getInjectDecoratorToken(decorators, warnings) {
+    var _a, _b;
+    for (const decorator of decorators) {
+        if (getDecoratorName(decorator) !== 'Inject') {
+            continue;
+        }
+        const [token] = (_b = (_a = decorator.getCallExpression()) === null || _a === void 0 ? void 0 : _a.getArguments()) !== null && _b !== void 0 ? _b : [];
+        const dependency = getStaticExpressionText(token);
+        if (!dependency) {
+            warnings.push('Skipped @Inject() dependency because the token is not a static identifier.');
+            return { found: true };
+        }
+        return { found: true, dependency };
+    }
+    return { found: false };
+}
+function getStaticExpressionText(expression) {
+    if (!expression) {
+        return undefined;
+    }
+    if (Node.isIdentifier(expression)) {
+        return expression.getText();
+    }
+    if (Node.isPropertyAccessExpression(expression)) {
+        return expression.getText();
+    }
+    return undefined;
+}
+function getStaticPropertyName(nameNode) {
+    if (Node.isIdentifier(nameNode)) {
+        return nameNode.getText();
+    }
+    if (Node.isStringLiteral(nameNode) || Node.isNumericLiteral(nameNode)) {
+        return nameNode.getLiteralText();
+    }
+    return undefined;
+}
+function getDependencyTextFromTypeNode(typeNode) {
+    if (isPrimitiveTypeNode(typeNode)) {
+        return undefined;
+    }
+    if (Node.isTypeReference(typeNode)) {
+        const typeName = typeNode.getTypeName();
+        const dependency = typeName.getText();
+        return isPrimitiveDependencyText(dependency) ? undefined : dependency;
+    }
+    if (Node.isExpressionWithTypeArguments(typeNode)) {
+        const expression = typeNode.getExpression();
+        return getStaticExpressionText(expression);
+    }
+    return undefined;
+}
+function isPrimitiveTypeNode(typeNode) {
+    return [
+        SyntaxKind.AnyKeyword,
+        SyntaxKind.BigIntKeyword,
+        SyntaxKind.BooleanKeyword,
+        SyntaxKind.FalseKeyword,
+        SyntaxKind.NeverKeyword,
+        SyntaxKind.NullKeyword,
+        SyntaxKind.NumberKeyword,
+        SyntaxKind.ObjectKeyword,
+        SyntaxKind.StringKeyword,
+        SyntaxKind.SymbolKeyword,
+        SyntaxKind.TrueKeyword,
+        SyntaxKind.UndefinedKeyword,
+        SyntaxKind.UnknownKeyword,
+        SyntaxKind.VoidKeyword,
+    ].includes(typeNode.getKind());
+}
+function isPrimitiveDependencyText(dependency) {
+    return PRIMITIVE_TYPE_TEXTS.has(dependency);
+}
+function isRuntimeSafeTypeDependency(typeNode, dependency) {
+    const identifiers = getDependencyIdentifiersFromTypeNode(typeNode);
+    if (identifiers.length === 0 ||
+        identifiers.map((identifier) => identifier.getText()).join('.') !==
+            dependency) {
+        return false;
+    }
+    const [rootIdentifier] = identifiers;
+    const leafIdentifier = identifiers[identifiers.length - 1];
+    const isQualifiedDependency = identifiers.length > 1;
+    return (isRuntimeSafeIdentifier(rootIdentifier, {
+        allowNamespaceContainer: isQualifiedDependency,
+    }) &&
+        isRuntimeSafeIdentifier(leafIdentifier, { allowNamespaceContainer: false }));
+}
+function getDependencyIdentifiersFromTypeNode(typeNode) {
+    if (!Node.isTypeReference(typeNode)) {
+        return [];
+    }
+    const typeName = typeNode.getTypeName();
+    if (Node.isIdentifier(typeName)) {
+        return [typeName];
+    }
+    return typeName.getDescendantsOfKind(SyntaxKind.Identifier);
+}
+function isRuntimeSafeIdentifier(identifier, options) {
+    var _a, _b;
+    const symbol = (_a = identifier.getSymbol()) !== null && _a !== void 0 ? _a : identifier.getType().getSymbol();
+    if (!symbol) {
+        return false;
+    }
+    const declarations = symbol.getDeclarations();
+    if (declarations.length === 0) {
+        return false;
+    }
+    if (declarations.some((declaration) => isTypeOnlyImportDeclaration(declaration))) {
+        return false;
+    }
+    if (options.allowNamespaceContainer &&
+        declarations.some((declaration) => Node.isNamespaceImport(declaration))) {
+        return true;
+    }
+    const aliasedSymbol = symbol.getAliasedSymbol();
+    const runtimeDeclarations = (_b = aliasedSymbol === null || aliasedSymbol === void 0 ? void 0 : aliasedSymbol.getDeclarations()) !== null && _b !== void 0 ? _b : declarations;
+    if (runtimeDeclarations.length === 0) {
+        return false;
+    }
+    return runtimeDeclarations.some((declaration) => isRuntimeValueDeclaration(declaration, options));
+}
+function isTypeOnlyImportDeclaration(declaration) {
+    var _a, _b;
+    if (Node.isImportSpecifier(declaration)) {
+        return (declaration.isTypeOnly() ||
+            declaration.getImportDeclaration().isTypeOnly());
+    }
+    if (Node.isImportClause(declaration)) {
+        return declaration.isTypeOnly();
+    }
+    if (Node.isNamespaceImport(declaration)) {
+        return ((_b = (_a = declaration
+            .getFirstAncestorByKind(SyntaxKind.ImportDeclaration)) === null || _a === void 0 ? void 0 : _a.isTypeOnly()) !== null && _b !== void 0 ? _b : false);
+    }
+    return false;
+}
+function isRuntimeValueDeclaration(declaration, options) {
+    if (Node.isClassDeclaration(declaration) ||
+        Node.isEnumDeclaration(declaration) ||
+        Node.isFunctionDeclaration(declaration) ||
+        Node.isVariableDeclaration(declaration)) {
+        return true;
+    }
+    if (options.allowNamespaceContainer &&
+        Node.isModuleDeclaration(declaration)) {
+        return true;
+    }
+    return false;
+}
+function getExportRewriteSafety(sourceFile, classDeclaration, className) {
+    const warnings = [];
+    for (const statement of sourceFile.getStatements()) {
+        if (Node.isFunctionDeclaration(statement) && statement.isDefaultExport()) {
+            warnings.push('Skipped file because it has an unrelated default-exported function.');
+        }
+        if (Node.isClassDeclaration(statement) &&
+            statement !== classDeclaration &&
+            statement.isDefaultExport()) {
+            warnings.push('Skipped file because it has an unrelated default-exported class.');
+        }
+    }
+    for (const exportAssignment of sourceFile.getExportAssignments()) {
+        if (exportAssignment.isExportEquals()) {
+            warnings.push('Skipped file because export = is not safe to combine with export default.');
+            continue;
+        }
+        if (!isDefaultIdentifierExport(exportAssignment, className) &&
+            !isDefaultBrandedExport(exportAssignment, className)) {
+            warnings.push(`Skipped file because it has a complex default export: ${exportAssignment.getText()}`);
+        }
+    }
+    for (const exportDeclaration of sourceFile.getExportDeclarations()) {
+        const defaultExportSpecifier = exportDeclaration
+            .getNamedExports()
+            .find((specifier) => {
+            var _a;
+            const alias = (_a = specifier.getAliasNode()) === null || _a === void 0 ? void 0 : _a.getText();
+            return (alias === 'default' || (!alias && specifier.getName() === 'default'));
+        });
+        if (defaultExportSpecifier &&
+            defaultExportSpecifier.getName() !== className) {
+            warnings.push('Skipped file because it has an unrelated named default export.');
+        }
+        if (exportDeclaration.getModuleSpecifier()) {
+            const reExportsClass = exportDeclaration
+                .getNamedExports()
+                .some((specifier) => specifier.getName() === className);
+            if (reExportsClass) {
+                warnings.push(`Skipped file because it re-exports "${className}" from another module.`);
+            }
+        }
+    }
+    return warnings.length === 0
+        ? { safe: true, warnings: [] }
+        : { safe: false, warnings };
+}
+function getHelperImportSafety(sourceFile, helperImportPath) {
+    const warnings = ['brandAngularSymbol', 'deps']
+        .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
+        ? { safe: true, warnings: [] }
+        : { safe: false, warnings };
+}
+function hasConflictingTopLevelBinding(sourceFile, helperImportPath, helperName) {
+    var _a, _b, _c, _d;
+    for (const importDeclaration of sourceFile.getImportDeclarations()) {
+        if (((_a = importDeclaration.getDefaultImport()) === null || _a === void 0 ? void 0 : _a.getText()) === helperName) {
+            return true;
+        }
+        if (((_b = importDeclaration.getNamespaceImport()) === null || _b === void 0 ? void 0 : _b.getText()) === helperName) {
+            return true;
+        }
+        for (const namedImport of importDeclaration.getNamedImports()) {
+            const localName = (_d = (_c = namedImport.getAliasNode()) === null || _c === void 0 ? void 0 : _c.getText()) !== null && _d !== void 0 ? _d : namedImport.getName();
+            if (localName !== helperName) {
+                continue;
+            }
+            return importDeclaration.getModuleSpecifierValue() !== helperImportPath;
+        }
+    }
+    for (const statement of sourceFile.getStatements()) {
+        if (Node.isClassDeclaration(statement) &&
+            statement.getName() === helperName) {
+            return true;
+        }
+        if (Node.isFunctionDeclaration(statement) &&
+            statement.getName() === helperName) {
+            return true;
+        }
+        if (Node.isEnumDeclaration(statement) &&
+            statement.getName() === helperName) {
+            return true;
+        }
+        if (Node.isInterfaceDeclaration(statement) &&
+            statement.getName() === helperName) {
+            return true;
+        }
+        if (Node.isTypeAliasDeclaration(statement) &&
+            statement.getName() === helperName) {
+            return true;
+        }
+        if (Node.isVariableStatement(statement)) {
+            const hasVariableName = statement
+                .getDeclarationList()
+                .getDeclarations()
+                .some((declaration) => declaration.getName() === helperName);
+            if (hasVariableName) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function isDefaultIdentifierExport(exportAssignment, className) {
+    if (exportAssignment.isExportEquals()) {
+        return false;
+    }
+    const expression = exportAssignment.getExpression();
+    return Node.isIdentifier(expression) && expression.getText() === className;
+}
+function isDefaultBrandedExport(exportAssignment, className) {
+    if (exportAssignment.isExportEquals()) {
+        return false;
+    }
+    const expression = exportAssignment.getExpression();
+    if (!Node.isCallExpression(expression)) {
+        return false;
+    }
+    const callTarget = expression.getExpression();
+    if (!Node.isIdentifier(callTarget) ||
+        callTarget.getText() !== 'brandAngularSymbol') {
+        return false;
+    }
+    const [targetClass] = expression.getArguments();
+    return Node.isIdentifier(targetClass) && targetClass.getText() === className;
+}
+function removeClassFromExportDeclaration(exportDeclaration, className) {
+    if (exportDeclaration.getModuleSpecifier()) {
+        return;
+    }
+    for (const namedExport of exportDeclaration.getNamedExports()) {
+        if (namedExport.getName() === className) {
+            namedExport.remove();
+        }
+    }
+    if (exportDeclaration.getNamedExports().length === 0) {
+        exportDeclaration.remove();
+    }
+}
+function hasLocalNamedImport(sourceFile, helperImportPath, importName) {
+    return sourceFile.getImportDeclarations().some((importDeclaration) => {
+        if (importDeclaration.getModuleSpecifierValue() !== helperImportPath) {
+            return false;
+        }
+        return importDeclaration.getNamedImports().some((namedImport) => {
+            var _a, _b;
+            const localName = (_b = (_a = namedImport.getAliasNode()) === null || _a === void 0 ? void 0 : _a.getText()) !== null && _b !== void 0 ? _b : namedImport.getName();
+            return localName === importName;
+        });
+    });
+}
+function createProject(tsConfigFilePath) {
+    if (tsConfigFilePath) {
+        return new Project({
+            skipAddingFilesFromTsConfig: true,
+            tsConfigFilePath,
+        });
+    }
+    return new Project({
+        compilerOptions: {
+            experimentalDecorators: true,
+            module: ts.ModuleKind.Preserve,
+            moduleResolution: ts.ModuleResolutionKind.Node10,
+            target: ts.ScriptTarget.ES2022,
+        },
+    });
+}
+function getDefaultTsConfigPath(rootDir) {
+    const tsConfigPath = join(rootDir, 'tsconfig.json');
+    return existsSync(tsConfigPath) ? tsConfigPath : undefined;
+}
+function collectTypeScriptFiles(rootDir) {
+    const files = [];
+    collectTypeScriptFilesInto(rootDir, files);
+    return files;
+}
+function collectTypeScriptFilesInto(directory, files) {
+    for (const entryName of readdirSync(directory)) {
+        const entryPath = join(directory, entryName);
+        const stats = statSync(entryPath);
+        if (stats.isDirectory()) {
+            if (!IGNORED_DIRECTORIES.has(entryName)) {
+                collectTypeScriptFilesInto(entryPath, files);
+            }
+            continue;
+        }
+        if (!stats.isFile() ||
+            extname(entryName) !== '.ts' ||
+            isGeneratedFile(entryPath)) {
+            continue;
+        }
+        files.push(entryPath);
+    }
+}
+function isGeneratedFile(filePath) {
+    const fileName = basename(filePath);
+    return (GENERATED_FILE_SUFFIXES.some((suffix) => fileName.endsWith(suffix)) ||
+        filePath.includes('/generated/') ||
+        filePath.includes('\\generated\\'));
+}
+function setProjectQuoteKind(project) {
+    const firstModuleSpecifier = project
+        .getSourceFiles()
+        .flatMap((sourceFile) => sourceFile.getImportDeclarations())
+        .map((importDeclaration) => importDeclaration.getModuleSpecifier().getText())
+        .find(Boolean);
+    project.manipulationSettings.set({
+        quoteKind: (firstModuleSpecifier === null || firstModuleSpecifier === void 0 ? void 0 : firstModuleSpecifier.startsWith('"'))
+            ? QuoteKind.Double
+            : QuoteKind.Single,
+    });
+}
+function isWithinRoot(filePath, rootDir) {
+    const absoluteFilePath = isAbsolute(filePath) ? filePath : resolve(filePath);
+    return (absoluteFilePath === rootDir || absoluteFilePath.startsWith(`${rootDir}/`));
+}
+function logFileResult(report, log) {
+    if (!report.changed && !report.skipped && !report.angularKind) {
+        return;
+    }
+    const status = report.changed
+        ? 'transformed'
+        : report.skipped
+            ? 'skipped'
+            : 'unchanged';
+    const details = [
+        `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(', ')}]`,
+        `status=${status}`,
+    ].filter(Boolean);
+    log(details.join(' '));
+    for (const warning of report.warnings) {
+        log(`  warning: ${warning}`);
+    }
+}
+function logSummary(summary, log) {
+    log([
+        `summary transformed=${summary.transformedFiles}`,
+        `skipped=${summary.skippedFiles}`,
+        `warnings=${summary.warnings}`,
+        `components=${summary.countByAngularKind.component}`,
+        `directives=${summary.countByAngularKind.directive}`,
+        `pipes=${summary.countByAngularKind.pipe}`,
+        `injectables=${summary.countByAngularKind.injectable}`,
+    ].join(' '));
+}
+function parseCliArgs(argv) {
+    const options = {};
+    for (let index = 0; index < argv.length; index += 1) {
+        const arg = argv[index];
+        switch (arg) {
+            case '--root':
+                options.rootDir = argv[++index];
+                break;
+            case '--tsconfig':
+                options.tsConfigFilePath = argv[++index];
+                break;
+            case '--helper-import':
+                options.helperImportPath = argv[++index];
+                break;
+            case '--transform-only-standalone-declarables':
+                options.transformOnlyStandaloneDeclarables = true;
+                break;
+            case '--no-providers':
+                options.includeProviders = false;
+                break;
+            case '--no-view-providers':
+                options.includeViewProviders = false;
+                break;
+            case '--dry-run':
+                options.dryRun = true;
+                break;
+            case '--help':
+                printHelpAndExit();
+                break;
+            default:
+                throw new Error(`Unknown argument: ${arg}`);
+        }
+    }
+    return options;
+}
+function printHelpAndExit() {
+    console.log(`Usage: craft-brand [options]
+
+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.
+  --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().
+  --dry-run                                    Print results without writing files.
+  --help                                       Show this help.
+`);
+    process.exit(0);
+}
+if (require.main === module) {
+    runAngularBrandCodemod(parseCliArgs(process.argv.slice(2))).catch((error) => {
+        console.error(error);
+        process.exitCode = 1;
+    });
+}
+//# sourceMappingURL=angular-brand-codemod.js.map