@openrewrite/recipes-angular 0.0.0

package/src/migration/remove-ie-polyfills.ts

@@ -0,0 +1,118 @@
+/*
+ * 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} from "@openrewrite/rewrite/javascript";
+import {J} from "@openrewrite/rewrite/java";
+import {JsonVisitor, Json, getMemberKeyName, isLiteral, isArray} from "@openrewrite/rewrite/json";
+
+const IE_POLYFILL_PREFIXES = ['core-js/', 'core-js'];
+const IE_POLYFILL_EXACT = ['classlist.js', 'web-animations-js'];
+
+function isIePolyfill(moduleSpecifier: string): boolean {
+    if (IE_POLYFILL_EXACT.includes(moduleSpecifier)) return true;
+    return IE_POLYFILL_PREFIXES.some(prefix => moduleSpecifier.startsWith(prefix));
+}
+
+class RemoveIePolyfillImports extends Recipe {
+    readonly name = "org.openrewrite.angular.migration.remove-ie-polyfills.typescript";
+    readonly displayName = "Remove IE polyfill imports from `polyfills.ts`";
+    readonly description = "Removes IE11-specific polyfill imports from `polyfills.ts`.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            private inPolyfillsFile = false;
+
+            protected async visitJsCompilationUnit(cu: JS.CompilationUnit, p: ExecutionContext): Promise<J | undefined> {
+                this.inPolyfillsFile = cu.sourcePath.endsWith('polyfills.ts') || cu.sourcePath.endsWith('polyfills.js');
+                return super.visitJsCompilationUnit(cu, p);
+            }
+
+            protected async visitImportDeclaration(jsImport: JS.Import, p: ExecutionContext): Promise<J | undefined> {
+                const imp = await super.visitImportDeclaration(jsImport, p) as JS.Import;
+                if (!this.inPolyfillsFile) return imp;
+                if (!imp.moduleSpecifier) return imp;
+
+                const moduleSpec = imp.moduleSpecifier.element;
+                if (moduleSpec.kind !== J.Kind.Literal) return imp;
+
+                const moduleName = (moduleSpec as J.Literal).value as string;
+                if (isIePolyfill(moduleName)) {
+                    return undefined;
+                }
+
+                return imp;
+            }
+        };
+    }
+}
+
+class RemoveIePolyfillsFromAngularJson extends Recipe {
+    readonly name = "org.openrewrite.angular.migration.remove-ie-polyfills.angular-json";
+    readonly displayName = "Remove IE polyfills from `angular.json`";
+    readonly description = "Removes IE11-specific polyfill entries from the `polyfills` array in `angular.json`.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JsonVisitor<ExecutionContext> {
+            protected async visitDocument(doc: Json.Document, p: ExecutionContext): Promise<Json | undefined> {
+                if (!doc.sourcePath.endsWith('angular.json')) return doc;
+                return super.visitDocument(doc, p);
+            }
+
+            protected async visitMember(member: Json.Member, p: ExecutionContext): Promise<Json | undefined> {
+                const m = await super.visitMember(member, p) as Json.Member;
+                if (!m) return m;
+
+                if (getMemberKeyName(m) !== 'polyfills') return m;
+                if (!isArray(m.value)) return m;
+
+                const filtered = m.value.values.filter(rp => {
+                    const elem = rp.element;
+                    if (!isLiteral(elem)) return true;
+                    const val = elem.value as string;
+                    return typeof val !== 'string' || !isIePolyfill(val);
+                });
+
+                if (filtered.length === m.value.values.length) return m;
+
+                const values = [...filtered];
+                if (values.length > 0 && m.value.values.length > 0) {
+                    const originalFirstPrefix = m.value.values[0].element.prefix;
+                    const newFirst = values[0];
+                    if (newFirst.element.prefix !== originalFirstPrefix) {
+                        values[0] = {
+                            ...newFirst,
+                            element: {...newFirst.element, prefix: originalFirstPrefix}
+                        };
+                    }
+                }
+
+                const arr = m.value as Json.Array;
+                return {
+                    ...m,
+                    value: {
+                        ...arr,
+                        values
+                    } as Json.Array
+                } as Json.Member;
+            }
+        }();
+    }
+}
+
+export class RemoveIePolyfills extends Recipe {
+    readonly name = "org.openrewrite.angular.migration.remove-ie-polyfills";
+    readonly displayName: string = "Remove IE11 polyfills";
+    readonly description: string = "Removes IE11-specific polyfill imports (`core-js`, `classlist.js`, `web-animations-js`) " +
+        "from `polyfills.ts` and `angular.json`. Angular 13 dropped IE11 support, making these polyfills unnecessary.";
+
+    async recipeList(): Promise<Recipe[]> {
+        return [
+            new RemoveIePolyfillImports(),
+            new RemoveIePolyfillsFromAngularJson(),
+        ];
+    }
+}

package/src/migration/remove-module-id.ts

@@ -0,0 +1,59 @@
+/*
+ * 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} from "@openrewrite/rewrite/javascript";
+import {J, isIdentifier} from "@openrewrite/rewrite/java";
+import {create} from "mutative";
+
+const DECORATORS_WITH_MODULE_ID = ['Component', 'Directive'];
+
+export class RemoveModuleId extends Recipe {
+    readonly name = "org.openrewrite.angular.migration.remove-module-id";
+    readonly displayName: string = "Remove `moduleId`";
+    readonly description: string = "Removes the `moduleId` property from `@Component` and `@Directive` decorators. " +
+        "`moduleId` was deprecated in Angular 16 and removed in Angular 17 as it served no purpose since Ivy.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            override async visitAnnotation(annotation: J.Annotation, p: ExecutionContext): Promise<J | undefined> {
+                let a = await super.visitAnnotation(annotation, p) as J.Annotation;
+                if (!a) return a;
+
+                const annotType = a.annotationType;
+                if (!isIdentifier(annotType)) return a;
+                if (!DECORATORS_WITH_MODULE_ID.includes(annotType.simpleName)) return a;
+
+                if (!a.arguments?.elements?.length) return a;
+                const firstArg = a.arguments.elements[0].element;
+                if (firstArg.kind !== J.Kind.NewClass) return a;
+
+                const newClass = firstArg as J.NewClass;
+                if (!newClass.body) return a;
+
+                let moduleIdIndex = -1;
+                for (let i = 0; i < newClass.body.statements.length; i++) {
+                    const stmt = newClass.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 === 'moduleId') {
+                            moduleIdIndex = i;
+                            break;
+                        }
+                    }
+                }
+
+                if (moduleIdIndex === -1) return a;
+
+                return create(a, draft => {
+                    const body = (draft.arguments!.elements[0].element as any).body!;
+                    body.statements = body.statements.filter((_: any, i: number) => i !== moduleIdIndex);
+                }) as J.Annotation;
+            }
+        }();
+    }
+}

package/src/migration/remove-relative-link-resolution.ts

@@ -0,0 +1,64 @@
+/*
+ * 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";
+
+export class RemoveRelativeLinkResolution extends Recipe {
+    readonly name = "org.openrewrite.angular.migration.remove-relative-link-resolution";
+    readonly displayName: string = "Remove `relativeLinkResolution`";
+    readonly description: string = "Removes the `relativeLinkResolution` option from `RouterModule.forRoot()` calls. " +
+        "This option was deprecated in Angular 14 and removed in Angular 15.";
+
+    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 callArgs = capture({variadic: true});
+                if (!await pattern`RouterModule.forRoot(${callArgs})`.match(m, this.cursor)) return m;
+
+                const args = (m as any).arguments?.elements;
+                if (!args || args.length < 2) return m;
+
+                const optionsArg = args[1].element;
+                if (optionsArg.kind !== J.Kind.NewClass) return m;
+
+                const optionsObj = optionsArg as J.NewClass;
+                if (!optionsObj.body) return m;
+
+                let rlrIndex = -1;
+                for (let i = 0; i < optionsObj.body.statements.length; i++) {
+                    const stmt = optionsObj.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 === 'relativeLinkResolution') {
+                            rlrIndex = i;
+                            break;
+                        }
+                    }
+                }
+
+                if (rlrIndex === -1) return m;
+
+                if (optionsObj.body.statements.length === 1) {
+                    return create(m, draft => {
+                        (draft as any).arguments.elements = (draft as any).arguments.elements.filter((_: any, i: number) => i !== 1);
+                    }) as J.MethodInvocation;
+                }
+
+                return create(m, draft => {
+                    const body = ((draft as any).arguments.elements[1].element as any).body;
+                    body.statements = body.statements.filter((_: any, i: number) => i !== rlrIndex);
+                }) as J.MethodInvocation;
+            }
+        }();
+    }
+}

package/src/migration/remove-standalone-true.ts

@@ -0,0 +1,50 @@
+import {ExecutionContext, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {JavaScriptVisitor, JS} from "@openrewrite/rewrite/javascript";
+import {isIdentifier, isLiteral, J} from "@openrewrite/rewrite/java";
+import {create} from "mutative";
+
+const ANGULAR_DECORATORS = ['Component', 'Directive', 'Pipe'];
+
+export class RemoveStandaloneTrue extends Recipe {
+    readonly name = "org.openrewrite.angular.migration.remove-standalone-true";
+    readonly displayName: string = "Remove redundant `standalone: true`";
+    readonly description: string = "Removes the `standalone: true` property from Angular component, directive, and pipe decorators since standalone is the default in Angular 19+.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            override async visitAnnotation(annotation: J.Annotation, p: ExecutionContext): Promise<J | undefined> {
+                let a = await super.visitAnnotation(annotation, p) as J.Annotation;
+                if (!a) return a;
+
+                const annotType = a.annotationType;
+                if (!isIdentifier(annotType)) return a;
+                if (!ANGULAR_DECORATORS.includes(annotType.simpleName)) return a;
+
+                if (!a.arguments?.elements?.length) return a;
+                const firstArg = a.arguments.elements[0].element;
+                if (firstArg.kind !== J.Kind.NewClass) return a;
+
+                const newClass = firstArg as J.NewClass;
+                if (!newClass.body) return a;
+
+                for (let i = 0; i < newClass.body.statements.length; i++) {
+                    const stmt = newClass.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 === 'standalone'
+                            && prop.initializer && isLiteral(prop.initializer)
+                            && prop.initializer.value === true) {
+                            return create(a, draft => {
+                                const body = (draft.arguments!.elements[0].element as any).body!;
+                                body.statements = body.statements.filter((_: any, idx: number) => idx !== i);
+                            }) as J.Annotation;
+                        }
+                    }
+                }
+
+                return a;
+            }
+        }();
+    }
+}

package/src/migration/remove-static-false.ts

@@ -0,0 +1,71 @@
+/*
+ * 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} from "@openrewrite/rewrite/javascript";
+import {J, isIdentifier, isLiteral} from "@openrewrite/rewrite/java";
+import {create} from "mutative";
+
+const QUERY_DECORATORS = ['ViewChild', 'ContentChild', 'ViewChildren', 'ContentChildren'];
+
+export class RemoveStaticFalse extends Recipe {
+    readonly name = "org.openrewrite.angular.migration.remove-static-false";
+    readonly displayName: string = "Remove `static: false` from view queries";
+    readonly description: string = "Removes `static: false` from `@ViewChild`, `@ContentChild`, `@ViewChildren`, and `@ContentChildren` decorators. " +
+        "In Angular 9 with Ivy, `static: false` became the default behavior, making the explicit option unnecessary.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            override async visitAnnotation(annotation: J.Annotation, p: ExecutionContext): Promise<J | undefined> {
+                let a = await super.visitAnnotation(annotation, p) as J.Annotation;
+                if (!a) return a;
+
+                const annotType = a.annotationType;
+                if (!isIdentifier(annotType)) return a;
+                if (!QUERY_DECORATORS.includes(annotType.simpleName)) return a;
+
+                if (!a.arguments?.elements || a.arguments.elements.length < 2) return a;
+
+                const optionsArg = a.arguments.elements[1].element;
+                if (optionsArg.kind !== J.Kind.NewClass) return a;
+
+                const optionsObj = optionsArg as J.NewClass;
+                if (!optionsObj.body) return a;
+
+                let staticIndex = -1;
+                let staticValue: boolean | null = null;
+
+                for (let i = 0; i < optionsObj.body.statements.length; i++) {
+                    const stmt = optionsObj.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 === 'static') {
+                            staticIndex = i;
+                            if (prop.initializer && isLiteral(prop.initializer)) {
+                                staticValue = prop.initializer.value as boolean;
+                            }
+                            break;
+                        }
+                    }
+                }
+
+                if (staticIndex === -1 || staticValue !== false) return a;
+
+                if (optionsObj.body.statements.length === 1) {
+                    return create(a, draft => {
+                        draft.arguments!.elements = draft.arguments!.elements.filter((_: any, i: number) => i !== 1);
+                    }) as J.Annotation;
+                }
+
+                return create(a, draft => {
+                    const body = (draft.arguments!.elements[1].element as any).body;
+                    body.statements = body.statements.filter((_: any, i: number) => i !== staticIndex);
+                }) as J.Annotation;
+            }
+        }();
+    }
+}

package/src/migration/remove-zone-js-polyfill.ts

@@ -0,0 +1,55 @@
+import {ExecutionContext, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {JsonVisitor, Json, getMemberKeyName, isLiteral, isArray} from "@openrewrite/rewrite/json";
+
+export class RemoveZoneJsPolyfill extends Recipe {
+    readonly name = "org.openrewrite.angular.migration.remove-zone-js-polyfill";
+    readonly displayName: string = "Remove zone.js polyfill from angular.json";
+    readonly description: string = "Removes zone.js entries from the `polyfills` array in `angular.json`. Angular 20 supports zoneless change detection via `provideZonelessChangeDetection()`, making the zone.js polyfill unnecessary.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JsonVisitor<ExecutionContext> {
+            protected async visitDocument(doc: Json.Document, p: ExecutionContext): Promise<Json | undefined> {
+                if (!doc.sourcePath.endsWith('angular.json')) return doc;
+                return super.visitDocument(doc, p);
+            }
+
+            protected async visitMember(member: Json.Member, p: ExecutionContext): Promise<Json | undefined> {
+                const m = await super.visitMember(member, p) as Json.Member;
+                if (!m) return m;
+
+                if (getMemberKeyName(m) !== 'polyfills') return m;
+                if (!isArray(m.value)) return m;
+
+                const filtered = m.value.values.filter(rp => {
+                    const elem = rp.element;
+                    if (!isLiteral(elem)) return true;
+                    const val = elem.value as string;
+                    return val !== 'zone.js' && !val?.startsWith('zone.js/');
+                });
+
+                if (filtered.length === m.value.values.length) return m;
+
+                const values = [...filtered];
+                if (values.length > 0 && m.value.values.length > 0) {
+                    const originalFirstPrefix = m.value.values[0].element.prefix;
+                    const newFirst = values[0];
+                    if (newFirst.element.prefix !== originalFirstPrefix) {
+                        values[0] = {
+                            ...newFirst,
+                            element: {...newFirst.element, prefix: originalFirstPrefix}
+                        };
+                    }
+                }
+
+                const arr = m.value as Json.Array;
+                return {
+                    ...m,
+                    value: {
+                        ...arr,
+                        values
+                    } as Json.Array
+                } as Json.Member;
+            }
+        }();
+    }
+}

package/src/migration/rename-after-render.ts

@@ -0,0 +1,32 @@
+import {ExecutionContext, produceAsync, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {JavaScriptVisitor, maybeAddImport, maybeRemoveImport} from "@openrewrite/rewrite/javascript";
+import {J, Type} from "@openrewrite/rewrite/java";
+
+export class RenameAfterRender extends Recipe {
+    readonly name = "org.openrewrite.angular.migration.rename-after-render";
+    readonly displayName: string = "Rename `afterRender` to `afterEveryRender`";
+    readonly description: string = "Renames `afterRender` to `afterEveryRender` in imports and usages. The `afterRender` function was renamed to `afterEveryRender` in Angular 20, and Angular provides no migration schematic for this change.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            protected async visitMethodInvocation(method: J.MethodInvocation, p: ExecutionContext): Promise<J | undefined> {
+                const m = await super.visitMethodInvocation(method, p) as J.MethodInvocation;
+
+                if (m.name.simpleName === 'afterRender') {
+                    const methodType = m.methodType;
+                    if (methodType?.declaringType?.kind === Type.Kind.Class
+                        && (methodType.declaringType as Type.Class).fullyQualifiedName === '@angular/core') {
+                        maybeAddImport(this, {module: '@angular/core', member: 'afterEveryRender'});
+                        maybeRemoveImport(this, '@angular/core', 'afterRender');
+
+                        return produceAsync(m, async draft => {
+                            draft.name.simpleName = 'afterEveryRender';
+                        });
+                    }
+                }
+
+                return m;
+            }
+        };
+    }
+}

package/src/migration/rename-check-no-changes.ts

@@ -0,0 +1,29 @@
+import {ExecutionContext, produceAsync, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {JavaScriptVisitor, maybeAddImport, maybeRemoveImport} from "@openrewrite/rewrite/javascript";
+import {J} from "@openrewrite/rewrite/java";
+
+export class RenameCheckNoChanges extends Recipe {
+    readonly name = "org.openrewrite.angular.migration.rename-check-no-changes";
+    readonly displayName: string = "Rename `provideExperimentalCheckNoChangesForDebug` to `provideCheckNoChangesForDebug`";
+    readonly description: string = "Renames `provideExperimentalCheckNoChangesForDebug` to `provideCheckNoChangesForDebug` in imports and usages. The experimental API was promoted to developer preview in Angular 20.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            override async visitIdentifier(identifier: J.Identifier, p: ExecutionContext): Promise<J | undefined> {
+                let id = await super.visitIdentifier(identifier, p) as J.Identifier;
+                if (!id) return id;
+
+                if (id.simpleName === 'provideExperimentalCheckNoChangesForDebug') {
+                    maybeAddImport(this, {module: '@angular/core', member: 'provideCheckNoChangesForDebug'});
+                    maybeRemoveImport(this, '@angular/core', 'provideExperimentalCheckNoChangesForDebug');
+
+                    return produceAsync(id, async draft => {
+                        draft.simpleName = 'provideCheckNoChangesForDebug';
+                    });
+                }
+
+                return id;
+            }
+        }();
+    }
+}

package/src/migration/rename-file.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, Option, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {isSourceFile} from "@openrewrite/rewrite";
+import * as path from "path";
+
+// TODO Replace with org.openrewrite.RenameFile once RpcRecipe supports no-arg construction.
+//  Previously this used rpc.prepareRecipe("org.openrewrite.RenameFile", ...) but
+//  PrepareRecipe.installSubRecipes calls marketplace.install(subRecipe.constructor, [])
+//  which fails for RpcRecipe because its constructor requires positional parameters.
+export class RenameFile extends Recipe {
+    readonly name = "org.openrewrite.angular.migration.rename-file";
+    readonly displayName = "Rename file";
+    readonly description = "Renames files matching a glob pattern to a new file name, preserving the directory.";
+
+    @Option({
+        displayName: "File matcher",
+        description: "Glob pattern to match files (e.g., `**/browserslist`). " +
+            "Supports `**` prefix to match in any directory.",
+        example: "**/browserslist"
+    })
+    fileMatcher!: string;
+
+    @Option({
+        displayName: "File name",
+        description: "The new file name (just the basename, e.g., `.browserslistrc`).",
+        example: ".browserslistrc"
+    })
+    fileName!: string;
+
+    constructor(options?: { fileMatcher?: string; fileName?: string }) {
+        super(options);
+        this.fileMatcher ??= '';
+        this.fileName ??= '';
+    }
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        const pattern = this.fileMatcher;
+        const newName = this.fileName;
+        const matchFn = globToMatcher(pattern);
+
+        return new class extends TreeVisitor<any, ExecutionContext> {
+            protected async preVisit(tree: any, _: ExecutionContext): Promise<any> {
+                this.stopAfterPreVisit();
+                if (isSourceFile(tree)) {
+                    const normalized = tree.sourcePath.replace(/\\/g, '/');
+                    if (matchFn(normalized)) {
+                        const dir = path.posix.dirname(normalized);
+                        const newPath = dir === '.' ? newName : `${dir}/${newName}`;
+                        return {...tree, sourcePath: newPath};
+                    }
+                }
+                return tree;
+            }
+        }();
+    }
+}
+
+function globToMatcher(pattern: string): (filePath: string) => boolean {
+    if (pattern.startsWith('**/')) {
+        const suffix = pattern.slice(3);
+        return (filePath: string) => {
+            const basename = path.posix.basename(filePath);
+            return basename === suffix || filePath === suffix || filePath.endsWith('/' + suffix);
+        };
+    }
+    return (filePath: string) => filePath === pattern;
+}

package/src/migration/rename-pending-tasks.ts

@@ -0,0 +1,30 @@
+import {ExecutionContext, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {JavaScriptVisitor, maybeAddImport, maybeRemoveImport} from "@openrewrite/rewrite/javascript";
+import {J, isIdentifier} from "@openrewrite/rewrite/java";
+import {create} from "mutative";
+
+export class RenamePendingTasks extends Recipe {
+    readonly name = "org.openrewrite.angular.migration.rename-pending-tasks";
+    readonly displayName: string = "Rename `ExperimentalPendingTasks` to `PendingTasks`";
+    readonly description: string = "Renames `ExperimentalPendingTasks` to `PendingTasks` in imports and usages. `ExperimentalPendingTasks` was renamed in Angular 19.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            override async visitIdentifier(identifier: J.Identifier, p: ExecutionContext): Promise<J | undefined> {
+                let id = await super.visitIdentifier(identifier, p) as J.Identifier;
+                if (!id) return id;
+
+                if (id.simpleName === 'ExperimentalPendingTasks') {
+                    maybeAddImport(this, {module: '@angular/core', member: 'PendingTasks'});
+                    maybeRemoveImport(this, '@angular/core', 'ExperimentalPendingTasks');
+
+                    return create(id, draft => {
+                        draft.simpleName = 'PendingTasks';
+                    }) as J.Identifier;
+                }
+
+                return id;
+            }
+        }();
+    }
+}

package/src/migration/rename-zoneless-provider.ts

@@ -0,0 +1,29 @@
+import {ExecutionContext, produceAsync, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {JavaScriptVisitor, maybeAddImport, maybeRemoveImport} from "@openrewrite/rewrite/javascript";
+import {J} from "@openrewrite/rewrite/java";
+
+export class RenameZonelessProvider extends Recipe {
+    readonly name = "org.openrewrite.angular.migration.rename-zoneless-provider";
+    readonly displayName: string = "Rename `provideExperimentalZonelessChangeDetection` to `provideZonelessChangeDetection`";
+    readonly description: string = "Renames `provideExperimentalZonelessChangeDetection` to `provideZonelessChangeDetection` in imports and usages. The experimental API was promoted to developer preview in Angular 20.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            override async visitIdentifier(identifier: J.Identifier, p: ExecutionContext): Promise<J | undefined> {
+                let id = await super.visitIdentifier(identifier, p) as J.Identifier;
+                if (!id) return id;
+
+                if (id.simpleName === 'provideExperimentalZonelessChangeDetection') {
+                    maybeAddImport(this, {module: '@angular/core', member: 'provideZonelessChangeDetection'});
+                    maybeRemoveImport(this, '@angular/core', 'provideExperimentalZonelessChangeDetection');
+
+                    return produceAsync(id, async draft => {
+                        draft.simpleName = 'provideZonelessChangeDetection';
+                    });
+                }
+
+                return id;
+            }
+        }();
+    }
+}

package/src/migration/replace-async-with-wait-for-async.ts

@@ -0,0 +1,32 @@
+import {ExecutionContext, produceAsync, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {JavaScriptVisitor, maybeAddImport, maybeRemoveImport} from "@openrewrite/rewrite/javascript";
+import {J, Type} from "@openrewrite/rewrite/java";
+
+export class ReplaceAsyncWithWaitForAsync extends Recipe {
+    readonly name = "org.openrewrite.angular.migration.replace-async-with-wait-for-async";
+    readonly displayName: string = "Replace `async` with `waitForAsync`";
+    readonly description: string = "Replaces the removed `async` test helper from `@angular/core/testing` with `waitForAsync`. The `async` function was deprecated in Angular 11 and removed in Angular 18.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            protected async visitMethodInvocation(method: J.MethodInvocation, p: ExecutionContext): Promise<J | undefined> {
+                const m = await super.visitMethodInvocation(method, p) as J.MethodInvocation;
+
+                if (m.name.simpleName === 'async') {
+                    const methodType = m.methodType;
+                    if (methodType?.declaringType?.kind === Type.Kind.Class
+                        && (methodType.declaringType as Type.Class).fullyQualifiedName === '@angular/core/testing') {
+                        maybeAddImport(this, {module: '@angular/core/testing', member: 'waitForAsync'});
+                        maybeRemoveImport(this, '@angular/core/testing', 'async');
+
+                        return produceAsync(m, async draft => {
+                            draft.name.simpleName = 'waitForAsync';
+                        });
+                    }
+                }
+
+                return m;
+            }
+        };
+    }
+}