lwc 2.31.6 → 2.31.8

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

@@ -341,9 +341,9 @@ function htmlAttributeToProperty(attrName) {
  * 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.31.6";
+const LWC_VERSION = "2.31.8";
 const LWC_VERSION_COMMENT_REGEX = /\/\*LWC compiler v([\d.]+)\*\/\s*}/;
-/** version: 2.31.6 */
+/** version: 2.31.8 */
 
 /**
  * Copyright (C) 2018 salesforce.com, inc.
@@ -425,7 +425,7 @@ for (let i = 0, len = ElementPrototypeAriaPropertyNames.length; i < len; i += 1)
         patch$1(propName);
     }
 }
-/** version: 2.31.6 */
+/** version: 2.31.8 */
 
 /**
  * Copyright (C) 2018 salesforce.com, inc.
@@ -505,7 +505,7 @@ function setFeatureFlagForTest(name, value) {
         setFeatureFlag(name, value);
     }
 }
-/** version: 2.31.6 */
+/** version: 2.31.8 */
 
 /*
  * Copyright (c) 2018, salesforce.com, inc.
@@ -2996,6 +2996,93 @@ const BaseBridgeElement = HTMLBridgeElementFactory(HTMLElementConstructor, getOw
 freeze(BaseBridgeElement);
 seal(BaseBridgeElement.prototype);
 
+/*
+ * Copyright (c) 2023, 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 supportsWeakRefs = typeof WeakRef === 'function' && typeof FinalizationRegistry === 'function';
+// In browsers that doesn't support WeakRefs, the values will still leak, but at least the keys won't
+class LegacyWeakMultiMap {
+    constructor() {
+        this._map = new WeakMap();
+    }
+    _getValues(key) {
+        let values = this._map.get(key);
+        if (isUndefined$1(values)) {
+            values = new Set();
+            this._map.set(key, values);
+        }
+        return values;
+    }
+    get(key) {
+        return this._getValues(key);
+    }
+    add(key, vm) {
+        const set = this._getValues(key);
+        set.add(vm);
+    }
+    delete(key) {
+        this._map.delete(key);
+    }
+}
+// This implementation relies on the WeakRef/FinalizationRegistry proposal.
+// For some background, see: https://github.com/tc39/proposal-weakrefs
+class ModernWeakMultiMap {
+    constructor() {
+        this._map = new WeakMap();
+        this._registry = new FinalizationRegistry((weakRefs) => {
+            // This should be considered an optional cleanup method to remove GC'ed values from their respective arrays.
+            // JS VMs are not obligated to call FinalizationRegistry callbacks.
+            // Work backwards, removing stale VMs
+            for (let i = weakRefs.length - 1; i >= 0; i--) {
+                const vm = weakRefs[i].deref();
+                if (isUndefined$1(vm)) {
+                    ArraySplice.call(weakRefs, i, 1); // remove
+                }
+            }
+        });
+    }
+    _getWeakRefs(key) {
+        let weakRefs = this._map.get(key);
+        if (isUndefined$1(weakRefs)) {
+            weakRefs = [];
+            this._map.set(key, weakRefs);
+        }
+        return weakRefs;
+    }
+    get(key) {
+        const weakRefs = this._getWeakRefs(key);
+        const result = new Set();
+        for (const weakRef of weakRefs) {
+            const vm = weakRef.deref();
+            if (!isUndefined$1(vm)) {
+                result.add(vm);
+            }
+        }
+        return result;
+    }
+    add(key, value) {
+        const weakRefs = this._getWeakRefs(key);
+        // We could check for duplicate values here, but it doesn't seem worth it.
+        // We transform the output into a Set anyway
+        ArrayPush$1.call(weakRefs, new WeakRef(value));
+        // It's important here not to leak the second argument, which is the "held value." The FinalizationRegistry
+        // effectively creates a strong reference between the first argument (the "target") and the held value. When
+        // the target is GC'ed, the callback is called, and then the held value is GC'ed.
+        // Putting the key here would mean the key is not GC'ed until the value is GC'ed, which defeats the purpose
+        // of the WeakMap. Whereas putting the weakRefs array here is fine, because it doesn't have a strong reference
+        // to anything. See also this example:
+        // https://gist.github.com/nolanlawson/79a3d36e8e6cc25c5048bb17c1795aea
+        this._registry.register(value, weakRefs);
+    }
+    delete(key) {
+        this._map.delete(key);
+    }
+}
+const WeakMultiMap = supportsWeakRefs ? ModernWeakMultiMap : LegacyWeakMultiMap;
+
 /*
  * Copyright (c) 2020, salesforce.com, inc.
  * All rights reserved.
@@ -3005,67 +3092,62 @@ seal(BaseBridgeElement.prototype);
 const swappedTemplateMap = new WeakMap();
 const swappedComponentMap = new WeakMap();
 const swappedStyleMap = new WeakMap();
-const activeTemplates = new WeakMap();
-const activeComponents = new WeakMap();
-const activeStyles = new WeakMap();
+// The important thing here is the weak values – VMs are transient (one per component instance) and should be GC'ed,
+// so we don't want to create strong references to them.
+// The weak keys are kind of useless, because Templates, LightningElementConstructors, and StylesheetFactories are
+// never GC'ed. But maybe they will be someday, so we may as well use weak keys too.
+const activeTemplates = new WeakMultiMap();
+const activeComponents = new WeakMultiMap();
+const activeStyles = new WeakMultiMap();
 function rehydrateHotTemplate(tpl) {
     const list = activeTemplates.get(tpl);
-    if (!isUndefined$1(list)) {
-        list.forEach((vm) => {
-            if (isFalse(vm.isDirty)) {
-                // forcing the vm to rehydrate in the micro-task:
-                markComponentAsDirty(vm);
-                scheduleRehydration(vm);
-            }
-        });
-        // resetting the Set to release the memory of those vm references
-        // since they are not longer related to this template, instead
-        // they will get re-associated once these instances are rehydrated.
-        list.clear();
+    for (const vm of list) {
+        if (isFalse(vm.isDirty)) {
+            // forcing the vm to rehydrate in the micro-task:
+            markComponentAsDirty(vm);
+            scheduleRehydration(vm);
+        }
     }
+    // Resetting the Set since these VMs are no longer related to this template, instead
+    // they will get re-associated once these instances are rehydrated.
+    activeTemplates.delete(tpl);
     return true;
 }
 function rehydrateHotStyle(style) {
     const list = activeStyles.get(style);
-    if (!isUndefined$1(list)) {
-        list.forEach((vm) => {
-            // if a style definition is swapped, we must reset
-            // vm's template content in the next micro-task:
-            forceRehydration(vm);
-        });
-        // resetting the Set to release the memory of those vm references
-        // since they are not longer related to this style, instead
-        // they will get re-associated once these instances are rehydrated.
-        list.clear();
-    }
+    for (const vm of list) {
+        // if a style definition is swapped, we must reset
+        // vm's template content in the next micro-task:
+        forceRehydration(vm);
+    }
+    // Resetting the Set since these VMs are no longer related to this style, instead
+    // they will get re-associated once these instances are rehydrated.
+    activeStyles.delete(style);
     return true;
 }
 function rehydrateHotComponent(Ctor) {
     const list = activeComponents.get(Ctor);
     let canRefreshAllInstances = true;
-    if (!isUndefined$1(list)) {
-        list.forEach((vm) => {
-            const { owner } = vm;
-            if (!isNull(owner)) {
-                // if a component class definition is swapped, we must reset
-                // owner's template content in the next micro-task:
-                forceRehydration(owner);
-            }
-            else {
-                // the hot swapping for components only work for instances of components
-                // created from a template, root elements can't be swapped because we
-                // don't have a way to force the creation of the element with the same state
-                // of the current element.
-                // Instead, we can report the problem to the caller so it can take action,
-                // for example: reload the entire page.
-                canRefreshAllInstances = false;
-            }
-        });
-        // resetting the Set to release the memory of those vm references
-        // since they are not longer related to this constructor, instead
-        // they will get re-associated once these instances are rehydrated.
-        list.clear();
-    }
+    for (const vm of list) {
+        const { owner } = vm;
+        if (!isNull(owner)) {
+            // if a component class definition is swapped, we must reset
+            // owner's template content in the next micro-task:
+            forceRehydration(owner);
+        }
+        else {
+            // the hot swapping for components only work for instances of components
+            // created from a template, root elements can't be swapped because we
+            // don't have a way to force the creation of the element with the same state
+            // of the current element.
+            // Instead, we can report the problem to the caller so it can take action,
+            // for example: reload the entire page.
+            canRefreshAllInstances = false;
+        }
+    }
+    // resetting the Set since these VMs are no longer related to this constructor, instead
+    // they will get re-associated once these instances are rehydrated.
+    activeComponents.delete(Ctor);
     return canRefreshAllInstances;
 }
 function getTemplateOrSwappedTemplate(tpl) {
@@ -3111,75 +3193,27 @@ function setActiveVM(vm) {
     }
     // 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);
+    activeComponents.add(Ctor, 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);
+        activeTemplates.add(tpl, vm);
         // tracking active styles associated to template
         const stylesheets = tpl.stylesheets;
         if (!isUndefined$1(stylesheets)) {
-            flattenStylesheets(stylesheets).forEach((stylesheet) => {
+            for (const stylesheet of flattenStylesheets(stylesheets)) {
                 // 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);
-                }
+                const swappedStylesheet = getStyleOrSwappedStyle(stylesheet);
                 // this will allow us to keep track of the stylesheet that are
                 // being used by a hot component
-                stylesheetVMs.add(vm);
-            });
-        }
-    }
-}
-function removeActiveVM(vm) {
-    if (process.env.NODE_ENV === 'production') {
-        // this method should never leak to prod
-        throw new ReferenceError();
-    }
-    // tracking inactive component
-    const Ctor = vm.def.ctor;
-    let list = activeComponents.get(Ctor);
-    if (!isUndefined$1(list)) {
-        // deleting the vm from the set to avoid leaking memory
-        list.delete(vm);
-    }
-    // removing inactive template
-    const tpl = vm.cmpTemplate;
-    if (tpl) {
-        list = activeTemplates.get(tpl);
-        if (!isUndefined$1(list)) {
-            // deleting the vm from the set to avoid leaking memory
-            list.delete(vm);
-        }
-        // removing active styles associated to template
-        const styles = tpl.stylesheets;
-        if (!isUndefined$1(styles)) {
-            flattenStylesheets(styles).forEach((style) => {
-                list = activeStyles.get(style);
-                if (!isUndefined$1(list)) {
-                    // deleting the vm from the set to avoid leaking memory
-                    list.delete(vm);
-                }
-            });
+                activeStyles.add(swappedStylesheet, vm);
+            }
         }
     }
 }
@@ -5684,9 +5718,6 @@ function resetComponentStateWhenRemoved(vm) {
     runChildNodesDisconnectedCallback(vm);
     runLightChildNodesDisconnectedCallback(vm);
   }
-  if (process.env.NODE_ENV !== 'production') {
-    removeActiveVM(vm);
-  }
 }
 // this method is triggered by the diffing algo only when a vnode from the
 // old vnode.children is removed from the DOM.
@@ -6061,22 +6092,33 @@ function recursivelyDisconnectChildren(vnodes) {
 // into snabbdom. Especially useful when the reset is a consequence of an error, in which case the
 // children VNodes might not be representing the current state of the DOM.
 function resetComponentRoot(vm) {
+  recursivelyRemoveChildren(vm.children, vm);
+  vm.children = EmptyArray;
+  runChildNodesDisconnectedCallback(vm);
+  vm.velements = EmptyArray;
+}
+// Helper function to remove all children of the root node.
+// If the set of children includes VFragment nodes, we need to remove the children of those nodes too.
+// Since VFragments can contain other VFragments, we need to traverse the entire of tree of VFragments.
+// If the set contains no VFragment nodes, no traversal is needed.
+function recursivelyRemoveChildren(vnodes, vm) {
   const {
-    children,
     renderRoot,
     renderer: {
       remove
     }
   } = vm;
-  for (let i = 0, len = children.length; i < len; i++) {
-    const child = children[i];
-    if (!isNull(child) && !isUndefined$1(child.elm)) {
-      remove(child.elm, renderRoot);
+  for (let i = 0, len = vnodes.length; i < len; i += 1) {
+    const vnode = vnodes[i];
+    if (!isNull(vnode)) {
+      // VFragments are special; their .elm property does not point to the root element since they have no single root.
+      if (isVFragment(vnode)) {
+        recursivelyRemoveChildren(vnode.children, vm);
+      } else if (!isUndefined$1(vnode.elm)) {
+        remove(vnode.elm, renderRoot);
+      }
     }
   }
-  vm.children = EmptyArray;
-  runChildNodesDisconnectedCallback(vm);
-  vm.velements = EmptyArray;
 }
 function scheduleRehydration(vm) {
   if (isTrue(vm.isScheduled)) {
@@ -7024,7 +7066,7 @@ function getComponentConstructor(elm) {
     }
     return ctor;
 }
-/* version: 2.31.6 */
+/* version: 2.31.8 */
 
 /*
  * Copyright (c) 2018, salesforce.com, inc.
@@ -7997,7 +8039,7 @@ function rendererFactory(baseRenderer) {
     function isNull(obj) {
         return obj === null;
     }
-    /** version: 2.31.6 */
+    /** version: 2.31.8 */
 
     /*
      * Copyright (c) 2018, salesforce.com, inc.
@@ -8558,6 +8600,6 @@ defineProperty(LightningElement, 'CustomElementConstructor', {
 });
 freeze(LightningElement);
 seal(LightningElement.prototype);
-/* version: 2.31.6 */
+/* version: 2.31.8 */
 
 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 };