@lwc/template-compiler 8.1.0 → 8.1.1

package/dist/index.cjs.js

@@ -68,8 +68,15 @@ function escapeScopeToken(input) {
     // in certain cases in attribute names
     return input.replace(/@/g, '___at___').replace(/#/g, '___hash___');
 }
-function generateScopeTokens(filename, namespace, name) {
-    const uniqueToken = `${namespace}-${name}_${path.basename(filename, path.extname(filename))}`;
+/**
+ * Generate the scope tokens for a given component. Note that this API is NOT stable and should be
+ * considered internal to the LWC framework.
+ * @param filename - full filename, e.g. `path/to/x/foo/foo.js`
+ * @param namespace - namespace, e.g. 'x' for `x/foo/foo.js`
+ * @param componentName - component name, e.g. 'foo' for `x/foo/foo.js`
+ */
+function generateScopeTokens(filename, namespace, componentName) {
+    const uniqueToken = `${namespace}-${componentName}_${path.basename(filename, path.extname(filename))}`;
     // This scope token is all lowercase so that it works correctly in case-sensitive namespaces (e.g. SVG).
     // It is deliberately designed to discourage people from relying on it by appearing somewhat random.
     // (But not totally random, because it's nice to have stable scope tokens for our own tests.)
@@ -13013,6 +13020,8 @@ function isStaticNode(node, apiVersion) {
     }
     // it is an element
     result &&= isElement(node);
+    // See W-16784305
+    result &&= node.name !== 'noframes';
     // all attrs are static-safe
     // the criteria to determine safety can be found in computeAttrValue
     result &&= attributes.every(({ name }) => {
@@ -13160,34 +13169,44 @@ function serializeAttrs(element, codeGen) {
     const attrs = [];
     let hasClassAttr = false;
     const collector = ({ name, value, hasExpression, hasSvgUseHref, needsScoping, }) => {
-        let v = typeof value === 'string' ? templateStringEscape(value) : value;
-        if (name === 'class') {
-            hasClassAttr = true;
-            // ${0} maps to class token that will be appended to the string.
-            // See buildParseFragmentFn for details.
-            // The token is only needed when the class attribute is static.
-            // The token will be injected at runtime for expressions in parseFragmentFn.
-            if (!hasExpression) {
-                if (typeof v === 'string') {
-                    v = normalizeWhitespace(v);
-                }
-                v += '${0}';
-            }
-        }
-        if (name === 'style' && !hasExpression && typeof v === 'string') {
-            v = normalizeStyleAttribute(v);
-        }
-        // `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');
+        // Do not serialize boolean class/style attribute (consistent with non-static optimized)
+        if (typeof value === 'boolean' && (name === 'class' || name === 'style')) {
+            return;
         }
         // See W-16614169
         const escapedAttributeName = templateStringEscape(name);
-        if (typeof v === 'string') {
+        if (typeof value === 'string') {
+            let v = templateStringEscape(value);
+            if (name === 'class') {
+                // ${0} maps to class token that will be appended to the string.
+                // See buildParseFragmentFn for details.
+                // The token is only needed when the class attribute is static.
+                // The token will be injected at runtime for expressions in parseFragmentFn.
+                if (!hasExpression) {
+                    v = normalizeWhitespace(v);
+                    if (v === '') {
+                        // Do not serialize empty class attribute (consistent with non-static optimized)
+                        return;
+                    }
+                    v += '${0}';
+                }
+                hasClassAttr = true;
+            }
+            // `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' && !hasExpression) {
+                v = String(v.toLowerCase() !== 'false');
+            }
+            if (name === 'style' && !hasExpression) {
+                v = normalizeStyleAttribute(v);
+                if (v === '') {
+                    // Do not serialize empty style attribute (consistent with non-static optimized)
+                    return;
+                }
+            }
             // IDs/IDRefs must be handled dynamically at runtime due to synthetic shadow scoping.
             // Skip serializing here and handle it as if it were a dynamic attribute instead.
             // Note that, to maintain backwards compatibility with the non-static output, we treat the valueless
@@ -14770,8 +14789,9 @@ function compile(source, filename, config) {
 
 exports.compile = compile;
 exports.default = compile;
+exports.generateScopeTokens = generateScopeTokens;
 exports.kebabcaseToCamelcase = kebabcaseToCamelcase;
 exports.parse = parse;
 exports.toPropertyName = toPropertyName;
-/** version: 8.1.0 */
+/** version: 8.1.1 */
 //# sourceMappingURL=index.cjs.js.map