lwc 2.30.1 → 2.30.3

package/dist/engine-dom/umd/es2017/engine-dom_debug.js

@@ -240,32 +240,57 @@
   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)) {
@@ -294,7 +319,24 @@
       CACHED_PROPERTY_ATTRIBUTE_MAPPING.set(propName, attributeName);
       return attributeName;
   }
-  /** version: 2.30.1 */
+  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;
+  }
+  /** version: 2.30.3 */
 
   /**
    * Copyright (C) 2018 salesforce.com, inc.
@@ -376,7 +418,7 @@
           patch$1(propName);
       }
   }
-  /** version: 2.30.1 */
+  /** version: 2.30.3 */
 
   /**
    * Copyright (C) 2018 salesforce.com, inc.
@@ -2576,7 +2618,7 @@
    * 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)) {
@@ -2593,11 +2635,11 @@
           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);
               }
@@ -2612,6 +2654,46 @@
       }
   }
 
+  /*
+   * 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.
@@ -2996,16 +3078,16 @@
       // 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
@@ -3160,7 +3242,11 @@
     // 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) {
@@ -3540,40 +3626,41 @@
           !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);
                   // Check if slot types of parent and child are matching
                   if (assignedNodeIsScopedSlot !== isScopedSlotElement) {
                       // 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;
@@ -5531,8 +5618,10 @@
   // `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')`,
@@ -5540,25 +5629,33 @@
               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
@@ -5611,16 +5708,22 @@
       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
@@ -5695,6 +5798,26 @@
                       }
                   }
               }
+              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);
@@ -5713,6 +5836,8 @@
               }
           }
           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;
       }
@@ -6059,27 +6184,34 @@
   // 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);
   }
@@ -6176,7 +6308,7 @@
       function isNull(obj) {
           return obj === null;
       }
-      /** version: 2.30.1 */
+      /** version: 2.30.3 */
 
       /*
        * Copyright (c) 2018, salesforce.com, inc.
@@ -6647,16 +6779,16 @@
         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;
   }
@@ -6729,7 +6861,7 @@
   });
   freeze(LightningElement);
   seal(LightningElement.prototype);
-  /* version: 2.30.1 */
+  /* version: 2.30.3 */
 
   exports.LightningElement = LightningElement;
   exports.__unstable__ProfilerControl = profilerControl;