@sunbird-cb/consumption 0.0.1

package/esm5/lib/_pipes/pipe-duration-transform/pipe-duration-transform.pipe.js

@@ -0,0 +1,143 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { Pipe } from '@angular/core';
+import * as moment from 'moment';
+var PipeDurationTransformPipe = /** @class */ (function () {
+    function PipeDurationTransformPipe() {
+    }
+    /**
+     * @param {?} data
+     * @param {?} type
+     * @return {?}
+     */
+    PipeDurationTransformPipe.prototype.transform = /**
+     * @param {?} data
+     * @param {?} type
+     * @return {?}
+     */
+    function (data, type) {
+        if (data <= 0) {
+            return '';
+        }
+        /** @type {?} */
+        var h = Math.floor(data / 3600);
+        /** @type {?} */
+        var m = Math.floor((data % 3600) / 60);
+        /** @type {?} */
+        var s = Math.floor((data % 3600) % 60);
+        /** @type {?} */
+        var duration = '';
+        switch (type) {
+            case 'time24':
+                return this.defaultDuration(h, m, s);
+            case 'hms':
+                return this.hmsCalculation(h, m, s, duration, type);
+            case 'hms2H':
+                /**
+                 * to Print HH:mm:ss
+                 * @type {?}
+                 */
+                var duration2 = moment.duration(data, 'seconds');
+                /** @type {?} */
+                var resultstring = moment.utc(duration2.asMilliseconds()).format('HH:mm:ss');
+                return resultstring;
+            case 'hms2M': /**to Print mm:ss */
+                /**
+                 * to Print mm:ss
+                 * @type {?}
+                 */
+                var duration2H = moment.duration(data, 'seconds');
+                /** @type {?} */
+                var resultstring2H = moment.utc(duration2H.asMilliseconds()).format('mm:ss');
+                return resultstring2H;
+            case 'hour':
+                if (h === 0) {
+                    duration += 'less than an hour';
+                }
+                if (h === 1) {
+                    duration += h + " hour";
+                }
+                if (h > 1) {
+                    duration += h + " hours";
+                }
+                return duration;
+            case 'day':
+                if (h > 24) {
+                    /** @type {?} */
+                    var duration3 = moment.duration(data, 'seconds');
+                    return duration3.days() + " day(s)";
+                }
+                return this.hmsCalculation(h, m, s, duration, type);
+            default:
+                return this.defaultDuration(h, m, s);
+        }
+    };
+    /**
+     * @param {?} h
+     * @param {?} m
+     * @param {?} s
+     * @return {?}
+     */
+    PipeDurationTransformPipe.prototype.defaultDuration = /**
+     * @param {?} h
+     * @param {?} m
+     * @param {?} s
+     * @return {?}
+     */
+    function (h, m, s) {
+        /** @type {?} */
+        var duration = '';
+        duration += h > 0 ? h.toString().padStart(2) + ":" : '';
+        duration += m > 0 ? m.toString().padStart(2) + ":" : '00:';
+        duration += s > 0 ? s.toString().padStart(2) : '00';
+        return duration;
+    };
+    /**
+     * @param {?} h
+     * @param {?} m
+     * @param {?} s
+     * @param {?} dur
+     * @param {?} type
+     * @return {?}
+     */
+    PipeDurationTransformPipe.prototype.hmsCalculation = /**
+     * @param {?} h
+     * @param {?} m
+     * @param {?} s
+     * @param {?} dur
+     * @param {?} type
+     * @return {?}
+     */
+    function (h, m, s, dur, type) {
+        /** @type {?} */
+        var space = '';
+        /** @type {?} */
+        var duration = dur;
+        if (h > 0) {
+            duration += type === 'hms' ? h + "h" : h + " hr";
+        }
+        if (m > 0) {
+            if (h > 0) {
+                space = ' ';
+            }
+            duration += type === 'hms' ? "" + space + m + "m" : "" + space + m + " min";
+        }
+        if (s > 0 && h === 0) {
+            if (m > 0) {
+                space = ' ';
+            }
+            duration += type === 'hms' ? "" + space + s + "s" : "" + space + s + " sec";
+        }
+        return duration;
+    };
+    PipeDurationTransformPipe.decorators = [
+        { type: Pipe, args: [{
+                    name: 'pipeDurationTransform',
+                },] }
+    ];
+    return PipeDurationTransformPipe;
+}());
+export { PipeDurationTransformPipe };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/_pipes/pipe-public-URL/pipe-public-URL.module.js

@@ -0,0 +1,23 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { PipePublicURL } from './pipe-public-URL.pipe';
+var PipePublicURLModule = /** @class */ (function () {
+    function PipePublicURLModule() {
+    }
+    PipePublicURLModule.decorators = [
+        { type: NgModule, args: [{
+                    declarations: [PipePublicURL],
+                    imports: [
+                        CommonModule,
+                    ],
+                    exports: [PipePublicURL],
+                },] }
+    ];
+    return PipePublicURLModule;
+}());
+export { PipePublicURLModule };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGlwZS1wdWJsaWMtVVJMLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BzdW5iaXJkLWNiL2NvbnN1bXB0aW9uLyIsInNvdXJjZXMiOlsibGliL19waXBlcy9waXBlLXB1YmxpYy1VUkwvcGlwZS1wdWJsaWMtVVJMLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7O0FBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQTtBQUN4QyxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUE7QUFDOUMsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLHdCQUF3QixDQUFBO0FBRXREO0lBQUE7SUFPbUMsQ0FBQzs7Z0JBUG5DLFFBQVEsU0FBQztvQkFDUixZQUFZLEVBQUUsQ0FBQyxhQUFhLENBQUM7b0JBQzdCLE9BQU8sRUFBRTt3QkFDUCxZQUFZO3FCQUNiO29CQUNELE9BQU8sRUFBRSxDQUFDLGFBQWEsQ0FBQztpQkFDekI7O0lBQ2tDLDBCQUFDO0NBQUEsQUFQcEMsSUFPb0M7U0FBdkIsbUJBQW1CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJ1xuaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJ1xuaW1wb3J0IHsgUGlwZVB1YmxpY1VSTCB9IGZyb20gJy4vcGlwZS1wdWJsaWMtVVJMLnBpcGUnXG5cbkBOZ01vZHVsZSh7XG4gIGRlY2xhcmF0aW9uczogW1BpcGVQdWJsaWNVUkxdLFxuICBpbXBvcnRzOiBbXG4gICAgQ29tbW9uTW9kdWxlLFxuICBdLFxuICBleHBvcnRzOiBbUGlwZVB1YmxpY1VSTF0sXG59KVxuZXhwb3J0IGNsYXNzIFBpcGVQdWJsaWNVUkxNb2R1bGUgeyB9XG4iXX0=

package/esm5/lib/_pipes/pipe-public-URL/pipe-public-URL.pipe.js

@@ -0,0 +1,41 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { Inject, Pipe } from '@angular/core';
+var PipePublicURL = /** @class */ (function () {
+    function PipePublicURL(environment) {
+        this.environment = environment;
+    }
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    PipePublicURL.prototype.transform = /**
+     * @param {?} value
+     * @return {?}
+     */
+    function (value) {
+        /** @type {?} */
+        var mainUrl = value && value.split('/content').pop() || '';
+        /** @type {?} */
+        var finalURL = this.environment.contentHost + "/" + this.environment.contentBucket + "/content" + mainUrl;
+        return value ? finalURL : '';
+    };
+    PipePublicURL.decorators = [
+        { type: Pipe, args: [{
+                    name: 'pipePublicURL',
+                },] }
+    ];
+    /** @nocollapse */
+    PipePublicURL.ctorParameters = function () { return [
+        { type: undefined, decorators: [{ type: Inject, args: ['environment',] }] }
+    ]; };
+    return PipePublicURL;
+}());
+export { PipePublicURL };
+if (false) {
+    /** @type {?} */
+    PipePublicURL.prototype.environment;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGlwZS1wdWJsaWMtVVJMLnBpcGUuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9Ac3VuYmlyZC1jYi9jb25zdW1wdGlvbi8iLCJzb3VyY2VzIjpbImxpYi9fcGlwZXMvcGlwZS1wdWJsaWMtVVJML3BpcGUtcHVibGljLVVSTC5waXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7QUFBQSxPQUFPLEVBQUUsTUFBTSxFQUFFLElBQUksRUFBaUIsTUFBTSxlQUFlLENBQUE7QUFFM0Q7SUFLRSx1QkFDeUIsV0FBZ0I7UUFDckMsSUFBSSxDQUFDLFdBQVcsR0FBRyxXQUFXLENBQUE7SUFDbEMsQ0FBQzs7Ozs7SUFFRCxpQ0FBUzs7OztJQUFULFVBQVUsS0FBYTs7WUFDZixPQUFPLEdBQUcsS0FBSyxJQUFJLEtBQUssQ0FBQyxLQUFLLENBQUMsVUFBVSxDQUFDLENBQUMsR0FBRyxFQUFFLElBQUksRUFBRTs7WUFDdEQsUUFBUSxHQUFNLElBQUksQ0FBQyxXQUFXLENBQUMsV0FBVyxTQUFJLElBQUksQ0FBQyxXQUFXLENBQUMsYUFBYSxnQkFBVyxPQUFTO1FBQ3RHLE9BQU8sS0FBSyxDQUFDLENBQUMsQ0FBQyxRQUFRLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQTtJQUM5QixDQUFDOztnQkFkRixJQUFJLFNBQUM7b0JBQ0osSUFBSSxFQUFFLGVBQWU7aUJBQ3RCOzs7O2dEQUlJLE1BQU0sU0FBQyxhQUFhOztJQVV6QixvQkFBQztDQUFBLEFBaEJELElBZ0JDO1NBYlksYUFBYTs7O0lBQ3hCLG9DQUFnQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdCwgUGlwZSwgUGlwZVRyYW5zZm9ybSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnXG5cbkBQaXBlKHtcbiAgbmFtZTogJ3BpcGVQdWJsaWNVUkwnLFxufSlcbmV4cG9ydCBjbGFzcyBQaXBlUHVibGljVVJMIGltcGxlbWVudHMgUGlwZVRyYW5zZm9ybSB7XG4gIGVudmlyb25tZW50OiBhbnlcbiAgY29uc3RydWN0b3IoXG4gICAgQEluamVjdCgnZW52aXJvbm1lbnQnKSBlbnZpcm9ubWVudDogYW55LCl7XG4gICAgICB0aGlzLmVudmlyb25tZW50ID0gZW52aXJvbm1lbnRcbiAgfVxuXG4gIHRyYW5zZm9ybSh2YWx1ZTogc3RyaW5nKTogYW55IHtcbiAgICBjb25zdCBtYWluVXJsID0gdmFsdWUgJiYgdmFsdWUuc3BsaXQoJy9jb250ZW50JykucG9wKCkgfHwgJydcbiAgICBjb25zdCBmaW5hbFVSTCA9IGAke3RoaXMuZW52aXJvbm1lbnQuY29udGVudEhvc3R9LyR7dGhpcy5lbnZpcm9ubWVudC5jb250ZW50QnVja2V0fS9jb250ZW50JHttYWluVXJsfWBcbiAgICByZXR1cm4gdmFsdWUgPyBmaW5hbFVSTCA6ICcnXG4gIH1cblxufVxuIl19

package/esm5/lib/_services/common-methods.service.js

@@ -0,0 +1,73 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import * as tslib_1 from "tslib";
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+var CommonMethodsService = /** @class */ (function () {
+    function CommonMethodsService() {
+    }
+    /**
+     * @param {?} contents
+     * @param {?} strip
+     * @return {?}
+     */
+    CommonMethodsService.prototype.transformContentsToWidgets = /**
+     * @param {?} contents
+     * @param {?} strip
+     * @return {?}
+     */
+    function (contents, strip) {
+        return (contents || []).map((/**
+         * @param {?} content
+         * @param {?} idx
+         * @return {?}
+         */
+        function (content, idx) { return (content ? {
+            widgetType: 'cardLib',
+            widgetSubType: 'cardContentLib',
+            widgetHostClass: 'mb-2',
+            widgetData: tslib_1.__assign({ content: content }, (content.batch && { batch: content.batch }), { cardSubType: strip.stripConfig && strip.stripConfig.cardSubType, cardCustomeClass: strip.customeClass ? strip.customeClass : '', context: { pageSection: strip.key, position: idx }, intranetMode: strip.stripConfig && strip.stripConfig.intranetMode, deletedMode: strip.stripConfig && strip.stripConfig.deletedMode, contentTags: strip.stripConfig && strip.stripConfig.contentTags }),
+        } : {
+            widgetType: 'card',
+            widgetSubType: 'cardContent',
+            widgetHostClass: 'mb-2',
+            widgetData: {},
+        }); }));
+    };
+    /**
+     * @param {?} strip
+     * @return {?}
+     */
+    CommonMethodsService.prototype.transformSkeletonToWidgets = /**
+     * @param {?} strip
+     * @return {?}
+     */
+    function (strip) {
+        return [1, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10].map((/**
+         * @param {?} _content
+         * @return {?}
+         */
+        function (_content) { return ({
+            widgetType: 'cardLib',
+            widgetSubType: 'cardContentLib',
+            widgetHostClass: 'mb-2',
+            widgetData: {
+                cardSubType: strip.loaderConfig && strip.loaderConfig.cardSubType || 'card-standard-skeleton',
+                cardCustomeClass: strip.customeClass ? strip.customeClass : '',
+            },
+        }); }));
+    };
+    CommonMethodsService.decorators = [
+        { type: Injectable, args: [{
+                    providedIn: 'root'
+                },] }
+    ];
+    /** @nocollapse */
+    CommonMethodsService.ctorParameters = function () { return []; };
+    /** @nocollapse */ CommonMethodsService.ngInjectableDef = i0.ɵɵdefineInjectable({ factory: function CommonMethodsService_Factory() { return new CommonMethodsService(); }, token: CommonMethodsService, providedIn: "root" });
+    return CommonMethodsService;
+}());
+export { CommonMethodsService };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/_services/configurations.service.js

@@ -0,0 +1,257 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, ReplaySubject, Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+// const instanceConfigPath: string | null = window.location.host
+// const locationHost: string | null = window.location.host
+// if (!environment.production && Boolean(environment.sitePath)) {
+//   locationHost = environment.sitePath
+//   instanceConfigPath = environment.sitePath
+// }
+var ConfigurationsService = /** @class */ (function () {
+    // update as the single source of truth
+    function ConfigurationsService() {
+        this.appSetup = true;
+        // The url the user tried to access while landing in the app before accepting tnc
+        this.userUrl = '';
+        this.baseUrl = "assets/configurations";
+        this.sitePath = "assets/configurations";
+        this.hostPath = (window.location.host).replace(':', '_');
+        this.userRoles = null;
+        this.userGroups = null;
+        this.restrictedFeatures = null;
+        this.restrictedWidgets = null;
+        this.instanceConfig = null;
+        this.appsConfig = null;
+        this.rootOrg = null;
+        this.org = null;
+        this.activeOrg = '';
+        this.isProduction = false;
+        this.hasAcceptedTnc = false;
+        this.profileDetailsStatus = false;
+        this.isActive = true;
+        this.userPreference = null;
+        this.userProfile = null;
+        this.userProfileV2 = null;
+        this.nodebbUserProfile = null;
+        this.isAuthenticated = false;
+        this.isNewUser = false;
+        // pinnedApps
+        this.pinnedApps = new BehaviorSubject(new Set());
+        // Notifier
+        this.prefChangeNotifier = new ReplaySubject(1);
+        this.tourGuideNotifier = new ReplaySubject();
+        this.authChangeNotifier = new ReplaySubject(1);
+        this.updateProfile = new BehaviorSubject(false);
+        this.updateProfileObservable = this.updateProfile.asObservable();
+        this.updateTourGuide = new BehaviorSubject(true);
+        this.updateTourGuideObservable = this.updateTourGuide.asObservable();
+        // platform rating
+        this.updatePlatformRating = new BehaviorSubject({ bottom: '120px' });
+        this.updatePlatformRatingObservable$ = this.updatePlatformRating.asObservable();
+        this.languageTranslationFlag = new Subject();
+        // Preference Related Values
+        this.activeThemeObject = null;
+        this.activeFontObject = null;
+        this.isDarkMode = false;
+        this.isIntranetAllowed = false;
+        this.isRTL = false;
+        this.activeLocale = null;
+        this.activeLocaleGroup = '';
+        this.completedActivity = null;
+        this.completedTour = false;
+        this.profileSettings = ['profilePicture', 'learningTime', 'learningPoints'];
+        this.primaryNavBar = {
+            color: 'primary',
+        };
+        this.pageNavBar = {
+            color: 'primary',
+        };
+        this.primaryNavBarConfig = null;
+        /* for temp Fix */
+        // setBaseUrl = (sitePath: string) => `assets/configurations/${(sitePath).replace(':', '_')}`
+        // setSitePath = (sitePath: string) => `assets/configurations/${(sitePath).replace(
+        //   ':',
+        //   '_',
+        // )}`
+        // setHostPath = (sitePath: string) => (sitePath).replace(':', '_')
+        this.welcomeTabs = null;
+        // variable setting for csJwtToken
+        this.cstoken = '';
+        this.changeNavBarFullView = new Subject();
+        this.openExploreMenuForMWeb = new Subject();
+        // @Inject('env') env: any
+        // if (!env.production && Boolean(env.sitePath)) {
+        //   locationHost = env.sitePath
+        //   instanceConfigPath = env.sitePath
+        // }
+    }
+    /**
+     * @param {?} state
+     * @return {?}
+     */
+    ConfigurationsService.prototype.updateGlobalProfile = /**
+     * @param {?} state
+     * @return {?}
+     */
+    function (state) {
+        this.updateProfile.next(state);
+    };
+    /**
+     * @param {?} state
+     * @return {?}
+     */
+    ConfigurationsService.prototype.updateTourGuideMethod = /**
+     * @param {?} state
+     * @return {?}
+     */
+    function (state) {
+        this.updateTourGuide.next(state);
+    };
+    /**
+     * @param {?} state
+     * @return {?}
+     */
+    ConfigurationsService.prototype.updatePlatformRatingMethod = /**
+     * @param {?} state
+     * @return {?}
+     */
+    function (state) {
+        this.updatePlatformRating.next(state);
+    };
+    ConfigurationsService.decorators = [
+        { type: Injectable, args: [{
+                    providedIn: 'root',
+                },] }
+    ];
+    /** @nocollapse */
+    ConfigurationsService.ctorParameters = function () { return []; };
+    /** @nocollapse */ ConfigurationsService.ngInjectableDef = i0.ɵɵdefineInjectable({ factory: function ConfigurationsService_Factory() { return new ConfigurationsService(); }, token: ConfigurationsService, providedIn: "root" });
+    return ConfigurationsService;
+}());
+export { ConfigurationsService };
+if (false) {
+    /** @type {?} */
+    ConfigurationsService.prototype.appSetup;
+    /** @type {?} */
+    ConfigurationsService.prototype.userUrl;
+    /** @type {?} */
+    ConfigurationsService.prototype.baseUrl;
+    /** @type {?} */
+    ConfigurationsService.prototype.sitePath;
+    /** @type {?} */
+    ConfigurationsService.prototype.hostPath;
+    /** @type {?} */
+    ConfigurationsService.prototype.userRoles;
+    /** @type {?} */
+    ConfigurationsService.prototype.userGroups;
+    /** @type {?} */
+    ConfigurationsService.prototype.restrictedFeatures;
+    /** @type {?} */
+    ConfigurationsService.prototype.restrictedWidgets;
+    /** @type {?} */
+    ConfigurationsService.prototype.instanceConfig;
+    /** @type {?} */
+    ConfigurationsService.prototype.appsConfig;
+    /** @type {?} */
+    ConfigurationsService.prototype.rootOrg;
+    /** @type {?} */
+    ConfigurationsService.prototype.courseContentPath;
+    /** @type {?} */
+    ConfigurationsService.prototype.org;
+    /** @type {?} */
+    ConfigurationsService.prototype.activeOrg;
+    /** @type {?} */
+    ConfigurationsService.prototype.isProduction;
+    /** @type {?} */
+    ConfigurationsService.prototype.hasAcceptedTnc;
+    /** @type {?} */
+    ConfigurationsService.prototype.profileDetailsStatus;
+    /** @type {?} */
+    ConfigurationsService.prototype.isActive;
+    /** @type {?} */
+    ConfigurationsService.prototype.userPreference;
+    /** @type {?} */
+    ConfigurationsService.prototype.userProfile;
+    /** @type {?} */
+    ConfigurationsService.prototype.userProfileV2;
+    /** @type {?} */
+    ConfigurationsService.prototype.nodebbUserProfile;
+    /** @type {?} */
+    ConfigurationsService.prototype.unMappedUser;
+    /** @type {?} */
+    ConfigurationsService.prototype.isAuthenticated;
+    /** @type {?} */
+    ConfigurationsService.prototype.isNewUser;
+    /** @type {?} */
+    ConfigurationsService.prototype.portalUrls;
+    /** @type {?} */
+    ConfigurationsService.prototype.positions;
+    /** @type {?} */
+    ConfigurationsService.prototype.overrideThemeChanges;
+    /** @type {?} */
+    ConfigurationsService.prototype.profileTimelyNudges;
+    /** @type {?} */
+    ConfigurationsService.prototype.pinnedApps;
+    /** @type {?} */
+    ConfigurationsService.prototype.prefChangeNotifier;
+    /** @type {?} */
+    ConfigurationsService.prototype.tourGuideNotifier;
+    /** @type {?} */
+    ConfigurationsService.prototype.authChangeNotifier;
+    /**
+     * @type {?}
+     * @private
+     */
+    ConfigurationsService.prototype.updateProfile;
+    /** @type {?} */
+    ConfigurationsService.prototype.updateProfileObservable;
+    /** @type {?} */
+    ConfigurationsService.prototype.updateTourGuide;
+    /** @type {?} */
+    ConfigurationsService.prototype.updateTourGuideObservable;
+    /** @type {?} */
+    ConfigurationsService.prototype.updatePlatformRating;
+    /** @type {?} */
+    ConfigurationsService.prototype.updatePlatformRatingObservable$;
+    /** @type {?} */
+    ConfigurationsService.prototype.languageTranslationFlag;
+    /** @type {?} */
+    ConfigurationsService.prototype.activeThemeObject;
+    /** @type {?} */
+    ConfigurationsService.prototype.activeFontObject;
+    /** @type {?} */
+    ConfigurationsService.prototype.isDarkMode;
+    /** @type {?} */
+    ConfigurationsService.prototype.isIntranetAllowed;
+    /** @type {?} */
+    ConfigurationsService.prototype.isRTL;
+    /** @type {?} */
+    ConfigurationsService.prototype.activeLocale;
+    /** @type {?} */
+    ConfigurationsService.prototype.activeLocaleGroup;
+    /** @type {?} */
+    ConfigurationsService.prototype.completedActivity;
+    /** @type {?} */
+    ConfigurationsService.prototype.completedTour;
+    /** @type {?} */
+    ConfigurationsService.prototype.profileSettings;
+    /** @type {?} */
+    ConfigurationsService.prototype.primaryNavBar;
+    /** @type {?} */
+    ConfigurationsService.prototype.pageNavBar;
+    /** @type {?} */
+    ConfigurationsService.prototype.primaryNavBarConfig;
+    /** @type {?} */
+    ConfigurationsService.prototype.welcomeTabs;
+    /** @type {?} */
+    ConfigurationsService.prototype.cstoken;
+    /** @type {?} */
+    ConfigurationsService.prototype.changeNavBarFullView;
+    /** @type {?} */
+    ConfigurationsService.prototype.openExploreMenuForMWeb;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"configurations.service.js","sourceRoot":"ng://@sunbird-cb/consumption/","sources":["lib/_services/configurations.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { BehaviorSubject, ReplaySubject, Subject } from 'rxjs';\nimport { IPortalUrls, IUserPreference, NsAppsConfig, NsInstanceConfig, NsPage, NsUser } from '@sunbird-cb/utils';\nimport { NSProfileDataV3 } from '../_models/profile-v3.models';\n// const instanceConfigPath: string | null = window.location.host\n// const locationHost: string | null = window.location.host\n\n// if (!environment.production && Boolean(environment.sitePath)) {\n//   locationHost = environment.sitePath\n//   instanceConfigPath = environment.sitePath\n// }\n@Injectable({\n  providedIn: 'root',\n})\nexport class ConfigurationsService {\n  // update as the single source of truth\n  constructor() {\n    // @Inject('env') env: any\n    // if (!env.production && Boolean(env.sitePath)) {\n    //   locationHost = env.sitePath\n    //   instanceConfigPath = env.sitePath\n    // }\n  }\n  appSetup = true;\n  // The url the user tried to access while landing in the app before accepting tnc\n  userUrl = '';\n  baseUrl = `assets/configurations`;\n  sitePath = `assets/configurations`;\n  hostPath = (window.location.host).replace(':', '_');\n\n  userRoles: Set<string> | null = null;\n  userGroups: Set<string> | null = null;\n  restrictedFeatures: Set<string> | null = null;\n  restrictedWidgets: Set<string> | null = null;\n  instanceConfig: NsInstanceConfig.IConfig | null = null;\n  appsConfig: NsAppsConfig.IAppsConfig | null = null;\n  rootOrg: string | null = null;\n  courseContentPath?: string;\n  org: string[] | null = null;\n  activeOrg: string | null = '';\n  isProduction = false;\n  hasAcceptedTnc = false;\n  profileDetailsStatus = false;\n  isActive = true;\n  userPreference: IUserPreference | null = null;\n  userProfile: NsUser.IUserProfile | null = null;\n  userProfileV2: NsUser.IUserProfile | null = null;\n  nodebbUserProfile: NsUser.INodebbUserProfile | null = null;\n  // created to store complete user details sent by pid\n  unMappedUser: any;\n  isAuthenticated = false;\n  isNewUser = false;\n  portalUrls: IPortalUrls | undefined;\n  positions: any;\n  overrideThemeChanges: any;\n  profileTimelyNudges: any;\n\n  // pinnedApps\n  pinnedApps = new BehaviorSubject<Set<string>>(new Set());\n\n  // Notifier\n  prefChangeNotifier = new ReplaySubject<Partial<IUserPreference>>(1);\n  tourGuideNotifier = new ReplaySubject<boolean>();\n  authChangeNotifier = new ReplaySubject<boolean>(1);\n\n  private updateProfile = new BehaviorSubject(false);\n  updateProfileObservable = this.updateProfile.asObservable();\n\n  updateTourGuide = new BehaviorSubject(true);\n  updateTourGuideObservable = this.updateTourGuide.asObservable();\n\n  // platform rating\n  updatePlatformRating = new BehaviorSubject({ bottom: '120px' });\n  updatePlatformRatingObservable$ = this.updatePlatformRating.asObservable();\n\n  languageTranslationFlag = new Subject();\n\n  // Preference Related Values\n  activeThemeObject: NsInstanceConfig.ITheme | null = null;\n  activeFontObject: NsInstanceConfig.IFontSize | null = null;\n  isDarkMode = false;\n  isIntranetAllowed = false;\n  isRTL = false;\n  activeLocale: NsInstanceConfig.ILocalsConfig | null = null;\n  activeLocaleGroup = '';\n  completedActivity: string[] | null = null;\n  completedTour = false;\n  profileSettings = ['profilePicture', 'learningTime', 'learningPoints'];\n\n  primaryNavBar: Partial<NsPage.INavBackground> = {\n    color: 'primary',\n  };\n  pageNavBar: Partial<NsPage.INavBackground> = {\n    color: 'primary',\n  };\n  primaryNavBarConfig: NsInstanceConfig.IPrimaryNavbarConfig | null = null;\n  /* for temp Fix */\n  // setBaseUrl = (sitePath: string) => `assets/configurations/${(sitePath).replace(':', '_')}`\n  // setSitePath = (sitePath: string) => `assets/configurations/${(sitePath).replace(\n  //   ':',\n  //   '_',\n  // )}`\n  // setHostPath = (sitePath: string) => (sitePath).replace(':', '_')\n  welcomeTabs: NSProfileDataV3.IProfileTab | null = null;\n\n  // variable setting for csJwtToken\n  cstoken = '';\n\n  changeNavBarFullView = new Subject();\n  openExploreMenuForMWeb = new Subject();\n  updateGlobalProfile(state: boolean) {\n    this.updateProfile.next(state);\n  }\n  updateTourGuideMethod(state: boolean) {\n    this.updateTourGuide.next(state);\n  }\n\n  updatePlatformRatingMethod(state: any) {\n    this.updatePlatformRating.next(state);\n  }\n}\n"]}