lwc 2.43.0 → 2.45.0

package/dist/synthetic-shadow/esm/es2017/synthetic-shadow.js

@@ -43,7 +43,7 @@ var assert = /*#__PURE__*/Object.freeze({
  */
 const { assign, create, defineProperties, defineProperty, freeze, getOwnPropertyDescriptor, getOwnPropertyNames, getPrototypeOf, hasOwnProperty, isFrozen, keys, seal, setPrototypeOf, } = Object;
 const { isArray } = Array;
-const { concat: ArrayConcat, copyWithin: ArrayCopyWithin, fill: ArrayFill, filter: ArrayFilter, find: ArrayFind, indexOf: ArrayIndexOf, join: ArrayJoin, map: ArrayMap, pop: ArrayPop, push: ArrayPush, reduce: ArrayReduce, reverse: ArrayReverse, shift: ArrayShift, slice: ArraySlice, some: ArraySome, sort: ArraySort, splice: ArraySplice, unshift: ArrayUnshift, forEach, } = Array.prototype;
+const { concat: ArrayConcat, copyWithin: ArrayCopyWithin, fill: ArrayFill, filter: ArrayFilter, find: ArrayFind, findIndex: ArrayFindIndex, indexOf: ArrayIndexOf, join: ArrayJoin, map: ArrayMap, pop: ArrayPop, push: ArrayPush, reduce: ArrayReduce, reverse: ArrayReverse, shift: ArrayShift, slice: ArraySlice, some: ArraySome, sort: ArraySort, splice: ArraySplice, unshift: ArrayUnshift, forEach, } = Array.prototype;
 const { charCodeAt: StringCharCodeAt, replace: StringReplace, split: StringSplit, slice: StringSlice, toLowerCase: StringToLowerCase, } = String.prototype;
 function isUndefined(obj) {
     return obj === undefined;
@@ -120,7 +120,7 @@ const KEY__NATIVE_QUERY_SELECTOR_ALL = '$nativeQuerySelectorAll$';
 // We use this to detect symbol support in order to avoid the expensive symbol polyfill. Note that
 // we can't use typeof since it will fail when transpiling.
 const hasNativeSymbolSupport = /*@__PURE__*/ (() => Symbol('x').toString() === 'Symbol(x)')();
-/** version: 2.43.0 */
+/** version: 2.45.0 */
 
 /**
  * Copyright (C) 2018 salesforce.com, inc.
@@ -129,7 +129,7 @@ const hasNativeSymbolSupport = /*@__PURE__*/ (() => Symbol('x').toString() === '
 if (!_globalThis.lwcRuntimeFlags) {
     Object.defineProperty(_globalThis, 'lwcRuntimeFlags', { value: create(null) });
 }
-/** version: 2.43.0 */
+/** version: 2.45.0 */
 
 /*
  * Copyright (c) 2018, salesforce.com, inc.
@@ -1503,7 +1503,7 @@ if (hasOwnProperty.call(HTMLElement.prototype, 'parentElement')) {
  */
 const EventListenerMap = new WeakMap();
 const ComposedPathMap = new WeakMap();
-function isEventListenerOrEventListenerObject(fnOrObj) {
+function isEventListenerOrEventListenerObject$1(fnOrObj) {
     return (isFunction(fnOrObj) ||
         (isObject(fnOrObj) &&
             !isNull(fnOrObj) &&
@@ -1524,7 +1524,7 @@ function shouldInvokeListener(event, target, currentTarget) {
     return composedPath.includes(currentTarget);
 }
 function getEventListenerWrapper(fnOrObj) {
-    if (!isEventListenerOrEventListenerObject(fnOrObj)) {
+    if (!isEventListenerOrEventListenerObject$1(fnOrObj)) {
         return fnOrObj;
     }
     let wrapperFn = EventListenerMap.get(fnOrObj);
@@ -1555,6 +1555,17 @@ function getEventListenerWrapper(fnOrObj) {
  * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
  */
 const eventToContextMap = new WeakMap();
+function getEventHandler(listener) {
+    if (isFunction(listener)) {
+        return listener;
+    }
+    else {
+        return listener.handleEvent;
+    }
+}
+function isEventListenerOrEventListenerObject(listener) {
+    return isFunction(listener) || isFunction(listener === null || listener === void 0 ? void 0 : listener.handleEvent);
+}
 const customElementToWrappedListeners = new WeakMap();
 function getEventMap(elm) {
     let listenerInfo = customElementToWrappedListeners.get(elm);
@@ -1574,49 +1585,58 @@ function getActualTarget(event) {
     return (_a = eventToShadowRootMap.get(event)) !== null && _a !== void 0 ? _a : eventTargetGetter.call(event);
 }
 const shadowRootEventListenerMap = new WeakMap();
-function getWrappedShadowRootListener(listener) {
-    if (!isFunction(listener)) {
+function getManagedShadowRootListener(listener) {
+    if (!isEventListenerOrEventListenerObject(listener)) {
         throw new TypeError(); // avoiding problems with non-valid listeners
     }
-    let shadowRootWrappedListener = shadowRootEventListenerMap.get(listener);
-    if (isUndefined(shadowRootWrappedListener)) {
-        shadowRootWrappedListener = function (event) {
-            // currentTarget is always defined inside an event listener
-            let currentTarget = eventCurrentTargetGetter.call(event);
-            // If currentTarget is not an instance of a native shadow root then we're dealing with a
-            // host element whose synthetic shadow root must be accessed via getShadowRoot().
-            if (!isInstanceOfNativeShadowRoot(currentTarget)) {
-                currentTarget = getShadowRoot(currentTarget);
-            }
-            const actualTarget = getActualTarget(event);
-            if (shouldInvokeListener(event, actualTarget, currentTarget)) {
-                listener.call(currentTarget, event);
-            }
+    let managedListener = shadowRootEventListenerMap.get(listener);
+    if (isUndefined(managedListener)) {
+        managedListener = {
+            identity: listener,
+            placement: 1 /* EventListenerContext.SHADOW_ROOT_LISTENER */,
+            handleEvent(event) {
+                // currentTarget is always defined inside an event listener
+                let currentTarget = eventCurrentTargetGetter.call(event);
+                // If currentTarget is not an instance of a native shadow root then we're dealing with a
+                // host element whose synthetic shadow root must be accessed via getShadowRoot().
+                if (!isInstanceOfNativeShadowRoot(currentTarget)) {
+                    currentTarget = getShadowRoot(currentTarget);
+                }
+                const actualTarget = getActualTarget(event);
+                if (shouldInvokeListener(event, actualTarget, currentTarget)) {
+                    getEventHandler(listener).call(currentTarget, event);
+                }
+            },
         };
-        shadowRootWrappedListener.placement = 1 /* EventListenerContext.SHADOW_ROOT_LISTENER */;
-        shadowRootEventListenerMap.set(listener, shadowRootWrappedListener);
+        shadowRootEventListenerMap.set(listener, managedListener);
     }
-    return shadowRootWrappedListener;
+    return managedListener;
 }
 const customElementEventListenerMap = new WeakMap();
-function getWrappedCustomElementListener(listener) {
-    if (!isFunction(listener)) {
+function getManagedCustomElementListener(listener) {
+    if (!isEventListenerOrEventListenerObject(listener)) {
         throw new TypeError(); // avoiding problems with non-valid listeners
     }
-    let customElementWrappedListener = customElementEventListenerMap.get(listener);
-    if (isUndefined(customElementWrappedListener)) {
-        customElementWrappedListener = function (event) {
-            // currentTarget is always defined inside an event listener
-            const currentTarget = eventCurrentTargetGetter.call(event);
-            const actualTarget = getActualTarget(event);
-            if (shouldInvokeListener(event, actualTarget, currentTarget)) {
-                listener.call(currentTarget, event);
-            }
+    let managedListener = customElementEventListenerMap.get(listener);
+    if (isUndefined(managedListener)) {
+        managedListener = {
+            identity: listener,
+            placement: 0 /* EventListenerContext.CUSTOM_ELEMENT_LISTENER */,
+            handleEvent(event) {
+                // currentTarget is always defined inside an event listener
+                const currentTarget = eventCurrentTargetGetter.call(event);
+                const actualTarget = getActualTarget(event);
+                if (shouldInvokeListener(event, actualTarget, currentTarget)) {
+                    getEventHandler(listener).call(currentTarget, event);
+                }
+            },
         };
-        customElementWrappedListener.placement = 0 /* EventListenerContext.CUSTOM_ELEMENT_LISTENER */;
-        customElementEventListenerMap.set(listener, customElementWrappedListener);
+        customElementEventListenerMap.set(listener, managedListener);
     }
-    return customElementWrappedListener;
+    return managedListener;
+}
+function indexOfManagedListener(listeners, listener) {
+    return ArrayFindIndex.call(listeners, (l) => l.identity === listener.identity);
 }
 function domListener(evt) {
     let immediatePropagationStopped = false;
@@ -1650,9 +1670,9 @@ function domListener(evt) {
         forEach.call(bookkeeping, (listener) => {
             if (isFalse(immediatePropagationStopped) && listener.placement === placement) {
                 // making sure that the listener was not removed from the original listener queue
-                if (ArrayIndexOf.call(listeners, listener) !== -1) {
+                if (indexOfManagedListener(listeners, listener) !== -1) {
                     // all handlers on the custom element should be called with undefined 'this'
-                    listener.call(undefined, evt);
+                    listener.handleEvent.call(undefined, evt);
                 }
             }
         });
@@ -1666,31 +1686,30 @@ function domListener(evt) {
     }
     eventToContextMap.set(evt, 2 /* EventListenerContext.UNKNOWN_LISTENER */);
 }
-function attachDOMListener(elm, type, wrappedListener) {
+function attachDOMListener(elm, type, managedListener) {
     const listenerMap = getEventMap(elm);
-    let cmpEventHandlers = listenerMap[type];
-    if (isUndefined(cmpEventHandlers)) {
-        cmpEventHandlers = listenerMap[type] = [];
+    let listeners = listenerMap[type];
+    if (isUndefined(listeners)) {
+        listeners = listenerMap[type] = [];
     }
     // Prevent identical listeners from subscribing to the same event type.
-    // TODO [#1824]: Options will also play a factor when we introduce support for them (#1824).
-    if (ArrayIndexOf.call(cmpEventHandlers, wrappedListener) !== -1) {
+    // TODO [#1824]: Options will also play a factor in deduping if we introduce options support
+    if (indexOfManagedListener(listeners, managedListener) !== -1) {
         return;
     }
     // only add to DOM if there is no other listener on the same placement yet
-    if (cmpEventHandlers.length === 0) {
-        // super.addEventListener() - this will not work on
+    if (listeners.length === 0) {
         addEventListener.call(elm, type, domListener);
     }
-    ArrayPush.call(cmpEventHandlers, wrappedListener);
+    ArrayPush.call(listeners, managedListener);
 }
-function detachDOMListener(elm, type, wrappedListener) {
+function detachDOMListener(elm, type, managedListener) {
     const listenerMap = getEventMap(elm);
-    let p;
+    let index;
     let listeners;
     if (!isUndefined((listeners = listenerMap[type])) &&
-        (p = ArrayIndexOf.call(listeners, wrappedListener)) !== -1) {
-        ArraySplice.call(listeners, p, 1);
+        (index = indexOfManagedListener(listeners, managedListener)) !== -1) {
+        ArraySplice.call(listeners, index, 1);
         // only remove from DOM if there is no other listener on the same placement
         if (listeners.length === 0) {
             removeEventListener.call(elm, type, domListener);
@@ -1699,42 +1718,38 @@ function detachDOMListener(elm, type, wrappedListener) {
 }
 function addCustomElementEventListener(type, listener, _options) {
     if (process.env.NODE_ENV !== 'production') {
-        if (!isFunction(listener)) {
-            throw new TypeError(`Invalid second argument for Element.addEventListener() in ${toString(this)} for event "${type}". Expected an EventListener but received ${listener}.`);
+        if (!isEventListenerOrEventListenerObject(listener)) {
+            throw new TypeError(`Invalid second argument for Element.addEventListener() in ${toString(this)} for event "${type}". Expected EventListener or EventListenerObject but received ${listener}.`);
         }
     }
-    // TODO [#1824]: Lift this restriction on the option parameter
-    if (isFunction(listener)) {
-        const wrappedListener = getWrappedCustomElementListener(listener);
-        attachDOMListener(this, type, wrappedListener);
+    if (isEventListenerOrEventListenerObject(listener)) {
+        const managedListener = getManagedCustomElementListener(listener);
+        attachDOMListener(this, type, managedListener);
     }
 }
 function removeCustomElementEventListener(type, listener, _options) {
-    // TODO [#1824]: Lift this restriction on the option parameter
-    if (isFunction(listener)) {
-        const wrappedListener = getWrappedCustomElementListener(listener);
-        detachDOMListener(this, type, wrappedListener);
+    if (isEventListenerOrEventListenerObject(listener)) {
+        const managedListener = getManagedCustomElementListener(listener);
+        detachDOMListener(this, type, managedListener);
     }
 }
 function addShadowRootEventListener(sr, type, listener, _options) {
     if (process.env.NODE_ENV !== 'production') {
-        if (!isFunction(listener)) {
-            throw new TypeError(`Invalid second argument for ShadowRoot.addEventListener() in ${toString(sr)} for event "${type}". Expected an EventListener but received ${listener}.`);
+        if (!isEventListenerOrEventListenerObject(listener)) {
+            throw new TypeError(`Invalid second argument for ShadowRoot.addEventListener() in ${toString(sr)} for event "${type}". Expected EventListener or EventListenerObject but received ${listener}.`);
         }
     }
-    // TODO [#1824]: Lift this restriction on the option parameter
-    if (isFunction(listener)) {
+    if (isEventListenerOrEventListenerObject(listener)) {
         const elm = getHost(sr);
-        const wrappedListener = getWrappedShadowRootListener(listener);
-        attachDOMListener(elm, type, wrappedListener);
+        const managedListener = getManagedShadowRootListener(listener);
+        attachDOMListener(elm, type, managedListener);
     }
 }
 function removeShadowRootEventListener(sr, type, listener, _options) {
-    // TODO [#1824]: Lift this restriction on the option parameter
-    if (isFunction(listener)) {
+    if (isEventListenerOrEventListenerObject(listener)) {
         const elm = getHost(sr);
-        const wrappedListener = getWrappedShadowRootListener(listener);
-        detachDOMListener(elm, type, wrappedListener);
+        const managedListener = getManagedShadowRootListener(listener);
+        detachDOMListener(elm, type, managedListener);
     }
 }
 
@@ -4676,5 +4691,5 @@ defineProperty(Element.prototype, '$domManual$', {
     },
     configurable: true,
 });
-/** version: 2.43.0 */
+/** version: 2.45.0 */
 //# sourceMappingURL=synthetic-shadow.js.map