@openrewrite/recipes-angular 0.0.0

package/src/migration/replace-deep-zone-js-imports.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 {create} from "mutative";
+import {JsonVisitor, Json, getMemberKeyName, isLiteral, isArray} from "@openrewrite/rewrite/json";
+
+function resolveDeepZoneImport(path: string): string | undefined {
+    if (!path.startsWith('zone.js/dist/') && !path.startsWith('zone.js/bundles/')) {
+        return undefined;
+    }
+    return path.includes('testing') ? 'zone.js/testing' : 'zone.js';
+}
+
+class ReplaceDeepZoneJsTypeScriptImports extends Recipe {
+    readonly name = "org.openrewrite.angular.migration.replace-deep-zone-js-imports.typescript";
+    readonly displayName = "Replace deep `zone.js` TypeScript imports";
+    readonly description = "Replaces legacy deep TypeScript imports from `zone.js`.";
+
+    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 literal = moduleSpec as J.Literal;
+                const newModule = resolveDeepZoneImport(literal.value as string);
+                if (!newModule) return imp;
+
+                const quote = literal.valueSource?.charAt(0) ?? "'";
+                return create(imp, draft => {
+                    const specDraft: any = draft.moduleSpecifier!.element;
+                    specDraft.value = newModule;
+                    specDraft.valueSource = `${quote}${newModule}${quote}`;
+                }) as JS.Import;
+            }
+        };
+    }
+}
+
+class ReplaceDeepZoneJsAngularJsonPolyfills extends Recipe {
+    readonly name = "org.openrewrite.angular.migration.replace-deep-zone-js-imports.angular-json";
+    readonly displayName = "Replace deep `zone.js` polyfills in `angular.json`";
+    readonly description = "Replaces legacy deep `zone.js` entries in the `polyfills` array of `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;
+
+                let changed = false;
+                const newValues = m.value.values.map(rp => {
+                    const elem = rp.element;
+                    if (!isLiteral(elem)) return rp;
+                    const val = elem.value as string;
+                    if (typeof val !== 'string') return rp;
+
+                    const newVal = resolveDeepZoneImport(val);
+                    if (!newVal) return rp;
+
+                    changed = true;
+                    const src = elem.source as string;
+                    const quote = src?.charAt(0) ?? '"';
+                    return {
+                        ...rp,
+                        element: {
+                            ...elem,
+                            value: newVal,
+                            source: `${quote}${newVal}${quote}`,
+                        } as Json.Literal,
+                    };
+                });
+
+                if (!changed) return m;
+
+                return {
+                    ...m,
+                    value: {
+                        ...m.value,
+                        values: newValues,
+                    } as Json.Array,
+                } as Json.Member;
+            }
+        }();
+    }
+}
+
+export class ReplaceDeepZoneJsImports extends Recipe {
+    readonly name = "org.openrewrite.angular.migration.replace-deep-zone-js-imports";
+    readonly displayName: string = "Replace deep `zone.js` imports";
+    readonly description: string = "Replaces legacy deep imports from `zone.js` such as `zone.js/dist/zone` or `zone.js/bundles/zone-testing.js` " +
+        "with the standard `zone.js` or `zone.js/testing` imports, in both TypeScript files and `angular.json` polyfills. " +
+        "Deep imports are no longer allowed in Angular 17.";
+
+    async recipeList(): Promise<Recipe[]> {
+        return [
+            new ReplaceDeepZoneJsTypeScriptImports(),
+            new ReplaceDeepZoneJsAngularJsonPolyfills(),
+        ];
+    }
+}

package/src/migration/replace-http-client-module.ts

@@ -0,0 +1,276 @@
+import {ExecutionContext, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {randomId, emptyMarkers} from "@openrewrite/rewrite";
+import {JavaScriptVisitor, JS, maybeAddImport, maybeRemoveImport, template, Template, capture, pattern} from "@openrewrite/rewrite/javascript";
+import {J, isIdentifier, emptySpace, singleSpace} from "@openrewrite/rewrite/java";
+
+const HTTP_MODULES = new Set([
+    'HttpClientModule',
+    'HttpClientJsonpModule',
+    'HttpClientXsrfModule',
+]);
+
+const TESTING_MODULES = new Set([
+    'HttpClientTestingModule',
+]);
+
+interface HttpModuleInfo {
+    index: number;
+    name: string;
+    xsrfOptions?: any;
+}
+
+export class ReplaceHttpClientModule extends Recipe {
+    readonly name = "org.openrewrite.angular.migration.replace-http-client-module";
+    readonly displayName: string = "Replace `HttpClientModule` with `provideHttpClient()`";
+    readonly description: string = "Replaces deprecated `HttpClientModule`, `HttpClientJsonpModule`, `HttpClientXsrfModule`, and `HttpClientTestingModule` with their functional equivalents: `provideHttpClient()` with feature functions and `provideHttpClientTesting()`.";
+
+    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 !== 'NgModule') 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 importsIndex = -1;
+                let providersIndex = -1;
+
+                for (let i = 0; i < newClass.body.statements.length; i++) {
+                    const stmt = newClass.body.statements[i].element;
+                    if (stmt.kind !== JS.Kind.PropertyAssignment) continue;
+
+                    const prop = stmt as JS.PropertyAssignment;
+                    const nameExpr = prop.name.element;
+                    if (!isIdentifier(nameExpr)) continue;
+
+                    if (nameExpr.simpleName === 'imports') {
+                        importsIndex = i;
+                    } else if (nameExpr.simpleName === 'providers') {
+                        providersIndex = i;
+                    }
+                }
+
+                if (importsIndex === -1) return a;
+
+                const importsStmt = newClass.body.statements[importsIndex].element as any;
+                const importsArray = importsStmt.initializer;
+                if (!importsArray?.initializer?.elements) return a;
+
+                const elements = importsArray.initializer.elements;
+                const httpModules: HttpModuleInfo[] = [];
+                const testingModules: HttpModuleInfo[] = [];
+
+                for (let i = 0; i < elements.length; i++) {
+                    const elem = elements[i].element;
+                    if (elem.kind === J.Kind.Identifier) {
+                        const name = (elem as J.Identifier).simpleName;
+                        if (HTTP_MODULES.has(name)) {
+                            httpModules.push({index: i, name});
+                        } else if (TESTING_MODULES.has(name)) {
+                            testingModules.push({index: i, name});
+                        }
+                    } else if (elem.kind === J.Kind.MethodInvocation) {
+                        const xsrfOpts = capture<J>('xsrfOpts');
+                        const match = await pattern`HttpClientXsrfModule.withOptions(${xsrfOpts})`.match(elem, this.cursor);
+                        if (match) {
+                            httpModules.push({
+                                index: i,
+                                name: 'HttpClientXsrfModule',
+                                xsrfOptions: match.get(xsrfOpts),
+                            });
+                        }
+                    }
+                }
+
+                if (httpModules.length === 0 && testingModules.length === 0) return a;
+
+                const indicesToRemove = new Set([
+                    ...httpModules.map(m => m.index),
+                    ...testingModules.map(m => m.index),
+                ]);
+
+                for (const mod of httpModules) {
+                    maybeRemoveImport(this, '@angular/common/http', mod.name);
+                }
+                for (const mod of testingModules) {
+                    maybeRemoveImport(this, '@angular/common/http/testing', mod.name);
+                }
+
+                const features: string[] = [];
+                let hasXsrfOptions = false;
+                let xsrfOptionsNode: any = null;
+
+                if (httpModules.length > 0) {
+                    maybeAddImport(this, {module: '@angular/common/http', member: 'provideHttpClient', onlyIfReferenced: false});
+
+                    for (const mod of httpModules) {
+                        if (mod.name === 'HttpClientJsonpModule') {
+                            features.push('withJsonpSupport');
+                            maybeAddImport(this, {module: '@angular/common/http', member: 'withJsonpSupport', onlyIfReferenced: false});
+                        } else if (mod.name === 'HttpClientXsrfModule') {
+                            if (mod.xsrfOptions) {
+                                features.push('withXsrfConfiguration');
+                                hasXsrfOptions = true;
+                                xsrfOptionsNode = mod.xsrfOptions;
+                            }
+                            maybeAddImport(this, {module: '@angular/common/http', member: 'withXsrfConfiguration', onlyIfReferenced: false});
+                        }
+                    }
+                }
+
+                if (testingModules.length > 0) {
+                    maybeAddImport(this, {module: '@angular/common/http/testing', member: 'provideHttpClientTesting', onlyIfReferenced: false});
+                }
+
+                // Build new provider nodes using templates
+                const newProviders: J.RightPadded<any>[] = [];
+
+                if (httpModules.length > 0) {
+                    const builder = Template.builder().code('provideHttpClient(');
+                    for (let i = 0; i < features.length; i++) {
+                        if (i > 0) builder.code(', ');
+                        if (features[i] === 'withXsrfConfiguration' && hasXsrfOptions && xsrfOptionsNode) {
+                            builder.code('withXsrfConfiguration(').param(xsrfOptionsNode).code(')');
+                        } else {
+                            builder.code(`${features[i]}()`);
+                        }
+                    }
+                    builder.code(')');
+                    const provideCall = await builder.build().apply(a, this.cursor);
+                    newProviders.push({
+                        kind: J.Kind.RightPadded,
+                        element: {...provideCall, prefix: singleSpace},
+                        after: emptySpace,
+                        markers: emptyMarkers,
+                    });
+                }
+
+                if (testingModules.length > 0) {
+                    const testingCall = await template`provideHttpClientTesting()`.apply(a, this.cursor);
+                    newProviders.push({
+                        kind: J.Kind.RightPadded,
+                        element: {...testingCall, prefix: singleSpace},
+                        after: emptySpace,
+                        markers: emptyMarkers,
+                    });
+                }
+
+                const existingStmts = newClass.body.statements;
+                const newStatements = [...existingStmts];
+
+                // 1. Remove HTTP modules from imports array
+                const origContainer = importsArray.initializer;
+                const filteredElements = origContainer.elements.filter((_: any, i: number) => !indicesToRemove.has(i));
+
+                const newImportsStmt = {
+                    ...importsStmt,
+                    initializer: {
+                        ...importsArray,
+                        initializer: {
+                            ...origContainer,
+                            elements: filteredElements,
+                        },
+                    },
+                };
+                newStatements[importsIndex] = {
+                    ...newStatements[importsIndex],
+                    element: newImportsStmt,
+                };
+
+                // 2. Add providers
+                if (providersIndex !== -1) {
+                    const providersStmt = newStatements[providersIndex].element as any;
+                    const provArray = providersStmt.initializer;
+                    const provContainer = provArray.initializer;
+                    const hasRealElements = provContainer.elements?.some(
+                        (e: any) => e.element && (e.element.kind === J.Kind.Identifier
+                            || e.element.kind === J.Kind.MethodInvocation
+                            || e.element.kind === J.Kind.NewClass
+                            || e.element.kind === JS.Kind.PropertyAssignment));
+                    const existingElements = hasRealElements ? provContainer.elements : [];
+                    const newProvStmt = {
+                        ...providersStmt,
+                        initializer: {
+                            ...provArray,
+                            initializer: {
+                                ...provContainer,
+                                elements: [...existingElements, ...newProviders],
+                            },
+                        },
+                    };
+                    newStatements[providersIndex] = {
+                        ...newStatements[providersIndex],
+                        element: newProvStmt,
+                    };
+                } else {
+                    const refProp = existingStmts[0].element as JS.PropertyAssignment;
+                    newStatements.push({
+                        kind: J.Kind.RightPadded,
+                        element: buildProvidersProperty(newProviders, refProp.prefix),
+                        after: emptySpace,
+                        markers: emptyMarkers,
+                    } as J.RightPadded<any>);
+                }
+
+                const newBody = {...newClass.body, statements: newStatements};
+                const newNewClass = {...newClass, body: newBody};
+                return {
+                    ...a,
+                    arguments: {
+                        ...a.arguments!,
+                        elements: [{
+                            ...a.arguments!.elements[0],
+                            element: newNewClass,
+                        }],
+                    },
+                } as J.Annotation;
+            }
+        }();
+    }
+}
+
+function buildProvidersProperty(providerElements: J.RightPadded<any>[], propPrefix: any): JS.PropertyAssignment {
+    return {
+        kind: JS.Kind.PropertyAssignment,
+        id: randomId(),
+        markers: emptyMarkers,
+        prefix: propPrefix,
+        name: {
+            kind: J.Kind.RightPadded,
+            element: {
+                kind: J.Kind.Identifier,
+                id: randomId(),
+                markers: emptyMarkers,
+                prefix: emptySpace,
+                annotations: [],
+                simpleName: 'providers',
+            } as J.Identifier,
+            after: emptySpace,
+            markers: emptyMarkers,
+        },
+        assigmentToken: "Colon" as JS.PropertyAssignment.Token,
+        initializer: {
+            kind: J.Kind.NewArray,
+            id: randomId(),
+            markers: emptyMarkers,
+            prefix: singleSpace,
+            typeExpression: null,
+            dimensions: [],
+            initializer: {
+                kind: 'org.openrewrite.java.tree.JContainer',
+                before: emptySpace,
+                markers: emptyMarkers,
+                elements: providerElements,
+            },
+        } as any,
+    };
+}

package/src/migration/replace-initial-navigation.ts

@@ -0,0 +1,73 @@
+/*
+ * 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";
+
+export class ReplaceInitialNavigation extends Recipe {
+    readonly name = "org.openrewrite.angular.migration.replace-initial-navigation";
+    readonly displayName: string = "Replace `initialNavigation` option values";
+    readonly description: string = "Replaces deprecated `initialNavigation` router option values: " +
+        "`'legacy_enabled'` and `true` become `'enabledBlocking'`, `'legacy_disabled'` and `false` become `'disabled'`, " +
+        "and `'enabled'` becomes `'enabledNonBlocking'`. " +
+        "The legacy values were removed in Angular 11; `'enabled'` was renamed in Angular 14.";
+
+    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 !== 'initialNavigation') return pa;
+
+                if (!pa.initializer) return pa;
+
+                if (isLiteral(pa.initializer)) {
+                    const lit = pa.initializer as J.Literal;
+                    const replacements: Record<string, string> = {
+                        'legacy_enabled': 'enabledBlocking',
+                        'legacy_disabled': 'disabled',
+                        'enabled': 'enabledNonBlocking',
+                    };
+
+                    if (typeof lit.value === 'string' && lit.value in replacements) {
+                        const newValue = replacements[lit.value];
+                        return create(pa, draft => {
+                            (draft as any).initializer = {
+                                ...lit,
+                                value: newValue,
+                                valueSource: `'${newValue}'`,
+                            };
+                        }) as JS.PropertyAssignment;
+                    }
+                    if (lit.value === true) {
+                        return create(pa, draft => {
+                            (draft as any).initializer = {
+                                ...lit,
+                                value: 'enabledBlocking',
+                                valueSource: `'enabledBlocking'`,
+                            };
+                        }) as JS.PropertyAssignment;
+                    }
+                    if (lit.value === false) {
+                        return create(pa, draft => {
+                            (draft as any).initializer = {
+                                ...lit,
+                                value: 'disabled',
+                                valueSource: `'disabled'`,
+                            };
+                        }) as JS.PropertyAssignment;
+                    }
+                }
+
+                return pa;
+            }
+        }();
+    }
+}

package/src/migration/replace-inject-flags.ts

@@ -0,0 +1,83 @@
+import {ExecutionContext, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {JavaScriptVisitor, maybeRemoveImport, template, Template} from "@openrewrite/rewrite/javascript";
+import {J, Type} from "@openrewrite/rewrite/java";
+
+const FLAG_TO_OPTION: Record<string, string> = {
+    'Optional': 'optional',
+    'Host': 'host',
+    'Self': 'self',
+    'SkipSelf': 'skipSelf',
+};
+
+function collectInjectFlags(expr: J): string[] | undefined {
+    if (expr.kind === J.Kind.FieldAccess) {
+        const fieldAccess = expr as J.FieldAccess;
+        if (fieldAccess.target.kind !== J.Kind.Identifier) return undefined;
+        if ((fieldAccess.target as J.Identifier).simpleName !== 'InjectFlags') return undefined;
+
+        const flagName = fieldAccess.name.element.simpleName;
+        if (flagName === 'Default') return [];
+        const option = FLAG_TO_OPTION[flagName];
+        return option ? [option] : undefined;
+    }
+
+    if (expr.kind === J.Kind.Binary) {
+        const binary = expr as J.Binary;
+        if (binary.operator.element !== J.Binary.Type.BitOr) return undefined;
+
+        const left = collectInjectFlags(binary.left);
+        if (!left) return undefined;
+        const right = collectInjectFlags(binary.right);
+        if (!right) return undefined;
+
+        return [...left, ...right];
+    }
+
+    return undefined;
+}
+
+function buildOptionsTemplate(injectName: J.Identifier, firstArg: J, options: string[]): Template {
+    if (options.length === 0) {
+        return template`${injectName}(${firstArg})`;
+    }
+    const objectLiteral = '{' + options.map(o => `${o}: true`).join(', ') + '}';
+    return Template.builder()
+        .param(injectName)
+        .code('(')
+        .param(firstArg)
+        .code(`, ${objectLiteral})`)
+        .build();
+}
+
+export class ReplaceInjectFlags extends Recipe {
+    readonly name = "org.openrewrite.angular.migration.replace-inject-flags";
+    readonly displayName: string = "Replace `InjectFlags` with options object";
+    readonly description: string = "Replaces deprecated `InjectFlags` enum usage in `inject()` calls with the corresponding options object. For example, `inject(MyService, InjectFlags.Optional)` becomes `inject(MyService, { optional: true })`.";
+
+    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 !== 'inject') return m;
+
+                const methodType = m.methodType;
+                if (methodType?.declaringType?.kind !== Type.Kind.Class
+                    || (methodType.declaringType as Type.Class).fullyQualifiedName !== '@angular/core') {
+                    return m;
+                }
+
+                const args = m.arguments?.elements;
+                if (!args || args.length !== 2) return m;
+
+                const options = collectInjectFlags(args[1].element);
+                if (!options) return m;
+
+                maybeRemoveImport(this, '@angular/core', 'InjectFlags');
+
+                const t = buildOptionsTemplate(m.name, args[0].element, options);
+                return await t.apply(m, this.cursor);
+            }
+        };
+    }
+}

package/src/migration/replace-load-children-string.ts

@@ -0,0 +1,48 @@
+/*
+ * 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, Template} from "@openrewrite/rewrite/javascript";
+import {J, isIdentifier, isLiteral} from "@openrewrite/rewrite/java";
+import {create} from "mutative";
+
+export class ReplaceLoadChildrenString extends Recipe {
+    readonly name = "org.openrewrite.angular.migration.replace-load-children-string";
+    readonly displayName = "Replace string-based `loadChildren` with dynamic `import()`";
+    readonly description = "Converts the deprecated string-based `loadChildren: 'path#Module'` syntax " +
+        "to dynamic imports: `loadChildren: () => import('path').then(m => m.Module)`.";
+
+    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)) return pa;
+                const lit = pa.initializer as J.Literal;
+                if (typeof lit.value !== 'string' || !lit.value.includes('#')) return pa;
+
+                const hashIndex = lit.value.indexOf('#');
+                const path = lit.value.substring(0, hashIndex);
+                const moduleName = lit.value.substring(hashIndex + 1);
+                if (!path || !moduleName) return pa;
+
+                const arrowFn = await Template.builder()
+                    .code(`() => import('${path}').then(m => m.${moduleName})`)
+                    .build()
+                    .apply(lit, this.cursor);
+
+                return create(pa, draft => {
+                    (draft as any).initializer = arrowFn;
+                }) as JS.PropertyAssignment;
+            }
+        }();
+    }
+}

package/src/migration/replace-node-sass-with-sass.ts

@@ -0,0 +1,22 @@
+/*
+ * 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 {AddDependency, RemoveDependency} from "@openrewrite/rewrite/javascript";
+
+export class ReplaceNodeSassWithSass extends Recipe {
+    readonly name = "org.openrewrite.angular.migration.replace-node-sass-with-sass";
+    readonly displayName: string = "Replace `node-sass` with `sass`";
+    readonly description: string = "Replaces the deprecated `node-sass` package with `sass` (Dart Sass). " +
+        "Angular 12 requires Dart Sass; `node-sass` is no longer supported.";
+
+    async recipeList(): Promise<Recipe[]> {
+        return [
+            new RemoveDependency({packageName: "node-sass"}),
+            new AddDependency({packageName: "sass", version: "^1.35.0", scope: "devDependencies"}),
+        ];
+    }
+}

package/src/migration/replace-router-link-with-href.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, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {JavaScriptVisitor, maybeAddImport, maybeRemoveImport} from "@openrewrite/rewrite/javascript";
+import {J} from "@openrewrite/rewrite/java";
+import {create} from "mutative";
+
+export class ReplaceRouterLinkWithHref extends Recipe {
+    readonly name = "org.openrewrite.angular.migration.replace-router-link-with-href";
+    readonly displayName: string = "Replace `RouterLinkWithHref` with `RouterLink`";
+    readonly description: string = "Replaces `RouterLinkWithHref` with `RouterLink` in imports and usages. " +
+        "`RouterLinkWithHref` was merged into `RouterLink` in Angular 16.";
+
+    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 === 'RouterLinkWithHref') {
+                    maybeAddImport(this, {module: '@angular/router', member: 'RouterLink'});
+                    maybeRemoveImport(this, '@angular/router', 'RouterLinkWithHref');
+
+                    return create(id, draft => {
+                        draft.simpleName = 'RouterLink';
+                    }) as J.Identifier;
+                }
+
+                return id;
+            }
+        }();
+    }
+}