lwc 2.30.0 → 2.30.2

package/dist/engine-dom/umd/es5/engine-dom.js

@@ -302,9 +302,9 @@
    * 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
-  var LWC_VERSION = "2.30.0";
+  var LWC_VERSION = "2.30.2";
   var LWC_VERSION_COMMENT_REGEX = /\/\*LWC compiler v([\d.]+)\*\/\s*}/;
-  /** version: 2.30.0 */
+  /** version: 2.30.2 */
 
   /**
    * Copyright (C) 2018 salesforce.com, inc.
@@ -385,7 +385,7 @@
       patch$1(propName);
     }
   }
-  /** version: 2.30.0 */
+  /** version: 2.30.2 */
 
   /**
    * Copyright (C) 2018 salesforce.com, inc.
@@ -467,7 +467,7 @@
       setFeatureFlag(name, value);
     }
   }
-  /** version: 2.30.0 */
+  /** version: 2.30.2 */
 
   /*
    * Copyright (c) 2018, salesforce.com, inc.
@@ -4221,16 +4221,16 @@
       // the custom element from the registry is expecting an upgrade callback
       vm = createViewModelHook(elm, vnode, renderer);
     };
-    var connectedCallback = function connectedCallback(elm) {
-      if (lwcRuntimeFlags.ENABLE_NATIVE_CUSTOM_ELEMENT_LIFECYCLE) {
+    var connectedCallback;
+    var disconnectedCallback;
+    if (lwcRuntimeFlags.ENABLE_NATIVE_CUSTOM_ELEMENT_LIFECYCLE) {
+      connectedCallback = function connectedCallback(elm) {
         connectRootElement(elm);
-      }
-    };
-    var disconnectedCallback = function disconnectedCallback(elm) {
-      if (lwcRuntimeFlags.ENABLE_NATIVE_CUSTOM_ELEMENT_LIFECYCLE) {
+      };
+      disconnectedCallback = function 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
@@ -6390,7 +6390,9 @@
   function installWireAdapters(vm) {
     var context = vm.context,
       wire = vm.def.wire;
-    vm.debugInfo[WIRE_DEBUG_ENTRY] = create(null);
+    if (process.env.NODE_ENV !== 'production') {
+      vm.debugInfo[WIRE_DEBUG_ENTRY] = create(null);
+    }
     var wiredConnecting = context.wiredConnecting = [];
     var wiredDisconnecting = context.wiredDisconnecting = [];
     for (var fieldNameOrMethod in wire) {
@@ -7063,7 +7065,7 @@
     }
     return ctor;
   }
-  /* version: 2.30.0 */
+  /* version: 2.30.2 */
 
   /*
    * Copyright (c) 2018, salesforce.com, inc.
@@ -7343,9 +7345,11 @@
   // Another benefit is that only LWC can create components that actually do anything – if you do
   // `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.
-  var createUpgradableConstructor = function createUpgradableConstructor(_connectedCallback, _disconnectedCallback) {
+  var createUpgradableConstructor = function createUpgradableConstructor(connectedCallback, disconnectedCallback) {
+    var hasConnectedCallback = !isUndefined$1(connectedCallback);
+    var hasDisconnectedCallback = !isUndefined$1(disconnectedCallback);
     // TODO [#2972]: this class should expose observedAttributes as necessary
-    return /*#__PURE__*/function (_HTMLElement) {
+    var UpgradableConstructor = /*#__PURE__*/function (_HTMLElement) {
       _inherits(UpgradableConstructor, _HTMLElement);
       var _super7 = _createSuper(UpgradableConstructor);
       function UpgradableConstructor(upgradeCallback) {
@@ -7356,32 +7360,34 @@
         // then elementBeingUpgraded will be false
         if (elementBeingUpgradedByLWC) {
           upgradeCallback(_assertThisInitialized(_this5));
-        } 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(_assertThisInitialized(_this5));
           // 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.
         }
         return _this5;
       }
-      _createClass(UpgradableConstructor, [{
-        key: "connectedCallback",
-        value: function connectedCallback() {
-          if (!elementsUpgradedOutsideLWC.has(this)) {
-            _connectedCallback(this);
-          }
+      return _createClass(UpgradableConstructor);
+    }( /*#__PURE__*/_wrapNativeSuper(HTMLElement)); // 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);
         }
-      }, {
-        key: "disconnectedCallback",
-        value: function disconnectedCallback() {
-          if (!elementsUpgradedOutsideLWC.has(this)) {
-            _disconnectedCallback(this);
-          }
+      };
+    }
+    if (hasDisconnectedCallback) {
+      UpgradableConstructor.prototype.disconnectedCallback = function () {
+        if (!elementsUpgradedOutsideLWC.has(this)) {
+          disconnectedCallback(this);
         }
-      }]);
-      return UpgradableConstructor;
-    }( /*#__PURE__*/_wrapNativeSuper(HTMLElement));
+      };
+    }
+    return UpgradableConstructor;
   };
   var createCustomElementVanilla = function createCustomElementVanilla(tagName, upgradeCallback, connectedCallback, disconnectedCallback) {
     // use global custom elements registry
@@ -7441,17 +7447,27 @@
       var _constructor$prototyp = constructor.prototype,
         connectedCallback = _constructor$prototyp.connectedCallback,
         disconnectedCallback = _constructor$prototyp.disconnectedCallback,
+        formAssociatedCallback = _constructor$prototyp.formAssociatedCallback,
+        formDisabledCallback = _constructor$prototyp.formDisabledCallback,
+        formResetCallback = _constructor$prototyp.formResetCallback,
+        formStateRestoreCallback = _constructor$prototyp.formStateRestoreCallback,
         adoptedCallback = _constructor$prototyp.adoptedCallback,
         attributeChangedCallback = _constructor$prototyp.attributeChangedCallback;
+      var formAssociated = Boolean(constructor.formAssociated);
       var observedAttributes = new Set((_a = constructor.observedAttributes) !== null && _a !== void 0 ? _a : []);
       return {
         UserCtor: constructor,
         PivotCtor: undefined,
         connectedCallback: connectedCallback,
         disconnectedCallback: disconnectedCallback,
+        formAssociatedCallback: formAssociatedCallback,
+        formDisabledCallback: formDisabledCallback,
+        formResetCallback: formResetCallback,
+        formStateRestoreCallback: formStateRestoreCallback,
         adoptedCallback: adoptedCallback,
         attributeChangedCallback: attributeChangedCallback,
-        observedAttributes: observedAttributes
+        observedAttributes: observedAttributes,
+        formAssociated: formAssociated
       };
     }
     // Helper to create stand-in element for each tagName registered that delegates out to the registry for the given
@@ -7530,6 +7546,34 @@
               }
             }
           }
+        }, {
+          key: "formAssociatedCallback",
+          value: function formAssociatedCallback(form) {
+            var _a;
+            var definition = definitionForElement.get(this);
+            (_a = definition === null || definition === void 0 ? void 0 : definition.formAssociatedCallback) === null || _a === void 0 ? void 0 : _a.call(this, form);
+          }
+        }, {
+          key: "formDisabledCallback",
+          value: function formDisabledCallback(disabled) {
+            var _a;
+            var definition = definitionForElement.get(this);
+            (_a = definition === null || definition === void 0 ? void 0 : definition.formDisabledCallback) === null || _a === void 0 ? void 0 : _a.call(this, disabled);
+          }
+        }, {
+          key: "formResetCallback",
+          value: function formResetCallback() {
+            var _a;
+            var definition = definitionForElement.get(this);
+            (_a = definition === null || definition === void 0 ? void 0 : definition.formResetCallback) === null || _a === void 0 ? void 0 : _a.call(this);
+          }
+        }, {
+          key: "formStateRestoreCallback",
+          value: function formStateRestoreCallback(state, mode) {
+            var _a;
+            var 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);
+          }
         }, {
           key: "adoptedCallback",
           value: function adoptedCallback() {
@@ -7553,6 +7597,8 @@
         return PivotCtor;
       }(NativeHTMLElement);
       PivotCtor.observedAttributes = _toConsumableArray(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;
     }
@@ -7923,9 +7969,9 @@
   // 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.
-  var createUserConstructor = function createUserConstructor(upgradeCallback, _connectedCallback2, _disconnectedCallback2, HTMLElementToExtend) {
+  var createUserConstructor = function createUserConstructor(HTMLElementToExtend, upgradeCallback, connectedCallback, disconnectedCallback) {
     // TODO [#2972]: this class should expose observedAttributes as necessary
-    return /*#__PURE__*/function (_HTMLElementToExtend) {
+    var UserConstructor = /*#__PURE__*/function (_HTMLElementToExtend) {
       _inherits(UserConstructor, _HTMLElementToExtend);
       var _super9 = _createSuper(UserConstructor);
       function UserConstructor() {
@@ -7935,26 +7981,27 @@
         upgradeCallback(_assertThisInitialized(_this7));
         return _this7;
       }
-      _createClass(UserConstructor, [{
-        key: "connectedCallback",
-        value: function connectedCallback() {
-          _connectedCallback2(this);
-        }
-      }, {
-        key: "disconnectedCallback",
-        value: function disconnectedCallback() {
-          _disconnectedCallback2(this);
-        }
-      }]);
-      return UserConstructor;
-    }(HTMLElementToExtend);
+      return _createClass(UserConstructor);
+    }(HTMLElementToExtend); // 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);
+      };
+    }
+    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');
     }
-    var UserConstructor = createUserConstructor(upgradeCallback, connectedCallback, disconnectedCallback, CachedHTMLElement);
+    var UserConstructor = createUserConstructor(CachedHTMLElement, upgradeCallback, connectedCallback, disconnectedCallback);
     var ScopedConstructor = createScopedConstructor(tagName, UserConstructor);
     return new ScopedConstructor(UserConstructor);
   }
@@ -8049,7 +8096,7 @@
       function isNull(obj) {
         return obj === null;
       }
-      /** version: 2.30.0 */
+      /** version: 2.30.2 */
 
       /*
        * Copyright (c) 2018, salesforce.com, inc.
@@ -8534,16 +8581,16 @@
         DisconnectingSlot.set(elm, disconnectRootElement);
       }
     };
-    var connectedCallback = function connectedCallback(elm) {
-      if (lwcRuntimeFlags.ENABLE_NATIVE_CUSTOM_ELEMENT_LIFECYCLE) {
+    var connectedCallback;
+    var disconnectedCallback;
+    if (lwcRuntimeFlags.ENABLE_NATIVE_CUSTOM_ELEMENT_LIFECYCLE) {
+      connectedCallback = function connectedCallback(elm) {
         connectRootElement(elm);
-      }
-    };
-    var disconnectedCallback = function disconnectedCallback(elm) {
-      if (lwcRuntimeFlags.ENABLE_NATIVE_CUSTOM_ELEMENT_LIFECYCLE) {
+      };
+      disconnectedCallback = function disconnectedCallback(elm) {
         disconnectRootElement(elm);
-      }
-    };
+      };
+    }
     var element = createCustomElement(tagName, upgradeCallback, connectedCallback, disconnectedCallback);
     return element;
   }
@@ -8615,7 +8662,7 @@
   });
   freeze(LightningElement);
   seal(LightningElement.prototype);
-  /* version: 2.30.0 */
+  /* version: 2.30.2 */
 
   exports.LightningElement = LightningElement;
   exports.__unstable__ProfilerControl = profilerControl;
@@ -8649,6 +8696,4 @@
   exports.unwrap = unwrap;
   exports.wire = wire;
 
-  Object.defineProperty(exports, '__esModule', { value: true });
-
 }));