@openrewrite/recipes-angular 0.0.0

package/src/migration/migrate-query-to-signal.ts

@@ -0,0 +1,276 @@
+/*
+ * Copyright 2026 the original author or authors.
+ *
+ * Moderne Proprietary. Only for use by Moderne customers under the terms of a commercial contract.
+ */
+
+import {ExecutionContext, randomId, emptyMarkers, markers as mkMarkers, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {JavaScriptVisitor, JS, maybeAddImport, maybeRemoveImport} from "@openrewrite/rewrite/javascript";
+import {J, isIdentifier, isLiteral, emptySpace, singleSpace} from "@openrewrite/rewrite/java";
+import {create} from "mutative";
+
+const ANGULAR_DECORATORS = ['Component', 'Directive', 'Pipe', 'Injectable'];
+
+const QUERY_DECORATOR_MAP: Record<string, string> = {
+    'ViewChild': 'viewChild',
+    'ViewChildren': 'viewChildren',
+    'ContentChild': 'contentChild',
+    'ContentChildren': 'contentChildren',
+};
+
+export class MigrateQueryToSignal extends Recipe {
+    readonly name = "org.openrewrite.angular.migration.migrate-query-to-signal";
+    readonly displayName: string = "Migrate query decorators to signal-based functions";
+    readonly description: string = "Converts `@ViewChild()`, `@ViewChildren()`, `@ContentChild()`, and `@ContentChildren()` " +
+        "decorated properties to signal-based query functions. For example, " +
+        "`@ViewChild('ref') el: ElementRef` becomes `el = viewChild<ElementRef>('ref')`.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            protected async visitClassDeclaration(classDecl: J.ClassDeclaration, p: ExecutionContext): Promise<J | undefined> {
+                let c = await super.visitClassDeclaration(classDecl, p) as J.ClassDeclaration;
+                if (!c) return c;
+
+                if (!c.leadingAnnotations.some(a => isIdentifier(a.annotationType)
+                    && ANGULAR_DECORATORS.includes((a.annotationType as J.Identifier).simpleName))) {
+                    return c;
+                }
+
+                let changed = false;
+                const usedFunctions = new Set<string>();
+                const removedDecorators = new Set<string>();
+
+                const newStatements = c.body.statements.map(stmt => {
+                    const el = stmt.element;
+                    if (el.kind !== J.Kind.VariableDeclarations) return stmt;
+
+                    const varDecl = el as J.VariableDeclarations;
+                    let queryIdx = -1;
+                    let queryName = '';
+                    for (let i = 0; i < varDecl.leadingAnnotations.length; i++) {
+                        const a = varDecl.leadingAnnotations[i];
+                        if (isIdentifier(a.annotationType)) {
+                            const name = (a.annotationType as J.Identifier).simpleName;
+                            if (QUERY_DECORATOR_MAP[name]) {
+                                queryIdx = i;
+                                queryName = name;
+                                break;
+                            }
+                        }
+                    }
+                    if (queryIdx === -1) return stmt;
+
+                    const annotation = varDecl.leadingAnnotations[queryIdx];
+                    if (!annotation.arguments?.elements?.length) return stmt;
+
+                    const funcName = QUERY_DECORATOR_MAP[queryName];
+                    const transformed = buildQueryField(varDecl, queryIdx, funcName, annotation);
+                    changed = true;
+                    usedFunctions.add(funcName);
+                    removedDecorators.add(queryName);
+                    return {
+                        ...stmt,
+                        element: transformed,
+                        markers: mkMarkers({kind: 'org.openrewrite.java.marker.Semicolon' as const, id: randomId()}),
+                    };
+                });
+
+                if (!changed) return c;
+
+                for (const func of usedFunctions) {
+                    maybeAddImport(this, {module: '@angular/core', member: func});
+                }
+                for (const dec of removedDecorators) {
+                    maybeRemoveImport(this, '@angular/core', dec);
+                }
+                maybeRemoveImport(this, '@angular/core', 'QueryList');
+
+                return create(c, (draft: any) => {
+                    draft.body.statements = newStatements;
+                }) as J.ClassDeclaration;
+            }
+        };
+    }
+}
+
+function unwrapTypeIdentifier(typeExpr: any): any {
+    if (typeExpr?.typeIdentifier) return unwrapTypeIdentifier(typeExpr.typeIdentifier);
+    return typeExpr;
+}
+
+function unwrapQueryListType(typeExpr: any): any {
+    const unwrapped = unwrapTypeIdentifier(typeExpr);
+    if (unwrapped?.kind === J.Kind.ParameterizedType) {
+        const pt = unwrapped as J.ParameterizedType;
+        if (isIdentifier(pt.class) && (pt.class as J.Identifier).simpleName === 'QueryList') {
+            if (pt.typeParameters?.elements?.length) {
+                return pt.typeParameters.elements[0].element;
+            }
+        }
+    }
+    return unwrapped;
+}
+
+interface QueryConfig {
+    selector: any;
+    selectorIsString: boolean;
+    options: any[] | undefined;
+}
+
+function parseQueryAnnotation(annotation: J.Annotation): QueryConfig {
+    const args = annotation.arguments!.elements;
+    const selector = args[0].element;
+    const selectorIsString = isLiteral(selector) && typeof (selector as J.Literal).value === 'string';
+
+    let options: any[] | undefined;
+    if (args.length > 1) {
+        const secondArg = args[1].element;
+        if (secondArg.kind === J.Kind.NewClass) {
+            const obj = secondArg as J.NewClass;
+            if (obj.body) {
+                const filteredProps = obj.body.statements.filter((stmt: any) => {
+                    const el = stmt.element;
+                    if (el.kind === JS.Kind.PropertyAssignment) {
+                        const prop = el as JS.PropertyAssignment;
+                        const nameExpr = prop.name.element;
+                        if (isIdentifier(nameExpr) && nameExpr.simpleName === 'static') {
+                            return false;
+                        }
+                    }
+                    return true;
+                });
+                if (filteredProps.length > 0) {
+                    options = filteredProps;
+                }
+            }
+        }
+    }
+
+    return {selector, selectorIsString, options};
+}
+
+function buildQueryField(varDecl: J.VariableDeclarations, annotationIdx: number, funcName: string, annotation: J.Annotation): any {
+    const namedVar = varDecl.variables[0].element;
+    const config = parseQueryAnnotation(annotation);
+
+    // Determine type parameter
+    const propertyType = varDecl.typeExpression ? unwrapQueryListType(varDecl.typeExpression) : null;
+    const needsTypeParam = config.selectorIsString && propertyType && !config.options?.some((stmt: any) => {
+        const el = stmt.element;
+        return el.kind === JS.Kind.PropertyAssignment
+            && isIdentifier((el as JS.PropertyAssignment).name.element)
+            && ((el as JS.PropertyAssignment).name.element as J.Identifier).simpleName === 'read';
+    });
+
+    let typeParameters: any = undefined;
+    if (needsTypeParam && propertyType) {
+        typeParameters = {
+            kind: 'org.openrewrite.java.tree.JContainer',
+            before: emptySpace,
+            markers: emptyMarkers,
+            elements: [{
+                kind: J.Kind.RightPadded,
+                element: {...propertyType, id: randomId(), prefix: emptySpace},
+                after: emptySpace,
+                markers: emptyMarkers,
+            }],
+        };
+    }
+
+    // Build arguments
+    const args: any[] = [];
+
+    // First arg: selector
+    args.push({
+        kind: J.Kind.RightPadded,
+        element: {...config.selector, id: randomId(), prefix: emptySpace},
+        after: emptySpace,
+        markers: emptyMarkers,
+    });
+
+    // Second arg: options object (if any remain after filtering)
+    if (config.options) {
+        args.push({
+            kind: J.Kind.RightPadded,
+            element: buildOptionsObject(config.options),
+            after: emptySpace,
+            markers: emptyMarkers,
+        });
+    }
+
+    const queryCall: any = {
+        kind: J.Kind.MethodInvocation,
+        id: randomId(),
+        prefix: singleSpace,
+        markers: emptyMarkers,
+        select: undefined,
+        typeParameters,
+        name: {
+            kind: J.Kind.Identifier,
+            id: randomId(),
+            prefix: emptySpace,
+            markers: emptyMarkers,
+            simpleName: funcName,
+            annotations: [],
+            type: undefined,
+        },
+        arguments: {
+            kind: 'org.openrewrite.java.tree.JContainer',
+            before: emptySpace,
+            markers: emptyMarkers,
+            elements: args,
+        },
+        methodType: undefined,
+    };
+
+    const newAnnotations = [...varDecl.leadingAnnotations];
+    newAnnotations.splice(annotationIdx, 1);
+
+    return {
+        ...varDecl,
+        id: randomId(),
+        leadingAnnotations: newAnnotations,
+        typeExpression: undefined,
+        variables: [{
+            ...varDecl.variables[0],
+            element: {
+                ...namedVar,
+                prefix: emptySpace,
+                dimensionsAfterName: [],
+                initializer: {
+                    before: singleSpace,
+                    element: queryCall,
+                    markers: emptyMarkers,
+                },
+            },
+        }],
+    };
+}
+
+function buildOptionsObject(statements: any[]): any {
+    return {
+        kind: J.Kind.NewClass,
+        id: randomId(),
+        prefix: singleSpace,
+        markers: emptyMarkers,
+        enclosing: undefined,
+        new: emptySpace,
+        clazz: undefined,
+        arguments: {
+            kind: 'org.openrewrite.java.tree.JContainer',
+            before: emptySpace,
+            markers: emptyMarkers,
+            elements: [],
+        },
+        body: {
+            kind: J.Kind.Block,
+            id: randomId(),
+            prefix: emptySpace,
+            markers: emptyMarkers,
+            static: {kind: J.Kind.RightPadded, element: false, after: emptySpace, markers: emptyMarkers},
+            statements,
+            end: singleSpace,
+        },
+        constructorType: undefined,
+    };
+}

package/src/migration/migrate-to-solution-style-tsconfig.ts

@@ -0,0 +1,139 @@
+/*
+ * Copyright 2026 the original author or authors.
+ *
+ * Moderne Proprietary. Only for use by Moderne customers under the terms of a commercial contract.
+ */
+
+import {ExecutionContext, ScanningRecipe, SourceFile, Tree, TreePrinters, TreeVisitor} from "@openrewrite/rewrite";
+import {isJson, Json, JsonParser, JsonVisitor, getMemberKeyName, isLiteral} from "@openrewrite/rewrite/json";
+
+interface Accumulator {
+    originalTsconfigContent: string | null;
+    baseAlreadyExists: boolean;
+    extendingPaths: string[];
+}
+
+export class MigrateToSolutionStyleTsconfig extends ScanningRecipe<Accumulator> {
+    readonly name = "org.openrewrite.angular.migration.migrate-to-solution-style-tsconfig";
+    readonly displayName: string = "Migrate to solution-style tsconfig";
+    readonly description: string = "Migrates a project to use a solution-style `tsconfig.json`. " +
+        "The original `tsconfig.json` content is moved to `tsconfig.base.json` (with project-specific " +
+        "fields removed), and `tsconfig.json` is replaced with a solution-style config that references " +
+        "the project's TypeScript configurations. Other tsconfig files that extend `./tsconfig.json` " +
+        "are updated to extend `./tsconfig.base.json`.";
+
+    initialValue(_ctx: ExecutionContext): Accumulator {
+        return {
+            originalTsconfigContent: null,
+            baseAlreadyExists: false,
+            extendingPaths: [],
+        };
+    }
+
+    async scanner(acc: Accumulator): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends TreeVisitor<Tree, ExecutionContext> {
+            protected async accept(tree: Tree, _ctx: ExecutionContext): Promise<Tree | undefined> {
+                if (!isJson(tree)) return tree;
+                const doc = tree as Json.Document;
+
+                if (doc.sourcePath === 'tsconfig.base.json') {
+                    acc.baseAlreadyExists = true;
+                    return doc;
+                }
+
+                if (doc.sourcePath === 'tsconfig.json') {
+                    const content = await TreePrinters.print(doc);
+                    try {
+                        const parsed = JSON.parse(content);
+                        if (Array.isArray(parsed.files) && parsed.files.length === 0 && parsed.references) {
+                            return doc;
+                        }
+                        acc.originalTsconfigContent = content;
+                    } catch {}
+                    return doc;
+                }
+
+                if (/^tsconfig\.\w+\.json$/.test(doc.sourcePath)) {
+                    const content = await TreePrinters.print(doc);
+                    try {
+                        const parsed = JSON.parse(content);
+                        if (parsed.extends === './tsconfig.json') {
+                            acc.extendingPaths.push(doc.sourcePath);
+                        }
+                    } catch {}
+                }
+
+                return doc;
+            }
+        };
+    }
+
+    async editorWithData(acc: Accumulator): Promise<TreeVisitor<any, ExecutionContext>> {
+        if (!acc.originalTsconfigContent || acc.baseAlreadyExists) {
+            return super.editorWithData(acc);
+        }
+
+        return new class extends JsonVisitor<ExecutionContext> {
+            private isExtendingFile = false;
+
+            protected async visitDocument(doc: Json.Document, ctx: ExecutionContext): Promise<Json | undefined> {
+                if (doc.sourcePath === 'tsconfig.json') {
+                    const solutionConfig: Record<string, any> = {files: []};
+                    if (acc.extendingPaths.length > 0) {
+                        solutionConfig.references = acc.extendingPaths.map(p => ({path: `./${p}`}));
+                    }
+                    const text = JSON.stringify(solutionConfig, null, 2) + '\n';
+                    const parsed = await new JsonParser({}).parseOne({
+                        text,
+                        sourcePath: doc.sourcePath
+                    }) as Json.Document;
+                    return {
+                        ...doc,
+                        value: parsed.value,
+                        eof: parsed.eof
+                    } as Json.Document;
+                }
+
+                this.isExtendingFile = acc.extendingPaths.includes(doc.sourcePath);
+                return super.visitDocument(doc, ctx);
+            }
+
+            protected async visitMember(member: Json.Member, p: ExecutionContext): Promise<Json | undefined> {
+                const m = await super.visitMember(member, p) as Json.Member;
+                if (!this.isExtendingFile) return m;
+                if (getMemberKeyName(m) !== 'extends') return m;
+                if (!isLiteral(m.value)) return m;
+                const literal = m.value as Json.Literal;
+                if (literal.value !== './tsconfig.json') return m;
+
+                return {
+                    ...m,
+                    value: {
+                        ...literal,
+                        value: './tsconfig.base.json',
+                        source: literal.source.replace('./tsconfig.json', './tsconfig.base.json'),
+                    } as Json.Literal
+                } as Json.Member;
+            }
+        };
+    }
+
+    async generate(acc: Accumulator, _ctx: ExecutionContext): Promise<SourceFile[]> {
+        if (!acc.originalTsconfigContent || acc.baseAlreadyExists) {
+            return [];
+        }
+
+        const parsed = JSON.parse(acc.originalTsconfigContent);
+        delete parsed.files;
+        delete parsed.include;
+        delete parsed.exclude;
+        delete parsed.references;
+
+        const text = JSON.stringify(parsed, null, 2) + '\n';
+        const doc = await new JsonParser({}).parseOne({
+            text,
+            sourcePath: 'tsconfig.base.json'
+        });
+        return [doc];
+    }
+}

package/src/migration/move-document-to-core.ts

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2026 the original author or authors.
+ *
+ * Moderne Proprietary. Only for use by Moderne customers under the terms of a commercial contract.
+ */
+
+import {Recipe} from "@openrewrite/rewrite";
+import {ChangeImport} from "@openrewrite/rewrite/javascript";
+
+const MODULE_HIERARCHY = ['@angular/platform-browser', '@angular/common', '@angular/core'];
+
+export class MoveDocumentImport extends Recipe {
+    readonly name = "org.openrewrite.angular.migration.move-document-import";
+    readonly displayName: string;
+    readonly description: string;
+    private readonly targetModule: string;
+
+    constructor(options?: { targetModule?: string }) {
+        super();
+        this.targetModule = options?.targetModule ?? '@angular/core';
+        this.displayName = `Move \`DOCUMENT\` import to \`${this.targetModule}\``;
+        this.description = `Moves the \`DOCUMENT\` import from older Angular modules to \`${this.targetModule}\`.`;
+    }
+
+    async recipeList(): Promise<Recipe[]> {
+        const targetIndex = MODULE_HIERARCHY.indexOf(this.targetModule);
+        return MODULE_HIERARCHY
+            .filter((_, i) => i < targetIndex)
+            .map(oldModule => new ChangeImport({
+                oldModule,
+                oldMember: 'DOCUMENT',
+                newModule: this.targetModule,
+            }));
+    }
+}
+
+/**
+ * @deprecated Use {@link MoveDocumentImport} instead.
+ */
+export const MoveDocumentToCore = MoveDocumentImport;

package/src/migration/remove-aot-summaries.ts

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2026 the original author or authors.
+ *
+ * Moderne Proprietary. Only for use by Moderne customers under the terms of a commercial contract.
+ */
+
+import {ExecutionContext, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {JavaScriptVisitor, JS, capture, pattern} from "@openrewrite/rewrite/javascript";
+import {J, isIdentifier} from "@openrewrite/rewrite/java";
+import {create} from "mutative";
+
+const TESTBED_METHODS = ['configureTestingModule', 'initTestEnvironment'];
+
+export class RemoveAotSummaries extends Recipe {
+    readonly name = "org.openrewrite.angular.migration.remove-aot-summaries";
+    readonly displayName: string = "Remove `aotSummaries` from TestBed";
+    readonly description: string = "Removes the `aotSummaries` property from `TestBed.configureTestingModule()` and " +
+        "`TestBed.initTestEnvironment()` calls. The `aotSummaries` parameter was removed in Angular 14 " +
+        "as it was only needed for the View Engine compiler.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            override async visitMethodInvocation(method: J.MethodInvocation, p: ExecutionContext): Promise<J | undefined> {
+                let m = await super.visitMethodInvocation(method, p) as J.MethodInvocation;
+                if (!m) return m;
+
+                const testBedArgs = capture({variadic: true});
+                if (!await pattern`TestBed.configureTestingModule(${testBedArgs})`.match(m, this.cursor)
+                    && !await pattern`TestBed.initTestEnvironment(${testBedArgs})`.match(m, this.cursor)) return m;
+
+                const args = (m as any).arguments?.elements;
+                if (!args || args.length === 0) return m;
+
+                for (let argIdx = 0; argIdx < args.length; argIdx++) {
+                    const arg = args[argIdx].element;
+                    if (arg.kind !== J.Kind.NewClass) continue;
+
+                    const obj = arg as J.NewClass;
+                    if (!obj.body) continue;
+
+                    let aotIndex = -1;
+                    for (let i = 0; i < obj.body.statements.length; i++) {
+                        const stmt = obj.body.statements[i].element;
+                        if (stmt.kind === JS.Kind.PropertyAssignment) {
+                            const prop = stmt as JS.PropertyAssignment;
+                            const nameExpr = prop.name.element;
+                            if (isIdentifier(nameExpr) && nameExpr.simpleName === 'aotSummaries') {
+                                aotIndex = i;
+                                break;
+                            }
+                        }
+                    }
+
+                    if (aotIndex === -1) continue;
+
+                    if (obj.body.statements.length === 1) {
+                        return create(m, draft => {
+                            (draft as any).arguments.elements = (draft as any).arguments.elements.filter((_: any, i: number) => i !== argIdx);
+                        }) as J.MethodInvocation;
+                    }
+
+                    return create(m, draft => {
+                        const body = ((draft as any).arguments.elements[argIdx].element as any).body;
+                        body.statements = body.statements.filter((_: any, i: number) => i !== aotIndex);
+                    }) as J.MethodInvocation;
+                }
+
+                return m;
+            }
+        }();
+    }
+}