lwc 2.43.0 → 2.44.0

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

@@ -46,7 +46,7 @@
      */
     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;
@@ -123,7 +123,7 @@
     // 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.44.0 */
 
     /**
      * Copyright (C) 2018 salesforce.com, inc.
@@ -132,7 +132,7 @@
     if (!_globalThis.lwcRuntimeFlags) {
         Object.defineProperty(_globalThis, 'lwcRuntimeFlags', { value: create(null) });
     }
-    /** version: 2.43.0 */
+    /** version: 2.44.0 */
 
     /*
      * Copyright (c) 2018, salesforce.com, inc.
@@ -1506,7 +1506,7 @@
      */
     const EventListenerMap = new WeakMap();
     const ComposedPathMap = new WeakMap();
-    function isEventListenerOrEventListenerObject(fnOrObj) {
+    function isEventListenerOrEventListenerObject$1(fnOrObj) {
         return (isFunction(fnOrObj) ||
             (isObject(fnOrObj) &&
                 !isNull(fnOrObj) &&
@@ -1527,7 +1527,7 @@
         return composedPath.includes(currentTarget);
     }
     function getEventListenerWrapper(fnOrObj) {
-        if (!isEventListenerOrEventListenerObject(fnOrObj)) {
+        if (!isEventListenerOrEventListenerObject$1(fnOrObj)) {
             return fnOrObj;
         }
         let wrapperFn = EventListenerMap.get(fnOrObj);
@@ -1558,6 +1558,17 @@
      * 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);
@@ -1577,49 +1588,58 @@
         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;
@@ -1653,9 +1673,9 @@
             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);
                     }
                 }
             });
@@ -1669,31 +1689,30 @@
         }
         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);
@@ -1702,42 +1721,38 @@
     }
     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);
         }
     }
 
@@ -4679,7 +4694,7 @@
         },
         configurable: true,
     });
-    /** version: 2.43.0 */
+    /** version: 2.44.0 */
 
 })();
 //# sourceMappingURL=synthetic-shadow.js.map