@lwc/engine-core 6.1.1 → 6.2.1

package/dist/index.cjs.js

@@ -27,8 +27,7 @@ let enabled$1 = false;
 const reportingControl = {
     /**
      * Attach a new reporting control (aka dispatcher).
-     *
-     * @param dispatcher - reporting control
+     * @param dispatcher reporting control
      */
     attachDispatcher(dispatcher) {
         enabled$1 = true;
@@ -71,7 +70,7 @@ function onReportingEnabled(callback) {
 /**
  * Report to the current dispatcher, if there is one.
  * @param reportingEventId
- * @param payload - data to report
+ * @param payload data to report
  */
 function report(reportingEventId, payload) {
     if (enabled$1) {
@@ -236,6 +235,7 @@ class ReactiveObserver {
     }
     observe(job) {
         const inceptionReactiveRecord = currentReactiveObserver;
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
         currentReactiveObserver = this;
         let error;
         try {
@@ -285,6 +285,80 @@ class ReactiveObserver {
         // we keep track of observing records where the observing record was added to so we can do some clean up later on
         shared.ArrayPush.call(this.listeners, reactiveObservers);
     }
+    isObserving() {
+        return currentReactiveObserver === this;
+    }
+}
+
+/*
+ * Copyright (c) 2024, 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
+ */
+/**
+ * This map keeps track of objects to signals. There is an assumption that the signal is strongly referenced
+ * on the object which allows the SignalTracker to be garbage collected along with the object.
+ */
+const TargetToSignalTrackerMap = new WeakMap();
+function getSignalTracker(target) {
+    let signalTracker = TargetToSignalTrackerMap.get(target);
+    if (shared.isUndefined(signalTracker)) {
+        signalTracker = new SignalTracker();
+        TargetToSignalTrackerMap.set(target, signalTracker);
+    }
+    return signalTracker;
+}
+function subscribeToSignal(target, signal, update) {
+    const signalTracker = getSignalTracker(target);
+    if (shared.isFalse(signalTracker.seen(signal))) {
+        signalTracker.subscribeToSignal(signal, update);
+    }
+}
+function unsubscribeFromSignals(target) {
+    if (TargetToSignalTrackerMap.has(target)) {
+        const signalTracker = getSignalTracker(target);
+        signalTracker.unsubscribeFromSignals();
+        signalTracker.reset();
+    }
+}
+/**
+ * This class is used to keep track of the signals associated to a given object.
+ * It is used to prevent the LWC engine from subscribing duplicate callbacks multiple times
+ * to the same signal. Additionally, it keeps track of all signal unsubscribe callbacks, handles invoking
+ * them when necessary and discarding them.
+ */
+class SignalTracker {
+    constructor() {
+        this.signalToUnsubscribeMap = new Map();
+    }
+    seen(signal) {
+        return this.signalToUnsubscribeMap.has(signal);
+    }
+    subscribeToSignal(signal, update) {
+        try {
+            const unsubscribe = signal.subscribe(update);
+            if (shared.isFunction(unsubscribe)) {
+                // TODO [#3978]: Evaluate how we should handle the case when unsubscribe is not a function.
+                // Long term we should throw an error or log a warning.
+                this.signalToUnsubscribeMap.set(signal, unsubscribe);
+            }
+        }
+        catch (err) {
+            logWarnOnce(`Attempted to subscribe to an object that has the shape of a signal but received the following error: ${err?.stack ?? err}`);
+        }
+    }
+    unsubscribeFromSignals() {
+        try {
+            this.signalToUnsubscribeMap.forEach((unsubscribe) => unsubscribe());
+        }
+        catch (err) {
+            logWarnOnce(`Attempted to call a signal's unsubscribe callback but received the following error: ${err?.stack ?? err}`);
+        }
+    }
+    reset() {
+        this.signalToUnsubscribeMap.clear();
+    }
 }
 
 /*
@@ -306,10 +380,26 @@ function componentValueMutated(vm, key) {
         valueMutated(vm.component, key);
     }
 }
-function componentValueObserved(vm, key) {
+function componentValueObserved(vm, key, target = {}) {
+    const { component, tro } = vm;
     // On the server side, we don't need mutation tracking. Skipping it improves performance.
     if (process.env.IS_BROWSER) {
-        valueObserved(vm.component, key);
+        valueObserved(component, key);
+    }
+    // The portion of reactivity that's exposed to signals is to subscribe a callback to re-render the VM (templates).
+    // We check check the following to ensure re-render is subscribed at the correct time.
+    //  1. The template is currently being rendered (there is a template reactive observer)
+    //  2. There was a call to a getter to access the signal (happens during vnode generation)
+    if (lwcRuntimeFlags.ENABLE_EXPERIMENTAL_SIGNALS &&
+        shared.isObject(target) &&
+        !shared.isNull(target) &&
+        'value' in target &&
+        'subscribe' in target &&
+        shared.isFunction(target.subscribe) &&
+        // Only subscribe if a template is being rendered by the engine
+        tro.isObserving()) {
+        // Subscribe the template reactive observer's notify method, which will mark the vm as dirty and schedule hydration.
+        subscribeToSignal(component, target, tro.notify.bind(tro));
     }
 }
 function createReactiveObserver(callback) {
@@ -346,6 +436,7 @@ function addCallbackToNextTick(callback) {
         }
     }
     if (nextTickCallbackQueue.length === 0) {
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
         Promise.resolve().then(flushCallbackQueue);
     }
     shared.ArrayPush.call(nextTickCallbackQueue, callback);
@@ -427,7 +518,11 @@ function applyTemporaryCompilerV5SlotFix(data) {
     if (!shared.isUndefined(attrs)) {
         const { slot } = attrs;
         if (!shared.isUndefined(slot) && !shared.isNull(slot)) {
-            return Object.assign(Object.assign({}, data), { attrs: cloneAndOmitKey(attrs, 'slot'), slotAssignment: String(slot) });
+            return {
+                ...data,
+                attrs: cloneAndOmitKey(attrs, 'slot'),
+                slotAssignment: String(slot),
+            };
         }
     }
     return data;
@@ -441,15 +536,20 @@ function applyTemporaryCompilerV5SlotFix(data) {
  */
 function resolveCircularModuleDependency(fn) {
     const module = fn();
-    return (module === null || module === void 0 ? void 0 : module.__esModule) ? module.default : module;
+    return module?.__esModule ? module.default : module;
 }
 function isCircularModuleDependency(obj) {
     return shared.isFunction(obj) && shared.hasOwnProperty.call(obj, '__circular__');
 }
 
-var _a, _b;
-const instrumentDef = (_a = globalThis.__lwc_instrument_cmp_def) !== null && _a !== void 0 ? _a : shared.noop;
-const instrumentInstance = (_b = globalThis.__lwc_instrument_cmp_instance) !== null && _b !== void 0 ? _b : shared.noop;
+/*
+ * 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 instrumentDef = globalThis.__lwc_instrument_cmp_def ?? shared.noop;
+const instrumentInstance = globalThis.__lwc_instrument_cmp_instance ?? shared.noop;
 
 /*
  * Copyright (c) 2018, salesforce.com, inc.
@@ -1333,6 +1433,7 @@ const reactiveMembrane = new ObservableMembrane({
  * EXPERIMENTAL: This function implements an unwrap mechanism that
  * works for observable membrane objects. This API is subject to
  * change or being removed.
+ * @param value
  */
 function unwrap(value) {
     // On the server side, we don't need mutation tracking. Skipping it improves performance.
@@ -1401,6 +1502,7 @@ function initGlobalStylesheet() {
             }
             return promise;
         });
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
         Promise.all(promises).then((stylesheetTexts) => {
             // When replaceSync() is called, the entire contents of the constructable stylesheet are replaced
             // with the copied+concatenated styles. This means that any shadow root's adoptedStyleSheets that
@@ -1445,6 +1547,8 @@ function applyShadowMigrateMode(shadowRoot) {
  * that a Custom Element can support (including AOM properties), which
  * determines what kind of capabilities the Base Lightning Element should support. When producing the new descriptors
  * for the Base Lightning Element, it also include the reactivity bit, so the standard property is reactive.
+ * @param propName
+ * @param descriptor
  */
 function createBridgeToElementDescriptor(propName, descriptor) {
     const { get, set, enumerable, configurable } = descriptor;
@@ -1494,7 +1598,7 @@ const refsCache = new WeakMap();
 /**
  * This class is the base class for any LWC element.
  * Some elements directly extends this class, others implement it via inheritance.
- **/
+ */
 // @ts-ignore
 const LightningElement = function () {
     // This should be as performant as possible, while any initialization should be done lazily
@@ -1512,7 +1616,6 @@ const LightningElement = function () {
         const { assertInstanceOfHTMLElement } = vm.renderer;
         assertInstanceOfHTMLElement(vm.elm, `Component creation requires a DOM element to be associated to ${vm}.`);
     }
-    const component = this;
     shared.setPrototypeOf(elm, bridge.prototype);
     vm.component = this;
     // Locker hooks assignment. When the LWC engine run with Locker, Locker intercepts all the new
@@ -1527,7 +1630,7 @@ const LightningElement = function () {
     }
     markLockerLiveObject(this);
     // Linking elm, shadow root and component with the VM.
-    associateVM(component, vm);
+    associateVM(this, vm);
     associateVM(elm, vm);
     if (vm.renderMode === 1 /* RenderMode.Shadow */) {
         vm.renderRoot = doAttachShadow(vm);
@@ -1951,8 +2054,9 @@ function createObservedFieldPropertyDescriptor(key) {
     return {
         get() {
             const vm = getAssociatedVM(this);
-            componentValueObserved(vm, key);
-            return vm.cmpFields[key];
+            const val = vm.cmpFields[key];
+            componentValueObserved(vm, key, val);
+            return val;
         },
         set(newValue) {
             const vm = getAssociatedVM(this);
@@ -2063,6 +2167,7 @@ function createConfigWatcher(component, configCallback, callbackWhenConfigIsRead
         if (hasPendingConfig === false) {
             hasPendingConfig = true;
             // collect new config in the micro-task
+            // eslint-disable-next-line @typescript-eslint/no-floating-promises
             Promise.resolve().then(() => {
                 hasPendingConfig = false;
                 // resetting current reactive params
@@ -2205,6 +2310,7 @@ function installWireAdapters(vm) {
                 connector.connect();
                 if (!lwcRuntimeFlags.ENABLE_WIRE_SYNC_EMIT) {
                     if (hasDynamicParams) {
+                        // eslint-disable-next-line @typescript-eslint/no-floating-promises
                         Promise.resolve().then(computeConfigAndUpdate);
                         return;
                     }
@@ -2256,8 +2362,9 @@ function createPublicPropertyDescriptor(key) {
                 }
                 return;
             }
-            componentValueObserved(vm, key);
-            return vm.cmpProps[key];
+            const val = vm.cmpProps[key];
+            componentValueObserved(vm, key, val);
+            return val;
         },
         set(newValue) {
             const vm = getAssociatedVM(this);
@@ -2330,8 +2437,9 @@ function internalTrackDecorator(key) {
     return {
         get() {
             const vm = getAssociatedVM(this);
-            componentValueObserved(vm, key);
-            return vm.cmpFields[key];
+            const val = vm.cmpFields[key];
+            componentValueObserved(vm, key, val);
+            return val;
         },
         set(newValue) {
             const vm = getAssociatedVM(this);
@@ -2359,9 +2467,11 @@ function internalTrackDecorator(key) {
  * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
  */
 /**
- * @wire decorator to wire fields and methods to a wire adapter in
+ * The @wire decorator wires fields and methods to a wire adapter in
  * LWC Components. This function implements the internals of this
  * decorator.
+ * @param _adapter
+ * @param _config
  */
 function wire(_adapter, _config) {
     if (process.env.NODE_ENV !== 'production') {
@@ -2472,6 +2582,8 @@ function validateMethodDecoratedWithApi(Ctor, methodName, descriptor) {
 /**
  * INTERNAL: This function can only be invoked by compiled code. The compiler
  * will prevent this function from being imported by user-land code.
+ * @param Ctor
+ * @param meta
  */
 function registerDecorators(Ctor, meta) {
     const proto = Ctor.prototype;
@@ -2660,6 +2772,7 @@ function isTemplateRegistered(tpl) {
 /**
  * INTERNAL: This function can only be invoked by compiled code. The compiler
  * will prevent this function from being imported by userland code.
+ * @param tpl
  */
 function registerTemplate(tpl) {
     if (process.env.NODE_ENV !== 'production') {
@@ -2673,6 +2786,10 @@ function registerTemplate(tpl) {
 /**
  * EXPERIMENTAL: This function acts like a hook for Lightning Locker Service and other similar
  * libraries to sanitize vulnerable attributes.
+ * @param tagName
+ * @param namespaceUri
+ * @param attrName
+ * @param attrValue
  */
 function sanitizeAttribute(tagName, namespaceUri, attrName, attrValue) {
     // locker-service patches this function during runtime to sanitize vulnerable attributes. When
@@ -3205,6 +3322,14 @@ function createComponentDef(Ctor) {
     let shadowSupportMode = superDef.shadowSupportMode;
     if (!shared.isUndefined(ctorShadowSupportMode)) {
         shadowSupportMode = ctorShadowSupportMode;
+        if (isReportingEnabled() &&
+            (shadowSupportMode === "any" /* ShadowSupportMode.Any */ ||
+                shadowSupportMode === "native" /* ShadowSupportMode.Native */)) {
+            report("ShadowSupportModeUsage" /* ReportingEventId.ShadowSupportModeUsage */, {
+                tagName: Ctor.name,
+                mode: shadowSupportMode,
+            });
+        }
     }
     let renderMode = superDef.renderMode;
     if (!shared.isUndefined(ctorRenderMode)) {
@@ -3250,6 +3375,7 @@ function createComponentDef(Ctor) {
 /**
  * EXPERIMENTAL: This function allows for the identification of LWC constructors. This API is
  * subject to change or being removed.
+ * @param ctor
  */
 function isComponentConstructor(ctor) {
     if (!shared.isFunction(ctor)) {
@@ -3323,6 +3449,7 @@ const lightingElementDef = {
 /**
  * EXPERIMENTAL: This function allows for the collection of internal component metadata. This API is
  * subject to change or being removed.
+ * @param Ctor
  */
 function getComponentDef(Ctor) {
     const def = getComponentInternalDef(Ctor);
@@ -3519,12 +3646,14 @@ function getNearestShadowComponent(vm) {
  * If the component that is currently being rendered uses scoped styles,
  * this returns the unique token for that scoped stylesheet. Otherwise
  * it returns null.
+ * @param owner
+ * @param legacy
  */
 // TODO [#3733]: remove support for legacy scope tokens
 function getScopeTokenClass(owner, legacy) {
     const { cmpTemplate, context } = owner;
     return ((context.hasScopedStyles &&
-        (legacy ? cmpTemplate === null || cmpTemplate === void 0 ? void 0 : cmpTemplate.legacyStylesheetToken : cmpTemplate === null || cmpTemplate === void 0 ? void 0 : cmpTemplate.stylesheetToken)) ||
+        (legacy ? cmpTemplate?.legacyStylesheetToken : cmpTemplate?.stylesheetToken)) ||
         null);
 }
 /**
@@ -3532,6 +3661,7 @@ function getScopeTokenClass(owner, legacy) {
  * exists. Otherwise it returns null.
  *
  * A host style token is applied to the component if scoped styles are used.
+ * @param vnode
  */
 function getStylesheetTokenHost(vnode) {
     const { template } = getComponentInternalDef(vnode.ctor);
@@ -3651,7 +3781,7 @@ function patchAttributes(oldVnode, vnode, renderer) {
 }
 function patchSlotAssignment(oldVnode, vnode, renderer) {
     const { slotAssignment } = vnode;
-    if ((oldVnode === null || oldVnode === void 0 ? void 0 : oldVnode.slotAssignment) === slotAssignment) {
+    if (oldVnode?.slotAssignment === slotAssignment) {
         return;
     }
     const { elm } = vnode;
@@ -3728,6 +3858,8 @@ function getMapFromClassName(className) {
         return EmptyObject;
     }
     // computed class names must be string
+    // This will throw if className is a symbol or null-prototype object
+    // eslint-disable-next-line @typescript-eslint/restrict-plus-operands
     className = shared.isString(className) ? className : className + '';
     let map = classNameToClassMap[className];
     if (map) {
@@ -3808,9 +3940,8 @@ function patchStyleAttribute(oldVnode, vnode, renderer) {
  * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
  */
 function applyEventListeners(vnode, renderer) {
-    var _a;
     const { elm } = vnode;
-    const on = (_a = vnode.data) === null || _a === void 0 ? void 0 : _a.on;
+    const on = vnode.data?.on;
     if (shared.isUndefined(on)) {
         return;
     }
@@ -3939,13 +4070,11 @@ function traverseAndSetElements(root, parts, renderer) {
 }
 /**
  * Given an array of static parts, do all the mounting required for these parts.
- *
- * @param root - the root element
- * @param vnode - the parent VStatic
- * @param renderer - the renderer to use
- * @param mount - true this is a first (mount) render as opposed to a subsequent (patch) render
+ * @param root the root element
+ * @param vnode the parent VStatic
+ * @param renderer the renderer to use
  */
-function applyStaticParts(root, vnode, renderer, mount) {
+function mountStaticParts(root, vnode, renderer) {
     // On the server, we don't support ref (because it relies on renderedCallback), nor do we
     // support event listeners (no interactivity), so traversing parts makes no sense
     if (!process.env.IS_BROWSER) {
@@ -3955,20 +4084,45 @@ function applyStaticParts(root, vnode, renderer, mount) {
     if (shared.isUndefined(parts)) {
         return;
     }
-    // This adds `part.elm` to each `part`. We have to do this on every mount/patch because the `parts`
+    // This adds `part.elm` to each `part`. We have to do this on every mount because the `parts`
     // array is recreated from scratch every time, so each `part.elm` is now undefined.
-    // TODO [#3800]: avoid calling traverseAndSetElements on every re-render
     traverseAndSetElements(root, parts, renderer);
     // Currently only event listeners and refs are supported for static vnodes
     for (const part of parts) {
-        if (mount) {
-            // Event listeners only need to be applied once when mounting
-            applyEventListeners(part, renderer);
-        }
+        // Event listeners only need to be applied once when mounting
+        applyEventListeners(part, renderer);
         // Refs must be updated after every render due to refVNodes getting reset before every render
         applyRefs(part, owner);
     }
 }
+/**
+ * Mounts elements to the newly generated VStatic node
+ * @param n1 the previous VStatic vnode
+ * @param n2 the current VStatic vnode
+ */
+function patchStaticParts(n1, n2) {
+    // On the server, we don't support ref (because it relies on renderedCallback), nor do we
+    // support event listeners (no interactivity), so traversing parts makes no sense
+    if (!process.env.IS_BROWSER) {
+        return;
+    }
+    const { parts: currParts, owner: currPartsOwner } = n2;
+    if (shared.isUndefined(currParts)) {
+        return;
+    }
+    const { parts: prevParts } = n1;
+    if (process.env.NODE_ENV !== 'production') {
+        shared.assert.isTrue(currParts.length === prevParts?.length, 'Expected static parts to be the same for the same element. This is an error with the LWC framework itself.');
+    }
+    for (let i = 0; i < currParts.length; i++) {
+        const part = currParts[i];
+        // Patch only occurs if the vnode is newly generated, which means the part.elm is always undefined
+        // Since the vnode and elements are the same we can safely assume that prevParts[i].elm is defined.
+        part.elm = prevParts[i].elm;
+        // Refs must be updated after every render due to refVNodes getting reset before every render
+        applyRefs(part, currPartsOwner);
+    }
+}
 
 /*
  * Copyright (c) 2018, salesforce.com, inc.
@@ -3985,7 +4139,6 @@ function patchChildren(c1, c2, parent, renderer) {
     }
 }
 function patch(n1, n2, parent, renderer) {
-    var _a, _b;
     if (n1 === n2) {
         return;
     }
@@ -4018,15 +4171,14 @@ function patch(n1, n2, parent, renderer) {
             patchFragment(n1, n2, parent, renderer);
             break;
         case 2 /* VNodeType.Element */:
-            patchElement(n1, n2, (_a = n2.data.renderer) !== null && _a !== void 0 ? _a : renderer);
+            patchElement(n1, n2, n2.data.renderer ?? renderer);
             break;
         case 3 /* VNodeType.CustomElement */:
-            patchCustomElement(n1, n2, parent, (_b = n2.data.renderer) !== null && _b !== void 0 ? _b : renderer);
+            patchCustomElement(n1, n2, parent, n2.data.renderer ?? renderer);
             break;
     }
 }
 function mount(node, parent, renderer, anchor) {
-    var _a, _b;
     switch (node.type) {
         case 0 /* VNodeType.Text */:
             // VText has no special capability, fallback to the owner's renderer
@@ -4045,11 +4197,11 @@ function mount(node, parent, renderer, anchor) {
             break;
         case 2 /* VNodeType.Element */:
             // If the vnode data has a renderer override use it, else fallback to owner's renderer
-            mountElement(node, parent, anchor, (_a = node.data.renderer) !== null && _a !== void 0 ? _a : renderer);
+            mountElement(node, parent, anchor, node.data.renderer ?? renderer);
             break;
         case 3 /* VNodeType.CustomElement */:
             // If the vnode data has a renderer override use it, else fallback to owner's renderer
-            mountCustomElement(node, parent, anchor, (_b = node.data.renderer) !== null && _b !== void 0 ? _b : renderer);
+            mountCustomElement(node, parent, anchor, node.data.renderer ?? renderer);
             break;
     }
 }
@@ -4111,11 +4263,11 @@ function mountElement(vnode, parent, anchor, renderer) {
     mountVNodes(vnode.children, elm, renderer, null);
 }
 function patchStatic(n1, n2, renderer) {
-    const elm = (n2.elm = n1.elm);
+    n2.elm = n1.elm;
     // slotAssignments can only apply to the top level element, never to a static part.
     patchSlotAssignment(n1, n2, renderer);
     // The `refs` object is blown away in every re-render, so we always need to re-apply them
-    applyStaticParts(elm, n2, renderer, false);
+    patchStaticParts(n1, n2);
 }
 function patchElement(n1, n2, renderer) {
     const elm = (n2.elm = n1.elm);
@@ -4138,7 +4290,7 @@ function mountStatic(vnode, parent, anchor, renderer) {
     // slotAssignments can only apply to the top level element, never to a static part.
     patchSlotAssignment(null, vnode, renderer);
     insertNode(elm, parent, anchor, renderer);
-    applyStaticParts(elm, vnode, renderer, true);
+    mountStaticParts(elm, vnode, renderer);
 }
 function mountCustomElement(vnode, parent, anchor, renderer) {
     const { sel, owner, ctor } = vnode;
@@ -4400,17 +4552,15 @@ function applyStyleScoping(elm, owner, renderer) {
     }
 }
 function applyDomManual(elm, vnode) {
-    var _a;
     const { owner, data: { context }, } = vnode;
-    if (owner.shadowMode === 1 /* ShadowMode.Synthetic */ && ((_a = context === null || context === void 0 ? void 0 : context.lwc) === null || _a === void 0 ? void 0 : _a.dom) === "manual" /* LwcDomMode.Manual */) {
+    if (owner.shadowMode === 1 /* ShadowMode.Synthetic */ && context?.lwc?.dom === "manual" /* LwcDomMode.Manual */) {
         elm.$domManual$ = true;
     }
 }
 function applyElementRestrictions(elm, vnode) {
-    var _a, _b;
     if (process.env.NODE_ENV !== 'production') {
         const isSynthetic = vnode.owner.shadowMode === 1 /* ShadowMode.Synthetic */;
-        const isPortal = vnode.type === 2 /* VNodeType.Element */ && ((_b = (_a = vnode.data.context) === null || _a === void 0 ? void 0 : _a.lwc) === null || _b === void 0 ? void 0 : _b.dom) === "manual" /* LwcDomMode.Manual */;
+        const isPortal = vnode.type === 2 /* VNodeType.Element */ && vnode.data.context?.lwc?.dom === "manual" /* LwcDomMode.Manual */;
         const isLight = vnode.owner.renderMode === 0 /* RenderMode.Light */;
         patchElementWithRestrictions(elm, {
             isPortal,
@@ -4463,6 +4613,7 @@ function allocateChildren(vnode, vm) {
  * With the delimiters removed, the contents are marked dynamic so they are diffed correctly.
  *
  * This function is used for slotted VFragments to avoid the text delimiters interfering with slotting functionality.
+ * @param children
  */
 function flattenFragmentsInChildren(children) {
     const flattenedChildren = [];
@@ -4517,7 +4668,6 @@ function createViewModelHook(elm, vnode, renderer) {
     return vm;
 }
 function allocateInSlot(vm, children, owner) {
-    var _a;
     const { cmpSlots: { slotAssignments: oldSlotsMapping }, } = vm;
     const cmpSlotsMapping = shared.create(null);
     // Collect all slots into cmpSlotsMapping
@@ -4528,7 +4678,7 @@ function allocateInSlot(vm, children, owner) {
         }
         let slotName = '';
         if (isVBaseElement(vnode) || isVStatic(vnode)) {
-            slotName = (_a = vnode.slotAssignment) !== null && _a !== void 0 ? _a : '';
+            slotName = vnode.slotAssignment ?? '';
         }
         else if (isVScopedSlotFragment(vnode)) {
             slotName = vnode.slotName;
@@ -4537,6 +4687,7 @@ function allocateInSlot(vm, children, owner) {
         // but elm.setAttribute('slot', Symbol(1)) is an error.
         // the following line also throws same error for symbols
         // Similar for Object.create(null)
+        // eslint-disable-next-line @typescript-eslint/restrict-plus-operands
         const normalizedSlotName = '' + slotName;
         const vnodes = (cmpSlotsMapping[normalizedSlotName] =
             cmpSlotsMapping[normalizedSlotName] || []);
@@ -4934,11 +5085,11 @@ function s(slotName, data, children, slotset) {
                         // to the vnode because the current way the diffing algo works, it will replace the original reference
                         // to the host element with a new one. This means the new element will be mounted and immediately unmounted.
                         // Creating a copy of the vnode to preserve a reference to the previous host element.
-                        clonedVNode = Object.assign(Object.assign({}, vnode), { slotAssignment: data.slotAssignment });
+                        clonedVNode = { ...vnode, slotAssignment: data.slotAssignment };
                     }
                     // If the slot content is standard type, the content is static, no additional
                     // processing needed on the vnode
-                    shared.ArrayPush.call(newChildren, clonedVNode !== null && clonedVNode !== void 0 ? clonedVNode : vnode);
+                    shared.ArrayPush.call(newChildren, clonedVNode ?? vnode);
                 }
             }
         }
@@ -5076,6 +5227,7 @@ function i(iterable, factory) {
 }
 /**
  * [f]lattening
+ * @param items
  */
 function f(items) {
     if (process.env.NODE_ENV !== 'production') {
@@ -5192,6 +5344,10 @@ function fid(url) {
  * [ddc] - create a (deprecated) dynamic component via `<x-foo lwc:dynamic={Ctor}>`
  *
  * TODO [#3331]: remove usage of lwc:dynamic in 246
+ * @param sel
+ * @param Ctor
+ * @param data
+ * @param children
  */
 function ddc(sel, Ctor, data, children = EmptyArray) {
     if (process.env.NODE_ENV !== 'production') {
@@ -5210,6 +5366,9 @@ function ddc(sel, Ctor, data, children = EmptyArray) {
 }
 /**
  * [dc] - create a dynamic component via `<lwc:component lwc:is={Ctor}>`
+ * @param Ctor
+ * @param data
+ * @param children
  */
 function dc(Ctor, data, children = EmptyArray) {
     if (process.env.NODE_ENV !== 'production') {
@@ -5237,13 +5396,13 @@ function dc(Ctor, data, children = EmptyArray) {
  * to the engine that a particular collection of children must be diffed using the slow
  * algo based on keys due to the nature of the list. E.g.:
  *
- *   - slot element's children: the content of the slot has to be dynamic when in synthetic
- *                              shadow mode because the `vnode.children` might be the slotted
- *                              content vs default content, in which case the size and the
- *                              keys are not matching.
- *   - children that contain dynamic components
- *   - children that are produced by iteration
- *
+ * - slot element's children: the content of the slot has to be dynamic when in synthetic
+ * shadow mode because the `vnode.children` might be the slotted
+ * content vs default content, in which case the size and the
+ * keys are not matching.
+ * - children that contain dynamic components
+ * - children that are produced by iteration
+ * @param vnodes
  */
 function sc(vnodes) {
     if (process.env.NODE_ENV !== 'production') {
@@ -5267,6 +5426,7 @@ let sanitizeHtmlContentHook = () => {
 };
 /**
  * Sets the sanitizeHtmlContentHook.
+ * @param newHookImpl
  */
 function setSanitizeHtmlContentHook(newHookImpl) {
     sanitizeHtmlContentHook = newHookImpl;
@@ -5397,7 +5557,7 @@ function logGlobalOperationStart(opId, vm) {
         start(markName);
     }
     if (isProfilerEnabled) {
-        currentDispatcher(opId, 0 /* Phase.Start */, vm === null || vm === void 0 ? void 0 : vm.tagName, vm === null || vm === void 0 ? void 0 : vm.idx, vm === null || vm === void 0 ? void 0 : vm.renderMode, vm === null || vm === void 0 ? void 0 : vm.shadowMode);
+        currentDispatcher(opId, 0 /* Phase.Start */, vm?.tagName, vm?.idx, vm?.renderMode, vm?.shadowMode);
     }
 }
 function logGlobalOperationEnd(opId, vm) {
@@ -5407,7 +5567,7 @@ function logGlobalOperationEnd(opId, vm) {
         end(opName, markName);
     }
     if (isProfilerEnabled) {
-        currentDispatcher(opId, 1 /* Phase.Stop */, vm === null || vm === void 0 ? void 0 : vm.tagName, vm === null || vm === void 0 ? void 0 : vm.idx, vm === null || vm === void 0 ? void 0 : vm.renderMode, vm === null || vm === void 0 ? void 0 : vm.shadowMode);
+        currentDispatcher(opId, 1 /* Phase.Stop */, vm?.tagName, vm?.idx, vm?.renderMode, vm?.shadowMode);
     }
 }
 
@@ -5429,7 +5589,6 @@ function validateSlots(vm) {
     assertNotProd(); // this method should never leak to prod
     const { cmpSlots } = vm;
     for (const slotName in cmpSlots.slotAssignments) {
-        // eslint-disable-next-line @lwc/lwc-internal/no-production-assert
         shared.assert.isTrue(shared.isArray(cmpSlots.slotAssignments[slotName]), `Slots can only be set to an array, instead received ${shared.toString(cmpSlots.slotAssignments[slotName])} for slot "${slotName}" in ${vm}.`);
     }
 }
@@ -5709,6 +5868,8 @@ 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.
+ * @param Ctor
+ * @param metadata
  */
 function registerComponent(
 // We typically expect a LightningElementConstructor, but technically you can call this with anything
@@ -5727,16 +5888,14 @@ Ctor, metadata) {
     return Ctor;
 }
 function getComponentRegisteredTemplate(Ctor) {
-    var _a;
-    return (_a = registeredComponentMap.get(Ctor)) === null || _a === void 0 ? void 0 : _a.tmpl;
+    return registeredComponentMap.get(Ctor)?.tmpl;
 }
 function getComponentRegisteredName(Ctor) {
-    var _a;
-    return (_a = registeredComponentMap.get(Ctor)) === null || _a === void 0 ? void 0 : _a.sel;
+    return registeredComponentMap.get(Ctor)?.sel;
 }
 function getComponentAPIVersion(Ctor) {
     const metadata = registeredComponentMap.get(Ctor);
-    const apiVersion = metadata === null || metadata === void 0 ? void 0 : metadata.apiVersion;
+    const apiVersion = metadata?.apiVersion;
     if (shared.isUndefined(apiVersion)) {
         // This should only occur in our Karma tests; in practice every component
         // is registered, and so this code path should not get hit. But to be safe,
@@ -5754,11 +5913,27 @@ function getTemplateReactiveObserver(vm) {
         }
     });
 }
+function resetTemplateObserverAndUnsubscribe(vm) {
+    const { tro, component } = vm;
+    tro.reset();
+    // Unsubscribe every time the template reactive observer is reset.
+    if (lwcRuntimeFlags.ENABLE_EXPERIMENTAL_SIGNALS) {
+        unsubscribeFromSignals(component);
+    }
+}
 function renderComponent(vm) {
     if (process.env.NODE_ENV !== 'production') {
         shared.assert.invariant(vm.isDirty, `${vm} is not dirty.`);
     }
-    vm.tro.reset();
+    // The engine should only hold a subscription to a signal if it is rendered in the template.
+    // Because of the potential presence of conditional rendering logic, we unsubscribe on each render
+    // in the scenario where it is present in one condition but not the other.
+    // For example:
+    // 1. There is an lwc:if=true conditional where the signal is present on the template.
+    // 2. The lwc:if changes to false and the signal is no longer present on the template.
+    // If the signal is still subscribed to, the template will re-render when it receives a notification
+    // from the signal, even though we won't be using the new value.
+    resetTemplateObserverAndUnsubscribe(vm);
     const vnodes = invokeComponentRenderMethod(vm);
     vm.isDirty = false;
     vm.isScheduled = false;
@@ -5833,9 +6008,8 @@ function appendVM(vm) {
 function resetComponentStateWhenRemoved(vm) {
     const { state } = vm;
     if (state !== 2 /* VMState.disconnected */) {
-        const { tro } = vm;
         // Making sure that any observing record will not trigger the rehydrated on this vm
-        tro.reset();
+        resetTemplateObserverAndUnsubscribe(vm);
         runDisconnectedCallback(vm);
         // Spec: https://dom.spec.whatwg.org/#concept-node-remove (step 14-15)
         runChildNodesDisconnectedCallback(vm);
@@ -6053,7 +6227,7 @@ function computeShadowMode(def, owner, renderer, hydrated) {
     return shadowMode;
 }
 function assertIsVM(obj) {
-    if (shared.isNull(obj) || !shared.isObject(obj) || !('renderRoot' in obj)) {
+    if (!shared.isObject(obj) || shared.isNull(obj) || !('renderRoot' in obj)) {
         throw new TypeError(`${obj} is not a VM.`);
     }
 }
@@ -6148,7 +6322,7 @@ function flushRehydrationQueue() {
             logGlobalOperationEnd(8 /* OperationId.GlobalRehydrate */);
             // re-throwing the original error will break the current tick, but since the next tick is
             // already scheduled, it should continue patching the rest.
-            throw error; // eslint-disable-line no-unsafe-finally
+            throw error;
         }
     }
     logGlobalOperationEnd(8 /* OperationId.GlobalRehydrate */);
@@ -6246,6 +6420,7 @@ function runLightChildNodesDisconnectedCallback(vm) {
  * need to continue into its children because by attempting to disconnect the
  * custom element itself will trigger the removal of anything slotted or anything
  * defined on its shadow.
+ * @param vnodes
  */
 function recursivelyDisconnectChildren(vnodes) {
     for (let i = 0, len = vnodes.length; i < len; i += 1) {
@@ -6621,7 +6796,7 @@ function checkAndReportViolation(elm, prop, isSetter, setValue) {
         setValueType = shared.isNull(setValue) ? 'null' : typeof setValue;
     }
     report("NonStandardAriaReflection" /* ReportingEventId.NonStandardAriaReflection */, {
-        tagName: vm === null || vm === void 0 ? void 0 : vm.tagName,
+        tagName: vm?.tagName,
         propertyName: prop,
         isSetter,
         setValueType,
@@ -6699,7 +6874,6 @@ function hydrateVM(vm) {
     runRenderedCallback(vm);
 }
 function hydrateNode(node, vnode, renderer) {
-    var _a, _b;
     let hydratedNode;
     switch (vnode.type) {
         case 0 /* VNodeType.Text */:
@@ -6719,10 +6893,10 @@ function hydrateNode(node, vnode, renderer) {
             hydratedNode = hydrateFragment(node, vnode, renderer);
             break;
         case 2 /* VNodeType.Element */:
-            hydratedNode = hydrateElement(node, vnode, (_a = vnode.data.renderer) !== null && _a !== void 0 ? _a : renderer);
+            hydratedNode = hydrateElement(node, vnode, vnode.data.renderer ?? renderer);
             break;
         case 3 /* VNodeType.CustomElement */:
-            hydratedNode = hydrateCustomElement(node, vnode, (_b = vnode.data.renderer) !== null && _b !== void 0 ? _b : renderer);
+            hydratedNode = hydrateCustomElement(node, vnode, vnode.data.renderer ?? renderer);
             break;
     }
     return renderer.nextSibling(hydratedNode);
@@ -6765,7 +6939,6 @@ function getValidationPredicate(optOutStaticProp) {
     return (_attrName) => true;
 }
 function hydrateText(node, vnode, renderer) {
-    var _a;
     if (!hasCorrectNodeType(vnode, node, 3 /* EnvNodeTypes.TEXT */, renderer)) {
         return handleMismatch(node, vnode, renderer);
     }
@@ -6775,12 +6948,11 @@ function hydrateText(node, vnode, renderer) {
         }
     }
     const { setText } = renderer;
-    setText(node, (_a = vnode.text) !== null && _a !== void 0 ? _a : null);
+    setText(node, vnode.text ?? null);
     vnode.elm = node;
     return node;
 }
 function hydrateComment(node, vnode, renderer) {
-    var _a;
     if (!hasCorrectNodeType(vnode, node, 8 /* EnvNodeTypes.COMMENT */, renderer)) {
         return handleMismatch(node, vnode, renderer);
     }
@@ -6792,7 +6964,7 @@ function hydrateComment(node, vnode, renderer) {
         }
     }
     const { setProperty } = renderer;
-    setProperty(node, NODE_VALUE_PROP, (_a = vnode.text) !== null && _a !== void 0 ? _a : null);
+    setProperty(node, NODE_VALUE_PROP, vnode.text ?? null);
     vnode.elm = node;
     return node;
 }
@@ -6802,7 +6974,7 @@ function hydrateStaticElement(elm, vnode, renderer) {
         return handleMismatch(elm, vnode, renderer);
     }
     vnode.elm = elm;
-    applyStaticParts(elm, vnode, renderer, true);
+    mountStaticParts(elm, vnode, renderer);
     return elm;
 }
 function hydrateFragment(elm, vnode, renderer) {
@@ -6827,7 +6999,10 @@ function hydrateElement(elm, vnode, renderer) {
         if (!shared.isUndefined(props) && !shared.isUndefined(props.innerHTML)) {
             if (getProperty(elm, 'innerHTML') === props.innerHTML) {
                 // Do a shallow clone since VNodeData may be shared across VNodes due to hoist optimization
-                vnode.data = Object.assign(Object.assign({}, vnode.data), { props: cloneAndOmitKey(props, 'innerHTML') });
+                vnode.data = {
+                    ...vnode.data,
+                    props: cloneAndOmitKey(props, 'innerHTML'),
+                };
             }
             else {
                 if (process.env.NODE_ENV !== 'production') {
@@ -7039,7 +7214,11 @@ function validateClassAttr(vnode, elm, renderer) {
             className = shared.ArrayJoin.call(classNames, ' ');
         }
         else if (!shared.isUndefined(classMap)) {
-            classMap = Object.assign(Object.assign(Object.assign({}, classMap), (!shared.isNull(scopedToken) ? { [scopedToken]: true } : {})), (!shared.isNull(stylesheetTokenHost) ? { [stylesheetTokenHost]: true } : {}));
+            classMap = {
+                ...classMap,
+                ...(!shared.isNull(scopedToken) ? { [scopedToken]: true } : {}),
+                ...(!shared.isNull(stylesheetTokenHost) ? { [stylesheetTokenHost]: true } : {}),
+            };
         }
         else {
             // The order of the className should be scopedToken stylesheetTokenHost
@@ -7397,6 +7576,7 @@ function freezeTemplate(tmpl) {
 /**
  * EXPERIMENTAL: This function provides access to the component constructor, given an HTMLElement.
  * This API is subject to change or being removed.
+ * @param elm
  */
 function getComponentConstructor(elm) {
     let ctor = null;
@@ -7421,6 +7601,7 @@ function getComponentConstructor(elm) {
  * EXPERIMENTAL: This function allows you to create a reactive readonly
  * membrane around any object value. This API is subject to change or
  * being removed.
+ * @param obj
  */
 function readonly(obj) {
     if (process.env.NODE_ENV !== 'production') {
@@ -7475,5 +7656,5 @@ exports.swapTemplate = swapTemplate;
 exports.track = track;
 exports.unwrap = unwrap;
 exports.wire = wire;
-/** version: 6.1.1 */
+/** version: 6.2.1 */
 //# sourceMappingURL=index.cjs.js.map