@openrewrite/recipes-angular 0.0.0

package/src/search/find-i18n-usage.ts

@@ -0,0 +1,94 @@
+/*
+ * 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, JS} from "@openrewrite/rewrite/javascript";
+import {J} from "@openrewrite/rewrite/java";
+import {JsonVisitor, Json, getMemberKeyName, isLiteral} from "@openrewrite/rewrite/json";
+
+const I18N_CONFIG_KEYS = new Set(['i18nLocale', 'i18nFile', 'i18nFormat', 'i18nMissingTranslation']);
+
+class FindI18nConfigInAngularJson extends Recipe {
+    readonly name = "org.openrewrite.angular.search.find-i18n-usage.angular-json";
+    readonly displayName = "Find i18n configuration in `angular.json`";
+    readonly description = "Finds legacy i18n configuration keys (`i18nLocale`, `i18nFile`, `i18nFormat`, `i18nMissingTranslation`) 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;
+
+                const keyName = getMemberKeyName(m);
+                if (keyName && I18N_CONFIG_KEYS.has(keyName)) {
+                    return foundSearchResult(m,
+                        `Legacy i18n config \`${keyName}\`. Angular 9 requires \`@angular/localize\` for i18n support.`);
+                }
+
+                return m;
+            }
+        }();
+    }
+}
+
+class FindLocalizeUsageInTypeScript extends Recipe {
+    readonly name = "org.openrewrite.angular.search.find-i18n-usage.typescript";
+    readonly displayName = "Find `$localize` usage in TypeScript";
+    readonly description = "Finds `$localize` tagged template literal usage and `@angular/localize` imports.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            protected async visitImportDeclaration(jsImport: JS.Import, p: ExecutionContext): Promise<J | undefined> {
+                const imp = await super.visitImportDeclaration(jsImport, p) as JS.Import;
+                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 (moduleName === '@angular/localize' || moduleName.startsWith('@angular/localize/')) {
+                    return foundSearchResult(imp,
+                        "`@angular/localize` import. Ensure `import '@angular/localize/init'` is in `polyfills.ts`.");
+                }
+
+                return imp;
+            }
+
+            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;
+
+                if (id.simpleName === '$localize') {
+                    return foundSearchResult(id,
+                        "`$localize` usage. Ensure `@angular/localize` is installed and `import '@angular/localize/init'` is in `polyfills.ts`.");
+                }
+
+                return id;
+            }
+        };
+    }
+}
+
+export class FindI18nUsage extends Recipe {
+    readonly name = "org.openrewrite.angular.search.find-i18n-usage";
+    readonly displayName: string = "Find i18n usage";
+    readonly description: string = "Finds i18n usage indicators: legacy i18n configuration in `angular.json` " +
+        "(`i18nLocale`, `i18nFile`, `i18nFormat`, `i18nMissingTranslation`), `$localize` tagged template literals, " +
+        "and `@angular/localize` imports. Projects with these markers need `@angular/localize` installed and " +
+        "`import '@angular/localize/init'` in `polyfills.ts` for Angular 9+.";
+
+    async recipeList(): Promise<Recipe[]> {
+        return [
+            new FindI18nConfigInAngularJson(),
+            new FindLocalizeUsageInTypeScript(),
+        ];
+    }
+}

package/src/search/find-karma-usage.ts

@@ -0,0 +1,47 @@
+/*
+ * 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 {JsonVisitor, Json, getMemberKeyName, isLiteral} from "@openrewrite/rewrite/json";
+
+export class FindKarmaUsage extends Recipe {
+    readonly name = "org.openrewrite.angular.search.find-karma-usage";
+    readonly displayName: string = "Find Karma test runner usage";
+    readonly description: string = "Finds Karma test runner configuration in package.json dependencies and angular.json test builder. " +
+        "Angular 21 replaces Karma with Vitest as the default test runner.";
+
+    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('package.json') && !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;
+
+                const key = getMemberKeyName(m);
+                if (!key) return m;
+
+                if (key.startsWith('karma')) {
+                    return foundSearchResult(m,
+                        `Karma dependency '${key}'. Angular 21 uses Vitest as the default test runner. See https://angular.dev/guide/testing`);
+                }
+
+                if (key === 'builder' && isLiteral(m.value)) {
+                    const val = m.value.value as string;
+                    if (typeof val === 'string' && val.includes('karma')) {
+                        return foundSearchResult(m,
+                            "Karma test builder reference. Angular 21 uses Vitest as the default test runner. See https://angular.dev/guide/testing");
+                    }
+                }
+
+                return m;
+            }
+        }();
+    }
+}

package/src/search/find-load-children-string-usage.ts

@@ -0,0 +1,43 @@
+/*
+ * 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, JS} from "@openrewrite/rewrite/javascript";
+import {J, isIdentifier, isLiteral} from "@openrewrite/rewrite/java";
+
+export class FindLoadChildrenStringUsage extends Recipe {
+    readonly name = "org.openrewrite.angular.search.find-load-children-string-usage";
+    readonly displayName: string = "Find deprecated string-based `loadChildren` usage";
+    readonly description: string = "Finds usages of the deprecated string-based `loadChildren` syntax " +
+        "(e.g. `loadChildren: './path/to/module#ModuleName'`). " +
+        "String-based lazy loading was deprecated in Angular 8 and removed in Angular 11. " +
+        "Use dynamic imports instead: `loadChildren: () => import('./path/to/module').then(m => m.ModuleName)`.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            override async visitPropertyAssignment(prop: JS.PropertyAssignment, p: ExecutionContext): Promise<J | undefined> {
+                let pa = await super.visitPropertyAssignment(prop, p) as JS.PropertyAssignment;
+                if (!pa) return pa;
+
+                const nameExpr = pa.name.element;
+                if (!isIdentifier(nameExpr) || nameExpr.simpleName !== 'loadChildren') return pa;
+
+                if (!pa.initializer) return pa;
+
+                if (isLiteral(pa.initializer)) {
+                    const lit = pa.initializer as J.Literal;
+                    if (typeof lit.value === 'string' && lit.value.includes('#')) {
+                        return foundSearchResult(pa,
+                            "String-based `loadChildren` was removed in Angular 11. " +
+                            "Use dynamic imports: `loadChildren: () => import('...').then(m => m.ModuleName)`.");
+                    }
+                }
+
+                return pa;
+            }
+        }();
+    }
+}

package/src/search/find-missing-injectable.ts

@@ -0,0 +1,75 @@
+/*
+ * 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, JS} from "@openrewrite/rewrite/javascript";
+import {J, isIdentifier} from "@openrewrite/rewrite/java";
+
+const ANGULAR_DECORATORS = new Set(['Component', 'Directive', 'Pipe', 'Injectable', 'NgModule']);
+
+export class FindMissingInjectable extends Recipe {
+    readonly name = "org.openrewrite.angular.search.find-missing-injectable";
+    readonly displayName: string = "Find classes with DI dependencies but missing `@Injectable()`";
+    readonly description: string = "Finds classes that have constructor parameters (suggesting dependency injection) " +
+        "but lack an `@Injectable()` or other Angular class-level decorator. " +
+        "Angular 9 with Ivy requires an explicit `@Injectable()` decorator for all services that use dependency injection.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            private importsFromAngular = false;
+
+            protected async visitImportDeclaration(jsImport: JS.Import, p: ExecutionContext): Promise<J | undefined> {
+                const imp = await super.visitImportDeclaration(jsImport, p) as JS.Import;
+                if (!imp?.moduleSpecifier) return imp;
+
+                const moduleSpec = imp.moduleSpecifier.element;
+                if (moduleSpec.kind === J.Kind.Literal) {
+                    const moduleName = (moduleSpec as J.Literal).value as string;
+                    if (moduleName.startsWith('@angular/')) {
+                        this.importsFromAngular = true;
+                    }
+                }
+
+                return imp;
+            }
+
+            override async visitClassDeclaration(classDecl: J.ClassDeclaration, p: ExecutionContext): Promise<J | undefined> {
+                const cd = await super.visitClassDeclaration(classDecl, p) as J.ClassDeclaration;
+                if (!cd) return cd;
+
+                if (!this.importsFromAngular) return cd;
+
+                const hasAngularDecorator = cd.leadingAnnotations.some(a =>
+                    isIdentifier(a.annotationType) && ANGULAR_DECORATORS.has(a.annotationType.simpleName)
+                );
+                if (hasAngularDecorator) return cd;
+
+                let hasConstructorParams = false;
+                for (const stmt of cd.body.statements) {
+                    const el = stmt.element;
+                    if (el.kind !== J.Kind.MethodDeclaration) continue;
+                    const method = el as J.MethodDeclaration;
+                    if (method.name.simpleName !== 'constructor') continue;
+
+                    const params = method.parameters?.elements;
+                    if (params && params.length > 0) {
+                        const hasRealParams = params.some(rp => rp.element.kind !== J.Kind.Empty);
+                        if (hasRealParams) {
+                            hasConstructorParams = true;
+                        }
+                    }
+                    break;
+                }
+
+                if (!hasConstructorParams) return cd;
+
+                return foundSearchResult(cd,
+                    "Class has constructor dependencies but no `@Injectable()` decorator. " +
+                    "Angular 9 with Ivy requires an explicit `@Injectable()` for dependency injection to work.");
+            }
+        }();
+    }
+}

package/src/search/find-ng-class-usage.ts

@@ -0,0 +1,45 @@
+/*
+ * 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, JS} from "@openrewrite/rewrite/javascript";
+import {J, isIdentifier} from "@openrewrite/rewrite/java";
+
+export class FindNgClassUsage extends Recipe {
+    readonly name = "org.openrewrite.angular.search.find-ng-class-usage";
+    readonly displayName: string = "Find `NgClass` usage";
+    readonly description: string = "Finds imports of `NgClass` from `@angular/common`. " +
+        "The `ngClass` directive is soft deprecated in Angular 21 in favor of native `[class.*]` bindings.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            protected async visitImportDeclaration(jsImport: JS.Import, p: ExecutionContext): Promise<J | undefined> {
+                const imp = await super.visitImportDeclaration(jsImport, p) as JS.Import;
+                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 (moduleName !== '@angular/common') return imp;
+
+                const namedBindings = imp.importClause?.namedBindings;
+                if (namedBindings?.kind === JS.Kind.NamedImports) {
+                    const named = namedBindings as JS.NamedImports;
+                    for (const specifier of named.elements.elements) {
+                        const spec = specifier.element as JS.ImportSpecifier;
+                        if (isIdentifier(spec.specifier) && spec.specifier.simpleName === 'NgClass') {
+                            return foundSearchResult(imp,
+                                "NgClass is soft deprecated in Angular 21. Use native [class.*] bindings instead. See https://angular.dev/api/common/NgClass");
+                        }
+                    }
+                }
+
+                return imp;
+            }
+        };
+    }
+}

package/src/search/find-ng-style-usage.ts

@@ -0,0 +1,45 @@
+/*
+ * 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, JS} from "@openrewrite/rewrite/javascript";
+import {J, isIdentifier} from "@openrewrite/rewrite/java";
+
+export class FindNgStyleUsage extends Recipe {
+    readonly name = "org.openrewrite.angular.search.find-ng-style-usage";
+    readonly displayName: string = "Find `NgStyle` usage";
+    readonly description: string = "Finds imports of `NgStyle` from `@angular/common`. " +
+        "The `ngStyle` directive is soft deprecated in Angular 21 in favor of native `[style.*]` bindings.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            protected async visitImportDeclaration(jsImport: JS.Import, p: ExecutionContext): Promise<J | undefined> {
+                const imp = await super.visitImportDeclaration(jsImport, p) as JS.Import;
+                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 (moduleName !== '@angular/common') return imp;
+
+                const namedBindings = imp.importClause?.namedBindings;
+                if (namedBindings?.kind === JS.Kind.NamedImports) {
+                    const named = namedBindings as JS.NamedImports;
+                    for (const specifier of named.elements.elements) {
+                        const spec = specifier.element as JS.ImportSpecifier;
+                        if (isIdentifier(spec.specifier) && spec.specifier.simpleName === 'NgStyle') {
+                            return foundSearchResult(imp,
+                                "NgStyle is soft deprecated in Angular 21. Use native [style.*] bindings instead. See https://angular.dev/api/common/NgStyle");
+                        }
+                    }
+                }
+
+                return imp;
+            }
+        };
+    }
+}

package/src/search/find-path-match-type-usage.ts

@@ -0,0 +1,44 @@
+/*
+ * 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, JS} from "@openrewrite/rewrite/javascript";
+import {J, isIdentifier, isLiteral} from "@openrewrite/rewrite/java";
+
+const VALID_VALUES = ['full', 'prefix'];
+
+export class FindPathMatchTypeUsage extends Recipe {
+    readonly name = "org.openrewrite.angular.search.find-path-match-type-usage";
+    readonly displayName: string = "Find `pathMatch` route properties that may need type narrowing";
+    readonly description: string = "Finds `pathMatch` property assignments in route configurations. " +
+        "In Angular 14, the `pathMatch` type was narrowed from `string` to `'full' | 'prefix'`. " +
+        "Routes defined as plain objects without explicit `Route` or `Routes` typing may fail type checking.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            override async visitPropertyAssignment(prop: JS.PropertyAssignment, p: ExecutionContext): Promise<J | undefined> {
+                let pa = await super.visitPropertyAssignment(prop, p) as JS.PropertyAssignment;
+                if (!pa) return pa;
+
+                const nameExpr = pa.name.element;
+                if (!isIdentifier(nameExpr) || nameExpr.simpleName !== 'pathMatch') return pa;
+
+                if (!pa.initializer) return pa;
+
+                if (isLiteral(pa.initializer)) {
+                    const lit = pa.initializer as J.Literal;
+                    if (typeof lit.value === 'string' && VALID_VALUES.includes(lit.value)) {
+                        return pa;
+                    }
+                }
+
+                return foundSearchResult(pa,
+                    "pathMatch type narrowed to 'full' | 'prefix' in Angular 14. " +
+                    "Ensure the route object is typed as Route or Routes, or use an explicit literal value.");
+            }
+        }();
+    }
+}

package/src/search/find-platform-dynamic-server-usage.ts

@@ -0,0 +1,38 @@
+import {ExecutionContext, foundSearchResult, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {JavaScriptVisitor, JS} from "@openrewrite/rewrite/javascript";
+import {J, isIdentifier} from "@openrewrite/rewrite/java";
+
+export class FindPlatformDynamicServerUsage extends Recipe {
+    readonly name = "org.openrewrite.angular.search.find-platform-dynamic-server-usage";
+    readonly displayName: string = "Find `platformDynamicServer` usage";
+    readonly description: string = "Finds usages of the removed `platformDynamicServer` API from `@angular/platform-server`. In Angular 18, replace with `platformServer` and add `import '@angular/compiler'`.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            protected async visitImportDeclaration(jsImport: JS.Import, p: ExecutionContext): Promise<J | undefined> {
+                const imp = await super.visitImportDeclaration(jsImport, p) as JS.Import;
+                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 (moduleName !== '@angular/platform-server') return imp;
+
+                const namedBindings = imp.importClause?.namedBindings;
+                if (namedBindings?.kind === JS.Kind.NamedImports) {
+                    const named = namedBindings as JS.NamedImports;
+                    for (const specifier of named.elements.elements) {
+                        const spec = specifier.element as JS.ImportSpecifier;
+                        if (isIdentifier(spec.specifier) && spec.specifier.simpleName === 'platformDynamicServer') {
+                            return foundSearchResult(imp,
+                                "platformDynamicServer has been removed in Angular 18. Replace with platformServer and add import '@angular/compiler'.");
+                        }
+                    }
+                }
+
+                return imp;
+            }
+        };
+    }
+}

package/src/search/find-platform-webworker-usage.ts

@@ -0,0 +1,34 @@
+/*
+ * 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, JS} from "@openrewrite/rewrite/javascript";
+import {J} from "@openrewrite/rewrite/java";
+
+export class FindPlatformWebworkerUsage extends Recipe {
+    readonly name = "org.openrewrite.angular.search.find-platform-webworker-usage";
+    readonly displayName: string = "Find removed `@angular/platform-webworker` usage";
+    readonly description: string = "Finds imports from `@angular/platform-webworker` and `@angular/platform-webworker-dynamic`, " +
+        "which were removed in Angular 8 with no direct replacement.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            protected async visitImportDeclaration(jsImport: JS.Import, p: ExecutionContext): Promise<J | undefined> {
+                const imp = await super.visitImportDeclaration(jsImport, p) as JS.Import;
+                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 (moduleName !== '@angular/platform-webworker' && moduleName !== '@angular/platform-webworker-dynamic') return imp;
+
+                return foundSearchResult(imp,
+                    `\`${moduleName}\` was removed in Angular 8 with no direct replacement.`);
+            }
+        };
+    }
+}

package/src/search/find-platform-worker-usage.ts

@@ -0,0 +1,39 @@
+import {ExecutionContext, foundSearchResult, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {JavaScriptVisitor, JS} from "@openrewrite/rewrite/javascript";
+import {J, isIdentifier} from "@openrewrite/rewrite/java";
+
+export class FindPlatformWorkerUsage extends Recipe {
+    readonly name = "org.openrewrite.angular.search.find-platform-worker-usage";
+    readonly displayName: string = "Find `isPlatformWorkerUi` and `isPlatformWorkerApp` usage";
+    readonly description: string = "Finds usages of the removed `isPlatformWorkerUi` and `isPlatformWorkerApp` APIs from `@angular/common`. These were removed in Angular 18 with no replacement, as they served no purpose since the removal of the WebWorker platform.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        const removedApis = new Set(['isPlatformWorkerUi', 'isPlatformWorkerApp']);
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            protected async visitImportDeclaration(jsImport: JS.Import, p: ExecutionContext): Promise<J | undefined> {
+                const imp = await super.visitImportDeclaration(jsImport, p) as JS.Import;
+                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 (moduleName !== '@angular/common') return imp;
+
+                const namedBindings = imp.importClause?.namedBindings;
+                if (namedBindings?.kind === JS.Kind.NamedImports) {
+                    const named = namedBindings as JS.NamedImports;
+                    for (const specifier of named.elements.elements) {
+                        const spec = specifier.element as JS.ImportSpecifier;
+                        if (isIdentifier(spec.specifier) && removedApis.has(spec.specifier.simpleName)) {
+                            return foundSearchResult(imp,
+                                `${spec.specifier.simpleName} has been removed from @angular/common in Angular 18 with no replacement.`);
+                        }
+                    }
+                }
+
+                return imp;
+            }
+        };
+    }
+}

package/src/search/find-preserve-fragment-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, JS} from "@openrewrite/rewrite/javascript";
+import {J, isIdentifier} from "@openrewrite/rewrite/java";
+
+export class FindPreserveFragmentUsage extends Recipe {
+    readonly name = "org.openrewrite.angular.search.find-preserve-fragment-usage";
+    readonly displayName: string = "Find deprecated `preserveFragment` usage";
+    readonly description: string = "Finds usages of the deprecated `preserveFragment` navigation option. " +
+        "`preserveFragment` was deprecated in Angular 4 and removed in Angular 11. " +
+        "Fragments are now preserved by default.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            override async visitPropertyAssignment(prop: JS.PropertyAssignment, p: ExecutionContext): Promise<J | undefined> {
+                let pa = await super.visitPropertyAssignment(prop, p) as JS.PropertyAssignment;
+                if (!pa) return pa;
+
+                const nameExpr = pa.name.element;
+                if (!isIdentifier(nameExpr) || nameExpr.simpleName !== 'preserveFragment') return pa;
+
+                return foundSearchResult(pa,
+                    "`preserveFragment` was removed in Angular 11. Fragments are now preserved by default.");
+            }
+        }();
+    }
+}

package/src/search/find-preserve-query-params-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, JS} from "@openrewrite/rewrite/javascript";
+import {J, isIdentifier} from "@openrewrite/rewrite/java";
+
+export class FindPreserveQueryParamsUsage extends Recipe {
+    readonly name = "org.openrewrite.angular.search.find-preserve-query-params-usage";
+    readonly displayName: string = "Find deprecated `preserveQueryParams` usage";
+    readonly description: string = "Finds usages of the deprecated `preserveQueryParams` navigation option. " +
+        "`preserveQueryParams` was deprecated in Angular 4 and removed in Angular 11. " +
+        "Use `queryParamsHandling: 'preserve'` instead.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            override async visitPropertyAssignment(prop: JS.PropertyAssignment, p: ExecutionContext): Promise<J | undefined> {
+                let pa = await super.visitPropertyAssignment(prop, p) as JS.PropertyAssignment;
+                if (!pa) return pa;
+
+                const nameExpr = pa.name.element;
+                if (!isIdentifier(nameExpr) || nameExpr.simpleName !== 'preserveQueryParams') return pa;
+
+                return foundSearchResult(pa,
+                    "`preserveQueryParams` was removed in Angular 11. Use `queryParamsHandling: 'preserve'` instead.");
+            }
+        }();
+    }
+}

package/src/search/find-provided-in-deprecated-usage.ts

@@ -0,0 +1,65 @@
+/*
+ * 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, JS} from "@openrewrite/rewrite/javascript";
+import {J, isIdentifier, isLiteral} from "@openrewrite/rewrite/java";
+
+const VALID_STRING_VALUES = new Set(['root', 'platform']);
+
+export class FindProvidedInDeprecatedUsage extends Recipe {
+    readonly name = "org.openrewrite.angular.search.find-provided-in-deprecated-usage";
+    readonly displayName: string = "Find deprecated `providedIn` values";
+    readonly description: string = "Finds usages of `providedIn: 'any'` and `providedIn: NgModule` " +
+        "in `@Injectable` and `InjectionToken` declarations. These were deprecated in Angular 15. " +
+        "Use `providedIn: 'root'` or add the service to `NgModule.providers` instead.";
+
+    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 (annotType.simpleName !== 'Injectable') 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 (const stmtPadded of newClass.body.statements) {
+                    const stmt = stmtPadded.element;
+                    if (stmt.kind !== JS.Kind.PropertyAssignment) continue;
+
+                    const prop = stmt as JS.PropertyAssignment;
+                    const nameExpr = prop.name.element;
+                    if (!isIdentifier(nameExpr) || nameExpr.simpleName !== 'providedIn') continue;
+                    if (!prop.initializer) continue;
+
+                    if (isLiteral(prop.initializer)) {
+                        const value = prop.initializer.value as string;
+                        if (value === 'any') {
+                            return foundSearchResult(a,
+                                "providedIn: 'any' is deprecated. Use providedIn: 'root' or add the service to NgModule.providers instead.");
+                        }
+                    } else if (isIdentifier(prop.initializer)) {
+                        const name = prop.initializer.simpleName;
+                        if (!VALID_STRING_VALUES.has(name)) {
+                            return foundSearchResult(a,
+                                `providedIn: ${name} (NgModule) is deprecated. Add the service to ${name}.providers instead.`);
+                        }
+                    }
+                }
+
+                return a;
+            }
+        }();
+    }
+}