@openrewrite/recipes-angular 0.0.0

package/src/migration/remove-browser-module-with-server-transition.ts

@@ -0,0 +1,185 @@
+import {ExecutionContext, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {randomId, emptyMarkers} from "@openrewrite/rewrite";
+import {JavaScriptVisitor, JS, maybeAddImport, template, Template, capture, pattern} from "@openrewrite/rewrite/javascript";
+import {J, isIdentifier, isLiteral, emptySpace, singleSpace} from "@openrewrite/rewrite/java";
+
+
+export class RemoveBrowserModuleWithServerTransition extends Recipe {
+    readonly name = "org.openrewrite.angular.migration.remove-browser-module-with-server-transition";
+    readonly displayName: string = "Remove `BrowserModule.withServerTransition`";
+    readonly description: string = "Replaces `BrowserModule.withServerTransition({ appId: '...' })` with `BrowserModule` and adds `{ provide: APP_ID, useValue: '...' }` to the NgModule providers. The `withServerTransition` method was removed in Angular 19.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            private appIdValue: string | null = null;
+
+            protected async visitMethodInvocation(method: J.MethodInvocation, p: ExecutionContext): Promise<J | undefined> {
+                const m = await super.visitMethodInvocation(method, p) as J.MethodInvocation;
+
+                if (!await pattern`BrowserModule.withServerTransition(${capture({variadic: true})})`.match(m, this.cursor)) return m;
+
+                const selectElem = (m as any).select?.element || (m as any).select;
+
+                this.appIdValue = extractAppId(m);
+                if (!this.appIdValue) return m;
+
+                return {...selectElem, prefix: m.prefix};
+            }
+
+            override async visitAnnotation(annotation: J.Annotation, p: ExecutionContext): Promise<J | undefined> {
+                this.appIdValue = null;
+                let a = await super.visitAnnotation(annotation, p) as J.Annotation;
+                if (!a) return a;
+
+                if (!this.appIdValue) 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;
+
+                const appIdValue = this.appIdValue!;
+                maybeAddImport(this, {module: '@angular/core', member: 'APP_ID', onlyIfReferenced: false});
+
+                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) && nameExpr.simpleName === 'providers') {
+                        providersIndex = i;
+                        break;
+                    }
+                }
+                const providerArray = await Template.builder()
+                    .code(`[{ provide: APP_ID, useValue: '${appIdValue}' }]`)
+                    .build()
+                    .apply(a, this.cursor) as any;
+                const providerRp = providerArray.initializer.elements[0];
+
+                const existingStmts = newClass.body.statements;
+                const newStatements = [...existingStmts];
+
+                if (providersIndex !== -1) {
+                    const providersStmt = newStatements[providersIndex].element as any;
+                    const provArray = providersStmt.initializer;
+                    const provContainer = provArray.initializer;
+                    const spacedProviderRp = addObjectSpacing(providerRp);
+                    newStatements[providersIndex] = {
+                        ...newStatements[providersIndex],
+                        element: {
+                            ...providersStmt,
+                            initializer: {
+                                ...provArray,
+                                initializer: {
+                                    ...provContainer,
+                                    elements: [...provContainer.elements, spacedProviderRp],
+                                },
+                            },
+                        },
+                    };
+                } else {
+                    const refProp = existingStmts[0].element as JS.PropertyAssignment;
+                    const spacedProvider = addObjectSpacing(providerRp);
+                    const newArray = {...providerArray, prefix: singleSpace, initializer: {
+                        ...providerArray.initializer,
+                        elements: [spacedProvider],
+                    }};
+                    newStatements.push({
+                        kind: J.Kind.RightPadded,
+                        element: buildProvidersProperty(newArray, 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 extractAppId(methodInv: any): string | null {
+    const args = methodInv.arguments?.elements;
+    if (!args?.length) return null;
+
+    const firstArg = args[0].element;
+    if (firstArg.kind !== J.Kind.NewClass) return null;
+
+    const argObj = firstArg as J.NewClass;
+    if (!argObj.body) return null;
+
+    for (const stmt of argObj.body.statements) {
+        if (stmt.element.kind === JS.Kind.PropertyAssignment) {
+            const prop = stmt.element as JS.PropertyAssignment;
+            const nameExpr = prop.name.element;
+            if (isIdentifier(nameExpr) && nameExpr.simpleName === 'appId' &&
+                prop.initializer && isLiteral(prop.initializer)) {
+                return prop.initializer.value as string;
+            }
+        }
+    }
+    return null;
+}
+
+function addObjectSpacing(rp: any): any {
+    const obj = rp.element;
+    if (!obj.body) return rp;
+    return {
+        ...rp,
+        element: {
+            ...obj,
+            prefix: singleSpace,
+            body: {
+                ...obj.body,
+                end: singleSpace,
+                statements: obj.body.statements.map((s: any) => ({
+                    ...s,
+                    element: {...s.element, prefix: singleSpace},
+                })),
+            },
+        },
+    };
+}
+
+function buildProvidersProperty(providerArray: 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: providerArray,
+    };
+}

package/src/migration/remove-component-factory-resolver.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, maybeRemoveImport} from "@openrewrite/rewrite/javascript";
+import {J, isIdentifier} from "@openrewrite/rewrite/java";
+import {create} from "mutative";
+
+export class RemoveComponentFactoryResolver extends Recipe {
+    readonly name = "org.openrewrite.angular.migration.remove-component-factory-resolver";
+    readonly displayName: string = "Remove `ComponentFactoryResolver`";
+    readonly description: string = "Replaces `resolver.resolveComponentFactory(Component)` with just `Component` " +
+        "and removes the `ComponentFactoryResolver` import. Since Ivy, `ViewContainerRef.createComponent` " +
+        "accepts the component class directly. `ComponentFactoryResolver` was deprecated in Angular 13 and removed in Angular 16.";
+
+    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 !== 'resolveComponentFactory') return m;
+                if (!m.arguments?.elements?.length) return m;
+
+                const componentArg = m.arguments.elements[0].element;
+
+                maybeRemoveImport(this, '@angular/core', 'ComponentFactoryResolver');
+
+                return create(componentArg, draft => {
+                    draft.prefix = m.prefix;
+                }) as J;
+            }
+
+            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 === 'ComponentFactoryResolver') {
+                    maybeRemoveImport(this, '@angular/core', 'ComponentFactoryResolver');
+                }
+
+                return id;
+            }
+        }();
+    }
+}

package/src/migration/remove-default-project.ts

@@ -0,0 +1,52 @@
+/*
+ * 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 {JsonVisitor, Json, getMemberKeyName, isObject} from "@openrewrite/rewrite/json";
+
+export class RemoveDefaultProject extends Recipe {
+    readonly name = "org.openrewrite.angular.migration.remove-default-project";
+    readonly displayName: string = "Remove `defaultProject` from `angular.json`";
+    readonly description: string = "Removes the deprecated `defaultProject` property from `angular.json`. " +
+        "The `defaultProject` option was deprecated in Angular 13 and the CLI infers the default project from the workspace.";
+
+    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;
+
+                if (!isObject(doc.value)) return doc;
+                const obj = doc.value as Json.Object;
+
+                const filtered = obj.members.filter(rp => {
+                    return getMemberKeyName(rp.element as Json.Member) !== 'defaultProject';
+                });
+
+                if (filtered.length === obj.members.length) return doc;
+
+                const values = [...filtered];
+                if (values.length > 0 && obj.members.length > 0) {
+                    const originalFirstPrefix = obj.members[0].element.prefix;
+                    const newFirst = values[0];
+                    if (newFirst.element.prefix !== originalFirstPrefix) {
+                        values[0] = {
+                            ...newFirst,
+                            element: {...newFirst.element, prefix: originalFirstPrefix}
+                        };
+                    }
+                }
+
+                return {
+                    ...doc,
+                    value: {
+                        ...obj,
+                        members: values
+                    } as Json.Object
+                } as Json.Document;
+            }
+        }();
+    }
+}

package/src/migration/remove-empty-ng-on-init.ts

@@ -0,0 +1,80 @@
+import {ExecutionContext, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {JavaScriptVisitor, maybeRemoveImport} from "@openrewrite/rewrite/javascript";
+import {J, isIdentifier, isMethodDeclaration} from "@openrewrite/rewrite/java";
+import {create} from "mutative";
+
+export class RemoveEmptyNgOnInit extends Recipe {
+    readonly name = "org.openrewrite.angular.migration.remove-empty-ng-on-init";
+    readonly displayName: string = "Remove empty `ngOnInit` lifecycle hooks";
+    readonly description: string = "Removes empty `ngOnInit` lifecycle hook methods and OnInit interface from Angular components.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            override async visitClassDeclaration(classDecl: J.ClassDeclaration, p: ExecutionContext): Promise<J | undefined> {
+                let c = await super.visitClassDeclaration(classDecl, p) as J.ClassDeclaration;
+
+                if (!c) {
+                    return c;
+                }
+
+                // Check if class has an empty ngOnInit method
+                const hasEmptyNgOnInit = c.body.statements.some(stmtPadded => {
+                    const stmt = stmtPadded.element;
+                    if (!isMethodDeclaration(stmt)) return false;
+                    if (!isIdentifier(stmt.name) || stmt.name.simpleName !== 'ngOnInit') return false;
+                    return stmt.body && stmt.body.statements.length === 0;
+                });
+
+                if (!hasEmptyNgOnInit) {
+                    return c;
+                }
+
+                // Remove the empty ngOnInit method
+                c = create(c, draft => {
+                    draft.body.statements = draft.body.statements.filter(stmtPadded => {
+                        const stmt = stmtPadded.element;
+                        if (!isMethodDeclaration(stmt)) return false;
+                        if (!isIdentifier(stmt.name) || stmt.name.simpleName !== 'ngOnInit') return true;
+                        // Keep non-empty ngOnInit
+                        return !(stmt.body && stmt.body.statements.length === 0);
+                    });
+                }) as J.ClassDeclaration;
+
+                // Check if class implements OnInit
+                if (c.implements) {
+                    const implementsOnInit = c.implements.elements.some(typeTreePadded => {
+                        const typeTree = typeTreePadded.element;
+                        if (isIdentifier(typeTree)) {
+                            return typeTree.simpleName === 'OnInit';
+                        }
+                        return false;
+                    });
+
+                    if (implementsOnInit) {
+                        // Remove OnInit from implements clause
+                        c = create(c, draft => {
+                            if (draft.implements) {
+                                draft.implements.elements = draft.implements.elements.filter(typeTreePadded => {
+                                    const typeTree = typeTreePadded.element;
+                                    if (isIdentifier(typeTree)) {
+                                        return typeTree.simpleName !== 'OnInit';
+                                    }
+                                    return true;
+                                });
+                                // If no implements left, set to undefined
+                                if (draft.implements.elements.length === 0) {
+                                    draft.implements = undefined;
+                                }
+                            }
+                        }) as J.ClassDeclaration;
+
+                        // Remove OnInit import if no longer used
+                        maybeRemoveImport(this, "@angular/core", "OnInit");
+                    }
+                }
+
+                return c;
+            }
+        }();
+    }
+}

package/src/migration/remove-enable-ivy.ts

@@ -0,0 +1,63 @@
+/*
+ * 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 {JsonVisitor, Json, getMemberKeyName, isObject} from "@openrewrite/rewrite/json";
+
+export class RemoveEnableIvy extends Recipe {
+    readonly name = "org.openrewrite.angular.migration.remove-enable-ivy";
+    readonly displayName: string = "Remove `enableIvy` compiler option";
+    readonly description: string = "Removes the `enableIvy` option from `angularCompilerOptions` in `tsconfig.json`. " +
+        "Ivy is the only rendering engine since Angular 12, and the option was removed in Angular 15.";
+
+    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('tsconfig.json') &&
+                    !doc.sourcePath.endsWith('tsconfig.app.json') &&
+                    !doc.sourcePath.endsWith('tsconfig.lib.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) !== 'angularCompilerOptions') return m;
+                if (!isObject(m.value)) return m;
+
+                const obj = m.value as Json.Object;
+                const filtered = obj.members.filter(rp => {
+                    return getMemberKeyName(rp.element as Json.Member) !== 'enableIvy';
+                });
+
+                if (filtered.length === obj.members.length) return m;
+
+                const values = [...filtered];
+                if (values.length > 0 && obj.members.length > 0) {
+                    const originalFirstPrefix = obj.members[0].element.prefix;
+                    const newFirst = values[0];
+                    if (newFirst.element.prefix !== originalFirstPrefix) {
+                        values[0] = {
+                            ...newFirst,
+                            element: {...newFirst.element, prefix: originalFirstPrefix}
+                        };
+                    }
+                }
+
+                return {
+                    ...m,
+                    value: {
+                        ...obj,
+                        members: values
+                    } as Json.Object
+                } as Json.Member;
+            }
+        }();
+    }
+}

package/src/migration/remove-entry-components.ts

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2026 the original author or authors.
+ *
+ * Moderne Proprietary. Only for use by Moderne customers under the terms of a commercial contract.
+ */
+
+import {ExecutionContext, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {JavaScriptVisitor, JS, maybeRemoveImport} from "@openrewrite/rewrite/javascript";
+import {J, isIdentifier} from "@openrewrite/rewrite/java";
+import {create} from "mutative";
+
+const DECORATORS_WITH_ENTRY_COMPONENTS = ['NgModule', 'Component'];
+
+export class RemoveEntryComponents extends Recipe {
+    readonly name = "org.openrewrite.angular.migration.remove-entry-components";
+    readonly displayName: string = "Remove `entryComponents`";
+    readonly description: string = "Removes the `entryComponents` property from `@NgModule` and `@Component` decorators, " +
+        "and removes the `ANALYZE_FOR_ENTRY_COMPONENTS` import. " +
+        "These were removed in Angular 16 as they served no purpose since Ivy.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            private removedEntryComponents = false;
+
+            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 (!DECORATORS_WITH_ENTRY_COMPONENTS.includes(annotType.simpleName)) 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 entryComponentsIndex = -1;
+                for (let i = 0; i < newClass.body.statements.length; i++) {
+                    const stmt = newClass.body.statements[i].element;
+                    if (stmt.kind === JS.Kind.PropertyAssignment) {
+                        const prop = stmt as JS.PropertyAssignment;
+                        const nameExpr = prop.name.element;
+                        if (isIdentifier(nameExpr) && nameExpr.simpleName === 'entryComponents') {
+                            entryComponentsIndex = i;
+                            break;
+                        }
+                    }
+                }
+
+                if (entryComponentsIndex === -1) return a;
+
+                this.removedEntryComponents = true;
+
+                return create(a, draft => {
+                    const body = (draft.arguments!.elements[0].element as any).body!;
+                    body.statements = body.statements.filter((_: any, i: number) => i !== entryComponentsIndex);
+                }) as J.Annotation;
+            }
+
+            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 === 'ANALYZE_FOR_ENTRY_COMPONENTS') {
+                    maybeRemoveImport(this, '@angular/core', 'ANALYZE_FOR_ENTRY_COMPONENTS');
+                }
+
+                return id;
+            }
+        }();
+    }
+}

package/src/migration/remove-es5-browser-support.ts

@@ -0,0 +1,59 @@
+/*
+ * 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 {JsonVisitor, Json, getMemberKeyName, isObject} from "@openrewrite/rewrite/json";
+
+export class RemoveEs5BrowserSupport extends Recipe {
+    readonly name = "org.openrewrite.angular.migration.remove-es5-browser-support";
+    readonly displayName: string = "Remove `es5BrowserSupport` from `angular.json`";
+    readonly description: string = "Removes the deprecated `es5BrowserSupport` option from `angular.json`. " +
+        "`es5BrowserSupport` was deprecated in Angular 7.3 and removed in Angular 10. " +
+        "Differential loading is now handled automatically by the Angular CLI based on the project's browserslist configuration.";
+
+    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 (!isObject(m.value)) return m;
+
+                const obj = m.value as Json.Object;
+                const filtered = obj.members.filter(rp => {
+                    return getMemberKeyName(rp.element as Json.Member) !== 'es5BrowserSupport';
+                });
+
+                if (filtered.length === obj.members.length) return m;
+
+                const values = [...filtered];
+                if (values.length > 0 && obj.members.length > 0) {
+                    const originalFirstPrefix = obj.members[0].element.prefix;
+                    const newFirst = values[0];
+                    if (newFirst.element.prefix !== originalFirstPrefix) {
+                        values[0] = {
+                            ...newFirst,
+                            element: {...newFirst.element, prefix: originalFirstPrefix}
+                        };
+                    }
+                }
+
+                return {
+                    ...m,
+                    value: {
+                        ...obj,
+                        members: values
+                    } as Json.Object
+                } as Json.Member;
+            }
+        }();
+    }
+}

package/src/migration/remove-extract-css.ts

@@ -0,0 +1,60 @@
+/*
+ * 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 {JsonVisitor, Json, getMemberKeyName, isObject} from "@openrewrite/rewrite/json";
+
+export class RemoveExtractCss extends Recipe {
+    readonly name = "org.openrewrite.angular.migration.remove-extract-css";
+    readonly displayName: string = "Remove `extractCss` from `angular.json`";
+    readonly description: string = "Removes the deprecated `extractCss` build option from `angular.json`. " +
+        "In Angular 11, CSS extraction became the default behavior for production builds and the option was deprecated.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JsonVisitor<ExecutionContext> {
+            protected async visitDocument(doc: Json.Document, p: ExecutionContext): Promise<Json | undefined> {
+                if (!doc.sourcePath.endsWith('angular.json')) return doc;
+                return super.visitDocument(doc, p);
+            }
+
+            protected async visitMember(member: Json.Member, p: ExecutionContext): Promise<Json | undefined> {
+                const m = await super.visitMember(member, p) as Json.Member;
+                if (!m) return m;
+
+                const keyName = getMemberKeyName(m);
+                if (keyName !== 'options' && keyName !== 'production' && keyName !== 'development') return m;
+                if (!isObject(m.value)) return m;
+
+                const obj = m.value as Json.Object;
+                const filtered = obj.members.filter(rp => {
+                    return getMemberKeyName(rp.element as Json.Member) !== 'extractCss';
+                });
+
+                if (filtered.length === obj.members.length) return m;
+
+                const values = [...filtered];
+                if (values.length > 0 && obj.members.length > 0) {
+                    const originalFirstPrefix = obj.members[0].element.prefix;
+                    const newFirst = values[0];
+                    if (newFirst.element.prefix !== originalFirstPrefix) {
+                        values[0] = {
+                            ...newFirst,
+                            element: {...newFirst.element, prefix: originalFirstPrefix}
+                        };
+                    }
+                }
+
+                return {
+                    ...m,
+                    value: {
+                        ...obj,
+                        members: values
+                    } as Json.Object
+                } as Json.Member;
+            }
+        }();
+    }
+}