@lwc/ssr-runtime 8.6.0 → 8.7.0

package/dist/index.js

@@ -295,8 +295,18 @@ from: ArrayFrom, } = Array;
 // statement, rather than this declaration.
 const { concat: ArrayConcat, copyWithin: ArrayCopyWithin, every: ArrayEvery, fill: ArrayFill, filter: ArrayFilter, find: ArrayFind, findIndex: ArrayFindIndex, includes: ArrayIncludes, indexOf: ArrayIndexOf, join: ArrayJoin, map: ArrayMap, pop: ArrayPop, push: ArrayPush, reduce: ArrayReduce, reverse: ArrayReverse, shift: ArrayShift, slice: ArraySlice, some: ArraySome, sort: ArraySort, splice: ArraySplice, unshift: ArrayUnshift, forEach, // Weird anomaly!
  } = Array.prototype;
+/** Detached {@linkcode String.fromCharCode}; see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/fromCharCode MDN Reference}. */
+const { fromCharCode: StringFromCharCode } = String;
 // No JSDocs here - see comment for Array.prototype
 const { charAt: StringCharAt, charCodeAt: StringCharCodeAt, replace: StringReplace, split: StringSplit, slice: StringSlice, toLowerCase: StringToLowerCase, trim: StringTrim, } = String.prototype;
+/**
+ * Determines whether the argument is `undefined`.
+ * @param obj Value to test
+ * @returns `true` if the value is `undefined`.
+ */
+function isUndefined(obj) {
+    return obj === undefined;
+}
 /**
  * Determines whether the argument is `null`.
  * @param obj Value to test
@@ -305,6 +315,14 @@ const { charAt: StringCharAt, charCodeAt: StringCharCodeAt, replace: StringRepla
 function isNull(obj) {
     return obj === null;
 }
+/**
+ * Determines whether the argument is an object or null.
+ * @param obj Value to test
+ * @returns `true` if the value is an object or null.
+ */
+function isObject(obj) {
+    return typeof obj === 'object';
+}
 const OtS = {}.toString;
 /**
  * Converts the argument to a string, safely accounting for objects with "null" prototype.
@@ -419,11 +437,114 @@ const { AriaAttrNameToPropNameMap, AriaPropNameToAttrNameMap } = /*@__PURE__*/ (
     // Synthetic creation of all AOM property descriptors for Custom Elements
     forEach.call(AriaPropertyNames, (propName) => {
         const attrName = StringToLowerCase.call(StringReplace.call(propName, /^aria/, () => 'aria-'));
+        // These type assertions are because the map types are a 1:1 mapping of ariaX to aria-x.
+        // TypeScript knows we have one of ariaX | ariaY and one of aria-x | aria-y, and tries to
+        // prevent us from doing ariaX: aria-y, but we that it's safe.
         AriaAttrNameToPropNameMap[attrName] = propName;
         AriaPropNameToAttrNameMap[propName] = attrName;
     });
     return { AriaAttrNameToPropNameMap, AriaPropNameToAttrNameMap };
 })();
+/**
+ *
+ * @param attrName
+ */
+function isAriaAttribute(attrName) {
+    return attrName in AriaAttrNameToPropNameMap;
+}
+// This list is based on https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes
+const GLOBAL_ATTRIBUTE = /*@__PURE__*/ new Set([
+    'accesskey',
+    'autocapitalize',
+    'autofocus',
+    'class',
+    'contenteditable',
+    'contextmenu',
+    'dir',
+    'draggable',
+    'enterkeyhint',
+    'exportparts',
+    'hidden',
+    'id',
+    'inputmode',
+    'is',
+    'itemid',
+    'itemprop',
+    'itemref',
+    'itemscope',
+    'itemtype',
+    'lang',
+    'nonce',
+    'part',
+    'slot',
+    'spellcheck',
+    'style',
+    'tabindex',
+    'title',
+    'translate',
+]);
+/**
+ *
+ * @param attrName
+ */
+function isGlobalHtmlAttribute(attrName) {
+    return GLOBAL_ATTRIBUTE.has(attrName);
+}
+// These are HTML standard prop/attribute IDL mappings, but are not predictable based on camel/kebab-case conversion
+const SPECIAL_PROPERTY_ATTRIBUTE_MAPPING = /*@__PURE__@*/ new Map([
+    ['accessKey', 'accesskey'],
+    ['readOnly', 'readonly'],
+    ['tabIndex', 'tabindex'],
+    ['bgColor', 'bgcolor'],
+    ['colSpan', 'colspan'],
+    ['rowSpan', 'rowspan'],
+    ['contentEditable', 'contenteditable'],
+    ['crossOrigin', 'crossorigin'],
+    ['dateTime', 'datetime'],
+    ['formAction', 'formaction'],
+    ['isMap', 'ismap'],
+    ['maxLength', 'maxlength'],
+    ['minLength', 'minlength'],
+    ['noValidate', 'novalidate'],
+    ['useMap', 'usemap'],
+    ['htmlFor', 'for'],
+]);
+/**
+ * Map associating previously transformed HTML property into HTML attribute.
+ */
+const CACHED_PROPERTY_ATTRIBUTE_MAPPING = /*@__PURE__@*/ new Map();
+/**
+ *
+ * @param propName
+ */
+function htmlPropertyToAttribute(propName) {
+    const ariaAttributeName = AriaPropNameToAttrNameMap[propName];
+    if (!isUndefined(ariaAttributeName)) {
+        return ariaAttributeName;
+    }
+    const specialAttributeName = SPECIAL_PROPERTY_ATTRIBUTE_MAPPING.get(propName);
+    if (!isUndefined(specialAttributeName)) {
+        return specialAttributeName;
+    }
+    const cachedAttributeName = CACHED_PROPERTY_ATTRIBUTE_MAPPING.get(propName);
+    if (!isUndefined(cachedAttributeName)) {
+        return cachedAttributeName;
+    }
+    let attributeName = '';
+    for (let i = 0, len = propName.length; i < len; i++) {
+        const code = StringCharCodeAt.call(propName, i);
+        if (code >= 65 && // "A"
+            code <= 90 // "Z"
+        ) {
+            attributeName += '-' + StringFromCharCode(code + 32);
+        }
+        else {
+            attributeName += StringFromCharCode(code);
+        }
+    }
+    CACHED_PROPERTY_ATTRIBUTE_MAPPING.set(propName, attributeName);
+    return attributeName;
+}
 
 /*
  * Copyright (c) 2020, salesforce.com, inc.
@@ -482,7 +603,7 @@ function flattenStylesheets(stylesheets) {
     }
     return list;
 }
-/** version: 8.6.0 */
+/** version: 8.7.0 */
 
 /*
  * Copyright (c) 2024, Salesforce, Inc.
@@ -643,21 +764,25 @@ const mutationTracker = new MutationTracker();
  * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
  */
 /**
- * Map of global attribute or ARIA attribute to the corresponding property name.
- * Not all global attributes are included, just those from `HTMLElementTheGoodParts`.
+ * Filters out the following types of properties that should not be set.
+ * - Properties that are not public.
+ * - Properties that are not global.
+ * - Properties that are global but are internally overridden.
  */
-const attrsToProps = assign(create(null), {
-    accesskey: 'accessKey',
-    dir: 'dir',
-    draggable: 'draggable',
-    hidden: 'hidden',
-    id: 'id',
-    lang: 'lang',
-    spellcheck: 'spellcheck',
-    tabindex: 'tabIndex',
-    title: 'title',
-    ...AriaAttrNameToPropNameMap,
-});
+function filterProperties(props, publicFields, privateFields) {
+    const propsToAssign = create(null);
+    const publicFieldSet = new Set(publicFields);
+    const privateFieldSet = new Set(privateFields);
+    keys(props).forEach((propName) => {
+        const attrName = htmlPropertyToAttribute(propName);
+        if (publicFieldSet.has(propName) ||
+            ((isGlobalHtmlAttribute(attrName) || isAriaAttribute(attrName)) &&
+                !privateFieldSet.has(propName))) {
+            propsToAssign[propName] = props[propName];
+        }
+    });
+    return propsToAssign;
+}
 /**
  * Descriptor for IDL attribute reflections that merely reflect the string, e.g. `title`.
  */
@@ -738,16 +863,6 @@ const ariaDescriptor = (attrName) => ({
         }
     },
 });
-function reflectAttrToProp(instance, attrName, attrValue) {
-    const reflectedPropName = attrsToProps[attrName];
-    // If it is a reflected property and it was not overridden by the instance
-    if (reflectedPropName && !hasOwnProperty.call(instance, reflectedPropName)) {
-        const currentValue = instance[reflectedPropName];
-        if (currentValue !== attrValue) {
-            instance[reflectedPropName] = attrValue;
-        }
-    }
-}
 const descriptors = {
     accessKey: stringDescriptor('accesskey'),
     dir: stringDescriptor('dir'),
@@ -819,7 +934,6 @@ class LightningElement {
         const normalizedName = StringToLowerCase.call(toString(attrName));
         const normalizedValue = String(attrValue);
         __classPrivateFieldGet(this, _LightningElement_attrs, "f")[normalizedName] = normalizedValue;
-        reflectAttrToProp(this, normalizedName, normalizedValue);
         mutationTracker.add(this, normalizedName);
     }
     getAttribute(attrName) {
@@ -836,7 +950,6 @@ class LightningElement {
     removeAttribute(attrName) {
         const normalizedName = StringToLowerCase.call(toString(attrName));
         delete __classPrivateFieldGet(this, _LightningElement_attrs, "f")[normalizedName];
-        reflectAttrToProp(this, normalizedName, null);
         // Track mutations for removal of non-existing attributes
         mutationTracker.add(this, normalizedName);
     }
@@ -1105,6 +1218,39 @@ function* toIteratorDirective(iterable) {
     }
 }
 
-export { ClassList, LightningElement, SYMBOL__GENERATE_MARKUP, SYMBOL__SET_INTERNALS, api, createContextProvider, createElement, fallbackTmpl, fallbackTmplNoYield, freezeTemplate, getComponentDef, hasScopedStaticStylesheets, hot, htmlEscape, isComponentConstructor, mutationTracker, parseFragment, parseSVGFragment, readonly, registerComponent, registerDecorators, registerTemplate, renderAttrs, renderAttrsNoYield, serverSideRenderComponent as renderComponent, renderStylesheets, renderer, sanitizeAttribute, sanitizeHtmlContent, serverSideRenderComponent, setFeatureFlag, setFeatureFlagForTest, setHooks, swapComponent, swapStyle, swapTemplate, toIteratorDirective, track, unwrap, validateStyleTextContents, wire };
-/** version: 8.6.0 */
+/*
+ * Copyright (c) 2024, Salesforce, 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
+ */
+// Deep freeze and clone an object. Designed for cloning/freezing child props when passed from a parent to a child so
+// that they are immutable. This is one of the normal guarantees of both engine-dom and engine-server that we want to
+// emulate in ssr-runtime. The goal here is that a child cannot mutate the props of its parent and thus affect
+// the parent's rendering, which would lead to bidirectional reactivity and mischief.
+function cloneAndDeepFreeze(obj) {
+    if (isArray(obj)) {
+        const res = [];
+        for (const item of obj) {
+            ArrayPush.call(res, cloneAndDeepFreeze(item));
+        }
+        freeze(res);
+        return res;
+    }
+    else if (isObject(obj) && !isNull(obj)) {
+        const res = create(null);
+        for (const [key, value] of entries(obj)) {
+            res[key] = cloneAndDeepFreeze(value);
+        }
+        freeze(res);
+        return res;
+    }
+    else {
+        // primitive
+        return obj;
+    }
+}
+
+export { ClassList, LightningElement, SYMBOL__GENERATE_MARKUP, SYMBOL__SET_INTERNALS, api, cloneAndDeepFreeze, createContextProvider, createElement, fallbackTmpl, fallbackTmplNoYield, filterProperties, freezeTemplate, getComponentDef, hasScopedStaticStylesheets, hot, htmlEscape, isComponentConstructor, mutationTracker, parseFragment, parseSVGFragment, readonly, registerComponent, registerDecorators, registerTemplate, renderAttrs, renderAttrsNoYield, serverSideRenderComponent as renderComponent, renderStylesheets, renderer, sanitizeAttribute, sanitizeHtmlContent, serverSideRenderComponent, setFeatureFlag, setFeatureFlagForTest, setHooks, swapComponent, swapStyle, swapTemplate, toIteratorDirective, track, unwrap, validateStyleTextContents, wire };
+/** version: 8.7.0 */
 //# sourceMappingURL=index.js.map