@lwc/babel-plugin-component 9.0.3 → 9.0.4-alpha.1

package/dist/constants.d.ts

@@ -23,7 +23,10 @@ declare const TEMPLATE_KEY = "tmpl";
 declare const COMPONENT_NAME_KEY = "sel";
 declare const API_VERSION_KEY = "apiVersion";
 declare const COMPONENT_CLASS_ID = "__lwc_component_class_internal";
+declare const PRIVATE_METHOD_PREFIX = "__lwc_component_class_internal_private_";
+declare const PRIVATE_METHOD_METADATA_KEY = "__lwcTransformedPrivateMethods";
+declare const ENABLE_PRIVATE_METHODS_KEY = "enablePrivateMethods";
 declare const SYNTHETIC_ELEMENT_INTERNALS_KEY = "enableSyntheticElementInternals";
 declare const COMPONENT_FEATURE_FLAG_KEY = "componentFeatureFlag";
-export { DECORATOR_TYPES, LWC_PACKAGE_ALIAS, LWC_PACKAGE_EXPORTS, LWC_COMPONENT_PROPERTIES, REGISTER_COMPONENT_ID, REGISTER_DECORATORS_ID, TEMPLATE_KEY, COMPONENT_NAME_KEY, API_VERSION_KEY, COMPONENT_CLASS_ID, SYNTHETIC_ELEMENT_INTERNALS_KEY, COMPONENT_FEATURE_FLAG_KEY, };
+export { DECORATOR_TYPES, LWC_PACKAGE_ALIAS, LWC_PACKAGE_EXPORTS, LWC_COMPONENT_PROPERTIES, REGISTER_COMPONENT_ID, REGISTER_DECORATORS_ID, TEMPLATE_KEY, COMPONENT_NAME_KEY, API_VERSION_KEY, COMPONENT_CLASS_ID, PRIVATE_METHOD_PREFIX, PRIVATE_METHOD_METADATA_KEY, ENABLE_PRIVATE_METHODS_KEY, SYNTHETIC_ELEMENT_INTERNALS_KEY, COMPONENT_FEATURE_FLAG_KEY, };
 //# sourceMappingURL=constants.d.ts.map

package/dist/index.cjs

@@ -41,6 +41,9 @@ const TEMPLATE_KEY = 'tmpl';
 const COMPONENT_NAME_KEY = 'sel';
 const API_VERSION_KEY = 'apiVersion';
 const COMPONENT_CLASS_ID = '__lwc_component_class_internal';
+const PRIVATE_METHOD_PREFIX = '__lwc_component_class_internal_private_';
+const PRIVATE_METHOD_METADATA_KEY = '__lwcTransformedPrivateMethods';
+const ENABLE_PRIVATE_METHODS_KEY = 'enablePrivateMethods';
 const SYNTHETIC_ELEMENT_INTERNALS_KEY = 'enableSyntheticElementInternals';
 const COMPONENT_FEATURE_FLAG_KEY = 'componentFeatureFlag';
 
@@ -123,6 +126,9 @@ function component ({ types: t }) {
         if (state.opts.enableSyntheticElementInternals === true) {
             properties.push(t.objectProperty(t.identifier(SYNTHETIC_ELEMENT_INTERNALS_KEY), t.booleanLiteral(true)));
         }
+        if (state.opts.enablePrivateMethods === true) {
+            properties.push(t.objectProperty(t.identifier(ENABLE_PRIVATE_METHODS_KEY), t.booleanLiteral(true)));
+        }
         const registerComponentExpression = t.callExpression(registerComponentId, [
             node,
             t.objectExpression(properties),
@@ -259,6 +265,30 @@ function incrementMetricCounter(metric, state) {
 function isErrorRecoveryMode(state) {
     return state.file.opts?.parserOpts?.errorRecovery ?? false;
 }
+/**
+ * Copies optional metadata properties between ClassMethod and ClassPrivateMethod nodes.
+ * These properties are not accepted by the t.classMethod() / t.classPrivateMethod() builders,
+ * so they must be transferred manually after node creation. Both the forward and reverse
+ * private-method transforms use this to maintain round-trip parity.
+ */
+function copyMethodMetadata(source, target) {
+    if (source.returnType != null)
+        target.returnType = source.returnType;
+    if (source.typeParameters != null)
+        target.typeParameters = source.typeParameters;
+    if (source.loc != null)
+        target.loc = source.loc;
+    if (source.abstract != null)
+        target.abstract = source.abstract;
+    if (source.access != null)
+        target.access = source.access;
+    if (source.accessibility != null)
+        target.accessibility = source.accessibility;
+    if (source.optional != null)
+        target.optional = source.optional;
+    if (source.override != null)
+        target.override = source.override;
+}
 
 /*
  * Copyright (c) 2023, salesforce.com, inc.
@@ -1244,6 +1274,197 @@ function compilerVersionNumber({ types: t }) {
     };
 }
 
+/*
+ * Copyright (c) 2025, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: MIT
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+ */
+// We only transform kind: 'method'. Other kinds ('get', 'set', 'constructor') are left alone.
+const METHOD_KIND = 'method';
+/**
+ * Standalone Babel plugin that transforms private method identifiers from
+ * `#privateMethod` to `__lwc_component_class_internal_private_privateMethod`.
+ *
+ * This must be registered BEFORE the main LWC class transform plugin so that
+ * private methods are converted to regular methods before decorator and class
+ * property processing.
+ *
+ * Uses Program > path.traverse() rather than a top-level ClassPrivateMethod visitor
+ * because the reverse transform has a ClassMethod visitor in the same Babel pass.
+ * A direct ClassPrivateMethod visitor would replace nodes that the reverse transform
+ * immediately converts back, creating an infinite loop. The manual traverse ensures
+ * all forward replacements complete before the reverse visitor sees any ClassMethod.
+ */
+function privateMethodTransform({ types: t, }) {
+    return {
+        visitor: {
+            Program(path, state) {
+                const transformedNames = new Set();
+                // Phase 1: Collect base names of all private methods (kind: 'method')
+                // so that Phase 2 can transform invocations even for forward references
+                // (call site visited before the method definition).
+                const privateMethodBaseNames = new Set();
+                path.traverse({
+                    ClassPrivateMethod(methodPath) {
+                        const key = methodPath.get('key');
+                        if (key.isPrivateName() && methodPath.node.kind === METHOD_KIND) {
+                            privateMethodBaseNames.add(key.node.id.name);
+                        }
+                    },
+                });
+                // Phase 2: Transform definitions and invocations
+                path.traverse({
+                    ClassPrivateMethod(methodPath, methodState) {
+                        const key = methodPath.get('key');
+                        if (!key.isPrivateName()) {
+                            return;
+                        }
+                        if (methodPath.node.kind !== METHOD_KIND) {
+                            handleError(methodPath, {
+                                errorInfo: errors.DecoratorErrors.UNSUPPORTED_PRIVATE_MEMBER,
+                                messageArgs: ['accessor methods'],
+                            }, methodState);
+                            return;
+                        }
+                        const node = methodPath.node;
+                        // Reject private methods with decorators (e.g. @api, @track, @wire)
+                        if (node.decorators && node.decorators.length > 0) {
+                            handleError(methodPath, {
+                                errorInfo: errors.DecoratorErrors.DECORATOR_ON_PRIVATE_METHOD,
+                            }, methodState);
+                            return;
+                        }
+                        const privateName = key.node.id.name;
+                        const transformedName = `${PRIVATE_METHOD_PREFIX}${privateName}`;
+                        const keyReplacement = t.identifier(transformedName);
+                        // Create a new ClassMethod node to replace the ClassPrivateMethod
+                        // https://babeljs.io/docs/babel-types#classmethod
+                        const classMethod = t.classMethod(METHOD_KIND, keyReplacement, node.params, node.body, node.computed, node.static, node.generator, node.async);
+                        copyMethodMetadata(node, classMethod);
+                        // Replace the entire ClassPrivateMethod node with the new ClassMethod node
+                        // (we can't just replace the key of type PrivateName with type Identifier)
+                        methodPath.replaceWith(classMethod);
+                        transformedNames.add(transformedName);
+                    },
+                    MemberExpression(memberPath) {
+                        const property = memberPath.node.property;
+                        if (t.isPrivateName(property)) {
+                            const baseName = property.id.name;
+                            if (privateMethodBaseNames.has(baseName)) {
+                                const prefixedName = `${PRIVATE_METHOD_PREFIX}${baseName}`;
+                                memberPath
+                                    .get('property')
+                                    .replaceWith(t.identifier(prefixedName));
+                            }
+                        }
+                    },
+                    ClassPrivateProperty(propPath, propState) {
+                        handleError(propPath, {
+                            errorInfo: errors.DecoratorErrors.UNSUPPORTED_PRIVATE_MEMBER,
+                            messageArgs: ['fields'],
+                        }, propState);
+                    },
+                }, state);
+                state.file.metadata[PRIVATE_METHOD_METADATA_KEY] = transformedNames;
+            },
+        },
+    };
+}
+
+/*
+ * Copyright (c) 2025, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: MIT
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+ */
+/**
+ * Standalone Babel plugin that reverses the private method transformation by converting
+ * methods with prefix {@link PRIVATE_METHOD_PREFIX} back to ClassPrivateMethod nodes,
+ * and restoring prefixed MemberExpression properties back to PrivateName nodes.
+ *
+ * This must be registered AFTER @babel/plugin-transform-class-properties so that
+ * class properties are fully transformed before private methods are restored.
+ *
+ * Round-trip parity: to match {@link ./private-method-transform.ts}, this transform must copy the same
+ * properties from ClassMethod onto ClassPrivateMethod when present: returnType, typeParameters, loc,
+ * abstract, access, accessibility, optional, override (plus async, generator, computed from the builder).
+ *
+ * @see {@link ./private-method-transform.ts} for original transformation
+ */
+function reversePrivateMethodTransform({ types: t, }) {
+    // Scoped to this plugin instance's closure. Safe as long as each Babel run creates a
+    // fresh plugin via LwcReversePrivateMethodTransform(); would accumulate across files if
+    // the same instance were ever reused.
+    const reverseTransformedNames = new Set();
+    return {
+        visitor: {
+            ClassMethod(path, state) {
+                const key = path.get('key');
+                // kind: 'method' | 'get' | 'set' - only 'method' is in scope.
+                if (key.isIdentifier() && path.node.kind === 'method') {
+                    const methodName = key.node.name;
+                    if (methodName.startsWith(PRIVATE_METHOD_PREFIX)) {
+                        const forwardTransformedNames = state.file.metadata[PRIVATE_METHOD_METADATA_KEY];
+                        // If the method was not transformed by the forward pass, it is a
+                        // user-defined method that collides with the reserved prefix.
+                        if (!forwardTransformedNames || !forwardTransformedNames.has(methodName)) {
+                            const message = errors.DecoratorErrors.PRIVATE_METHOD_NAME_COLLISION.message.replace('{0}', methodName);
+                            throw path.buildCodeFrameError(message);
+                        }
+                        const originalPrivateName = methodName.replace(PRIVATE_METHOD_PREFIX, '');
+                        const node = path.node;
+                        const classPrivateMethod = t.classPrivateMethod('method', t.privateName(t.identifier(originalPrivateName)), node.params, node.body, node.static);
+                        // Properties the t.classPrivateMethod() builder doesn't accept
+                        classPrivateMethod.async = node.async;
+                        classPrivateMethod.generator = node.generator;
+                        classPrivateMethod.computed = node.computed;
+                        copyMethodMetadata(node, classPrivateMethod);
+                        path.replaceWith(classPrivateMethod);
+                        reverseTransformedNames.add(methodName);
+                    }
+                }
+            },
+            MemberExpression(path, state) {
+                const property = path.node.property;
+                if (!t.isIdentifier(property) || !property.name.startsWith(PRIVATE_METHOD_PREFIX)) {
+                    return;
+                }
+                const forwardTransformedNames = state.file.metadata[PRIVATE_METHOD_METADATA_KEY];
+                if (!forwardTransformedNames || !forwardTransformedNames.has(property.name)) {
+                    return;
+                }
+                const originalName = property.name.replace(PRIVATE_METHOD_PREFIX, '');
+                path.get('property').replaceWith(t.privateName(t.identifier(originalName)));
+            },
+            // After all nodes have been visited, verify that every method the forward transform
+            // renamed was also restored by the reverse transform. A mismatch here means an
+            // intermediate plugin (e.g. @babel/plugin-transform-class-properties) removed or
+            // renamed a prefixed method, leaving a mangled name in the final output.
+            Program: {
+                exit(_path, state) {
+                    const forwardTransformedNames = state.file.metadata[PRIVATE_METHOD_METADATA_KEY];
+                    if (!forwardTransformedNames) {
+                        return;
+                    }
+                    const missingFromReverse = [];
+                    for (const name of forwardTransformedNames) {
+                        if (!reverseTransformedNames.has(name)) {
+                            missingFromReverse.push(name);
+                        }
+                    }
+                    if (missingFromReverse.length > 0) {
+                        throw new Error(`Private method transform count mismatch: ` +
+                            `forward transformed ${forwardTransformedNames.size} method(s), ` +
+                            `but reverse transformed ${reverseTransformedNames.size}. ` +
+                            `Missing reverse transforms for: ${missingFromReverse.join(', ')}`);
+                    }
+                },
+            },
+        },
+    };
+}
+
 /*
  * Copyright (c) 2023, salesforce.com, inc.
  * All rights reserved.
@@ -1292,6 +1513,8 @@ function LwcClassTransform(api) {
     };
 }
 
+exports.LwcPrivateMethodTransform = privateMethodTransform;
+exports.LwcReversePrivateMethodTransform = reversePrivateMethodTransform;
 exports.default = LwcClassTransform;
-/** version: 9.0.3 */
+/** version: 9.0.4-alpha.1 */
 //# sourceMappingURL=index.cjs.map

package/dist/index.d.ts

@@ -1,6 +1,8 @@
 import type { BabelAPI, LwcBabelPluginPass } from './types';
 import type { PluginObj } from '@babel/core';
 export type { LwcBabelPluginOptions } from './types';
+export { default as LwcPrivateMethodTransform } from './private-method-transform';
+export { default as LwcReversePrivateMethodTransform } from './reverse-private-method-transform';
 /**
  * The transform is done in 2 passes:
  * - First, apply in a single AST traversal the decorators and the component transformation.

package/dist/index.js

@@ -37,6 +37,9 @@ const TEMPLATE_KEY = 'tmpl';
 const COMPONENT_NAME_KEY = 'sel';
 const API_VERSION_KEY = 'apiVersion';
 const COMPONENT_CLASS_ID = '__lwc_component_class_internal';
+const PRIVATE_METHOD_PREFIX = '__lwc_component_class_internal_private_';
+const PRIVATE_METHOD_METADATA_KEY = '__lwcTransformedPrivateMethods';
+const ENABLE_PRIVATE_METHODS_KEY = 'enablePrivateMethods';
 const SYNTHETIC_ELEMENT_INTERNALS_KEY = 'enableSyntheticElementInternals';
 const COMPONENT_FEATURE_FLAG_KEY = 'componentFeatureFlag';
 
@@ -119,6 +122,9 @@ function component ({ types: t }) {
         if (state.opts.enableSyntheticElementInternals === true) {
             properties.push(t.objectProperty(t.identifier(SYNTHETIC_ELEMENT_INTERNALS_KEY), t.booleanLiteral(true)));
         }
+        if (state.opts.enablePrivateMethods === true) {
+            properties.push(t.objectProperty(t.identifier(ENABLE_PRIVATE_METHODS_KEY), t.booleanLiteral(true)));
+        }
         const registerComponentExpression = t.callExpression(registerComponentId, [
             node,
             t.objectExpression(properties),
@@ -255,6 +261,30 @@ function incrementMetricCounter(metric, state) {
 function isErrorRecoveryMode(state) {
     return state.file.opts?.parserOpts?.errorRecovery ?? false;
 }
+/**
+ * Copies optional metadata properties between ClassMethod and ClassPrivateMethod nodes.
+ * These properties are not accepted by the t.classMethod() / t.classPrivateMethod() builders,
+ * so they must be transferred manually after node creation. Both the forward and reverse
+ * private-method transforms use this to maintain round-trip parity.
+ */
+function copyMethodMetadata(source, target) {
+    if (source.returnType != null)
+        target.returnType = source.returnType;
+    if (source.typeParameters != null)
+        target.typeParameters = source.typeParameters;
+    if (source.loc != null)
+        target.loc = source.loc;
+    if (source.abstract != null)
+        target.abstract = source.abstract;
+    if (source.access != null)
+        target.access = source.access;
+    if (source.accessibility != null)
+        target.accessibility = source.accessibility;
+    if (source.optional != null)
+        target.optional = source.optional;
+    if (source.override != null)
+        target.override = source.override;
+}
 
 /*
  * Copyright (c) 2023, salesforce.com, inc.
@@ -1240,6 +1270,197 @@ function compilerVersionNumber({ types: t }) {
     };
 }
 
+/*
+ * Copyright (c) 2025, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: MIT
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+ */
+// We only transform kind: 'method'. Other kinds ('get', 'set', 'constructor') are left alone.
+const METHOD_KIND = 'method';
+/**
+ * Standalone Babel plugin that transforms private method identifiers from
+ * `#privateMethod` to `__lwc_component_class_internal_private_privateMethod`.
+ *
+ * This must be registered BEFORE the main LWC class transform plugin so that
+ * private methods are converted to regular methods before decorator and class
+ * property processing.
+ *
+ * Uses Program > path.traverse() rather than a top-level ClassPrivateMethod visitor
+ * because the reverse transform has a ClassMethod visitor in the same Babel pass.
+ * A direct ClassPrivateMethod visitor would replace nodes that the reverse transform
+ * immediately converts back, creating an infinite loop. The manual traverse ensures
+ * all forward replacements complete before the reverse visitor sees any ClassMethod.
+ */
+function privateMethodTransform({ types: t, }) {
+    return {
+        visitor: {
+            Program(path, state) {
+                const transformedNames = new Set();
+                // Phase 1: Collect base names of all private methods (kind: 'method')
+                // so that Phase 2 can transform invocations even for forward references
+                // (call site visited before the method definition).
+                const privateMethodBaseNames = new Set();
+                path.traverse({
+                    ClassPrivateMethod(methodPath) {
+                        const key = methodPath.get('key');
+                        if (key.isPrivateName() && methodPath.node.kind === METHOD_KIND) {
+                            privateMethodBaseNames.add(key.node.id.name);
+                        }
+                    },
+                });
+                // Phase 2: Transform definitions and invocations
+                path.traverse({
+                    ClassPrivateMethod(methodPath, methodState) {
+                        const key = methodPath.get('key');
+                        if (!key.isPrivateName()) {
+                            return;
+                        }
+                        if (methodPath.node.kind !== METHOD_KIND) {
+                            handleError(methodPath, {
+                                errorInfo: DecoratorErrors.UNSUPPORTED_PRIVATE_MEMBER,
+                                messageArgs: ['accessor methods'],
+                            }, methodState);
+                            return;
+                        }
+                        const node = methodPath.node;
+                        // Reject private methods with decorators (e.g. @api, @track, @wire)
+                        if (node.decorators && node.decorators.length > 0) {
+                            handleError(methodPath, {
+                                errorInfo: DecoratorErrors.DECORATOR_ON_PRIVATE_METHOD,
+                            }, methodState);
+                            return;
+                        }
+                        const privateName = key.node.id.name;
+                        const transformedName = `${PRIVATE_METHOD_PREFIX}${privateName}`;
+                        const keyReplacement = t.identifier(transformedName);
+                        // Create a new ClassMethod node to replace the ClassPrivateMethod
+                        // https://babeljs.io/docs/babel-types#classmethod
+                        const classMethod = t.classMethod(METHOD_KIND, keyReplacement, node.params, node.body, node.computed, node.static, node.generator, node.async);
+                        copyMethodMetadata(node, classMethod);
+                        // Replace the entire ClassPrivateMethod node with the new ClassMethod node
+                        // (we can't just replace the key of type PrivateName with type Identifier)
+                        methodPath.replaceWith(classMethod);
+                        transformedNames.add(transformedName);
+                    },
+                    MemberExpression(memberPath) {
+                        const property = memberPath.node.property;
+                        if (t.isPrivateName(property)) {
+                            const baseName = property.id.name;
+                            if (privateMethodBaseNames.has(baseName)) {
+                                const prefixedName = `${PRIVATE_METHOD_PREFIX}${baseName}`;
+                                memberPath
+                                    .get('property')
+                                    .replaceWith(t.identifier(prefixedName));
+                            }
+                        }
+                    },
+                    ClassPrivateProperty(propPath, propState) {
+                        handleError(propPath, {
+                            errorInfo: DecoratorErrors.UNSUPPORTED_PRIVATE_MEMBER,
+                            messageArgs: ['fields'],
+                        }, propState);
+                    },
+                }, state);
+                state.file.metadata[PRIVATE_METHOD_METADATA_KEY] = transformedNames;
+            },
+        },
+    };
+}
+
+/*
+ * Copyright (c) 2025, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: MIT
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+ */
+/**
+ * Standalone Babel plugin that reverses the private method transformation by converting
+ * methods with prefix {@link PRIVATE_METHOD_PREFIX} back to ClassPrivateMethod nodes,
+ * and restoring prefixed MemberExpression properties back to PrivateName nodes.
+ *
+ * This must be registered AFTER @babel/plugin-transform-class-properties so that
+ * class properties are fully transformed before private methods are restored.
+ *
+ * Round-trip parity: to match {@link ./private-method-transform.ts}, this transform must copy the same
+ * properties from ClassMethod onto ClassPrivateMethod when present: returnType, typeParameters, loc,
+ * abstract, access, accessibility, optional, override (plus async, generator, computed from the builder).
+ *
+ * @see {@link ./private-method-transform.ts} for original transformation
+ */
+function reversePrivateMethodTransform({ types: t, }) {
+    // Scoped to this plugin instance's closure. Safe as long as each Babel run creates a
+    // fresh plugin via LwcReversePrivateMethodTransform(); would accumulate across files if
+    // the same instance were ever reused.
+    const reverseTransformedNames = new Set();
+    return {
+        visitor: {
+            ClassMethod(path, state) {
+                const key = path.get('key');
+                // kind: 'method' | 'get' | 'set' - only 'method' is in scope.
+                if (key.isIdentifier() && path.node.kind === 'method') {
+                    const methodName = key.node.name;
+                    if (methodName.startsWith(PRIVATE_METHOD_PREFIX)) {
+                        const forwardTransformedNames = state.file.metadata[PRIVATE_METHOD_METADATA_KEY];
+                        // If the method was not transformed by the forward pass, it is a
+                        // user-defined method that collides with the reserved prefix.
+                        if (!forwardTransformedNames || !forwardTransformedNames.has(methodName)) {
+                            const message = DecoratorErrors.PRIVATE_METHOD_NAME_COLLISION.message.replace('{0}', methodName);
+                            throw path.buildCodeFrameError(message);
+                        }
+                        const originalPrivateName = methodName.replace(PRIVATE_METHOD_PREFIX, '');
+                        const node = path.node;
+                        const classPrivateMethod = t.classPrivateMethod('method', t.privateName(t.identifier(originalPrivateName)), node.params, node.body, node.static);
+                        // Properties the t.classPrivateMethod() builder doesn't accept
+                        classPrivateMethod.async = node.async;
+                        classPrivateMethod.generator = node.generator;
+                        classPrivateMethod.computed = node.computed;
+                        copyMethodMetadata(node, classPrivateMethod);
+                        path.replaceWith(classPrivateMethod);
+                        reverseTransformedNames.add(methodName);
+                    }
+                }
+            },
+            MemberExpression(path, state) {
+                const property = path.node.property;
+                if (!t.isIdentifier(property) || !property.name.startsWith(PRIVATE_METHOD_PREFIX)) {
+                    return;
+                }
+                const forwardTransformedNames = state.file.metadata[PRIVATE_METHOD_METADATA_KEY];
+                if (!forwardTransformedNames || !forwardTransformedNames.has(property.name)) {
+                    return;
+                }
+                const originalName = property.name.replace(PRIVATE_METHOD_PREFIX, '');
+                path.get('property').replaceWith(t.privateName(t.identifier(originalName)));
+            },
+            // After all nodes have been visited, verify that every method the forward transform
+            // renamed was also restored by the reverse transform. A mismatch here means an
+            // intermediate plugin (e.g. @babel/plugin-transform-class-properties) removed or
+            // renamed a prefixed method, leaving a mangled name in the final output.
+            Program: {
+                exit(_path, state) {
+                    const forwardTransformedNames = state.file.metadata[PRIVATE_METHOD_METADATA_KEY];
+                    if (!forwardTransformedNames) {
+                        return;
+                    }
+                    const missingFromReverse = [];
+                    for (const name of forwardTransformedNames) {
+                        if (!reverseTransformedNames.has(name)) {
+                            missingFromReverse.push(name);
+                        }
+                    }
+                    if (missingFromReverse.length > 0) {
+                        throw new Error(`Private method transform count mismatch: ` +
+                            `forward transformed ${forwardTransformedNames.size} method(s), ` +
+                            `but reverse transformed ${reverseTransformedNames.size}. ` +
+                            `Missing reverse transforms for: ${missingFromReverse.join(', ')}`);
+                    }
+                },
+            },
+        },
+    };
+}
+
 /*
  * Copyright (c) 2023, salesforce.com, inc.
  * All rights reserved.
@@ -1288,6 +1509,6 @@ function LwcClassTransform(api) {
     };
 }
 
-export { LwcClassTransform as default };
-/** version: 9.0.3 */
+export { privateMethodTransform as LwcPrivateMethodTransform, reversePrivateMethodTransform as LwcReversePrivateMethodTransform, LwcClassTransform as default };
+/** version: 9.0.4-alpha.1 */
 //# sourceMappingURL=index.js.map

package/dist/private-method-transform.d.ts

@@ -0,0 +1,18 @@
+import type { BabelAPI, LwcBabelPluginPass } from './types';
+import type { PluginObj } from '@babel/core';
+/**
+ * Standalone Babel plugin that transforms private method identifiers from
+ * `#privateMethod` to `__lwc_component_class_internal_private_privateMethod`.
+ *
+ * This must be registered BEFORE the main LWC class transform plugin so that
+ * private methods are converted to regular methods before decorator and class
+ * property processing.
+ *
+ * Uses Program > path.traverse() rather than a top-level ClassPrivateMethod visitor
+ * because the reverse transform has a ClassMethod visitor in the same Babel pass.
+ * A direct ClassPrivateMethod visitor would replace nodes that the reverse transform
+ * immediately converts back, creating an infinite loop. The manual traverse ensures
+ * all forward replacements complete before the reverse visitor sees any ClassMethod.
+ */
+export default function privateMethodTransform({ types: t, }: BabelAPI): PluginObj<LwcBabelPluginPass>;
+//# sourceMappingURL=private-method-transform.d.ts.map

package/dist/reverse-private-method-transform.d.ts

@@ -0,0 +1,18 @@
+import type { BabelAPI, LwcBabelPluginPass } from './types';
+import type { PluginObj } from '@babel/core';
+/**
+ * Standalone Babel plugin that reverses the private method transformation by converting
+ * methods with prefix {@link PRIVATE_METHOD_PREFIX} back to ClassPrivateMethod nodes,
+ * and restoring prefixed MemberExpression properties back to PrivateName nodes.
+ *
+ * This must be registered AFTER @babel/plugin-transform-class-properties so that
+ * class properties are fully transformed before private methods are restored.
+ *
+ * Round-trip parity: to match {@link ./private-method-transform.ts}, this transform must copy the same
+ * properties from ClassMethod onto ClassPrivateMethod when present: returnType, typeParameters, loc,
+ * abstract, access, accessibility, optional, override (plus async, generator, computed from the builder).
+ *
+ * @see {@link ./private-method-transform.ts} for original transformation
+ */
+export default function reversePrivateMethodTransform({ types: t, }: BabelAPI): PluginObj<LwcBabelPluginPass>;
+//# sourceMappingURL=reverse-private-method-transform.d.ts.map

package/dist/types.d.ts

@@ -14,6 +14,7 @@ export interface LwcBabelPluginOptions {
     instrumentation?: InstrumentationObject;
     apiVersion?: number;
     enableSyntheticElementInternals?: boolean;
+    enablePrivateMethods?: boolean;
     componentFeatureFlagModulePath?: string;
 }
 export interface LwcBabelPluginPass extends PluginPass {

package/dist/utils.d.ts

@@ -21,5 +21,12 @@ declare function getEngineImportSpecifiers(path: NodePath): ImportSpecifier[];
 declare function handleError(source: NodePath<types.Node>, decoratorErrorOpts: DecoratorErrorOptions, state: LwcBabelPluginPass): void;
 declare function incrementMetricCounter(metric: CompilerMetrics, state: LwcBabelPluginPass): void;
 declare function isErrorRecoveryMode(state: LwcBabelPluginPass): boolean;
-export { isClassMethod, isGetterClassMethod, isSetterClassMethod, getEngineImportSpecifiers, handleError, incrementMetricCounter, isErrorRecoveryMode, };
+/**
+ * Copies optional metadata properties between ClassMethod and ClassPrivateMethod nodes.
+ * These properties are not accepted by the t.classMethod() / t.classPrivateMethod() builders,
+ * so they must be transferred manually after node creation. Both the forward and reverse
+ * private-method transforms use this to maintain round-trip parity.
+ */
+declare function copyMethodMetadata(source: types.ClassMethod | types.ClassPrivateMethod, target: types.ClassMethod | types.ClassPrivateMethod): void;
+export { isClassMethod, isGetterClassMethod, isSetterClassMethod, getEngineImportSpecifiers, handleError, incrementMetricCounter, isErrorRecoveryMode, copyMethodMetadata, };
 //# sourceMappingURL=utils.d.ts.map

package/package.json

@@ -4,7 +4,7 @@
         "You can safely modify dependencies, devDependencies, keywords, etc., but other props will be overwritten."
     ],
     "name": "@lwc/babel-plugin-component",
-    "version": "9.0.3",
+    "version": "9.0.4-alpha.1",
     "description": "Babel plugin to transform a LWC module",
     "keywords": [
         "lwc"
@@ -52,8 +52,8 @@
     },
     "dependencies": {
         "@babel/helper-module-imports": "7.28.6",
-        "@lwc/errors": "9.0.3",
-        "@lwc/shared": "9.0.3",
+        "@lwc/errors": "9.0.4-alpha.1",
+        "@lwc/shared": "9.0.4-alpha.1",
         "line-column": "~1.0.2"
     },
     "devDependencies": {