@openrewrite/recipes-angular 1.1.3 → 1.1.5

package/src/libraries/primeng/18/migrate-p-fluid-to-wrapper.ts

@@ -0,0 +1,439 @@
+/*
+ * 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, ScanningRecipe, TreeVisitor} from "@openrewrite/rewrite";
+import {PlainText, PlainTextVisitor} from "@openrewrite/rewrite/text";
+import {JavaScriptVisitor, JS, maybeAddImport} from "@openrewrite/rewrite/javascript";
+import {J, isIdentifier} from "@openrewrite/rewrite/java";
+import * as path from "path";
+
+/**
+ * HTML files (repo-relative source paths) where the HTML sub-recipe rewrote `class="…p-fluid…"`
+ * to a `<p-fluid>` wrapper. The TS sub-recipe reads this set to decide which `*.component.ts`
+ * files need `FluidModule` added to their imports.
+ *
+ * Module-scoped because the two sub-recipes run sequentially within a single mod invocation —
+ * passing state via the recipe's `recipeList()` chain is the simplest way to share between the
+ * HTML and TS visitor types.
+ */
+const rewrittenHtmlPaths: Set<string> = new Set();
+
+/**
+ * Rewrites `<div class="…p-fluid…">…</div>` to `<p-fluid class="…">…</p-fluid>` in HTML
+ * templates. Uses scanner phase to pre-populate `rewrittenHtmlPaths` so the sibling
+ * `MigratePFluidAddImports` sub-recipe (which runs concurrently in the editor phase) can
+ * see the full set when its TS visitor fires.
+ */
+class MigratePFluidHtml extends ScanningRecipe<{}> {
+    readonly name = "org.openrewrite.primeng.MigratePFluidToWrapper.html";
+    readonly displayName = "Rewrite `.p-fluid` divs to `<p-fluid>` wrappers";
+    readonly description = "Rewrites `<div class=\"…p-fluid…\">…</div>` to `<p-fluid class=\"…\">…</p-fluid>` " +
+        "in HTML templates (the `p-fluid` class is removed from the resulting class list). Tracks " +
+        "which files were modified so a follow-up sub-recipe can add the `FluidModule` import.";
+
+    initialValue(_ctx: ExecutionContext): {} {
+        return {};
+    }
+
+    async scanner(_acc: {}): Promise<TreeVisitor<any, ExecutionContext>> {
+        // Populate the shared rewritten-paths set during the scanner phase so the sibling
+        // import-adder recipe sees it before its editor runs.
+        return new class extends PlainTextVisitor<ExecutionContext> {
+            override async visitText(text: PlainText, p: ExecutionContext): Promise<PlainText | undefined> {
+                const t = await super.visitText(text, p) as PlainText;
+                if (!t) return t;
+                if (!t.sourcePath.endsWith('.html')) return t;
+                if (!/\bp-fluid\b/.test(t.text)) return t;
+                // Same rewrite logic, but only record the path — don't mutate the tree here.
+                if (rewriteHtml(t.text) !== t.text) {
+                    rewrittenHtmlPaths.add(t.sourcePath);
+                }
+                return t;
+            }
+        }();
+    }
+
+    async editorWithData(_acc: {}): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends PlainTextVisitor<ExecutionContext> {
+            override async visitText(text: PlainText, p: ExecutionContext): Promise<PlainText | undefined> {
+                const t = await super.visitText(text, p) as PlainText;
+                if (!t) return t;
+                if (!rewrittenHtmlPaths.has(t.sourcePath)) return t;
+                const updated = rewriteHtml(t.text);
+                if (updated === t.text) return t;
+                return {...t, text: updated, snippets: []};
+            }
+        }();
+    }
+}
+
+/**
+ * Adds a `FluidModule` import line and prepends `FluidModule` to the `imports: [...]` array
+ * of every `*.component.ts` whose `templateUrl` points at an HTML file rewritten by
+ * `MigratePFluidHtml`, plus the root NgModule for non-standalone apps. Without that, Angular
+ * reports `'p-fluid' is not a known element`.
+ *
+ * Why prepend rather than append: a multi-line `imports: [..., DataViewModule,]` with trailing
+ * comma has trailing whitespace (`,\n  `) before `]` whose AST location is fiddly to mutate
+ * cleanly. Prepending sidesteps that — we slot the new entry in front of the existing first
+ * element, reusing that element's prefix for indentation, and the framework's natural
+ * inter-element comma handles the separator. Module-import order is functionally irrelevant
+ * to Angular.
+ */
+class MigratePFluidAddImports extends Recipe {
+    readonly name = "org.openrewrite.primeng.MigratePFluidToWrapper.add-imports";
+    readonly displayName = "Add `FluidModule` import to components using `<p-fluid>`";
+    readonly description = "For each `*.component.ts` whose `templateUrl` references an HTML file " +
+        "rewritten with `<p-fluid>` wrappers (and the root NgModule for non-standalone apps), " +
+        "adds `import { FluidModule } from 'primeng/fluid';` and prepends `FluidModule` to the " +
+        "component's or module's `imports: [...]` array.";
+
+    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;
+                const annotName = (annotType as J.Identifier).simpleName;
+                if (annotName !== 'Component' && annotName !== '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;
+
+                // Decide whether this site needs FluidModule:
+                //  - @Component: only if its templateUrl points at a rewritten HTML.
+                //  - @NgModule: only the root NgModule (`bootstrap: [...]` present), and only if
+                //    any HTML in the project was rewritten — catch-all for non-standalone apps.
+                if (annotName === 'Component') {
+                    const sourceFile = this.cursor.firstEnclosing((v: any): v is { sourcePath: string } =>
+                        v && typeof v.sourcePath === 'string');
+                    if (!templateUrlReferencesRewritten(newClass, sourceFile?.sourcePath)) return a;
+                } else {
+                    if (rewrittenHtmlPaths.size === 0) return a;
+                    const hasBootstrap = newClass.body.statements.some(s => {
+                        const stmt = s.element;
+                        if (stmt.kind !== JS.Kind.PropertyAssignment) return false;
+                        const nameExpr = (stmt as JS.PropertyAssignment).name.element;
+                        return isIdentifier(nameExpr) && (nameExpr as J.Identifier).simpleName === 'bootstrap';
+                    });
+                    if (!hasBootstrap) return a;
+                }
+
+                // Find the `imports: [...]` member.
+                let importsIndex = -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 as J.Identifier).simpleName === 'imports') {
+                        importsIndex = i;
+                        break;
+                    }
+                }
+
+                maybeAddImport(this, {
+                    module: 'primeng/fluid',
+                    member: 'FluidModule',
+                    onlyIfReferenced: false,
+                });
+
+                if (importsIndex === -1) return a;
+
+                const importsStmt = newClass.body.statements[importsIndex].element as any;
+                const arr = importsStmt.initializer;
+                const container = arr?.initializer;
+                const existingElements = container?.elements ?? [];
+
+                // Idempotence: skip if FluidModule is already in the array.
+                for (const el of existingElements) {
+                    const expr = el.element;
+                    if (isIdentifier(expr) && (expr as J.Identifier).simpleName === 'FluidModule') {
+                        return a;
+                    }
+                }
+
+                // Prepend, not append. The new entry mirrors the prefix of the existing first
+                // element (so the indent matches in multi-line arrays). The existing first
+                // element's prefix needs no change — it becomes the second element, and the
+                // framework injects a comma + the original prefix as the inter-element separator.
+                const fluidIdentifier: J.Identifier = {
+                    kind: J.Kind.Identifier,
+                    id: a.id,
+                    prefix: existingElements.length > 0 ? existingElements[0].element.prefix : {kind: 'org.openrewrite.java.tree.Space', whitespace: '', comments: []} as any,
+                    markers: {kind: 'org.openrewrite.marker.Markers', id: a.id, markers: []},
+                    annotations: [],
+                    simpleName: 'FluidModule',
+                };
+                const fluidRP = {
+                    kind: J.Kind.RightPadded,
+                    element: fluidIdentifier,
+                    after: {kind: 'org.openrewrite.java.tree.Space', whitespace: '', comments: []},
+                    markers: {kind: 'org.openrewrite.marker.Markers', id: a.id, markers: []},
+                };
+
+                const updatedImportsStmt = {
+                    ...importsStmt,
+                    initializer: {
+                        ...arr,
+                        initializer: {
+                            ...container,
+                            elements: [fluidRP, ...existingElements],
+                        },
+                    },
+                };
+
+                const newStatements = [...newClass.body.statements];
+                newStatements[importsIndex] = {
+                    ...newStatements[importsIndex],
+                    element: updatedImportsStmt,
+                };
+
+                const newNewClass = {...newClass, body: {...newClass.body, statements: newStatements}};
+                return {
+                    ...a,
+                    arguments: {
+                        ...a.arguments!,
+                        elements: [{
+                            ...a.arguments!.elements[0],
+                            element: newNewClass,
+                        }],
+                    },
+                } as J.Annotation;
+            }
+        };
+    }
+}
+
+/**
+ * Migrates PrimeNG v17's `.p-fluid` CSS class — removed in v18 — to v18's `<p-fluid>`
+ * wrapper component.
+ *
+ * In v17, `.p-fluid` made child form controls `display: block; width: 100%`, which most
+ * apps used to stack labels above inputs. In v18 the class is a no-op, so pages silently
+ * lose that layout. The replacement is the `<p-fluid>` wrapper from `primeng/fluid`,
+ * which applies the same effect via design tokens.
+ *
+ * Two-phase recipe:
+ * 1. `MigratePFluidHtml` — rewrites `<div class="…p-fluid…">…</div>` to
+ *    `<p-fluid class="…">…</p-fluid>` and tracks affected file paths.
+ * 2. `MigratePFluidAddImports` — adds `FluidModule` to component files whose `templateUrl`
+ *    points at one of the rewritten HTML files.
+ *
+ * Limitations: rewrites only `<div>` containers (other elements like `<section>` are left
+ * for `MarkDeprecatedPrimengCssClasses` to flag). Custom CSS rules selecting `.p-fluid`
+ * stop matching after the rewrite — same trade-off PrimeNG itself made by removing the class.
+ */
+export class MigratePFluidToWrapper extends Recipe {
+    readonly name = "org.openrewrite.primeng.MigratePFluidToWrapper";
+    readonly displayName = "Migrate `.p-fluid` to `<p-fluid>` wrapper";
+    readonly description = "Rewrites `<div class=\"…p-fluid…\">…</div>` to `<p-fluid class=\"…\">…</p-fluid>` " +
+        "and adds a `FluidModule` import from `primeng/fluid` to the corresponding component file. " +
+        "PrimeNG 18 removed the `.p-fluid` CSS class; the `<p-fluid>` wrapper component is its " +
+        "replacement.";
+
+    async recipeList(): Promise<Recipe[]> {
+        // Reset shared state for each top-level invocation; each call to `recipeList()` produces
+        // a fresh chain instance, but the module-scoped Set persists across them otherwise.
+        rewrittenHtmlPaths.clear();
+        return [
+            new MigratePFluidHtml(),
+            new MigratePFluidAddImports(),
+        ];
+    }
+}
+
+/**
+ * Rewrite every `<div class="…p-fluid…">CHILDREN</div>` in the given source text. Two cases:
+ *
+ *  1. `p-fluid` is the only class on the div → replace the div entirely with `<p-fluid>`:
+ *     `<div class="p-fluid">CHILDREN</div>` → `<p-fluid>CHILDREN</p-fluid>`
+ *
+ *  2. The div has other classes → keep the original `<div>` (preserving its natural
+ *     content-width and any custom CSS targeting its non-`p-fluid` classes) and wrap
+ *     CHILDREN in a `<p-fluid>`. The `p-fluid` class is stripped from the div:
+ *     `<div class="X p-fluid">CHILDREN</div>` → `<div class="X"><p-fluid>CHILDREN</p-fluid></div>`
+ *
+ * Case 2 prevents the v18 `<p-fluid>` element's `display: block; width: 100%;` from
+ * forcing the wrapper to fill its flex parent (a regression vs. v17's `<div class="…p-fluid">`,
+ * whose own width was content-driven — only child inputs got 100% from `.p-fluid`).
+ */
+function rewriteHtml(src: string): string {
+    if (!/\bp-fluid\b/.test(src)) return src;
+
+    const divOpenRe = /<div\b([^>]*)>/g;
+    type Rewrite = {
+        openStart: number;
+        openEnd: number;
+        closeStart: number;
+        closeEnd: number;
+        replaceDiv: boolean;       // true = replace <div> with <p-fluid>; false = wrap children
+        newOpenTag: string;        // the rewritten opening tag
+    };
+    const rewrites: Rewrite[] = [];
+
+    let m: RegExpExecArray | null;
+    while ((m = divOpenRe.exec(src)) !== null) {
+        const attrs = m[1];
+        // Skip self-closing `<div ... />` — no body to wrap.
+        if (attrs.trimEnd().endsWith('/')) continue;
+
+        const classMatch = attrs.match(/(?:^|\s)class\s*=\s*("([^"]*)"|'([^']*)')/);
+        if (!classMatch) continue;
+        const classValue = classMatch[2] ?? classMatch[3];
+        if (!/\bp-fluid\b/.test(classValue)) continue;
+
+        const openEnd = divOpenRe.lastIndex;
+        const closePos = findMatchingDivClose(src, openEnd);
+        if (closePos === -1) continue; // Unbalanced HTML; skip.
+
+        const otherClasses = classValue
+            .split(/\s+/)
+            .filter(c => c && c !== 'p-fluid')
+            .join(' ')
+            .trim();
+
+        const openTag = src.slice(m.index, openEnd);
+
+        let replaceDiv: boolean;
+        let newOpenTag: string;
+        if (otherClasses === '' && /<div\s+class\s*=\s*("[^"]*"|'[^']*')\s*>/.test(openTag)) {
+            // `p-fluid` was the sole class AND the div had no other attributes → drop the
+            // div entirely and replace with `<p-fluid>`.
+            replaceDiv = true;
+            newOpenTag = '<p-fluid>';
+        } else {
+            // Keep the original div; just strip `p-fluid` from its class list (or remove the
+            // class attribute entirely if `p-fluid` was the only entry there). The `<p-fluid>`
+            // wrapper goes around CHILDREN inside.
+            replaceDiv = false;
+            const newClassAttr = otherClasses ? ` class="${otherClasses}"` : '';
+            newOpenTag = openTag.replace(/\s+class\s*=\s*("[^"]*"|'[^']*')/, newClassAttr);
+        }
+
+        rewrites.push({
+            openStart: m.index,
+            openEnd,
+            closeStart: closePos,
+            closeEnd: closePos + '</div>'.length,
+            replaceDiv,
+            newOpenTag,
+        });
+    }
+
+    if (rewrites.length === 0) return src;
+
+    // Apply rewrites from the end of the string forward so earlier offsets stay valid.
+    let updated = src;
+    for (let i = rewrites.length - 1; i >= 0; i--) {
+        const r = rewrites[i];
+        if (r.replaceDiv) {
+            // Replace `<div class="p-fluid">…</div>` with `<p-fluid>…</p-fluid>`.
+            updated =
+                updated.slice(0, r.openStart) +
+                '<p-fluid>' +
+                updated.slice(r.openEnd, r.closeStart) +
+                '</p-fluid>' +
+                updated.slice(r.closeEnd);
+        } else {
+            // Keep the div, but rewrite its open tag (drop the p-fluid class) and wrap
+            // children in <p-fluid>. We need the indentation of the FIRST child line and
+            // of the closing `</div>` so `<p-fluid>` tags align naturally; preserve
+            // whatever the existing children indent looked like by using the existing
+            // child-block whitespace verbatim.
+            const childrenBlock = updated.slice(r.openEnd, r.closeStart);
+            // Insert <p-fluid> on its own line if the original had multi-line children;
+            // otherwise put it inline. We detect multi-line by the presence of `\n` in
+            // the children block.
+            let wrappedChildren: string;
+            if (childrenBlock.includes('\n')) {
+                // Match the leading whitespace of the first non-empty child line so the
+                // <p-fluid> tags sit one indent level outside the children.
+                const childIndentMatch = childrenBlock.match(/\n([ \t]*)\S/);
+                const childIndent = childIndentMatch?.[1] ?? '';
+                // Outer indent (where </div> sits) is one level less; approximate by
+                // dropping 2 chars of the child indent (good enough for 2-space-indent
+                // codebases; falls back to '' for 1-char or no indent).
+                const outerIndent = childIndent.length >= 2 ? childIndent.slice(0, -2) : '';
+                wrappedChildren =
+                    `\n${childIndent}<p-fluid>` +
+                    childrenBlock.replace(/\n/g, `\n  `) +
+                    `</p-fluid>\n${outerIndent}`;
+            } else {
+                wrappedChildren = `<p-fluid>${childrenBlock}</p-fluid>`;
+            }
+            updated =
+                updated.slice(0, r.openStart) +
+                r.newOpenTag +
+                wrappedChildren +
+                '</div>' +
+                updated.slice(r.closeEnd);
+        }
+    }
+    return updated;
+}
+
+/**
+ * From the position immediately after a `<div ...>` opening tag, return the index where
+ * its matching `</div>` close tag starts. Returns -1 if the file is malformed.
+ */
+function findMatchingDivClose(src: string, startPos: number): number {
+    let depth = 1;
+    let i = startPos;
+    while (i < src.length) {
+        const openIdx = src.indexOf('<div', i);
+        const closeIdx = src.indexOf('</div>', i);
+        if (closeIdx === -1) return -1;
+        if (openIdx !== -1 && openIdx < closeIdx) {
+            const tagEnd = src.indexOf('>', openIdx);
+            if (tagEnd === -1) return -1;
+            const tag = src.slice(openIdx, tagEnd + 1);
+            if (!tag.trimEnd().endsWith('/>')) depth++;
+            i = tagEnd + 1;
+        } else {
+            depth--;
+            if (depth === 0) return closeIdx;
+            i = closeIdx + '</div>'.length;
+        }
+    }
+    return -1;
+}
+
+/**
+ * Given a `@Component({...})` argument NewClass and the source path of the TS file, check
+ * whether its `templateUrl` resolves to a path in the rewritten-HTML set.
+ */
+function templateUrlReferencesRewritten(newClass: J.NewClass, tsSourcePath: string | undefined): boolean {
+    if (!tsSourcePath) return false;
+    if (!newClass.body) return false;
+
+    for (const stmt of newClass.body.statements) {
+        const s = stmt.element;
+        if (s.kind !== JS.Kind.PropertyAssignment) continue;
+        const prop = s as JS.PropertyAssignment;
+        const nameExpr = prop.name.element;
+        if (!isIdentifier(nameExpr)) continue;
+        if ((nameExpr as J.Identifier).simpleName !== 'templateUrl') continue;
+        const valueExpr: any = (prop as any).initializer?.element ?? (prop as any).initializer;
+        if (valueExpr?.kind !== J.Kind.Literal) continue;
+        const templatePath = String((valueExpr as J.Literal).value ?? '');
+        const tsDir = path.dirname(tsSourcePath);
+        const resolved = path.normalize(path.join(tsDir, templatePath));
+        for (const htmlPath of rewrittenHtmlPaths) {
+            if (htmlPath === resolved || htmlPath.endsWith(resolved) || resolved.endsWith(htmlPath)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    return false;
+}

package/src/libraries/primeng/18/migrate-primeng-config.ts

@@ -0,0 +1,112 @@
+/*
+ * 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, produceAsync, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {ChangeImport, JavaScriptVisitor, JS} from "@openrewrite/rewrite/javascript";
+import {J, isIdentifier} from "@openrewrite/rewrite/java";
+
+const CONFIG_NAMES = new Set(['PrimeNGConfig', 'PrimeNG']);
+
+class RenamePrimeNGConfigIdentifiers extends Recipe {
+    readonly name = "org.openrewrite.primeng.MigratePrimeNgConfigToPrimeNG.identifiers";
+    readonly displayName = "Rename `PrimeNGConfig` identifiers to `PrimeNG`";
+    readonly description = "Renames `PrimeNGConfig` identifier usages in files importing it from `primeng/api`.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            private hasImport = 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) return imp;
+                if ((moduleSpec as J.Literal).value !== "primeng/api") return imp;
+
+                const namedBindings = imp.importClause?.namedBindings;
+                if (namedBindings?.kind === JS.Kind.NamedImports) {
+                    for (const specifier of (namedBindings as JS.NamedImports).elements.elements) {
+                        const spec = specifier.element as JS.ImportSpecifier;
+                        if (isIdentifier(spec.specifier) && (spec.specifier as J.Identifier).simpleName === 'PrimeNGConfig') {
+                            this.hasImport = true;
+                        }
+                    }
+                }
+                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 (this.hasImport && id.simpleName === 'PrimeNGConfig') {
+                    return produceAsync(id, async draft => { draft.simpleName = 'PrimeNG'; });
+                }
+                return id;
+            }
+        };
+    }
+}
+
+class FindPrimeNGConfigInjection extends Recipe {
+    readonly name = "org.openrewrite.primeng.MigratePrimeNgConfigToPrimeNG.find-injection";
+    readonly displayName = "Find `PrimeNGConfig` / `PrimeNG` service injection";
+    readonly description = "Flags constructor injection or `inject()` calls for `PrimeNGConfig` or `PrimeNG` service, " +
+        "suggesting migration to `providePrimeNG()` in application providers.";
+
+    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) return m;
+
+                if (isIdentifier(m.name) && m.name.simpleName === 'inject') {
+                    for (const arg of m.arguments?.elements ?? []) {
+                        if (isIdentifier(arg.element) && CONFIG_NAMES.has((arg.element as J.Identifier).simpleName)) {
+                            return foundSearchResult(m,
+                                `\`${(arg.element as J.Identifier).simpleName}\` injection detected. ` +
+                                "Migrate to `providePrimeNG({ ... })` in your application providers (e.g. `app.config.ts`) instead of injecting the service directly.");
+                        }
+                    }
+                }
+
+                return m;
+            }
+
+            protected async visitVariableDeclarations(variable: J.VariableDeclarations, p: ExecutionContext): Promise<J | undefined> {
+                const v = await super.visitVariableDeclarations(variable, p) as J.VariableDeclarations;
+                if (!v) return v;
+
+                if (v.typeExpression && isIdentifier(v.typeExpression) && CONFIG_NAMES.has(v.typeExpression.simpleName)) {
+                    return foundSearchResult(v,
+                        `\`${v.typeExpression.simpleName}\` type annotation detected. ` +
+                        "Migrate to `providePrimeNG({ ... })` in your application providers (e.g. `app.config.ts`) instead of injecting the service directly.");
+                }
+
+                return v;
+            }
+        };
+    }
+}
+
+export class MigratePrimeNgConfigToPrimeNG extends Recipe {
+    readonly name = "org.openrewrite.primeng.MigratePrimeNgConfigToPrimeNG";
+    readonly displayName = "Migrate `PrimeNGConfig` to `PrimeNG`";
+    readonly description = "Renames the `PrimeNGConfig` import from `primeng/api` to `PrimeNG` from `primeng/config`, " +
+        "renames all identifier usages, and flags injection sites that should be migrated to `providePrimeNG()` in application providers.";
+
+    async recipeList(): Promise<Recipe[]> {
+        return [
+            new RenamePrimeNGConfigIdentifiers(),
+            new ChangeImport({
+                oldModule: "primeng/api",
+                oldMember: "PrimeNGConfig",
+                newModule: "primeng/config",
+                newMember: "PrimeNG",
+            }),
+            new FindPrimeNGConfigInjection(),
+        ];
+    }
+}

package/src/libraries/primeng/18/migrate-primeng-signal-assignments.ts

@@ -0,0 +1,83 @@
+/*
+ * 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} from "@openrewrite/rewrite/java";
+
+// Fields on the v18 `PrimeNG` config service that are now `WritableSignal<T>`.
+// In v17 they were plain fields, so direct assignment worked.
+// In v18 the assignment must go through `.set(value)`.
+const SIGNAL_FIELDS = new Set<string>([
+    'ripple',
+    'inputStyle',
+    'inputVariant',
+    'csp',
+]);
+
+/**
+ * Converts assignments like `service.ripple = true` to `service.ripple.set(true)`
+ * in files that import `PrimeNG` from `primeng/config` (i.e. the v18 config service).
+ */
+export class MigratePrimeNGSignalAssignments extends Recipe {
+    readonly name = "org.openrewrite.primeng.MigratePrimeNGSignalAssignments";
+    readonly displayName = "Migrate `PrimeNG` config field assignments to `.set()`";
+    readonly description = "In PrimeNG 18, fields on the `PrimeNG` config service like `ripple`, " +
+        "`inputStyle`, `inputVariant`, and `csp` are `WritableSignal<T>` rather than plain fields. " +
+        "Direct assignment (`service.ripple = true`) no longer compiles. This recipe rewrites such " +
+        "assignments to use the signal's `set()` method (`service.ripple.set(true)`) when the file " +
+        "imports `PrimeNG` from `primeng/config`.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            private hasPrimeNGImport = 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) return imp;
+                if ((moduleSpec as J.Literal).value !== "primeng/config") return imp;
+
+                const namedBindings = imp.importClause?.namedBindings;
+                if (namedBindings?.kind === JS.Kind.NamedImports) {
+                    for (const specifier of (namedBindings as JS.NamedImports).elements.elements) {
+                        const spec = specifier.element as JS.ImportSpecifier;
+                        if (isIdentifier(spec.specifier) && (spec.specifier as J.Identifier).simpleName === 'PrimeNG') {
+                            this.hasPrimeNGImport = true;
+                        }
+                    }
+                }
+                return imp;
+            }
+
+            protected async visitAssignment(assignment: J.Assignment, p: ExecutionContext): Promise<J | undefined> {
+                const a = await super.visitAssignment(assignment, p) as J.Assignment;
+                if (!a) return a;
+                if (!this.hasPrimeNGImport) return a;
+
+                const variable = a.variable;
+                if (variable.kind !== J.Kind.FieldAccess) return a;
+
+                const fa = variable as J.FieldAccess;
+                const fieldName = (fa.name as any)?.element?.simpleName ?? (fa.name as any)?.simpleName;
+                if (!fieldName || !SIGNAL_FIELDS.has(fieldName)) return a;
+
+                const valueNode = (a.assignment as any).element ?? a.assignment;
+
+                const replacement = await Template.builder()
+                    .param(fa)
+                    .code('.set(')
+                    .param(valueNode)
+                    .code(')')
+                    .build()
+                    .apply(a, this.cursor);
+
+                return {...(replacement as any), prefix: a.prefix} as J;
+            }
+        };
+    }
+}