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

package/dist/index.cjs

@@ -1290,84 +1290,76 @@ const METHOD_KIND = 'method';
  * 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.
+ * Uses the `pre` lifecycle hook to run all transformations in a single pass
+ * before the visitor phase, guaranteeing the traversal executes exactly once.
  */
 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, {
+        visitor: {},
+        pre() {
+            const state = this;
+            const programPath = state.file.path;
+            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();
+            programPath.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
+            programPath.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: ['fields'],
-                        }, propState);
-                    },
-                }, state);
-                state.file.metadata[PRIVATE_METHOD_METADATA_KEY] = transformedNames;
-            },
+                            messageArgs: ['accessor methods'],
+                        }, methodState);
+                        return;
+                    }
+                    const node = methodPath.node;
+                    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);
+                    const classMethod = t.classMethod(METHOD_KIND, keyReplacement, node.params, node.body, node.computed, node.static, node.generator, node.async);
+                    copyMethodMetadata(node, classMethod);
+                    methodPath.replaceWith(classMethod);
+                    transformedNames.add(transformedName);
+                },
+                PrivateName(privatePath) {
+                    const baseName = privatePath.node.id.name;
+                    if (!privateMethodBaseNames.has(baseName)) {
+                        return;
+                    }
+                    const parentPath = privatePath.parentPath;
+                    if (parentPath.isMemberExpression()) {
+                        const prefixedName = `${PRIVATE_METHOD_PREFIX}${baseName}`;
+                        privatePath.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;
         },
     };
 }
@@ -1516,5 +1508,5 @@ function LwcClassTransform(api) {
 exports.LwcPrivateMethodTransform = privateMethodTransform;
 exports.LwcReversePrivateMethodTransform = reversePrivateMethodTransform;
 exports.default = LwcClassTransform;
-/** version: 9.0.4-alpha.1 */
+/** version: 9.1.0 */
 //# sourceMappingURL=index.cjs.map

package/dist/index.js

@@ -1286,84 +1286,76 @@ const METHOD_KIND = 'method';
  * 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.
+ * Uses the `pre` lifecycle hook to run all transformations in a single pass
+ * before the visitor phase, guaranteeing the traversal executes exactly once.
  */
 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, {
+        visitor: {},
+        pre() {
+            const state = this;
+            const programPath = state.file.path;
+            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();
+            programPath.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
+            programPath.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: ['fields'],
-                        }, propState);
-                    },
-                }, state);
-                state.file.metadata[PRIVATE_METHOD_METADATA_KEY] = transformedNames;
-            },
+                            messageArgs: ['accessor methods'],
+                        }, methodState);
+                        return;
+                    }
+                    const node = methodPath.node;
+                    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);
+                    const classMethod = t.classMethod(METHOD_KIND, keyReplacement, node.params, node.body, node.computed, node.static, node.generator, node.async);
+                    copyMethodMetadata(node, classMethod);
+                    methodPath.replaceWith(classMethod);
+                    transformedNames.add(transformedName);
+                },
+                PrivateName(privatePath) {
+                    const baseName = privatePath.node.id.name;
+                    if (!privateMethodBaseNames.has(baseName)) {
+                        return;
+                    }
+                    const parentPath = privatePath.parentPath;
+                    if (parentPath.isMemberExpression()) {
+                        const prefixedName = `${PRIVATE_METHOD_PREFIX}${baseName}`;
+                        privatePath.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;
         },
     };
 }
@@ -1510,5 +1502,5 @@ function LwcClassTransform(api) {
 }
 
 export { privateMethodTransform as LwcPrivateMethodTransform, reversePrivateMethodTransform as LwcReversePrivateMethodTransform, LwcClassTransform as default };
-/** version: 9.0.4-alpha.1 */
+/** version: 9.1.0 */
 //# sourceMappingURL=index.js.map

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

@@ -8,11 +8,8 @@ import type { PluginObj } from '@babel/core';
  * 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.
+ * Uses the `pre` lifecycle hook to run all transformations in a single pass
+ * before the visitor phase, guaranteeing the traversal executes exactly once.
  */
 export default function privateMethodTransform({ types: t, }: BabelAPI): PluginObj<LwcBabelPluginPass>;
 //# sourceMappingURL=private-method-transform.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.4-alpha.1",
+    "version": "9.1.0",
     "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.4-alpha.1",
-        "@lwc/shared": "9.0.4-alpha.1",
+        "@lwc/errors": "9.1.0",
+        "@lwc/shared": "9.1.0",
         "line-column": "~1.0.2"
     },
     "devDependencies": {