@lwc/ssr-compiler 8.22.3 → 8.22.5

package/dist/compile-template/expression.d.ts

@@ -2,4 +2,13 @@ import type { ComplexExpression as IrComplexExpression, Expression as IrExpressi
 import type { Expression as EsExpression } from 'estree';
 import type { TransformerContext } from './types';
 export declare function expressionIrToEs(node: IrExpression | IrComplexExpression, cxt: TransformerContext): EsExpression;
+/**
+ * Given an expression in a context, return an expression that may be scoped to that context.
+ * For example, for the expression `foo`, it will typically be `instance.foo`, but if we're
+ * inside a `for:each` block then the `foo` variable may refer to the scoped `foo`,
+ * e.g. `<template for:each={foos} for:item="foo">`
+ * @param expression
+ * @param cxt
+ */
+export declare function getScopedExpression(expression: IrExpression, cxt: TransformerContext): EsExpression;
 //# sourceMappingURL=expression.d.ts.map

package/dist/compile-template/shared.d.ts

@@ -4,15 +4,6 @@ import type { Expression as EsExpression, ObjectExpression as EsObjectExpression
 import type { ComplexExpression as IrComplexExpression, Expression as IrExpression, Literal as IrLiteral } from '@lwc/template-compiler';
 export declare function optimizeAdjacentYieldStmts(statements: EsStatement[]): EsStatement[];
 export declare function bAttributeValue(node: IrNode, attrName: string): EsExpression;
-/**
- * Given an expression in a context, return an expression that may be scoped to that context.
- * For example, for the expression `foo`, it will typically be `instance.foo`, but if we're
- * inside a `for:each` block then the `foo` variable may refer to the scoped `foo`,
- * e.g. `<template for:each={foos} for:item="foo">`
- * @param expression
- * @param cxt
- */
-export declare function getScopedExpression(expression: EsExpression, cxt: TransformerContext): EsExpression;
 export declare function normalizeClassAttributeValue(value: string): string;
 export declare function getChildAttrsOrProps(attrs: (IrAttribute | IrProperty)[], cxt: TransformerContext): EsObjectExpression;
 /**

package/dist/compile-template/types.d.ts

@@ -31,5 +31,6 @@ export interface TransformerContext {
 export interface TemplateOpts {
     preserveComments: boolean;
     experimentalComplexExpressions: boolean;
+    apiVersion: number;
 }
 //# sourceMappingURL=types.d.ts.map

package/dist/index.cjs.js

@@ -1257,25 +1257,45 @@ function addScopeTokenDeclarations(program, filename, namespace, componentName)
  * SPDX-License-Identifier: MIT
  * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
  */
-function getRootMemberExpression$2(node) {
-    return node.object.type === 'MemberExpression' ? getRootMemberExpression$2(node.object) : node;
-}
 function expressionIrToEs(node, cxt) {
-    if (node.type === 'Identifier') {
-        const isLocalVar = cxt.isLocalVar(node.name);
-        return isLocalVar
-            ? node
-            : estreeToolkit.builders.memberExpression(estreeToolkit.builders.identifier('instance'), node);
+    const isComplexTemplateExpressionEnabled = cxt.templateOptions.experimentalComplexExpressions &&
+        shared.isAPIFeatureEnabled(11 /* APIFeature.ENABLE_COMPLEX_TEMPLATE_EXPRESSIONS */, cxt.templateOptions.apiVersion);
+    return templateCompiler.bindExpression(node, (n) => cxt.isLocalVar(n.name), 'instance', isComplexTemplateExpressionEnabled);
+}
+/**
+ * Given an expression in a context, return an expression that may be scoped to that context.
+ * For example, for the expression `foo`, it will typically be `instance.foo`, but if we're
+ * inside a `for:each` block then the `foo` variable may refer to the scoped `foo`,
+ * e.g. `<template for:each={foos} for:item="foo">`
+ * @param expression
+ * @param cxt
+ */
+function getScopedExpression(expression, cxt) {
+    let scopeReferencedId = null;
+    if (expression.type === 'MemberExpression') {
+        // e.g. `foo.bar` -> scopeReferencedId is `foo`
+        scopeReferencedId = getRootIdentifier$1(expression);
     }
-    else if (node.type === 'MemberExpression') {
-        const nodeClone = structuredClone(node);
-        const rootMemberExpr = getRootMemberExpression$2(nodeClone);
-        if (!cxt.isLocalVar(rootMemberExpr.object.name)) {
-            rootMemberExpr.object = estreeToolkit.builders.memberExpression(estreeToolkit.builders.identifier('instance'), rootMemberExpr.object);
-        }
-        return nodeClone;
+    else if (expression.type === 'Identifier') {
+        // e.g. `foo` -> scopeReferencedId is `foo`
+        scopeReferencedId = expression;
+    }
+    if (scopeReferencedId === null && !cxt.templateOptions.experimentalComplexExpressions) {
+        throw new Error(`Invalid expression, must be a MemberExpression or Identifier, found type="${expression.type}": \`${JSON.stringify(expression)}\``);
+    }
+    return cxt.isLocalVar(scopeReferencedId?.name)
+        ? expression
+        : expressionIrToEs(expression, cxt);
+}
+function getRootMemberExpression$1(node) {
+    return node.object.type === 'MemberExpression' ? getRootMemberExpression$1(node.object) : node;
+}
+function getRootIdentifier$1(node) {
+    const rootMemberExpression = getRootMemberExpression$1(node);
+    if (rootMemberExpression.object.type === 'Identifier') {
+        return rootMemberExpression.object;
     }
-    throw new Error(`Unimplemented expression: ${node.type}`);
+    throw new Error(`Invalid expression, must be an Identifier, found type="${rootMemberExpression.type}": \`${JSON.stringify(rootMemberExpression)}\``);
 }
 
 /*
@@ -1328,53 +1348,6 @@ function bAttributeValue(node, attrName) {
         return estreeToolkit.builders.memberExpression(estreeToolkit.builders.literal('instance'), nameAttrValue);
     }
 }
-function getRootMemberExpression$1(node) {
-    return node.object.type === 'MemberExpression' ? getRootMemberExpression$1(node.object) : node;
-}
-function getRootIdentifier$1(node, cxt) {
-    const rootMemberExpression = getRootMemberExpression$1(node);
-    if (estreeToolkit.is.identifier(rootMemberExpression.object)) {
-        return rootMemberExpression.object;
-    }
-    if (cxt.templateOptions.experimentalComplexExpressions) {
-        // TODO [#3370]: Implement complex template expressions
-        return null;
-    }
-    // Should be impossible to hit, at least until we implement complex template expressions
-    /* v8 ignore next */
-    throw new Error(`Invalid expression, must be an Identifier, found type="${rootMemberExpression.type}": \`${JSON.stringify(rootMemberExpression)}\``);
-}
-/**
- * Given an expression in a context, return an expression that may be scoped to that context.
- * For example, for the expression `foo`, it will typically be `instance.foo`, but if we're
- * inside a `for:each` block then the `foo` variable may refer to the scoped `foo`,
- * e.g. `<template for:each={foos} for:item="foo">`
- * @param expression
- * @param cxt
- */
-function getScopedExpression(expression, cxt) {
-    let scopeReferencedId = null;
-    if (estreeToolkit.is.memberExpression(expression)) {
-        // e.g. `foo.bar` -> scopeReferencedId is `foo`
-        scopeReferencedId = getRootIdentifier$1(expression, cxt);
-    }
-    else if (estreeToolkit.is.identifier(expression)) {
-        // e.g. `foo` -> scopeReferencedId is `foo`
-        scopeReferencedId = expression;
-    }
-    if (scopeReferencedId === null) {
-        if (cxt.templateOptions.experimentalComplexExpressions) {
-            // TODO [#3370]: Implement complex template expressions
-            return expression;
-        }
-        // Should be impossible to hit, at least until we implement complex template expressions
-        /* v8 ignore next */
-        throw new Error(`Invalid expression, must be a MemberExpression or Identifier, found type="${expression.type}": \`${JSON.stringify(expression)}\``);
-    }
-    return cxt.isLocalVar(scopeReferencedId.name)
-        ? expression
-        : estreeToolkit.builders.memberExpression(estreeToolkit.builders.identifier('instance'), expression);
-}
 function normalizeClassAttributeValue(value) {
     // @ts-expect-error weird indirection results in wrong overload being picked up
     return shared.StringReplace.call(shared.StringTrim.call(value), /\s+/g, ' ');
@@ -2601,9 +2574,11 @@ function compileTemplate(src, filename, options, compilationMode) {
     }
     const preserveComments = !!root.directives.find((directive) => directive.name === 'PreserveComments')?.value?.value;
     const experimentalComplexExpressions = Boolean(options.experimentalComplexExpressions);
+    const apiVersion = Number(options.apiVersion);
     const { addImport, getImports, statements, cxt } = templateIrToEsTree(root, {
         preserveComments,
         experimentalComplexExpressions,
+        apiVersion,
     });
     addImport(['renderStylesheets', 'hasScopedStaticStylesheets']);
     for (const [imports, source] of getStylesheetImports(filename)) {
@@ -2666,5 +2641,5 @@ function compileTemplateForSSR(src, filename, options, mode = shared.DEFAULT_SSR
 
 exports.compileComponentForSSR = compileComponentForSSR;
 exports.compileTemplateForSSR = compileTemplateForSSR;
-/** version: 8.22.3 */
+/** version: 8.22.5 */
 //# sourceMappingURL=index.cjs.js.map

package/dist/index.js

@@ -1,7 +1,7 @@
 /**
  * Copyright (c) 2025 Salesforce, Inc.
  */
-import { AMBIGUOUS_PROP_SET, DISALLOWED_PROP_SET, LWC_VERSION_COMMENT, normalizeStyleAttributeValue, normalizeTabIndex, StringReplace, StringTrim, entries, kebabCaseToCamelCase, isUndefined, HTML_NAMESPACE, isVoidElement, isBooleanAttribute, DEFAULT_SSR_MODE, generateCustomElementTagName } from '@lwc/shared';
+import { AMBIGUOUS_PROP_SET, DISALLOWED_PROP_SET, LWC_VERSION_COMMENT, isAPIFeatureEnabled, normalizeStyleAttributeValue, normalizeTabIndex, StringReplace, StringTrim, entries, kebabCaseToCamelCase, isUndefined, HTML_NAMESPACE, isVoidElement, isBooleanAttribute, DEFAULT_SSR_MODE, generateCustomElementTagName } from '@lwc/shared';
 import { generate } from 'astring';
 import { builders, traverse, is } from 'estree-toolkit';
 import { parseModule } from 'meriyah';
@@ -9,7 +9,7 @@ import { generateCompilerError, DecoratorErrors, SsrCompilerErrors, LWCClassErro
 import { produce } from 'immer';
 import { parse as parse$1 } from 'node:path';
 import { parse } from 'acorn';
-import { generateScopeTokens, toPropertyName, kebabcaseToCamelcase, parse as parse$2 } from '@lwc/template-compiler';
+import { generateScopeTokens, bindExpression, toPropertyName, kebabcaseToCamelcase, parse as parse$2 } from '@lwc/template-compiler';
 import { builders as builders$1 } from 'estree-toolkit/dist/builders';
 import { isValidES3Identifier } from '@babel/types';
 import { inspect } from 'util';
@@ -1253,25 +1253,45 @@ function addScopeTokenDeclarations(program, filename, namespace, componentName)
  * SPDX-License-Identifier: MIT
  * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
  */
-function getRootMemberExpression$2(node) {
-    return node.object.type === 'MemberExpression' ? getRootMemberExpression$2(node.object) : node;
-}
 function expressionIrToEs(node, cxt) {
-    if (node.type === 'Identifier') {
-        const isLocalVar = cxt.isLocalVar(node.name);
-        return isLocalVar
-            ? node
-            : builders.memberExpression(builders.identifier('instance'), node);
+    const isComplexTemplateExpressionEnabled = cxt.templateOptions.experimentalComplexExpressions &&
+        isAPIFeatureEnabled(11 /* APIFeature.ENABLE_COMPLEX_TEMPLATE_EXPRESSIONS */, cxt.templateOptions.apiVersion);
+    return bindExpression(node, (n) => cxt.isLocalVar(n.name), 'instance', isComplexTemplateExpressionEnabled);
+}
+/**
+ * Given an expression in a context, return an expression that may be scoped to that context.
+ * For example, for the expression `foo`, it will typically be `instance.foo`, but if we're
+ * inside a `for:each` block then the `foo` variable may refer to the scoped `foo`,
+ * e.g. `<template for:each={foos} for:item="foo">`
+ * @param expression
+ * @param cxt
+ */
+function getScopedExpression(expression, cxt) {
+    let scopeReferencedId = null;
+    if (expression.type === 'MemberExpression') {
+        // e.g. `foo.bar` -> scopeReferencedId is `foo`
+        scopeReferencedId = getRootIdentifier$1(expression);
     }
-    else if (node.type === 'MemberExpression') {
-        const nodeClone = structuredClone(node);
-        const rootMemberExpr = getRootMemberExpression$2(nodeClone);
-        if (!cxt.isLocalVar(rootMemberExpr.object.name)) {
-            rootMemberExpr.object = builders.memberExpression(builders.identifier('instance'), rootMemberExpr.object);
-        }
-        return nodeClone;
+    else if (expression.type === 'Identifier') {
+        // e.g. `foo` -> scopeReferencedId is `foo`
+        scopeReferencedId = expression;
+    }
+    if (scopeReferencedId === null && !cxt.templateOptions.experimentalComplexExpressions) {
+        throw new Error(`Invalid expression, must be a MemberExpression or Identifier, found type="${expression.type}": \`${JSON.stringify(expression)}\``);
+    }
+    return cxt.isLocalVar(scopeReferencedId?.name)
+        ? expression
+        : expressionIrToEs(expression, cxt);
+}
+function getRootMemberExpression$1(node) {
+    return node.object.type === 'MemberExpression' ? getRootMemberExpression$1(node.object) : node;
+}
+function getRootIdentifier$1(node) {
+    const rootMemberExpression = getRootMemberExpression$1(node);
+    if (rootMemberExpression.object.type === 'Identifier') {
+        return rootMemberExpression.object;
     }
-    throw new Error(`Unimplemented expression: ${node.type}`);
+    throw new Error(`Invalid expression, must be an Identifier, found type="${rootMemberExpression.type}": \`${JSON.stringify(rootMemberExpression)}\``);
 }
 
 /*
@@ -1324,53 +1344,6 @@ function bAttributeValue(node, attrName) {
         return builders.memberExpression(builders.literal('instance'), nameAttrValue);
     }
 }
-function getRootMemberExpression$1(node) {
-    return node.object.type === 'MemberExpression' ? getRootMemberExpression$1(node.object) : node;
-}
-function getRootIdentifier$1(node, cxt) {
-    const rootMemberExpression = getRootMemberExpression$1(node);
-    if (is.identifier(rootMemberExpression.object)) {
-        return rootMemberExpression.object;
-    }
-    if (cxt.templateOptions.experimentalComplexExpressions) {
-        // TODO [#3370]: Implement complex template expressions
-        return null;
-    }
-    // Should be impossible to hit, at least until we implement complex template expressions
-    /* v8 ignore next */
-    throw new Error(`Invalid expression, must be an Identifier, found type="${rootMemberExpression.type}": \`${JSON.stringify(rootMemberExpression)}\``);
-}
-/**
- * Given an expression in a context, return an expression that may be scoped to that context.
- * For example, for the expression `foo`, it will typically be `instance.foo`, but if we're
- * inside a `for:each` block then the `foo` variable may refer to the scoped `foo`,
- * e.g. `<template for:each={foos} for:item="foo">`
- * @param expression
- * @param cxt
- */
-function getScopedExpression(expression, cxt) {
-    let scopeReferencedId = null;
-    if (is.memberExpression(expression)) {
-        // e.g. `foo.bar` -> scopeReferencedId is `foo`
-        scopeReferencedId = getRootIdentifier$1(expression, cxt);
-    }
-    else if (is.identifier(expression)) {
-        // e.g. `foo` -> scopeReferencedId is `foo`
-        scopeReferencedId = expression;
-    }
-    if (scopeReferencedId === null) {
-        if (cxt.templateOptions.experimentalComplexExpressions) {
-            // TODO [#3370]: Implement complex template expressions
-            return expression;
-        }
-        // Should be impossible to hit, at least until we implement complex template expressions
-        /* v8 ignore next */
-        throw new Error(`Invalid expression, must be a MemberExpression or Identifier, found type="${expression.type}": \`${JSON.stringify(expression)}\``);
-    }
-    return cxt.isLocalVar(scopeReferencedId.name)
-        ? expression
-        : builders.memberExpression(builders.identifier('instance'), expression);
-}
 function normalizeClassAttributeValue(value) {
     // @ts-expect-error weird indirection results in wrong overload being picked up
     return StringReplace.call(StringTrim.call(value), /\s+/g, ' ');
@@ -2597,9 +2570,11 @@ function compileTemplate(src, filename, options, compilationMode) {
     }
     const preserveComments = !!root.directives.find((directive) => directive.name === 'PreserveComments')?.value?.value;
     const experimentalComplexExpressions = Boolean(options.experimentalComplexExpressions);
+    const apiVersion = Number(options.apiVersion);
     const { addImport, getImports, statements, cxt } = templateIrToEsTree(root, {
         preserveComments,
         experimentalComplexExpressions,
+        apiVersion,
     });
     addImport(['renderStylesheets', 'hasScopedStaticStylesheets']);
     for (const [imports, source] of getStylesheetImports(filename)) {
@@ -2661,5 +2636,5 @@ function compileTemplateForSSR(src, filename, options, mode = DEFAULT_SSR_MODE)
 }
 
 export { compileComponentForSSR, compileTemplateForSSR };
-/** version: 8.22.3 */
+/** version: 8.22.5 */
 //# sourceMappingURL=index.js.map

package/package.json

@@ -4,7 +4,7 @@
         "You can safely modify dependencies, devDependencies, keywords, etc., but other props will be overwritten."
     ],
     "name": "@lwc/ssr-compiler",
-    "version": "8.22.3",
+    "version": "8.22.5",
     "description": "Compile component for use during server-side rendering",
     "keywords": [
         "compiler",
@@ -49,9 +49,9 @@
     },
     "dependencies": {
         "@babel/types": "7.28.4",
-        "@lwc/errors": "8.22.3",
-        "@lwc/shared": "8.22.3",
-        "@lwc/template-compiler": "8.22.3",
+        "@lwc/errors": "8.22.5",
+        "@lwc/shared": "8.22.5",
+        "@lwc/template-compiler": "8.22.5",
         "acorn": "8.15.0",
         "astring": "^1.9.0",
         "estree-toolkit": "^1.7.13",
@@ -59,7 +59,7 @@
         "meriyah": "^5.0.0"
     },
     "devDependencies": {
-        "@lwc/babel-plugin-component": "8.22.3",
+        "@lwc/babel-plugin-component": "8.22.5",
         "@types/estree": "^1.0.8"
     }
 }