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

package/README.md

@@ -21,8 +21,8 @@ This babel plugin does the following transform:
 ## Usage
 
 ```js
-import babel from '@babel/core';
-import lwcPlugin from '@lwc/babel-plugin-component';
+const babel = require('@babel/core');
+const lwcPlugin = require('@lwc/babel-plugin-component');
 
 const source = `
 import { LightningElement } from 'lwc';

package/dist/dedupe-imports.d.ts

@@ -0,0 +1,4 @@
+import type { types, NodePath } from '@babel/core';
+import type { BabelAPI } from './types';
+export default function ({ types: t }: BabelAPI): (path: NodePath<types.Program>) => void;
+//# sourceMappingURL=dedupe-imports.d.ts.map

package/dist/{index.cjs → index.cjs.js}

@@ -5,7 +5,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var node_path = require('node:path');
+var path = require('path');
 var helperModuleImports = require('@babel/helper-module-imports');
 var shared = require('@lwc/shared');
 var errors = require('@lwc/errors');
@@ -54,8 +54,8 @@ const COMPONENT_FEATURE_FLAG_KEY = 'componentFeatureFlag';
  * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
  */
 function getBaseName(classPath) {
-    const ext = node_path.extname(classPath);
-    return node_path.basename(classPath, ext);
+    const ext = path.extname(classPath);
+    return path.basename(classPath, ext);
 }
 function importDefaultTemplate(path, state) {
     const { filename } = state.file.opts;
@@ -1167,6 +1167,57 @@ function decorators({ types: t }) {
     };
 }
 
+/*
+ * Copyright (c) 2023, 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
+ */
+function defaultImport(t, specifiers) {
+    const defaultImport = specifiers.find((s) => t.isImportDefaultSpecifier(s));
+    return defaultImport && defaultImport.local.name;
+}
+function dedupeImports ({ types: t }) {
+    return function (path) {
+        const body = path.get('body');
+        const importStatements = body.filter((s) => s.isImportDeclaration());
+        const visited = new Map();
+        importStatements.forEach((importPath) => {
+            const sourceLiteral = importPath.node.source;
+            // If the import is of the type import * as X, just ignore it since we can't dedupe
+            if (importPath.node.specifiers.some((_) => t.isImportNamespaceSpecifier(_))) {
+                return;
+            }
+            // If we have seen the same source, we will try to dedupe it
+            if (visited.has(sourceLiteral.value)) {
+                const visitedImport = visited.get(sourceLiteral.value);
+                const visitedSpecifiers = visitedImport.node.specifiers;
+                const visitedDefaultImport = defaultImport(t, visitedSpecifiers);
+                // We merge all the named imports unless is a default with the same name
+                let canImportBeRemoved = true;
+                importPath.node.specifiers.forEach((s) => {
+                    if (visitedDefaultImport && t.isImportDefaultSpecifier(s)) {
+                        if (visitedDefaultImport !== s.local.name) {
+                            canImportBeRemoved = false;
+                        }
+                    }
+                    else {
+                        visitedSpecifiers.push(s);
+                    }
+                });
+                if (canImportBeRemoved) {
+                    importPath.remove();
+                }
+                // We need to sort the imports due to a bug in babel where default must be first
+                visitedSpecifiers.sort((a) => (t.isImportDefaultSpecifier(a) ? -1 : 1));
+            }
+            else {
+                visited.set(sourceLiteral.value, importPath);
+            }
+        });
+    };
+}
+
 /*
  * Copyright (c) 2023, salesforce.com, inc.
  * All rights reserved.
@@ -1290,84 +1341,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;
         },
     };
 }
@@ -1503,6 +1546,8 @@ function LwcClassTransform(api) {
                 exit(path) {
                     const engineImportSpecifiers = getEngineImportSpecifiers(path);
                     removeImportedDecoratorSpecifiers(engineImportSpecifiers);
+                    // Will eventually be removed to eliminate unnecessary complexity. Rollup already does this for us.
+                    dedupeImports(api)(path);
                 },
             },
             Import: transformDynamicImports,
@@ -1516,5 +1561,5 @@ function LwcClassTransform(api) {
 exports.LwcPrivateMethodTransform = privateMethodTransform;
 exports.LwcReversePrivateMethodTransform = reversePrivateMethodTransform;
 exports.default = LwcClassTransform;
-/** version: 9.0.4-alpha.1 */
-//# sourceMappingURL=index.cjs.map
+/** version: 9.0.4-alpha.2 */
+//# sourceMappingURL=index.cjs.js.map

package/dist/index.js

@@ -1,7 +1,7 @@
 /**
  * Copyright (c) 2026 Salesforce, Inc.
  */
-import { extname, basename } from 'node:path';
+import { extname, basename } from 'path';
 import { addNamed, addDefault } from '@babel/helper-module-imports';
 import { getAPIVersionFromNumber, generateCustomElementTagName, DISALLOWED_PROP_SET, AMBIGUOUS_PROP_SET, isAPIFeatureEnabled, LWC_VERSION_COMMENT } from '@lwc/shared';
 import { generateCompilerDiagnostic, DiagnosticLevel, generateErrorMessage, DecoratorErrors, CompilerMetrics, LWCClassErrors } from '@lwc/errors';
@@ -1163,6 +1163,57 @@ function decorators({ types: t }) {
     };
 }
 
+/*
+ * Copyright (c) 2023, 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
+ */
+function defaultImport(t, specifiers) {
+    const defaultImport = specifiers.find((s) => t.isImportDefaultSpecifier(s));
+    return defaultImport && defaultImport.local.name;
+}
+function dedupeImports ({ types: t }) {
+    return function (path) {
+        const body = path.get('body');
+        const importStatements = body.filter((s) => s.isImportDeclaration());
+        const visited = new Map();
+        importStatements.forEach((importPath) => {
+            const sourceLiteral = importPath.node.source;
+            // If the import is of the type import * as X, just ignore it since we can't dedupe
+            if (importPath.node.specifiers.some((_) => t.isImportNamespaceSpecifier(_))) {
+                return;
+            }
+            // If we have seen the same source, we will try to dedupe it
+            if (visited.has(sourceLiteral.value)) {
+                const visitedImport = visited.get(sourceLiteral.value);
+                const visitedSpecifiers = visitedImport.node.specifiers;
+                const visitedDefaultImport = defaultImport(t, visitedSpecifiers);
+                // We merge all the named imports unless is a default with the same name
+                let canImportBeRemoved = true;
+                importPath.node.specifiers.forEach((s) => {
+                    if (visitedDefaultImport && t.isImportDefaultSpecifier(s)) {
+                        if (visitedDefaultImport !== s.local.name) {
+                            canImportBeRemoved = false;
+                        }
+                    }
+                    else {
+                        visitedSpecifiers.push(s);
+                    }
+                });
+                if (canImportBeRemoved) {
+                    importPath.remove();
+                }
+                // We need to sort the imports due to a bug in babel where default must be first
+                visitedSpecifiers.sort((a) => (t.isImportDefaultSpecifier(a) ? -1 : 1));
+            }
+            else {
+                visited.set(sourceLiteral.value, importPath);
+            }
+        });
+    };
+}
+
 /*
  * Copyright (c) 2023, salesforce.com, inc.
  * All rights reserved.
@@ -1286,84 +1337,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;
         },
     };
 }
@@ -1499,6 +1542,8 @@ function LwcClassTransform(api) {
                 exit(path) {
                     const engineImportSpecifiers = getEngineImportSpecifiers(path);
                     removeImportedDecoratorSpecifiers(engineImportSpecifiers);
+                    // Will eventually be removed to eliminate unnecessary complexity. Rollup already does this for us.
+                    dedupeImports(api)(path);
                 },
             },
             Import: transformDynamicImports,
@@ -1510,5 +1555,5 @@ function LwcClassTransform(api) {
 }
 
 export { privateMethodTransform as LwcPrivateMethodTransform, reversePrivateMethodTransform as LwcReversePrivateMethodTransform, LwcClassTransform as default };
-/** version: 9.0.4-alpha.1 */
+/** version: 9.0.4-alpha.2 */
 //# 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.0.4-alpha.2",
     "description": "Babel plugin to transform a LWC module",
     "keywords": [
         "lwc"
@@ -19,22 +19,17 @@
         "url": "https://github.com/salesforce/lwc/issues"
     },
     "license": "MIT",
-    "type": "module",
     "publishConfig": {
         "access": "public"
     },
-    "engines": {
-        "node": ">=16.6.0"
-    },
     "volta": {
         "extends": "../../../package.json"
     },
-    "main": "dist/index.js",
+    "main": "dist/index.cjs.js",
     "module": "dist/index.js",
     "types": "dist/index.d.ts",
     "files": [
         "dist/**/*.js",
-        "dist/**/*.cjs",
         "dist/**/*.d.ts"
     ],
     "scripts": {
@@ -52,8 +47,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.0.4-alpha.2",
+        "@lwc/shared": "9.0.4-alpha.2",
         "line-column": "~1.0.2"
     },
     "devDependencies": {