@openrewrite/recipes-react 0.2.9

package/src/refactoring/create-element-to-jsx.ts

@@ -0,0 +1,200 @@
+import {ExecutionContext, printer, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {JavaScriptVisitor, JS, raw, template} from "@openrewrite/rewrite/javascript";
+import {J} from "@openrewrite/rewrite/java";
+
+/**
+ * Converts `React.createElement()` calls to JSX syntax.
+ *
+ * Handles:
+ * - String tags: `createElement('div', ...)` → `<div ... />`
+ * - Component tags: `createElement(MyComponent, ...)` → `<MyComponent ... />`
+ * - Props objects: `{ className: 'foo' }` → `className="foo"`
+ * - String children: `'Hello'` → text node
+ * - Expression children: `{expr}` → `{expr}`
+ * - Nested createElement calls are handled recursively
+ *
+ * Before:
+ * ```tsx
+ * React.createElement('div', { className: 'foo' }, 'Hello')
+ * React.createElement(MyComponent, { name: 'World' })
+ * ```
+ *
+ * After:
+ * ```tsx
+ * <div className="foo">Hello</div>
+ * <MyComponent name="World" />
+ * ```
+ *
+ * @see https://github.com/reactjs/react-codemod#create-element-to-jsx
+ */
+export class CreateElementToJsx extends Recipe {
+    readonly name = "org.openrewrite.react.refactoring.create-element-to-jsx";
+    readonly displayName: string = "Convert `createElement` to JSX";
+    readonly description: string = "Converts `React.createElement()` calls to JSX syntax for improved readability.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            override async visitMethodInvocation(method: J.MethodInvocation, ctx: ExecutionContext): Promise<J | undefined> {
+                let m = await super.visitMethodInvocation(method, ctx) as J.MethodInvocation;
+
+                if (!this.isCreateElementCall(m)) return m;
+
+                const args = m.arguments.elements;
+                if (args.length === 0) return m;
+
+                // Extract tag name
+                const tagName = this.getTagName(args[0].element);
+                if (!tagName) return m;
+
+                // Extract props
+                const propsStr = args.length > 1
+                    ? await this.serializeProps(args[1].element)
+                    : '';
+
+                // Extract children
+                const childArgs = args.length > 2
+                    ? args.slice(2).map(a => a.element)
+                    : [];
+                const childrenStr = await this.serializeChildren(childArgs);
+
+                // Build JSX
+                let jsxSource: string;
+                if (childrenStr) {
+                    jsxSource = `<${tagName}${propsStr}>${childrenStr}</${tagName}>`;
+                } else {
+                    jsxSource = `<${tagName}${propsStr} />`;
+                }
+
+                return await template`${raw(jsxSource)}`.apply(m, this.cursor);
+            }
+
+            private isCreateElementCall(method: J.MethodInvocation): boolean {
+                if (method.name.simpleName !== 'createElement') return false;
+
+                // React.createElement(...)
+                if (method.select?.element?.kind === J.Kind.Identifier) {
+                    return (method.select.element as J.Identifier).simpleName === 'React';
+                }
+
+                return false;
+            }
+
+            private getTagName(expr: any): string | undefined {
+                // String literal: 'div', 'span', etc.
+                if (expr.kind === J.Kind.Literal) {
+                    const lit = expr as J.Literal;
+                    if (typeof lit.value === 'string') {
+                        return lit.value;
+                    }
+                    return undefined;
+                }
+
+                // Identifier: MyComponent
+                if (expr.kind === J.Kind.Identifier) {
+                    return (expr as J.Identifier).simpleName;
+                }
+
+                // FieldAccess: Foo.Bar
+                if (expr.kind === J.Kind.FieldAccess) {
+                    const fa = expr as J.FieldAccess;
+                    if (fa.target.kind === J.Kind.Identifier) {
+                        return `${(fa.target as J.Identifier).simpleName}.${fa.name.element.simpleName}`;
+                    }
+                    return undefined;
+                }
+
+                return undefined;
+            }
+
+            private async serializeProps(propsExpr: any): Promise<string> {
+                // null or undefined → no props
+                if (propsExpr.kind === J.Kind.Literal) {
+                    const lit = propsExpr as J.Literal;
+                    if (lit.value === null) return '';
+                }
+                if (propsExpr.kind === J.Kind.Identifier) {
+                    if ((propsExpr as J.Identifier).simpleName === 'undefined') return '';
+                }
+
+                // Object literal (represented as J.NewClass with body)
+                if (propsExpr.kind === J.Kind.NewClass) {
+                    const obj = propsExpr as J.NewClass;
+                    if (!obj.body) return '';
+
+                    const attrs: string[] = [];
+                    for (const stmt of obj.body.statements) {
+                        const s = stmt.element;
+
+                        if (s.kind === JS.Kind.PropertyAssignment) {
+                            const prop = s as JS.PropertyAssignment;
+                            const keyExpr = prop.name.element;
+                            let key: string | undefined;
+
+                            if (keyExpr.kind === J.Kind.Identifier) {
+                                key = (keyExpr as J.Identifier).simpleName;
+                            }
+
+                            if (key && prop.initializer) {
+                                const value = prop.initializer;
+
+                                // String literal values → key="value"
+                                if (value.kind === J.Kind.Literal) {
+                                    const lit = value as J.Literal;
+                                    if (typeof lit.value === 'string') {
+                                        attrs.push(`${key}="${lit.value}"`);
+                                        continue;
+                                    }
+                                }
+
+                                // Other values → key={value}
+                                const valueSource = await printer(this.cursor).print(value);
+                                attrs.push(`${key}={${valueSource.trim()}}`);
+                            } else if (key && !prop.initializer) {
+                                // Shorthand: { disabled } → disabled
+                                attrs.push(key);
+                            }
+                        } else if (s.kind === JS.Kind.Spread) {
+                            // Spread: {...rest} → {...rest}
+                            const spread = s as JS.Spread;
+                            const spreadSource = await printer(this.cursor).print(spread.expression);
+                            attrs.push(`{...${spreadSource.trim()}}`);
+                        }
+                    }
+
+                    return attrs.length > 0 ? ' ' + attrs.join(' ') : '';
+                }
+
+                // Non-object props (variable reference) → {...props}
+                const source = await printer(this.cursor).print(propsExpr);
+                return ` {...${source.trim()}}`;
+            }
+
+            private async serializeChildren(children: any[]): Promise<string> {
+                if (children.length === 0) return '';
+
+                const parts: string[] = [];
+                for (const child of children) {
+                    // String literal children → text node
+                    if (child.kind === J.Kind.Literal) {
+                        const lit = child as J.Literal;
+                        if (typeof lit.value === 'string') {
+                            // Escape HTML special characters
+                            const escaped = (lit.value as string)
+                                .replace(/&/g, '&amp;')
+                                .replace(/</g, '&lt;')
+                                .replace(/>/g, '&gt;');
+                            parts.push(escaped);
+                            continue;
+                        }
+                    }
+
+                    // Other expressions → {expression}
+                    const source = await printer(this.cursor).print(child);
+                    parts.push(`{${source.trim()}}`);
+                }
+
+                return parts.join('');
+            }
+        }();
+    }
+}

package/src/refactoring/manual-bind-to-arrow.ts

@@ -0,0 +1,139 @@
+import {ExecutionContext, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {JavaScriptVisitor} from "@openrewrite/rewrite/javascript";
+import {J} from "@openrewrite/rewrite/java";
+
+/**
+ * Converts manual `.bind(this)` in constructors to class field arrow functions.
+ *
+ * Before:
+ * ```tsx
+ * class MyComponent extends React.Component {
+ *   constructor(props) {
+ *     super(props);
+ *     this.handleClick = this.handleClick.bind(this);
+ *   }
+ *   handleClick() { ... }
+ * }
+ * ```
+ *
+ * After:
+ * ```tsx
+ * class MyComponent extends React.Component {
+ *   constructor(props) {
+ *     super(props);
+ *   }
+ *   handleClick = () => { ... };
+ * }
+ * ```
+ *
+ * @see https://github.com/reactjs/react-codemod#manual-bind-to-arrow-transform
+ */
+export class ManualBindToArrow extends Recipe {
+    readonly name = "org.openrewrite.react.refactoring.manual-bind-to-arrow";
+    readonly displayName: string = "Convert manual `.bind(this)` to arrow functions";
+    readonly description: string = "Converts `this.method = this.method.bind(this)` in constructors to class field arrow function syntax.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            private boundMethods = new Set<string>();
+
+            override async visitClassDeclaration(classDecl: J.ClassDeclaration, ctx: ExecutionContext): Promise<J | undefined> {
+                this.boundMethods.clear();
+
+                // First pass: find bind statements in constructor
+                await this.findBindStatements(classDecl);
+
+                if (this.boundMethods.size === 0) {
+                    return classDecl;
+                }
+
+                // Second pass: remove bind statements and convert methods to arrow functions
+                return await super.visitClassDeclaration(classDecl, ctx);
+            }
+
+            private async findBindStatements(classDecl: J.ClassDeclaration): Promise<void> {
+                const body = classDecl.body;
+                if (!body) return;
+
+                for (const stmt of body.statements) {
+                    const s = stmt.element;
+                    if (!s) continue;
+
+                    if (s.kind === J.Kind.MethodDeclaration) {
+                        const method = s as J.MethodDeclaration;
+                        if (method.name.simpleName === 'constructor') {
+                            // Look for this.x = this.x.bind(this) in constructor body
+                            if (method.body) {
+                                for (const bodyStmt of method.body.statements) {
+                                    const bs = bodyStmt.element;
+                                    if (!bs) continue;
+                                    this.checkForBindStatement(bs);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            private checkForBindStatement(stmt: J): void {
+                // Match: this.x = this.x.bind(this)
+                if (stmt.kind !== J.Kind.Assignment) return;
+                const assignment = stmt as J.Assignment;
+
+                // LHS: this.x
+                if (assignment.variable.kind !== J.Kind.FieldAccess) return;
+                const lhs = assignment.variable as J.FieldAccess;
+                if (lhs.target.kind !== J.Kind.Identifier) return;
+                if ((lhs.target as J.Identifier).simpleName !== 'this') return;
+                const methodName = lhs.name.element.simpleName;
+
+                // RHS: this.x.bind(this)
+                const rhs = assignment.assignment.element;
+                if (!rhs || rhs.kind !== J.Kind.MethodInvocation) return;
+                const call = rhs as J.MethodInvocation;
+                if (call.name.simpleName !== 'bind') return;
+
+                // Check select is this.x
+                if (!call.select) return;
+                const select = (call.select as any).element ?? call.select;
+                if (select.kind !== J.Kind.FieldAccess) return;
+                const selectFa = select as J.FieldAccess;
+                if (selectFa.target.kind !== J.Kind.Identifier) return;
+                if ((selectFa.target as J.Identifier).simpleName !== 'this') return;
+                if (selectFa.name.element.simpleName !== methodName) return;
+
+                this.boundMethods.add(methodName);
+            }
+
+            override async visitMethodDeclaration(method: J.MethodDeclaration, ctx: ExecutionContext): Promise<J | undefined> {
+                let m = await super.visitMethodDeclaration(method, ctx) as J.MethodDeclaration;
+
+                // Remove bind statements from constructor
+                if (m.name.simpleName === 'constructor' && m.body && this.boundMethods.size > 0) {
+                    const filteredStatements = m.body.statements.filter(stmt => {
+                        const s = stmt.element;
+                        if (!s || s.kind !== J.Kind.Assignment) return true;
+                        const assignment = s as J.Assignment;
+                        if (assignment.variable.kind !== J.Kind.FieldAccess) return true;
+                        const fa = assignment.variable as J.FieldAccess;
+                        if (fa.target.kind !== J.Kind.Identifier) return true;
+                        if ((fa.target as J.Identifier).simpleName !== 'this') return true;
+                        return !this.boundMethods.has(fa.name.element.simpleName);
+                    });
+
+                    if (filteredStatements.length !== m.body.statements.length) {
+                        m = {
+                            ...m,
+                            body: {
+                                ...m.body,
+                                statements: filteredStatements
+                            }
+                        } as any as J.MethodDeclaration;
+                    }
+                }
+
+                return m;
+            }
+        }();
+    }
+}

package/src/refactoring/pure-render-mixin.ts

@@ -0,0 +1,346 @@
+import {ExecutionContext, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {JavaScriptVisitor, JS, maybeRemoveImport, raw, template} from "@openrewrite/rewrite/javascript";
+import {J} from "@openrewrite/rewrite/java";
+
+/**
+ * Removes `PureRenderMixin` from `React.createClass` components and replaces it
+ * with an explicit `shouldComponentUpdate` method using `shallowCompare`.
+ *
+ * Before:
+ * ```tsx
+ * var PureRenderMixin = require('react-addons-pure-render-mixin');
+ * var MyComponent = React.createClass({
+ *     mixins: [PureRenderMixin],
+ *     render() { return <div />; }
+ * });
+ * ```
+ *
+ * After:
+ * ```tsx
+ * var MyComponent = React.createClass({
+ *     shouldComponentUpdate(nextProps, nextState) {
+ *         return React.addons.shallowCompare(this, nextProps, nextState);
+ *     },
+ *     render() { return <div />; }
+ * });
+ * ```
+ *
+ * @see https://github.com/reactjs/react-codemod#pure-render-mixin
+ */
+export class PureRenderMixin extends Recipe {
+    readonly name = "org.openrewrite.react.refactoring.pure-render-mixin";
+    readonly displayName: string = "Remove `PureRenderMixin`";
+    readonly description: string = "Removes `PureRenderMixin` from `React.createClass` mixins and adds an explicit `shouldComponentUpdate` method.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            private transformed = false;
+
+            override async visitJsCompilationUnit(cu: JS.CompilationUnit, ctx: ExecutionContext): Promise<J | undefined> {
+                this.transformed = false;
+                const result = await super.visitJsCompilationUnit(cu, ctx);
+                if (this.transformed) {
+                    maybeRemoveImport(this, "react-addons-pure-render-mixin", "default");
+                }
+                return result;
+            }
+
+            override async visitMethodInvocation(method: J.MethodInvocation, ctx: ExecutionContext): Promise<J | undefined> {
+                let m = await super.visitMethodInvocation(method, ctx) as J.MethodInvocation;
+
+                if (!this.isCreateClassCall(m)) return m;
+
+                const args = m.arguments.elements;
+                if (args.length === 0) return m;
+
+                const specArg = args[0].element;
+                if (specArg.kind !== J.Kind.NewClass) return m;
+
+                const specObj = specArg as J.NewClass;
+                if (!specObj.body) return m;
+
+                // Find the mixins property and check for PureRenderMixin
+                const mixinsInfo = this.findPureRenderMixin(specObj.body);
+                if (!mixinsInfo) return m;
+
+                // Check that shouldComponentUpdate doesn't already exist
+                if (this.hasShouldComponentUpdate(specObj.body)) return m;
+
+                // Get member indent from existing members
+                const memberIndent = this.getMemberIndent(specObj.body);
+
+                // Build shouldComponentUpdate by cloning an existing method's structure
+                // and replacing its internals with the desired content
+                const existingMethod = this.findAnyMethod(specObj.body);
+                if (!existingMethod) return m;
+
+                // Create the return expression via template
+                const returnExpr = await template`React.addons.shallowCompare(this, nextProps, nextState)`.apply(specObj, this.cursor);
+                if (!returnExpr) return m;
+
+                // Create parameter identifiers via template
+                const nextPropsId = await template`nextProps`.apply(specObj, this.cursor);
+                const nextStateId = await template`nextState`.apply(specObj, this.cursor);
+                if (!nextPropsId || !nextStateId) return m;
+
+                // Build the shouldComponentUpdate method by cloning structure from existing method
+                const scuMethod = this.buildMethodFromTemplate(
+                    existingMethod,
+                    'shouldComponentUpdate',
+                    [nextPropsId, nextStateId],
+                    returnExpr
+                );
+
+                // Build new statements: remove mixins (or PureRenderMixin from it), add shouldComponentUpdate
+                const newStatements = this.buildNewStatements(
+                    specObj.body.statements,
+                    mixinsInfo,
+                    scuMethod,
+                    memberIndent
+                );
+
+                this.transformed = true;
+
+                // Return updated method invocation with modified spec object
+                return {
+                    ...m,
+                    arguments: {
+                        ...m.arguments,
+                        elements: [
+                            {
+                                ...args[0],
+                                element: {
+                                    ...specObj,
+                                    body: {
+                                        ...specObj.body,
+                                        statements: newStatements
+                                    }
+                                }
+                            },
+                            ...args.slice(1)
+                        ]
+                    }
+                } as any as J.MethodInvocation;
+            }
+
+            private isCreateClassCall(method: J.MethodInvocation): boolean {
+                if (method.name.simpleName === 'createClass' && method.select) {
+                    const select = (method.select as any).element ?? method.select;
+                    if (select.kind === J.Kind.Identifier) {
+                        return (select as J.Identifier).simpleName === 'React';
+                    }
+                }
+                if (method.name.simpleName === 'createReactClass' && !method.select) {
+                    return true;
+                }
+                return false;
+            }
+
+            private findPureRenderMixin(body: J.Block): { stmtIndex: number; isOnlyMixin: boolean } | undefined {
+                for (let i = 0; i < body.statements.length; i++) {
+                    const s = body.statements[i].element;
+                    if (s.kind !== JS.Kind.PropertyAssignment) continue;
+
+                    const prop = s as JS.PropertyAssignment;
+                    const keyExpr = prop.name.element;
+                    if (keyExpr.kind !== J.Kind.Identifier) continue;
+                    if ((keyExpr as J.Identifier).simpleName !== 'mixins') continue;
+
+                    // Check if the initializer is an array containing PureRenderMixin
+                    if (!prop.initializer) continue;
+                    const init = prop.initializer;
+                    if (init.kind !== J.Kind.NewArray) continue;
+
+                    const arr = init as J.NewArray;
+                    if (!arr.initializer) continue;
+
+                    const elements = arr.initializer.elements ?? [];
+                    const hasPRM = elements.some((el: any) => {
+                        const elem = el.element ?? el;
+                        return elem.kind === J.Kind.Identifier &&
+                            (elem as J.Identifier).simpleName === 'PureRenderMixin';
+                    });
+
+                    if (hasPRM) {
+                        return {
+                            stmtIndex: i,
+                            isOnlyMixin: elements.length === 1
+                        };
+                    }
+                }
+                return undefined;
+            }
+
+            private hasShouldComponentUpdate(body: J.Block): boolean {
+                return body.statements.some(stmt => {
+                    const s = stmt.element;
+                    if (s.kind === J.Kind.MethodDeclaration) {
+                        return (s as J.MethodDeclaration).name.simpleName === 'shouldComponentUpdate';
+                    }
+                    return false;
+                });
+            }
+
+            private findAnyMethod(body: J.Block): J.MethodDeclaration | undefined {
+                for (const stmt of body.statements) {
+                    if (stmt.element?.kind === J.Kind.MethodDeclaration) {
+                        return stmt.element as J.MethodDeclaration;
+                    }
+                }
+                return undefined;
+            }
+
+            private buildMethodFromTemplate(
+                existingMethod: J.MethodDeclaration,
+                name: string,
+                params: J[],
+                returnExpr: J
+            ): J.MethodDeclaration {
+                // Clone the existing method structure and replace name, params, and body
+                const nameId = {
+                    ...existingMethod.name,
+                    simpleName: name,
+                } as J.Identifier;
+
+                const emptySpace = {kind: 'org.openrewrite.java.tree.Space' as const, whitespace: '', comments: []};
+                const singleSpace = {kind: 'org.openrewrite.java.tree.Space' as const, whitespace: ' ', comments: []};
+                const emptyMarkers = existingMethod.markers;
+
+                // Build parameter list with proper spacing between params
+                const paramElements = params.map((param, i) => ({
+                    kind: 'org.openrewrite.java.tree.JRightPadded' as const,
+                    element: i > 0 ? {...(param as any), prefix: singleSpace} : param,
+                    after: emptySpace,
+                    markers: emptyMarkers,
+                }));
+
+                const bodyPrefix = existingMethod.body?.prefix ?? existingMethod.prefix;
+
+                // Build return statement by wrapping the expression
+                // Add a space prefix to the expression so it renders as "return expr" not "returnexpr"
+                const returnExprWithSpace = {...(returnExpr as any), prefix: singleSpace};
+                const returnStmt: any = {
+                    kind: J.Kind.Return,
+                    id: (returnExpr as any).id,
+                    prefix: {
+                        kind: 'org.openrewrite.java.tree.Space' as const,
+                        whitespace: '\n        ',
+                        comments: []
+                    },
+                    markers: emptyMarkers,
+                    expression: returnExprWithSpace,
+                };
+
+                const body: J.Block = {
+                    kind: J.Kind.Block,
+                    id: existingMethod.body?.id ?? (existingMethod as any).id,
+                    prefix: bodyPrefix,
+                    markers: existingMethod.markers,
+                    static: existingMethod.body?.static ?? {
+                        kind: 'org.openrewrite.java.tree.JRightPadded' as const,
+                        element: false,
+                        after: {kind: 'org.openrewrite.java.tree.Space' as const, whitespace: '', comments: []},
+                        markers: existingMethod.markers,
+                    },
+                    statements: [{
+                        kind: 'org.openrewrite.java.tree.JRightPadded' as const,
+                        element: returnStmt,
+                        after: {kind: 'org.openrewrite.java.tree.Space' as const, whitespace: '', comments: []},
+                        markers: existingMethod.markers,
+                    }],
+                    end: {
+                        kind: 'org.openrewrite.java.tree.Space' as const,
+                        whitespace: '\n    ',
+                        comments: []
+                    },
+                } as any as J.Block;
+
+                const parameters = {
+                    ...existingMethod.parameters,
+                    elements: paramElements,
+                } as any;
+
+                return {
+                    ...existingMethod,
+                    name: nameId,
+                    parameters: parameters,
+                    body: body,
+                } as any as J.MethodDeclaration;
+            }
+
+            private getMemberIndent(body: J.Block): any {
+                for (const stmt of body.statements) {
+                    if (stmt.element?.prefix) return stmt.element.prefix;
+                }
+                return undefined;
+            }
+
+            private buildNewStatements(
+                statements: any[],
+                mixinsInfo: { stmtIndex: number; isOnlyMixin: boolean },
+                scuMethod: J,
+                indent: any
+            ): any[] {
+                const result: any[] = [];
+                let scuInserted = false;
+
+                for (let i = 0; i < statements.length; i++) {
+                    if (i === mixinsInfo.stmtIndex) {
+                        if (mixinsInfo.isOnlyMixin) {
+                            // Remove the entire mixins property
+                            continue;
+                        } else {
+                            // Remove PureRenderMixin from the array but keep other mixins
+                            const stmt = statements[i];
+                            const prop = stmt.element as JS.PropertyAssignment;
+                            const arr = prop.initializer as J.NewArray;
+                            const filteredElements = (arr.initializer!.elements as any[]).filter((el: any) => {
+                                const elem = el.element ?? el;
+                                return !(elem.kind === J.Kind.Identifier &&
+                                    (elem as J.Identifier).simpleName === 'PureRenderMixin');
+                            });
+                            result.push({
+                                ...stmt,
+                                element: {
+                                    ...prop,
+                                    initializer: {
+                                        ...arr,
+                                        initializer: {
+                                            ...arr.initializer,
+                                            elements: filteredElements
+                                        }
+                                    }
+                                }
+                            });
+                            continue;
+                        }
+                    }
+
+                    const s = statements[i].element;
+                    // Insert shouldComponentUpdate before render
+                    if (!scuInserted && s.kind === J.Kind.MethodDeclaration &&
+                        (s as J.MethodDeclaration).name.simpleName === 'render') {
+                        const scuStmt = {
+                            ...statements[i],
+                            element: indent ? {...(scuMethod as any), prefix: indent} : scuMethod
+                        };
+                        result.push(scuStmt);
+                        scuInserted = true;
+                    }
+                    result.push(statements[i]);
+                }
+
+                // If render wasn't found, append at the end
+                if (!scuInserted) {
+                    const lastStmt = statements[statements.length - 1];
+                    result.push({
+                        ...lastStmt,
+                        element: indent ? {...(scuMethod as any), prefix: indent} : scuMethod
+                    });
+                }
+
+                return result;
+            }
+        }();
+    }
+}