@ngx-plus/ngx-alerts/bundles/ngx-plus-ngx-alerts.umd.js

(function (global, factory) {
	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core'), require('lodash'), require('sweetalert2'), require('ng-snotify'), require('@angular/common')) :
	typeof define === 'function' && define.amd ? define(['exports', '@angular/core', 'lodash', 'sweetalert2', 'ng-snotify', '@angular/common'], factory) :
	(factory((global['ngx-plus'] = global['ngx-plus'] || {}, global['ngx-plus']['ngx-alerts'] = {}),global.ng.core,global.lodash,global.swal,global.ngSnotify,global.ng.common));
}(this, (function (exports,core,lodash,swal,ngSnotify,common) { 'use strict';

swal = swal && swal.hasOwnProperty('default') ? swal['default'] : swal;

/*! *****************************************************************************
Copyright (c) Microsoft Corporation. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use
this file except in compliance with the License. You may obtain a copy of the
License at http://www.apache.org/licenses/LICENSE-2.0
THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
MERCHANTABLITY OR NON-INFRINGEMENT.
See the Apache Version 2.0 License for specific language governing permissions
and limitations under the License.
***************************************************************************** */
/* global Reflect, Promise */










function __read(o, n) {
    var m = typeof Symbol === "function" && o[Symbol.iterator];
    if (!m) return o;
    var i = m.call(o), r, ar = [], e;
    try {
        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
    }
    catch (error) { e = { error: error }; }
    finally {
        try {
            if (r && !r.done && (m = i["return"])) m.call(i);
        }
        finally { if (e) throw e.error; }
    }
    return ar;
}
function __spread() {
    for (var ar = [], i = 0; i < arguments.length; i++)
        ar = ar.concat(__read(arguments[i]));
    return ar;
}

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */
var NgxAlertTemplatesComponent = /** @class */ (function () {
    function NgxAlertTemplatesComponent() {
    }
    return NgxAlertTemplatesComponent;
}());
NgxAlertTemplatesComponent.decorators = [
    { type: core.Component, args: [{
                selector: 'ngx-alert-templates',
                template: "\n    <ng-snotify></ng-snotify>\n  ",
            },] },
];
/** @nocollapse */
NgxAlertTemplatesComponent.ctorParameters = function () { return []; };
/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */
var NgxAlertInterfaces = /** @class */ (function () {
    function NgxAlertInterfaces() {
    }
    return NgxAlertInterfaces;
}());
/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */
/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */
/**
 * @record
 */
var NgxAlertsService = /** @class */ (function () {
    /**
     * @param {?} notifyService
     */
    function NgxAlertsService(notifyService) {
        this.notifyService = notifyService;
    }
    /**
     * @param {?} type
     * @param {?} config
     * @return {?}
     */
    NgxAlertsService.prototype.defaultNotify = function (type, config) {
        return this.notifyService[type](config.body, config.title || null, {
            timeout: config.timeout || 3000,
            showProgressBar: config.showProgressBar || true,
            closeOnClick: config.closeOnClick || true,
            pauseOnHover: config.pauseOnHover || true,
            buttons: config.buttons,
            placeholder: config.placeholder,
            html: config.html || null,
            position: config.position || 'rightBottom',
        });
    };
    /**
     * @param {?} config
     * @return {?}
     */
    NgxAlertsService.prototype.notifySimple = function (config) {
        this.defaultNotify('simple', config);
    };
    /**
     * @param {?} config
     * @return {?}
     */
    NgxAlertsService.prototype.notifySuccess = function (config) {
        this.defaultNotify('success', config);
    };
    /**
     * @param {?} config
     * @return {?}
     */
    NgxAlertsService.prototype.notifyInfo = function (config) {
        this.defaultNotify('info', config);
    };
    /**
     * @param {?} config
     * @return {?}
     */
    NgxAlertsService.prototype.notifyWarning = function (config) {
        this.defaultNotify('warning', config);
    };
    /**
     * @param {?} config
     * @return {?}
     */
    NgxAlertsService.prototype.notifyError = function (config) {
        this.defaultNotify('error', config);
    };
    /**
     * @param {?} config
     * @return {?}
     */
    NgxAlertsService.prototype.notifyPrompt = function (config) {
        this.defaultNotify('prompt', config);
    };
    /**
     * @param {?} config
     * @return {?}
     */
    NgxAlertsService.prototype.notifyConfirm = function (config) {
        this.defaultNotify('confirm', config);
    };
    /**
     * @param {?} toastId
     * @return {?}
     */
    NgxAlertsService.prototype.notifyDismiss = function (toastId) {
        this.notifyService.remove(toastId);
    };
    /**
     * @param {?=} options
     * @param {?=} successCb
     * @param {?=} closeCb
     * @return {?}
     */
    NgxAlertsService.prototype.alert = function (options, successCb, closeCb) {
        if (options === void 0) { options = {}; }
        if (successCb === void 0) { successCb = lodash.noop; }
        if (closeCb === void 0) { closeCb = lodash.noop; }
        var /** @type {?} */ defaultOptions = {
            type: options.type || null,
            title: options.title || null,
            text: options.text || null,
            buttonsStyling: options.buttonsStyling || false,
            confirmButtonClass: options.confirmButtonClass || 'btn btn-lg btn-secondary',
            animation: options.animation || true,
            customClass: options.customClass || '',
        };
        if (closeCb !== lodash.noop) {
            defaultOptions.showCancelButton = options.showCancelButton || true;
            defaultOptions.cancelButtonClass = options.cancelButtonClass || 'btn btn-lg btn-secondary';
        }
        return swal(lodash.assign(defaultOptions, options)).then(function (res) { return successCb(res); }, function (dismiss) { return closeCb(dismiss); });
    };
    /**
     * @param {?=} options
     * @param {?=} successCb
     * @param {?=} closeCb
     * @return {?}
     */
    NgxAlertsService.prototype.alertSuccess = function (options, successCb, closeCb) {
        if (options === void 0) { options = {}; }
        if (successCb === void 0) { successCb = lodash.noop; }
        if (closeCb === void 0) { closeCb = lodash.noop; }
        var /** @type {?} */ defaultOptions = {
            type: 'success',
            confirmButtonClass: 'btn btn-lg btn-success',
        };
        return this.alert(lodash.assign(defaultOptions, options), successCb, closeCb);
    };
    /**
     * @param {?=} options
     * @param {?=} successCb
     * @param {?=} closeCb
     * @return {?}
     */
    NgxAlertsService.prototype.alertWarning = function (options, successCb, closeCb) {
        if (options === void 0) { options = {}; }
        if (successCb === void 0) { successCb = lodash.noop; }
        if (closeCb === void 0) { closeCb = lodash.noop; }
        var /** @type {?} */ defaultOptions = {
            type: 'warning',
            confirmButtonClass: 'btn btn-lg btn-warning',
        };
        return this.alert(lodash.assign(defaultOptions, options), successCb, closeCb);
    };
    /**
     * @param {?=} options
     * @param {?=} successCb
     * @param {?=} closeCb
     * @return {?}
     */
    NgxAlertsService.prototype.alertError = function (options, successCb, closeCb) {
        if (options === void 0) { options = {}; }
        if (successCb === void 0) { successCb = lodash.noop; }
        if (closeCb === void 0) { closeCb = lodash.noop; }
        var /** @type {?} */ defaultOptions = {
            type: 'error',
            confirmButtonClass: 'btn btn-lg btn-danger',
        };
        return this.alert(lodash.assign(defaultOptions, options), successCb, closeCb);
    };
    /**
     * @param {?=} options
     * @param {?=} successCb
     * @param {?=} closeCb
     * @return {?}
     */
    NgxAlertsService.prototype.alertInfo = function (options, successCb, closeCb) {
        if (options === void 0) { options = {}; }
        if (successCb === void 0) { successCb = lodash.noop; }
        if (closeCb === void 0) { closeCb = lodash.noop; }
        var /** @type {?} */ defaultOptions = {
            type: 'info',
            confirmButtonClass: 'btn btn-lg btn-info',
        };
        return this.alert(lodash.assign(defaultOptions, options), successCb, closeCb);
    };
    /**
     * @param {?=} options
     * @param {?=} successCb
     * @param {?=} closeCb
     * @return {?}
     */
    NgxAlertsService.prototype.alertQuestion = function (options, successCb, closeCb) {
        if (options === void 0) { options = {}; }
        if (successCb === void 0) { successCb = lodash.noop; }
        if (closeCb === void 0) { closeCb = lodash.noop; }
        var /** @type {?} */ defaultOptions = {
            type: 'question',
            confirmButtonClass: 'btn btn-lg btn-primary',
        };
        return this.alert(lodash.assign(defaultOptions, options), successCb, closeCb);
    };
    return NgxAlertsService;
}());
NgxAlertsService.decorators = [
    { type: core.Injectable },
];
/** @nocollapse */
NgxAlertsService.ctorParameters = function () { return [
    { type: ngSnotify.SnotifyService, },
]; };
/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */
/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */
var components = [NgxAlertTemplatesComponent];
var NgxAlertsModule = /** @class */ (function () {
    function NgxAlertsModule() {
    }
    /**
     * @return {?}
     */
    NgxAlertsModule.forRoot = function () {
        return {
            ngModule: NgxAlertsModule,
            providers: [{ provide: 'SnotifyToastConfig', useValue: ngSnotify.ToastDefaults }, ngSnotify.SnotifyService, NgxAlertsService],
        };
    };
    return NgxAlertsModule;
}());
NgxAlertsModule.decorators = [
    { type: core.NgModule, args: [{
                imports: [common.CommonModule, ngSnotify.SnotifyModule],
                declarations: __spread(components),
                exports: __spread(components),
            },] },
];
/** @nocollapse */
NgxAlertsModule.ctorParameters = function () { return []; };

exports.NgxAlertTemplatesComponent = NgxAlertTemplatesComponent;
exports.NgxAlertInterfaces = NgxAlertInterfaces;
exports.NgxAlertsService = NgxAlertsService;
exports.NgxAlertsModule = NgxAlertsModule;

Object.defineProperty(exports, '__esModule', { value: true });

})));
//# sourceMappingURL=ngx-plus-ngx-alerts.umd.js.map