ng2-events/lib/ng2-events.esm.js

Supercharge your Angular2+ event handling

var __extends = (this && this.__extends) || (function () {
    var extendStatics = function (d, b) {
        extendStatics = Object.setPrototypeOf ||
            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
        return extendStatics(d, b);
    };
    return function (d, b) {
        if (typeof b !== "function" && b !== null)
            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
        extendStatics(d, b);
        function __() { this.constructor = d; }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    };
})();
import * as i0 from '@angular/core';
import { Injectable, Inject, NgModule, Directive, Input, EventEmitter, Output, InjectionToken } from '@angular/core';
import { EVENT_MANAGER_PLUGINS } from '@angular/platform-browser';
import { DOCUMENT } from '@angular/common';
import { Subject } from 'rxjs';
import { auditTime } from 'rxjs/operators';
var MyEventManagerPlugin = /** @class */ (function () {
    function MyEventManagerPlugin(_doc) {
        this._doc = _doc;
    }
    MyEventManagerPlugin.prototype.addGlobalEventListener = function (element, eventName, handler) {
        var target;
        if (element === 'document')
            target = this._doc;
        else if (element === 'window' && typeof (window) !== undefined)
            target = window;
        if (!target) {
            throw new Error("Unsupported event target " + target + " for event " + eventName);
        }
        return this.addEventListener(target, eventName, handler);
    };
    ;
    return MyEventManagerPlugin;
}());
/**
 * Listen to events that are fired outside of the current element and its children
 *
 * Usage:
 * <div (outside.click)="close()"></div>
 *
 */
var OutsideEventPlugin = /** @class */ (function (_super) {
    __extends(OutsideEventPlugin, _super);
    function OutsideEventPlugin(doc) {
        return _super.call(this, doc) || this;
    }
    OutsideEventPlugin.prototype.supports = function (eventName) {
        return eventName.indexOf('outside.') === 0;
    };
    OutsideEventPlugin.prototype.addEventListener = function (element, eventName, handler) {
        var realEventName = eventName.slice(8);
        return this.manager.addEventListener((element.ownerDocument || document), realEventName, function (e) {
            if (element !== e.target && !element.contains(e.target)) {
                handler(e);
            }
        });
    };
    return OutsideEventPlugin;
}(MyEventManagerPlugin));
OutsideEventPlugin.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: OutsideEventPlugin, deps: [{ token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable });
OutsideEventPlugin.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: OutsideEventPlugin });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: OutsideEventPlugin, decorators: [{
            type: Injectable
        }], ctorParameters: function () {
        return [{ type: undefined, decorators: [{
                        type: Inject,
                        args: [DOCUMENT]
                    }] }];
    } });
var OutsideEventModule = /** @class */ (function () {
    function OutsideEventModule() {
    }
    return OutsideEventModule;
}());
OutsideEventModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: OutsideEventModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
OutsideEventModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: OutsideEventModule });
OutsideEventModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: OutsideEventModule, providers: [
        {
            provide: EVENT_MANAGER_PLUGINS,
            useClass: OutsideEventPlugin,
            multi: true
        }
    ] });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: OutsideEventModule, decorators: [{
            type: NgModule,
            args: [{
                    providers: [
                        {
                            provide: EVENT_MANAGER_PLUGINS,
                            useClass: OutsideEventPlugin,
                            multi: true
                        }
                    ]
                }]
        }] });
/**
 * Listen to events without triggering change detection
 *
 * Usage:
 * <button (undetected.click)="handleClick()"></button>
 *
 * ...
 *
 * export class ExampleComponent implements OnInit {
 *
 *  constructor(private zone: NgZone) {}
 *
 *  handleClick() {
 *      if(someCondition) {
 *          this.zone.run(() => {
 *              ...
 *          });
 *      }
 *  }
 * }
 *
 */
var UndetectedEventPlugin = /** @class */ (function (_super) {
    __extends(UndetectedEventPlugin, _super);
    function UndetectedEventPlugin(doc) {
        return _super.call(this, doc) || this;
    }
    UndetectedEventPlugin.prototype.supports = function (eventName) {
        return eventName.indexOf('undetected.') === 0;
    };
    UndetectedEventPlugin.prototype.addEventListener = function (element, eventName, handler) {
        var _this = this;
        var realEventName = eventName.slice(11);
        return this.manager.getZone().runOutsideAngular(function () { return _this.manager.addEventListener(element, realEventName, handler); });
    };
    return UndetectedEventPlugin;
}(MyEventManagerPlugin));
UndetectedEventPlugin.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: UndetectedEventPlugin, deps: [{ token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable });
UndetectedEventPlugin.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: UndetectedEventPlugin });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: UndetectedEventPlugin, decorators: [{
            type: Injectable
        }], ctorParameters: function () {
        return [{ type: undefined, decorators: [{
                        type: Inject,
                        args: [DOCUMENT]
                    }] }];
    } });
var UndetectedEventModule = /** @class */ (function () {
    function UndetectedEventModule() {
    }
    return UndetectedEventModule;
}());
UndetectedEventModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: UndetectedEventModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
UndetectedEventModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: UndetectedEventModule });
UndetectedEventModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: UndetectedEventModule, providers: [
        {
            provide: EVENT_MANAGER_PLUGINS,
            useClass: UndetectedEventPlugin,
            multi: true
        }
    ] });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: UndetectedEventModule, decorators: [{
            type: NgModule,
            args: [{
                    providers: [
                        {
                            provide: EVENT_MANAGER_PLUGINS,
                            useClass: UndetectedEventPlugin,
                            multi: true
                        }
                    ]
                }]
        }] });
/**
 * Register multiple event listeners
 *
 * Usage:
 * <button (multi.focus,select)="foo($event)"></button>
 *
 */
var MultiEventPlugin = /** @class */ (function (_super) {
    __extends(MultiEventPlugin, _super);
    function MultiEventPlugin(doc) {
        return _super.call(this, doc) || this;
    }
    MultiEventPlugin.prototype.supports = function (eventName) {
        return eventName.indexOf('multi.') === 0;
    };
    MultiEventPlugin.prototype.addEventListener = function (element, eventName, handler) {
        var _this = this;
        var eventNames = eventName.slice(6).split(',');
        var eventListeners = eventNames.map(function (x) { return _this.manager.addEventListener(element, x, handler); });
        return function () {
            eventListeners.forEach(function (x) { return x(); });
        };
    };
    return MultiEventPlugin;
}(MyEventManagerPlugin));
MultiEventPlugin.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: MultiEventPlugin, deps: [{ token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable });
MultiEventPlugin.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: MultiEventPlugin });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: MultiEventPlugin, decorators: [{
            type: Injectable
        }], ctorParameters: function () {
        return [{ type: undefined, decorators: [{
                        type: Inject,
                        args: [DOCUMENT]
                    }] }];
    } });
var MultiEventModule = /** @class */ (function () {
    function MultiEventModule() {
    }
    return MultiEventModule;
}());
MultiEventModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: MultiEventModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
MultiEventModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: MultiEventModule });
MultiEventModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: MultiEventModule, providers: [
        {
            provide: EVENT_MANAGER_PLUGINS,
            useClass: MultiEventPlugin,
            multi: true
        }
    ] });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: MultiEventModule, decorators: [{
            type: NgModule,
            args: [{
                    providers: [
                        {
                            provide: EVENT_MANAGER_PLUGINS,
                            useClass: MultiEventPlugin,
                            multi: true
                        }
                    ]
                }]
        }] });
/**
 * Control event listeners with an observable operator without triggering change detection
 * every time the event fires
 *
 * Usage:
 * <button (observe.throttleTime-500.click)="foo()"></button>
 *
 * The method used must be present on the Observable object
 * e.g. through an explicit import:
 * import 'rxjs/add/operator/throttleTime';
 *
 *
 * To get finer-grained control and the possibility to add multiple observable operators
 * use the ObserveEventDirective.
 */
var ObserveEventPlugin = /** @class */ (function (_super) {
    __extends(ObserveEventPlugin, _super);
    function ObserveEventPlugin(doc) {
        return _super.call(this, doc) || this;
    }
    ObserveEventPlugin.prototype.supports = function (eventName) {
        return eventName.indexOf('observe.') === 0;
    };
    ObserveEventPlugin.prototype.addEventListener = function (element, eventName, handler) {
        var _this = this;
        return this.manager.getZone().runOutsideAngular(function () {
            var eventRest = eventName.slice(8).split('.');
            var fnParts = eventRest[0].split('-');
            var fnName = fnParts[0];
            var fnArg = (fnParts.length > 1) ? +fnParts[1] : undefined;
            var delegateEvent = eventRest.slice(1).join('.');
            var subject = new Subject();
            var observable = subject.asObservable();
            if (observable[fnName]) {
                observable = (fnArg !== undefined)
                    ? observable[fnName](fnArg)
                    : observable[fnName]();
            }
            else {
                console.error('The function "' + fnName + '" does not exist on Observable!');
                return function () { };
            }
            observable.subscribe(function (x) { return _this.manager.getZone().run(function () { return handler(x); }); });
            var listener = _this.manager.addEventListener(element, delegateEvent, function ($event) {
                subject.next($event);
            });
            return function () {
                listener();
                subject.complete();
            };
        });
    };
    return ObserveEventPlugin;
}(MyEventManagerPlugin));
ObserveEventPlugin.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: ObserveEventPlugin, deps: [{ token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable });
ObserveEventPlugin.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: ObserveEventPlugin });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: ObserveEventPlugin, decorators: [{
            type: Injectable
        }], ctorParameters: function () {
        return [{ type: undefined, decorators: [{
                        type: Inject,
                        args: [DOCUMENT]
                    }] }];
    } });
var ObserveEventModule = /** @class */ (function () {
    function ObserveEventModule() {
    }
    return ObserveEventModule;
}());
ObserveEventModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: ObserveEventModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
ObserveEventModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: ObserveEventModule });
ObserveEventModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: ObserveEventModule, providers: [
        {
            provide: EVENT_MANAGER_PLUGINS,
            useClass: ObserveEventPlugin,
            multi: true
        }
    ] });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: ObserveEventModule, decorators: [{
            type: NgModule,
            args: [{
                    providers: [
                        {
                            provide: EVENT_MANAGER_PLUGINS,
                            useClass: ObserveEventPlugin,
                            multi: true
                        }
                    ]
                }]
        }] });
/**
 * Pass events to a given observable subject without triggering change detection
 *
 * Usage:
 * <button [ev-observe]="subject" ev-events="click"></button>
 *
 * ...
 *
 * export class ExampleComponent implements OnInit {
 *  public subject = new Subject();
 *
 *  constructor(private zone: NgZone) {}
 *
 *  ngOnInit() {
 *      this.subject
 *          .throttleTime(300)
 *          .filter(someCondition)
 *          ...
 *          .subscribe($event => this.zone.run(() => this.handleEvent($event)));
 *  }
 * }
 *
 * Notes:
 * The [ev-events] property can be either a string or an array of strings to handle multiple events
 *
 */
var ObserveEventDirective = /** @class */ (function () {
    function ObserveEventDirective(elm, renderer, zone) {
        this.elm = elm;
        this.renderer = renderer;
        this.zone = zone;
        this.listeners = [];
    }
    Object.defineProperty(ObserveEventDirective.prototype, "events", {
        set: function (e) {
            var _this = this;
            this.unregisterAll();
            var events = (typeof (e) === 'string')
                ? [e]
                : e;
            this.zone.runOutsideAngular(function () {
                _this.listeners = events.map(function (x) { return _this.addListener(x); });
            });
        },
        enumerable: false,
        configurable: true
    });
    ObserveEventDirective.prototype.ngOnDestroy = function () {
        this.unregisterAll();
    };
    ObserveEventDirective.prototype.unregisterAll = function () {
        this.listeners.forEach(function (x) { return x(); });
        this.listeners = [];
    };
    ObserveEventDirective.prototype.addListener = function (eventName) {
        var _this = this;
        var colon = eventName.indexOf(':');
        var handler = function ($event) { return _this.fireEvent($event); };
        if (colon === -1) {
            return this.renderer.listen(this.elm.nativeElement, eventName, handler);
        }
        else {
            var scope = eventName.slice(0, colon);
            var realEventName = eventName.slice(colon + 1);
            return this.renderer.listen(scope, realEventName, handler);
        }
    };
    ObserveEventDirective.prototype.fireEvent = function ($event) {
        if (!this.observe)
            return;
        this.observe.next($event);
    };
    return ObserveEventDirective;
}());
ObserveEventDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: ObserveEventDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Directive });
ObserveEventDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.0.2", type: ObserveEventDirective, selector: "[ev-observe]", inputs: { observe: ["ev-observe", "observe"], events: ["ev-events", "events"] }, ngImport: i0 });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: ObserveEventDirective, decorators: [{
            type: Directive,
            args: [{
                    selector: '[ev-observe]'
                }]
        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i0.NgZone }]; }, propDecorators: { observe: [{
                type: Input,
                args: ['ev-observe']
            }], events: [{
                type: Input,
                args: ['ev-events']
            }] } });
var ObserveEventDirectiveModule = /** @class */ (function () {
    function ObserveEventDirectiveModule() {
    }
    return ObserveEventDirectiveModule;
}());
ObserveEventDirectiveModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: ObserveEventDirectiveModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
ObserveEventDirectiveModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: ObserveEventDirectiveModule, declarations: [ObserveEventDirective], exports: [ObserveEventDirective] });
ObserveEventDirectiveModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: ObserveEventDirectiveModule });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: ObserveEventDirectiveModule, decorators: [{
            type: NgModule,
            args: [{
                    declarations: [
                        ObserveEventDirective
                    ],
                    exports: [
                        ObserveEventDirective
                    ]
                }]
        }] });
function getNativeEventNames(eventName) {
    var supportsPointerEvents = typeof (window) !== 'undefined' && 'PointerEvent' in window;
    switch (eventName) {
        case 'up':
            return supportsPointerEvents
                ? ['pointerup']
                : ['mouseup', 'touchend'];
        case 'down':
            return supportsPointerEvents
                ? ['pointerdown']
                : ['mousedown', 'touchstart'];
        case 'move':
            return supportsPointerEvents
                ? ['pointermove']
                : ['mousemove', 'touchmove'];
        default:
            return [];
    }
}
/**
 * Quick-firing 'up' and 'down' events that work cross-browser for mouse and touch events
 *
 * Usage:
 * <button (down)="activate()" (up)="deactivate()"></button>
 *
 */
var TouchEventPlugin = /** @class */ (function (_super) {
    __extends(TouchEventPlugin, _super);
    function TouchEventPlugin(doc) {
        return _super.call(this, doc) || this;
    }
    TouchEventPlugin.prototype.supports = function (eventName) {
        return eventName === 'down' || eventName === 'up' || eventName === 'move';
    };
    TouchEventPlugin.prototype.addEventListener = function (element, eventName, handler) {
        var _this = this;
        var eventListeners = getNativeEventNames(eventName).map(function (x) { return _this.manager.addEventListener(element, x, function (e) {
            // prevent default so only one of the event listeners is fired
            e.preventDefault();
            handler(e);
        }); });
        return function () {
            eventListeners.forEach(function (x) { return x(); });
        };
    };
    return TouchEventPlugin;
}(MyEventManagerPlugin));
TouchEventPlugin.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: TouchEventPlugin, deps: [{ token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable });
TouchEventPlugin.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: TouchEventPlugin });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: TouchEventPlugin, decorators: [{
            type: Injectable
        }], ctorParameters: function () {
        return [{ type: undefined, decorators: [{
                        type: Inject,
                        args: [DOCUMENT]
                    }] }];
    } });
var TouchEventModule = /** @class */ (function () {
    function TouchEventModule() {
    }
    return TouchEventModule;
}());
TouchEventModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: TouchEventModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
TouchEventModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: TouchEventModule });
TouchEventModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: TouchEventModule, providers: [
        {
            provide: EVENT_MANAGER_PLUGINS,
            useClass: TouchEventPlugin,
            multi: true
        }
    ] });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: TouchEventModule, decorators: [{
            type: NgModule,
            args: [{
                    providers: [
                        {
                            provide: EVENT_MANAGER_PLUGINS,
                            useClass: TouchEventPlugin,
                            multi: true
                        }
                    ]
                }]
        }] });
/**
 * Automatically unregister an event listener after the event fired once
 *
 * Usage:
 * <button (once.click)="foo()">...</button>
 *
 */
var OnceEventPlugin = /** @class */ (function (_super) {
    __extends(OnceEventPlugin, _super);
    function OnceEventPlugin(doc) {
        return _super.call(this, doc) || this;
    }
    OnceEventPlugin.prototype.supports = function (eventName) {
        return eventName.indexOf('once.') === 0;
    };
    OnceEventPlugin.prototype.addEventListener = function (element, eventName, handler) {
        var realEventName = eventName.slice(5);
        var active = true;
        var eventListener = this.manager.addEventListener(element, realEventName, function ($event) {
            eventListener();
            active = false;
            handler($event);
        });
        return function () {
            if (active)
                eventListener();
        };
    };
    return OnceEventPlugin;
}(MyEventManagerPlugin));
OnceEventPlugin.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: OnceEventPlugin, deps: [{ token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable });
OnceEventPlugin.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: OnceEventPlugin });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: OnceEventPlugin, decorators: [{
            type: Injectable
        }], ctorParameters: function () {
        return [{ type: undefined, decorators: [{
                        type: Inject,
                        args: [DOCUMENT]
                    }] }];
    } });
var OnceEventModule = /** @class */ (function () {
    function OnceEventModule() {
    }
    return OnceEventModule;
}());
OnceEventModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: OnceEventModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
OnceEventModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: OnceEventModule });
OnceEventModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: OnceEventModule, providers: [
        {
            provide: EVENT_MANAGER_PLUGINS,
            useClass: OnceEventPlugin,
            multi: true
        }
    ] });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: OnceEventModule, decorators: [{
            type: NgModule,
            args: [{
                    providers: [
                        {
                            provide: EVENT_MANAGER_PLUGINS,
                            useClass: OnceEventPlugin,
                            multi: true
                        }
                    ]
                }]
        }] });
/**
 * Conditionally apply event listeners to an element
 *
 * Usage:
 * <button [ev-condition]="isActive()"
 *      ev-events="click"
 *      (ev-fire)="handleClick($event)">...</button>
 *
 * Notes:
 * The [ev-events] property can be either a string or an array of strings to handle multiple events
 */
var ConditionEventDirective = /** @class */ (function () {
    function ConditionEventDirective(elm, renderer) {
        this.elm = elm;
        this.renderer = renderer;
        this.fire = new EventEmitter();
        this.listeners = [];
    }
    ConditionEventDirective.prototype.ngOnChanges = function (changes) {
        var _this = this;
        this.unregisterAll();
        if (!this.condition || !this.events)
            return;
        var events = (typeof (this.events) === 'string')
            ? [this.events]
            : this.events;
        this.listeners = events.map(function (x) { return _this.addListener(x); });
    };
    ConditionEventDirective.prototype.ngOnDestroy = function () {
        this.unregisterAll();
    };
    ConditionEventDirective.prototype.unregisterAll = function () {
        this.listeners.forEach(function (x) { return x(); });
        this.listeners = [];
    };
    ConditionEventDirective.prototype.addListener = function (eventName) {
        var _this = this;
        var colon = eventName.indexOf(':');
        var handler = function ($event) { return _this.fire.next($event); };
        if (colon === -1) {
            return this.renderer.listen(this.elm.nativeElement, eventName, handler);
        }
        else {
            var scope = eventName.slice(0, colon);
            var realEventName = eventName.slice(colon + 1);
            return this.renderer.listen(scope, realEventName, handler);
        }
    };
    return ConditionEventDirective;
}());
ConditionEventDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: ConditionEventDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive });
ConditionEventDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.0.2", type: ConditionEventDirective, selector: "[ev-condition]", inputs: { condition: ["ev-condition", "condition"], events: ["ev-events", "events"] }, outputs: { fire: "ev-fire" }, usesOnChanges: true, ngImport: i0 });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: ConditionEventDirective, decorators: [{
            type: Directive,
            args: [{
                    selector: '[ev-condition]'
                }]
        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.Renderer2 }]; }, propDecorators: { condition: [{
                type: Input,
                args: ['ev-condition']
            }], events: [{
                type: Input,
                args: ['ev-events']
            }], fire: [{
                type: Output,
                args: ['ev-fire']
            }] } });
var ConditionEventDirectiveModule = /** @class */ (function () {
    function ConditionEventDirectiveModule() {
    }
    return ConditionEventDirectiveModule;
}());
ConditionEventDirectiveModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: ConditionEventDirectiveModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
ConditionEventDirectiveModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: ConditionEventDirectiveModule, declarations: [ConditionEventDirective], exports: [ConditionEventDirective] });
ConditionEventDirectiveModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: ConditionEventDirectiveModule });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: ConditionEventDirectiveModule, decorators: [{
            type: NgModule,
            args: [{
                    declarations: [
                        ConditionEventDirective
                    ],
                    exports: [
                        ConditionEventDirective
                    ]
                }]
        }] });
var SCROLL_EVENT_TIME = new InjectionToken('ScrollEventTime');
/**
 * Detects when an element is scrolled into or out of the viewport
 *
 * Usage:
 * <div (scroll-in)="activate()" (scroll-out)="deactivate()">...</div>
 *
 * The matching handler of the initial status is called upon attaching
 * to notify the element of its current status. $event is true for the
 * initial call, false otherwise
 *
 */
var ScrollEventPlugin = /** @class */ (function (_super) {
    __extends(ScrollEventPlugin, _super);
    function ScrollEventPlugin(doc, time) {
        var _this = _super.call(this, doc) || this;
        _this.listeners = [];
        _this.globalListener = undefined;
        _this.subject = new Subject();
        _this.subject
            .pipe(auditTime(time))
            .subscribe(function () {
            _this.listeners.forEach(function (x) { return x(); });
        });
        return _this;
    }
    ScrollEventPlugin.prototype.supports = function (eventName) {
        return eventName === 'scroll-in' || eventName === 'scroll-out';
    };
    ScrollEventPlugin.prototype.addEventListener = function (element, eventName, handler) {
        var _this = this;
        var isScrollIn = (eventName === 'scroll-in');
        var status = undefined;
        setTimeout(function () {
            status = _this.getStatus(element);
            if ((isScrollIn && status) || (!isScrollIn && !status)) {
                handler(true);
            }
        }, 0);
        var listener = function () {
            var newStatus = _this.getStatus(element);
            if (status === newStatus)
                return;
            if ((isScrollIn && newStatus) || (!isScrollIn && !newStatus)) {
                _this.manager.getZone().run(function () { return handler(false); });
            }
            status = newStatus;
        };
        this.listeners.push(listener);
        this.updateGlobalListener();
        return function () {
            var index = _this.listeners.indexOf(listener);
            if (index === -1)
                return;
            _this.listeners.splice(index, 1);
            _this.updateGlobalListener();
        };
    };
    ScrollEventPlugin.prototype.updateGlobalListener = function () {
        var _this = this;
        if (this.listeners.length && this.globalListener === undefined) {
            this.manager.getZone().runOutsideAngular(function () {
                var handler = function () {
                    _this.subject.next();
                };
                var listeners = ['scroll', 'resize', 'orientationchange']
                    .map(function (x) { return _this.manager.addEventListener(_this._doc.defaultView || window, x, handler); });
                _this.globalListener = function () {
                    listeners.forEach(function (x) { return x(); });
                };
            });
        }
        else if (!this.listeners.length && this.globalListener !== undefined) {
            this.globalListener();
            this.globalListener = undefined;
        }
    };
    ScrollEventPlugin.prototype.getStatus = function (element) {
        var rect = element.getBoundingClientRect();
        return (rect.bottom >= 0 && rect.top <= window.innerHeight);
    };
    return ScrollEventPlugin;
}(MyEventManagerPlugin));
ScrollEventPlugin.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: ScrollEventPlugin, deps: [{ token: DOCUMENT }, { token: SCROLL_EVENT_TIME }], target: i0.ɵɵFactoryTarget.Injectable });
ScrollEventPlugin.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: ScrollEventPlugin });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: ScrollEventPlugin, decorators: [{
            type: Injectable
        }], ctorParameters: function () {
        return [{ type: undefined, decorators: [{
                        type: Inject,
                        args: [DOCUMENT]
                    }] }, { type: undefined, decorators: [{
                        type: Inject,
                        args: [SCROLL_EVENT_TIME]
                    }] }];
    } });
var ScrollEventModule = /** @class */ (function () {
    function ScrollEventModule() {
    }
    return ScrollEventModule;
}());
ScrollEventModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: ScrollEventModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
ScrollEventModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: ScrollEventModule });
ScrollEventModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: ScrollEventModule, providers: [
        {
            provide: EVENT_MANAGER_PLUGINS,
            useClass: ScrollEventPlugin,
            multi: true
        },
        {
            provide: SCROLL_EVENT_TIME,
            useValue: 200
        }
    ] });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: ScrollEventModule, decorators: [{
            type: NgModule,
            args: [{
                    providers: [
                        {
                            provide: EVENT_MANAGER_PLUGINS,
                            useClass: ScrollEventPlugin,
                            multi: true
                        },
                        {
                            provide: SCROLL_EVENT_TIME,
                            useValue: 200
                        }
                    ]
                }]
        }] });
var Ng2EventsModule = /** @class */ (function () {
    function Ng2EventsModule() {
    }
    return Ng2EventsModule;
}());
Ng2EventsModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: Ng2EventsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
Ng2EventsModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: Ng2EventsModule, imports: [OutsideEventModule,
        TouchEventModule,
        MultiEventModule,
        UndetectedEventModule,
        ObserveEventModule,
        ObserveEventDirectiveModule,
        OnceEventModule,
        ConditionEventDirectiveModule,
        ScrollEventModule], exports: [OutsideEventModule,
        TouchEventModule,
        MultiEventModule,
        UndetectedEventModule,
        ObserveEventModule,
        ObserveEventDirectiveModule,
        OnceEventModule,
        ConditionEventDirectiveModule,
        ScrollEventModule] });
Ng2EventsModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: Ng2EventsModule, imports: [[
            OutsideEventModule,
            TouchEventModule,
            MultiEventModule,
            UndetectedEventModule,
            ObserveEventModule,
            ObserveEventDirectiveModule,
            OnceEventModule,
            ConditionEventDirectiveModule,
            ScrollEventModule
        ], OutsideEventModule,
        TouchEventModule,
        MultiEventModule,
        UndetectedEventModule,
        ObserveEventModule,
        ObserveEventDirectiveModule,
        OnceEventModule,
        ConditionEventDirectiveModule,
        ScrollEventModule] });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.0.2", ngImport: i0, type: Ng2EventsModule, decorators: [{
            type: NgModule,
            args: [{
                    imports: [
                        OutsideEventModule,
                        TouchEventModule,
                        MultiEventModule,
                        UndetectedEventModule,
                        ObserveEventModule,
                        ObserveEventDirectiveModule,
                        OnceEventModule,
                        ConditionEventDirectiveModule,
                        ScrollEventModule
                    ],
                    exports: [
                        OutsideEventModule,
                        TouchEventModule,
                        MultiEventModule,
                        UndetectedEventModule,
                        ObserveEventModule,
                        ObserveEventDirectiveModule,
                        OnceEventModule,
                        ConditionEventDirectiveModule,
                        ScrollEventModule
                    ]
                }]
        }] });
export default Ng2EventsModule;
export { ConditionEventDirective, ConditionEventDirectiveModule, MultiEventModule, Ng2EventsModule, ObserveEventDirective, ObserveEventDirectiveModule, ObserveEventModule, OnceEventModule, OutsideEventModule, SCROLL_EVENT_TIME, ScrollEventModule, TouchEventModule, UndetectedEventModule };