@afterswf/playerglobal 0.0.0-stage → 0.2.460

package/dist/lib/events/Event.js

@@ -0,0 +1,213 @@
+import { __extends } from "tslib";
+import { ASObject } from '@awayfl/avm2';
+import { release } from '@awayfl/swf-loader';
+import { assert, axCoerceString } from '@awayjs/graphics';
+var Event = /** @class */ (function (_super) {
+    __extends(Event, _super);
+    function Event(type, bubbles, cancelable) {
+        if (bubbles === void 0) { bubbles = false; }
+        if (cancelable === void 0) { cancelable = false; }
+        var _this = _super.call(this) || this;
+        //	todo:
+        //	these 2 only exists to prevent errors in types for now, because for some reason
+        //	some functions use core/EventBase for type but recieve as3/Event
+        _this._iAllowedToPropagate = true;
+        _this._iAllowedToImmediatlyPropagate = true;
+        _this._type = axCoerceString(type);
+        _this._bubbles = !!bubbles;
+        _this._cancelable = !!cancelable;
+        _this._target = null;
+        _this._currentTarget = null;
+        _this._eventPhase = null; //80pro: todo: EventPhase.AT_TARGET;
+        _this._stopPropagation = false;
+        _this._stopImmediatePropagation = false;
+        _this._isDefaultPrevented = false;
+        return _this;
+    }
+    Event.getInstance = function (type, bubbles, cancelable) {
+        if (bubbles === void 0) { bubbles = false; }
+        if (cancelable === void 0) { cancelable = false; }
+        var instance = this._instances[type];
+        if (!instance) {
+            instance = new Event(type, bubbles, cancelable);
+            this._instances[type] = instance;
+        }
+        instance._bubbles = bubbles;
+        instance._cancelable = cancelable;
+        return instance;
+    };
+    Event.getBroadcastInstance = function (type, bubbles, cancelable) {
+        if (bubbles === void 0) { bubbles = false; }
+        if (cancelable === void 0) { cancelable = false; }
+        var instance = this._instances[type];
+        if (!instance) {
+            instance = new Event(type, bubbles, cancelable);
+            this._instances[type] = instance;
+            // Some events are documented as broadcast event in the AS3 docs.
+            // We can't set |_isBroadcastEvent| flag in the
+            // constructor because if you create custom events with these types they do capture and bubble.
+            release || assert(Event.isBroadcastEventType(type));
+        }
+        instance._isBroadcastEvent = true;
+        instance._bubbles = bubbles;
+        instance._cancelable = cancelable;
+        return instance;
+    };
+    /**
+   * http://stackoverflow.com/questions/16900176/as3enterframe-event-propagation-understanding-issue
+   */
+    Event.isBroadcastEventType = function (type) {
+        switch (type) {
+            case Event.ENTER_FRAME:
+            case Event.EXIT_FRAME:
+            case Event.FRAME_CONSTRUCTED:
+            case Event.RENDER:
+            case Event.ACTIVATE:
+            case Event.DEACTIVATE:
+                return true;
+        }
+        return false;
+    };
+    Object.defineProperty(Event.prototype, "type", {
+        get: function () {
+            return this._type;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Event.prototype, "bubbles", {
+        get: function () {
+            return this._bubbles;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Event.prototype, "cancelable", {
+        get: function () {
+            return this._cancelable;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Event.prototype, "target", {
+        get: function () {
+            return this._target;
+        },
+        set: function (value) {
+            this._target = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Event.prototype, "currentTarget", {
+        get: function () {
+            return this._currentTarget;
+        },
+        set: function (value) {
+            this._currentTarget = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Event.prototype, "eventPhase", {
+        get: function () {
+            return this._eventPhase;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Event.prototype.stopPropagation = function () {
+        this._stopPropagation = true;
+        if (this.adaptee) {
+            this.adaptee.stopPropagation();
+        }
+    };
+    Event.prototype.stopImmediatePropagation = function () {
+        this._stopImmediatePropagation = this._stopPropagation = true;
+        if (this.adaptee) {
+            this.adaptee.stopImmediatePropagation();
+        }
+    };
+    Event.prototype.preventDefault = function () {
+        if (this._cancelable) {
+            this._isDefaultPrevented = true;
+        }
+    };
+    Event.prototype.isDefaultPrevented = function () {
+        return this._isDefaultPrevented;
+    };
+    Event.prototype.isBroadcastEvent = function () {
+        return !!this._isBroadcastEvent;
+    };
+    Event.prototype.clone = function () {
+        return new Event(this._type, this._bubbles, this._cancelable);
+    };
+    Event.prototype.toString = function () {
+        return this.formatToString('Event', 'type', 'bubbles', 'cancelable', 'eventPhase');
+    };
+    Event.prototype.formatToString = function (className) {
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        var str = '[' + className;
+        for (var i = 0; i < args.length; i++) {
+            var field = args[i];
+            var value = this.axGetPublicProperty(field);
+            if (typeof value === 'string') {
+                value = '"' + value + '"';
+            }
+            str += ' ' + field + '=' + value;
+        }
+        return str + ']';
+    };
+    Event.classInitializer = function () {
+        var self = this;
+        self._instances = {};
+    };
+    // JS -> AS Bindings
+    Event.ACTIVATE = 'activate';
+    Event.ADDED = 'added';
+    Event.ADDED_TO_STAGE = 'addedToStage';
+    Event.CANCEL = 'cancel';
+    Event.CHANGE = 'change';
+    Event.CLEAR = 'clear';
+    Event.CLOSE = 'close';
+    Event.COMPLETE = 'complete';
+    Event.CONNECT = 'connect';
+    Event.COPY = 'copy';
+    Event.CUT = 'cut';
+    Event.DEACTIVATE = 'deactivate';
+    Event.ENTER_FRAME = 'enterFrame';
+    Event.FRAME_CONSTRUCTED = 'frameConstructed';
+    Event.EXIT_FRAME = 'exitFrame';
+    Event.FRAME_LABEL = 'frameLabel';
+    Event.ID3 = 'id3';
+    Event.INIT = 'init';
+    Event.MOUSE_LEAVE = 'mouseLeave';
+    Event.OPEN = 'open';
+    Event.PASTE = 'paste';
+    Event.REMOVED = 'removed';
+    Event.REMOVED_FROM_STAGE = 'removedFromStage';
+    Event.RENDER = 'render';
+    Event.RESIZE = 'resize';
+    Event.SCROLL = 'scroll';
+    Event.TEXT_INTERACTION_MODE_CHANGE = 'textInteractionModeChange';
+    Event.SELECT = 'select';
+    Event.SELECT_ALL = 'selectAll';
+    Event.SOUND_COMPLETE = 'soundComplete';
+    Event.TAB_CHILDREN_CHANGE = 'tabChildrenChange';
+    Event.TAB_ENABLED_CHANGE = 'tabEnabledChange';
+    Event.TAB_INDEX_CHANGE = 'tabIndexChange';
+    Event.UNLOAD = 'unload';
+    Event.FULLSCREEN = 'fullScreen';
+    Event.CONTEXT3D_CREATE = 'context3DCreate';
+    Event.TEXTURE_READY = 'textureReady';
+    Event.VIDEO_FRAME = 'videoFrame';
+    Event.SUSPEND = 'suspend';
+    Event.AVM1_INIT = 'initialize';
+    Event.AVM1_CONSTRUCT = 'construct';
+    Event.AVM1_LOAD = 'load';
+    return Event;
+}(ASObject));
+export { Event };

package/dist/lib/events/EventDispatcher.d.ts

@@ -0,0 +1,57 @@
+import { Event } from './Event';
+import { EventDispatcherBase } from './EventDispatcherBase';
+/**
+     * [broadcast event] Dispatched when the Flash Player or AIR application operating
+     * loses system focus and is becoming inactive.
+     * @eventType	flash.events.Event.DEACTIVATE
+    [Event(name="deactivate", type="flash.events.Event")]
+
+     * [broadcast event] Dispatched when the Flash Player or AIR application gains
+     * operating system focus and becomes active.
+     * @eventType	flash.events.Event.ACTIVATE
+    [Event(name="activate", type="flash.events.Event")]
+ */
+export declare class EventDispatcher extends EventDispatcherBase {
+    static eventsThatBubbleInAwayJS: string[];
+    readonly id: number;
+    toString(): string;
+    hasEventListener(type: string, listener?: (event: Event) => void): boolean;
+    willTrigger(): void;
+    dispatchEvent(event: Event, comesFromAway?: boolean): boolean;
+    protected eventMapping: Object;
+    protected eventMappingDummys: Object;
+    protected eventMappingExtern: Object;
+    protected eventMappingInvert: Object;
+    _avm1Context: any;
+    constructor(target?: any);
+    private initActivateListener;
+    private removeActivateListener;
+    private _activateCallbackDelegate;
+    private activateCallback;
+    private initDeactivateListener;
+    private removeDeactivateListener;
+    private _deactivateCallbackDelegate;
+    private deactivateCallback;
+    addEventListener(type: string, listener: (event: Event) => void, useCapture?: boolean, priority?: number, useWeakReference?: boolean): void;
+    /**
+     * Remove an event listener
+     * @method removeEventListener
+     * @param {String} type of event to remove a listener for
+     * @param {Function} listener function
+     */
+    removeEventListener(type: string, listener: (event: Event) => void): void;
+}
+export declare class BroadcastEventDispatchQueue {
+    /**
+     * The queues start off compact but can have null values if event targets are removed.
+     * Periodically we compact them if too many null values exist.
+     */
+    private _queues;
+    private static _instance;
+    static getInstance(): BroadcastEventDispatchQueue;
+    add(type: string, target: EventDispatcher): void;
+    remove(type: string, target: EventDispatcher): void;
+    dispatchEvent(event: Event): void;
+    getQueueLength(type: string): number;
+}
+//# sourceMappingURL=EventDispatcher.d.ts.map

package/dist/lib/events/EventDispatcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventDispatcher.d.ts","sourceRoot":"","sources":["../../../lib/events/EventDispatcher.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAS5D;;;;;;;;;;GAUG;AAEH,qBAAa,eAAgB,SAAQ,mBAAmB;IAEvD,OAAc,wBAAwB,EAAE,MAAM,EAAE,CAmB/C;IAED,SAAgB,EAAE,EAAE,MAAM,CAAC;IAEpB,QAAQ,IAAI,MAAM;IAIlB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,GAAG,OAAO;IAK1E,WAAW;IAIX,aAAa,CAAC,KAAK,EAAE,KAAK,EAAE,aAAa,GAAE,OAAe,GAAG,OAAO;IAkB3E,SAAS,CAAC,YAAY,EAAE,MAAM,CAAC;IAC/B,SAAS,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACrC,SAAS,CAAC,kBAAkB,EAAE,MAAM,CAAC;IAErC,SAAS,CAAC,kBAAkB,EAAE,MAAM,CAAC;IAG9B,YAAY,EAAE,GAAG,CAAC;gBAEb,MAAM,GAAE,GAAU;IA6B9B,OAAO,CAAC,oBAAoB;IAI5B,OAAO,CAAC,sBAAsB;IAI9B,OAAO,CAAC,yBAAyB,CAAuB;IACxD,OAAO,CAAC,gBAAgB;IAMxB,OAAO,CAAC,sBAAsB;IAI9B,OAAO,CAAC,wBAAwB;IAIhC,OAAO,CAAC,2BAA2B,CAAuB;IAC1D,OAAO,CAAC,kBAAkB;IAKnB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,EAAE,UAAU,GAAE,OAAe,EAClG,QAAQ,GAAE,MAAkB,EAAE,gBAAgB,GAAE,OAAe,GAAG,IAAI;IA2CvE;;;;;OAKG;IACI,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,GAAG,IAAI;CAoBhF;AAQD,qBAAa,2BAA2B;IACvC;;;OAGG;IACH,OAAO,CAAC,OAAO,CAAmG;IAClH,OAAO,CAAC,MAAM,CAAC,SAAS,CAA8B;WACxC,WAAW,IAAI,2BAA2B;IAKxD,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,eAAe;IAUzC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,eAAe;IAO5C,aAAa,CAAC,KAAK,EAAE,KAAK;IA0B1B,cAAc,CAAC,IAAI,EAAE,MAAM;CAG3B"}

package/dist/lib/events/EventDispatcher.js

@@ -0,0 +1,233 @@
+import { __extends } from "tslib";
+import { Event } from './Event';
+import { EventDispatcherBase } from './EventDispatcherBase';
+import { UUID } from '@awayjs/core';
+import { release } from '@awayfl/swf-loader';
+import { assert } from '@awayjs/graphics';
+import { MouseEvent } from '../events/MouseEvent';
+import { Settings } from '@awayfl/avm2';
+/**
+     * [broadcast event] Dispatched when the Flash Player or AIR application operating
+     * loses system focus and is becoming inactive.
+     * @eventType	flash.events.Event.DEACTIVATE
+    [Event(name="deactivate", type="flash.events.Event")]
+
+     * [broadcast event] Dispatched when the Flash Player or AIR application gains
+     * operating system focus and becomes active.
+     * @eventType	flash.events.Event.ACTIVATE
+    [Event(name="activate", type="flash.events.Event")]
+ */
+var EventDispatcher = /** @class */ (function (_super) {
+    __extends(EventDispatcher, _super);
+    function EventDispatcher(target) {
+        if (target === void 0) { target = null; }
+        var _this = _super.call(this, target) || this;
+        _this.id = UUID.Next();
+        _this.eventMapping || (_this.eventMapping = {});
+        _this.eventMappingDummys || (_this.eventMappingDummys = {});
+        _this.eventMappingExtern || (_this.eventMappingExtern = {});
+        _this.eventMappingInvert || (_this.eventMappingInvert = {});
+        _this._activateCallbackDelegate = function (event) { return _this.activateCallback(event); };
+        _this.eventMapping[Event.ACTIVATE] = {
+            adaptedType: '',
+            addListener: _this.initActivateListener,
+            removeListener: _this.removeActivateListener,
+            callback: _this._activateCallbackDelegate
+        };
+        _this._deactivateCallbackDelegate = function (event) { return _this.deactivateCallback(event); };
+        _this.eventMapping[Event.DEACTIVATE] = {
+            adaptedType: '',
+            addListener: _this.initDeactivateListener,
+            removeListener: _this.removeDeactivateListener,
+            callback: _this._deactivateCallbackDelegate
+        };
+        return _this;
+    }
+    EventDispatcher.prototype.toString = function () {
+        return '';
+    };
+    EventDispatcher.prototype.hasEventListener = function (type, listener) {
+        return _super.prototype.hasEventListener.call(this, type, listener);
+    };
+    EventDispatcher.prototype.willTrigger = function () {
+    };
+    EventDispatcher.prototype.dispatchEvent = function (event, comesFromAway) {
+        if (comesFromAway === void 0) { comesFromAway = false; }
+        event.currentTarget = this;
+        if (event.type == 'enterFrame') { //} || event.type=="scroll"){
+            event.target = this;
+        }
+        var returnVal = _super.prototype.dispatchEvent.call(this, event);
+        // workaround for now.
+        // mousevents already bubble up the scenegraph in MouseMangager
+        // for all other events, we want to bubble them up here:
+        if (!comesFromAway && event.bubbles && EventDispatcher.eventsThatBubbleInAwayJS.indexOf(event.type) == -1) {
+            if (this.adaptee && this.adaptee.parent) {
+                this.adaptee.parent.adapter.dispatchEvent(event);
+            }
+        }
+        return returnVal;
+    };
+    // ---------- event mapping functions Event.ACTIVATE
+    EventDispatcher.prototype.initActivateListener = function (type, callback) {
+        window.onfocus = callback;
+    };
+    EventDispatcher.prototype.removeActivateListener = function (type, callback) {
+        window.onfocus = null;
+    };
+    EventDispatcher.prototype.activateCallback = function (event) {
+        if (event === void 0) { event = null; }
+        this.dispatchEvent(new this.sec.flash.events.Event(Event.ACTIVATE));
+    };
+    // ---------- event mapping functions Event.DEACTIVATE
+    EventDispatcher.prototype.initDeactivateListener = function (type, callback) {
+        window.onblur = callback;
+    };
+    EventDispatcher.prototype.removeDeactivateListener = function (type, callback) {
+        window.onblur = null;
+    };
+    EventDispatcher.prototype.deactivateCallback = function (event) {
+        if (event === void 0) { event = null; }
+        this.dispatchEvent(new this.sec.flash.events.Event(Event.DEACTIVATE));
+    };
+    /*overwrite*/
+    EventDispatcher.prototype.addEventListener = function (type, listener, useCapture, priority, useWeakReference) {
+        if (useCapture === void 0) { useCapture = false; }
+        if (priority === void 0) { priority = 0; }
+        if (useWeakReference === void 0) { useWeakReference = false; }
+        if (!useCapture && Event.isBroadcastEventType(type)) {
+            BroadcastEventDispatchQueue.getInstance().add(type, this);
+        }
+        this.eventMapping || (this.eventMapping = {});
+        this.eventMappingDummys || (this.eventMappingDummys = {});
+        this.eventMappingExtern || (this.eventMappingExtern = {});
+        this.eventMappingInvert || (this.eventMappingInvert = {});
+        if (this.eventMappingDummys.hasOwnProperty(type)) {
+            // this is a dummy eventMapping
+            // this means that this is a event-type, that is not yet supported
+            // we do not need to register it on superclass
+            // for now we output a warning
+            //console.log("Warning - EventDispatcher:  trying to listen for unsupported event: :
+            //"+this.eventMappingDummys[type]);
+            return;
+        }
+        else if (this.eventMapping.hasOwnProperty(type)) {
+            // a mapping exists for this event
+            //making sure standart behaviour still works (listener is tracked in list)
+            _super.prototype.addEventListener.call(this, type, listener, useCapture, priority, useWeakReference);
+            // call the provided "addListener" function
+            this.eventMapping[type].addListener.call(this, this.eventMapping[type].adaptedType, this.eventMapping[type].callback, listener);
+            return;
+        }
+        else {
+            // this is a external eventMapping
+            // this means that we do not need to create any mapping, and will manually dispatch the event
+            // we still need to register it on superclass, so it will work if we dispatch it manually
+            _super.prototype.addEventListener.call(this, type, listener, useCapture, priority, useWeakReference);
+            return;
+        }
+        // if we make it here, the event is not handled by this dispatcher
+        // lets output a Warning for now.
+        //console.log("EventDispatcher: trying to listen for unknown event: '"+type+"'")
+    };
+    /**
+     * Remove an event listener
+     * @method removeEventListener
+     * @param {String} type of event to remove a listener for
+     * @param {Function} listener function
+     */
+    EventDispatcher.prototype.removeEventListener = function (type, listener) {
+        this.eventMapping || (this.eventMapping = {});
+        this.eventMappingDummys || (this.eventMappingDummys = {});
+        this.eventMappingExtern || (this.eventMappingExtern = {});
+        this.eventMappingInvert || (this.eventMappingInvert = {});
+        _super.prototype.removeEventListener.call(this, type, listener);
+        if (this.eventMapping.hasOwnProperty(type)) {
+            // a mapping exists
+            this.eventMapping[type].removeListener.call(this, this.eventMapping[type].adaptedType, this.eventMapping[type].callback, listener);
+            if (!this.hasEventListener(type)) {
+                if (Event.isBroadcastEventType(type)) {
+                    BroadcastEventDispatchQueue.getInstance().remove(type, this);
+                }
+            }
+        }
+    };
+    EventDispatcher.eventsThatBubbleInAwayJS = [
+        MouseEvent.MOUSE_WHEEL,
+        MouseEvent.MOUSE_UP,
+        MouseEvent.MOUSE_OVER,
+        MouseEvent.MOUSE_OUT,
+        MouseEvent.ROLL_OVER,
+        MouseEvent.ROLL_OUT,
+        MouseEvent.MOUSE_MOVE,
+        MouseEvent.MOUSE_DOWN,
+        MouseEvent.DOUBLE_CLICK,
+        MouseEvent.CLICK,
+        Event.ENTER_FRAME,
+        Event.EXIT_FRAME,
+        Event.FRAME_CONSTRUCTED,
+        Event.ADDED_TO_STAGE,
+        Event.RESIZE,
+        Event.REMOVED_FROM_STAGE,
+        //KeyboardEvent.KEY_DOWN,
+        //KeyboardEvent.KEY_UP,
+    ];
+    return EventDispatcher;
+}(EventDispatcherBase));
+export { EventDispatcher };
+var USE_WEAK = ('WeakRef' in self) && Settings.USE_WEAK_REF;
+if (USE_WEAK) {
+    console.debug('[BroadcastEventDispatchQueue] `WeakRef` used for Broadcast Events!');
+}
+var BroadcastEventDispatchQueue = /** @class */ (function () {
+    function BroadcastEventDispatchQueue() {
+        /**
+         * The queues start off compact but can have null values if event targets are removed.
+         * Periodically we compact them if too many null values exist.
+         */
+        this._queues = {};
+    }
+    BroadcastEventDispatchQueue.getInstance = function () {
+        return BroadcastEventDispatchQueue._instance
+            || (BroadcastEventDispatchQueue._instance = new BroadcastEventDispatchQueue());
+    };
+    BroadcastEventDispatchQueue.prototype.add = function (type, target) {
+        // release || assert(Event.isBroadcastEventType(type), "Can only register broadcast events.");
+        var queue = this._queues[type] || (this._queues[type] = []);
+        if (queue[target.id])
+            return;
+        queue[target.id] = (USE_WEAK ? new self.WeakRef(target) : target);
+    };
+    BroadcastEventDispatchQueue.prototype.remove = function (type, target) {
+        //release || assert (Event.isBroadcastEventType(type), "Can only unregister broadcast events.");
+        var queue = this._queues[type];
+        release || assert(queue, 'There should already be a queue for this.');
+        delete queue[target.id];
+    };
+    BroadcastEventDispatchQueue.prototype.dispatchEvent = function (event) {
+        //release || assert (event.isBroadcastEvent(), "Cannot dispatch non-broadcast events.");
+        var queue = this._queues[event._type];
+        //return if no listeners exist for event type
+        if (!queue)
+            return;
+        for (var key in queue) {
+            var target = queue[key];
+            if (USE_WEAK)
+                target = target === null || target === void 0 ? void 0 : target.deref();
+            if (target) {
+                var dispatchedEvent = new event.sec.flash.events.Event(event.type, event.bubbles, event.cancelable);
+                dispatchedEvent._isBroadcastEvent = event._isBroadcastEvent;
+                target.dispatchEvent(dispatchedEvent);
+            }
+            else {
+                console.debug('[BroadcastEventDispatchQueue] Broadcast target was deleted by GC:', key);
+                delete queue[key];
+            }
+        }
+    };
+    BroadcastEventDispatchQueue.prototype.getQueueLength = function (type) {
+        return this._queues[type] ? Object.getOwnPropertyNames(this._queues[type]).length : 0;
+    };
+    return BroadcastEventDispatchQueue;
+}());
+export { BroadcastEventDispatchQueue };

package/dist/lib/events/EventDispatcherBase.d.ts

@@ -0,0 +1,61 @@
+import { ASObject, AXClass } from '@awayfl/avm2';
+import { Event } from './Event';
+/**
+ * Base export class for dispatching events
+*
+* @export class away.events.EventDispatcher
+*
+*/
+export declare class EventDispatcherBase extends ASObject {
+    static axClass: typeof EventDispatcherBase & AXClass;
+    private _listenerObjects;
+    private _t;
+    toString(): string;
+    constructor(target?: any);
+    /**
+     * Add an event listener
+     * @method addEventListener
+     * @param {String} Name of event to add a listener for
+     * @param {Function} Callback function
+     */
+    addEventListener(type: string, listener: (event: Event) => void, useCapture?: boolean, priority?: number, useWeakReference?: boolean): void;
+    /**
+     * Remove an event listener
+     * @method removeEventListener
+     * @param {String} Name of event to remove a listener for
+     * @param {Function} Callback function
+     */
+    removeEventListener(type: string, listener: (event: Event) => void): void;
+    /**
+     * Dispatch an event
+     * @method dispatchEvent
+     * @param {Event} Event to dispatch
+     */
+    dispatchEvent(event: Event): boolean;
+    /**
+     * check if an object has an event listener assigned to it
+     * @method hasListener
+     * @param {String} Name of event to remove a listener for
+     * @param {Function} Callback function
+     */
+    hasEventListener(type: string, listener?: (event: Event) => void): boolean;
+}
+export declare class ListenerObject {
+    private _index;
+    private _singlePriority;
+    private _listeners;
+    private _listenersByPriority;
+    numListeners: number;
+    addEventListener(listener: (event: Event) => void, priority?: number): void;
+    removeEventListener(listener: (event: Event) => void): void;
+    dispatchEvent(event: Event): void;
+    /**
+     * get Event Listener Index in array. Returns -1 if no listener is added
+     * @method getEventListenerIndex
+     * @param {String} Name of event to remove a listener for
+     * @param {Function} Callback function
+     */
+    getEventListenerIndex(listener: (event: Event) => void): number;
+}
+export default EventDispatcherBase;
+//# sourceMappingURL=EventDispatcherBase.d.ts.map

package/dist/lib/events/EventDispatcherBase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventDispatcherBase.d.ts","sourceRoot":"","sources":["../../../lib/events/EventDispatcherBase.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACjD,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC;;;;;EAKE;AACF,qBAAa,mBAAoB,SAAQ,QAAQ;IAChD,MAAM,CAAC,OAAO,EAAE,OAAO,mBAAmB,GAAG,OAAO,CAAC;IAErD,OAAO,CAAC,gBAAgB,CAAwB;IAChD,OAAO,CAAC,EAAE,CAAM;IAET,QAAQ,IAAI,MAAM;gBAIb,MAAM,GAAE,GAAU;IAM9B;;;;;OAKG;IACI,gBAAgB,CAAC,IAAI,EAAE,MAAM,EACnC,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,EAChC,UAAU,GAAE,OAAe,EAC3B,QAAQ,GAAE,MAAkB,EAC5B,gBAAgB,GAAE,OAAe,GAAG,IAAI;IAYzC;;;;;OAKG;IACI,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,GAAG,IAAI;IAchF;;;;OAIG;IACI,aAAa,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO;IAmB3C;;;;;OAKG;IACI,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,GAAG,OAAO;CASjF;AAUD,qBAAa,cAAc;IAC1B,OAAO,CAAC,MAAM,CAAa;IAC3B,OAAO,CAAC,eAAe,CAAa;IAEpC,OAAO,CAAC,UAAU,CAAsE;IAExF,OAAO,CAAC,oBAAoB,CAAsB;IAE3C,YAAY,EAAE,MAAM,CAAK;IAEzB,gBAAgB,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,EAAE,QAAQ,GAAE,MAAU,GAAG,IAAI;IA2E9E,mBAAmB,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,GAAG,IAAI;IAyB3D,aAAa,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI;IAwCxC;;;;;OAKG;IACI,qBAAqB,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,GAAG,MAAM;CAetE;AACD,eAAe,mBAAmB,CAAC"}