@openrewrite/recipes-react 0.2.9

package/src/react17/remove-event-persist.ts

@@ -0,0 +1,121 @@
+import {ExecutionContext, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {JavaScriptVisitor, JS} from "@openrewrite/rewrite/javascript";
+import {J} from "@openrewrite/rewrite/java";
+import {create} from "mutative";
+
+/**
+ * Removes `event.persist()` calls.
+ *
+ * React 17 removed event pooling, so calling `persist()` on
+ * synthetic events is no longer necessary.
+ *
+ * Before:
+ * ```tsx
+ * function handleChange(e) {
+ *     e.persist();
+ *     setState(e.target.value);
+ * }
+ * ```
+ *
+ * After:
+ * ```tsx
+ * function handleChange(e) {
+ *     setState(e.target.value);
+ * }
+ * ```
+ *
+ * @see https://reactjs.org/blog/2020/10/20/react-v17.html#no-event-pooling
+ */
+export class RemoveEventPersist extends Recipe {
+    readonly name = "org.openrewrite.react.17.remove-event-persist";
+    readonly displayName: string = "Remove `event.persist()` calls";
+    readonly description: string = "Removes `event.persist()` calls. React 17 removed event pooling, making persist() unnecessary.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            override async visitJsCompilationUnit(cu: JS.CompilationUnit, ctx: ExecutionContext): Promise<J | undefined> {
+                let result = await super.visitJsCompilationUnit(cu, ctx) as JS.CompilationUnit;
+
+                const statementsToRemove = new Set<string>();
+
+                for (const stmt of result.statements) {
+                    const s = stmt.element;
+                    if (!s) continue;
+                    if (this.isPersistCall(s)) {
+                        statementsToRemove.add((s as any).id);
+                    }
+                }
+
+                if (statementsToRemove.size === 0) return result;
+
+                const filteredStatements = result.statements.filter(stmt => {
+                    const s = stmt.element;
+                    return !s || !statementsToRemove.has((s as any).id);
+                });
+
+                return create(result, draft => {
+                    draft.statements = filteredStatements as any;
+                });
+            }
+
+            override async visitBlock(block: J.Block, ctx: ExecutionContext): Promise<J | undefined> {
+                let b = await super.visitBlock(block, ctx) as J.Block;
+
+                const statementsToRemove = new Set<string>();
+
+                for (const stmt of b.statements) {
+                    const s = stmt.element;
+                    if (!s) continue;
+                    if (this.isPersistCall(s)) {
+                        statementsToRemove.add((s as any).id);
+                    }
+                }
+
+                if (statementsToRemove.size === 0) return b;
+
+                const filteredStatements = b.statements.filter(stmt => {
+                    const s = stmt.element;
+                    return !s || !statementsToRemove.has((s as any).id);
+                });
+
+                return create(b, draft => {
+                    draft.statements = filteredStatements as any;
+                });
+            }
+
+            private isPersistCall(stmt: any): boolean {
+                let expr: any;
+
+                if (stmt.kind === JS.Kind.ExpressionStatement) {
+                    expr = (stmt as JS.ExpressionStatement).expression;
+                } else if (stmt.kind === J.Kind.MethodInvocation) {
+                    expr = stmt;
+                } else {
+                    return false;
+                }
+
+                if (!expr || expr.kind !== J.Kind.MethodInvocation) return false;
+
+                const method = expr as J.MethodInvocation;
+
+                // Must be called as x.persist(), not just persist()
+                if (!method.select) return false;
+
+                // Method name must be "persist"
+                if (method.name.simpleName !== 'persist') return false;
+
+                // Must have no real arguments (may contain J.Empty placeholder)
+                if (method.arguments) {
+                    const args = method.arguments.elements;
+                    const hasRealArgs = args.some((el: any) => {
+                        const element = el.element ?? el;
+                        return element.kind !== J.Kind.Empty;
+                    });
+                    if (hasRealArgs) return false;
+                }
+
+                return true;
+            }
+        }();
+    }
+}

package/src/react17/rename-unsafe-lifecycles.ts

@@ -0,0 +1,57 @@
+import {ExecutionContext, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {JavaScriptVisitor} from "@openrewrite/rewrite/javascript";
+import {J} from "@openrewrite/rewrite/java";
+
+const UNSAFE_LIFECYCLE_MAP: Record<string, string> = {
+    'componentWillMount': 'UNSAFE_componentWillMount',
+    'componentWillReceiveProps': 'UNSAFE_componentWillReceiveProps',
+    'componentWillUpdate': 'UNSAFE_componentWillUpdate',
+};
+
+/**
+ * Adds `UNSAFE_` prefix to deprecated lifecycle methods.
+ *
+ * React 16.3 deprecated `componentWillMount`, `componentWillReceiveProps`,
+ * and `componentWillUpdate`. React 17 requires the UNSAFE_ prefix.
+ *
+ * Before:
+ * ```tsx
+ * class MyComponent extends React.Component {
+ *   componentWillMount() { ... }
+ *   componentWillReceiveProps(nextProps) { ... }
+ *   componentWillUpdate(nextProps, nextState) { ... }
+ * }
+ * ```
+ *
+ * After:
+ * ```tsx
+ * class MyComponent extends React.Component {
+ *   UNSAFE_componentWillMount() { ... }
+ *   UNSAFE_componentWillReceiveProps(nextProps) { ... }
+ *   UNSAFE_componentWillUpdate(nextProps, nextState) { ... }
+ * }
+ * ```
+ */
+export class RenameUnsafeLifecycles extends Recipe {
+    readonly name = "org.openrewrite.react.17.rename-unsafe-lifecycles";
+    readonly displayName: string = "Add `UNSAFE_` prefix to deprecated lifecycle methods";
+    readonly description: string = "Renames `componentWillMount`, `componentWillReceiveProps`, and `componentWillUpdate` to their UNSAFE_ prefixed versions.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            override async visitIdentifier(ident: J.Identifier, ctx: ExecutionContext): Promise<J | undefined> {
+                let id = await super.visitIdentifier(ident, ctx) as J.Identifier;
+
+                const newName = UNSAFE_LIFECYCLE_MAP[id.simpleName];
+                if (newName) {
+                    return {
+                        ...id,
+                        simpleName: newName
+                    } as J.Identifier;
+                }
+
+                return id;
+            }
+        }();
+    }
+}

package/src/react17/update-react-imports.ts

@@ -0,0 +1,50 @@
+import {ExecutionContext, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {JavaScriptVisitor, maybeRemoveImport} from "@openrewrite/rewrite/javascript";
+import {J} from "@openrewrite/rewrite/java";
+
+/**
+ * Removes unnecessary `import React from 'react'` default imports.
+ *
+ * With React 17's new JSX transform, you no longer need to import React
+ * in every file that uses JSX. This recipe removes the default React
+ * import when it's only used for JSX (not for React.xxx API calls).
+ *
+ * Before:
+ * ```tsx
+ * import React from 'react';
+ *
+ * function App() {
+ *   return <div>Hello</div>;
+ * }
+ * ```
+ *
+ * After:
+ * ```tsx
+ * function App() {
+ *   return <div>Hello</div>;
+ * }
+ * ```
+ *
+ * Note: If `React` is used for API calls (e.g., `React.createElement`,
+ * `React.useRef`), the import is preserved.
+ *
+ * @see https://reactjs.org/blog/2020/09/22/introducing-the-new-jsx-transform.html
+ */
+export class UpdateReactImports extends Recipe {
+    readonly name = "org.openrewrite.react.17.update-react-imports";
+    readonly displayName: string = "Remove unnecessary React imports";
+    readonly description: string = "Removes the default `import React from 'react'` when React is only used for JSX, which is no longer necessary with the new JSX transform in React 17+.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            override async visitJsCompilationUnit(cu: any, ctx: ExecutionContext): Promise<J | undefined> {
+                let result = await super.visitJsCompilationUnit(cu, ctx);
+                // Schedule removal of the default React import.
+                // RemoveImport will only remove it if 'React' is not referenced
+                // anywhere outside of the import declaration itself.
+                maybeRemoveImport(this, "react", "default");
+                return result;
+            }
+        }();
+    }
+}

package/src/react17/upgrade-to-react-17.ts

@@ -0,0 +1,30 @@
+import {Recipe} from "@openrewrite/rewrite";
+import {UpgradeToReact16} from "../react16/upgrade-to-react-16";
+import {RenameUnsafeLifecycles} from "./rename-unsafe-lifecycles";
+import {UpdateReactImports} from "./update-react-imports";
+import {RemoveEventPersist} from "./remove-event-persist";
+
+/**
+ * Composite recipe that applies all React 17 migration recipes.
+ *
+ * First applies all React 16 migrations, then:
+ * - Add `UNSAFE_` prefix to deprecated lifecycle methods
+ * - Remove unnecessary `import React from 'react'`
+ * - Remove `e.persist()` calls (event pooling was removed)
+ *
+ * @see https://reactjs.org/blog/2020/10/20/react-v17.html
+ */
+export class UpgradeToReact17 extends Recipe {
+    readonly name = "org.openrewrite.react.migrate.upgrade-to-react-17";
+    readonly displayName = "Upgrade to React 17";
+    readonly description = "Migrate deprecated APIs for React 17 compatibility. Includes all React 16 migrations plus lifecycle method prefixing, import cleanup, and event.persist() removal.";
+
+    async recipeList(): Promise<Recipe[]> {
+        return [
+            new UpgradeToReact16(),
+            new RenameUnsafeLifecycles(),
+            new UpdateReactImports(),
+            new RemoveEventPersist(),
+        ];
+    }
+}

package/src/react18/remove-unstable-batched-updates.ts

@@ -0,0 +1,192 @@
+import {ExecutionContext, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {JavaScriptVisitor, JS, maybeRemoveImport} from "@openrewrite/rewrite/javascript";
+import {isIdentifier, J} from "@openrewrite/rewrite/java";
+import {create} from "mutative";
+
+/**
+ * Removes `unstable_batchedUpdates` wrappers from `react-dom`.
+ *
+ * In React 18, all state updates are automatically batched,
+ * making `unstable_batchedUpdates` unnecessary. This recipe
+ * unwraps the callback body and removes the wrapping call.
+ *
+ * Before:
+ * ```tsx
+ * import { unstable_batchedUpdates } from 'react-dom';
+ *
+ * unstable_batchedUpdates(() => {
+ *     setCount(1);
+ *     setFlag(true);
+ * });
+ * ```
+ *
+ * After:
+ * ```tsx
+ * setCount(1);
+ * setFlag(true);
+ * ```
+ *
+ * @see https://react.dev/blog/2022/03/29/react-v18#new-feature-automatic-batching
+ */
+export class RemoveUnstableBatchedUpdates extends Recipe {
+    readonly name = "org.openrewrite.react.18.remove-unstable-batched-updates";
+    readonly displayName = "Remove `unstable_batchedUpdates`";
+    readonly description = "Removes `unstable_batchedUpdates` wrappers from `react-dom`. React 18 automatically batches all state updates, making this function unnecessary.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            private changed = false;
+
+            override async visitJsCompilationUnit(cu: JS.CompilationUnit, ctx: ExecutionContext): Promise<J | undefined> {
+                this.changed = false;
+                let result = await super.visitJsCompilationUnit(cu, ctx) as JS.CompilationUnit;
+
+                result = this.inlineTopLevelStatements(result);
+
+                if (this.changed) {
+                    maybeRemoveImport(this, "react-dom", "unstable_batchedUpdates");
+                }
+
+                return result;
+            }
+
+            override async visitBlock(block: J.Block, ctx: ExecutionContext): Promise<J | undefined> {
+                let b = await super.visitBlock(block, ctx) as J.Block;
+                return this.inlineBlockStatements(b);
+            }
+
+            private inlineTopLevelStatements(cu: JS.CompilationUnit): JS.CompilationUnit {
+                const result = this.spliceStatements(cu.statements);
+                if (!result) return cu;
+                return create(cu, draft => {
+                    draft.statements = result as any;
+                });
+            }
+
+            private inlineBlockStatements(block: J.Block): J.Block {
+                const result = this.spliceStatements(block.statements);
+                if (!result) return block;
+                return create(block, draft => {
+                    draft.statements = result as any;
+                });
+            }
+
+            private spliceStatements(statements: any[]): any[] | null {
+                const newStatements: any[] = [];
+                let changed = false;
+
+                for (const paddedStmt of statements) {
+                    const stmt = paddedStmt.element;
+                    if (!stmt) {
+                        newStatements.push(paddedStmt);
+                        continue;
+                    }
+
+                    const bodyStatements = this.extractBatchedUpdatesBody(stmt);
+                    if (bodyStatements !== null && bodyStatements.length > 0) {
+                        // Compute indentation adjustment: replace the inner callback
+                        // indentation with the outer statement's indentation
+                        const outerPrefix = paddedStmt.element.prefix;
+                        const outerIndent = this.getIndentation(outerPrefix);
+                        const innerIndent = bodyStatements.length > 0
+                            ? this.getIndentation(bodyStatements[0].element.prefix)
+                            : outerIndent;
+
+                        for (const bodyStmt of bodyStatements) {
+                            const adjustedPrefix = this.adjustIndentation(
+                                bodyStmt.element.prefix, innerIndent, outerIndent
+                            );
+                            newStatements.push({
+                                ...bodyStmt,
+                                element: {
+                                    ...bodyStmt.element,
+                                    prefix: adjustedPrefix
+                                }
+                            });
+                        }
+                        changed = true;
+                        this.changed = true;
+                    } else {
+                        newStatements.push(paddedStmt);
+                    }
+                }
+
+                return changed ? newStatements : null;
+            }
+
+            private getIndentation(prefix: any): string {
+                const ws: string = prefix?.whitespace ?? '';
+                // Get the indentation from the last line of the whitespace
+                const lastNewline = ws.lastIndexOf('\n');
+                return lastNewline >= 0 ? ws.substring(lastNewline + 1) : ws;
+            }
+
+            private adjustIndentation(prefix: any, fromIndent: string, toIndent: string): any {
+                if (fromIndent === toIndent) return prefix;
+                const ws: string = prefix?.whitespace ?? '';
+                const lastNewline = ws.lastIndexOf('\n');
+                if (lastNewline < 0) return {...prefix, whitespace: toIndent};
+                const currentIndent = ws.substring(lastNewline + 1);
+                // Replace the inner indentation with the outer one
+                const adjusted = currentIndent.startsWith(fromIndent)
+                    ? toIndent + currentIndent.substring(fromIndent.length)
+                    : toIndent;
+                return {...prefix, whitespace: ws.substring(0, lastNewline + 1) + adjusted};
+            }
+
+            private extractBatchedUpdatesBody(stmt: any): any[] | null {
+                let expr: any;
+
+                if (stmt.kind === JS.Kind.ExpressionStatement) {
+                    expr = (stmt as JS.ExpressionStatement).expression;
+                } else if (stmt.kind === J.Kind.MethodInvocation) {
+                    expr = stmt;
+                } else {
+                    return null;
+                }
+
+                if (!expr || expr.kind !== J.Kind.MethodInvocation) return null;
+
+                const method = expr as J.MethodInvocation;
+
+                if (!this.isBatchedUpdatesCall(method)) return null;
+
+                // Get the callback argument
+                const args = method.arguments;
+                if (!args) return null;
+
+                const elements = args.elements;
+                if (!elements || elements.length === 0) return null;
+
+                const callback = elements[0].element;
+                if (!callback) return null;
+
+                // Arrow function with block body
+                if (callback.kind === JS.Kind.ArrowFunction) {
+                    const arrow = callback as JS.ArrowFunction;
+                    const body = arrow.lambda.body;
+                    if (body && body.kind === J.Kind.Block) {
+                        return (body as J.Block).statements;
+                    }
+                }
+
+                return null;
+            }
+
+            private isBatchedUpdatesCall(method: J.MethodInvocation): boolean {
+                if (method.name.simpleName === 'unstable_batchedUpdates') {
+                    // Direct call: unstable_batchedUpdates(...)
+                    if (!method.select) return true;
+
+                    // Namespace call: ReactDOM.unstable_batchedUpdates(...)
+                    const select = (method.select as any).element ?? method.select;
+                    if (isIdentifier(select) && select.simpleName === 'ReactDOM') {
+                        return true;
+                    }
+                }
+
+                return false;
+            }
+        }();
+    }
+}

package/src/react18/replace-reactdom-render.ts

@@ -0,0 +1,68 @@
+import {ExecutionContext, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {
+    capture,
+    JavaScriptVisitor,
+    maybeAddImport,
+    maybeRemoveImport,
+    pattern,
+    rewrite,
+    template
+} from "@openrewrite/rewrite/javascript";
+import {Expression, J} from "@openrewrite/rewrite/java";
+
+/**
+ * Replaces `ReactDOM.render()` with `createRoot().render()`.
+ *
+ * In React 18, `ReactDOM.render()` is deprecated in favor of
+ * `createRoot()` from `react-dom/client`.
+ *
+ * Before:
+ * ```tsx
+ * import ReactDOM from 'react-dom';
+ * ReactDOM.render(<App />, document.getElementById('root'));
+ * ```
+ *
+ * After:
+ * ```tsx
+ * import { createRoot } from 'react-dom/client';
+ * const root = createRoot(document.getElementById('root'));
+ * root.render(<App />);
+ * ```
+ *
+ * @see https://react.dev/blog/2022/03/08/react-18-upgrade-guide#updates-to-client-rendering-apis
+ */
+export class ReplaceReactDomRender extends Recipe {
+    readonly name = "org.openrewrite.react.18.replace-reactdom-render";
+    readonly displayName: string = "Replace `ReactDOM.render` with `createRoot`";
+    readonly description: string = "Migrates from the legacy `ReactDOM.render()` API to the `createRoot()` API from `react-dom/client` introduced in React 18.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        const reactDomOptions = {
+            context: ['import { render } from "react-dom";'],
+            dependencies: {'@types/react-dom': '^17.0.0'}
+        };
+
+        const element = capture<Expression>();
+        const container = capture<Expression>();
+
+        const rule = rewrite(() => ({
+            before: pattern`render(${element}, ${container})`.configure(reactDomOptions),
+            after: template`createRoot(${container}).render(${element})`
+        }));
+
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            override async visitMethodInvocation(method: J.MethodInvocation, p: ExecutionContext): Promise<J | undefined> {
+                let m = await super.visitMethodInvocation(method, p) as J.MethodInvocation;
+
+                const result = await rule.tryOn(this.cursor, m!);
+                if (result) {
+                    maybeRemoveImport(this, "react-dom", "render");
+                    maybeAddImport(this, {module: "react-dom/client", member: "createRoot", onlyIfReferenced: false});
+                    return result;
+                }
+
+                return m;
+            }
+        }();
+    }
+}

package/src/react18/replace-render-callback.ts

@@ -0,0 +1,66 @@
+import {ExecutionContext, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {JavaScriptVisitor} from "@openrewrite/rewrite/javascript";
+import {isIdentifier, J} from "@openrewrite/rewrite/java";
+import {create} from "mutative";
+
+/**
+ * Removes the third callback argument from `ReactDOM.render()` calls.
+ *
+ * In React 18, `ReactDOM.render()` is deprecated in favor of `createRoot()`,
+ * which does not support a callback argument. This recipe strips the callback
+ * to prepare code for the migration.
+ *
+ * Before:
+ * ```tsx
+ * ReactDOM.render(<App />, document.getElementById('root'), () => {
+ *     console.log('rendered');
+ * });
+ * ```
+ *
+ * After:
+ * ```tsx
+ * ReactDOM.render(<App />, document.getElementById('root'));
+ * ```
+ *
+ * @see https://react.dev/blog/2022/03/08/react-18-upgrade-guide#updates-to-client-rendering-apis
+ */
+export class ReplaceRenderCallback extends Recipe {
+    readonly name = "org.openrewrite.react.18.replace-render-callback";
+    readonly displayName: string = "Remove `ReactDOM.render` callback argument";
+    readonly description: string = "Removes the third callback argument from `ReactDOM.render(element, container, callback)` calls. Callbacks are not supported in React 18's `createRoot` API.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            override async visitMethodInvocation(method: J.MethodInvocation, p: ExecutionContext): Promise<J | undefined> {
+                let m = await super.visitMethodInvocation(method, p) as J.MethodInvocation;
+
+                if (m.name.simpleName !== 'render') return m;
+
+                // Check for ReactDOM.render (namespace call)
+                const isReactDomRender = (() => {
+                    if (m.select) {
+                        const select = (m.select as any).element ?? m.select;
+                        return isIdentifier(select) && select.simpleName === 'ReactDOM';
+                    }
+                    return false;
+                })();
+
+                if (!isReactDomRender) return m;
+
+                // Only transform when there are exactly 3 arguments (element, container, callback)
+                const args = m.arguments?.elements;
+                if (!args || args.length !== 3) return m;
+
+                // Remove the 3rd argument (callback)
+                const newArgs = args.slice(0, 2);
+
+                return create(m, draft => {
+                    (draft as any).arguments = {
+                        ...m.arguments,
+                        elements: newArgs
+                    };
+                });
+            }
+        }();
+    }
+}

package/src/react18/replace-unmount-component-at-node.ts

@@ -0,0 +1,66 @@
+import {ExecutionContext, Recipe, TreeVisitor} from "@openrewrite/rewrite";
+import {
+    capture,
+    JavaScriptVisitor,
+    maybeAddImport,
+    maybeRemoveImport,
+    pattern,
+    rewrite,
+    template
+} from "@openrewrite/rewrite/javascript";
+import {Expression, J} from "@openrewrite/rewrite/java";
+
+/**
+ * Replaces `ReactDOM.unmountComponentAtNode()` with `createRoot().unmount()`.
+ *
+ * In React 18, `ReactDOM.unmountComponentAtNode()` is deprecated in favor of
+ * `createRoot().unmount()` from `react-dom/client`.
+ *
+ * Before:
+ * ```tsx
+ * import { unmountComponentAtNode } from 'react-dom';
+ * unmountComponentAtNode(document.getElementById('root'));
+ * ```
+ *
+ * After:
+ * ```tsx
+ * import { createRoot } from 'react-dom/client';
+ * createRoot(document.getElementById('root')).unmount();
+ * ```
+ *
+ * @see https://react.dev/blog/2022/03/08/react-18-upgrade-guide#updates-to-client-rendering-apis
+ */
+export class ReplaceUnmountComponentAtNode extends Recipe {
+    readonly name = "org.openrewrite.react.18.replace-unmount-component-at-node";
+    readonly displayName: string = "Replace `unmountComponentAtNode` with `createRoot().unmount()`";
+    readonly description: string = "Replaces `ReactDOM.unmountComponentAtNode(container)` with `createRoot(container).unmount()` from `react-dom/client`.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        const reactDomOptions = {
+            context: ['import { unmountComponentAtNode } from "react-dom";'],
+            dependencies: {'@types/react-dom': '^17.0.0'}
+        };
+
+        const container = capture<Expression>();
+
+        const rule = rewrite(() => ({
+            before: pattern`unmountComponentAtNode(${container})`.configure(reactDomOptions),
+            after: template`createRoot(${container}).unmount()`
+        }));
+
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            override async visitMethodInvocation(method: J.MethodInvocation, p: ExecutionContext): Promise<J | undefined> {
+                let m = await super.visitMethodInvocation(method, p) as J.MethodInvocation;
+
+                const result = await rule.tryOn(this.cursor, m!);
+                if (result) {
+                    maybeRemoveImport(this, "react-dom", "unmountComponentAtNode");
+                    maybeAddImport(this, {module: "react-dom/client", member: "createRoot", onlyIfReferenced: false});
+                    return result;
+                }
+
+                return m;
+            }
+        }();
+    }
+}