@openrewrite/recipes-angular 1.9.0 → 1.10.0-20260813-195315

package/src/migration/migrate-model-with-output.ts

@@ -0,0 +1,201 @@
+/*
+ * Copyright 2026 the original author or authors.
+ *
+ * Moderne Proprietary. Only for use by Moderne customers under the terms of a commercial contract.
+ */
+
+import {emptyMarkers, ExecutionContext, markers as mkMarkers, randomId, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {JavaScriptVisitor, JS, maybeAddImport, maybeRemoveImport} from "@openrewrite/rewrite/javascript";
+import {emptySpace, isIdentifier, J, singleSpace} from "@openrewrite/rewrite/java";
+import {create} from "mutative";
+import {buildOptionsObject, buildPropertyAssignment, identifier, rightPadded} from "./js-support";
+
+export class MigrateModelWithOutput extends Recipe {
+    readonly name = "org.openrewrite.angular.migration.migrate-model-with-output";
+    readonly displayName: string = "Split a `model()` that has a matching explicit output";
+    readonly description: string = "Rewrites `foo = model()` to `fooInput = input({alias: 'foo'})` plus " +
+        "`foo = linkedSignal(this.fooInput)` when the same class also declares a `fooChange` output. " +
+        "`model()` already contributes a `fooChange` output, and Angular 22 rejects the resulting duplicate.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            protected async visitClassDeclaration(classDecl: J.ClassDeclaration, p: ExecutionContext): Promise<J | undefined> {
+                const c = await super.visitClassDeclaration(classDecl, p) as J.ClassDeclaration;
+                if (!c) return c;
+
+                const outputs = new Set<string>();
+                for (const stmt of c.body.statements) {
+                    const name = declaredName(stmt.element);
+                    if (name && declaresOutput(stmt.element)) outputs.add(name);
+                }
+                if (outputs.size === 0) return c;
+
+                let changed = false;
+                const newStatements = c.body.statements.flatMap(stmt => {
+                    const name = declaredName(stmt.element);
+                    if (!name || !outputs.has(`${name}Change`)) return [stmt];
+
+                    const varDecl = stmt.element as J.VariableDeclarations;
+                    const modelCall = modelInvocation(varDecl);
+                    if (!modelCall) return [stmt];
+
+                    const inputCall = toInputCall(modelCall, name);
+                    if (!inputCall) return [stmt];
+
+                    changed = true;
+                    const semicolon = mkMarkers({kind: 'org.openrewrite.java.marker.Semicolon' as const, id: randomId()});
+                    return [
+                        {...stmt, element: withNameAndInitializer(varDecl, `${name}Input`, inputCall), markers: semicolon},
+                        {...stmt, element: withNameAndInitializer(varDecl, name, linkedSignalCall(`${name}Input`)), markers: semicolon},
+                    ];
+                });
+
+                if (!changed) return c;
+
+                maybeAddImport(this, {module: '@angular/core', member: 'input'});
+                maybeAddImport(this, {module: '@angular/core', member: 'linkedSignal'});
+                maybeRemoveImport(this, '@angular/core', 'model');
+
+                return create(c, (draft: any) => {
+                    draft.body.statements = newStatements;
+                }) as J.ClassDeclaration;
+            }
+        };
+    }
+}
+
+function declaredName(statement: J): string | undefined {
+    if (statement.kind !== J.Kind.VariableDeclarations) return undefined;
+    const variables = (statement as J.VariableDeclarations).variables;
+    if (variables.length !== 1) return undefined;
+    const name = variables[0].element.name;
+    return isIdentifier(name) ? name.simpleName : undefined;
+}
+
+function declaresOutput(statement: J): boolean {
+    if (statement.kind !== J.Kind.VariableDeclarations) return false;
+    const varDecl = statement as J.VariableDeclarations;
+
+    if (varDecl.leadingAnnotations.some(a => isIdentifier(a.annotationType)
+        && (a.annotationType as J.Identifier).simpleName === 'Output')) {
+        return true;
+    }
+
+    return !!factoryInvocation(varDecl, 'output');
+}
+
+function modelInvocation(varDecl: J.VariableDeclarations): J.MethodInvocation | undefined {
+    return factoryInvocation(varDecl, 'model');
+}
+
+/** Matches `factory(...)` and `factory.required(...)` initializers. */
+function factoryInvocation(varDecl: J.VariableDeclarations, factory: string): J.MethodInvocation | undefined {
+    const initializer = varDecl.variables[0]?.element.initializer?.element;
+    if (!initializer || initializer.kind !== J.Kind.MethodInvocation) return undefined;
+
+    const call = initializer as J.MethodInvocation;
+    if (!isIdentifier(call.name)) return undefined;
+
+    if (!call.select) {
+        return call.name.simpleName === factory ? call : undefined;
+    }
+    const select = call.select.element;
+    return call.name.simpleName === 'required' && isIdentifier(select) && select.simpleName === factory ? call : undefined;
+}
+
+/**
+ * Turns the `model()` call into the matching `input()` call, aliased back to the original
+ * property name so templates keep binding to it. Returns undefined when the options argument
+ * is something other than an object literal, which we cannot merge an alias into.
+ */
+function toInputCall(modelCall: J.MethodInvocation, name: string): J.MethodInvocation | undefined {
+    const required = !!modelCall.select;
+    const args = (modelCall.arguments?.elements ?? []).filter(rp => rp.element.kind !== J.Kind.Empty);
+    const optionsIndex = required ? 0 : 1;
+    const options = args[optionsIndex]?.element;
+
+    let newArgs;
+    if (!options) {
+        newArgs = [...args, rightPadded({
+            ...buildOptionsObject([buildPropertyAssignment('alias', name)]),
+            prefix: args.length > 0 ? singleSpace : emptySpace,
+        })];
+    } else if (options.kind === J.Kind.NewClass && (options as J.NewClass).body) {
+        const body = (options as J.NewClass).body!;
+        const properties = body.statements.filter(rp => rp.element.kind !== J.Kind.Empty);
+        const hasAlias = properties.some(rp => {
+            const element = rp.element;
+            if (element.kind !== JS.Kind.PropertyAssignment) return false;
+            const propName = (element as JS.PropertyAssignment).name.element;
+            return isIdentifier(propName) && propName.simpleName === 'alias';
+        });
+        if (hasAlias) {
+            newArgs = args;
+        } else {
+            const withAlias = {
+                ...options,
+                body: {...body, statements: [rightPadded(buildPropertyAssignment('alias', name)), ...properties]},
+            };
+            newArgs = [...args];
+            newArgs[optionsIndex] = {...args[optionsIndex], element: withAlias};
+        }
+    } else {
+        return undefined;
+    }
+
+    return {
+        ...modelCall,
+        select: required ? {...modelCall.select!, element: identifier('input')} : undefined,
+        name: required ? modelCall.name : identifier('input'),
+        arguments: {...modelCall.arguments!, elements: newArgs},
+        methodType: undefined,
+    } as J.MethodInvocation;
+}
+
+function linkedSignalCall(inputName: string): J.MethodInvocation {
+    const thisAccess: J.FieldAccess = {
+        kind: J.Kind.FieldAccess,
+        id: randomId(),
+        prefix: emptySpace,
+        markers: emptyMarkers,
+        target: identifier('this'),
+        name: {kind: J.Kind.LeftPadded, before: emptySpace, element: identifier(inputName), markers: emptyMarkers},
+        type: undefined,
+    } as J.FieldAccess;
+
+    return {
+        kind: J.Kind.MethodInvocation,
+        id: randomId(),
+        prefix: singleSpace,
+        markers: emptyMarkers,
+        select: undefined,
+        typeParameters: undefined,
+        name: identifier('linkedSignal'),
+        arguments: {
+            kind: 'org.openrewrite.java.tree.JContainer',
+            before: emptySpace,
+            markers: emptyMarkers,
+            elements: [rightPadded(thisAccess)],
+        },
+        methodType: undefined,
+    } as unknown as J.MethodInvocation;
+}
+
+function withNameAndInitializer(varDecl: J.VariableDeclarations, name: string, call: J.MethodInvocation): any {
+    const namedVar = varDecl.variables[0].element;
+    return {
+        ...varDecl,
+        id: randomId(),
+        typeExpression: undefined,
+        variables: [{
+            ...varDecl.variables[0],
+            element: {
+                ...namedVar,
+                id: randomId(),
+                name: identifier(name, (namedVar.name as J.Identifier).prefix),
+                dimensionsAfterName: [],
+                initializer: {before: singleSpace, element: call, markers: emptyMarkers},
+            },
+        }],
+    };
+}

package/src/migration/remove-with-fetch.ts

@@ -0,0 +1,53 @@
+/*
+ * Copyright 2026 the original author or authors.
+ *
+ * Moderne Proprietary. Only for use by Moderne customers under the terms of a commercial contract.
+ */
+
+import {emptyMarkers, ExecutionContext, randomId, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {JavaScriptVisitor, maybeRemoveImport} from "@openrewrite/rewrite/javascript";
+import {emptySpace, isIdentifier, J} from "@openrewrite/rewrite/java";
+
+export class RemoveWithFetch extends Recipe {
+    readonly name = "org.openrewrite.angular.migration.remove-with-fetch";
+    readonly displayName: string = "Remove `withFetch()` from `provideHttpClient()`";
+    readonly description: string = "Removes the `withFetch()` feature from `provideHttpClient()` calls. " +
+        "Angular 22 uses the Fetch API by default and deprecated `withFetch()`, which can be safely removed.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            override async visitMethodInvocation(method: J.MethodInvocation, p: ExecutionContext): Promise<J | undefined> {
+                const m = await super.visitMethodInvocation(method, p) as J.MethodInvocation;
+                if (!m || m.name.simpleName !== 'provideHttpClient') return m;
+
+                const elements = m.arguments?.elements ?? [];
+                const retained = elements.filter(rp => !isWithFetchCall(rp.element));
+                if (retained.length === elements.length) return m;
+
+                maybeRemoveImport(this, '@angular/common/http', 'withFetch');
+
+                const newElements = retained.length > 0
+                    ? [{...retained[0], element: {...retained[0].element, prefix: elements[0].element.prefix}}, ...retained.slice(1)]
+                    : [{
+                        kind: J.Kind.RightPadded,
+                        element: {
+                            kind: J.Kind.Empty,
+                            id: randomId(),
+                            prefix: emptySpace,
+                            markers: emptyMarkers,
+                        } as J.Empty,
+                        after: emptySpace,
+                        markers: emptyMarkers,
+                    } as J.RightPadded<any>];
+
+                return {...m, arguments: {...m.arguments!, elements: newElements}} as J.MethodInvocation;
+            }
+        }();
+    }
+}
+
+function isWithFetchCall(expression: J): boolean {
+    if (expression.kind !== J.Kind.MethodInvocation) return false;
+    const invocation = expression as J.MethodInvocation;
+    return !invocation.select && isIdentifier(invocation.name) && invocation.name.simpleName === 'withFetch';
+}

package/src/migration/rename-angular-js-globals.ts

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2026 the original author or authors.
+ *
+ * Moderne Proprietary. Only for use by Moderne customers under the terms of a commercial contract.
+ */
+
+import {ExecutionContext, produceAsync, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {JavaScriptVisitor} from "@openrewrite/rewrite/javascript";
+import {J} from "@openrewrite/rewrite/java";
+
+const RENAMES: Record<string, string> = {
+    getAngularLib: 'getAngularJSGlobal',
+    setAngularLib: 'setAngularJSGlobal',
+};
+
+export class RenameAngularJsGlobals extends Recipe {
+    readonly name = "org.openrewrite.angular.migration.rename-angular-js-globals";
+    readonly displayName: string = "Rename `getAngularLib`/`setAngularLib` to `getAngularJSGlobal`/`setAngularJSGlobal`";
+    readonly description: string = "Renames the `getAngularLib` and `setAngularLib` functions from `@angular/upgrade` to " +
+        "`getAngularJSGlobal` and `setAngularJSGlobal`. The deprecated aliases were removed in Angular 22.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            override async visitIdentifier(identifier: J.Identifier, p: ExecutionContext): Promise<J | undefined> {
+                const id = await super.visitIdentifier(identifier, p) as J.Identifier;
+                if (!id) return id;
+
+                const replacement = RENAMES[id.simpleName];
+                if (!replacement) return id;
+
+                return produceAsync(id, async draft => {
+                    draft.simpleName = replacement;
+                });
+            }
+        }();
+    }
+}

package/src/migration/rename-default-change-detection.ts

@@ -0,0 +1,33 @@
+/*
+ * 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} from "@openrewrite/rewrite/javascript";
+import {isIdentifier, J} from "@openrewrite/rewrite/java";
+
+export class RenameDefaultChangeDetection extends Recipe {
+    readonly name = "org.openrewrite.angular.migration.rename-default-change-detection";
+    readonly displayName: string = "Rename `ChangeDetectionStrategy.Default` to `ChangeDetectionStrategy.Eager`";
+    readonly description: string = "Renames the deprecated `ChangeDetectionStrategy.Default` enum member to its Angular 22 " +
+        "replacement `ChangeDetectionStrategy.Eager`. Both members have the same value, so the change is behavior preserving.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            protected async visitFieldAccess(fieldAccess: J.FieldAccess, p: ExecutionContext): Promise<J | undefined> {
+                const f = await super.visitFieldAccess(fieldAccess, p) as J.FieldAccess;
+                if (!f) return f;
+
+                if (!isIdentifier(f.target) || f.target.simpleName !== 'ChangeDetectionStrategy') return f;
+                if (f.name.element.simpleName !== 'Default') return f;
+
+                return {
+                    ...f,
+                    name: {...f.name, element: {...f.name.element, simpleName: 'Eager'}}
+                } as J.FieldAccess;
+            }
+        }();
+    }
+}

package/src/migration/rename-ssr-experimental-platform.ts

@@ -0,0 +1,108 @@
+/*
+ * 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 {getMemberKeyName, isMember, isObject, Json, JsonVisitor} from "@openrewrite/rewrite/json";
+
+const APPLICATION_BUILDERS = new Set([
+    '@angular-devkit/build-angular:application',
+    '@angular-devkit/build-angular:build-application',
+    '@angular/build:application',
+    '@angular/build:build-application',
+]);
+
+export class RenameSsrExperimentalPlatform extends Recipe {
+    readonly name = "org.openrewrite.angular.migration.rename-ssr-experimental-platform";
+    readonly displayName: string = "Rename `ssr.experimentalPlatform` to `ssr.platform` in `angular.json`";
+    readonly description: string = "Angular 22 renamed the `ssr.experimentalPlatform` builder option to `ssr.platform` on the " +
+        "`application` and `build-application` builders. Matches the `update-workspace-config` schematic.";
+
+    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;
+
+                const root = doc.value;
+                if (!isObject(root)) return doc;
+
+                const updated = mapProjects(root);
+                return updated === root ? doc : {...doc, value: updated} as Json.Document;
+            }
+        }();
+    }
+}
+
+function mapProjects(root: Json.Object): Json.Object {
+    return mapObjectMember(root, 'projects', projects =>
+        mapObjectMembers(projects, project => mapProject(project)));
+}
+
+function mapProject(project: Json.Object): Json.Object {
+    if (findMember(project, 'projectType')?.value !== 'application') return project;
+    return mapObjectMember(project, 'architect', architect =>
+        mapObjectMembers(architect, target => mapTarget(target)));
+}
+
+function mapTarget(target: Json.Object): Json.Object {
+    const builder = findMember(target, 'builder')?.value;
+    if (typeof builder !== 'string' || !APPLICATION_BUILDERS.has(builder)) return target;
+
+    let updated = mapObjectMember(target, 'options', renameSsrPlatform);
+    updated = mapObjectMember(updated, 'configurations', configurations =>
+        mapObjectMembers(configurations, renameSsrPlatform));
+    return updated;
+}
+
+function renameSsrPlatform(options: Json.Object): Json.Object {
+    return mapObjectMember(options, 'ssr', ssr => renameMember(ssr, 'experimentalPlatform', 'platform'));
+}
+
+/* ---------- small object helpers ---------- */
+
+function findMember(obj: Json.Object, key: string): {value: unknown; member: Json.Member} | undefined {
+    for (const rp of obj.members) {
+        if (!isMember(rp.element)) continue;
+        const m = rp.element as Json.Member;
+        if (getMemberKeyName(m) === key) return {value: (m.value as Json.Literal).value, member: m};
+    }
+    return undefined;
+}
+
+function mapObjectMember(obj: Json.Object, key: string, fn: (child: Json.Object) => Json.Object): Json.Object {
+    const members = obj.members.map(rp => {
+        if (!isMember(rp.element)) return rp;
+        const m = rp.element as Json.Member;
+        if (getMemberKeyName(m) !== key || !isObject(m.value)) return rp;
+        const updated = fn(m.value as Json.Object);
+        return updated === m.value ? rp : {...rp, element: {...m, value: updated} as Json.Member};
+    });
+    return members.every((rp, i) => rp === obj.members[i]) ? obj : {...obj, members};
+}
+
+function mapObjectMembers(obj: Json.Object, fn: (child: Json.Object) => Json.Object): Json.Object {
+    const members = obj.members.map(rp => {
+        if (!isMember(rp.element)) return rp;
+        const m = rp.element as Json.Member;
+        if (!isObject(m.value)) return rp;
+        const updated = fn(m.value as Json.Object);
+        return updated === m.value ? rp : {...rp, element: {...m, value: updated} as Json.Member};
+    });
+    return members.every((rp, i) => rp === obj.members[i]) ? obj : {...obj, members};
+}
+
+function renameMember(obj: Json.Object, from: string, to: string): Json.Object {
+    // If the target key already exists, leave the object alone rather than clobbering it.
+    if (findMember(obj, to)) return obj;
+
+    const members = obj.members.map(rp => {
+        if (!isMember(rp.element)) return rp;
+        const m = rp.element as Json.Member;
+        if (getMemberKeyName(m) !== from) return rp;
+        const newKey = {...m.key.element, source: `"${to}"`, value: to} as Json.Literal;
+        return {...rp, element: {...m, key: {...m.key, element: newKey}} as Json.Member};
+    });
+    return members.every((rp, i) => rp === obj.members[i]) ? obj : {...obj, members};
+}

package/src/migration/replace-create-ng-module-ref.ts

@@ -0,0 +1,32 @@
+/*
+ * Copyright 2026 the original author or authors.
+ *
+ * Moderne Proprietary. Only for use by Moderne customers under the terms of a commercial contract.
+ */
+
+import {ExecutionContext, produceAsync, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {JavaScriptVisitor, maybeAddImport, maybeRemoveImport} from "@openrewrite/rewrite/javascript";
+import {J} from "@openrewrite/rewrite/java";
+
+export class ReplaceCreateNgModuleRef extends Recipe {
+    readonly name = "org.openrewrite.angular.migration.replace-create-ng-module-ref";
+    readonly displayName: string = "Replace `createNgModuleRef` with `createNgModule`";
+    readonly description: string = "Renames `createNgModuleRef` to `createNgModule` in imports and usages. " +
+        "The deprecated `createNgModuleRef` alias was removed in Angular 22.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            override async visitIdentifier(identifier: J.Identifier, p: ExecutionContext): Promise<J | undefined> {
+                const id = await super.visitIdentifier(identifier, p) as J.Identifier;
+                if (!id || id.simpleName !== 'createNgModuleRef') return id;
+
+                maybeAddImport(this, {module: '@angular/core', member: 'createNgModule'});
+                maybeRemoveImport(this, '@angular/core', 'createNgModuleRef');
+
+                return produceAsync(id, async draft => {
+                    draft.simpleName = 'createNgModule';
+                });
+            }
+        }();
+    }
+}

package/src/migration/suppress-safe-navigation-diagnostics.ts

@@ -0,0 +1,42 @@
+/*
+ * 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 {detectIndent, isObject, Json, JsonVisitor} from "@openrewrite/rewrite/json";
+import {addMemberPath, declaresAngularCompilerOptions, isRootTsconfig, literal, memberIndent} from "./json-support";
+
+const SUPPRESSED_CHECKS = ['nullishCoalescingNotNullable', 'optionalChainNotNullable'];
+
+export class SuppressSafeNavigationDiagnostics extends Recipe {
+    readonly name = "org.openrewrite.angular.migration.suppress-safe-navigation-diagnostics";
+    readonly displayName: string = "Suppress the safe navigation extended diagnostics";
+    readonly description: string = "Sets the `nullishCoalescingNotNullable` and `optionalChainNotNullable` extended diagnostics to " +
+        "`suppress` in `angularCompilerOptions` in `tsconfig.json`. Angular 22 narrows types across safe navigation and " +
+        "nullish coalescing in templates, which makes both diagnostics fire on templates that previously compiled cleanly.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JsonVisitor<ExecutionContext> {
+            protected async visitDocument(doc: Json.Document, p: ExecutionContext): Promise<Json | undefined> {
+                if (!isRootTsconfig(doc.sourcePath) && !declaresAngularCompilerOptions(doc)) return doc;
+
+                const root = doc.value;
+                if (!isObject(root)) return doc;
+
+                const indentUnit = detectIndent(doc);
+                const indent = memberIndent(root, indentUnit);
+
+                let value = root;
+                for (const check of SUPPRESSED_CHECKS) {
+                    value = addMemberPath(value,
+                        ['angularCompilerOptions', 'extendedDiagnostics', 'checks', check],
+                        literal('"suppress"', 'suppress'), indent, indentUnit);
+                }
+
+                return value === root ? doc : {...doc, value} as Json.Document;
+            }
+        }();
+    }
+}

package/src/migration/upgrade-to-angular-22.ts

@@ -0,0 +1,92 @@
+/*
+ * 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 {upgradeDependencyVersion} from "@openrewrite/rewrite/javascript";
+import {UpgradeToAngular21CodeChanges} from "./upgrade-to-angular-21";
+import {FindProvideRoutesUsage} from "../search/find-provide-routes-usage";
+import {FindCheckNoChangesUsage} from "../search/find-check-no-changes-usage";
+import {FindCanMatchUsage} from "../search/find-can-match-usage";
+import {FindHttpXhrBackendUsage} from "../search/find-http-xhr-backend-usage";
+import {FindImplicitParamsInheritance} from "../search/find-implicit-params-inheritance";
+import {AddEagerChangeDetection} from "./add-eager-change-detection";
+import {RenameDefaultChangeDetection} from "./rename-default-change-detection";
+import {AddNoIncrementalHydration} from "./add-no-incremental-hydration";
+import {AddStrictTemplatesFalse} from "./add-strict-templates-false";
+import {SuppressSafeNavigationDiagnostics} from "./suppress-safe-navigation-diagnostics";
+import {AddWithXhr} from "./add-with-xhr";
+import {AddTrustProxyHeaders} from "./add-trust-proxy-headers";
+import {AddIstanbulInstrumenter} from "./add-istanbul-instrumenter";
+import {MigrateModelWithOutput} from "./migrate-model-with-output";
+import {FindTemplateSafeNavigation} from "../search/find-template-safe-navigation";
+import {ReplaceCreateNgModuleRef} from "./replace-create-ng-module-ref";
+import {RenameAngularJsGlobals} from "./rename-angular-js-globals";
+import {RenameSsrExperimentalPlatform} from "./rename-ssr-experimental-platform";
+
+export class UpgradeToAngular22CodeChanges extends Recipe {
+    readonly name = "org.openrewrite.angular.UpgradeToAngular22CodeChanges";
+    readonly displayName = "Upgrade to Angular 22 (code changes)";
+    readonly description = "The source changes of the Angular 22 migration, without the dependency version bumps. " +
+        "Use `UpgradeToAngular22` unless you are composing a migration to a later major.";
+
+    async recipeList(): Promise<Recipe[]> {
+        return [
+            new UpgradeToAngular21CodeChanges(),
+            // Removed and behaviorally changed APIs that need human review
+            new FindProvideRoutesUsage(),
+            new FindCheckNoChangesUsage(),
+            new FindCanMatchUsage(),
+            new FindHttpXhrBackendUsage(),
+            new FindImplicitParamsInheritance(),
+            new FindTemplateSafeNavigation(),
+            // Change detection defaults
+            new AddEagerChangeDetection(),
+            new RenameDefaultChangeDetection(),
+            // `HttpClient` backend default. `RemoveWithFetch` deliberately does not run here: dropping
+            // `withFetch()` would leave a call that `AddWithXhr` then flips onto the XHR backend.
+            new AddWithXhr(),
+            // Hydration and template type checking defaults
+            new AddNoIncrementalHydration(),
+            new AddStrictTemplatesFalse(),
+            new SuppressSafeNavigationDiagnostics(),
+            // Server rendering and test tooling
+            new AddTrustProxyHeaders(),
+            new RenameSsrExperimentalPlatform(),
+            new AddIstanbulInstrumenter(),
+            // Removed and deprecated APIs
+            new MigrateModelWithOutput(),
+            new ReplaceCreateNgModuleRef(),
+            new RenameAngularJsGlobals(),
+        ];
+    }
+}
+
+export class UpgradeToAngular22 extends Recipe {
+    readonly name = "org.openrewrite.angular.UpgradeToAngular22";
+    readonly displayName = "Upgrade to Angular 22";
+    readonly description = "Migrates Angular 21.x applications to Angular 22. " +
+        "This includes running the Angular 21 migration first, making the pre-existing change detection, " +
+        "`HttpClient` backend, incremental hydration, strict template, and safe navigation diagnostic defaults " +
+        "explicit, replacing APIs removed in Angular 22, flagging the router behavior changes for review, and " +
+        "upgrading TypeScript to 6.0.x.";
+
+    async recipeList(): Promise<Recipe[]> {
+        return [
+            new UpgradeToAngular22CodeChanges(),
+            // Angular core packages
+            await upgradeDependencyVersion({packagePattern: "@angular/*", newVersion: "22.x"}),
+            // Angular DevKit; `architect` and `build-webpack` kept the 0.<major><minor>.x CLI scheme
+            await upgradeDependencyVersion({packageName: "@angular-devkit/core", newVersion: "22.x"}),
+            await upgradeDependencyVersion({packagePattern: "@angular-devkit/s*", newVersion: "22.x"}),
+            await upgradeDependencyVersion({packageName: "@angular-devkit/build-angular", newVersion: "22.x"}),
+            await upgradeDependencyVersion({packagePattern: "@angular-devkit/architect*", newVersion: "0.2201.x"}),
+            await upgradeDependencyVersion({packageName: "@angular-devkit/build-webpack", newVersion: "0.2201.x"}),
+            await upgradeDependencyVersion({packageName: "@schematics/angular", newVersion: "22.x"}),
+            // TypeScript
+            await upgradeDependencyVersion({packageName: "typescript", newVersion: "6.0.x"}),
+        ];
+    }
+}

package/src/search/find-can-match-usage.ts

@@ -0,0 +1,32 @@
+/*
+ * Copyright 2026 the original author or authors.
+ *
+ * Moderne Proprietary. Only for use by Moderne customers under the terms of a commercial contract.
+ */
+
+import {ExecutionContext, foundSearchResult, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {JavaScriptVisitor} from "@openrewrite/rewrite/javascript";
+import {isIdentifier, J} from "@openrewrite/rewrite/java";
+
+export class FindCanMatchUsage extends Recipe {
+    readonly name = "org.openrewrite.angular.search.find-can-match-usage";
+    readonly displayName: string = "Find two argument `canMatch` guard calls";
+    readonly description: string = "Finds calls to a `canMatch` guard that pass only a route and its segments. " +
+        "Angular 22 made the `currentSnapshot` parameter of `CanMatch` and `CanMatchFn` required, so those calls no longer compile. " +
+        "Guards that declare fewer parameters keep working and are not reported.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            override async visitMethodInvocation(method: J.MethodInvocation, p: ExecutionContext): Promise<J | undefined> {
+                const m = await super.visitMethodInvocation(method, p) as J.MethodInvocation;
+                if (!m || !isIdentifier(m.name) || m.name.simpleName !== 'canMatch') return m;
+
+                const args = (m.arguments?.elements ?? []).filter(rp => rp.element.kind !== J.Kind.Empty);
+                if (args.length !== 2) return m;
+
+                return foundSearchResult(m,
+                    "The currentSnapshot parameter of CanMatch and CanMatchFn is required as of Angular 22. Pass the route snapshot as a third argument.");
+            }
+        };
+    }
+}

package/src/search/find-check-no-changes-usage.ts

@@ -0,0 +1,29 @@
+/*
+ * Copyright 2026 the original author or authors.
+ *
+ * Moderne Proprietary. Only for use by Moderne customers under the terms of a commercial contract.
+ */
+
+import {ExecutionContext, foundSearchResult, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {JavaScriptVisitor} from "@openrewrite/rewrite/javascript";
+import {isIdentifier, J} from "@openrewrite/rewrite/java";
+
+export class FindCheckNoChangesUsage extends Recipe {
+    readonly name = "org.openrewrite.angular.search.find-check-no-changes-usage";
+    readonly displayName: string = "Find `ChangeDetectorRef.checkNoChanges` usage";
+    readonly description: string = "Finds calls to `checkNoChanges()`, which was removed from `ChangeDetectorRef` in Angular 22. " +
+        "In tests, use `fixture.detectChanges()` instead.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            override async visitMethodInvocation(method: J.MethodInvocation, p: ExecutionContext): Promise<J | undefined> {
+                const m = await super.visitMethodInvocation(method, p) as J.MethodInvocation;
+                if (!m || !m.select) return m;
+                if (!isIdentifier(m.name) || m.name.simpleName !== 'checkNoChanges') return m;
+
+                return foundSearchResult(m,
+                    "ChangeDetectorRef.checkNoChanges() was removed in Angular 22. Use fixture.detectChanges() in tests instead.");
+            }
+        };
+    }
+}