lwc 2.30.1 → 2.30.3

package/dist/engine-dom/esm/es2017/engine-dom.js

@@ -237,32 +237,57 @@ const KEY__SCOPED_CSS = '$scoped$';
 const XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
 const SVG_NAMESPACE = 'http://www.w3.org/2000/svg';
 const XLINK_NAMESPACE = 'http://www.w3.org/1999/xlink';
-/**
- * Map composed of properties to attributes not following the HTML property to attribute mapping
- * convention.
+
+/*
+ * Copyright (c) 2020, 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 NO_STANDARD_PROPERTY_ATTRIBUTE_MAPPING = 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'],
-]);
+const CAMEL_REGEX = /-([a-z])/g;
+// Convoluted map generation so that @lwc/shared remains fully tree-shakable (verify-treeshakable)
+const { NO_STANDARD_ATTRIBUTE_PROPERTY_MAPPING, NO_STANDARD_PROPERTY_ATTRIBUTE_MAPPING } = 
+/*#__PURE__*/ (() => {
+    /**
+     * Map composed of properties to attributes not following the HTML property to attribute mapping
+     * convention.
+     */
+    const NO_STANDARD_PROPERTY_ATTRIBUTE_MAPPING = 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'],
+    ]);
+    /**
+     * Inverted map with attribute name key and property name value.
+     */
+    const NO_STANDARD_ATTRIBUTE_PROPERTY_MAPPING = new Map();
+    NO_STANDARD_PROPERTY_ATTRIBUTE_MAPPING.forEach((value, key) => NO_STANDARD_ATTRIBUTE_PROPERTY_MAPPING.set(value, key));
+    return {
+        NO_STANDARD_ATTRIBUTE_PROPERTY_MAPPING,
+        NO_STANDARD_PROPERTY_ATTRIBUTE_MAPPING,
+    };
+})();
 /**
  * Map associating previously transformed HTML property into HTML attribute.
  */
 const CACHED_PROPERTY_ATTRIBUTE_MAPPING = new Map();
+/**
+ * Map associating previously transformed HTML attribute into HTML property.
+ */
+const CACHED_ATTRIBUTE_PROPERTY_MAPPING = new Map();
 function htmlPropertyToAttribute(propName) {
     const ariaAttributeName = AriaPropNameToAttrNameMap[propName];
     if (!isUndefined$1(ariaAttributeName)) {
@@ -291,6 +316,23 @@ function htmlPropertyToAttribute(propName) {
     CACHED_PROPERTY_ATTRIBUTE_MAPPING.set(propName, attributeName);
     return attributeName;
 }
+function htmlAttributeToProperty(attrName) {
+    const ariaPropertyName = AriaAttrNameToPropNameMap[attrName];
+    if (!isUndefined$1(ariaPropertyName)) {
+        return ariaPropertyName;
+    }
+    const specialPropertyName = NO_STANDARD_ATTRIBUTE_PROPERTY_MAPPING.get(attrName);
+    if (!isUndefined$1(specialPropertyName)) {
+        return specialPropertyName;
+    }
+    const cachedPropertyName = CACHED_ATTRIBUTE_PROPERTY_MAPPING.get(attrName);
+    if (!isUndefined$1(cachedPropertyName)) {
+        return cachedPropertyName;
+    }
+    const propertyName = StringReplace.call(attrName, CAMEL_REGEX, (g) => g[1].toUpperCase());
+    CACHED_ATTRIBUTE_PROPERTY_MAPPING.set(attrName, propertyName);
+    return propertyName;
+}
 
 /*
  * Copyright (c) 2018, salesforce.com, inc.
@@ -299,9 +341,9 @@ function htmlPropertyToAttribute(propName) {
  * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
  */
 // Increment whenever the LWC template compiler changes
-const LWC_VERSION = "2.30.1";
+const LWC_VERSION = "2.30.3";
 const LWC_VERSION_COMMENT_REGEX = /\/\*LWC compiler v([\d.]+)\*\/\s*}/;
-/** version: 2.30.1 */
+/** version: 2.30.3 */
 
 /**
  * Copyright (C) 2018 salesforce.com, inc.
@@ -383,7 +425,7 @@ for (let i = 0, len = ElementPrototypeAriaPropertyNames.length; i < len; i += 1)
         patch$1(propName);
     }
 }
-/** version: 2.30.1 */
+/** version: 2.30.3 */
 
 /**
  * Copyright (C) 2018 salesforce.com, inc.
@@ -463,7 +505,7 @@ function setFeatureFlagForTest(name, value) {
         setFeatureFlag(name, value);
     }
 }
-/** version: 2.30.1 */
+/** version: 2.30.3 */
 
 /*
  * Copyright (c) 2018, salesforce.com, inc.
@@ -3615,7 +3657,7 @@ function isVScopedSlotFragment(vnode) {
  * SPDX-License-Identifier: MIT
  * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
  */
-const ColonCharCode = 58;
+const ColonCharCode$1 = 58;
 function patchAttributes(oldVnode, vnode, renderer) {
     const { attrs } = vnode.data;
     if (isUndefined$1(attrs)) {
@@ -3632,11 +3674,11 @@ function patchAttributes(oldVnode, vnode, renderer) {
         const old = oldAttrs[key];
         if (old !== cur) {
             unlockAttribute(elm, key);
-            if (StringCharCodeAt.call(key, 3) === ColonCharCode) {
+            if (StringCharCodeAt.call(key, 3) === ColonCharCode$1) {
                 // Assume xml namespace
                 setAttribute(elm, key, cur, XML_NAMESPACE);
             }
-            else if (StringCharCodeAt.call(key, 5) === ColonCharCode) {
+            else if (StringCharCodeAt.call(key, 5) === ColonCharCode$1) {
                 // Assume xlink namespace
                 setAttribute(elm, key, cur, XLINK_NAMESPACE);
             }
@@ -3651,6 +3693,46 @@ function patchAttributes(oldVnode, vnode, renderer) {
     }
 }
 
+/*
+ * 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 ColonCharCode = 58;
+function patchAttrUnlessProp(oldVnode, vnode, renderer) {
+    const { data: { attrs }, elm, } = vnode;
+    if (isUndefined$1(attrs)) {
+        return;
+    }
+    const { removeAttribute, setAttribute, setProperty } = renderer;
+    const oldAttrs = isNull(oldVnode) ? EmptyObject : oldVnode.data.attrs;
+    for (const name in attrs) {
+        const cur = attrs[name];
+        const old = oldAttrs[name];
+        if (old !== cur) {
+            const propName = htmlAttributeToProperty(name);
+            if (propName in elm) {
+                setProperty(elm, name, cur);
+            }
+            else if (StringCharCodeAt.call(name, 3) === ColonCharCode) {
+                // Assume xml namespace
+                setAttribute(elm, name, cur, XML_NAMESPACE);
+            }
+            else if (StringCharCodeAt.call(name, 5) === ColonCharCode) {
+                // Assume xlink namespace
+                setAttribute(elm, name, cur, XLINK_NAMESPACE);
+            }
+            else if (isNull(cur) || isUndefined$1(cur)) {
+                removeAttribute(elm, name);
+            }
+            else {
+                setAttribute(elm, name, cur);
+            }
+        }
+    }
+}
+
 /*
  * Copyright (c) 2018, salesforce.com, inc.
  * All rights reserved.
@@ -4060,16 +4142,16 @@ function mountCustomElement(vnode, parent, anchor, renderer) {
     // the custom element from the registry is expecting an upgrade callback
     vm = createViewModelHook(elm, vnode, renderer);
   };
-  const connectedCallback = elm => {
-    if (lwcRuntimeFlags.ENABLE_NATIVE_CUSTOM_ELEMENT_LIFECYCLE) {
+  let connectedCallback;
+  let disconnectedCallback;
+  if (lwcRuntimeFlags.ENABLE_NATIVE_CUSTOM_ELEMENT_LIFECYCLE) {
+    connectedCallback = elm => {
       connectRootElement(elm);
-    }
-  };
-  const disconnectedCallback = elm => {
-    if (lwcRuntimeFlags.ENABLE_NATIVE_CUSTOM_ELEMENT_LIFECYCLE) {
+    };
+    disconnectedCallback = elm => {
       disconnectRootElement(elm);
-    }
-  };
+    };
+  }
   // Should never get a tag with upper case letter at this point; the compiler
   // should produce only tags with lowercase letters. However, the Java
   // compiler may generate tagnames with uppercase letters so - for backwards
@@ -4247,7 +4329,11 @@ function patchElementPropsAndAttrs$1(oldVnode, vnode, renderer) {
   // value is set before type=radio.
   patchClassAttribute(oldVnode, vnode, renderer);
   patchStyleAttribute(oldVnode, vnode, renderer);
-  patchAttributes(oldVnode, vnode, renderer);
+  if (vnode.data.external) {
+    patchAttrUnlessProp(oldVnode, vnode, renderer);
+  } else {
+    patchAttributes(oldVnode, vnode, renderer);
+  }
   patchProps(oldVnode, vnode, renderer);
 }
 function applyStyleScoping(elm, owner, renderer) {
@@ -4680,8 +4766,11 @@ function s(slotName, data, children, slotset) {
         !isUndefined$1(slotset.slotAssignments) &&
         !isUndefined$1(slotset.slotAssignments[slotName]) &&
         slotset.slotAssignments[slotName].length !== 0) {
-        children = slotset.slotAssignments[slotName].reduce((accumulator, vnode) => {
-            if (vnode) {
+        const newChildren = [];
+        const slotAssignments = slotset.slotAssignments[slotName];
+        for (let i = 0; i < slotAssignments.length; i++) {
+            const vnode = slotAssignments[i];
+            if (!isNull(vnode)) {
                 const assignedNodeIsScopedSlot = isVScopedSlotFragment(vnode);
                 // The only sniff test for a scoped <slot> element is the presence of `slotData`
                 const isScopedSlotElement = !isUndefined$1(data.slotData);
@@ -4691,32 +4780,30 @@ function s(slotName, data, children, slotset) {
                         logError(`Mismatched slot types for ${slotName === '' ? '(default)' : slotName} slot. Both parent and child component must use standard type or scoped type for a given slot.`, slotset.owner);
                     }
                     // Ignore slot content from parent
-                    return accumulator;
+                    continue;
                 }
                 // If the passed slot content is factory, evaluate it and add the produced vnodes
                 if (assignedNodeIsScopedSlot) {
                     const vmBeingRenderedInception = getVMBeingRendered();
-                    let scopedSlotChildren = [];
                     // Evaluate in the scope of the slot content's owner
                     // if a slotset is provided, there will always be an owner. The only case where owner is
                     // undefined is for root components, but root components cannot accept slotted content
                     setVMBeingRendered(slotset.owner);
                     try {
-                        scopedSlotChildren = vnode.factory(data.slotData);
+                        ArrayPush$1.apply(newChildren, vnode.factory(data.slotData));
                     }
                     finally {
                         setVMBeingRendered(vmBeingRenderedInception);
                     }
-                    return ArrayConcat$1.call(accumulator, scopedSlotChildren);
                 }
                 else {
                     // If the slot content is standard type, the content is static, no additional
                     // processing needed on the vnode
-                    return ArrayConcat$1.call(accumulator, vnode);
+                    ArrayPush$1.call(newChildren, vnode);
                 }
             }
-            return accumulator;
-        }, []);
+        }
+        children = newChildren;
     }
     const vmBeingRendered = getVMBeingRendered();
     const { renderMode, shadowMode } = vmBeingRendered;
@@ -6937,7 +7024,7 @@ function getComponentConstructor(elm) {
     }
     return ctor;
 }
-/* version: 2.30.1 */
+/* version: 2.30.3 */
 
 /*
  * Copyright (c) 2018, salesforce.com, inc.
@@ -7220,8 +7307,10 @@ let elementBeingUpgradedByLWC = false;
 // `customElements.define('x-foo')`, then you don't have access to the upgradeCallback, so it's a dummy custom element.
 // This class should be created once per tag name.
 const createUpgradableConstructor = (connectedCallback, disconnectedCallback) => {
+    const hasConnectedCallback = !isUndefined$1(connectedCallback);
+    const hasDisconnectedCallback = !isUndefined$1(disconnectedCallback);
     // TODO [#2972]: this class should expose observedAttributes as necessary
-    return class UpgradableConstructor extends HTMLElement {
+    class UpgradableConstructor extends HTMLElement {
         constructor(upgradeCallback) {
             super();
             // If the element is not created using lwc.createElement(), e.g. `document.createElement('x-foo')`,
@@ -7229,25 +7318,33 @@ const createUpgradableConstructor = (connectedCallback, disconnectedCallback) =>
             if (elementBeingUpgradedByLWC) {
                 upgradeCallback(this);
             }
-            else {
-                // keep track of elements that were not created by lwc.createElement,
-                // so we can ignore their lifecycle hooks
+            else if (hasConnectedCallback || hasDisconnectedCallback) {
+                // If this element has connected or disconnected callbacks, then we need to keep track of
+                // instances that were created outside LWC (i.e. not created by `lwc.createElement()`).
+                // If the element has no connected or disconnected callbacks, then we don't need to track this.
                 elementsUpgradedOutsideLWC.add(this);
                 // TODO [#2970]: LWC elements cannot be upgraded via new Ctor()
                 // Do we want to support this? Throw an error? Currently for backwards compat it's a no-op.
             }
         }
-        connectedCallback() {
+    }
+    // Do not unnecessarily add a connectedCallback/disconnectedCallback, as it introduces perf overhead
+    // See: https://github.com/salesforce/lwc/pull/3162#issuecomment-1311851174
+    if (hasConnectedCallback) {
+        UpgradableConstructor.prototype.connectedCallback = function () {
             if (!elementsUpgradedOutsideLWC.has(this)) {
                 connectedCallback(this);
             }
-        }
-        disconnectedCallback() {
+        };
+    }
+    if (hasDisconnectedCallback) {
+        UpgradableConstructor.prototype.disconnectedCallback = function () {
             if (!elementsUpgradedOutsideLWC.has(this)) {
                 disconnectedCallback(this);
             }
-        }
-    };
+        };
+    }
+    return UpgradableConstructor;
 };
 const createCustomElementVanilla = (tagName, upgradeCallback, connectedCallback, disconnectedCallback) => {
     // use global custom elements registry
@@ -7300,16 +7397,22 @@ function createScopedRegistry() {
     const EMPTY_SET = new Set();
     function createDefinitionRecord(constructor) {
         var _a;
-        const { connectedCallback, disconnectedCallback, adoptedCallback, attributeChangedCallback, } = constructor.prototype;
+        const { connectedCallback, disconnectedCallback, formAssociatedCallback, formDisabledCallback, formResetCallback, formStateRestoreCallback, adoptedCallback, attributeChangedCallback, } = constructor.prototype;
+        const formAssociated = Boolean(constructor.formAssociated);
         const observedAttributes = new Set((_a = constructor.observedAttributes) !== null && _a !== void 0 ? _a : []);
         return {
             UserCtor: constructor,
             PivotCtor: undefined,
             connectedCallback,
             disconnectedCallback,
+            formAssociatedCallback,
+            formDisabledCallback,
+            formResetCallback,
+            formStateRestoreCallback,
             adoptedCallback,
             attributeChangedCallback,
             observedAttributes,
+            formAssociated,
         };
     }
     // Helper to create stand-in element for each tagName registered that delegates out to the registry for the given
@@ -7384,6 +7487,26 @@ function createScopedRegistry() {
                     }
                 }
             }
+            formAssociatedCallback(form) {
+                var _a;
+                const definition = definitionForElement.get(this);
+                (_a = definition === null || definition === void 0 ? void 0 : definition.formAssociatedCallback) === null || _a === void 0 ? void 0 : _a.call(this, form);
+            }
+            formDisabledCallback(disabled) {
+                var _a;
+                const definition = definitionForElement.get(this);
+                (_a = definition === null || definition === void 0 ? void 0 : definition.formDisabledCallback) === null || _a === void 0 ? void 0 : _a.call(this, disabled);
+            }
+            formResetCallback() {
+                var _a;
+                const definition = definitionForElement.get(this);
+                (_a = definition === null || definition === void 0 ? void 0 : definition.formResetCallback) === null || _a === void 0 ? void 0 : _a.call(this);
+            }
+            formStateRestoreCallback(state, mode) {
+                var _a;
+                const definition = definitionForElement.get(this);
+                (_a = definition === null || definition === void 0 ? void 0 : definition.formStateRestoreCallback) === null || _a === void 0 ? void 0 : _a.call(this, state, mode);
+            }
             adoptedCallback() {
                 var _a;
                 const definition = definitionForElement.get(this);
@@ -7402,6 +7525,8 @@ function createScopedRegistry() {
             }
         }
         PivotCtor.observedAttributes = [...registeredDefinition.observedAttributes];
+        // TODO [#3000]: support case where registeredDefinition is not form-associated, but later definition is.
+        PivotCtor.formAssociated = registeredDefinition.formAssociated;
         registeredPivotCtors.add(PivotCtor);
         return PivotCtor;
     }
@@ -7748,27 +7873,34 @@ if (lwcRuntimeFlags.ENABLE_SCOPED_CUSTOM_ELEMENT_REGISTRY) {
 // Creates a constructor that is intended to be used as the UserConstructor in a scoped (pivots) registry.
 // In this case, the upgradeCallback only needs to be defined once because we create these on-demand,
 // multiple times per tag name.
-const createUserConstructor = (upgradeCallback, connectedCallback, disconnectedCallback, HTMLElementToExtend) => {
+const createUserConstructor = (HTMLElementToExtend, upgradeCallback, connectedCallback, disconnectedCallback) => {
   // TODO [#2972]: this class should expose observedAttributes as necessary
-  return class UserConstructor extends HTMLElementToExtend {
+  class UserConstructor extends HTMLElementToExtend {
     constructor() {
       super();
       upgradeCallback(this);
     }
-    connectedCallback() {
+  }
+  // Do not unnecessarily add a connectedCallback/disconnectedCallback, as it introduces perf overhead
+  // See: https://github.com/salesforce/lwc/pull/3162#issuecomment-1311851174
+  if (!isUndefined$1(connectedCallback)) {
+    UserConstructor.prototype.connectedCallback = function () {
       connectedCallback(this);
-    }
-    disconnectedCallback() {
+    };
+  }
+  if (!isUndefined$1(disconnectedCallback)) {
+    UserConstructor.prototype.disconnectedCallback = function () {
       disconnectedCallback(this);
-    }
-  };
+    };
+  }
+  return UserConstructor;
 };
 function createCustomElementScoped(tagName, upgradeCallback, connectedCallback, disconnectedCallback) {
   if (isUndefined$1(createScopedConstructor) || isUndefined$1(CachedHTMLElement)) {
     // This error should be impossible to hit
     throw new Error('The flag ENABLE_SCOPED_CUSTOM_ELEMENT_REGISTRY must be set to true to use this feature');
   }
-  const UserConstructor = createUserConstructor(upgradeCallback, connectedCallback, disconnectedCallback, CachedHTMLElement);
+  const UserConstructor = createUserConstructor(CachedHTMLElement, upgradeCallback, connectedCallback, disconnectedCallback);
   const ScopedConstructor = createScopedConstructor(tagName, UserConstructor);
   return new ScopedConstructor(UserConstructor);
 }
@@ -7865,7 +7997,7 @@ function rendererFactory(baseRenderer) {
     function isNull(obj) {
         return obj === null;
     }
-    /** version: 2.30.1 */
+    /** version: 2.30.3 */
 
     /*
      * Copyright (c) 2018, salesforce.com, inc.
@@ -8344,16 +8476,16 @@ function createElement(sel, options) {
       DisconnectingSlot.set(elm, disconnectRootElement);
     }
   };
-  const connectedCallback = elm => {
-    if (lwcRuntimeFlags.ENABLE_NATIVE_CUSTOM_ELEMENT_LIFECYCLE) {
+  let connectedCallback;
+  let disconnectedCallback;
+  if (lwcRuntimeFlags.ENABLE_NATIVE_CUSTOM_ELEMENT_LIFECYCLE) {
+    connectedCallback = elm => {
       connectRootElement(elm);
-    }
-  };
-  const disconnectedCallback = elm => {
-    if (lwcRuntimeFlags.ENABLE_NATIVE_CUSTOM_ELEMENT_LIFECYCLE) {
+    };
+    disconnectedCallback = elm => {
       disconnectRootElement(elm);
-    }
-  };
+    };
+  }
   const element = createCustomElement(tagName, upgradeCallback, connectedCallback, disconnectedCallback);
   return element;
 }
@@ -8426,6 +8558,6 @@ defineProperty(LightningElement, 'CustomElementConstructor', {
 });
 freeze(LightningElement);
 seal(LightningElement.prototype);
-/* version: 2.30.1 */
+/* version: 2.30.3 */
 
 export { LightningElement, profilerControl as __unstable__ProfilerControl, api$1 as api, deprecatedBuildCustomElementConstructor as buildCustomElementConstructor, createContextProvider, createElement, freezeTemplate, getComponentConstructor, getComponentDef, hydrateComponent, isComponentConstructor, isNodeShadowed as isNodeFromTemplate, parseFragment, parseSVGFragment, readonly, register, registerComponent, registerDecorators, registerTemplate, renderer, rendererFactory, sanitizeAttribute, setFeatureFlag, setFeatureFlagForTest, setHooks, swapComponent, swapStyle, swapTemplate, track, unwrap, wire };