New Case Study:See how Anthropic automated 95% of dependency reviews with Socket.Learn More →

seng-event

Package Overview

Dependencies

Advanced tools

Install Socket

Detect and block malicious and high-risk dependencies

Install

seng-event - npm Package Compare versions

Comparing version 1.2.3 to 1.2.4

tsconfig.build.json

index.d.ts

		import { default as _export } from './lib/EventDispatcher';
		export { default as IEventDispatcher } from './lib/IEventDispatcher';
		export { default as IEvent } from './lib/IEvent';
		export { IEventDispatcher } from './lib/IEventDispatcher';
		export { IEvent } from './lib/IEvent';
		export { default as EventPhase } from './lib/EventPhase';
		@@ -5,0 +5,0 @@ export { default as EventListenerData } from './lib/EventListenerData';

index.js

		"use strict";
		Object.defineProperty(exports, "__esModule", { value: true });
		var EventDispatcher_1 = require("./lib/EventDispatcher");
		var EventPhase_1 = require("./lib/EventPhase");
		exports.EventPhase = EventPhase_1.default;
		var EventListenerData_1 = require("./lib/EventListenerData");
		exports.EventListenerData = EventListenerData_1.default;
		var CallListenerResult_1 = require("./lib/CallListenerResult");
		exports.CallListenerResult = CallListenerResult_1.default;
		var AbstractEvent_1 = require("./lib/AbstractEvent");
		exports.AbstractEvent = AbstractEvent_1.default;
		exports.default = EventDispatcher_1.default;

		var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

		exports.__esModule = true;
		exports.default = exports.AbstractEvent = exports.CallListenerResult = exports.EventListenerData = exports.EventPhase = exports.IEvent = exports.IEventDispatcher = void 0;

		var _EventDispatcher = _interopRequireDefault(require("./lib/EventDispatcher"));

		var _IEventDispatcher = require("./lib/IEventDispatcher");

		exports.IEventDispatcher = _IEventDispatcher.IEventDispatcher;

		var _IEvent = require("./lib/IEvent");

		exports.IEvent = _IEvent.IEvent;

		var _EventPhase = _interopRequireDefault(require("./lib/EventPhase"));

		exports.EventPhase = _EventPhase.default;

		var _EventListenerData = _interopRequireDefault(require("./lib/EventListenerData"));

		exports.EventListenerData = _EventListenerData.default;

		var _CallListenerResult = _interopRequireDefault(require("./lib/CallListenerResult"));

		exports.CallListenerResult = _CallListenerResult.default;

		var _AbstractEvent = _interopRequireDefault(require("./lib/AbstractEvent"));

		exports.AbstractEvent = _AbstractEvent.default;
		var _default = _EventDispatcher.default;
		exports.default = _default;

lib/AbstractEvent.d.ts

		@@ -1,4 +0,4 @@
		import IEvent from './IEvent';
		import { IEvent } from './IEvent';
		import EventPhase from './EventPhase';
		import IEventDispatcher from './IEventDispatcher';
		import { IEventDispatcher } from './IEventDispatcher';
		import { EventHandler } from './EventDispatcher';
		@@ -5,0 +5,0 @@ import CallListenerResult from './CallListenerResult';

271

lib/AbstractEvent.js

		"use strict";
		Object.defineProperty(exports, "__esModule", { value: true });
		var callListenerResult = 0 /* NONE */;

		var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

		exports.__esModule = true;
		exports.default = void 0;

		var _EventPhase = _interopRequireDefault(require("./EventPhase"));

		var _CallListenerResult = _interopRequireDefault(require("./CallListenerResult"));

		var callListenerResult = _CallListenerResult.default.NONE;
		/**
		@@ -9,90 +18,172 @@ * Abstract base class for all events that can be dispatched through [[EventDispatcher]]. This class
		*/
		var AbstractEvent = (function () {
		/**
		* Creates a new AbstractEvent instance.
		* @param type The type of the event. Event listeners will only be called if their eventType match this type.
		* @param bubbles If true, the event will also go through a bubbling phase. See [[EventDispatcher.dispatchEvent]]
		* for more information on the event phases.
		* @param cancelable Indicates if [[preventDefault]] can be called on this event. This will prevent the 'default
		* action' of the event from being executed. It is up to the [[EventDispatcher]] instance that dispatches the
		* event to stop the default action from executing when the [[EventDispatcher.dispatchEvent\|dispatchEvent]]
		* method returns _false_
		* @param setTimeStamp If true, will set the [[timeStamp]] property of this event to the current time whenever
		* this event is dispatched.
		*/
		function AbstractEvent(type, bubbles, cancelable, setTimeStamp) {
		if (bubbles === void 0) { bubbles = false; }
		if (cancelable === void 0) { cancelable = false; }
		if (setTimeStamp === void 0) { setTimeStamp = false; }
		this.type = type;
		this.bubbles = bubbles;
		this.cancelable = cancelable;
		/**
		* Will be updated by [[EventDispatcher]] during the dispatch of an event to the target that
		* listeners are currently being called on. After completion of an event dispatch this value
		* will be reset to _null_.
		*/
		this.currentTarget = null;
		/**
		* Will be updated by [[EventDispatcher]] when [[EventDispatcher.dispatchEvent\|dispatchEvent]] is
		* called with this event. The value will be set to the EventDispatcher instance that dispatched
		* the event.
		*/
		this.target = null;
		/**
		* The current event phase of this event. During event dispatch, this value will be either
		* [[EventPhase.CAPTURING_PHASE\|CAPTURING_PHASE]], [[EventPhase.AT_TARGET\|AT_TARGET]] or
		* [[EventPhase.BUBBLING_PHASE\|BUBBLING_PHASE]]. If this event is not currently being dispatched this will be
		* set to [[EventPhase.NONE\|NONE]].
		*/
		this.eventPhase = 0 /* NONE */;
		/**
		* _true_ if [[cancelable]] is true and [[preventDefault]] has been called on this event.
		*/
		this.defaultPrevented = false;
		this.timeStamp = setTimeStamp ? Date.now() : 0;

		var AbstractEvent =
		/#__PURE__/
		function () {
		/**
		* Will be updated by [[EventDispatcher]] during the dispatch of an event to the target that
		* listeners are currently being called on. After completion of an event dispatch this value
		* will be reset to _null_.
		*/

		/**
		* Will be updated by [[EventDispatcher]] when [[EventDispatcher.dispatchEvent\|dispatchEvent]] is
		* called with this event. The value will be set to the EventDispatcher instance that dispatched
		* the event.
		*/

		/**
		* The current event phase of this event. During event dispatch, this value will be either
		* [[EventPhase.CAPTURING_PHASE\|CAPTURING_PHASE]], [[EventPhase.AT_TARGET\|AT_TARGET]] or
		* [[EventPhase.BUBBLING_PHASE\|BUBBLING_PHASE]]. If this event is not currently being dispatched this will be
		* set to [[EventPhase.NONE\|NONE]].
		*/

		/**
		* Indicates the time this event is dispatched in the number of milliseconds elapsed since
		* _1 January 1970 00:00:00 UTC_. This value will only be set if the setTimestamp parameter in the constructor
		* is set to _true_. Otherwise, this value will be _0_.
		*/

		/**
		* _true_ if [[cancelable]] is true and [[preventDefault]] has been called on this event.
		*/

		/**
		* Creates a new AbstractEvent instance.
		* @param type The type of the event. Event listeners will only be called if their eventType match this type.
		* @param bubbles If true, the event will also go through a bubbling phase. See [[EventDispatcher.dispatchEvent]]
		* for more information on the event phases.
		* @param cancelable Indicates if [[preventDefault]] can be called on this event. This will prevent the 'default
		* action' of the event from being executed. It is up to the [[EventDispatcher]] instance that dispatches the
		* event to stop the default action from executing when the [[EventDispatcher.dispatchEvent\|dispatchEvent]]
		* method returns _false_
		* @param setTimeStamp If true, will set the [[timeStamp]] property of this event to the current time whenever
		* this event is dispatched.
		*/
		function AbstractEvent(type, bubbles, cancelable, setTimeStamp) {
		if (bubbles === void 0) {
		bubbles = false;
		}
		/**
		* When called during the dispatch of an event, will prevent any targets further in the event chain
		* from being processed. All listeners on the current target will still be executed.
		* @see [[EventDispatcher.dispatchEvent]]
		*/
		AbstractEvent.prototype.stopPropagation = function () {
		if (callListenerResult < 1 /* PROPAGATION_STOPPED */) {
		callListenerResult = 1 /* PROPAGATION_STOPPED */;
		}
		};
		/**
		* When called during the dispatch of an event, will prevent any other event listener from being
		* called for this event.
		* @see [[EventDispatcher.dispatchEvent]]
		*/
		AbstractEvent.prototype.stopImmediatePropagation = function () {
		callListenerResult = 2 /* IMMEDIATE_PROPAGATION_STOPPED */;
		};
		/**
		* May only be called when the [[cancelable]] property of an event is set to _true_. Indicates to the
		* instance that dispatched the event that the default action for the event should not be executed.
		*/
		AbstractEvent.prototype.preventDefault = function () {
		if (this.cancelable) {
		this.defaultPrevented = true;
		}
		else {
		throw new Error('Called preventDefault on a non-cancelable event');
		}
		};
		/**
		* Calls the given event handler, and returns an enum value that indicates if [[stopPropagation]] or
		* [[stopImmediatePropagation]] have been called on this event during the execution of that handler.
		* @param handler The event handler to execute
		* @returns An enum value, see [[CallListenerResult]]
		*/
		AbstractEvent.prototype.callListener = function (handler) {
		callListenerResult = 0 /* NONE */;
		handler.call(null, this);
		return callListenerResult;
		};
		return AbstractEvent;
		}());
		exports.default = AbstractEvent;

		if (cancelable === void 0) {
		cancelable = false;
		}

		if (setTimeStamp === void 0) {
		setTimeStamp = false;
		}

		Object.defineProperty(this, "type", {
		configurable: true,
		enumerable: true,
		writable: true,
		value: void 0
		});
		Object.defineProperty(this, "bubbles", {
		configurable: true,
		enumerable: true,
		writable: true,
		value: void 0
		});
		Object.defineProperty(this, "cancelable", {
		configurable: true,
		enumerable: true,
		writable: true,
		value: void 0
		});
		Object.defineProperty(this, "currentTarget", {
		configurable: true,
		enumerable: true,
		writable: true,
		value: null
		});
		Object.defineProperty(this, "target", {
		configurable: true,
		enumerable: true,
		writable: true,
		value: null
		});
		Object.defineProperty(this, "eventPhase", {
		configurable: true,
		enumerable: true,
		writable: true,
		value: _EventPhase.default.NONE
		});
		Object.defineProperty(this, "timeStamp", {
		configurable: true,
		enumerable: true,
		writable: true,
		value: void 0
		});
		Object.defineProperty(this, "defaultPrevented", {
		configurable: true,
		enumerable: true,
		writable: true,
		value: false
		});
		this.type = type;
		this.bubbles = bubbles;
		this.cancelable = cancelable;
		this.timeStamp = setTimeStamp ? Date.now() : 0;
		}
		/**
		* When called during the dispatch of an event, will prevent any targets further in the event chain
		* from being processed. All listeners on the current target will still be executed.
		* @see [[EventDispatcher.dispatchEvent]]
		*/


		var _proto = AbstractEvent.prototype;

		_proto.stopPropagation = function stopPropagation() {
		if (callListenerResult < _CallListenerResult.default.PROPAGATION_STOPPED) {
		callListenerResult = _CallListenerResult.default.PROPAGATION_STOPPED;
		}
		};
		/**
		* When called during the dispatch of an event, will prevent any other event listener from being
		* called for this event.
		* @see [[EventDispatcher.dispatchEvent]]
		*/


		_proto.stopImmediatePropagation = function stopImmediatePropagation() {
		callListenerResult = _CallListenerResult.default.IMMEDIATE_PROPAGATION_STOPPED;
		};
		/**
		* May only be called when the [[cancelable]] property of an event is set to _true_. Indicates to the
		* instance that dispatched the event that the default action for the event should not be executed.
		*/


		_proto.preventDefault = function preventDefault() {
		if (this.cancelable) {
		this.defaultPrevented = true;
		} else {
		throw new Error('Called preventDefault on a non-cancelable event');
		}
		};
		/**
		* Calls the given event handler, and returns an enum value that indicates if [[stopPropagation]] or
		* [[stopImmediatePropagation]] have been called on this event during the execution of that handler.
		* @param handler The event handler to execute
		* @returns An enum value, see [[CallListenerResult]]
		*/


		_proto.callListener = function callListener(handler) {
		callListenerResult = _CallListenerResult.default.NONE;
		handler.call(null, this);
		return callListenerResult;
		};
		/**
		* Should be implemented by child classes and return a copy of the event
		*/


		return AbstractEvent;
		}();

		var _default = AbstractEvent;
		exports.default = _default;

lib/CallListenerResult.d.ts

		/**
		* Enum that is returned by the [[AbstractEvent.callListener]] method
		*/
		declare const enum CallListenerResult {
		declare enum CallListenerResult {
		/**
		@@ -6,0 +6,0 @@ * Indicates that neither [[IEvent.stopPropagation\|stopPropagation]] nor

lib/CallListenerResult.js

		"use strict";
		Object.defineProperty(exports, "__esModule", { value: true });

		exports.__esModule = true;
		exports.default = void 0;

		/**
		@@ -7,18 +10,10 @@ * Enum that is returned by the [[AbstractEvent.callListener]] method
		var CallListenerResult;

		(function (CallListenerResult) {
		/**
		* Indicates that neither [[IEvent.stopPropagation\|stopPropagation]] nor
		* [[IEvent.stopImmediatePropagation\|stopImmediatePropagation]] has been called
		*/
		CallListenerResult[CallListenerResult["NONE"] = 0] = "NONE";
		/**
		* Indicates that [[IEvent.stopPropagation\|stopPropagation]] has been called, but
		* [[IEvent.stopImmediatePropagation\|stopImmediatePropagation]] hasn't
		*/
		CallListenerResult[CallListenerResult["PROPAGATION_STOPPED"] = 1] = "PROPAGATION_STOPPED";
		/**
		* Indicates that [[IEvent.stopImmediatePropagation\|stopImmediatePropagation]] has been called
		*/
		CallListenerResult[CallListenerResult["IMMEDIATE_PROPAGATION_STOPPED"] = 2] = "IMMEDIATE_PROPAGATION_STOPPED";
		CallListenerResult[CallListenerResult["NONE"] = 0] = "NONE";
		CallListenerResult[CallListenerResult["PROPAGATION_STOPPED"] = 1] = "PROPAGATION_STOPPED";
		CallListenerResult[CallListenerResult["IMMEDIATE_PROPAGATION_STOPPED"] = 2] = "IMMEDIATE_PROPAGATION_STOPPED";
		})(CallListenerResult \|\| (CallListenerResult = {}));
		exports.default = CallListenerResult;

		var _default = CallListenerResult;
		exports.default = _default;

lib/event/BasicEvent.js

		"use strict";
		Object.defineProperty(exports, "__esModule", { value: true });
		var tslib_1 = require("tslib");
		var AbstractEvent_1 = require("../AbstractEvent");
		var BasicEvent = (function (_super) {
		tslib_1.__extends(BasicEvent, _super);
		function BasicEvent() {
		return _super !== null && _super.apply(this, arguments) \|\| this;
		}
		BasicEvent.prototype.clone = function () {
		return new BasicEvent(this.type, this.bubbles, this.cancelable);
		};
		return BasicEvent;
		}(AbstractEvent_1.default));
		exports.default = BasicEvent;

		var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

		exports.__esModule = true;
		exports.default = void 0;

		var _inheritsLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/inheritsLoose"));

		var _AbstractEvent2 = _interopRequireDefault(require("../AbstractEvent"));

		var BasicEvent =
		/#__PURE__/
		function (_AbstractEvent) {
		(0, _inheritsLoose2.default)(BasicEvent, _AbstractEvent);

		function BasicEvent() {
		return _AbstractEvent.apply(this, arguments) \|\| this;
		}

		var _proto = BasicEvent.prototype;

		_proto.clone = function clone() {
		return new BasicEvent(this.type, this.bubbles, this.cancelable, this.timeStamp !== 0);
		};

		return BasicEvent;
		}(_AbstractEvent2.default);

		var _default = BasicEvent;
		exports.default = _default;

100

lib/event/CommonEvent.js

		"use strict";
		Object.defineProperty(exports, "__esModule", { value: true });
		var tslib_1 = require("tslib");
		var eventTypeUtils_1 = require("../util/eventTypeUtils");
		var AbstractEvent_1 = require("../AbstractEvent");
		var CommonEvent = (function (_super) {
		tslib_1.__extends(CommonEvent, _super);
		function CommonEvent() {
		return _super !== null && _super.apply(this, arguments) \|\| this;
		}
		CommonEvent.prototype.clone = function () {
		return new CommonEvent(this.type, this.bubbles, this.cancelable);
		};
		return CommonEvent;
		}(AbstractEvent_1.default));
		CommonEvent.COMPLETE = eventTypeUtils_1.EVENT_TYPE_PLACEHOLDER;
		CommonEvent.UPDATE = eventTypeUtils_1.EVENT_TYPE_PLACEHOLDER;
		CommonEvent.INIT = eventTypeUtils_1.EVENT_TYPE_PLACEHOLDER;
		CommonEvent.CHANGE = eventTypeUtils_1.EVENT_TYPE_PLACEHOLDER;
		CommonEvent.OPEN = eventTypeUtils_1.EVENT_TYPE_PLACEHOLDER;
		CommonEvent.CLOSE = eventTypeUtils_1.EVENT_TYPE_PLACEHOLDER;
		CommonEvent.RESIZE = eventTypeUtils_1.EVENT_TYPE_PLACEHOLDER;
		eventTypeUtils_1.generateEventTypes({ CommonEvent: CommonEvent });
		exports.default = CommonEvent;

		var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

		exports.__esModule = true;
		exports.default = void 0;

		var _inheritsLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/inheritsLoose"));

		var _eventTypeUtils = require("../util/eventTypeUtils");

		var _AbstractEvent2 = _interopRequireDefault(require("../AbstractEvent"));

		var CommonEvent =
		/#__PURE__/
		function (_AbstractEvent) {
		(0, _inheritsLoose2.default)(CommonEvent, _AbstractEvent);

		function CommonEvent() {
		return _AbstractEvent.apply(this, arguments) \|\| this;
		}

		var _proto = CommonEvent.prototype;

		_proto.clone = function clone() {
		return new CommonEvent(this.type, this.bubbles, this.cancelable);
		};

		return CommonEvent;
		}(_AbstractEvent2.default);

		Object.defineProperty(CommonEvent, "COMPLETE", {
		configurable: true,
		enumerable: true,
		writable: true,
		value: _eventTypeUtils.EVENT_TYPE_PLACEHOLDER
		});
		Object.defineProperty(CommonEvent, "UPDATE", {
		configurable: true,
		enumerable: true,
		writable: true,
		value: _eventTypeUtils.EVENT_TYPE_PLACEHOLDER
		});
		Object.defineProperty(CommonEvent, "INIT", {
		configurable: true,
		enumerable: true,
		writable: true,
		value: _eventTypeUtils.EVENT_TYPE_PLACEHOLDER
		});
		Object.defineProperty(CommonEvent, "CHANGE", {
		configurable: true,
		enumerable: true,
		writable: true,
		value: _eventTypeUtils.EVENT_TYPE_PLACEHOLDER
		});
		Object.defineProperty(CommonEvent, "OPEN", {
		configurable: true,
		enumerable: true,
		writable: true,
		value: _eventTypeUtils.EVENT_TYPE_PLACEHOLDER
		});
		Object.defineProperty(CommonEvent, "CLOSE", {
		configurable: true,
		enumerable: true,
		writable: true,
		value: _eventTypeUtils.EVENT_TYPE_PLACEHOLDER
		});
		Object.defineProperty(CommonEvent, "RESIZE", {
		configurable: true,
		enumerable: true,
		writable: true,
		value: _eventTypeUtils.EVENT_TYPE_PLACEHOLDER
		});
		(0, _eventTypeUtils.generateEventTypes)({
		CommonEvent: CommonEvent
		});
		var _default = CommonEvent;
		exports.default = _default;

lib/EventDispatcher.d.ts

		import sengDisposable from 'seng-disposable';
		import IEventDispatcher from './IEventDispatcher';
		import IEvent from './IEvent';
		import { IEventDispatcher } from './IEventDispatcher';
		import { IEvent } from './IEvent';
		import EventListenerData from './EventListenerData';
		@@ -202,2 +202,2 @@ /**
		*/
		export declare type EventHandler = (event?: IEvent) => any;
		export declare type EventHandler = (event: IEvent) => any;

650

lib/EventDispatcher.js

		"use strict";
		Object.defineProperty(exports, "__esModule", { value: true });
		var tslib_1 = require("tslib");
		var seng_disposable_1 = require("seng-disposable");
		var EventListenerData_1 = require("./EventListenerData");

		var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

		exports.__esModule = true;
		exports.callListeners = exports.getCallTree = exports.getParents = exports.removeListenersFrom = exports.default = void 0;

		var _inheritsLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/inheritsLoose"));

		var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));

		var _sengDisposable2 = _interopRequireDefault(require("seng-disposable"));

		var _EventListenerData = _interopRequireDefault(require("./EventListenerData"));

		var _EventPhase = _interopRequireDefault(require("./EventPhase"));

		var _CallListenerResult = _interopRequireDefault(require("./CallListenerResult"));

		/**
		@@ -14,212 +28,283 @@ * Base class that adds the ability to dispatch events and attach handlers that should be
		*/
		var EventDispatcher = (function (_super) {
		tslib_1.__extends(EventDispatcher, _super);
		/**
		* Creates an EventDispatcher instance.
		* @param parent If set, registers the given EventDispatcher instance as parent. This
		* child-parent relationship is used in the event chain during the capture phase of
		* events and the bubbling phase of bubbling events. For more information on event
		* bubbling and capturing, see [[dispatchEvent]]
		* @param target If set, will set the [[IEvent.target\|target]] attribute of all events
		* dispatched by this EventDispatcher to the given object. If not set, will use this instance
		* as a target for dispatched events.
		*/
		function EventDispatcher(parent, target) {
		if (parent === void 0) { parent = null; }
		var _this = _super.call(this) \|\| this;
		/**
		* An object containing all event listeners by [[IEvent.type\|event type]]. Each value
		* on this object is an Array of [[EventListenerData]] objects for each event listener
		* added with that type.
		*/
		_this.listeners = {};
		_this.target = target \|\| _this;
		_this.parent = parent;
		return _this;
		var EventDispatcher =
		/#__PURE__/
		function (_sengDisposable) {
		(0, _inheritsLoose2.default)(EventDispatcher, _sengDisposable);

		/**
		* The parent EventDispatcher instance. If this instance has no parent, this value will be
		* set to _null_. The parent is used in the bubbling and capturing phases of events.
		* @see [[dispatchEvent]] for more information on the bubbling and capturing chain
		*/

		/**
		* An object containing all event listeners by [[IEvent.type\|event type]]. Each value
		* on this object is an Array of [[EventListenerData]] objects for each event listener
		* added with that type.
		*/

		/**
		* The value that will be set as [[IEvent.target\|target]] on events that are dispatched
		* by this EventDispatcher instance.
		*/

		/**
		* Creates an EventDispatcher instance.
		* @param parent If set, registers the given EventDispatcher instance as parent. This
		* child-parent relationship is used in the event chain during the capture phase of
		* events and the bubbling phase of bubbling events. For more information on event
		* bubbling and capturing, see [[dispatchEvent]]
		* @param target If set, will set the [[IEvent.target\|target]] attribute of all events
		* dispatched by this EventDispatcher to the given object. If not set, will use this instance
		* as a target for dispatched events.
		*/
		function EventDispatcher(parent, target) {
		var _this;

		if (parent === void 0) {
		parent = null;
		}
		/**
		* Dispatches the given event. The dispatch consists of three phases:
		* 1. The capture phase. We walk through all ancestors of this EventDispatcher, with the
		* top-most instance first and the direct parent of this EventDispatcher last. On each
		* ancestor, we call all event handlers that are added with the _useCapture_ argument
		* set to _true_ and the _eventType_ set to the same [[IEvent.type\|type]] as
		* the given event.
		* If this EventDispatcher has no parent, this phase will be skipped.
		* 2. The target phase. In this phase we call all event handlers on this EventDispatcher
		* instance that listen for the same [[IEvent.type\|type]] as the given event.
		* 3. The bubbling phase. This phase will only be executed if the given event has the
		* [[IEvent.bubbles\|bubbles]] property set to _true_. If so, we will again walk through
		* all ancestors of this EventDispatcher, but in the reverse order: the direct parent
		* of this instance first and the top-most parent last. On every ancestor, we will call
		* all event handlers that are added with the _useCapture_ argument set to _false_ and the
		* _eventType_ set to the same [[IEvent.type\|type]] as the given event.
		*
		* If any of the event handlers call [[IEvent.stopPropagation\|stopPropagation()]], we will
		* skip all event handlers that occur on a target later in the event chain. If an event handler
		* calls [[IEvent.stopImmediatePropagation\|stopImmediatePropagation()]], we will also skip
		* any event handlers on the same target in the event chain.
		* @param event The event to dispatch
		* @returns If one of the handlers that have been called during this dispatch
		* called [[IEvent.preventDefault\|event.preventDefault()]], this method will return _false_.
		* If no handlers have been called or none of the handlers have called
		* [[IEvent.preventDefault\|event.preventDefault()]], this method will return _true_.
		*
		* _Please note: [[IEvent.preventDefault\|preventDefault()]] can only be called on
		* events that have their [[IEvent.cancelable\|cancelable]] property set to true_
		*/
		EventDispatcher.prototype.dispatchEvent = function (event) {
		if (this.isDisposed()) {
		throw new Error('Can\'t dispatchEvent on a disposed EventDispatcher');

		_this = _sengDisposable.call(this) \|\| this;
		Object.defineProperty((0, _assertThisInitialized2.default)(_this), "parent", {
		configurable: true,
		enumerable: true,
		writable: true,
		value: void 0
		});
		Object.defineProperty((0, _assertThisInitialized2.default)(_this), "listeners", {
		configurable: true,
		enumerable: true,
		writable: true,
		value: {}
		});
		Object.defineProperty((0, _assertThisInitialized2.default)(_this), "target", {
		configurable: true,
		enumerable: true,
		writable: true,
		value: void 0
		});
		_this.target = target \|\| (0, _assertThisInitialized2.default)(_this);
		_this.parent = parent;
		return _this;
		}
		/**
		* Dispatches the given event. The dispatch consists of three phases:
		* 1. The capture phase. We walk through all ancestors of this EventDispatcher, with the
		* top-most instance first and the direct parent of this EventDispatcher last. On each
		* ancestor, we call all event handlers that are added with the _useCapture_ argument
		* set to _true_ and the _eventType_ set to the same [[IEvent.type\|type]] as
		* the given event.
		* If this EventDispatcher has no parent, this phase will be skipped.
		* 2. The target phase. In this phase we call all event handlers on this EventDispatcher
		* instance that listen for the same [[IEvent.type\|type]] as the given event.
		* 3. The bubbling phase. This phase will only be executed if the given event has the
		* [[IEvent.bubbles\|bubbles]] property set to _true_. If so, we will again walk through
		* all ancestors of this EventDispatcher, but in the reverse order: the direct parent
		* of this instance first and the top-most parent last. On every ancestor, we will call
		* all event handlers that are added with the _useCapture_ argument set to _false_ and the
		* _eventType_ set to the same [[IEvent.type\|type]] as the given event.
		*
		* If any of the event handlers call [[IEvent.stopPropagation\|stopPropagation()]], we will
		* skip all event handlers that occur on a target later in the event chain. If an event handler
		* calls [[IEvent.stopImmediatePropagation\|stopImmediatePropagation()]], we will also skip
		* any event handlers on the same target in the event chain.
		* @param event The event to dispatch
		* @returns If one of the handlers that have been called during this dispatch
		* called [[IEvent.preventDefault\|event.preventDefault()]], this method will return _false_.
		* If no handlers have been called or none of the handlers have called
		* [[IEvent.preventDefault\|event.preventDefault()]], this method will return _true_.
		*
		* _Please note: [[IEvent.preventDefault\|preventDefault()]] can only be called on
		* events that have their [[IEvent.cancelable\|cancelable]] property set to true_
		*/


		var _proto = EventDispatcher.prototype;

		_proto.dispatchEvent = function dispatchEvent(event) {
		if (this.isDisposed()) {
		throw new Error("Can't dispatchEvent on a disposed EventDispatcher");
		} else {
		// todo: on debug builds, check willTrigger and log if false
		var callTree = getCallTree(this, event.bubbles);
		event.target = this.target;
		event.eventPhase = callTree.length === 1 ? _EventPhase.default.AT_TARGET : _EventPhase.default.CAPTURING_PHASE;

		for (var i = 0; i < callTree.length; i += 1) {
		var currentTarget = callTree[i];
		event.currentTarget = currentTarget;

		if (currentTarget === this) {
		event.eventPhase = _EventPhase.default.AT_TARGET;
		}
		else {
		// todo: on debug builds, check willTrigger and log if false
		var callTree = exports.getCallTree(this, event.bubbles);
		event.target = this.target;
		event.eventPhase = callTree.length === 1 ? 2 /* AT_TARGET / : 1 / CAPTURING_PHASE */;
		for (var i = 0; i < callTree.length; i += 1) {
		var currentTarget = callTree[i];
		event.currentTarget = currentTarget;
		if (currentTarget === this) {
		event.eventPhase = 2 /* AT_TARGET */;
		}
		var propagationIsStopped = exports.callListeners(currentTarget.listeners, event);
		if (propagationIsStopped) {
		event.eventPhase = 0 /* NONE */;
		break;
		}
		if (i === callTree.length - 1) {
		// after last target in tree, reset eventPhase to NONE
		event.eventPhase = 0 /* NONE */;
		}
		else if (currentTarget === this) {
		// after target === currentTarget we will enter the bubbling phase
		event.eventPhase = 3 /* BUBBLING_PHASE */;
		}
		}
		event.currentTarget = null;
		return !event.defaultPrevented;

		var propagationIsStopped = callListeners(currentTarget.listeners, event);

		if (propagationIsStopped) {
		event.eventPhase = _EventPhase.default.NONE;
		break;
		}
		};
		/**
		* Adds a new event listener. The given handler function will be called in the following cases:
		* - An event with a [[IEvent.type\|type]] that is equal to the given _eventType_ is dispatched
		* on this EventDispatcher instance.
		* - An event with a [[IEvent.type\|type]] that is equal to the given _eventType_ is dispatched
		* on a child EventDispatcher, and the _useCapture_ parameter is set to _true_
		* - An event with [[IEvent.bubbles\|bubbles]] set to _true_ and a [[IEvent.type\|type]] that
		* is equal to the given _eventType_ is dispatched on a child EventDispatcher, and the
		* _useCapture_ parameter is set to _false_
		*
		* @see [[dispatchEvent]] for more info on the which event listeners are called during
		* capturing and bubbling
		* @param eventType The eventType to listen for
		* @param handler The handler function that will be called when a matching event is dispatched.
		* This function will retrieve the dispatched [[IEvent\|event]] as a parameter
		* @param useCapture Indicates if this handler should be called during the capturing phase
		* of an event chain. If and only if this is set to _false_ will this handler be called
		* during the bubbling phase of an event chain.
		* @param priority A number that indicates the priority of this event listener relative
		* to other event listeners of the same type on this EventDispatcher instance. A higher number
		* indicates that this listener will be called earlier.
		* @returns An object describing the listener that has a [[EventListenerData.dispose\|dispose()]]
		* method to remove the listener.
		*/
		EventDispatcher.prototype.addEventListener = function (eventType, handler, useCapture, priority) {
		if (useCapture === void 0) { useCapture = false; }
		if (priority === void 0) { priority = 0; }
		if (typeof (this.listeners[eventType]) === 'undefined') {
		this.listeners[eventType] = [];

		if (i === callTree.length - 1) {
		// after last target in tree, reset eventPhase to NONE
		event.eventPhase = _EventPhase.default.NONE;
		} else if (currentTarget === this) {
		// after target === currentTarget we will enter the bubbling phase
		event.eventPhase = _EventPhase.default.BUBBLING_PHASE;
		}
		var data = new EventListenerData_1.default(this, eventType, handler, useCapture, priority);
		this.listeners[eventType].push(data);
		this.listeners[eventType].sort(this.listenerSorter);
		return data;
		};
		/**
		* Checks if an event listener matching the given parameters exists on this EventDispatcher
		* instance.
		* @param eventType Will only look for event listeners with this _eventType_
		* @param handler If set, will only match event listeners that have the same handler function
		* @param useCapture If set, will only match event listeners that have the same _useCapture_
		* argument. _Please note: if no useCapture argument was provided to [[addEventListener]], it
		* is set to false by default_
		* @returns {boolean} True if one or more event listeners exist
		*/
		EventDispatcher.prototype.hasEventListener = function (eventType, handler, useCapture) {
		if (typeof handler === 'undefined') {
		return !!this.listeners[eventType] && this.listeners[eventType].length > 0;
		}
		else if (!this.listeners[eventType]) {
		return false;
		}
		else {
		for (var i = 0; i < this.listeners[eventType].length; i += 1) {
		var listenerData = this.listeners[eventType][i];
		if (listenerData.handler === handler &&
		(typeof useCapture === 'undefined' \|\| useCapture === listenerData.useCapture)) {
		return true;
		}
		}
		return false;
		}
		};
		/**
		* Checks if an event listener with a [[EventListenerData.type\|type]] of the given _eventType_ exists
		* on this EventDispatcher or any ancestor EventDispatcher instance.
		* @param eventType The event type to check for
		* @returns _true_ if a matching listener is found
		*/
		EventDispatcher.prototype.willTrigger = function (eventType) {
		return this.hasEventListener(eventType) \|\| (!!this.parent && this.parent.willTrigger(eventType));
		};
		/**
		* Removes all event listeners that match the given parameters from this EventDispatcher
		* instance.
		*
		* _Please note: if you remove an event listener during the dispatch of an event it will
		* not be called anymore, even if it was supposed to be called in the same event chain_
		* @param eventType Only event listeners of that have this _eventType_ are removed
		* @param handler Only event listeners that have this handler function will be removed
		* @param useCapture Only event listeners that have been added with the same _useCapture_
		* parameter will be removed. _Please note: if no useCapture argument is provided, only
		* event listeners that have useCapture set to false will be removed._
		*/
		EventDispatcher.prototype.removeEventListener = function (eventType, handler, useCapture) {
		if (useCapture === void 0) { useCapture = false; }
		exports.removeListenersFrom(this.listeners, eventType, handler, useCapture);
		};
		/**
		* Removes all event listeners that have a [[IEvent.type\|type]] of the given _eventType_
		* from this EventDispatcher instance, regardless of their [[EventListenerData.handler\|handler]] or
		* [[EventListenerData.useCapture\|useCapture]] property.
		*
		* _Please note: if you remove an event listener during the dispatch of an event it will
		* not be called anymore, even if it was supposed to be called in the same event chain_
		* @param eventType The [[IEvent.type\|type]] of event to remove. If not provided, all event listeners
		* will be removed regardless of their type.
		*/
		EventDispatcher.prototype.removeAllEventListeners = function (eventType) {
		exports.removeListenersFrom(this.listeners, eventType);
		};
		/**
		* Cleans up this EventListener instance. No event handlers on this EventDispatcher will be called
		* and future calls to dispatchEvent() will be ignored.
		*/
		EventDispatcher.prototype.dispose = function () {
		this.removeAllEventListeners();
		_super.prototype.dispose.call(this);
		};
		/**
		* Method that is used to sort arrays of event listeners based on their [[EventListenerData.priority\|priority]]
		* property. Higher priority will be sorted before lower priority values.
		* @param e1 The first event listener to compare
		* @param e2 The other event listener to compare to
		* @returns A number that indicates the sorting according to the JS sort() method.
		*/
		EventDispatcher.prototype.listenerSorter = function (e1, e2) {
		return e2.priority - e1.priority;
		};
		return EventDispatcher;
		}(seng_disposable_1.default));
		exports.default = EventDispatcher;
		}

		event.currentTarget = null;
		return !event.defaultPrevented;
		}
		};
		/**
		* Adds a new event listener. The given handler function will be called in the following cases:
		* - An event with a [[IEvent.type\|type]] that is equal to the given _eventType_ is dispatched
		* on this EventDispatcher instance.
		* - An event with a [[IEvent.type\|type]] that is equal to the given _eventType_ is dispatched
		* on a child EventDispatcher, and the _useCapture_ parameter is set to _true_
		* - An event with [[IEvent.bubbles\|bubbles]] set to _true_ and a [[IEvent.type\|type]] that
		* is equal to the given _eventType_ is dispatched on a child EventDispatcher, and the
		* _useCapture_ parameter is set to _false_
		*
		* @see [[dispatchEvent]] for more info on the which event listeners are called during
		* capturing and bubbling
		* @param eventType The eventType to listen for
		* @param handler The handler function that will be called when a matching event is dispatched.
		* This function will retrieve the dispatched [[IEvent\|event]] as a parameter
		* @param useCapture Indicates if this handler should be called during the capturing phase
		* of an event chain. If and only if this is set to _false_ will this handler be called
		* during the bubbling phase of an event chain.
		* @param priority A number that indicates the priority of this event listener relative
		* to other event listeners of the same type on this EventDispatcher instance. A higher number
		* indicates that this listener will be called earlier.
		* @returns An object describing the listener that has a [[EventListenerData.dispose\|dispose()]]
		* method to remove the listener.
		*/


		_proto.addEventListener = function addEventListener(eventType, handler, useCapture, priority) {
		if (useCapture === void 0) {
		useCapture = false;
		}

		if (priority === void 0) {
		priority = 0;
		}

		if (typeof this.listeners[eventType] === 'undefined') {
		this.listeners[eventType] = [];
		}

		var data = new _EventListenerData.default(this, eventType, handler, useCapture, priority);
		this.listeners[eventType].push(data);
		this.listeners[eventType].sort(this.listenerSorter);
		return data;
		};
		/**
		* Checks if an event listener matching the given parameters exists on this EventDispatcher
		* instance.
		* @param eventType Will only look for event listeners with this _eventType_
		* @param handler If set, will only match event listeners that have the same handler function
		* @param useCapture If set, will only match event listeners that have the same _useCapture_
		* argument. _Please note: if no useCapture argument was provided to [[addEventListener]], it
		* is set to false by default_
		* @returns {boolean} True if one or more event listeners exist
		*/


		_proto.hasEventListener = function hasEventListener(eventType, handler, useCapture) {
		if (typeof handler === 'undefined') {
		return !!this.listeners[eventType] && this.listeners[eventType].length > 0;
		}

		if (!this.listeners[eventType]) {
		return false;
		}

		for (var i = 0; i < this.listeners[eventType].length; i += 1) {
		var listenerData = this.listeners[eventType][i];

		if (listenerData.handler === handler && (typeof useCapture === 'undefined' \|\| useCapture === listenerData.useCapture)) {
		return true;
		}
		}

		return false;
		};
		/**
		* Checks if an event listener with a [[EventListenerData.type\|type]] of the given _eventType_ exists
		* on this EventDispatcher or any ancestor EventDispatcher instance.
		* @param eventType The event type to check for
		* @returns _true_ if a matching listener is found
		*/


		_proto.willTrigger = function willTrigger(eventType) {
		return this.hasEventListener(eventType) \|\| !!this.parent && this.parent.willTrigger(eventType);
		};
		/**
		* Removes all event listeners that match the given parameters from this EventDispatcher
		* instance.
		*
		* _Please note: if you remove an event listener during the dispatch of an event it will
		* not be called anymore, even if it was supposed to be called in the same event chain_
		* @param eventType Only event listeners of that have this _eventType_ are removed
		* @param handler Only event listeners that have this handler function will be removed
		* @param useCapture Only event listeners that have been added with the same _useCapture_
		* parameter will be removed. _Please note: if no useCapture argument is provided, only
		* event listeners that have useCapture set to false will be removed._
		*/


		_proto.removeEventListener = function removeEventListener(eventType, handler, useCapture) {
		if (useCapture === void 0) {
		useCapture = false;
		}

		removeListenersFrom(this.listeners, eventType, handler, useCapture);
		};
		/**
		* Removes all event listeners that have a [[IEvent.type\|type]] of the given _eventType_
		* from this EventDispatcher instance, regardless of their [[EventListenerData.handler\|handler]] or
		* [[EventListenerData.useCapture\|useCapture]] property.
		*
		* _Please note: if you remove an event listener during the dispatch of an event it will
		* not be called anymore, even if it was supposed to be called in the same event chain_
		* @param eventType The [[IEvent.type\|type]] of event to remove. If not provided, all event listeners
		* will be removed regardless of their type.
		*/


		_proto.removeAllEventListeners = function removeAllEventListeners(eventType) {
		removeListenersFrom(this.listeners, eventType);
		};
		/**
		* Cleans up this EventListener instance. No event handlers on this EventDispatcher will be called
		* and future calls to dispatchEvent() will be ignored.
		*/


		_proto.dispose = function dispose() {
		this.removeAllEventListeners();

		_sengDisposable.prototype.dispose.call(this);
		};
		/**
		* Method that is used to sort arrays of event listeners based on their [[EventListenerData.priority\|priority]]
		* property. Higher priority will be sorted before lower priority values.
		* @param e1 The first event listener to compare
		* @param e2 The other event listener to compare to
		* @returns A number that indicates the sorting according to the JS sort() method.
		*/


		_proto.listenerSorter = function listenerSorter(e1, e2) {
		return e2.priority - e1.priority;
		};

		return EventDispatcher;
		}(_sengDisposable2.default);
		/**
		@@ -236,25 +321,32 @@ * Helper function for [[EventDispatcher.removeEventListener]] and [[EventDispatcher.removeAllEventListeners]].
		*/
		exports.removeListenersFrom = function (listeners, eventType, handler, useCapture) {
		for (var i in listeners) {
		if (listeners.hasOwnProperty(i)) {
		var matchesEventType = !eventType \|\| i === eventType;
		if (matchesEventType && listeners.hasOwnProperty(i) && listeners[i] instanceof Array) {
		var listenersForType = listeners[i];
		// traverse the array in reverse. this will make sure removal does not affect the loop
		for (var j = listenersForType.length; j; j -= 1) {
		var listenerData = listenersForType[j - 1];
		if ((!handler \|\| handler === listenerData.handler) &&
		(typeof useCapture === 'undefined' \|\| !!useCapture === listenerData.useCapture)) {
		listenersForType.splice(j - 1, 1);
		// mark the listener as removed, because it might still be active in the current event loop
		listenerData.isRemoved = true;
		}
		}
		// If an eventType was provided, this will be the only property where we need to remove listeners
		if (eventType) {
		break;
		}
		}


		exports.default = EventDispatcher;

		var removeListenersFrom = function removeListenersFrom(listeners, eventType, handler, useCapture) {
		for (var i in listeners) {
		/* istanbul ignore else */
		if (listeners.hasOwnProperty(i)) {
		var matchesEventType = !eventType \|\| i === eventType;

		if (matchesEventType && listeners.hasOwnProperty(i) && listeners[i] instanceof Array) {
		var listenersForType = listeners[i]; // traverse the array in reverse. this will make sure removal does not affect the loop

		for (var j = listenersForType.length; j; j -= 1) {
		var listenerData = listenersForType[j - 1];

		if ((!handler \|\| handler === listenerData.handler) && (typeof useCapture === 'undefined' \|\| !!useCapture === listenerData.useCapture)) {
		listenersForType.splice(j - 1, 1); // mark the listener as removed, because it might still be active in the current event loop

		listenerData.isRemoved = true;
		}
		} // If an eventType was provided, this will be the only property where we need to remove listeners


		if (eventType) {
		break;
		}
		}
		}
		}
		};
		@@ -267,10 +359,16 @@ /**
		*/
		exports.getParents = function (target) {
		var currentTarget = target;
		var parents = [];
		while (currentTarget.parent) {
		currentTarget = currentTarget.parent;
		parents.push(currentTarget);
		}
		return parents;


		exports.removeListenersFrom = removeListenersFrom;

		var getParents = function getParents(target) {
		var currentTarget = target;
		var parents = [];

		while (currentTarget.parent) {
		currentTarget = currentTarget.parent;
		parents.push(currentTarget);
		}

		return parents;
		};
		@@ -286,13 +384,21 @@ /**
		*/
		exports.getCallTree = function (target, bubbles) {
		var callTree = [];
		var parents = exports.getParents(target);
		for (var i = parents.length; i; i -= 1) {
		callTree.push(parents[i - 1]);
		}
		callTree.push(target);
		if (bubbles) {
		Array.prototype.push.apply(callTree, parents);
		}
		return callTree;


		exports.getParents = getParents;

		var getCallTree = function getCallTree(target, bubbles) {
		var callTree = [];
		var parents = getParents(target);

		for (var i = parents.length; i; i -= 1) {
		callTree.push(parents[i - 1]);
		}

		callTree.push(target);

		if (bubbles) {
		Array.prototype.push.apply(callTree, parents);
		}

		return callTree;
		};
		@@ -310,18 +416,34 @@ /**
		*/
		exports.callListeners = function (listeners, event) {
		var listenersOfType = listeners[event.type] ? listeners[event.type].slice() : [];
		var propagationIsStopped = false;
		for (var i = 0; i < listenersOfType.length; i += 1) {
		var disabledOnPhase = listenersOfType[i].useCapture ? 3 /* BUBBLING_PHASE / : 1 / CAPTURING_PHASE */;
		if (event.eventPhase !== disabledOnPhase && !listenersOfType[i].isRemoved) {
		var callResult = event.callListener(listenersOfType[i].handler);
		if (callResult > 0 /* NONE */) {
		propagationIsStopped = true;
		if (callResult === 2 /* IMMEDIATE_PROPAGATION_STOPPED */) {
		break;
		}
		}


		exports.getCallTree = getCallTree;

		var callListeners = function callListeners(listeners, event) {
		var listenersOfType = listeners[event.type] ? listeners[event.type].concat() : [];
		var propagationIsStopped = false;

		for (var i = 0; i < listenersOfType.length; i += 1) {
		var disabledOnPhase = listenersOfType[i].useCapture ? _EventPhase.default.BUBBLING_PHASE : _EventPhase.default.CAPTURING_PHASE;

		if (event.eventPhase !== disabledOnPhase && !listenersOfType[i].isRemoved) {
		var callResult = event.callListener(listenersOfType[i].handler);

		if (callResult > _CallListenerResult.default.NONE) {
		propagationIsStopped = true;

		if (callResult === _CallListenerResult.default.IMMEDIATE_PROPAGATION_STOPPED) {
		break;
		}
		}
		}
		return propagationIsStopped;
		}

		return propagationIsStopped;
		};
		/**
		* Type alias for the [[EventDispatcher.listeners]] property that contains all listeners for
		* an EventDispatcher instance
		*/


		exports.callListeners = callListeners;

139

lib/EventListenerData.js

		"use strict";
		Object.defineProperty(exports, "__esModule", { value: true });
		var tslib_1 = require("tslib");
		var seng_disposable_1 = require("seng-disposable");

		var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

		exports.__esModule = true;
		exports.default = void 0;

		var _inheritsLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/inheritsLoose"));

		var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));

		var _sengDisposable2 = _interopRequireDefault(require("seng-disposable"));

		/**
		@@ -10,40 +19,88 @@ * Data object that is created on every call to [[EventDispatcher.addEventListener]]. The object is
		*/
		var EventListenerData = (function (_super) {
		tslib_1.__extends(EventListenerData, _super);
		/**
		* @param dispatcher The EventDispatcher on which this listener listens for events
		* @param type The type of event this listener responds to
		* @param handler The handler function that will be called when a matching event is dispatched
		* @param useCapture Set to the _useCapture_ argument passed to [[EventDispatcher.addEventListener\|addEventListener]]
		* @param priority Set to the _priority_ argument passed to [[EventDispatcher.addEventListener\|addEventListener]].
		* Used to sort the listener within the [[EventDispatcher._listeners\|_listeners]] object of the EventDispatcher
		*/
		function EventListenerData(dispatcher, type, handler, useCapture, priority) {
		var _this = _super.call(this) \|\| this;
		_this.dispatcher = dispatcher;
		_this.type = type;
		_this.handler = handler;
		_this.useCapture = useCapture;
		_this.priority = priority;
		/**
		* This property will be set to _true_ by the [[EventDispatcher]] this listener is bound to when
		* the listener is removed. This is to make sure the handler is not called, even if the listener
		* is removed while dispatching the event.
		*/
		_this.isRemoved = false;
		return _this;
		var EventListenerData =
		/#__PURE__/
		function (_sengDisposable) {
		(0, _inheritsLoose2.default)(EventListenerData, _sengDisposable);

		/**
		* This property will be set to _true_ by the [[EventDispatcher]] this listener is bound to when
		* the listener is removed. This is to make sure the handler is not called, even if the listener
		* is removed while dispatching the event.
		*/

		/**
		* @param dispatcher The EventDispatcher on which this listener listens for events
		* @param type The type of event this listener responds to
		* @param handler The handler function that will be called when a matching event is dispatched
		* @param useCapture Set to the _useCapture_ argument passed to [[EventDispatcher.addEventListener\|addEventListener]]
		* @param priority Set to the _priority_ argument passed to [[EventDispatcher.addEventListener\|addEventListener]].
		* Used to sort the listener within the [[EventDispatcher._listeners\|_listeners]] object of the EventDispatcher
		*/
		function EventListenerData(dispatcher, type, handler, useCapture, priority) {
		var _this;

		_this = _sengDisposable.call(this) \|\| this;
		Object.defineProperty((0, _assertThisInitialized2.default)(_this), "dispatcher", {
		configurable: true,
		enumerable: true,
		writable: true,
		value: void 0
		});
		Object.defineProperty((0, _assertThisInitialized2.default)(_this), "type", {
		configurable: true,
		enumerable: true,
		writable: true,
		value: void 0
		});
		Object.defineProperty((0, _assertThisInitialized2.default)(_this), "handler", {
		configurable: true,
		enumerable: true,
		writable: true,
		value: void 0
		});
		Object.defineProperty((0, _assertThisInitialized2.default)(_this), "useCapture", {
		configurable: true,
		enumerable: true,
		writable: true,
		value: void 0
		});
		Object.defineProperty((0, _assertThisInitialized2.default)(_this), "priority", {
		configurable: true,
		enumerable: true,
		writable: true,
		value: void 0
		});
		Object.defineProperty((0, _assertThisInitialized2.default)(_this), "isRemoved", {
		configurable: true,
		enumerable: true,
		writable: true,
		value: false
		});
		_this.dispatcher = dispatcher;
		_this.type = type;
		_this.handler = handler;
		_this.useCapture = useCapture;
		_this.priority = priority;
		return _this;
		}
		/**
		* Detaches this event listener from its EventDispatcher. The handler function on this listener will
		* no longer be called in response to dispatched events.
		*/


		var _proto = EventListenerData.prototype;

		_proto.dispose = function dispose() {
		if (this.dispatcher) {
		this.dispatcher.removeEventListener(this.type, this.handler, this.useCapture);
		this.dispatcher = null;
		}
		/**
		* Detaches this event listener from its EventDispatcher. The handler function on this listener will
		* no longer be called in response to dispatched events.
		*/
		EventListenerData.prototype.dispose = function () {
		if (this.dispatcher) {
		this.dispatcher.removeEventListener(this.type, this.handler, this.useCapture);
		this.dispatcher = null;
		}
		_super.prototype.dispose.call(this);
		};
		return EventListenerData;
		}(seng_disposable_1.default));
		exports.default = EventListenerData;

		_sengDisposable.prototype.dispose.call(this);
		};

		return EventListenerData;
		}(_sengDisposable2.default);

		exports.default = EventListenerData;

lib/EventPhase.d.ts

		/**
		* An enum for possible event phases that an event can be in
		*/
		declare const enum EventPhase {
		declare enum EventPhase {
		/**
		@@ -6,0 +6,0 @@ * Indicates that the event is currently not being dispatched

lib/EventPhase.js

		"use strict";
		Object.defineProperty(exports, "__esModule", { value: true });

		exports.__esModule = true;
		exports.default = void 0;

		/**
		@@ -7,22 +10,11 @@ * An enum for possible event phases that an event can be in
		var EventPhase;

		(function (EventPhase) {
		/**
		* Indicates that the event is currently not being dispatched
		*/
		EventPhase[EventPhase["NONE"] = 0] = "NONE";
		/**
		* Indicates that the event is in the capturing phase, moving down from the top-most EventDispatcher
		* instance to the parent of the target EventDispatcher
		*/
		EventPhase[EventPhase["CAPTURING_PHASE"] = 1] = "CAPTURING_PHASE";
		/**
		* Indicates that we are currently calling the event listeners on the event target during dispatch.
		*/
		EventPhase[EventPhase["AT_TARGET"] = 2] = "AT_TARGET";
		/**
		* Indicates that we are currently moving back up from the parent of the target EventDispatcher to
		* the top-most EventDispatcher instance.
		*/
		EventPhase[EventPhase["BUBBLING_PHASE"] = 3] = "BUBBLING_PHASE";
		EventPhase[EventPhase["NONE"] = 0] = "NONE";
		EventPhase[EventPhase["CAPTURING_PHASE"] = 1] = "CAPTURING_PHASE";
		EventPhase[EventPhase["AT_TARGET"] = 2] = "AT_TARGET";
		EventPhase[EventPhase["BUBBLING_PHASE"] = 3] = "BUBBLING_PHASE";
		})(EventPhase \|\| (EventPhase = {}));
		exports.default = EventPhase;

		var _default = EventPhase;
		exports.default = _default;

lib/IEvent.d.ts

		@@ -1,6 +0,6 @@
		import IEventDispatcher from './IEventDispatcher';
		import { IEventDispatcher } from './IEventDispatcher';
		import EventPhase from './EventPhase';
		import { EventHandler } from './EventDispatcher';
		import CallListenerResult from './CallListenerResult';
		interface IEvent {
		export interface IEvent {
		type: string;
		@@ -20,2 +20,1 @@ bubbles: boolean;
		}
		export default IEvent;

lib/IEvent.js

		@@ -1,2 +0,1 @@
		"use strict";
		Object.defineProperty(exports, "__esModule", { value: true });
		"use strict";

lib/IEventDispatcher.d.ts

		@@ -1,5 +0,5 @@
		import IEvent from './IEvent';
		import { IEvent } from './IEvent';
		import EventListenerData from './EventListenerData';
		import { EventHandler } from './EventDispatcher';
		interface IEventDispatcher {
		export interface IEventDispatcher {
		dispatchEvent(event: IEvent): boolean;
		@@ -13,2 +13,1 @@ addEventListener(type: string, handler: EventHandler, useCapture?: boolean, priority?: number): EventListenerData;
		}
		export default IEventDispatcher;

lib/IEventDispatcher.js

		@@ -1,2 +0,1 @@
		"use strict";
		Object.defineProperty(exports, "__esModule", { value: true });
		"use strict";

lib/util/eventTypeUtils.js

		"use strict";
		Object.defineProperty(exports, "__esModule", { value: true });

		exports.__esModule = true;
		exports.generateEventTypes = exports.EVENT_TYPE_PLACEHOLDER = void 0;

		/**
		@@ -7,3 +10,3 @@ * Constant string that can be used as a placeholder for the static event types on an
		*/
		exports.EVENT_TYPE_PLACEHOLDER = '__eventTypeUtil::EVENT_TYPE_PLACEHOLDER';
		var EVENT_TYPE_PLACEHOLDER = '__eventTypeUtil::EVENT_TYPE_PLACEHOLDER';
		/**
		@@ -76,11 +79,16 @@ * It is common practice to have static properties on an [[AbstractEvent\|event class]] that indicate
		*/
		exports.generateEventTypes = function (targets) {
		Object.keys(targets).forEach(function (name) {
		var target = targets[name];
		Object.keys(target).forEach(function (prop) {
		if (target[prop] === exports.EVENT_TYPE_PLACEHOLDER) {
		target[prop] = name + "/" + prop;
		}
		});

		exports.EVENT_TYPE_PLACEHOLDER = EVENT_TYPE_PLACEHOLDER;

		var generateEventTypes = function generateEventTypes(targets) {
		Object.keys(targets).forEach(function (name) {
		var target = targets[name];
		Object.keys(target).forEach(function (prop) {
		if (target[prop] === EVENT_TYPE_PLACEHOLDER) {
		target[prop] = name + "/" + prop;
		}
		});
		});
		};

		exports.generateEventTypes = generateEventTypes;

159

package.json

		{
		"name": "seng-event",
		"version": "1.2.3",
		"version": "1.2.4",
		"description": "Provides Classes and utilities for dispatching and listening to events.",
		"main": "index.js",
		"main": "./index.js",
		"types": "./index.d.ts",
		"scripts": {
		"prepublish": "npm run build:npm",
		"test": "npm-run-all test:*",
		"test:unit": "karma start --single-run --browsers PhantomJS",
		"test:unit:dev": "karma start karma.conf.dev.js",
		"validate": "npm-run-all -p validate:webpack lint test:unit -s validate:coverage",
		"validate:webpack": "webpack-validator config/webpack.config.dist.js && webpack-validator config/webpack.config.test.js",
		"validate:coverage": "istanbul check-coverage --statement 1 --branches 1 --functions 1 --lines 1",
		"lint": "npm-run-all lint:*",
		"lint:ts": "tslint -c tslint.json \"src/*/.ts\"",
		"prepublishOnly": "npm-run-all -s validate build",
		"validate": "npm-run-all -p lint test",
		"dev": "npm-run-all -p dev:*",
		"dev:babel": "babel ./src -x \".ts\" --out-dir ./ --watch",
		"dev:ts": "tsc --noEmit --allowJs --watch",
		"build": "npm-run-all -s clean build:*",
		"build:babel": "babel ./src -x \".ts\" -x \".js\" --out-dir ./",
		"build:ts": "tsc -p ./tsconfig.build.json",
		"test": "cross-env NODE_ENV=test nyc mocha \"./test/*/.spec.{ts,js}\"",
		"test:dev": "mocha -w --watch-extensions ts,js \"./test/*/.spec.{ts,js}\"",
		"clean": "npm-run-all clean:*",
		"clean:test": "shx rm -rf coverage",
		"clean:npm": "shx rm -rf lib npm index.js index.d.ts",
		"clean:dist": "shx rm -rf dist \"seng-*.@(zip\|tar.gz)\"",
		"compile": "npm-run-all compile:**",
		"compile:npm": "npm run clean:npm && tsc -p ./ -d --outDir ./npm && shx mv \"./npm/*\" ./ && shx rm -rf ./npm",
		"compile:dist:typescript:es6": "tsc -p ./ -t es6 -m es6 --outDir ./dist/es6/",
		"compile:dist:webpack": "node script/webpack.js",
		"clean:test": "shx rm -rf coverage .nyc_output",
		"clean:npm": "shx rm -rf lib tmp index.js",
		"doc": "npm-run-all -p doc:*",
		"doc:typedoc": "typedoc --out docs/ src/ --mode file",
		"generate": "npm-run-all clean compile test:unit doc",
		"build": "npm-run-all clean compile",
		"dev": "node script/webpack-dev.js",
		"build:npm": "npm-run-all test compile:npm",
		"build:dist": "npm-run-all clean:dist compile:dist:**"
		"lint": "npm-run-all lint:*",
		"lint:js": "eslint src --ext .js --cache",
		"lint:ts": "tslint src/*/.ts -c tslint.json -p tsconfig.json -t verbose",
		"prettify": "prettier --write \"src/*/.{js,ts,json}\"",
		"precommit": "lint-staged"
		},
		"scriptsComment": {
		"test": "Placeholder for all types of tests",
		"test:unit": "Runs unit tests with Karma in PhantomJS",
		"test:unit:dev": "Runs unit tests with Karma in PhantomJS (with the watch mode)",
		"validate": "Runs all scripts that validate if the contents of this repos is correct",
		"validate:webpack": "Validates the webpack config file",
		"validate:coverage": "Checks if the code coverage results are above a defined minimun",
		"lint": "Placeholder for all types if linting checks",
		"lint:ts": "Lints the source files using tslint",
		"clean": "Placeholder for all clean tasks, resets the checkout to a clean state",
		"clean:test": "Remove all test related output",
		"clean:npm": "Remove all npm related output",
		"clean:dist": "Remove all dist related output",
		"compile": "Placeholder for all tasks that compile code",
		"compile:npm": "Compiles the code for npm. The output needs to end up in the current directory, but if we use that as outputPath in tsconfig.json it disables file-globbing for the includes array. That's why we are outputting it in a npm folder, and then moving it the this folder.",
		"compile:dist:typescript:es6": "Compiles typescript to es6 code in the dist folder",
		"compile:dist:webpack": "Compiles all dist bundles with webpack",
		"doc": "Placeholder for all doc scripts",
		"doc:typedoc": "Runs typedoc",
		"generate": "Placeholder for all scripts that generate something (code, test, doc, etc)",
		"build": "Cleans and compiles everything",
		"dev": "Compiles browser dist bundle with webpack and starts server",
		"build:npm": "Prepares the checkout for an npm publish",
		"build:dist": "Prepares the checkout for travis deployments to github and s3"
		"lint-staged": {
		"gitDir": "./",
		"linters": {
		"src/*/.{js,ts,json}": [
		"prettier --write",
		"git add"
		],
		"src/*/.js": [
		"npm run lint:js"
		],
		"src/*/.ts": [
		"npm run lint:ts"
		]
		}
		},
		@@ -79,49 +66,45 @@ "pre-push": [
		"devDependencies": {
		"@types/chai": "^3.4.34",
		"@types/mocha": "^2.2.32",
		"@types/sinon": "^2.3.6",
		"@babel/cli": "^7.0.0-beta.42",
		"@babel/core": "^7.0.0-beta.42",
		"@babel/plugin-transform-runtime": "^7.0.0-beta.42",
		"@babel/preset-env": "^7.0.0-beta.42",
		"@babel/preset-stage-3": "^7.0.0-beta.42",
		"@babel/preset-typescript": "^7.0.0-beta.42",
		"@babel/register": "^7.0.0-beta.42",
		"@types/chai": "^4.0.10",
		"@types/mocha": "^2.2.44",
		"@types/sinon": "^4.1.2",
		"@types/sinon-chai": "^2.7.29",
		"@types/webpack": "^1.12.35",
		"archiver": "^1.0.0",
		"awesome-typescript-loader": "^3.0.0-beta.17",
		"chai": "^3.5.0",
		"babel-eslint": "^8.0.3",
		"babel-plugin-istanbul": "^4.1.5",
		"chai": "^4.1.2",
		"coveralls": "^2.11.6",
		"es6-promise": "^3.2.1",
		"es6-promisify": "^4.1.0",
		"es6-promisify-all": "^0.1.0",
		"istanbul": "^0.4.5",
		"istanbul-instrumenter-loader": "^0.2.0",
		"karma": "^0.13.22",
		"karma-chai": "^0.1.0",
		"karma-coverage": "^1.0.0",
		"karma-mocha": "^1.1.1",
		"karma-mocha-reporter": "^2.2.0",
		"karma-phantomjs-launcher": "^1.0.0",
		"karma-remap-istanbul": "^0.6.0",
		"karma-source-map-support": "^1.1.0",
		"karma-sourcemap-loader": "^0.3.7",
		"karma-webpack": "^1.7.0",
		"marked": "^0.3.5",
		"mocha": "^2.5.3",
		"npm-run-all": "^2.2.0",
		"phantomjs-prebuilt": "^2.1.3",
		"pre-push": "^0.1.1",
		"remap-istanbul": "^0.9.5",
		"shx": "^0.1.2",
		"sinon": "^4.0.1",
		"cross-env": "^5.1.1",
		"eslint": "^4.13.1",
		"eslint-config-airbnb-base": "^12.1.0",
		"eslint-config-prettier": "^2.9.0",
		"eslint-friendly-formatter": "^3.0.0",
		"eslint-plugin-import": "^2.8.0",
		"eslint-plugin-prettier": "^2.4.0",
		"husky": "^0.14.3",
		"jsdom": "^11.5.1",
		"jsdom-global": "^3.0.2",
		"lint-staged": "^6.0.0",
		"mocha": "^4.0.1",
		"npm-run-all": "^4.1.2",
		"nyc": "^11.3.0",
		"prettier": "^1.9.2",
		"shx": "^0.2.2",
		"sinon": "^4.1.3",
		"sinon-chai": "^2.14.0",
		"tslint": "^5.3.2",
		"tslint-config-airbnb": "^5.0.1",
		"tsutils": "^2.1.0",
		"typedoc": "^0.7.1",
		"typescript": "^2.3.3",
		"webpack": "^1.12.12",
		"webpack-dev-server": "^1.16.2",
		"webpack-system-register": "^1.3.2",
		"webpack-validator": "^2.1.3"
		"tslint": "^5.8.0",
		"tslint-config-airbnb": "^5.4.2",
		"tslint-config-prettier": "^1.6.0",
		"typedoc": "^0.9.0",
		"typescript": "^2.8.1"
		},
		"dependencies": {
		"seng-disposable": "^1.1.3",
		"tslib": "^1.2.0"
		"@babel/runtime": "^7.0.0-beta.42",
		"seng-disposable": "^1.1.3"
		}
		}

README.md

		@@ -22,4 +22,2 @@ [![Travis](https://img.shields.io/travis/mediamonks/seng-event.svg?maxAge=2592000)](https://travis-ci.org/mediamonks/seng-event)

		### yarn / npm

		```sh
		@@ -33,7 +31,2 @@ yarn add seng-event

		### other

		We also have browser, amd, commonjs, umd, systemjs and es6 versions of
		this module available attached to the [Github Releases](https://github.com/mediamonks/seng-event/releases).

		## Basic usage
		@@ -98,14 +91,12 @@
		```sh
		yarn build # build this project
		yarn dev # run dev-watch mode, serving example/index.html in the browser
		yarn generate # generate all artifacts (compiles ts, webpack, docs and coverage)
		yarn typings # install .d.ts dependencies (done on install)
		yarn test:unit # run the unit tests
		yarn validate # runs validation scripts, including test, lint and coverage check
		yarn lint # run tslint on this project
		yarn doc # generate typedoc documentation
		yarn build # build this project
		yarn dev # run compilers in watch mode, both for babel and typescript
		yarn test # run the unit tests incl coverage
		yarn test:dev # run the unit tests in watch mode
		yarn lint # run eslint and tslint on this project
		yarn doc # generate typedoc documentation
		```

		When installing this module, it adds a pre-push hook, that runs the `validate`
		script before committing, so you can be sure that everything checks out.
		When installing this module, it adds a pre-commit hook, that runs lint and prettier commands
		before committing, so you can be sure that everything checks out.

		@@ -112,0 +103,0 @@ ## Contribute

.npmignore

karma.conf.dev.js

yarn.lock

Sorry, the diff of this file is not supported yet

seng-event - npm Package Compare versions

Improved metrics

Worsened metrics

Dependency changes