@angular/fire/fesm2015/angular-fire-messaging.js

The official library for Firebase and Angular

import { Injectable, Inject, Optional, PLATFORM_ID, NgZone, ɵɵdefineInjectable, ɵɵinject, NgModule } from '@angular/core';
import { of, EMPTY, throwError, Observable, concat } from 'rxjs';
import { observeOn, switchMap, map, defaultIfEmpty, catchError, mergeMap } from 'rxjs/operators';
import { ɵAngularFireSchedulers, ɵfirebaseAppFactory, ɵlazySDKProxy, FIREBASE_OPTIONS, FIREBASE_APP_NAME } from '@angular/fire';
import { isPlatformServer } from '@angular/common';

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
// WARNING: interface has both a type and a value, skipping emit
class AngularFireMessaging {
    /**
     * @param {?} options
     * @param {?} nameOrConfig
     * @param {?} platformId
     * @param {?} zone
     */
    constructor(options, nameOrConfig, 
    // tslint:disable-next-line:ban-types
    platformId, zone) {
        /** @type {?} */
        const schedulers = new ɵAngularFireSchedulers(zone);
        /** @type {?} */
        const messaging = of(undefined).pipe(observeOn(schedulers.outsideAngular), switchMap((/**
         * @return {?}
         */
        () => isPlatformServer(platformId) ? EMPTY : import('firebase/messaging'))), map((/**
         * @return {?}
         */
        () => ɵfirebaseAppFactory(options, zone, nameOrConfig))), map((/**
         * @param {?} app
         * @return {?}
         */
        app => app.messaging())));
        if (!isPlatformServer(platformId)) {
            this.requestPermission = messaging.pipe(observeOn(schedulers.outsideAngular), 
            // tslint:disable-next-line
            switchMap((/**
             * @param {?} messaging
             * @return {?}
             */
            messaging => messaging.requestPermission())));
        }
        else {
            this.requestPermission = throwError('Not available on server platform.');
        }
        this.getToken = messaging.pipe(observeOn(schedulers.outsideAngular), switchMap((/**
         * @param {?} messaging
         * @return {?}
         */
        messaging => messaging.getToken())), defaultIfEmpty(null));
        /** @type {?} */
        const tokenChanges = messaging.pipe(observeOn(schedulers.outsideAngular), switchMap((/**
         * @param {?} messaging
         * @return {?}
         */
        messaging => new Observable(messaging.onTokenRefresh.bind(messaging)).pipe(switchMap((/**
         * @return {?}
         */
        () => messaging.getToken()))))));
        this.tokenChanges = concat(messaging.pipe(observeOn(schedulers.outsideAngular), switchMap((/**
         * @param {?} messaging
         * @return {?}
         */
        messaging => messaging.getToken()))), tokenChanges);
        this.messages = messaging.pipe(observeOn(schedulers.outsideAngular), switchMap((/**
         * @param {?} messaging
         * @return {?}
         */
        messaging => new Observable(messaging.onMessage.bind(messaging)))));
        this.requestToken = of(undefined).pipe(switchMap((/**
         * @return {?}
         */
        () => this.requestPermission)), catchError((/**
         * @return {?}
         */
        () => of(null))), mergeMap((/**
         * @return {?}
         */
        () => this.tokenChanges)));
        this.deleteToken = (/**
         * @param {?} token
         * @return {?}
         */
        (token) => messaging.pipe(observeOn(schedulers.outsideAngular), switchMap((/**
         * @param {?} messaging
         * @return {?}
         */
        messaging => messaging.deleteToken(token))), defaultIfEmpty(false)));
        return ɵlazySDKProxy(this, messaging, zone);
    }
}
AngularFireMessaging.decorators = [
    { type: Injectable, args: [{
                providedIn: 'any'
            },] }
];
/** @nocollapse */
AngularFireMessaging.ctorParameters = () => [
    { type: undefined, decorators: [{ type: Inject, args: [FIREBASE_OPTIONS,] }] },
    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [FIREBASE_APP_NAME,] }] },
    { type: Object, decorators: [{ type: Inject, args: [PLATFORM_ID,] }] },
    { type: NgZone }
];
/** @nocollapse */ AngularFireMessaging.ɵprov = ɵɵdefineInjectable({ factory: function AngularFireMessaging_Factory() { return new AngularFireMessaging(ɵɵinject(FIREBASE_OPTIONS), ɵɵinject(FIREBASE_APP_NAME, 8), ɵɵinject(PLATFORM_ID), ɵɵinject(NgZone)); }, token: AngularFireMessaging, providedIn: "any" });
if (false) {
    /** @type {?} */
    AngularFireMessaging.prototype.requestPermission;
    /** @type {?} */
    AngularFireMessaging.prototype.getToken;
    /** @type {?} */
    AngularFireMessaging.prototype.tokenChanges;
    /** @type {?} */
    AngularFireMessaging.prototype.messages;
    /** @type {?} */
    AngularFireMessaging.prototype.requestToken;
    /** @type {?} */
    AngularFireMessaging.prototype.deleteToken;
}

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class AngularFireMessagingModule {
}
AngularFireMessagingModule.decorators = [
    { type: NgModule, args: [{
                providers: [AngularFireMessaging]
            },] }
];

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */

export { AngularFireMessaging, AngularFireMessagingModule };
//# sourceMappingURL=angular-fire-messaging.js.map