@lwc/template-compiler 8.1.0 → 8.1.2

package/dist/index.d.ts

@@ -5,6 +5,7 @@ export { CustomRendererConfig, CustomRendererElementConfig } from './shared/rend
 export { Config } from './config';
 export { toPropertyName } from './shared/utils';
 export { kebabcaseToCamelcase } from './shared/naming';
+export { generateScopeTokens } from './scopeTokens';
 /**
  * Parses HTML markup into an AST
  * @param source HTML markup to parse

package/dist/index.js

@@ -44,8 +44,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.)
@@ -12921,7 +12928,7 @@ function generateStylesheetTokens(codeGen) {
     return styleTokens;
 }
 const DECLARATION_DELIMITER = /;(?![^(]*\))/g;
-const PROPERTY_DELIMITER = /:(.+)/;
+const PROPERTY_DELIMITER = /:(.+)/s; // `/s` (dotAll) required to match styles across newlines, e.g. `color: \n red;`
 // Borrowed from Vue template compiler.
 // https://github.com/vuejs/vue/blob/531371b818b0e31a989a06df43789728f23dc4e8/src/platforms/web/util/style.js#L5-L16
 function parseStyleText(cssText) {
@@ -12989,6 +12996,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 }) => {
@@ -13136,34 +13145,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
@@ -14744,6 +14763,6 @@ function compile(source, filename, config) {
     };
 }
 
-export { ElementDirectiveName, LWCDirectiveDomMode, LWCDirectiveRenderMode, LwcTagName, RootDirectiveName, TemplateDirectiveName, compile, compile as default, kebabcaseToCamelcase, parse, toPropertyName };
-/** version: 8.1.0 */
+export { ElementDirectiveName, LWCDirectiveDomMode, LWCDirectiveRenderMode, LwcTagName, RootDirectiveName, TemplateDirectiveName, compile, compile as default, generateScopeTokens, kebabcaseToCamelcase, parse, toPropertyName };
+/** version: 8.1.2 */
 //# sourceMappingURL=index.js.map