@lwc/babel-plugin-component 8.23.0 → 8.25.0

package/dist/constants.d.ts

@@ -24,5 +24,6 @@ declare const COMPONENT_NAME_KEY = "sel";
 declare const API_VERSION_KEY = "apiVersion";
 declare const COMPONENT_CLASS_ID = "__lwc_component_class_internal";
 declare const SYNTHETIC_ELEMENT_INTERNALS_KEY = "enableSyntheticElementInternals";
-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, };
+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, };
 //# sourceMappingURL=constants.d.ts.map

package/dist/decorators/api/transform.d.ts

@@ -1,6 +1,6 @@
 import type { types, NodePath } from '@babel/core';
 import type { DecoratorMeta } from '../index';
-import type { BabelTypes } from '../../types';
+import type { BabelTypes, LwcBabelPluginPass } from '../../types';
 import type { ClassBodyItem } from '../types';
-export default function transform(t: BabelTypes, decoratorMetas: DecoratorMeta[], classBodyItems: NodePath<ClassBodyItem>[]): types.ObjectProperty[];
+export default function transform(t: BabelTypes, decoratorMetas: DecoratorMeta[], classBodyItems: NodePath<ClassBodyItem>[], state: LwcBabelPluginPass): types.ObjectProperty[];
 //# sourceMappingURL=transform.d.ts.map

package/dist/decorators/index.d.ts

@@ -7,7 +7,7 @@ export interface DecoratorMeta {
     name: LwcDecoratorName;
     propertyName: string;
     path: NodePath<types.Decorator>;
-    decoratedNodeType: DecoratorType;
+    decoratedNodeType: DecoratorType | null;
     type?: DecoratorType;
 }
 declare function validateImportedLwcDecoratorUsage(engineImportSpecifiers: ImportSpecifier[], state: LwcBabelPluginPass): void;

package/dist/decorators/wire/transform.d.ts

@@ -1,5 +1,5 @@
 import type { types } from '@babel/core';
 import type { DecoratorMeta } from '../index';
-import type { BabelTypes } from '../../types';
-export default function transform(t: BabelTypes, decoratorMetas: DecoratorMeta[]): types.ObjectProperty[];
+import type { BabelTypes, LwcBabelPluginPass } from '../../types';
+export default function transform(t: BabelTypes, decoratorMetas: DecoratorMeta[], state: LwcBabelPluginPass): types.ObjectProperty[];
 //# sourceMappingURL=transform.d.ts.map

package/dist/index.cjs.js

@@ -42,6 +42,7 @@ const COMPONENT_NAME_KEY = 'sel';
 const API_VERSION_KEY = 'apiVersion';
 const COMPONENT_CLASS_ID = '__lwc_component_class_internal';
 const SYNTHETIC_ELEMENT_INTERNALS_KEY = 'enableSyntheticElementInternals';
+const COMPONENT_FEATURE_FLAG_KEY = 'componentFeatureFlag';
 
 /*
  * Copyright (c) 2023, salesforce.com, inc.
@@ -75,6 +76,13 @@ function component ({ types: t }) {
     function createRegisterComponent(declarationPath, state) {
         const registerComponentId = helperModuleImports.addNamed(declarationPath, REGISTER_COMPONENT_ID, LWC_PACKAGE_ALIAS);
         const templateIdentifier = importDefaultTemplate(declarationPath, state);
+        // Optionally import feature flag module if provided via compiler options
+        let componentFeatureFlagIdentifier;
+        if (state.opts.componentFeatureFlagModulePath) {
+            componentFeatureFlagIdentifier = helperModuleImports.addDefault(declarationPath, state.opts.componentFeatureFlagModulePath, {
+                nameHint: COMPONENT_FEATURE_FLAG_KEY,
+            });
+        }
         const statementPath = declarationPath.getStatementParent();
         const componentRegisteredName = getComponentRegisteredName(t, state);
         let node = declarationPath.node;
@@ -103,6 +111,14 @@ function component ({ types: t }) {
             // The client needs to trust the server that it's providing an actual known API version
             t.objectProperty(t.identifier(API_VERSION_KEY), t.numericLiteral(apiVersion)),
         ];
+        if (componentFeatureFlagIdentifier) {
+            properties.push(t.objectProperty(t.identifier(COMPONENT_FEATURE_FLAG_KEY), t.objectExpression([
+                t.objectProperty(t.identifier('value'), t.callExpression(t.identifier('Boolean'), [
+                    componentFeatureFlagIdentifier,
+                ])),
+                t.objectProperty(t.identifier('path'), t.stringLiteral(state.opts.componentFeatureFlagModulePath)),
+            ])));
+        }
         // Only include enableSyntheticElementInternals if set to true
         if (state.opts.enableSyntheticElementInternals === true) {
             properties.push(t.objectProperty(t.identifier(SYNTHETIC_ELEMENT_INTERNALS_KEY), t.booleanLiteral(true)));
@@ -213,9 +229,36 @@ function generateError(source, { errorInfo, messageArgs }, state) {
     error.lwcCode = errorInfo && errorInfo.code;
     return error;
 }
+function collectError(source, { errorInfo, messageArgs }, state) {
+    const diagnostic = errors.generateCompilerDiagnostic(errorInfo, {
+        messageArgs,
+        origin: {
+            filename: state.filename,
+            location: normalizeLocation(source) ?? undefined,
+        },
+    }, true);
+    if (diagnostic.level === errors.DiagnosticLevel.Fatal) {
+        throw generateError(source, { errorInfo, messageArgs }, state);
+    }
+    if (!state.file.metadata.lwcErrors) {
+        state.file.metadata.lwcErrors = [];
+    }
+    state.file.metadata.lwcErrors.push(diagnostic);
+}
+function handleError(source, decoratorErrorOpts, state) {
+    if (isErrorRecoveryMode(state)) {
+        collectError(source, decoratorErrorOpts, state);
+    }
+    else {
+        throw generateError(source, decoratorErrorOpts, state);
+    }
+}
 function incrementMetricCounter(metric, state) {
     state.opts.instrumentation?.incrementCounter(metric);
 }
+function isErrorRecoveryMode(state) {
+    return state.file.opts?.parserOpts?.errorRecovery ?? false;
+}
 
 /*
  * Copyright (c) 2023, salesforce.com, inc.
@@ -239,7 +282,7 @@ function validateConflict(path, decorators, state) {
     const isPublicFieldTracked = decorators.some((decorator) => decorator.name === TRACK_DECORATOR$2 &&
         decorator.path.parentPath.node === path.parentPath.node);
     if (isPublicFieldTracked) {
-        throw generateError(path, {
+        handleError(path, {
             errorInfo: errors.DecoratorErrors.API_AND_TRACK_DECORATOR_CONFLICT,
         }, state);
     }
@@ -250,45 +293,45 @@ function isBooleanPropDefaultTrue(property) {
 }
 function validatePropertyValue(property, state) {
     if (isBooleanPropDefaultTrue(property)) {
-        throw generateError(property, {
+        handleError(property, {
             errorInfo: errors.DecoratorErrors.INVALID_BOOLEAN_PUBLIC_PROPERTY,
         }, state);
     }
 }
 function validatePropertyName(property, state) {
     if (property.node.computed) {
-        throw generateError(property, {
+        handleError(property, {
             errorInfo: errors.DecoratorErrors.PROPERTY_CANNOT_BE_COMPUTED,
         }, state);
     }
     const propertyName = property.get('key.name').node;
     if (propertyName === 'part') {
-        throw generateError(property, {
+        handleError(property, {
             errorInfo: errors.DecoratorErrors.PROPERTY_NAME_PART_IS_RESERVED,
             messageArgs: [propertyName],
         }, state);
     }
     else if (propertyName.startsWith('on')) {
-        throw generateError(property, {
+        handleError(property, {
             errorInfo: errors.DecoratorErrors.PROPERTY_NAME_CANNOT_START_WITH_ON,
             messageArgs: [propertyName],
         }, state);
     }
     else if (propertyName.startsWith('data') && propertyName.length > 4) {
-        throw generateError(property, {
+        handleError(property, {
             errorInfo: errors.DecoratorErrors.PROPERTY_NAME_CANNOT_START_WITH_DATA,
             messageArgs: [propertyName],
         }, state);
     }
     else if (shared.DISALLOWED_PROP_SET.has(propertyName)) {
-        throw generateError(property, {
+        handleError(property, {
             errorInfo: errors.DecoratorErrors.PROPERTY_NAME_IS_RESERVED,
             messageArgs: [propertyName],
         }, state);
     }
     else if (shared.AMBIGUOUS_PROP_SET.has(propertyName)) {
         const camelCased = shared.AMBIGUOUS_PROP_SET.get(propertyName);
-        throw generateError(property, {
+        handleError(property, {
             errorInfo: errors.DecoratorErrors.PROPERTY_NAME_IS_AMBIGUOUS,
             messageArgs: [propertyName, camelCased],
         }, state);
@@ -306,7 +349,7 @@ function validateSingleApiDecoratorOnSetterGetterPair(decorators, state) {
             const methodPath = path.parentPath;
             const methodName = methodPath.get('key.name').node;
             if (visitedMethods.has(methodName)) {
-                throw generateError(methodPath, {
+                handleError(methodPath, {
                     errorInfo: errors.DecoratorErrors.SINGLE_DECORATOR_ON_SETTER_GETTER_PAIR,
                     messageArgs: [methodName],
                 }, state);
@@ -332,7 +375,7 @@ function validateUniqueness(decorators, state) {
                 compareType === DECORATOR_TYPES.SETTER) ||
                 (currentType === DECORATOR_TYPES.SETTER && compareType === DECORATOR_TYPES.GETTER);
             if (haveSameName && isDifferentProperty && !isGetterSetterPair) {
-                throw generateError(comparePath, {
+                handleError(comparePath, {
                     errorInfo: errors.DecoratorErrors.DUPLICATE_API_PROPERTY,
                     messageArgs: [currentPropertyName],
                 }, state);
@@ -391,8 +434,12 @@ function getSiblingGetSetPairType(propertyName, type, classBodyItems) {
         return siblingKind === 'get' ? DECORATOR_TYPES.GETTER : DECORATOR_TYPES.SETTER;
     }
 }
-function computePublicPropsConfig(publicPropertyMetas, classBodyItems) {
+function computePublicPropsConfig(publicPropertyMetas, classBodyItems, state) {
     return publicPropertyMetas.reduce((acc, { propertyName, decoratedNodeType }) => {
+        // This should never happen as we filter null in class visitor and
+        // collect appropriate errors in errorRecoveryMode || throw otherwise
+        if (isErrorRecoveryMode(state) && !decoratedNodeType)
+            return acc;
         if (!(propertyName in acc)) {
             acc[propertyName] = {};
         }
@@ -409,12 +456,12 @@ function computePublicPropsConfig(publicPropertyMetas, classBodyItems) {
         return acc;
     }, {});
 }
-function transform$2(t, decoratorMetas, classBodyItems) {
+function transform$2(t, decoratorMetas, classBodyItems, state) {
     const objectProperties = [];
     const apiDecoratorMetas = decoratorMetas.filter(isApiDecorator);
     const publicPropertyMetas = apiDecoratorMetas.filter(({ decoratedNodeType }) => decoratedNodeType !== DECORATOR_TYPES.METHOD);
     if (publicPropertyMetas.length) {
-        const propsConfig = computePublicPropsConfig(publicPropertyMetas, classBodyItems);
+        const propsConfig = computePublicPropsConfig(publicPropertyMetas, classBodyItems, state);
         objectProperties.push(t.objectProperty(t.identifier(PUBLIC_PROPS), t.valueToNode(propsConfig)));
     }
     const publicMethodMetas = apiDecoratorMetas.filter(({ decoratedNodeType }) => decoratedNodeType === DECORATOR_TYPES.METHOD);
@@ -458,9 +505,10 @@ function isWireDecorator(decorator) {
 const { TRACK_DECORATOR: TRACK_DECORATOR$1, WIRE_DECORATOR: WIRE_DECORATOR$1, API_DECORATOR } = LWC_PACKAGE_EXPORTS;
 function validateWireId(id, path, state) {
     if (!id) {
-        throw generateError(path, {
+        handleError(path, {
             errorInfo: errors.DecoratorErrors.ADAPTER_SHOULD_BE_FIRST_PARAMETER,
         }, state);
+        return;
     }
     let adapter;
     if (id.isIdentifier()) {
@@ -470,9 +518,10 @@ function validateWireId(id, path, state) {
     else if (id.isMemberExpression()) {
         if (id.node.computed) {
             // @wire(adapter[computed])
-            throw generateError(id, {
+            handleError(id, {
                 errorInfo: errors.DecoratorErrors.FUNCTION_IDENTIFIER_CANNOT_HAVE_COMPUTED_PROPS,
             }, state);
+            return;
         }
         const object = id.get('object');
         if (object.isIdentifier()) {
@@ -481,73 +530,79 @@ function validateWireId(id, path, state) {
         }
         else {
             // @wire(adapter.foo.bar)
-            throw generateError(id, {
+            handleError(id, {
                 errorInfo: errors.DecoratorErrors.FUNCTION_IDENTIFIER_CANNOT_HAVE_NESTED_MEMBER_EXRESSIONS,
             }, state);
+            return;
         }
     }
     else {
         // @wire(1), @wire('adapter'), @wire(function adapter() {}), etc.
-        throw generateError(id, {
+        handleError(id, {
             errorInfo: errors.DecoratorErrors.FUNCTION_IDENTIFIER_SHOULD_BE_FIRST_PARAMETER,
         }, state);
+        return;
     }
     // Ensure wire adapter is imported (check for member expression or identifier)
     const adapterBinding = path.scope.getBinding(adapter.node.name);
     if (!adapterBinding) {
-        throw generateError(id, {
+        handleError(id, {
             errorInfo: errors.DecoratorErrors.WIRE_ADAPTER_SHOULD_BE_IMPORTED,
             messageArgs: [adapter.node.name],
         }, state);
+        return;
     }
     // ensure wire adapter is a first parameter
     if (!adapterBinding.path.isImportSpecifier() &&
         !adapterBinding.path.isImportDefaultSpecifier()) {
-        throw generateError(id, {
+        handleError(id, {
             errorInfo: errors.DecoratorErrors.IMPORTED_FUNCTION_IDENTIFIER_SHOULD_BE_FIRST_PARAMETER,
         }, state);
     }
 }
 function validateWireConfig(config, path, state) {
     if (!config.isObjectExpression()) {
-        throw generateError(config, {
+        handleError(config, {
             errorInfo: errors.DecoratorErrors.CONFIG_OBJECT_SHOULD_BE_SECOND_PARAMETER,
         }, state);
     }
-    for (const prop of config.get('properties')) {
-        // Only validate {[computed]: true} object properties; {static: true} props are all valid
-        // and we ignore {...spreads} and {methods(){}}
-        if (!prop.isObjectProperty() || !prop.node.computed)
-            continue;
-        const key = prop.get('key');
-        if (key.isIdentifier()) {
-            // Only allow identifiers that originated from a `const` declaration
-            const binding = key.scope.getBinding(key.node.name);
-            // TODO [#3956]: Investigate allowing imported constants
-            if (binding?.kind === 'const')
-                continue;
-            // By default, the identifier `undefined` has no binding (when it's actually undefined),
-            // but has a binding if it's used as a variable (e.g. `let undefined = "don't do this"`)
-            if (key.node.name === 'undefined' && !binding)
+    const properties = config.get('properties');
+    if (Array.isArray(properties)) {
+        for (const prop of properties) {
+            // Only validate {[computed]: true} object properties; {static: true} props are all valid
+            // and we ignore {...spreads} and {methods(){}}
+            if (!prop.isObjectProperty() || !prop.node.computed)
                 continue;
-        }
-        else if (key.isLiteral()) {
-            // A literal can be a regexp, template literal, or primitive; only allow primitives
-            if (key.isTemplateLiteral()) {
-                // A template literal is not guaranteed to always result in the same value
-                // (e.g. `${Math.random()}`), so we disallow them entirely.
-                // TODO [#3956]: Investigate allowing template literals
-                throw generateError(key, {
-                    errorInfo: errors.DecoratorErrors.COMPUTED_PROPERTY_CANNOT_BE_TEMPLATE_LITERAL,
-                }, state);
+            const key = prop.get('key');
+            if (key.isIdentifier()) {
+                // Only allow identifiers that originated from a `const` declaration
+                const binding = key.scope.getBinding(key.node.name);
+                // TODO [#3956]: Investigate allowing imported constants
+                if (binding?.kind === 'const')
+                    continue;
+                // By default, the identifier `undefined` has no binding (when it's actually undefined),
+                // but has a binding if it's used as a variable (e.g. `let undefined = "don't do this"`)
+                if (key.node.name === 'undefined' && !binding)
+                    continue;
             }
-            else if (!key.isRegExpLiteral()) {
-                continue;
+            else if (key.isLiteral()) {
+                // A literal can be a regexp, template literal, or primitive; only allow primitives
+                if (key.isTemplateLiteral()) {
+                    // A template literal is not guaranteed to always result in the same value
+                    // (e.g. `${Math.random()}`), so we disallow them entirely.
+                    // TODO [#3956]: Investigate allowing template literals
+                    handleError(key, {
+                        errorInfo: errors.DecoratorErrors.COMPUTED_PROPERTY_CANNOT_BE_TEMPLATE_LITERAL,
+                    }, state);
+                }
+                else if (!key.isRegExpLiteral()) {
+                    continue;
+                }
             }
+            handleError(key, {
+                errorInfo: errors.DecoratorErrors.COMPUTED_PROPERTY_MUST_BE_CONSTANT_OR_LITERAL,
+            }, state);
         }
-        throw generateError(key, {
-            errorInfo: errors.DecoratorErrors.COMPUTED_PROPERTY_MUST_BE_CONSTANT_OR_LITERAL,
-        }, state);
     }
 }
 function validateWireParameters(path, state) {
@@ -569,13 +624,13 @@ function validateUsageWithOtherDecorators(path, decorators, state) {
         if (path !== decorator.path &&
             decorator.name === WIRE_DECORATOR$1 &&
             decorator.path.parentPath.node === path.parentPath.node) {
-            throw generateError(path, {
+            handleError(path, {
                 errorInfo: errors.DecoratorErrors.ONE_WIRE_DECORATOR_ALLOWED,
             }, state);
         }
         if ((decorator.name === API_DECORATOR || decorator.name === TRACK_DECORATOR$1) &&
             decorator.path.parentPath.node === path.parentPath.node) {
-            throw generateError(path, {
+            handleError(path, {
                 errorInfo: errors.DecoratorErrors.CONFLICT_WITH_ANOTHER_DECORATOR,
                 messageArgs: [decorator.name],
             }, state);
@@ -601,15 +656,26 @@ function isObservedProperty(configProperty) {
     const propertyValue = configProperty.get('value');
     return (propertyValue.isStringLiteral() && propertyValue.node.value.startsWith(WIRE_PARAM_PREFIX));
 }
-function getWiredStatic(wireConfig) {
-    return wireConfig
-        .get('properties')
+function getWiredStatic(wireConfig, state) {
+    const properties = wireConfig.get('properties');
+    // Should only occurs in error recovery mode when config validation has already failed
+    // Skip processing since the error has been logged upstream
+    if (isErrorRecoveryMode(state) && !Array.isArray(properties)) {
+        return [];
+    }
+    return properties
         .filter((property) => !isObservedProperty(property))
         .map((path) => path.node);
 }
-function getWiredParams(t, wireConfig) {
-    return wireConfig
-        .get('properties')
+function getWiredParams(t, wireConfig, state) {
+    const properties = wireConfig.get('properties');
+    // Should only occur in error recovery mode when config validation has already failed
+    // Skip processing since the error has been logged upstream
+    if (isErrorRecoveryMode(state) && !Array.isArray(properties)) {
+        // In error recovery mode, return empty array instead of crashing
+        return [];
+    }
+    return properties
         .filter((property) => isObservedProperty(property))
         .map((path) => {
         // Need to clone deep the observed property to remove the param prefix
@@ -739,7 +805,7 @@ const scopedReferenceLookup = (scope) => (name) => {
         value,
     };
 };
-function transform$1(t, decoratorMetas) {
+function transform$1(t, decoratorMetas, state) {
     const objectProperties = [];
     const wiredValues = decoratorMetas.filter(isWireDecorator).map(({ path }) => {
         const [id, config] = path.get('expression.arguments');
@@ -752,8 +818,8 @@ function transform$1(t, decoratorMetas) {
             isClassMethod,
         };
         if (config) {
-            wiredValue.static = getWiredStatic(config);
-            wiredValue.params = getWiredParams(t, config);
+            wiredValue.static = getWiredStatic(config, state);
+            wiredValue.params = getWiredParams(t, config, state);
         }
         const referenceLookup = scopedReferenceLookup(path.scope);
         const isMemberExpression = id.isMemberExpression();
@@ -802,7 +868,7 @@ function isTrackDecorator(decorator) {
 function validate$1(decorators, state) {
     decorators.filter(isTrackDecorator).forEach(({ path }) => {
         if (!path.parentPath.isClassProperty()) {
-            throw generateError(path, {
+            handleError(path, {
                 errorInfo: errors.DecoratorErrors.TRACK_ONLY_ALLOWED_ON_CLASS_PROPERTIES,
             }, state);
         }
@@ -863,11 +929,14 @@ function getDecoratedNodeType(decoratorPath, state) {
     else if (propertyOrMethod.isClassProperty()) {
         return DECORATOR_TYPES.PROPERTY;
     }
-    else {
-        throw generateError(propertyOrMethod, {
-            errorInfo: errors.DecoratorErrors.INVALID_DECORATOR_TYPE,
-        }, state);
-    }
+    handleError(propertyOrMethod, {
+        errorInfo: errors.DecoratorErrors.INVALID_DECORATOR_TYPE,
+    }, state);
+    // We should only be here when we are running in errorRecoveryMode
+    // otherwise, the handleError method should already "throw"
+    // since, we couldn't determine a node type, we will return a null here
+    // so we can filter out this node and attempt to proceed with the compilation process
+    return null;
 }
 function validateImportedLwcDecoratorUsage(engineImportSpecifiers, state) {
     engineImportSpecifiers
@@ -890,14 +959,15 @@ function validateImportedLwcDecoratorUsage(engineImportSpecifiers, state) {
             ? reference.parentPath
             : reference.parentPath.parentPath;
         if (!decorator.isDecorator()) {
-            throw generateError(decorator, {
+            handleError(decorator, {
                 errorInfo: errors.DecoratorErrors.IS_NOT_DECORATOR,
                 messageArgs: [name],
             }, state);
         }
         const propertyOrMethod = decorator.parentPath;
-        if (!propertyOrMethod.isClassProperty() && !propertyOrMethod.isClassMethod()) {
-            throw generateError(propertyOrMethod, {
+        if (propertyOrMethod === null ||
+            (!propertyOrMethod.isClassProperty() && !propertyOrMethod.isClassMethod())) {
+            handleError(propertyOrMethod === null ? decorator : propertyOrMethod, {
                 errorInfo: errors.DecoratorErrors.IS_NOT_CLASS_PROPERTY_OR_CLASS_METHOD,
                 messageArgs: [name],
             }, state);
@@ -917,7 +987,7 @@ function validate(decorators, state) {
     for (const { name, path } of decorators) {
         const binding = path.scope.getBinding(name);
         if (binding === undefined || !isImportedFromLwcSource(binding.path)) {
-            throw generateInvalidDecoratorError(path, state);
+            handleInvalidDecoratorError(path, state);
         }
     }
     DECORATOR_TRANSFORMS.forEach(({ validate }) => validate(decorators, state));
@@ -937,7 +1007,7 @@ function removeImportedDecoratorSpecifiers(engineImportSpecifiers) {
         }
     });
 }
-function generateInvalidDecoratorError(path, state) {
+function handleInvalidDecoratorError(path, state) {
     const expressionPath = path.get('expression');
     const { node } = path;
     const { expression } = node;
@@ -949,13 +1019,13 @@ function generateInvalidDecoratorError(path, state) {
         name = expression.callee.name;
     }
     if (name) {
-        return generateError(path.parentPath, {
+        handleError(path.parentPath, {
             errorInfo: errors.DecoratorErrors.INVALID_DECORATOR_WITH_NAME,
             messageArgs: [name, AVAILABLE_DECORATORS, LWC_PACKAGE_ALIAS],
         }, state);
     }
     else {
-        return generateError(path.parentPath, {
+        handleError(path.parentPath, {
             errorInfo: errors.DecoratorErrors.INVALID_DECORATOR,
             messageArgs: [AVAILABLE_DECORATORS, LWC_PACKAGE_ALIAS],
         }, state);
@@ -980,7 +1050,8 @@ function getDecoratorMetadata(decoratorPath, state) {
         name = expressionPath.node.callee.name;
     }
     else {
-        throw generateInvalidDecoratorError(decoratorPath, state);
+        handleInvalidDecoratorError(decoratorPath, state);
+        return null;
     }
     const propertyName = decoratorPath.parent.key.name;
     const decoratedNodeType = getDecoratedNodeType(decoratorPath, state);
@@ -991,11 +1062,11 @@ function getDecoratorMetadata(decoratorPath, state) {
         decoratedNodeType,
     };
 }
-function getMetadataObjectPropertyList(t, decoratorMetas, classBodyItems) {
+function getMetadataObjectPropertyList(t, decoratorMetas, classBodyItems, state) {
     const list = [
-        ...api.transform(t, decoratorMetas, classBodyItems),
+        ...api.transform(t, decoratorMetas, classBodyItems, state),
         ...track.transform(t, decoratorMetas),
-        ...wire.transform(t, decoratorMetas),
+        ...wire.transform(t, decoratorMetas, state),
     ];
     const fieldNames = classBodyItems
         .filter((field) => field.isClassProperty({ computed: false, static: false }))
@@ -1033,9 +1104,11 @@ function decorators({ types: t }) {
                 return;
             }
             const decoratorPaths = collectDecoratorPaths(classBodyItems);
-            const decoratorMetas = decoratorPaths.map((path) => getDecoratorMetadata(path, state));
+            const decoratorMetas = decoratorPaths
+                .map((path) => getDecoratorMetadata(path, state))
+                .filter((meta) => meta !== null);
             validate(decoratorMetas, state);
-            const metaPropertyList = getMetadataObjectPropertyList(t, decoratorMetas, classBodyItems);
+            const metaPropertyList = getMetadataObjectPropertyList(t, decoratorMetas, classBodyItems, state);
             if (metaPropertyList.length === 0) {
                 return;
             }
@@ -1126,7 +1199,7 @@ function getImportSource(path) {
 }
 function validateImport(sourcePath, state) {
     if (!sourcePath.isStringLiteral()) {
-        throw generateError(sourcePath, {
+        handleError(sourcePath, {
             errorInfo: errors.LWCClassErrors.INVALID_DYNAMIC_IMPORT_SOURCE_STRICT,
             messageArgs: [String(sourcePath)],
         }, state);
@@ -1273,5 +1346,5 @@ function LwcClassTransform(api) {
 }
 
 exports.default = LwcClassTransform;
-/** version: 8.23.0 */
+/** version: 8.25.0 */
 //# sourceMappingURL=index.cjs.js.map

package/dist/index.js

@@ -4,7 +4,7 @@
 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 { generateErrorMessage, DecoratorErrors, CompilerMetrics, LWCClassErrors } from '@lwc/errors';
+import { generateCompilerDiagnostic, DiagnosticLevel, generateErrorMessage, DecoratorErrors, CompilerMetrics, LWCClassErrors } from '@lwc/errors';
 import lineColumn from 'line-column';
 
 /*
@@ -38,6 +38,7 @@ const COMPONENT_NAME_KEY = 'sel';
 const API_VERSION_KEY = 'apiVersion';
 const COMPONENT_CLASS_ID = '__lwc_component_class_internal';
 const SYNTHETIC_ELEMENT_INTERNALS_KEY = 'enableSyntheticElementInternals';
+const COMPONENT_FEATURE_FLAG_KEY = 'componentFeatureFlag';
 
 /*
  * Copyright (c) 2023, salesforce.com, inc.
@@ -71,6 +72,13 @@ function component ({ types: t }) {
     function createRegisterComponent(declarationPath, state) {
         const registerComponentId = addNamed(declarationPath, REGISTER_COMPONENT_ID, LWC_PACKAGE_ALIAS);
         const templateIdentifier = importDefaultTemplate(declarationPath, state);
+        // Optionally import feature flag module if provided via compiler options
+        let componentFeatureFlagIdentifier;
+        if (state.opts.componentFeatureFlagModulePath) {
+            componentFeatureFlagIdentifier = addDefault(declarationPath, state.opts.componentFeatureFlagModulePath, {
+                nameHint: COMPONENT_FEATURE_FLAG_KEY,
+            });
+        }
         const statementPath = declarationPath.getStatementParent();
         const componentRegisteredName = getComponentRegisteredName(t, state);
         let node = declarationPath.node;
@@ -99,6 +107,14 @@ function component ({ types: t }) {
             // The client needs to trust the server that it's providing an actual known API version
             t.objectProperty(t.identifier(API_VERSION_KEY), t.numericLiteral(apiVersion)),
         ];
+        if (componentFeatureFlagIdentifier) {
+            properties.push(t.objectProperty(t.identifier(COMPONENT_FEATURE_FLAG_KEY), t.objectExpression([
+                t.objectProperty(t.identifier('value'), t.callExpression(t.identifier('Boolean'), [
+                    componentFeatureFlagIdentifier,
+                ])),
+                t.objectProperty(t.identifier('path'), t.stringLiteral(state.opts.componentFeatureFlagModulePath)),
+            ])));
+        }
         // Only include enableSyntheticElementInternals if set to true
         if (state.opts.enableSyntheticElementInternals === true) {
             properties.push(t.objectProperty(t.identifier(SYNTHETIC_ELEMENT_INTERNALS_KEY), t.booleanLiteral(true)));
@@ -209,9 +225,36 @@ function generateError(source, { errorInfo, messageArgs }, state) {
     error.lwcCode = errorInfo && errorInfo.code;
     return error;
 }
+function collectError(source, { errorInfo, messageArgs }, state) {
+    const diagnostic = generateCompilerDiagnostic(errorInfo, {
+        messageArgs,
+        origin: {
+            filename: state.filename,
+            location: normalizeLocation(source) ?? undefined,
+        },
+    }, true);
+    if (diagnostic.level === DiagnosticLevel.Fatal) {
+        throw generateError(source, { errorInfo, messageArgs }, state);
+    }
+    if (!state.file.metadata.lwcErrors) {
+        state.file.metadata.lwcErrors = [];
+    }
+    state.file.metadata.lwcErrors.push(diagnostic);
+}
+function handleError(source, decoratorErrorOpts, state) {
+    if (isErrorRecoveryMode(state)) {
+        collectError(source, decoratorErrorOpts, state);
+    }
+    else {
+        throw generateError(source, decoratorErrorOpts, state);
+    }
+}
 function incrementMetricCounter(metric, state) {
     state.opts.instrumentation?.incrementCounter(metric);
 }
+function isErrorRecoveryMode(state) {
+    return state.file.opts?.parserOpts?.errorRecovery ?? false;
+}
 
 /*
  * Copyright (c) 2023, salesforce.com, inc.
@@ -235,7 +278,7 @@ function validateConflict(path, decorators, state) {
     const isPublicFieldTracked = decorators.some((decorator) => decorator.name === TRACK_DECORATOR$2 &&
         decorator.path.parentPath.node === path.parentPath.node);
     if (isPublicFieldTracked) {
-        throw generateError(path, {
+        handleError(path, {
             errorInfo: DecoratorErrors.API_AND_TRACK_DECORATOR_CONFLICT,
         }, state);
     }
@@ -246,45 +289,45 @@ function isBooleanPropDefaultTrue(property) {
 }
 function validatePropertyValue(property, state) {
     if (isBooleanPropDefaultTrue(property)) {
-        throw generateError(property, {
+        handleError(property, {
             errorInfo: DecoratorErrors.INVALID_BOOLEAN_PUBLIC_PROPERTY,
         }, state);
     }
 }
 function validatePropertyName(property, state) {
     if (property.node.computed) {
-        throw generateError(property, {
+        handleError(property, {
             errorInfo: DecoratorErrors.PROPERTY_CANNOT_BE_COMPUTED,
         }, state);
     }
     const propertyName = property.get('key.name').node;
     if (propertyName === 'part') {
-        throw generateError(property, {
+        handleError(property, {
             errorInfo: DecoratorErrors.PROPERTY_NAME_PART_IS_RESERVED,
             messageArgs: [propertyName],
         }, state);
     }
     else if (propertyName.startsWith('on')) {
-        throw generateError(property, {
+        handleError(property, {
             errorInfo: DecoratorErrors.PROPERTY_NAME_CANNOT_START_WITH_ON,
             messageArgs: [propertyName],
         }, state);
     }
     else if (propertyName.startsWith('data') && propertyName.length > 4) {
-        throw generateError(property, {
+        handleError(property, {
             errorInfo: DecoratorErrors.PROPERTY_NAME_CANNOT_START_WITH_DATA,
             messageArgs: [propertyName],
         }, state);
     }
     else if (DISALLOWED_PROP_SET.has(propertyName)) {
-        throw generateError(property, {
+        handleError(property, {
             errorInfo: DecoratorErrors.PROPERTY_NAME_IS_RESERVED,
             messageArgs: [propertyName],
         }, state);
     }
     else if (AMBIGUOUS_PROP_SET.has(propertyName)) {
         const camelCased = AMBIGUOUS_PROP_SET.get(propertyName);
-        throw generateError(property, {
+        handleError(property, {
             errorInfo: DecoratorErrors.PROPERTY_NAME_IS_AMBIGUOUS,
             messageArgs: [propertyName, camelCased],
         }, state);
@@ -302,7 +345,7 @@ function validateSingleApiDecoratorOnSetterGetterPair(decorators, state) {
             const methodPath = path.parentPath;
             const methodName = methodPath.get('key.name').node;
             if (visitedMethods.has(methodName)) {
-                throw generateError(methodPath, {
+                handleError(methodPath, {
                     errorInfo: DecoratorErrors.SINGLE_DECORATOR_ON_SETTER_GETTER_PAIR,
                     messageArgs: [methodName],
                 }, state);
@@ -328,7 +371,7 @@ function validateUniqueness(decorators, state) {
                 compareType === DECORATOR_TYPES.SETTER) ||
                 (currentType === DECORATOR_TYPES.SETTER && compareType === DECORATOR_TYPES.GETTER);
             if (haveSameName && isDifferentProperty && !isGetterSetterPair) {
-                throw generateError(comparePath, {
+                handleError(comparePath, {
                     errorInfo: DecoratorErrors.DUPLICATE_API_PROPERTY,
                     messageArgs: [currentPropertyName],
                 }, state);
@@ -387,8 +430,12 @@ function getSiblingGetSetPairType(propertyName, type, classBodyItems) {
         return siblingKind === 'get' ? DECORATOR_TYPES.GETTER : DECORATOR_TYPES.SETTER;
     }
 }
-function computePublicPropsConfig(publicPropertyMetas, classBodyItems) {
+function computePublicPropsConfig(publicPropertyMetas, classBodyItems, state) {
     return publicPropertyMetas.reduce((acc, { propertyName, decoratedNodeType }) => {
+        // This should never happen as we filter null in class visitor and
+        // collect appropriate errors in errorRecoveryMode || throw otherwise
+        if (isErrorRecoveryMode(state) && !decoratedNodeType)
+            return acc;
         if (!(propertyName in acc)) {
             acc[propertyName] = {};
         }
@@ -405,12 +452,12 @@ function computePublicPropsConfig(publicPropertyMetas, classBodyItems) {
         return acc;
     }, {});
 }
-function transform$2(t, decoratorMetas, classBodyItems) {
+function transform$2(t, decoratorMetas, classBodyItems, state) {
     const objectProperties = [];
     const apiDecoratorMetas = decoratorMetas.filter(isApiDecorator);
     const publicPropertyMetas = apiDecoratorMetas.filter(({ decoratedNodeType }) => decoratedNodeType !== DECORATOR_TYPES.METHOD);
     if (publicPropertyMetas.length) {
-        const propsConfig = computePublicPropsConfig(publicPropertyMetas, classBodyItems);
+        const propsConfig = computePublicPropsConfig(publicPropertyMetas, classBodyItems, state);
         objectProperties.push(t.objectProperty(t.identifier(PUBLIC_PROPS), t.valueToNode(propsConfig)));
     }
     const publicMethodMetas = apiDecoratorMetas.filter(({ decoratedNodeType }) => decoratedNodeType === DECORATOR_TYPES.METHOD);
@@ -454,9 +501,10 @@ function isWireDecorator(decorator) {
 const { TRACK_DECORATOR: TRACK_DECORATOR$1, WIRE_DECORATOR: WIRE_DECORATOR$1, API_DECORATOR } = LWC_PACKAGE_EXPORTS;
 function validateWireId(id, path, state) {
     if (!id) {
-        throw generateError(path, {
+        handleError(path, {
             errorInfo: DecoratorErrors.ADAPTER_SHOULD_BE_FIRST_PARAMETER,
         }, state);
+        return;
     }
     let adapter;
     if (id.isIdentifier()) {
@@ -466,9 +514,10 @@ function validateWireId(id, path, state) {
     else if (id.isMemberExpression()) {
         if (id.node.computed) {
             // @wire(adapter[computed])
-            throw generateError(id, {
+            handleError(id, {
                 errorInfo: DecoratorErrors.FUNCTION_IDENTIFIER_CANNOT_HAVE_COMPUTED_PROPS,
             }, state);
+            return;
         }
         const object = id.get('object');
         if (object.isIdentifier()) {
@@ -477,73 +526,79 @@ function validateWireId(id, path, state) {
         }
         else {
             // @wire(adapter.foo.bar)
-            throw generateError(id, {
+            handleError(id, {
                 errorInfo: DecoratorErrors.FUNCTION_IDENTIFIER_CANNOT_HAVE_NESTED_MEMBER_EXRESSIONS,
             }, state);
+            return;
         }
     }
     else {
         // @wire(1), @wire('adapter'), @wire(function adapter() {}), etc.
-        throw generateError(id, {
+        handleError(id, {
             errorInfo: DecoratorErrors.FUNCTION_IDENTIFIER_SHOULD_BE_FIRST_PARAMETER,
         }, state);
+        return;
     }
     // Ensure wire adapter is imported (check for member expression or identifier)
     const adapterBinding = path.scope.getBinding(adapter.node.name);
     if (!adapterBinding) {
-        throw generateError(id, {
+        handleError(id, {
             errorInfo: DecoratorErrors.WIRE_ADAPTER_SHOULD_BE_IMPORTED,
             messageArgs: [adapter.node.name],
         }, state);
+        return;
     }
     // ensure wire adapter is a first parameter
     if (!adapterBinding.path.isImportSpecifier() &&
         !adapterBinding.path.isImportDefaultSpecifier()) {
-        throw generateError(id, {
+        handleError(id, {
             errorInfo: DecoratorErrors.IMPORTED_FUNCTION_IDENTIFIER_SHOULD_BE_FIRST_PARAMETER,
         }, state);
     }
 }
 function validateWireConfig(config, path, state) {
     if (!config.isObjectExpression()) {
-        throw generateError(config, {
+        handleError(config, {
             errorInfo: DecoratorErrors.CONFIG_OBJECT_SHOULD_BE_SECOND_PARAMETER,
         }, state);
     }
-    for (const prop of config.get('properties')) {
-        // Only validate {[computed]: true} object properties; {static: true} props are all valid
-        // and we ignore {...spreads} and {methods(){}}
-        if (!prop.isObjectProperty() || !prop.node.computed)
-            continue;
-        const key = prop.get('key');
-        if (key.isIdentifier()) {
-            // Only allow identifiers that originated from a `const` declaration
-            const binding = key.scope.getBinding(key.node.name);
-            // TODO [#3956]: Investigate allowing imported constants
-            if (binding?.kind === 'const')
-                continue;
-            // By default, the identifier `undefined` has no binding (when it's actually undefined),
-            // but has a binding if it's used as a variable (e.g. `let undefined = "don't do this"`)
-            if (key.node.name === 'undefined' && !binding)
+    const properties = config.get('properties');
+    if (Array.isArray(properties)) {
+        for (const prop of properties) {
+            // Only validate {[computed]: true} object properties; {static: true} props are all valid
+            // and we ignore {...spreads} and {methods(){}}
+            if (!prop.isObjectProperty() || !prop.node.computed)
                 continue;
-        }
-        else if (key.isLiteral()) {
-            // A literal can be a regexp, template literal, or primitive; only allow primitives
-            if (key.isTemplateLiteral()) {
-                // A template literal is not guaranteed to always result in the same value
-                // (e.g. `${Math.random()}`), so we disallow them entirely.
-                // TODO [#3956]: Investigate allowing template literals
-                throw generateError(key, {
-                    errorInfo: DecoratorErrors.COMPUTED_PROPERTY_CANNOT_BE_TEMPLATE_LITERAL,
-                }, state);
+            const key = prop.get('key');
+            if (key.isIdentifier()) {
+                // Only allow identifiers that originated from a `const` declaration
+                const binding = key.scope.getBinding(key.node.name);
+                // TODO [#3956]: Investigate allowing imported constants
+                if (binding?.kind === 'const')
+                    continue;
+                // By default, the identifier `undefined` has no binding (when it's actually undefined),
+                // but has a binding if it's used as a variable (e.g. `let undefined = "don't do this"`)
+                if (key.node.name === 'undefined' && !binding)
+                    continue;
             }
-            else if (!key.isRegExpLiteral()) {
-                continue;
+            else if (key.isLiteral()) {
+                // A literal can be a regexp, template literal, or primitive; only allow primitives
+                if (key.isTemplateLiteral()) {
+                    // A template literal is not guaranteed to always result in the same value
+                    // (e.g. `${Math.random()}`), so we disallow them entirely.
+                    // TODO [#3956]: Investigate allowing template literals
+                    handleError(key, {
+                        errorInfo: DecoratorErrors.COMPUTED_PROPERTY_CANNOT_BE_TEMPLATE_LITERAL,
+                    }, state);
+                }
+                else if (!key.isRegExpLiteral()) {
+                    continue;
+                }
             }
+            handleError(key, {
+                errorInfo: DecoratorErrors.COMPUTED_PROPERTY_MUST_BE_CONSTANT_OR_LITERAL,
+            }, state);
         }
-        throw generateError(key, {
-            errorInfo: DecoratorErrors.COMPUTED_PROPERTY_MUST_BE_CONSTANT_OR_LITERAL,
-        }, state);
     }
 }
 function validateWireParameters(path, state) {
@@ -565,13 +620,13 @@ function validateUsageWithOtherDecorators(path, decorators, state) {
         if (path !== decorator.path &&
             decorator.name === WIRE_DECORATOR$1 &&
             decorator.path.parentPath.node === path.parentPath.node) {
-            throw generateError(path, {
+            handleError(path, {
                 errorInfo: DecoratorErrors.ONE_WIRE_DECORATOR_ALLOWED,
             }, state);
         }
         if ((decorator.name === API_DECORATOR || decorator.name === TRACK_DECORATOR$1) &&
             decorator.path.parentPath.node === path.parentPath.node) {
-            throw generateError(path, {
+            handleError(path, {
                 errorInfo: DecoratorErrors.CONFLICT_WITH_ANOTHER_DECORATOR,
                 messageArgs: [decorator.name],
             }, state);
@@ -597,15 +652,26 @@ function isObservedProperty(configProperty) {
     const propertyValue = configProperty.get('value');
     return (propertyValue.isStringLiteral() && propertyValue.node.value.startsWith(WIRE_PARAM_PREFIX));
 }
-function getWiredStatic(wireConfig) {
-    return wireConfig
-        .get('properties')
+function getWiredStatic(wireConfig, state) {
+    const properties = wireConfig.get('properties');
+    // Should only occurs in error recovery mode when config validation has already failed
+    // Skip processing since the error has been logged upstream
+    if (isErrorRecoveryMode(state) && !Array.isArray(properties)) {
+        return [];
+    }
+    return properties
         .filter((property) => !isObservedProperty(property))
         .map((path) => path.node);
 }
-function getWiredParams(t, wireConfig) {
-    return wireConfig
-        .get('properties')
+function getWiredParams(t, wireConfig, state) {
+    const properties = wireConfig.get('properties');
+    // Should only occur in error recovery mode when config validation has already failed
+    // Skip processing since the error has been logged upstream
+    if (isErrorRecoveryMode(state) && !Array.isArray(properties)) {
+        // In error recovery mode, return empty array instead of crashing
+        return [];
+    }
+    return properties
         .filter((property) => isObservedProperty(property))
         .map((path) => {
         // Need to clone deep the observed property to remove the param prefix
@@ -735,7 +801,7 @@ const scopedReferenceLookup = (scope) => (name) => {
         value,
     };
 };
-function transform$1(t, decoratorMetas) {
+function transform$1(t, decoratorMetas, state) {
     const objectProperties = [];
     const wiredValues = decoratorMetas.filter(isWireDecorator).map(({ path }) => {
         const [id, config] = path.get('expression.arguments');
@@ -748,8 +814,8 @@ function transform$1(t, decoratorMetas) {
             isClassMethod,
         };
         if (config) {
-            wiredValue.static = getWiredStatic(config);
-            wiredValue.params = getWiredParams(t, config);
+            wiredValue.static = getWiredStatic(config, state);
+            wiredValue.params = getWiredParams(t, config, state);
         }
         const referenceLookup = scopedReferenceLookup(path.scope);
         const isMemberExpression = id.isMemberExpression();
@@ -798,7 +864,7 @@ function isTrackDecorator(decorator) {
 function validate$1(decorators, state) {
     decorators.filter(isTrackDecorator).forEach(({ path }) => {
         if (!path.parentPath.isClassProperty()) {
-            throw generateError(path, {
+            handleError(path, {
                 errorInfo: DecoratorErrors.TRACK_ONLY_ALLOWED_ON_CLASS_PROPERTIES,
             }, state);
         }
@@ -859,11 +925,14 @@ function getDecoratedNodeType(decoratorPath, state) {
     else if (propertyOrMethod.isClassProperty()) {
         return DECORATOR_TYPES.PROPERTY;
     }
-    else {
-        throw generateError(propertyOrMethod, {
-            errorInfo: DecoratorErrors.INVALID_DECORATOR_TYPE,
-        }, state);
-    }
+    handleError(propertyOrMethod, {
+        errorInfo: DecoratorErrors.INVALID_DECORATOR_TYPE,
+    }, state);
+    // We should only be here when we are running in errorRecoveryMode
+    // otherwise, the handleError method should already "throw"
+    // since, we couldn't determine a node type, we will return a null here
+    // so we can filter out this node and attempt to proceed with the compilation process
+    return null;
 }
 function validateImportedLwcDecoratorUsage(engineImportSpecifiers, state) {
     engineImportSpecifiers
@@ -886,14 +955,15 @@ function validateImportedLwcDecoratorUsage(engineImportSpecifiers, state) {
             ? reference.parentPath
             : reference.parentPath.parentPath;
         if (!decorator.isDecorator()) {
-            throw generateError(decorator, {
+            handleError(decorator, {
                 errorInfo: DecoratorErrors.IS_NOT_DECORATOR,
                 messageArgs: [name],
             }, state);
         }
         const propertyOrMethod = decorator.parentPath;
-        if (!propertyOrMethod.isClassProperty() && !propertyOrMethod.isClassMethod()) {
-            throw generateError(propertyOrMethod, {
+        if (propertyOrMethod === null ||
+            (!propertyOrMethod.isClassProperty() && !propertyOrMethod.isClassMethod())) {
+            handleError(propertyOrMethod === null ? decorator : propertyOrMethod, {
                 errorInfo: DecoratorErrors.IS_NOT_CLASS_PROPERTY_OR_CLASS_METHOD,
                 messageArgs: [name],
             }, state);
@@ -913,7 +983,7 @@ function validate(decorators, state) {
     for (const { name, path } of decorators) {
         const binding = path.scope.getBinding(name);
         if (binding === undefined || !isImportedFromLwcSource(binding.path)) {
-            throw generateInvalidDecoratorError(path, state);
+            handleInvalidDecoratorError(path, state);
         }
     }
     DECORATOR_TRANSFORMS.forEach(({ validate }) => validate(decorators, state));
@@ -933,7 +1003,7 @@ function removeImportedDecoratorSpecifiers(engineImportSpecifiers) {
         }
     });
 }
-function generateInvalidDecoratorError(path, state) {
+function handleInvalidDecoratorError(path, state) {
     const expressionPath = path.get('expression');
     const { node } = path;
     const { expression } = node;
@@ -945,13 +1015,13 @@ function generateInvalidDecoratorError(path, state) {
         name = expression.callee.name;
     }
     if (name) {
-        return generateError(path.parentPath, {
+        handleError(path.parentPath, {
             errorInfo: DecoratorErrors.INVALID_DECORATOR_WITH_NAME,
             messageArgs: [name, AVAILABLE_DECORATORS, LWC_PACKAGE_ALIAS],
         }, state);
     }
     else {
-        return generateError(path.parentPath, {
+        handleError(path.parentPath, {
             errorInfo: DecoratorErrors.INVALID_DECORATOR,
             messageArgs: [AVAILABLE_DECORATORS, LWC_PACKAGE_ALIAS],
         }, state);
@@ -976,7 +1046,8 @@ function getDecoratorMetadata(decoratorPath, state) {
         name = expressionPath.node.callee.name;
     }
     else {
-        throw generateInvalidDecoratorError(decoratorPath, state);
+        handleInvalidDecoratorError(decoratorPath, state);
+        return null;
     }
     const propertyName = decoratorPath.parent.key.name;
     const decoratedNodeType = getDecoratedNodeType(decoratorPath, state);
@@ -987,11 +1058,11 @@ function getDecoratorMetadata(decoratorPath, state) {
         decoratedNodeType,
     };
 }
-function getMetadataObjectPropertyList(t, decoratorMetas, classBodyItems) {
+function getMetadataObjectPropertyList(t, decoratorMetas, classBodyItems, state) {
     const list = [
-        ...api.transform(t, decoratorMetas, classBodyItems),
+        ...api.transform(t, decoratorMetas, classBodyItems, state),
         ...track.transform(t, decoratorMetas),
-        ...wire.transform(t, decoratorMetas),
+        ...wire.transform(t, decoratorMetas, state),
     ];
     const fieldNames = classBodyItems
         .filter((field) => field.isClassProperty({ computed: false, static: false }))
@@ -1029,9 +1100,11 @@ function decorators({ types: t }) {
                 return;
             }
             const decoratorPaths = collectDecoratorPaths(classBodyItems);
-            const decoratorMetas = decoratorPaths.map((path) => getDecoratorMetadata(path, state));
+            const decoratorMetas = decoratorPaths
+                .map((path) => getDecoratorMetadata(path, state))
+                .filter((meta) => meta !== null);
             validate(decoratorMetas, state);
-            const metaPropertyList = getMetadataObjectPropertyList(t, decoratorMetas, classBodyItems);
+            const metaPropertyList = getMetadataObjectPropertyList(t, decoratorMetas, classBodyItems, state);
             if (metaPropertyList.length === 0) {
                 return;
             }
@@ -1122,7 +1195,7 @@ function getImportSource(path) {
 }
 function validateImport(sourcePath, state) {
     if (!sourcePath.isStringLiteral()) {
-        throw generateError(sourcePath, {
+        handleError(sourcePath, {
             errorInfo: LWCClassErrors.INVALID_DYNAMIC_IMPORT_SOURCE_STRICT,
             messageArgs: [String(sourcePath)],
         }, state);
@@ -1269,5 +1342,5 @@ function LwcClassTransform(api) {
 }
 
 export { LwcClassTransform as default };
-/** version: 8.23.0 */
+/** version: 8.25.0 */
 //# sourceMappingURL=index.js.map

package/dist/types.d.ts

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

package/dist/utils.d.ts

@@ -18,7 +18,8 @@ declare function isSetterClassMethod(classMethod: NodePath<types.Node>, properti
     static?: boolean;
 }): classMethod is NodePath<types.ClassMethod>;
 declare function getEngineImportSpecifiers(path: NodePath): ImportSpecifier[];
-declare function generateError(source: NodePath<types.Node>, { errorInfo, messageArgs }: DecoratorErrorOptions, state: LwcBabelPluginPass): Error;
+declare function handleError(source: NodePath<types.Node>, decoratorErrorOpts: DecoratorErrorOptions, state: LwcBabelPluginPass): void;
 declare function incrementMetricCounter(metric: CompilerMetrics, state: LwcBabelPluginPass): void;
-export { isClassMethod, isGetterClassMethod, isSetterClassMethod, generateError, getEngineImportSpecifiers, incrementMetricCounter, };
+declare function isErrorRecoveryMode(state: LwcBabelPluginPass): boolean;
+export { isClassMethod, isGetterClassMethod, isSetterClassMethod, getEngineImportSpecifiers, handleError, incrementMetricCounter, isErrorRecoveryMode, };
 //# 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": "8.23.0",
+    "version": "8.25.0",
     "description": "Babel plugin to transform a LWC module",
     "keywords": [
         "lwc"
@@ -47,8 +47,8 @@
     },
     "dependencies": {
         "@babel/helper-module-imports": "7.27.1",
-        "@lwc/errors": "8.23.0",
-        "@lwc/shared": "8.23.0",
+        "@lwc/errors": "8.25.0",
+        "@lwc/shared": "8.25.0",
         "line-column": "~1.0.2"
     },
     "devDependencies": {