lwc 2.43.0 → 2.44.0

package/dist/synthetic-shadow/umd/es5/synthetic-shadow.js

@@ -65,6 +65,7 @@
     var _Array$prototype = Array.prototype,
       ArrayFilter = _Array$prototype.filter,
       ArrayFind = _Array$prototype.find,
+      ArrayFindIndex = _Array$prototype.findIndex,
       ArrayIndexOf = _Array$prototype.indexOf,
       ArrayJoin = _Array$prototype.join,
       ArrayMap = _Array$prototype.map,
@@ -152,7 +153,7 @@
     var hasNativeSymbolSupport = /*@__PURE__*/function () {
       return Symbol('x').toString() === 'Symbol(x)';
     }();
-    /** version: 2.43.0 */
+    /** version: 2.44.0 */
 
     /**
      * Copyright (C) 2018 salesforce.com, inc.
@@ -163,7 +164,7 @@
         value: create(null)
       });
     }
-    /** version: 2.43.0 */
+    /** version: 2.44.0 */
 
     /*
      * Copyright (c) 2018, salesforce.com, inc.
@@ -1501,7 +1502,7 @@
      */
     var EventListenerMap = new WeakMap();
     var ComposedPathMap = new WeakMap();
-    function isEventListenerOrEventListenerObject(fnOrObj) {
+    function isEventListenerOrEventListenerObject$1(fnOrObj) {
       return isFunction(fnOrObj) || isObject(fnOrObj) && !isNull(fnOrObj) && isFunction(fnOrObj.handleEvent);
     }
     function shouldInvokeListener(event, target, currentTarget) {
@@ -1519,7 +1520,7 @@
       return composedPath.includes(currentTarget);
     }
     function getEventListenerWrapper(fnOrObj) {
-      if (!isEventListenerOrEventListenerObject(fnOrObj)) {
+      if (!isEventListenerOrEventListenerObject$1(fnOrObj)) {
         return fnOrObj;
       }
       var wrapperFn = EventListenerMap.get(fnOrObj);
@@ -1548,6 +1549,16 @@
      * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
      */
     var 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);
+    }
     var customElementToWrappedListeners = new WeakMap();
     function getEventMap(elm) {
       var listenerInfo = customElementToWrappedListeners.get(elm);
@@ -1567,51 +1578,62 @@
       return (_a = eventToShadowRootMap.get(event)) !== null && _a !== void 0 ? _a : eventTargetGetter.call(event);
     }
     var shadowRootEventListenerMap = new WeakMap();
-    function getWrappedShadowRootListener(listener) {
-      if (!isFunction(listener)) {
+    function getManagedShadowRootListener(listener) {
+      if (!isEventListenerOrEventListenerObject(listener)) {
         throw new TypeError(); // avoiding problems with non-valid listeners
       }
 
-      var shadowRootWrappedListener = shadowRootEventListenerMap.get(listener);
-      if (isUndefined(shadowRootWrappedListener)) {
-        shadowRootWrappedListener = function shadowRootWrappedListener(event) {
-          // currentTarget is always defined inside an event listener
-          var 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);
-          }
-          var actualTarget = getActualTarget(event);
-          if (shouldInvokeListener(event, actualTarget, currentTarget)) {
-            listener.call(currentTarget, event);
+      var managedListener = shadowRootEventListenerMap.get(listener);
+      if (isUndefined(managedListener)) {
+        managedListener = {
+          identity: listener,
+          placement: 1 /* EventListenerContext.SHADOW_ROOT_LISTENER */,
+          handleEvent: function handleEvent(event) {
+            // currentTarget is always defined inside an event listener
+            var 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);
+            }
+            var 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;
     }
     var customElementEventListenerMap = new WeakMap();
-    function getWrappedCustomElementListener(listener) {
-      if (!isFunction(listener)) {
+    function getManagedCustomElementListener(listener) {
+      if (!isEventListenerOrEventListenerObject(listener)) {
         throw new TypeError(); // avoiding problems with non-valid listeners
       }
 
-      var customElementWrappedListener = customElementEventListenerMap.get(listener);
-      if (isUndefined(customElementWrappedListener)) {
-        customElementWrappedListener = function customElementWrappedListener(event) {
-          // currentTarget is always defined inside an event listener
-          var currentTarget = eventCurrentTargetGetter.call(event);
-          var actualTarget = getActualTarget(event);
-          if (shouldInvokeListener(event, actualTarget, currentTarget)) {
-            listener.call(currentTarget, event);
+      var managedListener = customElementEventListenerMap.get(listener);
+      if (isUndefined(managedListener)) {
+        managedListener = {
+          identity: listener,
+          placement: 0 /* EventListenerContext.CUSTOM_ELEMENT_LISTENER */,
+          handleEvent: function handleEvent(event) {
+            // currentTarget is always defined inside an event listener
+            var currentTarget = eventCurrentTargetGetter.call(event);
+            var 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, function (l) {
+        return l.identity === listener.identity;
+      });
     }
     function domListener(evt) {
       var immediatePropagationStopped = false;
@@ -1647,9 +1669,9 @@
         forEach.call(bookkeeping, function (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);
             }
           }
         });
@@ -1665,30 +1687,29 @@
       eventToContextMap.set(evt, 2 /* EventListenerContext.UNKNOWN_LISTENER */);
     }
 
-    function attachDOMListener(elm, type, wrappedListener) {
+    function attachDOMListener(elm, type, managedListener) {
       var listenerMap = getEventMap(elm);
-      var cmpEventHandlers = listenerMap[type];
-      if (isUndefined(cmpEventHandlers)) {
-        cmpEventHandlers = listenerMap[type] = [];
+      var 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) {
       var listenerMap = getEventMap(elm);
-      var p;
+      var index;
       var listeners;
-      if (!isUndefined(listeners = listenerMap[type]) && (p = ArrayIndexOf.call(listeners, wrappedListener)) !== -1) {
-        ArraySplice.call(listeners, p, 1);
+      if (!isUndefined(listeners = listenerMap[type]) && (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);
@@ -1697,42 +1718,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 ".concat(toString(this), " for event \"").concat(type, "\". Expected an EventListener but received ").concat(listener, "."));
+        if (!isEventListenerOrEventListenerObject(listener)) {
+          throw new TypeError("Invalid second argument for Element.addEventListener() in ".concat(toString(this), " for event \"").concat(type, "\". Expected EventListener or EventListenerObject but received ").concat(listener, "."));
         }
       }
-      // TODO [#1824]: Lift this restriction on the option parameter
-      if (isFunction(listener)) {
-        var wrappedListener = getWrappedCustomElementListener(listener);
-        attachDOMListener(this, type, wrappedListener);
+      if (isEventListenerOrEventListenerObject(listener)) {
+        var managedListener = getManagedCustomElementListener(listener);
+        attachDOMListener(this, type, managedListener);
       }
     }
     function removeCustomElementEventListener(type, listener, _options) {
-      // TODO [#1824]: Lift this restriction on the option parameter
-      if (isFunction(listener)) {
-        var wrappedListener = getWrappedCustomElementListener(listener);
-        detachDOMListener(this, type, wrappedListener);
+      if (isEventListenerOrEventListenerObject(listener)) {
+        var 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 ".concat(toString(sr), " for event \"").concat(type, "\". Expected an EventListener but received ").concat(listener, "."));
+        if (!isEventListenerOrEventListenerObject(listener)) {
+          throw new TypeError("Invalid second argument for ShadowRoot.addEventListener() in ".concat(toString(sr), " for event \"").concat(type, "\". Expected EventListener or EventListenerObject but received ").concat(listener, "."));
         }
       }
-      // TODO [#1824]: Lift this restriction on the option parameter
-      if (isFunction(listener)) {
+      if (isEventListenerOrEventListenerObject(listener)) {
         var elm = getHost(sr);
-        var wrappedListener = getWrappedShadowRootListener(listener);
-        attachDOMListener(elm, type, wrappedListener);
+        var 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)) {
         var elm = getHost(sr);
-        var wrappedListener = getWrappedShadowRootListener(listener);
-        detachDOMListener(elm, type, wrappedListener);
+        var managedListener = getManagedShadowRootListener(listener);
+        detachDOMListener(elm, type, managedListener);
       }
     }
 
@@ -4654,7 +4671,7 @@
       },
       configurable: true
     });
-    /** version: 2.43.0 */
+    /** version: 2.44.0 */
 
 }));
 //# sourceMappingURL=synthetic-shadow.js.map