chore(all): prepare release 2.5.0

aurelia · Sep 10, 2019 · 8fa4751 · 8fa4751
1 parent c393624
commit 8fa4751
Show file tree

Hide file tree

Showing 11 changed files with 246 additions and 182 deletions.
diff --git a/bower.json b/bower.json
@@ -1,6 +1,6 @@
 {
   "name": "aurelia-binding",
-  "version": "2.4.1",
+  "version": "2.5.0",
   "description": "A modern databinding library for JavaScript and HTML.",
   "license": "MIT",
   "keywords": [

diff --git a/dist/amd/aurelia-binding.js b/dist/amd/aurelia-binding.js
@@ -3377,51 +3377,55 @@ define(['exports', 'aurelia-logging', 'aurelia-pal', 'aurelia-task-queue', 'aure
     return CapturedHandlerEntry;
   }();
 
-  function handleDelegatedEvent(event) {
-    event.propagationStopped = false;
-    var target = findOriginalEventTarget(event);
-
-    while (target && !event.propagationStopped) {
-      if (target.delegatedCallbacks) {
-        var callback = target.delegatedCallbacks[event.type];
-        if (callback) {
-          if (event.stopPropagation !== stopPropagation) {
-            event.standardStopPropagation = event.stopPropagation;
-            event.stopPropagation = stopPropagation;
-          }
-          if ('handleEvent' in callback) {
-            callback.handleEvent(event);
-          } else {
-            callback(event);
-          }
-        }
-      }
-
-      target = target.parentNode;
-    }
-  }
-
   var DelegateHandlerEntry = function () {
-    function DelegateHandlerEntry(eventName) {
+    function DelegateHandlerEntry(eventName, eventManager) {
 
 
       this.eventName = eventName;
       this.count = 0;
+      this.eventManager = eventManager;
     }
 
+    DelegateHandlerEntry.prototype.handleEvent = function handleEvent(event) {
+      event.propagationStopped = false;
+      var target = findOriginalEventTarget(event);
+
+      while (target && !event.propagationStopped) {
+        if (target.delegatedCallbacks) {
+          var callback = target.delegatedCallbacks[event.type];
+          if (callback) {
+            if (event.stopPropagation !== stopPropagation) {
+              event.standardStopPropagation = event.stopPropagation;
+              event.stopPropagation = stopPropagation;
+            }
+            if ('handleEvent' in callback) {
+              callback.handleEvent(event);
+            } else {
+              callback(event);
+            }
+          }
+        }
+
+        var parent = target.parentNode;
+        var shouldEscapeShadowRoot = this.eventManager.escapeShadowRoot && parent instanceof ShadowRoot;
+
+        target = shouldEscapeShadowRoot ? parent.host : parent;
+      }
+    };
+
     DelegateHandlerEntry.prototype.increment = function increment() {
       this.count++;
 
       if (this.count === 1) {
-        _aureliaPal.DOM.addEventListener(this.eventName, handleDelegatedEvent, false);
+        _aureliaPal.DOM.addEventListener(this.eventName, this, false);
       }
     };
 
     DelegateHandlerEntry.prototype.decrement = function decrement() {
       if (this.count === 0) {
         emLogger.warn('The same EventListener was disposed multiple times.');
       } else if (--this.count === 0) {
-        _aureliaPal.DOM.removeEventListener(this.eventName, handleDelegatedEvent, false);
+        _aureliaPal.DOM.removeEventListener(this.eventName, this, false);
       }
     };
 
@@ -3466,11 +3470,13 @@ define(['exports', 'aurelia-logging', 'aurelia-pal', 'aurelia-task-queue', 'aure
   }();
 
   var DefaultEventStrategy = function () {
-    function DefaultEventStrategy() {
+    function DefaultEventStrategy(eventManager) {
 
 
       this.delegatedHandlers = {};
       this.capturedHandlers = {};
+
+      this.eventManager = eventManager;
     }
 
     DefaultEventStrategy.prototype.subscribe = function subscribe(target, targetEvent, callback, strategy, disposable) {
@@ -3480,7 +3486,7 @@ define(['exports', 'aurelia-logging', 'aurelia-pal', 'aurelia-task-queue', 'aure
 
       if (strategy === delegationStrategy.bubbling) {
         delegatedHandlers = this.delegatedHandlers;
-        handlerEntry = delegatedHandlers[targetEvent] || (delegatedHandlers[targetEvent] = new DelegateHandlerEntry(targetEvent));
+        handlerEntry = delegatedHandlers[targetEvent] || (delegatedHandlers[targetEvent] = new DelegateHandlerEntry(targetEvent, this.eventManager));
         var delegatedCallbacks = target.delegatedCallbacks || (target.delegatedCallbacks = {});
         if (!delegatedCallbacks[targetEvent]) {
           handlerEntry.increment();
@@ -3541,10 +3547,13 @@ define(['exports', 'aurelia-logging', 'aurelia-pal', 'aurelia-task-queue', 'aure
 
   var EventManager = exports.EventManager = function () {
     function EventManager() {
+      var escapeShadowRoot = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+
 
 
       this.elementHandlerLookup = {};
       this.eventStrategyLookup = {};
+      this.escapeShadowRoot = escapeShadowRoot;
 
       this.registerElementConfig({
         tagName: 'input',
@@ -3584,7 +3593,7 @@ define(['exports', 'aurelia-logging', 'aurelia-pal', 'aurelia-task-queue', 'aure
         }
       });
 
-      this.defaultEventStrategy = new DefaultEventStrategy();
+      this.defaultEventStrategy = new DefaultEventStrategy(this);
     }
 
     EventManager.prototype.registerElementConfig = function registerElementConfig(config) {

diff --git a/dist/aurelia-binding.d.ts b/dist/aurelia-binding.d.ts
@@ -108,6 +108,8 @@ export declare enum delegationStrategy {
  * This is an internal API and is subject to change without notice in future releases.
  */
 export declare class EventManager {
+  constructor(escapeShadowRoot?: boolean);
+  escapeShadowRoot: boolean;
   registerElementConfig(config: { tagName: string; properties: { [propertyName: string]: string[] }; }): void;
   /**
    * Subscribes to specified event on the target element.

diff --git a/dist/aurelia-binding.js b/dist/aurelia-binding.js
@@ -3282,49 +3282,53 @@ class CapturedHandlerEntry {
   }
 }
 
-function handleDelegatedEvent(event) {
-  event.propagationStopped = false;
-  let target = findOriginalEventTarget(event);
+class DelegateHandlerEntry {
+  constructor(eventName, eventManager) {
+    this.eventName = eventName;
+    this.count = 0;
+    this.eventManager = eventManager;
+  }
 
-  while (target && !event.propagationStopped) {
-    if (target.delegatedCallbacks) {
-      let callback = target.delegatedCallbacks[event.type];
-      if (callback) {
-        if (event.stopPropagation !== stopPropagation) {
-          event.standardStopPropagation = event.stopPropagation;
-          event.stopPropagation = stopPropagation;
-        }
-        if ('handleEvent' in callback) {
-          callback.handleEvent(event);
-        } else {
-          callback(event);
+  handleEvent(event) {
+    event.propagationStopped = false;
+    let target = findOriginalEventTarget(event);
+
+    while (target && !event.propagationStopped) {
+      if (target.delegatedCallbacks) {
+        let callback = target.delegatedCallbacks[event.type];
+        if (callback) {
+          if (event.stopPropagation !== stopPropagation) {
+            event.standardStopPropagation = event.stopPropagation;
+            event.stopPropagation = stopPropagation;
+          }
+          if ('handleEvent' in callback) {
+            callback.handleEvent(event);
+          } else {
+            callback(event);
+          }
         }
       }
-    }
 
-    target = target.parentNode;
-  }
-}
+      const parent = target.parentNode;
+      const shouldEscapeShadowRoot = this.eventManager.escapeShadowRoot && parent instanceof ShadowRoot;
 
-class DelegateHandlerEntry {
-  constructor(eventName) {
-    this.eventName = eventName;
-    this.count = 0;
+      target = shouldEscapeShadowRoot ? parent.host : parent;
+    }
   }
 
   increment() {
     this.count++;
 
     if (this.count === 1) {
-      DOM.addEventListener(this.eventName, handleDelegatedEvent, false);
+      DOM.addEventListener(this.eventName, this, false);
     }
   }
 
   decrement() {
     if (this.count === 0) {
       emLogger.warn('The same EventListener was disposed multiple times.');
     } else if (--this.count === 0) {
-      DOM.removeEventListener(this.eventName, handleDelegatedEvent, false);
+      DOM.removeEventListener(this.eventName, this, false);
     }
   }
 }
@@ -3378,6 +3382,10 @@ class DefaultEventStrategy {
   delegatedHandlers = {};
   capturedHandlers = {};
 
+  constructor(eventManager) {
+    this.eventManager = eventManager;
+  }
+
   /**
    * @param {Element} target
    * @param {string} targetEvent
@@ -3392,7 +3400,7 @@ class DefaultEventStrategy {
 
     if (strategy === delegationStrategy.bubbling) {
       delegatedHandlers = this.delegatedHandlers;
-      handlerEntry = delegatedHandlers[targetEvent] || (delegatedHandlers[targetEvent] = new DelegateHandlerEntry(targetEvent));
+      handlerEntry = delegatedHandlers[targetEvent] || (delegatedHandlers[targetEvent] = new DelegateHandlerEntry(targetEvent, this.eventManager));
       let delegatedCallbacks = target.delegatedCallbacks || (target.delegatedCallbacks = {});
       if (!delegatedCallbacks[targetEvent]) {
         handlerEntry.increment();
@@ -3450,9 +3458,10 @@ export const delegationStrategy = {
 };
 
 export class EventManager {
-  constructor() {
+  constructor(escapeShadowRoot = false) {
     this.elementHandlerLookup = {};
     this.eventStrategyLookup = {};
+    this.escapeShadowRoot = escapeShadowRoot;
 
     this.registerElementConfig({
       tagName: 'input',
@@ -3492,7 +3501,7 @@ export class EventManager {
       }
     });
 
-    this.defaultEventStrategy = new DefaultEventStrategy();
+    this.defaultEventStrategy = new DefaultEventStrategy(this);
   }
 
   registerElementConfig(config) {

diff --git a/dist/commonjs/aurelia-binding.js b/dist/commonjs/aurelia-binding.js
@@ -3330,51 +3330,55 @@ var CapturedHandlerEntry = function () {
   return CapturedHandlerEntry;
 }();
 
-function handleDelegatedEvent(event) {
-  event.propagationStopped = false;
-  var target = findOriginalEventTarget(event);
-
-  while (target && !event.propagationStopped) {
-    if (target.delegatedCallbacks) {
-      var callback = target.delegatedCallbacks[event.type];
-      if (callback) {
-        if (event.stopPropagation !== stopPropagation) {
-          event.standardStopPropagation = event.stopPropagation;
-          event.stopPropagation = stopPropagation;
-        }
-        if ('handleEvent' in callback) {
-          callback.handleEvent(event);
-        } else {
-          callback(event);
-        }
-      }
-    }
-
-    target = target.parentNode;
-  }
-}
-
 var DelegateHandlerEntry = function () {
-  function DelegateHandlerEntry(eventName) {
+  function DelegateHandlerEntry(eventName, eventManager) {
 
 
     this.eventName = eventName;
     this.count = 0;
+    this.eventManager = eventManager;
   }
 
+  DelegateHandlerEntry.prototype.handleEvent = function handleEvent(event) {
+    event.propagationStopped = false;
+    var target = findOriginalEventTarget(event);
+
+    while (target && !event.propagationStopped) {
+      if (target.delegatedCallbacks) {
+        var callback = target.delegatedCallbacks[event.type];
+        if (callback) {
+          if (event.stopPropagation !== stopPropagation) {
+            event.standardStopPropagation = event.stopPropagation;
+            event.stopPropagation = stopPropagation;
+          }
+          if ('handleEvent' in callback) {
+            callback.handleEvent(event);
+          } else {
+            callback(event);
+          }
+        }
+      }
+
+      var parent = target.parentNode;
+      var shouldEscapeShadowRoot = this.eventManager.escapeShadowRoot && parent instanceof ShadowRoot;
+
+      target = shouldEscapeShadowRoot ? parent.host : parent;
+    }
+  };
+
   DelegateHandlerEntry.prototype.increment = function increment() {
     this.count++;
 
     if (this.count === 1) {
-      _aureliaPal.DOM.addEventListener(this.eventName, handleDelegatedEvent, false);
+      _aureliaPal.DOM.addEventListener(this.eventName, this, false);
     }
   };
 
   DelegateHandlerEntry.prototype.decrement = function decrement() {
     if (this.count === 0) {
       emLogger.warn('The same EventListener was disposed multiple times.');
     } else if (--this.count === 0) {
-      _aureliaPal.DOM.removeEventListener(this.eventName, handleDelegatedEvent, false);
+      _aureliaPal.DOM.removeEventListener(this.eventName, this, false);
     }
   };
 
@@ -3419,11 +3423,13 @@ var EventHandler = function () {
 }();
 
 var DefaultEventStrategy = function () {
-  function DefaultEventStrategy() {
+  function DefaultEventStrategy(eventManager) {
 
 
     this.delegatedHandlers = {};
     this.capturedHandlers = {};
+
+    this.eventManager = eventManager;
   }
 
   DefaultEventStrategy.prototype.subscribe = function subscribe(target, targetEvent, callback, strategy, disposable) {
@@ -3433,7 +3439,7 @@ var DefaultEventStrategy = function () {
 
     if (strategy === delegationStrategy.bubbling) {
       delegatedHandlers = this.delegatedHandlers;
-      handlerEntry = delegatedHandlers[targetEvent] || (delegatedHandlers[targetEvent] = new DelegateHandlerEntry(targetEvent));
+      handlerEntry = delegatedHandlers[targetEvent] || (delegatedHandlers[targetEvent] = new DelegateHandlerEntry(targetEvent, this.eventManager));
       var delegatedCallbacks = target.delegatedCallbacks || (target.delegatedCallbacks = {});
       if (!delegatedCallbacks[targetEvent]) {
         handlerEntry.increment();
@@ -3494,10 +3500,13 @@ var delegationStrategy = exports.delegationStrategy = {
 
 var EventManager = exports.EventManager = function () {
   function EventManager() {
+    var escapeShadowRoot = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+
 
 
     this.elementHandlerLookup = {};
     this.eventStrategyLookup = {};
+    this.escapeShadowRoot = escapeShadowRoot;
 
     this.registerElementConfig({
       tagName: 'input',
@@ -3537,7 +3546,7 @@ var EventManager = exports.EventManager = function () {
       }
     });
 
-    this.defaultEventStrategy = new DefaultEventStrategy();
+    this.defaultEventStrategy = new DefaultEventStrategy(this);
   }
 
   EventManager.prototype.registerElementConfig = function registerElementConfig(config) {