lwc 2.35.0 → 2.35.2

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

@@ -32,10 +32,10 @@ var LWC = (function (exports) {
 
   var assert = /*#__PURE__*/Object.freeze({
       __proto__: null,
+      fail: fail,
       invariant: invariant,
-      isTrue: isTrue$1,
       isFalse: isFalse$1,
-      fail: fail
+      isTrue: isTrue$1
   });
 
   /*
@@ -202,41 +202,11 @@ var LWC = (function (exports) {
    * SPDX-License-Identifier: MIT
    * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
    */
-  // Inspired from: https://mathiasbynens.be/notes/globalthis
-  const _globalThis = /*@__PURE__*/ (function () {
-      // On recent browsers, `globalThis` is already defined. In this case return it directly.
-      if (typeof globalThis === 'object') {
-          return globalThis;
-      }
-      let _globalThis;
-      try {
-          // eslint-disable-next-line no-extend-native
-          Object.defineProperty(Object.prototype, '__magic__', {
-              get: function () {
-                  return this;
-              },
-              configurable: true,
-          });
-          // __magic__ is undefined in Safari 10 and IE10 and older.
-          // @ts-ignore
-          // eslint-disable-next-line no-undef
-          _globalThis = __magic__;
-          // @ts-ignore
-          delete Object.prototype.__magic__;
-      }
-      catch (ex) {
-          // In IE8, Object.defineProperty only works on DOM objects.
-      }
-      finally {
-          // If the magic above fails for some reason we assume that we are in a legacy browser.
-          // Assume `window` exists in this case.
-          if (typeof _globalThis === 'undefined') {
-              // @ts-ignore
-              _globalThis = window;
-          }
-      }
-      return _globalThis;
-  })();
+  // See browser support for globalThis:
+  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/globalThis#browser_compatibility
+  /* istanbul ignore next */
+  // @ts-ignore
+  const _globalThis = typeof globalThis === 'object' ? globalThis : window;
 
   /*
    * Copyright (c) 2018, salesforce.com, inc.
@@ -351,7 +321,7 @@ var LWC = (function (exports) {
       CACHED_ATTRIBUTE_PROPERTY_MAPPING.set(attrName, propertyName);
       return propertyName;
   }
-  /** version: 2.35.0 */
+  /** version: 2.35.2 */
 
   /**
    * Copyright (C) 2018 salesforce.com, inc.
@@ -401,6 +371,7 @@ var LWC = (function (exports) {
           console.warn(`Failed to set the value "${value}" for the runtime feature flag "${name}" because it is undefined. Available flags: ${availableFlags}.`);
           return;
       }
+      // This may seem redundant, but `"production" === 'test-karma-lwc'` is replaced by Karma tests
       {
           // Disallow the same flag to be set more than once in production
           const runtimeValue = lwcRuntimeFlags[name];
@@ -418,7 +389,7 @@ var LWC = (function (exports) {
    */
   function setFeatureFlagForTest(name, value) {
   }
-  /** version: 2.35.0 */
+  /** version: 2.35.2 */
 
   /**
    * Copyright (C) 2018 salesforce.com, inc.
@@ -482,7 +453,7 @@ var LWC = (function (exports) {
           }
       }
   }
-  /** version: 2.35.0 */
+  /** version: 2.35.2 */
 
   /*
    * Copyright (c) 2018, salesforce.com, inc.
@@ -840,6 +811,14 @@ var LWC = (function (exports) {
           refVNodes[ref] = vnode;
       }
   }
+  // Throw an error if we're running in prod mode. Ensures code is truly removed from prod mode.
+  function assertNotProd() {
+      /* istanbul ignore if */
+      {
+          // this method should never leak to prod
+          throw new ReferenceError();
+      }
+  }
 
   /*
    * Copyright (c) 2020, salesforce.com, inc.
@@ -1430,7 +1409,6 @@ var LWC = (function (exports) {
       }
     };
   }
-  const EMPTY_REFS = freeze(create(null));
   const refsCache = new WeakMap();
   /**
    * This class is the base class for any LWC element.
@@ -1668,22 +1646,15 @@ var LWC = (function (exports) {
       }
       const {
         refVNodes,
-        hasRefVNodes,
         cmpTemplate
       } = vm;
       // For backwards compatibility with component written before template refs
       // were introduced, we return undefined if the template has no refs defined
       // anywhere. This fixes components that may want to add an expando called `refs`
       // and are checking if it exists with `if (this.refs)`  before adding it.
-      // Note it is not sufficient to just check if `refVNodes` is null or empty,
-      // because a template may have `lwc:ref` defined within a falsy `if:true` block.
-      if (!hasRefVNodes) {
-        return;
-      }
-      // For templates that are using `lwc:ref`, if there are no refs currently available
-      // (e.g. refs inside of a falsy `if:true` block), we return an empty object.
+      // Note we use a null refVNodes to indicate that the template has no refs defined.
       if (isNull(refVNodes)) {
-        return EMPTY_REFS;
+        return;
       }
       // The refNodes can be cached based on the refVNodes, since the refVNodes
       // are recreated from scratch every time the template is rendered.
@@ -2500,10 +2471,60 @@ var LWC = (function (exports) {
   }
   freeze(BaseBridgeElement);
   seal(BaseBridgeElement.prototype);
+  const swappedStyleMap = new WeakMap();
+  const activeTemplates = new WeakMap();
+  const activeComponents = new WeakMap();
+  const activeStyles = new WeakMap();
+  function getStyleOrSwappedStyle(style) {
+      assertNotProd(); // this method should never leak to prod
+      const visited = new Set();
+      while (swappedStyleMap.has(style) && !visited.has(style)) {
+          visited.add(style);
+          style = swappedStyleMap.get(style);
+      }
+      return style;
+  }
   function setActiveVM(vm) {
-      {
-          // this method should never leak to prod
-          throw new ReferenceError();
+      assertNotProd(); // this method should never leak to prod
+      // tracking active component
+      const Ctor = vm.def.ctor;
+      let componentVMs = activeComponents.get(Ctor);
+      if (isUndefined$1(componentVMs)) {
+          componentVMs = new Set();
+          activeComponents.set(Ctor, componentVMs);
+      }
+      // this will allow us to keep track of the hot components
+      componentVMs.add(vm);
+      // tracking active template
+      const tpl = vm.cmpTemplate;
+      if (tpl) {
+          let templateVMs = activeTemplates.get(tpl);
+          if (isUndefined$1(templateVMs)) {
+              templateVMs = new Set();
+              activeTemplates.set(tpl, templateVMs);
+          }
+          // this will allow us to keep track of the templates that are
+          // being used by a hot component
+          templateVMs.add(vm);
+          // tracking active styles associated to template
+          const stylesheets = tpl.stylesheets;
+          if (!isUndefined$1(stylesheets)) {
+              flattenStylesheets(stylesheets).forEach((stylesheet) => {
+                  // this is necessary because we don't hold the list of styles
+                  // in the vm, we only hold the selected (already swapped template)
+                  // but the styles attached to the template might not be the actual
+                  // active ones, but the swapped versions of those.
+                  stylesheet = getStyleOrSwappedStyle(stylesheet);
+                  let stylesheetVMs = activeStyles.get(stylesheet);
+                  if (isUndefined$1(stylesheetVMs)) {
+                      stylesheetVMs = new Set();
+                      activeStyles.set(stylesheet, stylesheetVMs);
+                  }
+                  // this will allow us to keep track of the stylesheet that are
+                  // being used by a hot component
+                  stylesheetVMs.add(vm);
+              });
+          }
       }
   }
   function swapTemplate(oldTpl, newTpl) {
@@ -4335,9 +4356,17 @@ var LWC = (function (exports) {
       vmBeingRendered = vm;
   }
   function validateSlots(vm, html) {
-      {
-          // this method should never leak to prod
-          throw new ReferenceError();
+      assertNotProd(); // this method should never leak to prod
+      const { cmpSlots } = vm;
+      const { slots = EmptyArray } = html;
+      for (const slotName in cmpSlots.slotAssignments) {
+          // eslint-disable-next-line @lwc/lwc-internal/no-production-assert
+          assert.isTrue(isArray$1(cmpSlots.slotAssignments[slotName]), `Slots can only be set to an array, instead received ${toString$1(cmpSlots.slotAssignments[slotName])} for slot "${slotName}" in ${vm}.`);
+          if (slotName !== '' && ArrayIndexOf.call(slots, slotName) === -1) {
+              // TODO [#1297]: this should never really happen because the compiler should always validate
+              // eslint-disable-next-line @lwc/lwc-internal/no-production-assert
+              logError(`Ignoring unknown provided slot name "${slotName}" in ${vm}. Check for a typo on the slot attribute.`, vm);
+          }
       }
   }
   function validateLightDomTemplate(template, vm) {
@@ -4447,9 +4476,7 @@ var LWC = (function (exports) {
               }
               if ("production" !== 'production') ;
               // reset the refs; they will be set during the tmpl() instantiation
-              const hasRefVNodes = Boolean(html.hasRefs);
-              vm.hasRefVNodes = hasRefVNodes;
-              vm.refVNodes = hasRefVNodes ? create(null) : null;
+              vm.refVNodes = html.hasRefs ? create(null) : null;
               // right before producing the vnodes, we clear up all internal references
               // to custom elements from the template.
               vm.velements = [];
@@ -4606,7 +4633,7 @@ var LWC = (function (exports) {
   const cmpEventListenerMap = new WeakMap();
   function getWrappedComponentsListener(vm, listener) {
       if (!isFunction$1(listener)) {
-          throw new TypeError(); // avoiding problems with non-valid listeners
+          throw new TypeError('Expected an EventListener but received ' + typeof listener); // avoiding problems with non-valid listeners
       }
       let wrappedListener = cmpEventListenerMap.get(listener);
       if (isUndefined$1(wrappedListener)) {
@@ -4739,7 +4766,6 @@ var LWC = (function (exports) {
       mode,
       owner,
       refVNodes: null,
-      hasRefVNodes: false,
       children: EmptyArray,
       aChildren: EmptyArray,
       velements: EmptyArray,
@@ -5950,7 +5976,7 @@ var LWC = (function (exports) {
   const cachedConstructors = new Map();
   const elementsUpgradedOutsideLWC = new WeakSet();
   let elementBeingUpgradedByLWC = false;
-  // Creates a constructor that is intended to be used as a vanilla custom element, except that the upgradeCallback is
+  // Creates a constructor that is intended to be used directly as a custom element, except that the upgradeCallback is
   // passed in to the constructor so LWC can reuse the same custom element constructor for multiple components.
   // 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.
@@ -5995,7 +6021,7 @@ var LWC = (function (exports) {
       }
       return UpgradableConstructor;
   };
-  const createCustomElementVanilla = (tagName, upgradeCallback, connectedCallback, disconnectedCallback) => {
+  const createCustomElementUsingUpgradableConstructor = (tagName, upgradeCallback, connectedCallback, disconnectedCallback) => {
       // use global custom elements registry
       let UpgradableConstructor = cachedConstructors.get(tagName);
       if (isUndefined$1(UpgradableConstructor)) {
@@ -6023,7 +6049,7 @@ var LWC = (function (exports) {
    */
   /**
    * Create a scoped registry, i.e. a function that can create custom elements whose tag names
-   * do not conflict with vanilla custom elements having the same tag name.
+   * do not conflict with third-party custom elements having the same tag name.
    */
   function createScopedRegistry() {
       if (!hasCustomElements) {
@@ -6564,10 +6590,10 @@ var LWC = (function (exports) {
    * We have three modes for creating custom elements:
    *
    * 1. Compat (legacy) browser support (e.g. IE11). Totally custom, doesn't rely on native browser APIs.
-   * 2. "Vanilla" custom elements registry. This system actually still allows us to have two LWC components with the
-   *    same tag name, via a simple trick: every custom element constructor we define in the registry is basically
-   *    the same. It's essentially a dummy `class extends HTMLElement` that accepts an `upgradeCallback` in its
-   *    constructor, which allows us to have completely customized functionality for different components.
+   * 2. "Upgradable constructor" custom element. This allows us to have two LWC components with the same tag name,
+   *    via a trick: every custom element constructor we define in the registry is basically the same. It's essentially
+   *    a dummy `class extends HTMLElement` that accepts an `upgradeCallback` in its constructor ("upgradable
+   *    constructor"), which allows us to have completely customized functionality for different components.
    * 3. "Scoped" (or "pivot") custom elements. This relies on a sophisticated system that emulates the "scoped custom
    *    elements registry" proposal, with support for avoiding conflicts in tag names both between LWC components and
    *    between LWC components and third-party elements. This uses a similar trick to #2, but is much more complex
@@ -6578,8 +6604,8 @@ var LWC = (function (exports) {
     if (lwcRuntimeFlags.ENABLE_SCOPED_CUSTOM_ELEMENT_REGISTRY) {
       createCustomElement = createCustomElementScoped;
     } else {
-      // use global custom elements registry (vanilla)
-      createCustomElement = createCustomElementVanilla;
+      // use the global registry, with an upgradable constructor for the defined custom element
+      createCustomElement = createCustomElementUsingUpgradableConstructor;
     }
   } else {
     // no registry available here
@@ -6635,10 +6661,10 @@ var LWC = (function (exports) {
 
       var assert = /*#__PURE__*/Object.freeze({
           __proto__: null,
+          fail: fail,
           invariant: invariant,
-          isTrue: isTrue$1,
           isFalse: isFalse$1,
-          fail: fail
+          isTrue: isTrue$1
       });
       function isUndefined(obj) {
           return obj === undefined;
@@ -6646,7 +6672,7 @@ var LWC = (function (exports) {
       function isNull(obj) {
           return obj === null;
       }
-      /** version: 2.35.0 */
+      /** version: 2.35.2 */
 
       /*
        * Copyright (c) 2018, salesforce.com, inc.
@@ -7199,7 +7225,7 @@ var LWC = (function (exports) {
   });
   freeze(LightningElement);
   seal(LightningElement.prototype);
-  /* version: 2.35.0 */
+  /* version: 2.35.2 */
 
   exports.LightningElement = LightningElement;
   exports.__unstable__ProfilerControl = profilerControl;