@openrewrite/recipes-angular 0.0.0

package/src/search/find-angular-decorator.ts

@@ -0,0 +1,58 @@
+import {ExecutionContext, foundSearchResult, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {JavaScriptVisitor, JS} from "@openrewrite/rewrite/javascript";
+import {isIdentifier, J} from "@openrewrite/rewrite/java";
+
+export class FindAngularDecorator extends Recipe {
+    readonly name = "org.openrewrite.angular.search.find-angular-decorator";
+    readonly displayName: string = "Find Angular decorators";
+    readonly description: string = "Finds all Angular decorators like @Component, @Directive, @Injectable, etc.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        const angularDecorators = new Set([
+            'Component',
+            'Directive',
+            'Injectable',
+            'NgModule',
+            'Pipe',
+            'Input',
+            'Output',
+            'ViewChild',
+            'ViewChildren',
+            'ContentChild',
+            'ContentChildren',
+            'HostBinding',
+            'HostListener'
+        ]);
+
+        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;
+
+                // Check if this is an Angular decorator
+                let decoratorName: string | undefined;
+                const annotType = a.annotationType;
+                if (isIdentifier(annotType)) {
+                    decoratorName = annotType.simpleName;
+                } else if (annotType.kind === J.Kind.FieldAccess) {
+                    const fieldAccess = annotType as J.FieldAccess;
+                    const nameIdent = fieldAccess.name.element;
+                    if (isIdentifier(nameIdent)) {
+                        decoratorName = nameIdent.simpleName;
+                    }
+                } else if (annotType.kind === JS.Kind.ExpressionWithTypeArguments) {
+                    const exprWithTypeArgs = annotType as JS.ExpressionWithTypeArguments;
+                    if (isIdentifier(exprWithTypeArgs.clazz)) {
+                        decoratorName = exprWithTypeArgs.clazz.simpleName;
+                    }
+                }
+
+                // Mark Angular decorators with SearchResult
+                if (decoratorName && angularDecorators.has(decoratorName)) {
+                    return foundSearchResult(a as J.Annotation);
+                }
+
+                return a;
+            }
+        }();
+    }
+}

package/src/search/find-angular-http-usage.ts

@@ -0,0 +1,35 @@
+/*
+ * 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 FindAngularHttpUsage extends Recipe {
+    readonly name = "org.openrewrite.angular.search.find-angular-http-usage";
+    readonly displayName: string = "Find removed `@angular/http` usage";
+    readonly description: string = "Finds imports from the `@angular/http` module, which was deprecated in Angular 5 and removed in Angular 8. " +
+        "Use `@angular/common/http` (`HttpClient`, `HttpClientModule`) instead.";
+
+    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/http') return imp;
+
+                return foundSearchResult(imp,
+                    "`@angular/http` was deprecated in Angular 5 and removed in Angular 8. " +
+                    "Use `@angular/common/http` (`HttpClient`, `HttpClientModule`) instead.");
+            }
+        };
+    }
+}

package/src/search/find-animation-driver-matches-element.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 FindAnimationDriverMatchesElement extends Recipe {
+    readonly name = "org.openrewrite.angular.search.find-animation-driver-matches-element";
+    readonly displayName: string = "Find `AnimationDriver.matchesElement` usage";
+    readonly description: string = "Finds imports of `AnimationDriver` from `@angular/animations/browser`, which had its `matchesElement` method removed in Angular 18.";
+
+    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/animations/browser') 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 === 'AnimationDriver') {
+                            return foundSearchResult(imp,
+                                "AnimationDriver.matchesElement has been removed in Angular 18.");
+                        }
+                    }
+                }
+
+                return imp;
+            }
+        };
+    }
+}

package/src/search/find-async-test-helper-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 FindAsyncTestHelperUsage extends Recipe {
+    readonly name = "org.openrewrite.angular.search.find-async-test-helper-usage";
+    readonly displayName: string = "Find deprecated `async` test helper usage";
+    readonly description: string = "Finds usages of the deprecated `async` test helper from `@angular/core/testing`. " +
+        "The `async` function was deprecated in Angular 11 and should be replaced with `waitForAsync`.";
+
+    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/core/testing') 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 === 'async') {
+                            return foundSearchResult(imp,
+                                "The `async` test helper is deprecated since Angular 11. Use `waitForAsync` instead.");
+                        }
+                    }
+                }
+
+                return imp;
+            }
+        };
+    }
+}

package/src/search/find-bare-module-with-providers.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 {JavaScriptVisitor, JS} from "@openrewrite/rewrite/javascript";
+import {J, isIdentifier} from "@openrewrite/rewrite/java";
+
+export class FindBareModuleWithProviders extends Recipe {
+    readonly name = "org.openrewrite.angular.search.find-bare-module-with-providers";
+    readonly displayName: string = "Find `ModuleWithProviders` without generic type";
+    readonly description: string = "Finds imports of `ModuleWithProviders` from `@angular/core`. " +
+        "Starting in Angular 10, `ModuleWithProviders` requires a generic type parameter " +
+        "(e.g. `ModuleWithProviders<MyModule>`). Ensure all usages specify the module type.";
+
+    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/core') 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 === 'ModuleWithProviders') {
+                            return foundSearchResult(imp,
+                                "`ModuleWithProviders` requires a generic type parameter since Angular 10. " +
+                                "Ensure all usages specify the module type: `ModuleWithProviders<MyModule>`.");
+                        }
+                    }
+                }
+
+                return imp;
+            }
+        };
+    }
+}

package/src/search/find-browser-transfer-state-module-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 FindBrowserTransferStateModuleUsage extends Recipe {
+    readonly name = "org.openrewrite.angular.search.find-browser-transfer-state-module-usage";
+    readonly displayName: string = "Find `BrowserTransferStateModule` usage";
+    readonly description: string = "Finds usages of `BrowserTransferStateModule` from `@angular/platform-browser` " +
+        "which was removed in Angular 16. `TransferState` can be used directly without this module.";
+
+    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-browser') 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 === 'BrowserTransferStateModule') {
+                            return foundSearchResult(imp,
+                                "BrowserTransferStateModule has been removed in Angular 16. TransferState can be used directly without this module.");
+                        }
+                    }
+                }
+
+                return imp;
+            }
+        };
+    }
+}

package/src/search/find-common-module-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 {JavaScriptVisitor, JS} from "@openrewrite/rewrite/javascript";
+import {J, isIdentifier} from "@openrewrite/rewrite/java";
+
+export class FindCommonModuleUsage extends Recipe {
+    readonly name = "org.openrewrite.angular.search.find-common-module-usage";
+    readonly displayName: string = "Find `CommonModule` usage";
+    readonly description: string = "Finds imports of `CommonModule` from `@angular/common`. " +
+        "Since Angular 19, standalone components are the default and `CommonModule` is no longer needed " +
+        "in component `imports` arrays. Built-in directives and pipes are available automatically.";
+
+    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 === 'CommonModule') {
+                            return foundSearchResult(imp,
+                                "CommonModule is unnecessary in standalone components (default since Angular 19). " +
+                                "Built-in directives and pipes are available automatically. See https://angular.dev/guide/components/importing");
+                        }
+                    }
+                }
+
+                return imp;
+            }
+        };
+    }
+}

package/src/search/find-compiler-factory-usage.ts

@@ -0,0 +1,51 @@
+/*
+ * 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 DEPRECATED_SYMBOLS = [
+    'CompilerFactory', 'Compiler', 'CompilerOptions',
+    'ModuleWithComponentFactories', 'NgModuleFactory', 'NgModuleFactoryLoader'
+];
+
+export class FindCompilerFactoryUsage extends Recipe {
+    readonly name = "org.openrewrite.angular.search.find-compiler-factory-usage";
+    readonly displayName: string = "Find View Engine API usage";
+    readonly description: string = "Finds usages of View Engine APIs from `@angular/core` " +
+        "(`CompilerFactory`, `Compiler`, `CompilerOptions`, `ModuleWithComponentFactories`, " +
+        "`NgModuleFactory`, `NgModuleFactoryLoader`) which were deprecated in Angular 13.";
+
+    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/core') 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) && DEPRECATED_SYMBOLS.includes(spec.specifier.simpleName)) {
+                            return foundSearchResult(imp,
+                                `${spec.specifier.simpleName} was deprecated in Angular 13 with the removal of the View Engine rendering pipeline.`);
+                        }
+                    }
+                }
+
+                return imp;
+            }
+        };
+    }
+}

package/src/search/find-date-pipe-default-timezone-usage.ts

@@ -0,0 +1,46 @@
+/*
+ * 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 FindDatePipeDefaultTimezoneUsage extends Recipe {
+    readonly name = "org.openrewrite.angular.search.find-date-pipe-default-timezone-usage";
+    readonly displayName: string = "Find `DATE_PIPE_DEFAULT_TIMEZONE` usage";
+    readonly description: string = "Finds usages of `DATE_PIPE_DEFAULT_TIMEZONE` which was deprecated in Angular 15. " +
+        "Use `DATE_PIPE_DEFAULT_OPTIONS` with a `{timezone: '...'}` object value instead.";
+
+    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 === 'DATE_PIPE_DEFAULT_TIMEZONE') {
+                            return foundSearchResult(imp,
+                                "DATE_PIPE_DEFAULT_TIMEZONE has been deprecated in Angular 15. " +
+                                "Use DATE_PIPE_DEFAULT_OPTIONS with a {timezone: '...'} object value instead.");
+                        }
+                    }
+                }
+
+                return imp;
+            }
+        };
+    }
+}

package/src/search/find-effect-timing-usage.ts

@@ -0,0 +1,28 @@
+import {ExecutionContext, foundSearchResult, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {JavaScriptVisitor} from "@openrewrite/rewrite/javascript";
+import {J, Type} from "@openrewrite/rewrite/java";
+
+export class FindEffectTimingUsage extends Recipe {
+    readonly name = "org.openrewrite.angular.search.find-effect-timing-usage";
+    readonly displayName: string = "Find `effect()` usage affected by Angular 19 timing changes";
+    readonly description: string = "Finds `effect()` calls from `@angular/core`. In Angular 19, effects triggered outside change detection now run as part of the change detection process instead of as a microtask, and effects triggered during change detection run earlier, before the component's template.";
+
+    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 === 'effect') {
+                    const methodType = m.methodType;
+                    if (methodType?.declaringType?.kind === Type.Kind.Class
+                        && (methodType.declaringType as Type.Class).fullyQualifiedName === '@angular/core') {
+                        return foundSearchResult(m,
+                            "effect() timing changed in v19. See https://angular.dev/api/core/effect");
+                    }
+                }
+
+                return m;
+            }
+        };
+    }
+}

package/src/search/find-empty-projectable-nodes.ts

@@ -0,0 +1,68 @@
+import {ExecutionContext, foundSearchResult, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {JavaScriptVisitor, JS} from "@openrewrite/rewrite/javascript";
+import {J, isIdentifier, Type} from "@openrewrite/rewrite/java";
+
+export class FindEmptyProjectableNodes extends Recipe {
+    readonly name = "org.openrewrite.angular.search.find-empty-projectable-nodes";
+    readonly displayName: string = "Find `createComponent` calls with empty `projectableNodes`";
+    readonly description: string = "Finds `createComponent()` calls that pass empty arrays in `projectableNodes`. In Angular 19, passing an empty array now renders the default `ng-content` fallback content. To suppress fallback content, pass `[document.createTextNode('')]` instead.";
+
+    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 !== 'createComponent') 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;
+
+                // The second argument is the options object { projectableNodes: [...] }
+                const optionsArg = args[1].element;
+                if (optionsArg.kind !== J.Kind.NewClass) return m;
+
+                const optionsObj = optionsArg as J.NewClass;
+                if (!optionsObj.body) return m;
+
+                for (const stmt of optionsObj.body.statements) {
+                    if (stmt.element.kind !== JS.Kind.PropertyAssignment) continue;
+                    const prop = stmt.element as JS.PropertyAssignment;
+                    const nameExpr = prop.name.element;
+                    if (!isIdentifier(nameExpr) || nameExpr.simpleName !== 'projectableNodes') continue;
+
+                    if (prop.initializer && hasEmptyArrayElement(prop.initializer)) {
+                        return foundSearchResult(m,
+                            "Empty projectableNodes now render ng-content fallback in v19. See https://angular.dev/api/core/createComponent");
+                    }
+                }
+
+                return m;
+            }
+        };
+    }
+}
+
+function hasEmptyArrayElement(node: any): boolean {
+    // projectableNodes: [[], [node]] — look for [] elements in the outer array
+    const elements = node.initializer?.elements;
+    if (!elements) return false;
+
+    for (const rp of elements) {
+        const elem = rp.element;
+        // Empty array: J$NewArray whose only element is J$Empty
+        if (elem.kind === J.Kind.NewArray) {
+            const innerElements = elem.initializer?.elements;
+            if (innerElements && innerElements.length === 1
+                && innerElements[0].element.kind === J.Kind.Empty) {
+                return true;
+            }
+        }
+    }
+    return false;
+}

package/src/search/find-fake-async-usage.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, foundSearchResult, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {JavaScriptVisitor} from "@openrewrite/rewrite/javascript";
+import {J, Type} from "@openrewrite/rewrite/java";
+
+export class FindFakeAsyncUsage extends Recipe {
+    readonly name = "org.openrewrite.angular.search.find-fake-async-usage";
+    readonly displayName: string = "Find zone.js-dependent test helper usage";
+    readonly description: string = "Finds `fakeAsync()`, `tick()`, and `waitForAsync()` calls from `@angular/core/testing`. " +
+        "These zone.js-dependent test helpers are incompatible with Vitest, the default test runner in Angular 21. " +
+        "Migrate to native async/await patterns instead.";
+
+    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 === 'fakeAsync' || m.name.simpleName === 'tick' || m.name.simpleName === 'waitForAsync') {
+                    const methodType = m.methodType;
+                    if (methodType?.declaringType?.kind === Type.Kind.Class
+                        && (methodType.declaringType as Type.Class).fullyQualifiedName === '@angular/core/testing') {
+                        return foundSearchResult(m,
+                            `${m.name.simpleName}() is a zone.js-dependent test helper incompatible with Vitest. ` +
+                            "Migrate to native async/await. See https://angular.dev/guide/testing");
+                    }
+                }
+
+                return m;
+            }
+        };
+    }
+}

package/src/search/find-hammer-js-usage.ts

@@ -0,0 +1,48 @@
+import {ExecutionContext, foundSearchResult, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {JavaScriptVisitor, JS} from "@openrewrite/rewrite/javascript";
+import {J, Type} from "@openrewrite/rewrite/java";
+
+export class FindHammerJsUsage extends Recipe {
+    readonly name = "org.openrewrite.angular.search.find-hammer-js-usage";
+    readonly displayName: string = "Find HammerJS usage";
+    readonly description: string = "Finds `HammerModule` imports and HammerJS references. Angular has deprecated HammerJS support and it will be removed in Angular 21.";
+
+    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 === 'hammerjs' || moduleName.startsWith('hammerjs/')) {
+                    return foundSearchResult(imp,
+                        "HammerJS import. Angular has deprecated HammerJS support; it will be removed in Angular 21.");
+                }
+
+                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 === 'HammerModule' && id.type?.kind === Type.Kind.Class
+                    && (id.type as Type.Class).fullyQualifiedName === 'HammerModule') {
+                    return foundSearchResult(id,
+                        "HammerModule usage. Angular has deprecated HammerJS support; it will be removed in Angular 21.");
+                }
+
+                if (id.simpleName === 'HammerGestureConfig' && id.type?.kind === Type.Kind.Class
+                    && (id.type as Type.Class).fullyQualifiedName === 'HammerGestureConfig') {
+                    return foundSearchResult(id,
+                        "HammerGestureConfig usage. Angular has deprecated HammerJS support; it will be removed in Angular 21.");
+                }
+
+                return id;
+            }
+        };
+    }
+}