@openrewrite/recipes-angular 0.0.0

package/src/migration/migrate-input-to-signal.ts

@@ -0,0 +1,320 @@
+/*
+ * Copyright 2026 the original author or authors.
+ *
+ * Moderne Proprietary. Only for use by Moderne customers under the terms of a commercial contract.
+ */
+
+import {ExecutionContext, randomId, emptyMarkers, markers as mkMarkers, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {JavaScriptVisitor, JS, maybeAddImport, maybeRemoveImport} from "@openrewrite/rewrite/javascript";
+import {J, isIdentifier, isLiteral, emptySpace, singleSpace} from "@openrewrite/rewrite/java";
+import {create} from "mutative";
+
+const ANGULAR_DECORATORS = ['Component', 'Directive', 'Pipe', 'Injectable'];
+
+export class MigrateInputToSignal extends Recipe {
+    readonly name = "org.openrewrite.angular.migration.migrate-input-to-signal";
+    readonly displayName: string = "Migrate `@Input()` to signal-based `input()`";
+    readonly description: string = "Converts `@Input()` decorated properties in Angular classes to signal-based " +
+        "`input()` declarations. For example, `@Input() name: string` becomes `name = input<string>()`, " +
+        "and `@Input({ required: true }) name!: string` becomes `name = input.required<string>()`.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            protected async visitClassDeclaration(classDecl: J.ClassDeclaration, p: ExecutionContext): Promise<J | undefined> {
+                let c = await super.visitClassDeclaration(classDecl, p) as J.ClassDeclaration;
+                if (!c) return c;
+
+                if (!c.leadingAnnotations.some(a => isIdentifier(a.annotationType)
+                    && ANGULAR_DECORATORS.includes((a.annotationType as J.Identifier).simpleName))) {
+                    return c;
+                }
+
+                let changed = false;
+                const newStatements = c.body.statements.map(stmt => {
+                    const el = stmt.element;
+                    if (el.kind !== J.Kind.VariableDeclarations) return stmt;
+
+                    const varDecl = el as J.VariableDeclarations;
+                    const inputIdx = varDecl.leadingAnnotations.findIndex(
+                        a => isIdentifier(a.annotationType) && (a.annotationType as J.Identifier).simpleName === 'Input'
+                    );
+                    if (inputIdx === -1) return stmt;
+
+                    const inputAnnotation = varDecl.leadingAnnotations[inputIdx];
+                    const config = parseInputConfig(inputAnnotation);
+                    const transformed = buildInputField(varDecl, inputIdx, config);
+                    changed = true;
+                    return {
+                        ...stmt,
+                        element: transformed,
+                        markers: mkMarkers({kind: 'org.openrewrite.java.marker.Semicolon' as const, id: randomId()}),
+                    };
+                });
+
+                if (!changed) return c;
+
+                maybeAddImport(this, {module: '@angular/core', member: 'input'});
+                maybeRemoveImport(this, '@angular/core', 'Input');
+
+                return create(c, (draft: any) => {
+                    draft.body.statements = newStatements;
+                }) as J.ClassDeclaration;
+            }
+        };
+    }
+}
+
+interface InputConfig {
+    required: boolean;
+    alias?: string;
+}
+
+function parseInputConfig(annotation: J.Annotation): InputConfig {
+    const config: InputConfig = {required: false};
+    if (!annotation.arguments?.elements?.length) return config;
+
+    const firstArg = annotation.arguments.elements[0].element;
+
+    // @Input('alias') — string literal argument
+    if (isLiteral(firstArg) && typeof (firstArg as J.Literal).value === 'string') {
+        config.alias = (firstArg as J.Literal).value as string;
+        return config;
+    }
+
+    // @Input({ required: true, alias: 'foo' }) — object literal
+    if (firstArg.kind === J.Kind.NewClass) {
+        const obj = firstArg as J.NewClass;
+        if (obj.body) {
+            for (const stmt of obj.body.statements) {
+                const el = stmt.element;
+                if (el.kind === JS.Kind.PropertyAssignment) {
+                    const prop = el as JS.PropertyAssignment;
+                    const nameExpr = prop.name.element;
+                    if (isIdentifier(nameExpr)) {
+                        if (nameExpr.simpleName === 'required' && isLiteral(prop.initializer) && (prop.initializer as J.Literal).value === true) {
+                            config.required = true;
+                        } else if (nameExpr.simpleName === 'alias' && isLiteral(prop.initializer)) {
+                            config.alias = (prop.initializer as J.Literal).value as string;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    return config;
+}
+
+function unwrapTypeIdentifier(typeExpr: any): any {
+    if (typeExpr?.typeIdentifier) return unwrapTypeIdentifier(typeExpr.typeIdentifier);
+    return typeExpr;
+}
+
+function buildInputCall(typeExpr: any, existingInitializer: any, config: InputConfig): any {
+    const hasType = !!typeExpr;
+    const unwrappedType = hasType ? unwrapTypeIdentifier(typeExpr) : null;
+
+    // Build type parameters: input<string>()
+    let typeParameters: any = undefined;
+    if (unwrappedType) {
+        typeParameters = {
+            kind: 'org.openrewrite.java.tree.JContainer',
+            before: emptySpace,
+            markers: emptyMarkers,
+            elements: [{
+                kind: J.Kind.RightPadded,
+                element: {...unwrappedType, id: randomId(), prefix: emptySpace},
+                after: emptySpace,
+                markers: emptyMarkers,
+            }],
+        };
+    }
+
+    // Build arguments list
+    const args: any[] = [];
+
+    // Default value argument
+    if (existingInitializer && !config.required) {
+        args.push({
+            kind: J.Kind.RightPadded,
+            element: {...existingInitializer.element, prefix: emptySpace},
+            after: emptySpace,
+            markers: emptyMarkers,
+        });
+    }
+
+    // Options argument: { alias: 'foo' }
+    if (config.alias) {
+        const aliasOption = buildOptionsObject([
+            buildPropertyAssignment('alias', config.alias),
+        ]);
+        if (args.length > 0) {
+            // Add space before options when there's a default value
+            args.push({
+                kind: J.Kind.RightPadded,
+                element: {...aliasOption, prefix: singleSpace},
+                after: emptySpace,
+                markers: emptyMarkers,
+            });
+        } else {
+            args.push({
+                kind: J.Kind.RightPadded,
+                element: {...aliasOption, prefix: emptySpace},
+                after: emptySpace,
+                markers: emptyMarkers,
+            });
+        }
+    }
+
+    // If no args, add empty
+    if (args.length === 0) {
+        args.push({
+            kind: J.Kind.RightPadded,
+            element: {kind: J.Kind.Empty, id: randomId(), prefix: emptySpace, markers: emptyMarkers},
+            after: emptySpace,
+            markers: emptyMarkers,
+        });
+    }
+
+    // For input.required<T>(), use select: input, name: required
+    const isRequired = config.required;
+
+    const call: any = {
+        kind: J.Kind.MethodInvocation,
+        id: randomId(),
+        prefix: singleSpace,
+        markers: emptyMarkers,
+        select: isRequired ? {
+            kind: J.Kind.RightPadded,
+            element: {
+                kind: J.Kind.Identifier,
+                id: randomId(),
+                prefix: emptySpace,
+                markers: emptyMarkers,
+                simpleName: 'input',
+                annotations: [],
+                type: undefined,
+            },
+            after: emptySpace,
+            markers: emptyMarkers,
+        } : undefined,
+        typeParameters,
+        name: {
+            kind: J.Kind.Identifier,
+            id: randomId(),
+            prefix: emptySpace,
+            markers: emptyMarkers,
+            simpleName: isRequired ? 'required' : 'input',
+            annotations: [],
+            type: undefined,
+        },
+        arguments: {
+            kind: 'org.openrewrite.java.tree.JContainer',
+            before: emptySpace,
+            markers: emptyMarkers,
+            elements: args,
+        },
+        methodType: undefined,
+    };
+
+    return call;
+}
+
+function buildPropertyAssignment(key: string, value: string): any {
+    return {
+        kind: JS.Kind.PropertyAssignment,
+        id: randomId(),
+        prefix: singleSpace,
+        markers: emptyMarkers,
+        name: {
+            kind: J.Kind.RightPadded,
+            element: {
+                kind: J.Kind.Identifier,
+                id: randomId(),
+                prefix: emptySpace,
+                markers: emptyMarkers,
+                simpleName: key,
+                annotations: [],
+                type: undefined,
+            },
+            after: emptySpace,
+            markers: emptyMarkers,
+        },
+        assigmentToken: 'Colon',
+        initializer: {
+            kind: J.Kind.Literal,
+            id: randomId(),
+            prefix: singleSpace,
+            markers: emptyMarkers,
+            value: value,
+            valueSource: `'${value}'`,
+            unicodeEscapes: undefined,
+            type: undefined,
+        },
+    };
+}
+
+function buildOptionsObject(properties: any[]): any {
+    return {
+        kind: J.Kind.NewClass,
+        id: randomId(),
+        prefix: emptySpace,
+        markers: emptyMarkers,
+        enclosing: undefined,
+        new: emptySpace,
+        clazz: undefined,
+        arguments: {
+            kind: 'org.openrewrite.java.tree.JContainer',
+            before: emptySpace,
+            markers: emptyMarkers,
+            elements: [],
+        },
+        body: {
+            kind: J.Kind.Block,
+            id: randomId(),
+            prefix: emptySpace,
+            markers: emptyMarkers,
+            static: {kind: J.Kind.RightPadded, element: false, after: emptySpace, markers: emptyMarkers},
+            statements: properties.map(p => ({
+                kind: J.Kind.RightPadded,
+                element: p,
+                after: emptySpace,
+                markers: emptyMarkers,
+            })),
+            end: singleSpace,
+        },
+        constructorType: undefined,
+    };
+}
+
+function buildInputField(varDecl: J.VariableDeclarations, inputAnnotationIdx: number, config: InputConfig): any {
+    const namedVar = varDecl.variables[0].element;
+    const inputCall = buildInputCall(
+        varDecl.typeExpression,
+        namedVar.initializer,
+        config,
+    );
+
+    const newAnnotations = [...varDecl.leadingAnnotations];
+    newAnnotations.splice(inputAnnotationIdx, 1);
+
+    return {
+        ...varDecl,
+        id: randomId(),
+        leadingAnnotations: newAnnotations,
+        typeExpression: undefined,
+        variables: [{
+            ...varDecl.variables[0],
+            element: {
+                ...namedVar,
+                prefix: emptySpace,
+                dimensionsAfterName: [],
+                initializer: {
+                    before: singleSpace,
+                    element: inputCall,
+                    markers: emptyMarkers,
+                },
+            },
+        }],
+    };
+}

package/src/migration/migrate-output-to-signal.ts

@@ -0,0 +1,268 @@
+/*
+ * Copyright 2026 the original author or authors.
+ *
+ * Moderne Proprietary. Only for use by Moderne customers under the terms of a commercial contract.
+ */
+
+import {ExecutionContext, randomId, emptyMarkers, markers as mkMarkers, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {JavaScriptVisitor, JS, maybeAddImport, maybeRemoveImport} from "@openrewrite/rewrite/javascript";
+import {J, isIdentifier, isLiteral, emptySpace, singleSpace} from "@openrewrite/rewrite/java";
+import {create} from "mutative";
+
+const ANGULAR_DECORATORS = ['Component', 'Directive', 'Pipe', 'Injectable'];
+
+export class MigrateOutputToSignal extends Recipe {
+    readonly name = "org.openrewrite.angular.migration.migrate-output-to-signal";
+    readonly displayName: string = "Migrate `@Output()` to signal-based `output()`";
+    readonly description: string = "Converts `@Output()` decorated properties using `EventEmitter` in Angular classes to " +
+        "signal-based `output()` declarations. For example, `@Output() clicked = new EventEmitter<void>()` becomes " +
+        "`clicked = output<void>()`.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            protected async visitClassDeclaration(classDecl: J.ClassDeclaration, p: ExecutionContext): Promise<J | undefined> {
+                let c = await super.visitClassDeclaration(classDecl, p) as J.ClassDeclaration;
+                if (!c) return c;
+
+                if (!c.leadingAnnotations.some(a => isIdentifier(a.annotationType)
+                    && ANGULAR_DECORATORS.includes((a.annotationType as J.Identifier).simpleName))) {
+                    return c;
+                }
+
+                let changed = false;
+                const newStatements = c.body.statements.map(stmt => {
+                    const el = stmt.element;
+                    if (el.kind !== J.Kind.VariableDeclarations) return stmt;
+
+                    const varDecl = el as J.VariableDeclarations;
+                    const outputIdx = varDecl.leadingAnnotations.findIndex(
+                        a => isIdentifier(a.annotationType) && (a.annotationType as J.Identifier).simpleName === 'Output'
+                    );
+                    if (outputIdx === -1) return stmt;
+
+                    const namedVar = varDecl.variables[0].element;
+                    if (!namedVar.initializer) return stmt;
+
+                    const initExpr = namedVar.initializer.element;
+                    if (initExpr.kind !== J.Kind.NewClass) return stmt;
+
+                    const newClass = initExpr as J.NewClass;
+                    const emitterName = extractClassName(newClass);
+                    if (emitterName !== 'EventEmitter') return stmt;
+
+                    const outputAnnotation = varDecl.leadingAnnotations[outputIdx];
+                    const alias = parseOutputAlias(outputAnnotation);
+                    const typeParams = extractTypeParams(newClass);
+                    const transformed = buildOutputField(varDecl, outputIdx, typeParams, alias);
+                    changed = true;
+                    return {
+                        ...stmt,
+                        element: transformed,
+                        markers: mkMarkers({kind: 'org.openrewrite.java.marker.Semicolon' as const, id: randomId()}),
+                    };
+                });
+
+                if (!changed) return c;
+
+                maybeAddImport(this, {module: '@angular/core', member: 'output'});
+                maybeRemoveImport(this, '@angular/core', 'Output');
+                maybeRemoveImport(this, '@angular/core', 'EventEmitter');
+
+                return create(c, (draft: any) => {
+                    draft.body.statements = newStatements;
+                }) as J.ClassDeclaration;
+            }
+        };
+    }
+}
+
+function extractClassName(newClass: J.NewClass): string | undefined {
+    const clazz = newClass.class;
+    if (!clazz) return undefined;
+    if (isIdentifier(clazz)) return (clazz as J.Identifier).simpleName;
+    if (clazz.kind === J.Kind.ParameterizedType) {
+        const pt = clazz as J.ParameterizedType;
+        if (isIdentifier(pt.class)) return (pt.class as J.Identifier).simpleName;
+    }
+    return undefined;
+}
+
+function extractTypeParams(newClass: J.NewClass): any[] | undefined {
+    const clazz = newClass.class;
+    if (clazz?.kind === J.Kind.ParameterizedType) {
+        const pt = clazz as J.ParameterizedType;
+        if (pt.typeParameters?.elements?.length) {
+            return pt.typeParameters.elements.map(e => e.element);
+        }
+    }
+    return undefined;
+}
+
+function parseOutputAlias(annotation: J.Annotation): string | undefined {
+    if (!annotation.arguments?.elements?.length) return undefined;
+
+    const firstArg = annotation.arguments.elements[0].element;
+    if (isLiteral(firstArg) && typeof (firstArg as J.Literal).value === 'string') {
+        return (firstArg as J.Literal).value as string;
+    }
+    return undefined;
+}
+
+function unwrapTypeIdentifier(typeExpr: any): any {
+    if (typeExpr?.typeIdentifier) return unwrapTypeIdentifier(typeExpr.typeIdentifier);
+    return typeExpr;
+}
+
+function buildOutputField(varDecl: J.VariableDeclarations, outputAnnotationIdx: number, typeParams: any[] | undefined, alias: string | undefined): any {
+    const namedVar = varDecl.variables[0].element;
+
+    // Build type parameters for output<T>()
+    let typeParameters: any = undefined;
+    if (typeParams?.length) {
+        typeParameters = {
+            kind: 'org.openrewrite.java.tree.JContainer',
+            before: emptySpace,
+            markers: emptyMarkers,
+            elements: typeParams.map(tp => ({
+                kind: J.Kind.RightPadded,
+                element: {...unwrapTypeIdentifier(tp), id: randomId(), prefix: emptySpace},
+                after: emptySpace,
+                markers: emptyMarkers,
+            })),
+        };
+    }
+
+    // Build arguments
+    const args: any[] = [];
+    if (alias) {
+        args.push({
+            kind: J.Kind.RightPadded,
+            element: buildOptionsObject([buildPropertyAssignment('alias', alias)]),
+            after: emptySpace,
+            markers: emptyMarkers,
+        });
+    }
+    if (args.length === 0) {
+        args.push({
+            kind: J.Kind.RightPadded,
+            element: {kind: J.Kind.Empty, id: randomId(), prefix: emptySpace, markers: emptyMarkers},
+            after: emptySpace,
+            markers: emptyMarkers,
+        });
+    }
+
+    const outputCall: any = {
+        kind: J.Kind.MethodInvocation,
+        id: randomId(),
+        prefix: singleSpace,
+        markers: emptyMarkers,
+        select: undefined,
+        typeParameters,
+        name: {
+            kind: J.Kind.Identifier,
+            id: randomId(),
+            prefix: emptySpace,
+            markers: emptyMarkers,
+            simpleName: 'output',
+            annotations: [],
+            type: undefined,
+        },
+        arguments: {
+            kind: 'org.openrewrite.java.tree.JContainer',
+            before: emptySpace,
+            markers: emptyMarkers,
+            elements: args,
+        },
+        methodType: undefined,
+    };
+
+    const newAnnotations = [...varDecl.leadingAnnotations];
+    newAnnotations.splice(outputAnnotationIdx, 1);
+
+    return {
+        ...varDecl,
+        id: randomId(),
+        leadingAnnotations: newAnnotations,
+        typeExpression: undefined,
+        variables: [{
+            ...varDecl.variables[0],
+            element: {
+                ...namedVar,
+                prefix: emptySpace,
+                dimensionsAfterName: [],
+                initializer: {
+                    before: singleSpace,
+                    element: outputCall,
+                    markers: emptyMarkers,
+                },
+            },
+        }],
+    };
+}
+
+function buildPropertyAssignment(key: string, value: string): any {
+    return {
+        kind: JS.Kind.PropertyAssignment,
+        id: randomId(),
+        prefix: singleSpace,
+        markers: emptyMarkers,
+        name: {
+            kind: J.Kind.RightPadded,
+            element: {
+                kind: J.Kind.Identifier,
+                id: randomId(),
+                prefix: emptySpace,
+                markers: emptyMarkers,
+                simpleName: key,
+                annotations: [],
+                type: undefined,
+            },
+            after: emptySpace,
+            markers: emptyMarkers,
+        },
+        assigmentToken: 'Colon',
+        initializer: {
+            kind: J.Kind.Literal,
+            id: randomId(),
+            prefix: singleSpace,
+            markers: emptyMarkers,
+            value: value,
+            valueSource: `'${value}'`,
+            unicodeEscapes: undefined,
+            type: undefined,
+        },
+    };
+}
+
+function buildOptionsObject(properties: any[]): any {
+    return {
+        kind: J.Kind.NewClass,
+        id: randomId(),
+        prefix: emptySpace,
+        markers: emptyMarkers,
+        enclosing: undefined,
+        new: emptySpace,
+        clazz: undefined,
+        arguments: {
+            kind: 'org.openrewrite.java.tree.JContainer',
+            before: emptySpace,
+            markers: emptyMarkers,
+            elements: [],
+        },
+        body: {
+            kind: J.Kind.Block,
+            id: randomId(),
+            prefix: emptySpace,
+            markers: emptyMarkers,
+            static: {kind: J.Kind.RightPadded, element: false, after: emptySpace, markers: emptyMarkers},
+            statements: properties.map(p => ({
+                kind: J.Kind.RightPadded,
+                element: p,
+                after: emptySpace,
+                markers: emptyMarkers,
+            })),
+            end: singleSpace,
+        },
+        constructorType: undefined,
+    };
+}