@lwc/template-compiler 7.0.1-alpha.0 → 7.0.1

package/dist/index.js

@@ -10888,6 +10888,138 @@ function validateExpressionAst(rootNode) {
     });
 }
 
+/*
+ * Copyright (c) 2018, 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
+ */
+// https://262.ecma-international.org/12.0/#sec-keywords-and-reserved-words
+// prettier-ignore
+const REVERSED_KEYWORDS = new Set([
+    // Reserved keywords
+    'await', 'break', 'case', 'catch', 'class', 'const', 'continue', 'debugger', 'default', 'delete',
+    'do', 'else', 'enum', 'export', 'extends', 'false', 'finally', 'for', 'function', 'if', 'import',
+    'in', 'instanceof', 'new', 'null', 'return', 'super', 'switch', 'this', 'throw', 'true', 'try',
+    'typeof', 'var', 'void', 'while', 'with', 'yield',
+    // Strict mode only reserved keywords
+    'let', 'static', 'implements', 'interface', 'package', 'private', 'protected', 'public'
+]);
+function isReservedES6Keyword(str) {
+    return REVERSED_KEYWORDS.has(str);
+}
+
+/*
+ * Copyright (c) 2018, 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
+ */
+const EXPRESSION_SYMBOL_START = '{';
+const EXPRESSION_SYMBOL_END = '}';
+const POTENTIAL_EXPRESSION_RE = /^.?{.+}.*$/;
+const WHITESPACES_RE = /\s/;
+function isExpression(source) {
+    // Issue #3418: Legacy behavior, previous regex treated "{}" attribute value as non expression
+    return source[0] === '{' && source.slice(-1) === '}' && source.length > 2;
+}
+function isPotentialExpression(source) {
+    return !!source.match(POTENTIAL_EXPRESSION_RE);
+}
+function validateExpression(node, config) {
+    // TODO [#3370]: remove experimental template expression flag
+    if (config.experimentalComplexExpressions) {
+        return validateExpressionAst(node);
+    }
+    const isValidNode = isIdentifier(node) || isMemberExpression(node);
+    invariant(isValidNode, ParserDiagnostics.INVALID_NODE, [node.type]);
+    if (isMemberExpression(node)) {
+        invariant(config.experimentalComputedMemberExpression || !node.computed, ParserDiagnostics.COMPUTED_PROPERTY_ACCESS_NOT_ALLOWED);
+        const { object, property } = node;
+        if (!isIdentifier(object)) {
+            validateExpression(object, config);
+        }
+        if (!isIdentifier(property)) {
+            validateExpression(property, config);
+        }
+    }
+}
+function validateSourceIsParsedExpression(source, parsedExpression) {
+    if (parsedExpression.end === source.length - 1) {
+        return;
+    }
+    let unclosedParenthesisCount = 0;
+    for (let i = 0, n = parsedExpression.start; i < n; i++) {
+        if (source[i] === '(') {
+            unclosedParenthesisCount++;
+        }
+    }
+    // source[source.length - 1] === '}', n = source.length - 1 is to avoid processing '}'.
+    for (let i = parsedExpression.end, n = source.length - 1; i < n; i++) {
+        const character = source[i];
+        if (character === ')') {
+            unclosedParenthesisCount--;
+        }
+        else if (character === ';') {
+            // acorn parseExpressionAt will stop at the first ";", it may be that the expression is not
+            // a multiple expression ({foo;}), but this is a case that we explicitly do not want to support.
+            // in such case, let's fail with the same error as if it were a multiple expression.
+            invariant(false, ParserDiagnostics.MULTIPLE_EXPRESSIONS);
+        }
+        else {
+            invariant(WHITESPACES_RE.test(character), ParserDiagnostics.TEMPLATE_EXPRESSION_PARSING_ERROR, ['Unexpected end of expression']);
+        }
+    }
+    invariant(unclosedParenthesisCount === 0, ParserDiagnostics.TEMPLATE_EXPRESSION_PARSING_ERROR, [
+        'Unexpected end of expression',
+    ]);
+}
+function validatePreparsedJsExpressions(ctx) {
+    ctx.preparsedJsExpressions?.forEach(({ parsedExpression, rawText }) => {
+        const acornLoc = parsedExpression.loc;
+        const parse5Loc = {
+            startLine: acornLoc.start.line,
+            startCol: acornLoc.start.column,
+            startOffset: parsedExpression.start,
+            endLine: acornLoc.end.line,
+            endCol: acornLoc.end.column,
+            endOffset: parsedExpression.end,
+        };
+        ctx.withErrorWrapping(() => {
+            validateExpressionAst(parsedExpression);
+        }, ParserDiagnostics.TEMPLATE_EXPRESSION_PARSING_ERROR, sourceLocation(parse5Loc), (err) => `Invalid expression ${rawText} - ${err.message}`);
+    });
+}
+function parseExpression(ctx, source, location) {
+    const { ecmaVersion } = ctx;
+    return ctx.withErrorWrapping(() => {
+        const parsed = parseExpressionAt(source, 1, {
+            ecmaVersion,
+            // TODO [#3370]: remove experimental template expression flag
+            allowAwaitOutsideFunction: ctx.config.experimentalComplexExpressions,
+        });
+        validateSourceIsParsedExpression(source, parsed);
+        validateExpression(parsed, ctx.config);
+        return { ...parsed, location };
+    }, ParserDiagnostics.TEMPLATE_EXPRESSION_PARSING_ERROR, location, (err) => `Invalid expression ${source} - ${err.message}`);
+}
+function parseIdentifier(ctx, source, location) {
+    let isValid = true;
+    isValid = isIdentifierStart(source.charCodeAt(0));
+    for (let i = 1; i < source.length && isValid; i++) {
+        isValid = isIdentifierChar(source.charCodeAt(i));
+    }
+    if (isValid && !isReservedES6Keyword(source)) {
+        return {
+            ...identifier(source),
+            location,
+        };
+    }
+    else {
+        ctx.throwAtLocation(ParserDiagnostics.INVALID_IDENTIFIER, location, [source]);
+    }
+}
+
 /*
  * Copyright (c) 2023, salesforce.com, inc.
  * All rights reserved.
@@ -11045,17 +11177,19 @@ class TemplateHtmlTokenizer extends Tokenizer {
         }
     }
 }
-function isTemplateExpressionTextNodeValue(value) {
-    return value?.[0] === '{';
-}
 function isTemplateElement(node) {
     return node.nodeName === 'template';
 }
 function isTextNode(node) {
     return node?.nodeName === '#text';
 }
-function isTemplateExpressionTextNode(node) {
-    return isTextNode(node) && isTemplateExpressionTextNodeValue(node.value);
+function isTemplateExpressionTextNode(node, html) {
+    return (isTextNode(node) &&
+        isTemplateExpressionTextNodeValue(node.value, node.sourceCodeLocation.startOffset, html));
+}
+function isTemplateExpressionTextNodeValue(value, startOffset, html) {
+    return (value.startsWith(EXPRESSION_SYMBOL_START) &&
+        html.startsWith(EXPRESSION_SYMBOL_START, startOffset));
 }
 /**
  * This class extends `parse5`'s internal parser. The heavy lifting is
@@ -11077,11 +11211,12 @@ class TemplateHtmlParser extends Parser {
     _insertCharacters(token) {
         const parentNode = this.openElements.current;
         const previousPeer = parentNode.childNodes.at(-1);
+        const html = this.tokenizer.preprocessor.html;
         if (
         // If we're not dealing with a template expression...
-        !isTemplateExpressionTextNodeValue(token.chars) &&
+        !isTemplateExpressionTextNodeValue(token.chars, token.location.startOffset, html) &&
             // ... and the previous node wasn't a text-node-template-expression...
-            !isTemplateExpressionTextNode(previousPeer)) {
+            !isTemplateExpressionTextNode(previousPeer, html)) {
             // ... concatenate the provided characters with the previous token's characters.
             return super._insertCharacters(token);
         }
@@ -11201,138 +11336,6 @@ function decodeTextContent(source) {
     return he.decode(source);
 }
 
-/*
- * Copyright (c) 2018, 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
- */
-// https://262.ecma-international.org/12.0/#sec-keywords-and-reserved-words
-// prettier-ignore
-const REVERSED_KEYWORDS = new Set([
-    // Reserved keywords
-    'await', 'break', 'case', 'catch', 'class', 'const', 'continue', 'debugger', 'default', 'delete',
-    'do', 'else', 'enum', 'export', 'extends', 'false', 'finally', 'for', 'function', 'if', 'import',
-    'in', 'instanceof', 'new', 'null', 'return', 'super', 'switch', 'this', 'throw', 'true', 'try',
-    'typeof', 'var', 'void', 'while', 'with', 'yield',
-    // Strict mode only reserved keywords
-    'let', 'static', 'implements', 'interface', 'package', 'private', 'protected', 'public'
-]);
-function isReservedES6Keyword(str) {
-    return REVERSED_KEYWORDS.has(str);
-}
-
-/*
- * Copyright (c) 2018, 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
- */
-const EXPRESSION_SYMBOL_START = '{';
-const EXPRESSION_SYMBOL_END = '}';
-const POTENTIAL_EXPRESSION_RE = /^.?{.+}.*$/;
-const WHITESPACES_RE = /\s/;
-function isExpression(source) {
-    // Issue #3418: Legacy behavior, previous regex treated "{}" attribute value as non expression
-    return source[0] === '{' && source.slice(-1) === '}' && source.length > 2;
-}
-function isPotentialExpression(source) {
-    return !!source.match(POTENTIAL_EXPRESSION_RE);
-}
-function validateExpression(node, config) {
-    // TODO [#3370]: remove experimental template expression flag
-    if (config.experimentalComplexExpressions) {
-        return validateExpressionAst(node);
-    }
-    const isValidNode = isIdentifier(node) || isMemberExpression(node);
-    invariant(isValidNode, ParserDiagnostics.INVALID_NODE, [node.type]);
-    if (isMemberExpression(node)) {
-        invariant(config.experimentalComputedMemberExpression || !node.computed, ParserDiagnostics.COMPUTED_PROPERTY_ACCESS_NOT_ALLOWED);
-        const { object, property } = node;
-        if (!isIdentifier(object)) {
-            validateExpression(object, config);
-        }
-        if (!isIdentifier(property)) {
-            validateExpression(property, config);
-        }
-    }
-}
-function validateSourceIsParsedExpression(source, parsedExpression) {
-    if (parsedExpression.end === source.length - 1) {
-        return;
-    }
-    let unclosedParenthesisCount = 0;
-    for (let i = 0, n = parsedExpression.start; i < n; i++) {
-        if (source[i] === '(') {
-            unclosedParenthesisCount++;
-        }
-    }
-    // source[source.length - 1] === '}', n = source.length - 1 is to avoid processing '}'.
-    for (let i = parsedExpression.end, n = source.length - 1; i < n; i++) {
-        const character = source[i];
-        if (character === ')') {
-            unclosedParenthesisCount--;
-        }
-        else if (character === ';') {
-            // acorn parseExpressionAt will stop at the first ";", it may be that the expression is not
-            // a multiple expression ({foo;}), but this is a case that we explicitly do not want to support.
-            // in such case, let's fail with the same error as if it were a multiple expression.
-            invariant(false, ParserDiagnostics.MULTIPLE_EXPRESSIONS);
-        }
-        else {
-            invariant(WHITESPACES_RE.test(character), ParserDiagnostics.TEMPLATE_EXPRESSION_PARSING_ERROR, ['Unexpected end of expression']);
-        }
-    }
-    invariant(unclosedParenthesisCount === 0, ParserDiagnostics.TEMPLATE_EXPRESSION_PARSING_ERROR, [
-        'Unexpected end of expression',
-    ]);
-}
-function validatePreparsedJsExpressions(ctx) {
-    ctx.preparsedJsExpressions?.forEach(({ parsedExpression, rawText }) => {
-        const acornLoc = parsedExpression.loc;
-        const parse5Loc = {
-            startLine: acornLoc.start.line,
-            startCol: acornLoc.start.column,
-            startOffset: parsedExpression.start,
-            endLine: acornLoc.end.line,
-            endCol: acornLoc.end.column,
-            endOffset: parsedExpression.end,
-        };
-        ctx.withErrorWrapping(() => {
-            validateExpressionAst(parsedExpression);
-        }, ParserDiagnostics.TEMPLATE_EXPRESSION_PARSING_ERROR, sourceLocation(parse5Loc), (err) => `Invalid expression ${rawText} - ${err.message}`);
-    });
-}
-function parseExpression(ctx, source, location) {
-    const { ecmaVersion } = ctx;
-    return ctx.withErrorWrapping(() => {
-        const parsed = parseExpressionAt(source, 1, {
-            ecmaVersion,
-            // TODO [#3370]: remove experimental template expression flag
-            allowAwaitOutsideFunction: ctx.config.experimentalComplexExpressions,
-        });
-        validateSourceIsParsedExpression(source, parsed);
-        validateExpression(parsed, ctx.config);
-        return { ...parsed, location };
-    }, ParserDiagnostics.TEMPLATE_EXPRESSION_PARSING_ERROR, location, (err) => `Invalid expression ${source} - ${err.message}`);
-}
-function parseIdentifier(ctx, source, location) {
-    let isValid = true;
-    isValid = isIdentifierStart(source.charCodeAt(0));
-    for (let i = 1; i < source.length && isValid; i++) {
-        isValid = isIdentifierChar(source.charCodeAt(i));
-    }
-    if (isValid && !isReservedES6Keyword(source)) {
-        return {
-            ...identifier(source),
-            location,
-        };
-    }
-    else {
-        ctx.throwAtLocation(ParserDiagnostics.INVALID_IDENTIFIER, location, [source]);
-    }
-}
-
 /*
  * Copyright (c) 2018, salesforce.com, inc.
  * All rights reserved.
@@ -12985,7 +12988,6 @@ function isStaticNode(node, apiVersion) {
             name !== 'slot' &&
             // check for ScopedId
             name !== 'id' &&
-            name !== 'spellcheck' && // spellcheck is specially handled by the vnodes.
             !isIdReferencingAttribute(name) &&
             // svg href needs sanitization.
             !isSvgUseHref(nodeName, name, namespace) &&
@@ -13147,6 +13149,14 @@ function serializeAttrs(element, codeGen) {
                 v += '${0}';
             }
         }
+        // `spellcheck` string values are specially handled to massage them into booleans.
+        // For backwards compat with non-static-optimized templates, we also treat any non-`"false"`
+        // value other than the valueless format (e.g. `<div spellcheck>`) as `"true"`,
+        // even though per MDN, the empty string and `"true"` are equivalent:
+        // https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/spellcheck
+        if (name === 'spellcheck' && typeof v === 'string' && !hasExpression) {
+            v = String(v.toLowerCase() !== 'false');
+        }
         if (typeof v === 'string') {
             // Inject a placeholder where the staticPartId will go when an expression occurs.
             // This is only needed for SSR to inject the expression value during serialization.
@@ -13577,7 +13587,7 @@ class CodeGen {
     }
     genClassExpression(value) {
         let classExpression = this.bindExpression(value);
-        const isClassNameObjectBindingEnabled = isAPIFeatureEnabled(11 /* APIFeature.TEMPLATE_CLASS_NAME_OBJECT_BINDING */, this.state.config.apiVersion);
+        const isClassNameObjectBindingEnabled = isAPIFeatureEnabled(10 /* APIFeature.TEMPLATE_CLASS_NAME_OBJECT_BINDING */, this.state.config.apiVersion);
         if (isClassNameObjectBindingEnabled) {
             classExpression = this.genNormalizeClassName(classExpression);
         }
@@ -13691,6 +13701,7 @@ class CodeGen {
         const callExpression$1 = callExpression(identifier$1, params);
         // Check if the property actually exists before calling, to allow
         // for older engines to work with newer compilers
+        // TODO [#4313]: remove temporary logic to support v7 compiler + v6 engine
         return fallbackForCompilerEngineVersionMismatch
             ? conditionalExpression(identifier$1, callExpression$1, fallbackForCompilerEngineVersionMismatch)
             : callExpression$1;
@@ -14378,6 +14389,7 @@ function transform(codeGen) {
             if (attrName === 'id') {
                 return codeGen.genScopedId(attrValue.value);
             }
+            // `spellcheck` string values are specially handled to massage them into booleans.
             if (attrName === 'spellcheck') {
                 return literal$1(attrValue.value.toLowerCase() !== 'false');
             }
@@ -14640,5 +14652,5 @@ function compile(source, filename, config) {
 }
 
 export { ElementDirectiveName, LWCDirectiveDomMode, LWCDirectiveRenderMode, LwcTagName, RootDirectiveName, TemplateDirectiveName, compile, compile as default, kebabcaseToCamelcase, parse, toPropertyName };
-/** version: 7.0.0 */
+/** version: 7.0.1 */
 //# sourceMappingURL=index.js.map