lwc 2.38.0 → 2.39.0

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

@@ -321,7 +321,7 @@ var LWC = (function (exports) {
         CACHED_ATTRIBUTE_PROPERTY_MAPPING.set(attrName, propertyName);
         return propertyName;
     }
-    /** version: 2.38.0 */
+    /** version: 2.39.0 */
 
     /**
      * Copyright (C) 2018 salesforce.com, inc.
@@ -389,7 +389,7 @@ var LWC = (function (exports) {
      */
     function setFeatureFlagForTest(name, value) {
     }
-    /** version: 2.38.0 */
+    /** version: 2.39.0 */
 
     /**
      * Copyright (C) 2018 salesforce.com, inc.
@@ -453,7 +453,7 @@ var LWC = (function (exports) {
             }
         }
     }
-    /** version: 2.38.0 */
+    /** version: 2.39.0 */
 
     /*
      * Copyright (c) 2018, salesforce.com, inc.
@@ -2357,10 +2357,101 @@ var LWC = (function (exports) {
     }
     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;
     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 getStyleOrSwappedStyle(style) {
         assertNotProd(); // this method should never leak to prod
         const visited = new Set();
@@ -2374,42 +2465,27 @@ var LWC = (function (exports) {
         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);
+        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);
-                });
+                    activeStyles.add(swappedStylesheet, vm);
+                }
             }
         }
     }
@@ -3281,8 +3357,9 @@ var LWC = (function (exports) {
         }
     }
     function patchCustomElement(n1, n2, parent, renderer) {
+        // TODO [#3331]: This if branch should be removed in 246 with lwc:dynamic
         if (n1.ctor !== n2.ctor) {
-            // If the constructor, unmount the current component and mount a new one using the new
+            // If the constructor differs, unmount the current component and mount a new one using the new
             // constructor.
             const anchor = renderer.nextSibling(n1.elm);
             unmount(n1, parent, renderer, true);
@@ -3732,9 +3809,17 @@ var LWC = (function (exports) {
             if (n2 !== n1) {
                 if (isVNode(n1)) {
                     if (isVNode(n2)) {
-                        // both vnodes are equivalent, and we just need to patch them
-                        patch(n1, n2, parent, renderer);
-                        anchor = n2.elm;
+                        if (isSameVnode(n1, n2)) {
+                            // both vnodes are equivalent, and we just need to patch them
+                            patch(n1, n2, parent, renderer);
+                            anchor = n2.elm;
+                        }
+                        else {
+                            // removing the old vnode since the new one is different
+                            unmount(n1, parent, renderer, true);
+                            mount(n2, parent, renderer, anchor);
+                            anchor = n2.elm;
+                        }
                     }
                     else {
                         // removing the old vnode since the new one is null
@@ -4028,11 +4113,13 @@ var LWC = (function (exports) {
         return url;
     }
     /**
-     * create a dynamic component via `<x-foo lwc:dynamic={Ctor}>`
+     * [ddc] - create a (deprecated) dynamic component via `<x-foo lwc:dynamic={Ctor}>`
+     *
+     * TODO [#3331]: remove usage of lwc:dynamic in 246
      */
-    function dc(sel, Ctor, data, children = EmptyArray) {
+    function ddc(sel, Ctor, data, children = EmptyArray) {
         // null or undefined values should produce a null value in the VNodes
-        if (Ctor == null) {
+        if (isNull(Ctor) || isUndefined$1(Ctor)) {
             return null;
         }
         if (!isComponentConstructor(Ctor)) {
@@ -4040,6 +4127,26 @@ var LWC = (function (exports) {
         }
         return c(sel, Ctor, data, children);
     }
+    /**
+     * [dc] - create a dynamic component via `<lwc:component lwc:is={Ctor}>`
+     */
+    function dc(Ctor, data, children = EmptyArray) {
+        // Null or undefined values should produce a null value in the VNodes.
+        // This is the only value at compile time as the constructor will not be known.
+        if (isNull(Ctor) || isUndefined$1(Ctor)) {
+            return null;
+        }
+        if (!isComponentConstructor(Ctor)) {
+            throw new Error(`Invalid constructor ${toString$1(Ctor)} is not a LightningElement constructor.`);
+        }
+        // Look up the dynamic component's name at runtime once the constructor is available.
+        // This information is only known at runtime and is stored as part of registerComponent.
+        const sel = getComponentRegisteredName(Ctor);
+        if (isUndefined$1(sel) || sel === '') {
+            throw new Error(`Invalid LWC constructor ${toString$1(Ctor)} does not have a registered name`);
+        }
+        return c(sel, Ctor, data, children);
+    }
     /**
      * slow children collection marking mechanism. this API allows the compiler to signal
      * to the engine that a particular collection of children must be diffed using the slow
@@ -4099,6 +4206,7 @@ var LWC = (function (exports) {
         fid,
         shc,
         ssf,
+        ddc,
     });
     /** Indicates if operations should be logged by the profiler. */
     let isProfilerEnabled = false;
@@ -4395,23 +4503,29 @@ 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
      */
-    const signedTemplateMap = new Map();
+    const registeredComponentMap = new Map();
     /**
      * INTERNAL: This function can only be invoked by compiled code. The compiler
      * will prevent this function from being imported by userland code.
      */
     function registerComponent(
     // We typically expect a LightningElementConstructor, but technically you can call this with anything
-    Ctor, { tmpl }) {
+    Ctor, metadata) {
         if (isFunction$1(Ctor)) {
-            signedTemplateMap.set(Ctor, tmpl);
+            // TODO [#3331]: add validation to check the value of metadata.sel is not an empty string.
+            registeredComponentMap.set(Ctor, metadata);
         }
         // chaining this method as a way to wrap existing assignment of component constructor easily,
         // without too much transformation
         return Ctor;
     }
     function getComponentRegisteredTemplate(Ctor) {
-        return signedTemplateMap.get(Ctor);
+        var _a;
+        return (_a = registeredComponentMap.get(Ctor)) === null || _a === void 0 ? void 0 : _a.tmpl;
+    }
+    function getComponentRegisteredName(Ctor) {
+        var _a;
+        return (_a = registeredComponentMap.get(Ctor)) === null || _a === void 0 ? void 0 : _a.sel;
     }
     function getTemplateReactiveObserver(vm) {
         return createReactiveObserver(() => {
@@ -4870,17 +4984,30 @@ var LWC = (function (exports) {
     // 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) {
-        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);
-            }
-        }
+        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 { renderRoot, renderer: { remove }, } = vm;
+        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);
+                }
+            }
+        }
+    }
     function scheduleRehydration(vm) {
         if (isTrue(vm.isScheduled)) {
             return;
@@ -6103,7 +6230,7 @@ var LWC = (function (exports) {
         function isNull(obj) {
             return obj === null;
         }
-        /** version: 2.38.0 */
+        /** version: 2.39.0 */
 
         /*
          * Copyright (c) 2023, salesforce.com, inc.
@@ -6714,7 +6841,7 @@ var LWC = (function (exports) {
             });
         }));
     }
-    /* version: 2.38.0 */
+    /* version: 2.39.0 */
 
     exports.LightningElement = LightningElement;
     exports.__unstable__ProfilerControl = profilerControl;