From 8fa4751387f00f532c7132c010f61226599e118e Mon Sep 17 00:00:00 2001 From: Rob Eisenberg Date: Mon, 9 Sep 2019 18:51:45 -0700 Subject: [PATCH] chore(all): prepare release 2.5.0 --- bower.json | 2 +- dist/amd/aurelia-binding.js | 69 +++++++++++++++----------- dist/aurelia-binding.d.ts | 2 + dist/aurelia-binding.js | 65 +++++++++++++----------- dist/commonjs/aurelia-binding.js | 69 +++++++++++++++----------- dist/es2015/aurelia-binding.js | 68 +++++++++++++------------ dist/native-modules/aurelia-binding.js | 69 +++++++++++++++----------- dist/system/aurelia-binding.js | 69 +++++++++++++++----------- doc/CHANGELOG.md | 11 ++++ package-lock.json | 2 +- package.json | 2 +- 11 files changed, 246 insertions(+), 182 deletions(-) diff --git a/bower.json b/bower.json index 95f1bdf3..3794a035 100644 --- 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 index 400f7dbf..d2192140 100644 --- a/dist/amd/aurelia-binding.js +++ b/dist/amd/aurelia-binding.js @@ -3377,43 +3377,47 @@ 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); } }; @@ -3421,7 +3425,7 @@ define(['exports', 'aurelia-logging', 'aurelia-pal', 'aurelia-task-queue', 'aure 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 index 4083deae..a61a4fab 100644 --- 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 index 36d7be2f..2280c88c 100644 --- a/dist/aurelia-binding.js +++ b/dist/aurelia-binding.js @@ -3282,41 +3282,45 @@ 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); } } @@ -3324,7 +3328,7 @@ class DelegateHandlerEntry { 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 index 55624bd7..4d6b7c3a 100644 --- a/dist/commonjs/aurelia-binding.js +++ b/dist/commonjs/aurelia-binding.js @@ -3330,43 +3330,47 @@ 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); } }; @@ -3374,7 +3378,7 @@ var DelegateHandlerEntry = function () { 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) { diff --git a/dist/es2015/aurelia-binding.js b/dist/es2015/aurelia-binding.js index e4fd5642..cfebd799 100644 --- a/dist/es2015/aurelia-binding.js +++ b/dist/es2015/aurelia-binding.js @@ -3078,43 +3078,45 @@ let CapturedHandlerEntry = class CapturedHandlerEntry { } } }; +let DelegateHandlerEntry = class DelegateHandlerEntry { + constructor(eventName, eventManager) { + this.eventName = eventName; + this.count = 0; + this.eventManager = eventManager; + } - -function handleDelegatedEvent(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); + 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; -let DelegateHandlerEntry = 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); } } @@ -3122,7 +3124,7 @@ let DelegateHandlerEntry = class DelegateHandlerEntry { 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); } } }; @@ -3154,9 +3156,12 @@ let EventHandler = class EventHandler { } }; let DefaultEventStrategy = class DefaultEventStrategy { - constructor() { + + constructor(eventManager) { this.delegatedHandlers = {}; this.capturedHandlers = {}; + + this.eventManager = eventManager; } subscribe(target, targetEvent, callback, strategy, disposable) { @@ -3166,7 +3171,7 @@ let DefaultEventStrategy = 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(); @@ -3225,9 +3230,10 @@ export const delegationStrategy = { }; export let EventManager = class EventManager { - constructor() { + constructor(escapeShadowRoot = false) { this.elementHandlerLookup = {}; this.eventStrategyLookup = {}; + this.escapeShadowRoot = escapeShadowRoot; this.registerElementConfig({ tagName: 'input', @@ -3267,7 +3273,7 @@ export let EventManager = class EventManager { } }); - this.defaultEventStrategy = new DefaultEventStrategy(); + this.defaultEventStrategy = new DefaultEventStrategy(this); } registerElementConfig(config) { diff --git a/dist/native-modules/aurelia-binding.js b/dist/native-modules/aurelia-binding.js index d9fe1307..e9b9bca7 100644 --- a/dist/native-modules/aurelia-binding.js +++ b/dist/native-modules/aurelia-binding.js @@ -3290,43 +3290,47 @@ 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) { - DOM.addEventListener(this.eventName, handleDelegatedEvent, false); + DOM.addEventListener(this.eventName, this, false); } }; @@ -3334,7 +3338,7 @@ var DelegateHandlerEntry = function () { 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); } }; @@ -3379,11 +3383,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) { @@ -3393,7 +3399,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(); @@ -3454,10 +3460,13 @@ export var delegationStrategy = { export var 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', @@ -3497,7 +3506,7 @@ export var EventManager = function () { } }); - this.defaultEventStrategy = new DefaultEventStrategy(); + this.defaultEventStrategy = new DefaultEventStrategy(this); } EventManager.prototype.registerElementConfig = function registerElementConfig(config) { diff --git a/dist/system/aurelia-binding.js b/dist/system/aurelia-binding.js index d15cf62f..d15984fc 100644 --- a/dist/system/aurelia-binding.js +++ b/dist/system/aurelia-binding.js @@ -776,30 +776,6 @@ System.register(['aurelia-logging', 'aurelia-pal', 'aurelia-task-queue', 'aureli } } - 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; - } - } - function hasDeclaredDependencies(descriptor) { return !!(descriptor && descriptor.get && descriptor.get.dependencies); } @@ -3609,18 +3585,46 @@ System.register(['aurelia-logging', 'aurelia-pal', 'aurelia-task-queue', 'aureli }(); 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) { - DOM.addEventListener(this.eventName, handleDelegatedEvent, false); + DOM.addEventListener(this.eventName, this, false); } }; @@ -3628,7 +3632,7 @@ System.register(['aurelia-logging', 'aurelia-pal', 'aurelia-task-queue', 'aureli 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); } }; @@ -3673,11 +3677,13 @@ System.register(['aurelia-logging', 'aurelia-pal', 'aurelia-task-queue', 'aureli }(); DefaultEventStrategy = function () { - function DefaultEventStrategy() { + function DefaultEventStrategy(eventManager) { this.delegatedHandlers = {}; this.capturedHandlers = {}; + + this.eventManager = eventManager; } DefaultEventStrategy.prototype.subscribe = function subscribe(target, targetEvent, callback, strategy, disposable) { @@ -3687,7 +3693,7 @@ System.register(['aurelia-logging', 'aurelia-pal', 'aurelia-task-queue', 'aureli 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(); @@ -3750,10 +3756,13 @@ System.register(['aurelia-logging', 'aurelia-pal', 'aurelia-task-queue', 'aureli _export('EventManager', 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', @@ -3793,7 +3802,7 @@ System.register(['aurelia-logging', 'aurelia-pal', 'aurelia-task-queue', 'aureli } }); - this.defaultEventStrategy = new DefaultEventStrategy(); + this.defaultEventStrategy = new DefaultEventStrategy(this); } EventManager.prototype.registerElementConfig = function registerElementConfig(config) { diff --git a/doc/CHANGELOG.md b/doc/CHANGELOG.md index aee6425b..07472992 100644 --- a/doc/CHANGELOG.md +++ b/doc/CHANGELOG.md @@ -1,3 +1,14 @@ + +# [2.5.0](https://github.com/aurelia/binding/compare/2.4.0...2.5.0) (2019-09-10) + + +### Bug Fixes + +* **event-manager:** shadow dom event bubbling ([7563566](https://github.com/aurelia/binding/commit/7563566)), closes [#755](https://github.com/aurelia/binding/issues/755) +* **event-manager:** update d.ts ([a6e6330](https://github.com/aurelia/binding/commit/a6e6330)), closes [#758](https://github.com/aurelia/binding/issues/758) [#755](https://github.com/aurelia/binding/issues/755) + + + ## [2.4.1](https://github.com/aurelia/binding/compare/2.2.0...2.4.1) (2019-08-06) diff --git a/package-lock.json b/package-lock.json index 000903c5..2ee4142f 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1,6 +1,6 @@ { "name": "aurelia-binding", - "version": "2.4.0", + "version": "2.5.0", "lockfileVersion": 1, "requires": true, "dependencies": { diff --git a/package.json b/package.json index 83ba3414..99f55222 100644 --- a/package.json +++ b/package.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.", "keywords": [ "aurelia",