@bnsights/bbsf-utilities 1.0.0

package/fesm2015/bnsights-bbsf-utilities.js

@@ -0,0 +1,661 @@
+import * as i1$2 from '@angular/common';
+import { DOCUMENT, CommonModule } from '@angular/common';
+import * as i0 from '@angular/core';
+import { Injectable, Inject, NgModule, Injector } from '@angular/core';
+import * as i1$3 from '@angular/router';
+import { Router, RouterModule } from '@angular/router';
+import * as i1$1 from '@ngx-translate/core';
+import { TranslateService } from '@ngx-translate/core';
+import { BlockUI, BlockUIModule } from 'ng-block-ui';
+import { ToastrService, ToastrModule } from 'ngx-toastr';
+import { HttpModule } from '@angular/http';
+import { __awaiter, __decorate } from 'tslib';
+import * as i1 from '@angular/common/http';
+import { HttpHeaders, HttpClient, HttpParams } from '@angular/common/http';
+import { UserManager, WebStorageStateStore } from 'oidc-client';
+import { BehaviorSubject, Subject } from 'rxjs';
+import { takeUntil, tap } from 'rxjs/operators';
+
+// This file can be replaced during build by using the `fileReplacements` array.
+// `ng build ---prod` replaces `environment.ts` with `environment.prod.ts`.
+// The list of file replacements can be found in `angular.json`.
+const environment = Object.assign({}, window.Envirnment);
+/*
+ * In development mode, to ignore zone related error stack frames such as
+ * `zone.run`, `zoneDelegate.invokeTask` for easier debugging, you can
+ * import the following file, but please comment it out in production mode
+ * because it will have performance impact when throw error
+ */
+// import 'zone.js/dist/zone-error';  // Included with Angular CLI.
+
+class EnvironmentService {
+    getEnvironmentObject() {
+        return environment;
+    }
+    getBaseUrl() {
+        let Url = environment["BBSF_BaseUrl"];
+        return Url;
+    }
+    getApiUrl() {
+        let Url = environment["BBSF_ApiUrl"];
+        return Url;
+    }
+    getProductionMode() {
+        let Mode = environment["BBSF_IsProduction"];
+        return Mode;
+    }
+    getIdentityServerUrl() {
+        let Url = environment["BBSF_IdentityServerUrl"];
+        return Url;
+    }
+}
+EnvironmentService.ɵprov = i0.ɵɵdefineInjectable({ factory: function EnvironmentService_Factory() { return new EnvironmentService(); }, token: EnvironmentService, providedIn: "root" });
+EnvironmentService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+
+class AuthService {
+    constructor(http, environmentService) {
+        this.http = http;
+        this.environmentService = environmentService;
+        // Observable navItem source
+        this._authNavStatusSource = new BehaviorSubject(false);
+        // Observable navItem stream
+        this.authNavStatus$ = this._authNavStatusSource.asObservable();
+        // Observable navItem source
+        this._userSource = new Subject();
+        this.UserStatus$ = this._userSource.asObservable();
+        this.manager = new UserManager({
+            authority: this.environmentService.getIdentityServerUrl(),
+            client_id: 'angular_spa',
+            redirect_uri: this.environmentService.getIdentityServerUrl() + '/Admin/authentication/auth-callback',
+            post_logout_redirect_uri: this.environmentService.getBaseUrl(),
+            response_type: "id_token token",
+            scope: "openid profile email IdentityServerApi",
+            filterProtocolClaims: true,
+            loadUserInfo: true,
+            automaticSilentRenew: true,
+            silent_redirect_uri: this.environmentService.getIdentityServerUrl() + '/assets/silent-callback.html',
+            userStore: new WebStorageStateStore({ store: window.localStorage })
+        });
+        this.redirectUrl = "";
+        this.manager.getUser().then((user) => __awaiter(this, void 0, void 0, function* () {
+            this.manager.storeUser(user);
+            AuthService.user = user;
+            this.user = user;
+            this._authNavStatusSource.next(yield this.isAuthenticated());
+        }));
+        this.manager.events.addAccessTokenExpired(_ => {
+            this._authNavStatusSource.next(false);
+        });
+    }
+    login() {
+        return this.manager.signinRedirect();
+    }
+    getUser() {
+        this.manager.getUser().then((user) => __awaiter(this, void 0, void 0, function* () {
+            ;
+            AuthService.user = user;
+            this.user = user;
+            this._authNavStatusSource.next(yield this.isAuthenticated());
+        }));
+    }
+    storUser(User) {
+        this.manager.storeUser(User);
+    }
+    revokeAccessToken() {
+        this.manager.revokeAccessToken();
+    }
+    signinSilent() {
+        let x = this.manager.signinSilentCallback();
+        x.then(s => {
+            //console.log(s)
+        });
+    }
+    completeAuthentication() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.user = yield this.manager.signinRedirectCallback();
+            AuthService.user = this.user;
+            this._userSource.next(AuthService.user);
+            this._authNavStatusSource.next(yield this.isAuthenticated());
+        });
+    }
+    refreshToken(token) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const httpOptions = {
+                headers: new HttpHeaders({
+                    'Content-Type': 'application/json',
+                    'Authorization': token
+                })
+            };
+            this.manager.revokeAccessToken();
+            return yield this.http.post(`${this.environmentService.getIdentityServerUrl()}/users/refresh-token`, httpOptions, { withCredentials: true }).subscribe((user) => {
+                this._userSource.next(user);
+                AuthService.user = user;
+                this.user = user;
+            });
+        });
+    }
+    getCurrentUser() {
+        return this.manager.getUser();
+    }
+    isAuthenticated(allowedPermission) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let user = yield this.manager.getUser().then(user => {
+                return user;
+            });
+            if (allowedPermission != null && allowedPermission != undefined) {
+                if (allowedPermission.length == 0) {
+                    return this.user != null && !this.user.expired;
+                }
+                else {
+                    let isUserInRole = this.isUserInRole(allowedPermission);
+                    return this.user != null && !this.user.expired && isUserInRole;
+                }
+            }
+            else
+                return this.user != null && !this.user.expired;
+        });
+    }
+    isUserInRole(allowedPermission) {
+        ;
+        let permissionSetSID = this.user.profile["permissionSetSID"].split `,`.map(x => +x);
+        return allowedPermission.every(i => permissionSetSID.includes(i));
+    }
+    authorizationHeaderValue() {
+        return `${AuthService.user.token_type} ${AuthService.user.access_token}`;
+    }
+    name() {
+        return AuthService.user != null ? AuthService.user.profile.given_name : '';
+    }
+    setUrl(url) {
+        localStorage.setItem("redirectUrl", url);
+    }
+    getUrl() {
+        return localStorage.getItem("redirectUrl");
+    }
+    signinSilentCallback() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let user = yield this.manager.signinSilentCallback();
+            //await this.manager.storeUser(user);
+            AuthService.user = user;
+            console.log("Token from  signinSilentCallback :" + AuthService.user);
+            this.user = user;
+        });
+    }
+    signout() {
+        return __awaiter(this, void 0, void 0, function* () {
+            localStorage.clear();
+            yield this.manager.signoutRedirect();
+        });
+    }
+}
+AuthService.user = null;
+AuthService.ɵprov = i0.ɵɵdefineInjectable({ factory: function AuthService_Factory() { return new AuthService(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(EnvironmentService)); }, token: AuthService, providedIn: "root" });
+AuthService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+AuthService.ctorParameters = () => [
+    { type: HttpClient },
+    { type: EnvironmentService }
+];
+
+class BBSFTranslateService extends TranslateService {
+}
+BBSFTranslateService.ɵprov = i0.ɵɵdefineInjectable({ factory: function BBSFTranslateService_Factory() { return new BBSFTranslateService(i0.ɵɵinject(i1$1.TranslateStore), i0.ɵɵinject(i1$1.TranslateLoader), i0.ɵɵinject(i1$1.TranslateCompiler), i0.ɵɵinject(i1$1.TranslateParser), i0.ɵɵinject(i1$1.MissingTranslationHandler), i0.ɵɵinject(i1$1.USE_DEFAULT_LANG), i0.ɵɵinject(i1$1.USE_STORE), i0.ɵɵinject(i1$1.USE_EXTEND), i0.ɵɵinject(i1$1.DEFAULT_LANGUAGE)); }, token: BBSFTranslateService, providedIn: "root" });
+BBSFTranslateService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+
+class UtilityService {
+    constructor(Translator, authService) {
+        this.Translator = Translator;
+        this.authService = authService;
+        this.isCreatedBefore = false;
+    }
+    getResourceValue(Key) {
+        let ResourceValue = "";
+        this.Translator.get(Key).subscribe(data => { ResourceValue = data; return ResourceValue; });
+        return ResourceValue;
+    }
+    getCurrentLanguage() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let user = yield this.authService.getCurrentUser().then((user) => {
+                return user;
+            });
+            return user.profile.locale;
+        });
+    }
+    isCurrentLanguageEnglish() {
+        return __awaiter(this, void 0, void 0, function* () {
+            (yield this.getCurrentLanguage()) == "en" ? true : false;
+        });
+    }
+    isCurrentLanguageArabic() {
+        return __awaiter(this, void 0, void 0, function* () {
+            (yield this.getCurrentLanguage()) == "ar" ? true : false;
+        });
+    }
+    notifySuccessMessage(Message, title, time) {
+        let MessageTemplate = this.getResourceValue("SuccessMessage");
+        let titleTemplate = this.getResourceValue("Success");
+        if (Message) {
+            MessageTemplate = Message;
+        }
+        if (title) {
+            titleTemplate = title;
+        }
+        let toaster = AppInjector.get(ToastrService);
+        toaster.success(MessageTemplate, titleTemplate);
+    }
+    notifyErrorMessage(Message, title, time) {
+        let MessageTemplate = this.getResourceValue("ErrorMessage");
+        let titleTemplate = this.getResourceValue("Error");
+        if (Message) {
+            MessageTemplate = Message;
+        }
+        if (title) {
+            titleTemplate = title;
+        }
+        const toaster = AppInjector.get(ToastrService);
+        toaster.error(MessageTemplate, titleTemplate);
+    }
+    notifyWarningMessage(Message, title, time) {
+        let MessageTemplate = this.getResourceValue("WarningMessage");
+        let titleTemplate = this.getResourceValue("Warning");
+        if (Message) {
+            MessageTemplate = Message;
+        }
+        if (title) {
+            titleTemplate = title;
+        }
+        const toaster = AppInjector.get(ToastrService);
+        toaster.warning(MessageTemplate, titleTemplate);
+    }
+    startBlockUI() {
+        this.blockUI.start();
+    }
+    stopBlockUI() {
+        this.blockUI.stop();
+    }
+}
+UtilityService.ɵprov = i0.ɵɵdefineInjectable({ factory: function UtilityService_Factory() { return new UtilityService(i0.ɵɵinject(BBSFTranslateService), i0.ɵɵinject(AuthService)); }, token: UtilityService, providedIn: "root" });
+UtilityService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+UtilityService.ctorParameters = () => [
+    { type: BBSFTranslateService },
+    { type: AuthService }
+];
+__decorate([
+    BlockUI()
+], UtilityService.prototype, "blockUI", void 0);
+
+class RequestOptionsModel {
+    constructor() {
+        this.disableSuccessNotification = false;
+        this.disableBlockUI = false;
+        this.responseType = "";
+        this.formGroup = null;
+    }
+}
+
+class ControlValidationService {
+    constructor(utilityService) {
+        this.utilityService = utilityService;
+        this.requestOptions = new RequestOptionsModel();
+        this.isCreatedBefor = false;
+    }
+    showGlobalError(errorMessage) {
+        let globalErorrElement = document.getElementsByClassName('alert alert-danger alert-InvalidValidation');
+        if (globalErorrElement.length > 0) {
+            this.removeElementsByClass('alert alert-danger alert-InvalidValidation');
+        }
+        if (this.isCreatedBefor == true) {
+            this.removeElementsByClass('alert alert-danger alert-InvalidValidation');
+        }
+        // tslint:disable-next-line: prefer-const
+        var objects = document.querySelectorAll('form.ng-invalid.ng-touched');
+        const tagName = 'div';
+        // tslint:disable-next-line: prefer-const
+        var elementToAppend = document.createElement(tagName); // Your tag name here
+        let message = "";
+        if (localStorage.getItem('language') == "ar")
+            message = errorMessage ? errorMessage : "لديك بعص الأخطاء . من فضلك قم بالمراجعه ";
+        else
+            message = errorMessage ? errorMessage : "You have some validation errors. Please check below";
+        elementToAppend.innerHTML = "<ul><li>" + message + "</li></ul>";
+        elementToAppend.className += 'alert alert-danger alert-InvalidValidation';
+        elementToAppend.id += 'errorId';
+        // tslint:disable-next-line: prefer-for-of
+        for (let i = 0; i < objects.length; i++) {
+            // const elementToAppen = elementToAppend.cloneNode(true);
+            // objects[i].insertBefore(elementToAppen, objects[i].firstChild);
+            const elementToAppen = elementToAppend.cloneNode(true);
+            let targetElement = objects[i].getElementsByClassName("b-control")[0];
+            targetElement.parentNode.insertBefore(elementToAppen, targetElement);
+            this.isCreatedBefor = true;
+            break;
+        }
+    }
+    RemoveGlobalError() {
+        const removedList = document.getElementsByClassName('alert alert-danger alert-InvalidValidation');
+        // tslint:disable-next-line: prefer-for-of
+        for (let index = 0; index < removedList.length; index++) {
+            const element = removedList[index];
+            element.remove();
+        }
+        this.isCreatedBefor = false;
+    }
+    showInputErro(errors) {
+        // show error on top of form 
+        this.showGlobalError();
+        // remove old error from server
+        this.removeElementsByClass('errortemplet');
+        // Looping in error Object
+        for (const key in errors) {
+            if (errors.hasOwnProperty(key)) {
+                for (const iterator of errors[key]) {
+                    const input = document.querySelectorAll('[ng-reflect-name=' + key + ']')[0];
+                    if (input.attributes['ng-reflect-name'].value === key) {
+                        this.removeElementsByClass('erroclass-' + key);
+                        const tagName = 'p';
+                        const elementToAppend = document.createElement(tagName); // Your tag name here
+                        elementToAppend.innerHTML = iterator;
+                        elementToAppend.style.color = 'red';
+                        elementToAppend.className += 'errortemplet erroclass-' + key;
+                        const elementToappen = elementToAppend.cloneNode(true);
+                        input.parentNode.insertBefore(elementToappen, input.lastChild);
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    removeElementsByClass(className) {
+        const elements = document.getElementsByClassName(className);
+        while (elements.length > 0) {
+            elements[0].parentNode.removeChild(elements[0]);
+        }
+    }
+    renderServerErrors(form, err, requestOptions) {
+        if (err.error == null) {
+            return;
+        }
+        this.requestOptions = requestOptions;
+        err.error.validation_errors.forEach((element) => {
+            let fieldName = element.field;
+            let controlName = element.control_name;
+            let message = element.message;
+            if (form == null) {
+                this.requestOptions.customErrorMessage ? this.utilityService.notifyErrorMessage(this.requestOptions.customErrorMessage) : this.utilityService.notifyErrorMessage(`${fieldName}: ${message}`);
+            }
+            else if (!this.hasControlName(form, controlName)) {
+                this.showGlobalError(`${fieldName}: ${message}`);
+            }
+            else {
+                this.setFieldError(form, controlName, fieldName, message);
+            }
+        });
+    }
+    hasControlName(form, controlName) {
+        let control = form.get(controlName);
+        return control != null;
+    }
+    setFieldError(form, controlName, fieldName, message) {
+        let control = form.get(controlName);
+        let errors = { [message]: true };
+        let fieldNameArray = fieldName.split('.');
+        if (fieldNameArray.length >= 1) {
+            switch (fieldNameArray[length - 1].toLocaleLowerCase()) {
+                case "english":
+                    let englishControl = control.get("EnglishValue");
+                    englishControl.setErrors(errors);
+                    englishControl.markAsTouched();
+                    englishControl.updateValueAndValidity();
+                    break;
+                case "arabic":
+                    let arabicControl = control.get("ArabicValue");
+                    arabicControl.setErrors(errors);
+                    arabicControl.markAsTouched();
+                    arabicControl.updateValueAndValidity();
+                    break;
+                default:
+                    control.setErrors(errors);
+                    control.markAsTouched();
+                    control.updateValueAndValidity();
+            }
+        }
+        else {
+            this.requestOptions.customErrorMessage ? this.utilityService.notifyErrorMessage(this.requestOptions.customErrorMessage) : this.utilityService.notifyErrorMessage(`${fieldName}: ${message}`);
+        }
+    }
+}
+ControlValidationService.ɵprov = i0.ɵɵdefineInjectable({ factory: function ControlValidationService_Factory() { return new ControlValidationService(i0.ɵɵinject(UtilityService)); }, token: ControlValidationService, providedIn: "root" });
+ControlValidationService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+ControlValidationService.ctorParameters = () => [
+    { type: UtilityService }
+];
+__decorate([
+    BlockUI()
+], ControlValidationService.prototype, "blockUI", void 0);
+
+class RequestHandlerService {
+    constructor(http, authService, environmentService, utilityService, controlValidationService, bbsfTranslateService) {
+        this.http = http;
+        this.authService = authService;
+        this.environmentService = environmentService;
+        this.utilityService = utilityService;
+        this.controlValidationService = controlValidationService;
+        this.bbsfTranslateService = bbsfTranslateService;
+        this.requestOptions = new RequestOptionsModel();
+        this.currentLanguage = "";
+        this.onDestroy$ = new Subject();
+        //using localStorage  to avoid call getCurrentLanguage() because it is not all to use async in constructor
+        this.currentLanguage = localStorage.getItem('language');
+        this.bbsfTranslateService.onLangChange.subscribe((event) => {
+            if (this.currentLanguage != event.lang) {
+                this.currentLanguage = event.lang;
+            }
+        });
+    }
+    get(Url, params, requestOptions) {
+        if (requestOptions)
+            this.requestOptions = requestOptions;
+        let headers = new HttpHeaders({
+            'Content-Type': 'application/json',
+            'Authorization': this.authService.authorizationHeaderValue(),
+        });
+        headers = headers.set('Accept-Language', this.currentLanguage.toString());
+        if (!this.requestOptions.disableBlockUI)
+            this.utilityService.startBlockUI();
+        return this.http.get(this.environmentService.getApiUrl() + Url, { headers: headers, params: params }).pipe(takeUntil(this.onDestroy$), tap((result) => {
+            if (!this.requestOptions.disableBlockUI)
+                this.utilityService.stopBlockUI();
+        }));
+    }
+    post(Url, model, params, requestOptions) {
+        if (requestOptions)
+            this.requestOptions = requestOptions;
+        let headers = new HttpHeaders({
+            'Content-Type': 'application/json',
+            'Authorization': this.authService.authorizationHeaderValue(),
+        });
+        headers = headers.set('Accept-Language', this.currentLanguage.toString());
+        if (!this.requestOptions.disableBlockUI)
+            this.utilityService.startBlockUI();
+        return this.http.post(this.environmentService.getApiUrl() + Url, model, { headers: headers, params: params, responseType: this.requestOptions.responseType }).pipe(takeUntil(this.onDestroy$), tap((result) => {
+            if (!this.requestOptions.disableBlockUI)
+                this.utilityService.stopBlockUI();
+        }));
+    }
+    destroyHandler() {
+        this.onDestroy$.next();
+    }
+}
+RequestHandlerService.ɵprov = i0.ɵɵdefineInjectable({ factory: function RequestHandlerService_Factory() { return new RequestHandlerService(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(AuthService), i0.ɵɵinject(EnvironmentService), i0.ɵɵinject(UtilityService), i0.ɵɵinject(ControlValidationService), i0.ɵɵinject(BBSFTranslateService)); }, token: RequestHandlerService, providedIn: "root" });
+RequestHandlerService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+RequestHandlerService.ctorParameters = () => [
+    { type: HttpClient },
+    { type: AuthService },
+    { type: EnvironmentService },
+    { type: UtilityService },
+    { type: ControlValidationService },
+    { type: BBSFTranslateService }
+];
+
+class StylesBundleService {
+    constructor(document) {
+        this.document = document;
+    }
+    loadThemes(lang, bundleEnglishName, bundleArabicName) {
+        if (lang == "ar") {
+            this.loadStyleBundle(bundleArabicName.toString());
+            document.querySelector('html').setAttribute("lang", "ar");
+            document.querySelector('html').setAttribute("dir", "rtl");
+        }
+        else {
+            this.loadStyleBundle(bundleEnglishName.toString());
+            document.querySelector('html').setAttribute("lang", "en");
+            document.querySelector('html').setAttribute("dir", "ltr");
+        }
+    }
+    loadStyleBundle(styleName) {
+        const head = this.document.getElementsByTagName('head')[0];
+        let themeLink = this.document.getElementById('client-theme');
+        if (themeLink && themeLink.href.includes(styleName)) {
+            return;
+        }
+        else if (themeLink && !themeLink.href.includes(styleName)) {
+            themeLink.remove();
+        }
+        const style = this.document.createElement('link');
+        style.id = 'client-theme';
+        style.rel = 'stylesheet';
+        style.href = `${styleName}`;
+        head.appendChild(style);
+    }
+}
+StylesBundleService.ɵprov = i0.ɵɵdefineInjectable({ factory: function StylesBundleService_Factory() { return new StylesBundleService(i0.ɵɵinject(i1$2.DOCUMENT)); }, token: StylesBundleService, providedIn: "root" });
+StylesBundleService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+StylesBundleService.ctorParameters = () => [
+    { type: Document, decorators: [{ type: Inject, args: [DOCUMENT,] }] }
+];
+
+class MasterLayoutService {
+    constructor(router, http, authService, stylesBundleService, translate) {
+        this.router = router;
+        this.http = http;
+        this.authService = authService;
+        this.stylesBundleService = stylesBundleService;
+        this.translate = translate;
+        this.ApiUrl = "/api/admin/Users/";
+    }
+    switchLang(lang, bundleEnglishName, bundleArabicName) {
+        this.changeLanguage(lang).subscribe((result) => {
+            this.updateUserInfo().subscribe((Value) => {
+                let UserInfoObject = Value;
+                this.authService.getUser();
+                this.authService.user.profile = Object.assign(this.authService.user.profile, UserInfoObject);
+                this.authService.storUser(this.authService.user);
+                this.stylesBundleService.loadThemes(lang, bundleEnglishName, bundleArabicName);
+                localStorage.setItem('language', lang);
+                this.translate.use(lang);
+            });
+        });
+    }
+    reloadComponent() {
+        let currentUrl = this.router.url;
+        this.router.routeReuseStrategy.shouldReuseRoute = () => false;
+        this.router.onSameUrlNavigation = 'reload';
+        this.router.navigate([currentUrl]);
+    }
+    changeLanguage(key) {
+        let params = new HttpParams();
+        params = params.append("UserId", this.authService.user.profile.id);
+        params = params.append("LanguageKey", key);
+        return this.http.post(this.ApiUrl + 'updateLaguage', null, params);
+    }
+    updateUserInfo() {
+        return this.http.get('/connect/userinfo');
+    }
+}
+MasterLayoutService.ɵprov = i0.ɵɵdefineInjectable({ factory: function MasterLayoutService_Factory() { return new MasterLayoutService(i0.ɵɵinject(i1$3.Router), i0.ɵɵinject(RequestHandlerService), i0.ɵɵinject(AuthService), i0.ɵɵinject(StylesBundleService), i0.ɵɵinject(i1$1.TranslateService)); }, token: MasterLayoutService, providedIn: "root" });
+MasterLayoutService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+MasterLayoutService.ctorParameters = () => [
+    { type: Router },
+    { type: RequestHandlerService },
+    { type: AuthService },
+    { type: StylesBundleService },
+    { type: TranslateService }
+];
+
+let AppInjector;
+class BBSFUtilitiesModule {
+    constructor(injector) {
+        this.injector = injector;
+        AppInjector = this.injector;
+    }
+}
+BBSFUtilitiesModule.decorators = [
+    { type: NgModule, args: [{
+                declarations: [],
+                imports: [
+                    CommonModule,
+                    BlockUIModule.forRoot(),
+                    HttpModule,
+                    RouterModule,
+                    ToastrModule.forRoot(),
+                ],
+                exports: [],
+                providers: [
+                    UtilityService,
+                    EnvironmentService,
+                    AuthService,
+                    RequestHandlerService,
+                    StylesBundleService,
+                    TranslateService,
+                    BBSFTranslateService,
+                    ControlValidationService,
+                    MasterLayoutService
+                ]
+            },] }
+];
+BBSFUtilitiesModule.ctorParameters = () => [
+    { type: Injector }
+];
+
+/*
+ * Public API Surface of bbsf-utilities
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AppInjector, AuthService, BBSFTranslateService, BBSFUtilitiesModule, ControlValidationService, EnvironmentService, MasterLayoutService, RequestHandlerService, RequestOptionsModel, StylesBundleService, UtilityService, environment };
+//# sourceMappingURL=bnsights-bbsf-utilities.js.map