@lwc/template-compiler 6.4.1 → 6.4.3

package/dist/codegen/static-element.d.ts

@@ -1,5 +1,7 @@
 import { ChildNode, Root, StaticElement, StaticChildNode, Text } from '../shared/types';
 import State from '../state';
 export declare function getStaticNodes(root: Root, state: State): Set<ChildNode>;
-export declare function transformStaticChildren(elm: StaticElement): (StaticChildNode | Text[])[];
-export declare const isDynamicText: (nodes: StaticChildNode | StaticChildNode[]) => nodes is Text[];
+export declare function transformStaticChildren(elm: StaticElement, preserveComments: boolean): (StaticChildNode | Text[])[];
+export declare const isContiguousText: (staticChild: StaticChildNode | Text[]) => staticChild is Text[];
+export declare const isTextExpression: (node: ChildNode) => boolean;
+export declare const hasDynamicText: (nodes: Text[]) => boolean;

package/dist/index.cjs.js

@@ -12675,7 +12675,7 @@ function collectStaticNodes(node, staticNodes, state) {
             childrenAreStaticSafe &&= staticNodes.has(childNode);
             // Collect nodes that have dynamic text ahead of time.
             // We only need to know if the direct child has dynamic text.
-            hasDynamicText ||= isText(childNode) && !isStringLiteral(childNode.value);
+            hasDynamicText ||= isTextExpression(childNode);
         });
         // for IfBlock and ElseifBlock, traverse down the else branch
         if (isConditionalParentBlock(node) && node.else) {
@@ -12703,62 +12703,57 @@ function getStaticNodes(root, state) {
     });
     return staticNodes;
 }
-// The purpose of this function is to concatenate the contiguous text nodes into a single array
+// The purpose of this function is to concatenate contiguous text nodes into a single array
 // to simplify the traversing logic when generating static parts and serializing the element.
-function transformStaticChildren(elm) {
+// Note, comments that are adjacent to text nodes are ignored when preserveComments is false,
+// ex: <span>{dynamic}<!-- comment -->text</span>
+// preserveComments = false => [[text, text]]
+// preserveComments = true => [[text], comment, [text]]
+function transformStaticChildren(elm, preserveComments) {
     const children = elm.children;
     if (!children.length || !STATIC_ELEMENT_WITH_DYNAMIC_TEXT_SET.has(elm)) {
         // The element either has no children or its children does not contain dynamic text.
         return children;
     }
     if (STATIC_ELEMENT_TO_DYNAMIC_TEXT_CHILDREN_CACHE.has(elm)) {
+        // This will be hit by serializeStaticElement
         return STATIC_ELEMENT_TO_DYNAMIC_TEXT_CHILDREN_CACHE.get(elm);
     }
     const result = [];
     const len = children.length;
     let current;
-    let next;
     let contiguousTextNodes = null;
     for (let i = 0; i < len; i++) {
         current = children[i];
-        if (!isText(current)) {
-            contiguousTextNodes = null;
-            result.push(current);
-        }
-        else {
+        if (isText(current)) {
             if (!shared.isNull(contiguousTextNodes)) {
                 // Already in a contiguous text node chain
                 // All contiguous nodes represent an expression in the source, it's guaranteed by the parser.
                 contiguousTextNodes.push(current);
             }
             else {
-                next = children[i + 1];
-                if (isExpression$1(current) || (!shared.isUndefined(next) && isText(next))) {
-                    // Text nodes can appear as follows:
-                    // 1. A single text literal node.
-                    // 2. A single text expression node.
-                    // 3. Contiguous series of text nodes (literal/expression mixed) with at least 1 expression.
-                    // When there is an expression in the source, the text nodes are split into contiguous text nodes.
-                    // When there is no expression in the source, the text will appear as a single text literal.
-                    // We normalize all of the contiguous text nodes or single text expression to an array.
-                    // Single text literal nodes (no expression or are not part of a contiguous set of text nodes) remain text nodes
-                    // and will not be consolidated to an array.
-                    // This is to normalize the traversal behavior when creating static parts and when serializing
-                    // the elements.
-                    contiguousTextNodes = [current];
-                }
-                // When contiguousTextNodes is null it is a single string literal.
-                result.push(contiguousTextNodes ?? current);
+                // First time seeing a contiguous text chain
+                contiguousTextNodes = [current];
+                result.push(contiguousTextNodes);
+            }
+        }
+        else {
+            // Non-text nodes signal the end of contiguous text node chain
+            if (!isComment(current) || preserveComments) {
+                // Ignore comment nodes when preserveComments is false
+                contiguousTextNodes = null;
+                result.push(current);
             }
         }
     }
     STATIC_ELEMENT_TO_DYNAMIC_TEXT_CHILDREN_CACHE.set(elm, result);
     return result;
 }
-// Dynamic text is consolidated from individual text arrays into a single Text[].
-// Static text = a single text literal node (not in an array).
-// Dynamic text = At least 1 text expression node + 0 or more text literal nodes (always in an array).
-const isDynamicText = (nodes) => shared.isArray(nodes) && shared.ArrayEvery.call(nodes, isText);
+// Given a static child, determines wether the child is a contiguous text node.
+// Note this is intended to be used with children generated from transformStaticChildren
+const isContiguousText = (staticChild) => shared.isArray(staticChild) && shared.ArrayEvery.call(staticChild, isText);
+const isTextExpression = (node) => isText(node) && !isStringLiteral(node.value);
+const hasDynamicText = (nodes) => shared.ArraySome.call(nodes, isTextExpression);
 
 /*
  * Copyright (c) 2018, salesforce.com, inc.
@@ -12843,12 +12838,14 @@ function serializeAttrs(element, codeGen) {
     // See buildParseFragmentFn for details.
     return attrs.join('') + (hasClassAttr ? '${2}' : '${3}');
 }
-function serializeChildren(node, parentTagName, codeGen) {
+function serializeChildren(children, parentTagName, codeGen) {
     let html = '';
-    for (const child of transformStaticChildren(node)) {
-        /* istanbul ignore else  */
-        if (isDynamicText(child)) {
-            html += serializeDynamicTextNode(child, codeGen);
+    for (const child of children) {
+        /* istanbul ignore else */
+        if (isContiguousText(child)) {
+            html += hasDynamicText(child)
+                ? serializeDynamicTextNode(child, codeGen)
+                : serializeChildren(child, parentTagName, codeGen);
         }
         else if (isText(child)) {
             html += serializeStaticTextNode(child, rawContentElements.has(parentTagName.toUpperCase()));
@@ -12894,7 +12891,8 @@ function serializeStaticElement(element, codeGen) {
         return html;
     }
     html += '>';
-    html += serializeChildren(element, tagName, codeGen);
+    const children = transformStaticChildren(element, codeGen.preserveComments);
+    html += serializeChildren(children, tagName, codeGen);
     if (!shared.isVoidElement(tagName, namespace) || hasChildren) {
         html += `</${tagName}>`;
     }
@@ -13464,17 +13462,19 @@ class CodeGen {
         while (stack.length > 0) {
             const current = stack.shift();
             // Skip comment nodes in parts count, as they will be stripped in production, unless when `lwc:preserve-comments` is enabled
-            if (isDynamicText(current) || !isComment(current) || this.preserveComments) {
+            if (isContiguousText(current) || !isComment(current) || this.preserveComments) {
                 partId++;
             }
-            if (isDynamicText(current)) {
+            if (isContiguousText(current)) {
                 const textNodes = current;
-                const partToken = `${"t" /* STATIC_PART_TOKEN_ID.TEXT */}${partId}`;
-                // Use the first text node as the key.
-                // Dynamic text is guaranteed to have at least 1 text node in the array by transformStaticChildren.
-                this.staticExpressionMap.set(textNodes[0], partToken);
-                const concatenatedText = this.genConcatenatedText(textNodes.map(({ value }) => isStringLiteral(value) ? value.value : this.bindExpression(value)));
-                setPartIdText(concatenatedText);
+                if (hasDynamicText(textNodes)) {
+                    const partToken = `${"t" /* STATIC_PART_TOKEN_ID.TEXT */}${partId}`;
+                    // Use the first text node as the key.
+                    // Dynamic text is guaranteed to have at least 1 text node in the array by transformStaticChildren.
+                    this.staticExpressionMap.set(textNodes[0], partToken);
+                    const concatenatedText = this.genConcatenatedText(textNodes.map(({ value }) => isStringLiteral(value) ? value.value : this.bindExpression(value)));
+                    setPartIdText(concatenatedText);
+                }
             }
             else if (isElement(current)) {
                 const elm = current;
@@ -13520,7 +13520,7 @@ class CodeGen {
                 // For depth-first traversal, children must be prepended in order, so that they are processed before
                 // siblings. Note that this is consistent with the order used in the diffing algo as well as
                 // `traverseAndSetElements` in @lwc/engine-core.
-                stack.unshift(...transformStaticChildren(elm));
+                stack.unshift(...transformStaticChildren(elm, this.preserveComments));
             }
         }
         if (partIdsToArgs.size === 0) {
@@ -14245,5 +14245,5 @@ function compile(source, config) {
 exports.compile = compile;
 exports.default = compile;
 exports.parse = parse;
-/** version: 6.4.1 */
+/** version: 6.4.3 */
 //# sourceMappingURL=index.cjs.js.map