Skip to content

Commit 8fa4751

Browse files
EisenbergEffectEisenbergEffect
committed
chore(all): prepare release 2.5.0
1 parent c393624 commit 8fa4751

File tree

11 files changed

+246
-182
lines changed

11 files changed

+246
-182
lines changed

‎bower.json‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,6 @@
11
{
22
"name": "aurelia-binding",
3-
"version": "2.4.1",
3+
"version": "2.5.0",
44
"description": "A modern databinding library for JavaScript and HTML.",
55
"license": "MIT",
66
"keywords": [

‎dist/amd/aurelia-binding.js‎

Lines changed: 39 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -3377,51 +3377,55 @@ define(['exports', 'aurelia-logging', 'aurelia-pal', 'aurelia-task-queue', 'aure
33773377
return CapturedHandlerEntry;
33783378
}();
33793379

3380-
function handleDelegatedEvent(event) {
3381-
event.propagationStopped = false;
3382-
var target = findOriginalEventTarget(event);
3383-
3384-
while (target && !event.propagationStopped) {
3385-
if (target.delegatedCallbacks) {
3386-
var callback = target.delegatedCallbacks[event.type];
3387-
if (callback) {
3388-
if (event.stopPropagation !== stopPropagation) {
3389-
event.standardStopPropagation = event.stopPropagation;
3390-
event.stopPropagation = stopPropagation;
3391-
}
3392-
if ('handleEvent' in callback) {
3393-
callback.handleEvent(event);
3394-
} else {
3395-
callback(event);
3396-
}
3397-
}
3398-
}
3399-
3400-
target = target.parentNode;
3401-
}
3402-
}
3403-
34043380
var DelegateHandlerEntry = function () {
3405-
function DelegateHandlerEntry(eventName) {
3381+
function DelegateHandlerEntry(eventName, eventManager) {
34063382

34073383

34083384
this.eventName = eventName;
34093385
this.count = 0;
3386+
this.eventManager = eventManager;
34103387
}
34113388

3389+
DelegateHandlerEntry.prototype.handleEvent = function handleEvent(event) {
3390+
event.propagationStopped = false;
3391+
var target = findOriginalEventTarget(event);
3392+
3393+
while (target && !event.propagationStopped) {
3394+
if (target.delegatedCallbacks) {
3395+
var callback = target.delegatedCallbacks[event.type];
3396+
if (callback) {
3397+
if (event.stopPropagation !== stopPropagation) {
3398+
event.standardStopPropagation = event.stopPropagation;
3399+
event.stopPropagation = stopPropagation;
3400+
}
3401+
if ('handleEvent' in callback) {
3402+
callback.handleEvent(event);
3403+
} else {
3404+
callback(event);
3405+
}
3406+
}
3407+
}
3408+
3409+
var parent = target.parentNode;
3410+
var shouldEscapeShadowRoot = this.eventManager.escapeShadowRoot && parent instanceof ShadowRoot;
3411+
3412+
target = shouldEscapeShadowRoot ? parent.host : parent;
3413+
}
3414+
};
3415+
34123416
DelegateHandlerEntry.prototype.increment = function increment() {
34133417
this.count++;
34143418

34153419
if (this.count === 1) {
3416-
_aureliaPal.DOM.addEventListener(this.eventName, handleDelegatedEvent, false);
3420+
_aureliaPal.DOM.addEventListener(this.eventName, this, false);
34173421
}
34183422
};
34193423

34203424
DelegateHandlerEntry.prototype.decrement = function decrement() {
34213425
if (this.count === 0) {
34223426
emLogger.warn('The same EventListener was disposed multiple times.');
34233427
} else if (--this.count === 0) {
3424-
_aureliaPal.DOM.removeEventListener(this.eventName, handleDelegatedEvent, false);
3428+
_aureliaPal.DOM.removeEventListener(this.eventName, this, false);
34253429
}
34263430
};
34273431

@@ -3466,11 +3470,13 @@ define(['exports', 'aurelia-logging', 'aurelia-pal', 'aurelia-task-queue', 'aure
34663470
}();
34673471

34683472
var DefaultEventStrategy = function () {
3469-
function DefaultEventStrategy() {
3473+
function DefaultEventStrategy(eventManager) {
34703474

34713475

34723476
this.delegatedHandlers = {};
34733477
this.capturedHandlers = {};
3478+
3479+
this.eventManager = eventManager;
34743480
}
34753481

34763482
DefaultEventStrategy.prototype.subscribe = function subscribe(target, targetEvent, callback, strategy, disposable) {
@@ -3480,7 +3486,7 @@ define(['exports', 'aurelia-logging', 'aurelia-pal', 'aurelia-task-queue', 'aure
34803486

34813487
if (strategy === delegationStrategy.bubbling) {
34823488
delegatedHandlers = this.delegatedHandlers;
3483-
handlerEntry = delegatedHandlers[targetEvent] || (delegatedHandlers[targetEvent] = new DelegateHandlerEntry(targetEvent));
3489+
handlerEntry = delegatedHandlers[targetEvent] || (delegatedHandlers[targetEvent] = new DelegateHandlerEntry(targetEvent, this.eventManager));
34843490
var delegatedCallbacks = target.delegatedCallbacks || (target.delegatedCallbacks = {});
34853491
if (!delegatedCallbacks[targetEvent]) {
34863492
handlerEntry.increment();
@@ -3541,10 +3547,13 @@ define(['exports', 'aurelia-logging', 'aurelia-pal', 'aurelia-task-queue', 'aure
35413547

35423548
var EventManager = exports.EventManager = function () {
35433549
function EventManager() {
3550+
var escapeShadowRoot = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
3551+
35443552

35453553

35463554
this.elementHandlerLookup = {};
35473555
this.eventStrategyLookup = {};
3556+
this.escapeShadowRoot = escapeShadowRoot;
35483557

35493558
this.registerElementConfig({
35503559
tagName: 'input',
@@ -3584,7 +3593,7 @@ define(['exports', 'aurelia-logging', 'aurelia-pal', 'aurelia-task-queue', 'aure
35843593
}
35853594
});
35863595

3587-
this.defaultEventStrategy = new DefaultEventStrategy();
3596+
this.defaultEventStrategy = new DefaultEventStrategy(this);
35883597
}
35893598

35903599
EventManager.prototype.registerElementConfig = function registerElementConfig(config) {

‎dist/aurelia-binding.d.ts‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -108,6 +108,8 @@ export declare enum delegationStrategy {
108108
* This is an internal API and is subject to change without notice in future releases.
109109
*/
110110
export declare class EventManager {
111+
constructor(escapeShadowRoot?: boolean);
112+
escapeShadowRoot: boolean;
111113
registerElementConfig(config: { tagName: string; properties: { [propertyName: string]: string[] }; }): void;
112114
/**
113115
* Subscribes to specified event on the target element.

‎dist/aurelia-binding.js‎

Lines changed: 37 additions & 28 deletions
Original file line numberDiff line numberDiff line change
@@ -3282,49 +3282,53 @@ class CapturedHandlerEntry {
32823282
}
32833283
}
32843284

3285-
function handleDelegatedEvent(event) {
3286-
event.propagationStopped = false;
3287-
let target = findOriginalEventTarget(event);
3285+
class DelegateHandlerEntry {
3286+
constructor(eventName, eventManager) {
3287+
this.eventName = eventName;
3288+
this.count = 0;
3289+
this.eventManager = eventManager;
3290+
}
32883291

3289-
while (target && !event.propagationStopped) {
3290-
if (target.delegatedCallbacks) {
3291-
let callback = target.delegatedCallbacks[event.type];
3292-
if (callback) {
3293-
if (event.stopPropagation !== stopPropagation) {
3294-
event.standardStopPropagation = event.stopPropagation;
3295-
event.stopPropagation = stopPropagation;
3296-
}
3297-
if ('handleEvent' in callback) {
3298-
callback.handleEvent(event);
3299-
} else {
3300-
callback(event);
3292+
handleEvent(event) {
3293+
event.propagationStopped = false;
3294+
let target = findOriginalEventTarget(event);
3295+
3296+
while (target && !event.propagationStopped) {
3297+
if (target.delegatedCallbacks) {
3298+
let callback = target.delegatedCallbacks[event.type];
3299+
if (callback) {
3300+
if (event.stopPropagation !== stopPropagation) {
3301+
event.standardStopPropagation = event.stopPropagation;
3302+
event.stopPropagation = stopPropagation;
3303+
}
3304+
if ('handleEvent' in callback) {
3305+
callback.handleEvent(event);
3306+
} else {
3307+
callback(event);
3308+
}
33013309
}
33023310
}
3303-
}
33043311

3305-
target = target.parentNode;
3306-
}
3307-
}
3312+
const parent = target.parentNode;
3313+
const shouldEscapeShadowRoot = this.eventManager.escapeShadowRoot && parent instanceof ShadowRoot;
33083314

3309-
class DelegateHandlerEntry {
3310-
constructor(eventName) {
3311-
this.eventName = eventName;
3312-
this.count = 0;
3315+
target = shouldEscapeShadowRoot ? parent.host : parent;
3316+
}
33133317
}
33143318

33153319
increment() {
33163320
this.count++;
33173321

33183322
if (this.count === 1) {
3319-
DOM.addEventListener(this.eventName, handleDelegatedEvent, false);
3323+
DOM.addEventListener(this.eventName, this, false);
33203324
}
33213325
}
33223326

33233327
decrement() {
33243328
if (this.count === 0) {
33253329
emLogger.warn('The same EventListener was disposed multiple times.');
33263330
} else if (--this.count === 0) {
3327-
DOM.removeEventListener(this.eventName, handleDelegatedEvent, false);
3331+
DOM.removeEventListener(this.eventName, this, false);
33283332
}
33293333
}
33303334
}
@@ -3378,6 +3382,10 @@ class DefaultEventStrategy {
33783382
delegatedHandlers = {};
33793383
capturedHandlers = {};
33803384

3385+
constructor(eventManager) {
3386+
this.eventManager = eventManager;
3387+
}
3388+
33813389
/**
33823390
* @param {Element} target
33833391
* @param {string} targetEvent
@@ -3392,7 +3400,7 @@ class DefaultEventStrategy {
33923400

33933401
if (strategy === delegationStrategy.bubbling) {
33943402
delegatedHandlers = this.delegatedHandlers;
3395-
handlerEntry = delegatedHandlers[targetEvent] || (delegatedHandlers[targetEvent] = new DelegateHandlerEntry(targetEvent));
3403+
handlerEntry = delegatedHandlers[targetEvent] || (delegatedHandlers[targetEvent] = new DelegateHandlerEntry(targetEvent, this.eventManager));
33963404
let delegatedCallbacks = target.delegatedCallbacks || (target.delegatedCallbacks = {});
33973405
if (!delegatedCallbacks[targetEvent]) {
33983406
handlerEntry.increment();
@@ -3450,9 +3458,10 @@ export const delegationStrategy = {
34503458
};
34513459

34523460
export class EventManager {
3453-
constructor() {
3461+
constructor(escapeShadowRoot = false) {
34543462
this.elementHandlerLookup = {};
34553463
this.eventStrategyLookup = {};
3464+
this.escapeShadowRoot = escapeShadowRoot;
34563465

34573466
this.registerElementConfig({
34583467
tagName: 'input',
@@ -3492,7 +3501,7 @@ export class EventManager {
34923501
}
34933502
});
34943503

3495-
this.defaultEventStrategy = new DefaultEventStrategy();
3504+
this.defaultEventStrategy = new DefaultEventStrategy(this);
34963505
}
34973506

34983507
registerElementConfig(config) {

‎dist/commonjs/aurelia-binding.js‎

Lines changed: 39 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -3330,51 +3330,55 @@ var CapturedHandlerEntry = function () {
33303330
return CapturedHandlerEntry;
33313331
}();
33323332

3333-
function handleDelegatedEvent(event) {
3334-
event.propagationStopped = false;
3335-
var target = findOriginalEventTarget(event);
3336-
3337-
while (target && !event.propagationStopped) {
3338-
if (target.delegatedCallbacks) {
3339-
var callback = target.delegatedCallbacks[event.type];
3340-
if (callback) {
3341-
if (event.stopPropagation !== stopPropagation) {
3342-
event.standardStopPropagation = event.stopPropagation;
3343-
event.stopPropagation = stopPropagation;
3344-
}
3345-
if ('handleEvent' in callback) {
3346-
callback.handleEvent(event);
3347-
} else {
3348-
callback(event);
3349-
}
3350-
}
3351-
}
3352-
3353-
target = target.parentNode;
3354-
}
3355-
}
3356-
33573333
var DelegateHandlerEntry = function () {
3358-
function DelegateHandlerEntry(eventName) {
3334+
function DelegateHandlerEntry(eventName, eventManager) {
33593335

33603336

33613337
this.eventName = eventName;
33623338
this.count = 0;
3339+
this.eventManager = eventManager;
33633340
}
33643341

3342+
DelegateHandlerEntry.prototype.handleEvent = function handleEvent(event) {
3343+
event.propagationStopped = false;
3344+
var target = findOriginalEventTarget(event);
3345+
3346+
while (target && !event.propagationStopped) {
3347+
if (target.delegatedCallbacks) {
3348+
var callback = target.delegatedCallbacks[event.type];
3349+
if (callback) {
3350+
if (event.stopPropagation !== stopPropagation) {
3351+
event.standardStopPropagation = event.stopPropagation;
3352+
event.stopPropagation = stopPropagation;
3353+
}
3354+
if ('handleEvent' in callback) {
3355+
callback.handleEvent(event);
3356+
} else {
3357+
callback(event);
3358+
}
3359+
}
3360+
}
3361+
3362+
var parent = target.parentNode;
3363+
var shouldEscapeShadowRoot = this.eventManager.escapeShadowRoot && parent instanceof ShadowRoot;
3364+
3365+
target = shouldEscapeShadowRoot ? parent.host : parent;
3366+
}
3367+
};
3368+
33653369
DelegateHandlerEntry.prototype.increment = function increment() {
33663370
this.count++;
33673371

33683372
if (this.count === 1) {
3369-
_aureliaPal.DOM.addEventListener(this.eventName, handleDelegatedEvent, false);
3373+
_aureliaPal.DOM.addEventListener(this.eventName, this, false);
33703374
}
33713375
};
33723376

33733377
DelegateHandlerEntry.prototype.decrement = function decrement() {
33743378
if (this.count === 0) {
33753379
emLogger.warn('The same EventListener was disposed multiple times.');
33763380
} else if (--this.count === 0) {
3377-
_aureliaPal.DOM.removeEventListener(this.eventName, handleDelegatedEvent, false);
3381+
_aureliaPal.DOM.removeEventListener(this.eventName, this, false);
33783382
}
33793383
};
33803384

@@ -3419,11 +3423,13 @@ var EventHandler = function () {
34193423
}();
34203424

34213425
var DefaultEventStrategy = function () {
3422-
function DefaultEventStrategy() {
3426+
function DefaultEventStrategy(eventManager) {
34233427

34243428

34253429
this.delegatedHandlers = {};
34263430
this.capturedHandlers = {};
3431+
3432+
this.eventManager = eventManager;
34273433
}
34283434

34293435
DefaultEventStrategy.prototype.subscribe = function subscribe(target, targetEvent, callback, strategy, disposable) {
@@ -3433,7 +3439,7 @@ var DefaultEventStrategy = function () {
34333439

34343440
if (strategy === delegationStrategy.bubbling) {
34353441
delegatedHandlers = this.delegatedHandlers;
3436-
handlerEntry = delegatedHandlers[targetEvent] || (delegatedHandlers[targetEvent] = new DelegateHandlerEntry(targetEvent));
3442+
handlerEntry = delegatedHandlers[targetEvent] || (delegatedHandlers[targetEvent] = new DelegateHandlerEntry(targetEvent, this.eventManager));
34373443
var delegatedCallbacks = target.delegatedCallbacks || (target.delegatedCallbacks = {});
34383444
if (!delegatedCallbacks[targetEvent]) {
34393445
handlerEntry.increment();
@@ -3494,10 +3500,13 @@ var delegationStrategy = exports.delegationStrategy = {
34943500

34953501
var EventManager = exports.EventManager = function () {
34963502
function EventManager() {
3503+
var escapeShadowRoot = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
3504+
34973505

34983506

34993507
this.elementHandlerLookup = {};
35003508
this.eventStrategyLookup = {};
3509+
this.escapeShadowRoot = escapeShadowRoot;
35013510

35023511
this.registerElementConfig({
35033512
tagName: 'input',
@@ -3537,7 +3546,7 @@ var EventManager = exports.EventManager = function () {
35373546
}
35383547
});
35393548

3540-
this.defaultEventStrategy = new DefaultEventStrategy();
3549+
this.defaultEventStrategy = new DefaultEventStrategy(this);
35413550
}
35423551

35433552
EventManager.prototype.registerElementConfig = function registerElementConfig(config) {

0 commit comments

Comments
 (0)