@soushians/authentication/bundles/soushians-authentication.umd.js

(function (global, factory) {
    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@soushians/shared'), require('@soushians/config'), require('@angular/material/snack-bar'), require('@angular/common'), require('@angular/flex-layout'), require('@angular/platform-browser/animations'), require('@angular/forms'), require('@soushians/form'), require('rxjs/add/operator/do'), require('@angular/common/http'), require('@angular/router'), require('rxjs'), require('@angular/material'), require('@ngrx/effects'), require('rxjs/operators'), require('@angular/core'), require('@ngrx/store')) :
    typeof define === 'function' && define.amd ? define('@soushians/authentication', ['exports', '@soushians/shared', '@soushians/config', '@angular/material/snack-bar', '@angular/common', '@angular/flex-layout', '@angular/platform-browser/animations', '@angular/forms', '@soushians/form', 'rxjs/add/operator/do', '@angular/common/http', '@angular/router', 'rxjs', '@angular/material', '@ngrx/effects', 'rxjs/operators', '@angular/core', '@ngrx/store'], factory) :
    (factory((global.soushians = global.soushians || {}, global.soushians.authentication = {}),global.shared,global.config,global.ng.material['snack-bar'],global.ng.common,global.ng['flex-layout'],global.ng.platformBrowser.animations,global.ng.forms,global.form,global.rxjs['add/operator/do'],global.ng.common.http,global.ng.router,global.rxjs,global.ng.material,global.effects,global.rxjs.operators,global.ng.core,global.i2));
}(this, (function (exports,shared,config,i4,common,flexLayout,animations,forms,form,_do,i1,router,rxjs,material,effects,operators,i0,i2) { 'use strict';

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    var UserModel = /** @class */ (function () {
        function UserModel(params) {
            var _this = this;
            // IdentificationNo: string;
            // IdentifierType: string;
            // RegisterDate: string;
            // UserType: string;
            this.Roles = [];
            params &&
                Object.keys(params).forEach(function (key) {
                    if (key in params)
                        (( /** @type {?} */(_this)))[key] = params[key];
                });
        }
        return UserModel;
    }());

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    /** @enum {string} */
    var SignInActionTypes = {
        WHO_AM_I: "[AUTHENTICATION] who am i",
        SIGNUP: "[AUTHENTICATION][SIGNUP] start",
        SIGNUP_SUCCEED: "[AUTHENTICATION][SIGNUP] Success",
        SIGNUP_FAILURE: "[AUTHENTICATION][SIGNUP] Failure",
        SIGNIN: "[AUTHENTICATION] Signin",
        DO_SIGNOUT: "[AUTHENTICATION] Do Signout",
        SIGNOUT: "[AUTHENTICATION] Signout",
        SIGNIN_SUCCEED: "[AUTHENTICATION][Signin] Success",
        SIGNIN_FAILURE: "[AUTHENTICATION][Signin] Failure",
        SIGNIN_REDIRECT: "[AUTHENTICATION][Signin] Redirect",
        SIGNIN_REQUIRED: "[AUTHENTICATION][Signin] Required",
    };
    var WhoAmIAction = /** @class */ (function () {
        function WhoAmIAction() {
            this.type = SignInActionTypes.WHO_AM_I;
        }
        return WhoAmIAction;
    }());
    /**
     * 	sign up
     */
    var /**
     * 	sign up
     */ Signup = /** @class */ (function () {
        function Signup(payload) {
            this.payload = payload;
            this.type = SignInActionTypes.SIGNUP;
        }
        return Signup;
    }());
    var SignupSecceed = /** @class */ (function () {
        function SignupSecceed(payload) {
            this.payload = payload;
            this.type = SignInActionTypes.SIGNUP_SUCCEED;
        }
        return SignupSecceed;
    }());
    var SignupFailed = /** @class */ (function () {
        function SignupFailed(payload) {
            this.payload = payload;
            this.type = SignInActionTypes.SIGNUP_FAILURE;
        }
        return SignupFailed;
    }());
    /**
     * Sign in
     */
    var /**
     * Sign in
     */ Signin = /** @class */ (function () {
        function Signin(payload) {
            this.payload = payload;
            this.type = SignInActionTypes.SIGNIN;
        }
        return Signin;
    }());
    var SigninSecceed = /** @class */ (function () {
        function SigninSecceed(payload) {
            this.payload = payload;
            this.type = SignInActionTypes.SIGNIN_SUCCEED;
        }
        return SigninSecceed;
    }());
    var SigninFailed = /** @class */ (function () {
        function SigninFailed(payload) {
            this.payload = payload;
            this.type = SignInActionTypes.SIGNIN_FAILURE;
        }
        return SigninFailed;
    }());
    var DoSignoutAction = /** @class */ (function () {
        function DoSignoutAction() {
            this.type = SignInActionTypes.DO_SIGNOUT;
        }
        return DoSignoutAction;
    }());
    var SignoutAction = /** @class */ (function () {
        function SignoutAction() {
            this.type = SignInActionTypes.SIGNOUT;
        }
        return SignoutAction;
    }());
    var SigninRequiredAction = /** @class */ (function () {
        function SigninRequiredAction() {
            this.type = SignInActionTypes.SIGNIN_REQUIRED;
        }
        return SigninRequiredAction;
    }());

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    /** @type {?} */
    var MODULE_DEFAULT_CONFIG = {
        mode: "cookie-base",
        token: {
            time: 24 * 12 * 60 * 60
        },
        server: "frontend_server",
        endpoints: {
            signOut: "",
            signOutMethod: "get",
            signIn: "",
            signUp: "",
            whoAmI: ""
        },
        forms: {
            signIn: "",
            signUp: ""
        },
        env: {
            production: false,
            frontend_server: "auth/module/frontend_server/did/not/set",
            server: "auth/module/server/did/not/set"
        },
        afterSignoutRedirectTo: "/",
        signupValidator: function (value) { return rxjs.of(true); },
        afterSignin: function (user) { },
        responseToUser: function (user) { return user; }
    };
    /** @type {?} */
    var MODULE_CONFIG_TOKEN = new i0.InjectionToken("ModuleConfig");

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    var AuthenticationConfigurationService = /** @class */ (function () {
        function AuthenticationConfigurationService(configFile, store) {
            var _this = this;
            this.store = store;
            this.config$ = new rxjs.BehaviorSubject(this._config);
            this._config = Object.assign({}, MODULE_DEFAULT_CONFIG, configFile);
            this.config$.next(this._config);
            this.store.select(config.getAuthenticationModuleConfig).subscribe(function (storeConfig) {
                if (!storeConfig)
                    return;
                _this._config = Object.assign({}, _this._config, storeConfig.Config);
                _this.config$.next(_this._config);
            });
        }
        Object.defineProperty(AuthenticationConfigurationService.prototype, "config", {
            get: /**
             * @return {?}
             */ function () {
                return this._config;
            },
            enumerable: true,
            configurable: true
        });
        AuthenticationConfigurationService.decorators = [
            { type: i0.Injectable, args: [{
                        providedIn: "root"
                    },] }
        ];
        /** @nocollapse */
        AuthenticationConfigurationService.ctorParameters = function () {
            return [
                { type: undefined, decorators: [{ type: i0.Inject, args: [MODULE_CONFIG_TOKEN,] }] },
                { type: i2.Store }
            ];
        };
        /** @nocollapse */ AuthenticationConfigurationService.ngInjectableDef = i0.defineInjectable({ factory: function AuthenticationConfigurationService_Factory() { return new AuthenticationConfigurationService(i0.inject(MODULE_CONFIG_TOKEN), i0.inject(i2.Store)); }, token: AuthenticationConfigurationService, providedIn: "root" });
        return AuthenticationConfigurationService;
    }());

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    var ProgressingStarted = /** @class */ (function () {
        function ProgressingStarted() {
            this.type = "[AUTHENTICATION] PROGRESSING_STARTED" /* PROGRESSING_STARTED */;
        }
        return ProgressingStarted;
    }());
    var ProgressingFinished = /** @class */ (function () {
        function ProgressingFinished() {
            this.type = "[AUTHENTICATION] PROGRESSING_FINISHED" /* PROGRESSING_FINISHED */;
        }
        return ProgressingFinished;
    }());

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    /** @type {?} */
    var NEW_CAPTCHA = '[captcha] new captcha';
    var NewCaptcha = /** @class */ (function () {
        function NewCaptcha() {
            this.type = NEW_CAPTCHA;
        }
        return NewCaptcha;
    }());

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

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    /** @type {?} */
    var COOKIE_NAME = "ngs-authentication";
    var SigninService = /** @class */ (function () {
        function SigninService(http, store, configurationService, snackBar) {
            var _this = this;
            this.http = http;
            this.store = store;
            this.configurationService = configurationService;
            this.snackBar = snackBar;
            setTimeout(function () { return _this.store.dispatch(new WhoAmIAction()); }, 300);
        }
        /**
         * @param {?} model
         * @return {?}
         */
        SigninService.prototype.signup = /**
         * @param {?} model
         * @return {?}
         */
            function (model) {
                var _this = this;
                return this.configurationService.config$.pipe(operators.filter(function (config$$1) { return config$$1.endpoints.signUp != ""; }), operators.take(1), operators.switchMap(function (config$$1) {
                    return _this.http.post(config$$1.env[config$$1.server] + config$$1.endpoints.signUp, model);
                }), operators.map(function (response) {
                    /** @type {?} */
                    var user = Object.assign({}, response.Result);
                    if (user.Role) {
                        user.Roles = [user.Role];
                    }
                    return user;
                }));
            };
        /**
         * @param {?} model
         * @return {?}
         */
        SigninService.prototype.signin = /**
         * @param {?} model
         * @return {?}
         */
            function (model) {
                var _this = this;
                return this.configurationService.config$.pipe(operators.filter(function (config$$1) { return config$$1.endpoints.signIn != ""; }), operators.take(1), operators.switchMap(function (config$$1) { return _this.http.post(config$$1.env[config$$1.server] + config$$1.endpoints.signIn, model); }), operators.map(this.configurationService.config.responseToUser), operators.map(function (user) {
                    if (user.Role) {
                        user.Roles = [user.Role];
                    }
                    return user;
                }), operators.tap(function (user) {
                    if (_this.configurationService.config.mode == "token-base")
                        shared.Cookie.setCookie(COOKIE_NAME, JSON.stringify(user), _this.configurationService.config.token.time);
                }), operators.tap(function (user) { return _this.configurationService.config.afterSignin(user); }));
            };
        // TODO:
        // TODO:
        /**
         * @return {?}
         */
        SigninService.prototype.signout =
            // TODO:
            /**
             * @return {?}
             */
            function () {
                /** @type {?} */
                var config$$1 = this.configurationService.config;
                /** @type {?} */
                var tokenObject = JSON.parse(shared.Cookie.getCookie(COOKIE_NAME));
                /** @type {?} */
                var endpoint = shared.stringTemplate(config$$1.env[config$$1.server] + config$$1.endpoints.signOut, tokenObject);
                /** @type {?} */
                var method = config$$1.endpoints.signOutMethod || "get";
                if (["get", "put", "post", "patch", "delete"].indexOf(method) === -1) {
                    rxjs.throwError(method + " is not valid http method. [ @starter/authentication/signinservice/singout ]");
                }
                return this.http[method](endpoint).pipe(operators.tap(function () {
                    shared.Cookie.deleteCookie(COOKIE_NAME);
                }));
            };
        /**
         * @return {?}
         */
        SigninService.prototype.whoAmI = /**
         * @return {?}
         */
            function () {
                var _this = this;
                debugger;
                /** @type {?} */
                var user = { Token: "--" };
                if (this.configurationService.config.mode == "token-base") {
                    try {
                        user = JSON.parse(shared.Cookie.getCookie(COOKIE_NAME));
                    }
                    catch (error) { }
                }
                return this.configurationService.config$.pipe(operators.filter(function (config$$1) { return config$$1.endpoints.whoAmI != ""; }), operators.take(1), operators.switchMap(function (config$$1) {
                    return _this.http.get(shared.stringTemplate(config$$1.env[config$$1.server] + config$$1.endpoints.whoAmI, { user: user }));
                }));
            };
        SigninService.decorators = [
            { type: i0.Injectable, args: [{
                        providedIn: "root"
                    },] }
        ];
        /** @nocollapse */
        SigninService.ctorParameters = function () {
            return [
                { type: i1.HttpClient },
                { type: i2.Store },
                { type: AuthenticationConfigurationService },
                { type: material.MatSnackBar }
            ];
        };
        /** @nocollapse */ SigninService.ngInjectableDef = i0.defineInjectable({ factory: function SigninService_Factory() { return new SigninService(i0.inject(i1.HttpClient), i0.inject(i2.Store), i0.inject(AuthenticationConfigurationService), i0.inject(i4.MatSnackBar)); }, token: SigninService, providedIn: "root" });
        return SigninService;
    }());

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    var SigninContainerComponent = /** @class */ (function () {
        function SigninContainerComponent(configurationService, store) {
            this.configurationService = configurationService;
            this.store = store;
            this.signedIn$ = new i0.EventEmitter();
            this.formId$ = this.configurationService.config$.map(function (config$$1) { return config$$1.forms.signIn; });
        }
        /**
         * @param {?} formValue
         * @return {?}
         */
        SigninContainerComponent.prototype.signIn = /**
         * @param {?} formValue
         * @return {?}
         */
            function (formValue) {
                this.store.dispatch(new Signin(formValue));
                this.signedIn$.emit(true);
            };
        SigninContainerComponent.decorators = [
            { type: i0.Component, args: [{
                        template: "\n        <auth-signin \n                [formId]='(formId$ | async)'\n                (signedin)=\"signIn($event)\"\n        ></auth-signin>\n  "
                    }] }
        ];
        /** @nocollapse */
        SigninContainerComponent.ctorParameters = function () {
            return [
                { type: AuthenticationConfigurationService },
                { type: i2.Store }
            ];
        };
        SigninContainerComponent.propDecorators = {
            signedIn$: [{ type: i0.Output }]
        };
        return SigninContainerComponent;
    }());

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    var AuthenticationContainerComponent = /** @class */ (function () {
        function AuthenticationContainerComponent() {
        }
        AuthenticationContainerComponent.decorators = [
            { type: i0.Component, args: [{
                        template: "\n          <router-outlet></router-outlet>\n        "
                    }] }
        ];
        return AuthenticationContainerComponent;
    }());

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    var SignupContainerComponent = /** @class */ (function () {
        function SignupContainerComponent(configurationService, store, snackBar) {
            this.configurationService = configurationService;
            this.store = store;
            this.snackBar = snackBar;
            this.signedUp$ = new i0.EventEmitter();
            this.formId$ = this.configurationService.config$.map(function (config$$1) { return config$$1.forms.signUp; });
        }
        /**
         * @param {?} formValue
         * @return {?}
         */
        SignupContainerComponent.prototype.signup = /**
         * @param {?} formValue
         * @return {?}
         */
            function (formValue) {
                var _this = this;
                this.configurationService.config$
                    .pipe(operators.take(1), operators.switchMap(function (config$$1) { return config$$1.signupValidator(formValue); }))
                    .subscribe(function (validation) {
                    if (validation) {
                        _this.store.dispatch(new Signup(formValue));
                        _this.signedUp$.emit(true);
                    }
                    else {
                        _this.snackBar.open("رمز عبور یکسان نیست", null, {
                            duration: 2222
                        });
                    }
                });
            };
        SignupContainerComponent.decorators = [
            { type: i0.Component, args: [{
                        template: "\n        <auth-signup \n                [formId]='(formId$ | async)'\n                (signedup)=\"signup($event)\"\n        ></auth-signup>\n  "
                    }] }
        ];
        /** @nocollapse */
        SignupContainerComponent.ctorParameters = function () {
            return [
                { type: AuthenticationConfigurationService },
                { type: i2.Store },
                { type: material.MatSnackBar }
            ];
        };
        SignupContainerComponent.propDecorators = {
            signedUp$: [{ type: i0.Output }]
        };
        return SignupContainerComponent;
    }());

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    /** @type {?} */
    var routes = [
        {
            path: "auth",
            component: AuthenticationContainerComponent,
            children: [
                {
                    path: "signin",
                    // canActivate: [ SigninGuard ],
                    component: SigninContainerComponent
                },
                {
                    path: "signup",
                    // canActivate: [ SigninGuard ],
                    component: SignupContainerComponent
                }
            ]
        }
    ];
    /** @type {?} */
    var AuthenticationRoutingModule = router.RouterModule.forChild(routes);

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    var SigninComponent = /** @class */ (function () {
        function SigninComponent() {
            this.signedin = new i0.EventEmitter();
        }
        /**
         * @param {?} formGroup
         * @return {?}
         */
        SigninComponent.prototype.signin = /**
         * @param {?} formGroup
         * @return {?}
         */
            function (formGroup) {
                if (!formGroup.valid)
                    return;
                this.signedin.emit(formGroup.value);
            };
        SigninComponent.decorators = [
            { type: i0.Component, args: [{
                        selector: "auth-signin",
                        template: "<div fxLayout='row' fxLayoutAlign=\"center center\">\r\n    <ngs-form-view \r\n        [id]=\"formId\"\r\n        [card]=\"true\"\r\n        (accept)=\"signin($event)\"\r\n    ></ngs-form-view>\r\n</div>\r\n<!-- <div>\r\n    <a fxFlex=\"nogrow\" routerLink=\"/user/password/reset\" mat-raised-button fxFlexFill>\u06A9\u0644\u0645\u0647 \u0639\u0628\u0648\u0631 \u062E\u0648\u062F \u0631\u0627 \u0641\u0631\u0627\u0645\u0648\u0634 \u06A9\u0631\u062F\u0647 \u0627\u06CC\u062F\u061F</a>\r\n</div> -->",
                        styles: [""]
                    }] }
        ];
        /** @nocollapse */
        SigninComponent.ctorParameters = function () { return []; };
        SigninComponent.propDecorators = {
            signedin: [{ type: i0.Output }],
            formId: [{ type: i0.Input }]
        };
        return SigninComponent;
    }());

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    // import { environment } from "../../../environments/environment";
    var WithCredentialInterceptor = /** @class */ (function () {
        function WithCredentialInterceptor(configurationService) {
            this.configurationService = configurationService;
        }
        /**
         * @param {?} request
         * @param {?} next
         * @return {?}
         */
        WithCredentialInterceptor.prototype.intercept = /**
         * @param {?} request
         * @param {?} next
         * @return {?}
         */
            function (request, next) {
                // if (!this.configurationService.config.env.production)
                (( /** @type {?} */(request))).withCredentials = true;
                return next.handle(request);
            };
        WithCredentialInterceptor.decorators = [
            { type: i0.Injectable }
        ];
        /** @nocollapse */
        WithCredentialInterceptor.ctorParameters = function () {
            return [
                { type: AuthenticationConfigurationService }
            ];
        };
        return WithCredentialInterceptor;
    }());

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    var UnauthorizedInterceptor = /** @class */ (function () {
        function UnauthorizedInterceptor(router$$1, store // private signinService: SigninService
        ) {
            this.router = router$$1;
            this.store = store;
        }
        /**
         * @param {?} request
         * @param {?} next
         * @return {?}
         */
        UnauthorizedInterceptor.prototype.intercept = /**
         * @param {?} request
         * @param {?} next
         * @return {?}
         */
            function (request, next) {
                var _this = this;
                return next
                    .handle(request)
                    .map(function (event) {
                    if (event instanceof i1.HttpResponse)
                        return event;
                })
                    .catch(function (err) {
                    if (!(err instanceof i1.HttpErrorResponse))
                        return rxjs.throwError(err);
                    if (err.status != 401)
                        return rxjs.throwError(err);
                    if (err.url.includes("logout"))
                        return rxjs.throwError(err);
                    if (err.url.includes("user/account/profile"))
                        return rxjs.throwError(err);
                    _this.store.dispatch(new SignoutAction());
                    return rxjs.throwError("Unauthorized");
                });
            };
        UnauthorizedInterceptor.decorators = [
            { type: i0.Injectable }
        ];
        /** @nocollapse */
        UnauthorizedInterceptor.ctorParameters = function () {
            return [
                { type: router.Router },
                { type: i2.Store }
            ];
        };
        return UnauthorizedInterceptor;
    }());

    /*! *****************************************************************************
    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.
    ***************************************************************************** */
    var __assign = function () {
        __assign = Object.assign || function __assign(t) {
            for (var s, i = 1, n = arguments.length; i < n; i++) {
                s = arguments[i];
                for (var p in s)
                    if (Object.prototype.hasOwnProperty.call(s, p))
                        t[p] = s[p];
            }
            return t;
        };
        return __assign.apply(this, arguments);
    };
    function __decorate(decorators, target, key, desc) {
        var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
        if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
            r = Reflect.decorate(decorators, target, key, desc);
        else
            for (var i = decorators.length - 1; i >= 0; i--)
                if (d = decorators[i])
                    r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
        return c > 3 && r && Object.defineProperty(target, key, r), r;
    }
    function __metadata(metadataKey, metadataValue) {
        if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
            return Reflect.metadata(metadataKey, metadataValue);
    }

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    /** @type {?} */
    var initialState = {
        loggedIn: false,
        user: new UserModel({ Id: 1 })
    };
    /**
     * @param {?=} state
     * @param {?=} action
     * @return {?}
     */
    function UserReducer(state, action) {
        if (state === void 0) {
            state = initialState;
        }
        switch (action.type) {
            case SignInActionTypes.SIGNIN_SUCCEED: {
                return __assign({}, state, { loggedIn: true, user: action.payload });
            }
            case SignInActionTypes.SIGNOUT: {
                return __assign({}, state, { loggedIn: false, user: new UserModel() });
            }
            default: {
                return state;
            }
        }
    }
    //#region  selectors
    /** @type {?} */
    var getLoggedIn = function (state) { return state.loggedIn; };
    /** @type {?} */
    var getUser = function (state) { return state.user; };

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    /** @type {?} */
    var AuthenticationReducers = {
        userStatus: UserReducer
        // captcha: captchaReducer.CaptchaReducer
    };
    //#region selectors
    /** @type {?} */
    var selectAuthenticationState = i2.createFeatureSelector("authentication");
    /** @type {?} */
    var selectAuthState = i2.createSelector(selectAuthenticationState, function (state) { return state.userStatus; });
    /** @type {?} */
    var getLoggedIn$1 = i2.createSelector(selectAuthState, getLoggedIn);
    /** @type {?} */
    var getUser$1 = i2.createSelector(selectAuthState, getUser);

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

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    var SigninEffects = /** @class */ (function () {
        function SigninEffects(actions$, router$$1, signinService, configurationService, bottomSheet) {
            var _this = this;
            this.actions$ = actions$;
            this.router = router$$1;
            this.signinService = signinService;
            this.configurationService = configurationService;
            this.bottomSheet = bottomSheet;
            this.whoAmI$ = this.actions$.pipe(effects.ofType(SignInActionTypes.WHO_AM_I), operators.switchMap(function () {
                return _this.signinService
                    .whoAmI()
                    .pipe(operators.map(function (user) { return new SigninSecceed(user); }), operators.catchError(function (error) { return rxjs.of(new SigninFailed(error)); }));
            }));
            this.Signin$ = this.actions$.pipe(effects.ofType(SignInActionTypes.SIGNIN), operators.pluck("payload"), operators.switchMap(function (payload) {
                return _this.signinService
                    .signin(payload)
                    .pipe(operators.map(function (user) { return new SigninSecceed(user); }), operators.catchError(function (error) { return rxjs.of(new SigninFailed(error)); }));
            }));
            this.signup$ = this.actions$.pipe(effects.ofType(SignInActionTypes.SIGNUP), operators.pluck("payload"), operators.switchMap(function (payload) {
                return _this.signinService
                    .signup(payload)
                    .pipe(operators.map(function (user) { return new SignupSecceed(user); }), operators.catchError(function (error) { return rxjs.of(new SignupFailed(error)); }));
            }));
            this.signupSucceed$ = this.actions$.pipe(effects.ofType(SignInActionTypes.SIGNUP_SUCCEED), operators.tap(function () {
                debugger;
                _this.router.navigate(["auth/signin"]);
            }));
            this.SignInRequired$ = this.actions$.pipe(effects.ofType(SignInActionTypes.SIGNIN_REQUIRED), operators.tap(function (data) {
                /** @type {?} */
                var signinBottomSheetRef = _this.bottomSheet.open(SigninContainerComponent, {
                    panelClass: "clear-mat-card-box"
                });
                signinBottomSheetRef.instance.signedIn$.subscribe(function () {
                    signinBottomSheetRef.dismiss();
                });
                return signinBottomSheetRef;
            }));
            this.SigninSucceed$ = this.actions$.pipe(effects.ofType(SignInActionTypes.SIGNIN_SUCCEED), operators.tap(function (data) {
                if (location.pathname.indexOf("signin") > -1)
                    _this.router.navigate(["/"]);
            }));
            this.AfterSigninFiled$ = this.actions$.pipe(effects.ofType(SignInActionTypes.SIGNIN_FAILURE), operators.map(function () { return new NewCaptcha(); }));
            this.DoSignout$ = this.actions$.pipe(effects.ofType(SignInActionTypes.DO_SIGNOUT), operators.switchMap(function (data) {
                return _this.signinService.signout().pipe(operators.map(function () { return new SignoutAction(); }), operators.catchError(function (err) {
                    // TODO: dispatch valid action
                    debugger;
                    return rxjs.of(err);
                }));
            }));
            // TODO
            // @Effect() Signout$ = this.actions$.ofType(SignInActionTypes.DO_SIGNOUT).pipe(map(() => new SignoutAction()));
            this.redirectToLoginPage$ = this.actions$.pipe(effects.ofType(SignInActionTypes.SIGNIN_REDIRECT), operators.tap(function (authed) { return _this.router.navigate(["auth/signin"]); }));
            this.redirectAfterSignout$ = this.actions$.pipe(effects.ofType(SignInActionTypes.SIGNOUT), operators.tap(function (authed) { return _this.router.navigate([_this.configurationService.config$.getValue().afterSignoutRedirectTo]); }));
        }
        SigninEffects.decorators = [
            { type: i0.Injectable }
        ];
        /** @nocollapse */
        SigninEffects.ctorParameters = function () {
            return [
                { type: effects.Actions },
                { type: router.Router },
                { type: SigninService },
                { type: AuthenticationConfigurationService },
                { type: material.MatBottomSheet }
            ];
        };
        __decorate([
            effects.Effect(),
            __metadata("design:type", Object)
        ], SigninEffects.prototype, "whoAmI$", void 0);
        __decorate([
            effects.Effect(),
            __metadata("design:type", Object)
        ], SigninEffects.prototype, "Signin$", void 0);
        __decorate([
            effects.Effect(),
            __metadata("design:type", Object)
        ], SigninEffects.prototype, "signup$", void 0);
        __decorate([
            effects.Effect({ dispatch: false }),
            __metadata("design:type", Object)
        ], SigninEffects.prototype, "signupSucceed$", void 0);
        __decorate([
            effects.Effect({ dispatch: false }),
            __metadata("design:type", Object)
        ], SigninEffects.prototype, "SignInRequired$", void 0);
        __decorate([
            effects.Effect({ dispatch: false }),
            __metadata("design:type", Object)
        ], SigninEffects.prototype, "SigninSucceed$", void 0);
        __decorate([
            effects.Effect(),
            __metadata("design:type", Object)
        ], SigninEffects.prototype, "AfterSigninFiled$", void 0);
        __decorate([
            effects.Effect(),
            __metadata("design:type", Object)
        ], SigninEffects.prototype, "DoSignout$", void 0);
        __decorate([
            effects.Effect({ dispatch: false }),
            __metadata("design:type", Object)
        ], SigninEffects.prototype, "redirectToLoginPage$", void 0);
        __decorate([
            effects.Effect({ dispatch: false }),
            __metadata("design:type", Object)
        ], SigninEffects.prototype, "redirectAfterSignout$", void 0);
        return SigninEffects;
    }());

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    var AuthenticationEffects = /** @class */ (function () {
        function AuthenticationEffects(actions$) {
            this.actions$ = actions$;
            this.dispachProgressingStarted$ = this.actions$.pipe(effects.ofType(SignInActionTypes.SIGNIN), operators.map(function () { return new ProgressingStarted(); }));
            this.dispachProgressingFinished$ = this.actions$.pipe(effects.ofType(SignInActionTypes.SIGNIN_FAILURE, SignInActionTypes.SIGNIN_SUCCEED), operators.map(function () { return new ProgressingFinished(); }));
        }
        AuthenticationEffects.decorators = [
            { type: i0.Injectable }
        ];
        /** @nocollapse */
        AuthenticationEffects.ctorParameters = function () {
            return [
                { type: effects.Actions }
            ];
        };
        __decorate([
            effects.Effect(),
            __metadata("design:type", Object)
        ], AuthenticationEffects.prototype, "dispachProgressingStarted$", void 0);
        __decorate([
            effects.Effect(),
            __metadata("design:type", Object)
        ], AuthenticationEffects.prototype, "dispachProgressingFinished$", void 0);
        return AuthenticationEffects;
    }());

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    var SignupComponent = /** @class */ (function () {
        function SignupComponent() {
            this.signedup = new i0.EventEmitter();
        }
        /**
         * @param {?} formGroup
         * @return {?}
         */
        SignupComponent.prototype.signup = /**
         * @param {?} formGroup
         * @return {?}
         */
            function (formGroup) {
                if (!formGroup.valid)
                    return;
                this.signedup.emit(formGroup.value);
            };
        SignupComponent.decorators = [
            { type: i0.Component, args: [{
                        selector: "auth-signup",
                        template: "<div fxLayout='row' fxLayoutAlign=\"center center\">\r\n    <ngs-form-view \r\n        [id]=\"formId\"\r\n        [card]=\"true\"\r\n        (accept)=\"signup($event)\"\r\n    ></ngs-form-view>\r\n</div>\r\n<!-- <div>\r\n    <a fxFlex=\"nogrow\" routerLink=\"/user/password/reset\" mat-raised-button fxFlexFill>\u06A9\u0644\u0645\u0647 \u0639\u0628\u0648\u0631 \u062E\u0648\u062F \u0631\u0627 \u0641\u0631\u0627\u0645\u0648\u0634 \u06A9\u0631\u062F\u0647 \u0627\u06CC\u062F\u061F</a>\r\n</div> -->",
                        styles: [""]
                    }] }
        ];
        /** @nocollapse */
        SignupComponent.ctorParameters = function () { return []; };
        SignupComponent.propDecorators = {
            signedup: [{ type: i0.Output }],
            formId: [{ type: i0.Input }]
        };
        return SignupComponent;
    }());

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    var SigninGuard = /** @class */ (function () {
        function SigninGuard(store) {
            this.store = store;
        }
        /**
         * @param {?} route
         * @param {?} state
         * @return {?}
         */
        SigninGuard.prototype.canActivate = /**
         * @param {?} route
         * @param {?} state
         * @return {?}
         */
            function (route, state) {
                return this.store.select(getLoggedIn$1).take(1).map(function (authed) { return !authed; });
            };
        SigninGuard.decorators = [
            { type: i0.Injectable }
        ];
        /** @nocollapse */
        SigninGuard.ctorParameters = function () {
            return [
                { type: i2.Store }
            ];
        };
        return SigninGuard;
    }());

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    var NgsAuthenticationModule = /** @class */ (function () {
        function NgsAuthenticationModule() {
        }
        /**
         * @param {?=} config
         * @return {?}
         */
        NgsAuthenticationModule.forRoot = /**
         * @param {?=} config
         * @return {?}
         */
            function (config$$1) {
                if (config$$1 === void 0) {
                    config$$1 = ( /** @type {?} */({}));
                }
                return {
                    ngModule: RootNgsAuthenticationModule,
                    providers: [
                        { provide: MODULE_CONFIG_TOKEN, useValue: config$$1 },
                        {
                            provide: i1.HTTP_INTERCEPTORS,
                            useClass: UnauthorizedInterceptor,
                            multi: true
                        },
                        {
                            provide: i1.HTTP_INTERCEPTORS,
                            useClass: WithCredentialInterceptor,
                            multi: true
                        },
                        SigninService
                    ]
                };
            };
        NgsAuthenticationModule.decorators = [
            { type: i0.NgModule, args: [{
                        imports: [
                            common.CommonModule,
                            router.RouterModule,
                            forms.FormsModule,
                            i1.HttpClientModule,
                            flexLayout.FlexLayoutModule,
                            material.MatIconModule,
                            material.MatButtonModule,
                            material.MatCardModule,
                            material.MatSnackBarModule,
                            material.MatSidenavModule,
                            material.MatExpansionModule,
                            material.MatSelectModule,
                            material.MatBottomSheetModule,
                            material.MatFormFieldModule,
                            material.MatListModule,
                            material.MatMenuModule,
                            material.MatRadioModule,
                            material.MatInputModule,
                            material.MatToolbarModule,
                            material.MatDatepickerModule,
                            material.MatProgressBarModule,
                            animations.BrowserAnimationsModule,
                            forms.ReactiveFormsModule,
                            forms.FormsModule,
                            form.NgsFormModule
                        ],
                        declarations: [
                            SigninContainerComponent,
                            SigninComponent,
                            AuthenticationContainerComponent,
                            SignupContainerComponent,
                            SignupComponent
                        ],
                        entryComponents: [SigninContainerComponent],
                        providers: [SigninGuard],
                        exports: []
                    },] }
        ];
        return NgsAuthenticationModule;
    }());
    var RootNgsAuthenticationModule = /** @class */ (function () {
        function RootNgsAuthenticationModule() {
            (( /** @type {?} */(window))).___starter = (( /** @type {?} */(window))).___starter || {};
            (( /** @type {?} */(window))).___starter.authentication = "7.8.0";
        }
        RootNgsAuthenticationModule.decorators = [
            { type: i0.NgModule, args: [{
                        imports: [
                            i2.StoreModule.forFeature("authentication", AuthenticationReducers),
                            effects.EffectsModule.forFeature([SigninEffects, AuthenticationEffects]),
                            AuthenticationRoutingModule,
                            NgsAuthenticationModule
                        ]
                    },] }
        ];
        /** @nocollapse */
        RootNgsAuthenticationModule.ctorParameters = function () { return []; };
        return RootNgsAuthenticationModule;
    }());

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

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

    exports.UserModel = UserModel;
    exports.SignInActionTypes = SignInActionTypes;
    exports.DoSignoutAction = DoSignoutAction;
    exports.SigninRequiredAction = SigninRequiredAction;
    exports.SigninService = SigninService;
    exports.SigninContainerComponent = SigninContainerComponent;
    exports.NgsAuthenticationModule = NgsAuthenticationModule;
    exports.getUser = getUser$1;
    exports.ɵr = AuthenticationRoutingModule;
    exports.ɵa = MODULE_CONFIG_TOKEN;
    exports.ɵb = RootNgsAuthenticationModule;
    exports.ɵi = SigninComponent;
    exports.ɵl = SignupComponent;
    exports.ɵq = AuthenticationEffects;
    exports.ɵp = SigninEffects;
    exports.ɵs = UnauthorizedInterceptor;
    exports.ɵt = WithCredentialInterceptor;
    exports.ɵc = AuthenticationReducers;
    exports.ɵe = selectAuthState;
    exports.ɵd = selectAuthenticationState;
    exports.ɵn = UserReducer;
    exports.ɵo = getUser;
    exports.ɵm = SigninGuard;
    exports.ɵh = AuthenticationConfigurationService;
    exports.ɵj = AuthenticationContainerComponent;
    exports.ɵk = SignupContainerComponent;

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

})));

//# sourceMappingURL=soushians-authentication.umd.js.map