@wavemaker-ai/app-ng-runtime 1.0.0-rc.647469

package/runtime/base/esm2022/services/app-defaults.service.mjs

@@ -0,0 +1,22 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class AppDefaultsService {
+    constructor() {
+    }
+    setFormats(formats) {
+        const dateFormat = formats.date;
+        const timeFormat = formats.time;
+        const dateTimeFormat = (dateFormat && timeFormat) ? dateFormat + ' ' + timeFormat : undefined;
+        const currency = formats.currency;
+        this.dateFormat = dateFormat;
+        this.timeFormat = timeFormat;
+        this.dateTimeFormat = dateTimeFormat;
+        this.currencyCode = currency;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AppDefaultsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AppDefaultsService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AppDefaultsService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBwLWRlZmF1bHRzLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9ydW50aW1lLWJhc2Uvc3JjL3NlcnZpY2VzL2FwcC1kZWZhdWx0cy5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBSzNDLE1BQU0sT0FBTyxrQkFBa0I7SUFFM0I7SUFDQSxDQUFDO0lBT0QsVUFBVSxDQUFDLE9BQVk7UUFDbkIsTUFBTSxVQUFVLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQztRQUNoQyxNQUFNLFVBQVUsR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDO1FBQ2hDLE1BQU0sY0FBYyxHQUFHLENBQUMsVUFBVSxJQUFJLFVBQVUsQ0FBQyxDQUFDLENBQUMsQ0FBQyxVQUFVLEdBQUcsR0FBRyxHQUFHLFVBQVUsQ0FBQyxDQUFDLENBQUMsU0FBUyxDQUFDO1FBQzlGLE1BQU0sUUFBUSxHQUFHLE9BQU8sQ0FBQyxRQUFRLENBQUM7UUFFbEMsSUFBSSxDQUFDLFVBQVUsR0FBRyxVQUFVLENBQUM7UUFDN0IsSUFBSSxDQUFDLFVBQVUsR0FBRyxVQUFVLENBQUM7UUFDN0IsSUFBSSxDQUFDLGNBQWMsR0FBRyxjQUFjLENBQUM7UUFDckMsSUFBSSxDQUFDLFlBQVksR0FBRyxRQUFRLENBQUM7SUFDakMsQ0FBQzsrR0FwQlEsa0JBQWtCO21IQUFsQixrQkFBa0I7OzRGQUFsQixrQkFBa0I7a0JBRDlCLFVBQVUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmltcG9ydCB7IEFwcERlZmF1bHRzIH0gZnJvbSAnQHdtL2NvcmUnO1xuXG5ASW5qZWN0YWJsZSgpXG5leHBvcnQgY2xhc3MgQXBwRGVmYXVsdHNTZXJ2aWNlIGltcGxlbWVudHMgQXBwRGVmYXVsdHMge1xuXG4gICAgY29uc3RydWN0b3IoKSB7XG4gICAgfVxuXG4gICAgZGF0ZUZvcm1hdDogc3RyaW5nO1xuICAgIHRpbWVGb3JtYXQ6IHN0cmluZztcbiAgICBkYXRlVGltZUZvcm1hdDogc3RyaW5nO1xuICAgIGN1cnJlbmN5Q29kZTogc3RyaW5nO1xuXG4gICAgc2V0Rm9ybWF0cyhmb3JtYXRzOiBhbnkpIHtcbiAgICAgICAgY29uc3QgZGF0ZUZvcm1hdCA9IGZvcm1hdHMuZGF0ZTtcbiAgICAgICAgY29uc3QgdGltZUZvcm1hdCA9IGZvcm1hdHMudGltZTtcbiAgICAgICAgY29uc3QgZGF0ZVRpbWVGb3JtYXQgPSAoZGF0ZUZvcm1hdCAmJiB0aW1lRm9ybWF0KSA/IGRhdGVGb3JtYXQgKyAnICcgKyB0aW1lRm9ybWF0IDogdW5kZWZpbmVkO1xuICAgICAgICBjb25zdCBjdXJyZW5jeSA9IGZvcm1hdHMuY3VycmVuY3k7XG5cbiAgICAgICAgdGhpcy5kYXRlRm9ybWF0ID0gZGF0ZUZvcm1hdDtcbiAgICAgICAgdGhpcy50aW1lRm9ybWF0ID0gdGltZUZvcm1hdDtcbiAgICAgICAgdGhpcy5kYXRlVGltZUZvcm1hdCA9IGRhdGVUaW1lRm9ybWF0O1xuICAgICAgICB0aGlzLmN1cnJlbmN5Q29kZSA9IGN1cnJlbmN5O1xuICAgIH1cbn1cbiJdfQ==

package/runtime/base/esm2022/services/app.manager.service.mjs

@@ -0,0 +1,522 @@
+import { Injectable } from '@angular/core';
+import { Router } from '@angular/router';
+import { DatePipe } from '@angular/common';
+import { $appDigest, AbstractDialogService, AbstractHttpService, AbstractI18nService, AbstractSpinnerService, App, fetchContent, getWmProjectProperties, isDefined, triggerFn } from '@wm/core';
+import { SecurityService } from '@wm/security';
+import { $rootScope, MetadataService, VariablesService } from '@wm/variables';
+import { extend, forEach, get, isEmpty, isObject, isUndefined, merge, trim } from "lodash-es";
+import { getModesFromLocalStorage } from '../public_api';
+import * as i0 from "@angular/core";
+import * as i1 from "@wm/core";
+import * as i2 from "@wm/security";
+import * as i3 from "@angular/router";
+import * as i4 from "@wm/variables";
+import * as i5 from "@angular/common";
+var POST_MESSAGES;
+(function (POST_MESSAGES) {
+    POST_MESSAGES["HIDE_TEMPLATES_SHOW_CASE"] = "hide-templates-show-case";
+    POST_MESSAGES["SHOW_TEMPLATES_SHOW_CASE"] = "show-templates-show-case";
+    POST_MESSAGES["UPDATE_LOCATION"] = "update-location-path";
+    POST_MESSAGES["SELECT_TEMPLATE"] = "select-template";
+    POST_MESSAGES["TEMPLATEBUNDLE_CONFIG"] = "template-bundle-config";
+    POST_MESSAGES["ON_LOAD"] = "on-load";
+})(POST_MESSAGES || (POST_MESSAGES = {}));
+export class AppManagerService {
+    static { this.SERVICE_NAME = 'AppManagerService'; }
+    constructor($http, $security, $dialog, $router, $app, $variables, $metadata, $spinner, $i18n, $datePipe) {
+        this.$http = $http;
+        this.$security = $security;
+        this.$dialog = $dialog;
+        this.$router = $router;
+        this.$app = $app;
+        this.$variables = $variables;
+        this.$metadata = $metadata;
+        this.$spinner = $spinner;
+        this.$i18n = $i18n;
+        this.$datePipe = $datePipe;
+        this.appVariablesLoaded = false;
+        this.appVariablesFired = false;
+        this._noRedirect = false;
+        this.appSubscriptions = []; // MEMORY LEAK FIX: Track subscriptions
+        // register method to invoke on session timeout
+        // MEMORY LEAK FIX: Store unsubscribe function for cleanup
+        this.sessionTimeoutUnsubscribe = this.$http.registerOnSessionTimeout(this.handle401.bind(this));
+        this.$variables.registerDependency('appManager', this);
+        // MEMORY LEAK FIX: Store subscription unsubscribe functions
+        this.appSubscriptions.push(this.$app.subscribe('toggle-variable-state', (data) => {
+            const variable = data.variable, active = data.active;
+            if (!isEmpty(trim(variable.spinnerContext))) {
+                if (active) {
+                    let spinnerExists;
+                    // WMS-21117 : Do not trigger spinner, if the current variable is same as spinner which is in context
+                    if (variable._spinnerId && variable._spinnerId.length) {
+                        forEach(variable._spinnerId, (item) => {
+                            if (item.slice(0, item.lastIndexOf('_')) === variable._id && this.$spinner.messagesByContext && this.$spinner.messagesByContext[variable.spinnerContext] &&
+                                (variable.spinnerMessage === this.$spinner.messagesByContext[variable.spinnerContext]["finalMessage"] || variable.spinnerMessage === this.$spinner.messagesByContext[variable.spinnerContext][item])) {
+                                spinnerExists = true;
+                                return;
+                            }
+                        });
+                    }
+                    if (!spinnerExists) {
+                        variable._spinnerId = variable._spinnerId || [];
+                        const spinnerId = this.$spinner.show(variable.spinnerMessage, variable._id + '_' + Date.now(), variable.spinnerclass, variable.spinnerContext);
+                        variable._spinnerId.push(spinnerId);
+                    }
+                }
+                else {
+                    this.$spinner.hide(variable._spinnerId.shift());
+                }
+            }
+        }));
+        this.appSubscriptions.push(this.$app.subscribe('userLoggedIn', () => {
+            this.setLandingPage();
+            if (this.lastLoggedUserId) {
+                this.$security.getConfig(config => {
+                    if (config && config.userInfo.userId !== this.lastLoggedUserId) {
+                        this.$app.clearPageCache();
+                    }
+                }, null);
+            }
+        }));
+        this.appSubscriptions.push(this.$app.subscribe('userLoggedOut', () => this.setLandingPage().then(() => {
+            this.$app.clearPageCache();
+        })));
+        this.appSubscriptions.push(this.$app.subscribe('http401', (d = {}) => this.handle401(d.page, d.options)));
+    }
+    /**
+     * On session timeout, if the session timeout config is set to a dialog, then open login dialog
+     */
+    showLoginDialog() {
+        this.$spinner.hide('globalSpinner');
+        // Removing the close all dialogs call, so the existing dialogs remain open and
+        // the login dialog comes on top of it.
+        this.$dialog.open('CommonLoginDialog');
+        // Since the login dialog is closed and opened its updated property isn't read by angular.
+        // Hence we trigger the digest cycle
+        $appDigest();
+    }
+    loadAppJS() {
+    }
+    loadCommonPage() {
+    }
+    loadSecurityConfig(forceFlag) {
+        return this.$security.load(forceFlag).then((r) => {
+            if (!this.$app.landingPageName) {
+                this.setLandingPage();
+            }
+            return r;
+        });
+    }
+    loadMetadata() {
+        return this.$metadata.load();
+    }
+    loadAppVariables(variables) {
+        if (this.appVariablesLoaded) {
+            return Promise.resolve();
+        }
+        const init = response => {
+            const data = this.$variables.register('app', response, this.$app);
+            // not assigning directly to this.$app to keep the reference in tact
+            extend(this.$app.Variables, data.Variables);
+            extend(this.$app.Actions, data.Actions);
+            this.updateLoggedInUserVariable();
+            this.updateSupportedLocaleVariable();
+            this.appVariablesLoaded = true;
+            this.appVariablesFired = false;
+        };
+        if (isDefined(variables)) {
+            init(variables);
+            return Promise.resolve();
+        }
+        return this.$http.get('./app.variables.json').then(response => init(response));
+    }
+    /**
+     * getter and setter for the property appVariablesFired
+     * this flag determines if the app variables(with startUpdate:true) have been fired
+     * they should get fired only once through app lifecycle
+     * @param {boolean} isFired
+     * @returns {boolean}
+     */
+    isAppVariablesFired(isFired) {
+        if (isDefined(isFired)) {
+            this.appVariablesFired = isFired;
+        }
+        return this.appVariablesFired;
+    }
+    clearLoggedInUserVariable(variable) {
+        variable.isAuthenticated = false;
+        variable.roles = [];
+        variable.name = undefined;
+        variable.id = undefined;
+        variable.tenantId = undefined;
+    }
+    updateLoggedInUserVariable() {
+        const loggedInUser = get(this.$app, 'Variables.loggedInUser.dataSet');
+        // sanity check
+        if (!loggedInUser) {
+            return;
+        }
+        return this.$security.load().then(() => {
+            const securityConfig = this.$security.get();
+            if (securityConfig && securityConfig.securityEnabled && securityConfig.authenticated) {
+                loggedInUser.isAuthenticated = securityConfig.authenticated;
+                loggedInUser.roles = securityConfig.userInfo.userRoles;
+                loggedInUser.name = securityConfig.userInfo.userName;
+                loggedInUser.id = securityConfig.userInfo.userId;
+                loggedInUser.tenantId = securityConfig.userInfo.tenantId;
+                loggedInUser.userAttributes = securityConfig.userInfo.userAttributes; // assign the extra userAttributes for custom usage.
+            }
+            else {
+                this.clearLoggedInUserVariable(loggedInUser);
+                loggedInUser.isSecurityEnabled = securityConfig && securityConfig.securityEnabled;
+                throw null;
+            }
+            return securityConfig;
+        }).catch(err => {
+            loggedInUser.isAuthenticated = false;
+            loggedInUser.roles = [];
+            loggedInUser.name = undefined;
+            loggedInUser.id = undefined;
+            loggedInUser.tenantId = undefined;
+            loggedInUser.userAttributes = {};
+        });
+    }
+    /**
+     * Overriding the app variable supported locale with the wmProperties i18n DataValues
+     *
+     * TODO[Vibhu]:
+     * Can write a simple migration to sync the supportedLocale variable with '_WM_APP_PROPERTIES.supportedLanguages'
+     * Hence, this may not be required
+     *
+     */
+    updateSupportedLocaleVariable() {
+        const supportedLocaleVar = get(this.$app, 'Variables.supportedLocale');
+    }
+    handleSSOLogin(config, options) {
+        const SSO_URL = 'services/security/ssologin', PREVIEW_WINDOW_NAME = 'WM_PREVIEW_WINDOW';
+        let page = '', queryParams;
+        // do not provide redirectTo page if fetching HOME page resulted 401
+        // on app load, by default Home page is loaded
+        /*
+         * For preview, this.$security.getRedirectedRouteQueryParams() gets the queryparams form the activated route(pagewrappercomponent)
+         * For deployed app, canactivate guard resolved to false and gets the queryparams from the canactivate gurard(no active route component)
+         */
+        queryParams = (options && options.queryParams) || this.$security.getRedirectedRouteQueryParams();
+        queryParams = this.$security.getQueryString(queryParams);
+        queryParams = queryParams ? '?' + queryParams : '';
+        const redirectPage = this.$security.getCurrentRoutePage();
+        const homePage = getWmProjectProperties().homePage;
+        if (redirectPage && (redirectPage !== homePage || !!queryParams)) {
+            page = '?redirectPage=' + encodeURIComponent(redirectPage);
+        }
+        // showing a redirecting message
+        document.body.textContent = get(this.getAppLocale(), ['MESSAGE_LOGIN_REDIRECTION']) || 'Redirecting to sso login...';
+        // appending redirect to page and page params
+        const ssoUrl = this.getDeployedURL() + SSO_URL + page + queryParams;
+        /*
+         * remove iFrame when redirected to IdP login page.
+         * this is being done as IDPs do not allow to get themselves loaded into iFrames.
+         * remove-toolbar has been assigned with a window name WM_PREVIEW_WINDOW, check if the iframe is our toolbar related and
+         * safely change the location of the parent toolbar with current url.
+         */
+        if (window.self !== window.top) {
+            try {
+                if (window.parent && window.location.origin === window.parent.origin) {
+                    if (window.parent.name === PREVIEW_WINDOW_NAME) {
+                        window.parent.location.href = window.self.location.href;
+                        window.parent.name = "";
+                    }
+                }
+                else {
+                    window.location.href = ssoUrl;
+                }
+            }
+            catch (error) {
+                window.location.href = ssoUrl;
+            }
+        }
+        else {
+            window.location.href = ssoUrl;
+        }
+    }
+    /**
+     * Handles the app when a XHR request returns 401 response
+     * If no user was logged in before 401 occurred, First time Login is simulated
+     * Else, a session timeout has occurred and the same is simulated
+     * @param page  if provided, represents the page name for which XHR request returned 401, on re-login
+     *              if not provided, a service request returned 401
+     * @param onSuccess success handler
+     * @param onError error handler
+     */
+    handle401(page, options) {
+        let sessionTimeoutConfig, sessionTimeoutMethod, loginConfig, loginMethod;
+        const LOGIN_METHOD = {
+            'DIALOG': 'DIALOG',
+            'PAGE': 'PAGE',
+            'SSO': 'SSO'
+        };
+        const config = this.$security.get();
+        let queryParamsObj = {};
+        loginConfig = config.loginConfig;
+        this.lastLoggedUserId = config.userInfo && config.userInfo.userId;
+        // if user found, 401 was thrown after session time
+        if (config.userInfo && config.userInfo.userName) {
+            config.authenticated = false;
+            sessionTimeoutConfig = loginConfig.sessionTimeout || { 'type': LOGIN_METHOD.DIALOG };
+            sessionTimeoutMethod = sessionTimeoutConfig.type.toUpperCase();
+            switch (sessionTimeoutMethod) {
+                case LOGIN_METHOD.DIALOG:
+                    this.showLoginDialog();
+                    break;
+                case LOGIN_METHOD.PAGE:
+                    if (!page) {
+                        page = this.$security.getCurrentRoutePage();
+                    }
+                    queryParamsObj['redirectTo'] = page;
+                    // Adding query params(page params of page being redirected to) to the URL.
+                    queryParamsObj = merge(queryParamsObj, this.$security.getRedirectedRouteQueryParams());
+                    // the redirect page should not be same as session timeout login page
+                    if (page !== sessionTimeoutConfig.pageName) {
+                        this.$router.navigate([sessionTimeoutConfig.pageName], { queryParams: queryParamsObj });
+                    }
+                    break;
+                case LOGIN_METHOD.SSO:
+                    this.handleSSOLogin(config, options);
+                    break;
+            }
+            this.setLandingPage();
+        }
+        else {
+            // if no user found, 401 was thrown for first time login
+            loginMethod = loginConfig.type.toUpperCase();
+            switch (loginMethod) {
+                case LOGIN_METHOD.DIALOG:
+                    // Through loginDialog, user will remain in the current state and failed calls will be executed post login through LoginActionService.
+                    // NOTE: user will be redirected to respective landing page only if dialog is opened manually(not through a failed 401 call).
+                    this.noRedirect(true);
+                    this.showLoginDialog();
+                    break;
+                case LOGIN_METHOD.PAGE:
+                    // do not provide redirectTo page if fetching HOME page resulted 401
+                    // on app load, by default Home page is loaded
+                    page = this.$security.getRedirectPage(config, page);
+                    queryParamsObj['redirectTo'] = page;
+                    const extraQueryParams = (options && options.queryParams) || this.$security.getRedirectedRouteQueryParams();
+                    queryParamsObj = merge(queryParamsObj, extraQueryParams);
+                    this.$router.navigate([loginConfig.pageName], { queryParams: queryParamsObj });
+                    this.$app.landingPageName = loginConfig.pageName;
+                    break;
+                case LOGIN_METHOD.SSO:
+                    this.handleSSOLogin(config, options);
+                    break;
+            }
+        }
+    }
+    /**
+     * Updates data dependent on logged in user
+     * Reloads security config, metadata
+     * Updates the loggedInUserVariable
+     * @returns {Promise<void>}
+     */
+    reloadAppData() {
+        return this.loadSecurityConfig(true).then(() => {
+            return this.loadMetadata().then(() => {
+                return this.updateLoggedInUserVariable().then((config) => {
+                    return Promise.resolve(this.beforeAppReady())
+                        .then(() => Promise.resolve(config));
+                });
+            });
+        });
+    }
+    noRedirect(value) {
+        if (isUndefined(value)) {
+            return this._noRedirect;
+        }
+        this._noRedirect = value;
+        return this._noRedirect;
+    }
+    /**
+     * invokes session failure requests
+     */
+    executeSessionFailureRequests() {
+        this.$http.executeSessionFailureRequests();
+    }
+    pushToSessionFailureRequests(callback) {
+        this.$http.pushToSessionFailureQueue(callback);
+    }
+    getDeployedURL() {
+        return this.$app.deployedUrl ? this.$app.deployedUrl : $rootScope.project.deployedUrl;
+    }
+    /**
+     * Fetches the customurlscheme for a mobile app
+     * which is used for redirection back to the app from browser in implicit oAuth flow
+     * @returns {string}
+     */
+    getCustomUrlScheme() {
+        return this.$app.customUrlScheme;
+    }
+    notify(eventName, data) {
+        this.$app.notify(eventName, data);
+    }
+    subscribe(eventName, data) {
+        return this.$app.subscribe(eventName, data);
+    }
+    getActivePage() {
+        return this.$app.activePage;
+    }
+    getAppLocale() {
+        return this.$app.appLocale;
+    }
+    getSelectedLocale() {
+        return this.$i18n.getSelectedLocale();
+    }
+    notifyApp(template, type, title) {
+        this.$app.notifyApp(template, type, title);
+    }
+    /**
+     * Triggers the onBeforeService method defined in app.js of the app
+     * @param requestParams
+     */
+    appOnBeforeServiceCall(requestParams) {
+        return triggerFn(this.$app.onBeforeServiceCall, requestParams);
+    }
+    /**
+     * Triggers the onServiceSuccess method defined in app.js of the app
+     * @param data
+     * @param xhrObj
+     */
+    appOnServiceSuccess(data, xhrObj) {
+        return triggerFn(this.$app.onServiceSuccess, data, xhrObj);
+    }
+    /**
+     * Triggers the onServiceError method defined in app.js of the app
+     * @param data
+     * @param xhrOb
+     */
+    appOnServiceError(data, xhrOb) {
+        return triggerFn(this.$app.onServiceError, data, xhrOb);
+    }
+    /**
+     * Triggers the appVariablesReady method defined in app.js of the app
+     */
+    appVariablesReady() {
+        triggerFn(this.$app.onAppVariablesReady);
+    }
+    /**
+     * Triggers the onBeforeAppReady method defined in app.js of the app
+     */
+    beforeAppReady() {
+        return triggerFn(this.$app.onBeforeAppReady);
+    }
+    /**
+     * Returns the pipe based on the input
+     */
+    getPipe(pipe) {
+        if (pipe === 'date') {
+            return this.$datePipe;
+        }
+    }
+    setLandingPage() {
+        return this.$security.getPageByLoggedInUser().then(p => this.$app.landingPageName = p);
+    }
+    /**
+     * return true if prefab type app
+     * @returns {boolean}
+     */
+    isPrefabType() {
+        return this.$app.isPrefabType;
+    }
+    /**
+     * return true if template bundle type app
+     * @returns {boolean}
+     */
+    isTemplateBundleType() {
+        return this.$app.isTemplateBundleType;
+    }
+    postMessage(content) {
+        window.top.postMessage(content, '*');
+    }
+    showTemplate(idx) {
+        const template = this.templates[idx];
+        // scope.activeTemplateIndex = idx;
+        this.$router.navigate([template.id]);
+    }
+    postTemplateBundleInfo() {
+        window.onmessage = (evt) => {
+            const msgData = evt.data;
+            if (!isObject(msgData)) {
+                return;
+            }
+            // @ts-ignore
+            const key = msgData.key;
+            switch (key) {
+                case POST_MESSAGES.HIDE_TEMPLATES_SHOW_CASE:
+                    // scope.hideShowCase = true;
+                    break;
+                case POST_MESSAGES.SELECT_TEMPLATE:
+                    // @ts-ignore
+                    this.showTemplate(msgData.templateIndex);
+                    break;
+            }
+        };
+        setTimeout(() => {
+            this.postMessage({ key: POST_MESSAGES.ON_LOAD });
+        });
+        return fetchContent('json', './config.json', true, response => {
+            this.templates = [];
+            if (!response.error) {
+                this.templates = response.templates;
+                this.postMessage({ 'key': POST_MESSAGES.TEMPLATEBUNDLE_CONFIG, 'config': response });
+            }
+        });
+    }
+    postAppTypeInfo() {
+        if (this.isTemplateBundleType()) {
+            return this.postTemplateBundleInfo();
+        }
+    }
+    initAppModes() {
+        // get modes from local storage
+        let storedModes = getModesFromLocalStorage();
+        // Apply restored modes
+        this.$app.setMode(storedModes);
+        // Listener for postMessage-based mode changes
+        // MEMORY LEAK FIX: Store bound function reference for cleanup
+        this.windowMessageListener = (event) => {
+            const { key, modes, shouldPersist } = event.data || {};
+            if (key === 'switch-mode' && modes) {
+                this.$app.setMode(modes, !shouldPersist);
+            }
+        };
+        window.addEventListener('message', this.windowMessageListener);
+    }
+    ngOnDestroy() {
+        // MEMORY LEAK FIX: Unsubscribe from all app subscriptions
+        this.appSubscriptions.forEach(unsubscribe => {
+            if (unsubscribe) {
+                unsubscribe();
+            }
+        });
+        this.appSubscriptions = [];
+        // MEMORY LEAK FIX: Unsubscribe from session timeout
+        if (this.sessionTimeoutUnsubscribe) {
+            this.sessionTimeoutUnsubscribe();
+            this.sessionTimeoutUnsubscribe = null;
+        }
+        // MEMORY LEAK FIX: Remove window message listener
+        if (this.windowMessageListener) {
+            window.removeEventListener('message', this.windowMessageListener);
+            this.windowMessageListener = null;
+        }
+        // MEMORY LEAK FIX: Clear references
+        this.templates = null;
+        this.lastLoggedUserId = null;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AppManagerService, deps: [{ token: i1.AbstractHttpService }, { token: i2.SecurityService }, { token: i1.AbstractDialogService }, { token: i3.Router }, { token: i1.App }, { token: i4.VariablesService }, { token: i4.MetadataService }, { token: i1.AbstractSpinnerService }, { token: i1.AbstractI18nService }, { token: i5.DatePipe }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AppManagerService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AppManagerService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.AbstractHttpService }, { type: i2.SecurityService }, { type: i1.AbstractDialogService }, { type: i3.Router }, { type: i1.App }, { type: i4.VariablesService }, { type: i4.MetadataService }, { type: i1.AbstractSpinnerService }, { type: i1.AbstractI18nService }, { type: i5.DatePipe }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"app.manager.service.js","sourceRoot":"","sources":["../../../../../projects/runtime-base/src/services/app.manager.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable, OnDestroy} from '@angular/core';\nimport {Router} from '@angular/router';\nimport {DatePipe} from '@angular/common';\n\nimport {\n    $appDigest,\n    AbstractDialogService,\n    AbstractHttpService,\n    AbstractI18nService,\n    AbstractSpinnerService,\n    App,\n    fetchContent,\n    getWmProjectProperties,\n    isDefined,\n    triggerFn\n} from '@wm/core';\nimport {SecurityService} from '@wm/security';\nimport {$rootScope, MetadataService, VariablesService} from '@wm/variables';\nimport {extend, forEach, get, isEmpty, isObject, isUndefined, merge, trim} from \"lodash-es\";\nimport {getModesFromLocalStorage} from '../public_api';\n\nenum POST_MESSAGES {\n    HIDE_TEMPLATES_SHOW_CASE = 'hide-templates-show-case',\n    SHOW_TEMPLATES_SHOW_CASE = 'show-templates-show-case',\n    UPDATE_LOCATION          = 'update-location-path',\n    SELECT_TEMPLATE          = 'select-template',\n    TEMPLATEBUNDLE_CONFIG    = 'template-bundle-config',\n    ON_LOAD                  = 'on-load'\n}\n\n\n@Injectable()\nexport class AppManagerService implements OnDestroy {\n    static readonly SERVICE_NAME = 'AppManagerService';\n\n    private appVariablesLoaded = false;\n    private appVariablesFired = false;\n    private _noRedirect = false;\n    private templates: Array<any>;\n    private lastLoggedUserId;\n    private appSubscriptions: Array<() => void> = []; // MEMORY LEAK FIX: Track subscriptions\n    private windowMessageListener: (event: MessageEvent) => void; // MEMORY LEAK FIX: Store listener reference\n    private sessionTimeoutUnsubscribe: () => void; // MEMORY LEAK FIX: Store unsubscribe function\n\n    constructor(\n        private $http: AbstractHttpService,\n        private $security: SecurityService,\n        private $dialog: AbstractDialogService,\n        private $router: Router,\n        private $app: App,\n        private $variables: VariablesService,\n        private $metadata: MetadataService,\n        private $spinner: AbstractSpinnerService,\n        private $i18n: AbstractI18nService,\n        private $datePipe: DatePipe,\n    ) {\n        // register method to invoke on session timeout\n        // MEMORY LEAK FIX: Store unsubscribe function for cleanup\n        this.sessionTimeoutUnsubscribe = this.$http.registerOnSessionTimeout(this.handle401.bind(this));\n\n        this.$variables.registerDependency('appManager', this);\n\n        // MEMORY LEAK FIX: Store subscription unsubscribe functions\n        this.appSubscriptions.push(this.$app.subscribe('toggle-variable-state', (data) => {\n            const variable = data.variable,\n                active = data.active;\n            if (!isEmpty(trim(variable.spinnerContext))) {\n                if (active) {\n                    let spinnerExists;\n                    // WMS-21117 : Do not trigger spinner, if the current variable is same as spinner which is in context\n                    if (variable._spinnerId && variable._spinnerId.length) {\n                        forEach(variable._spinnerId, (item) => {\n                            if (item.slice(0, item.lastIndexOf('_')) === variable._id && (this.$spinner as any).messagesByContext && (this.$spinner as any).messagesByContext[variable.spinnerContext] &&\n                                (variable.spinnerMessage === (this.$spinner as any).messagesByContext[variable.spinnerContext][\"finalMessage\"] || variable.spinnerMessage === (this.$spinner as any).messagesByContext[variable.spinnerContext][item])) {\n                                spinnerExists = true;\n                                return;\n                            }\n                        });\n                    }\n                    if (!spinnerExists) {\n                        variable._spinnerId = variable._spinnerId || [];\n                        const spinnerId = this.$spinner.show(variable.spinnerMessage,\n                            variable._id + '_' + Date.now(),\n                            variable.spinnerclass,\n                            variable.spinnerContext);\n                        variable._spinnerId.push(spinnerId);\n                    }\n                } else {\n                    this.$spinner.hide(variable._spinnerId.shift());\n                }\n            }\n        }));\n        this.appSubscriptions.push(this.$app.subscribe('userLoggedIn', () => {\n            this.setLandingPage();\n            if (this.lastLoggedUserId) {\n                this.$security.getConfig(config => {\n                    if(config && config.userInfo.userId !== this.lastLoggedUserId) {\n                        this.$app.clearPageCache();\n                    }\n                }, null);\n            }\n        }));\n        this.appSubscriptions.push(this.$app.subscribe('userLoggedOut', () => this.setLandingPage().then(() => {\n            this.$app.clearPageCache();\n        })));\n        this.appSubscriptions.push(this.$app.subscribe('http401', (d = {}) => this.handle401(d.page, d.options)));\n    }\n\n    /**\n     * On session timeout, if the session timeout config is set to a dialog, then open login dialog\n     */\n    private showLoginDialog() {\n        this.$spinner.hide('globalSpinner');\n        // Removing the close all dialogs call, so the existing dialogs remain open and\n        // the login dialog comes on top of it.\n        this.$dialog.open('CommonLoginDialog');\n        // Since the login dialog is closed and opened its updated property isn't read by angular.\n        // Hence we trigger the digest cycle\n        $appDigest();\n    }\n\n    loadAppJS() {\n\n    }\n\n    loadCommonPage() {\n\n    }\n\n    loadSecurityConfig(forceFlag?: boolean) {\n        return this.$security.load(forceFlag).then((r) => {\n            if (!this.$app.landingPageName) {\n                this.setLandingPage();\n            }\n            return r;\n        });\n    }\n\n    loadMetadata() {\n        return this.$metadata.load();\n    }\n\n    loadAppVariables(variables?: any) {\n        if (this.appVariablesLoaded) {\n            return Promise.resolve();\n        }\n\n        const init = response => {\n            const data = this.$variables.register('app', response, this.$app);\n            // not assigning directly to this.$app to keep the reference in tact\n            extend(this.$app.Variables, data.Variables);\n            extend(this.$app.Actions, data.Actions);\n            this.updateLoggedInUserVariable();\n            this.updateSupportedLocaleVariable();\n            this.appVariablesLoaded = true;\n            this.appVariablesFired = false;\n        };\n\n        if (isDefined(variables)) {\n            init(variables);\n            return Promise.resolve();\n        }\n\n        return this.$http.get('./app.variables.json').then(response => init(response));\n    }\n\n    /**\n     * getter and setter for the property appVariablesFired\n     * this flag determines if the app variables(with startUpdate:true) have been fired\n     * they should get fired only once through app lifecycle\n     * @param {boolean} isFired\n     * @returns {boolean}\n     */\n    isAppVariablesFired(isFired?: boolean) {\n        if (isDefined(isFired)) {\n            this.appVariablesFired = isFired;\n        }\n        return this.appVariablesFired;\n    }\n\n    private clearLoggedInUserVariable(variable) {\n        variable.isAuthenticated = false;\n        variable.roles           = [];\n        variable.name            = undefined;\n        variable.id              = undefined;\n        variable.tenantId        = undefined;\n    }\n\n    private updateLoggedInUserVariable() {\n        const loggedInUser = get(this.$app, 'Variables.loggedInUser.dataSet');\n\n        // sanity check\n        if (!loggedInUser) {\n            return;\n        }\n        return this.$security.load().then(() => {\n            const securityConfig = this.$security.get();\n            if (securityConfig && securityConfig.securityEnabled && securityConfig.authenticated) {\n                loggedInUser.isAuthenticated = securityConfig.authenticated;\n                loggedInUser.roles           = securityConfig.userInfo.userRoles;\n                loggedInUser.name            = securityConfig.userInfo.userName;\n                loggedInUser.id              = securityConfig.userInfo.userId;\n                loggedInUser.tenantId        = securityConfig.userInfo.tenantId;\n                loggedInUser.userAttributes  = securityConfig.userInfo.userAttributes; // assign the extra userAttributes for custom usage.\n            } else {\n                this.clearLoggedInUserVariable(loggedInUser);\n                loggedInUser.isSecurityEnabled = securityConfig && securityConfig.securityEnabled;\n                throw null;\n            }\n            return securityConfig;\n        }).catch(err => {\n            loggedInUser.isAuthenticated = false;\n            loggedInUser.roles           = [];\n            loggedInUser.name            = undefined;\n            loggedInUser.id              = undefined;\n            loggedInUser.tenantId        = undefined;\n            loggedInUser.userAttributes  = {};\n        });\n    }\n\n    /**\n     * Overriding the app variable supported locale with the wmProperties i18n DataValues\n     *\n     * TODO[Vibhu]:\n     * Can write a simple migration to sync the supportedLocale variable with '_WM_APP_PROPERTIES.supportedLanguages'\n     * Hence, this may not be required\n     *\n     */\n    updateSupportedLocaleVariable() {\n        const supportedLocaleVar = get(this.$app, 'Variables.supportedLocale');\n    }\n\n    handleSSOLogin(config, options) {\n        const SSO_URL = 'services/security/ssologin',\n            PREVIEW_WINDOW_NAME = 'WM_PREVIEW_WINDOW';\n        let page = '',\n            queryParams;\n\n        // do not provide redirectTo page if fetching HOME page resulted 401\n        // on app load, by default Home page is loaded\n\n            /*\n             * For preview, this.$security.getRedirectedRouteQueryParams() gets the queryparams form the activated route(pagewrappercomponent)\n             * For deployed app, canactivate guard resolved to false and gets the queryparams from the canactivate gurard(no active route component)\n             */\n            queryParams = (options && options.queryParams) || this.$security.getRedirectedRouteQueryParams();\n            queryParams = this.$security.getQueryString(queryParams);\n            queryParams = queryParams ? '?' + queryParams : '';\n\n            const redirectPage = this.$security.getCurrentRoutePage();\n            const homePage = getWmProjectProperties().homePage;\n            if (redirectPage && (redirectPage !== homePage || !!queryParams)) {\n                page = '?redirectPage=' + encodeURIComponent(redirectPage);\n            }\n\n            // showing a redirecting message\n            document.body.textContent = get(this.getAppLocale(), ['MESSAGE_LOGIN_REDIRECTION']) || 'Redirecting to sso login...';\n            // appending redirect to page and page params\n            const ssoUrl = this.getDeployedURL() + SSO_URL + page + queryParams;\n            /*\n             * remove iFrame when redirected to IdP login page.\n             * this is being done as IDPs do not allow to get themselves loaded into iFrames.\n             * remove-toolbar has been assigned with a window name WM_PREVIEW_WINDOW, check if the iframe is our toolbar related and\n             * safely change the location of the parent toolbar with current url.\n             */\n            if (window.self !== window.top) {\n                try {\n                    if (window.parent && window.location.origin === window.parent.origin){\n                        if(window.parent.name === PREVIEW_WINDOW_NAME) {\n                            window.parent.location.href = window.self.location.href;\n                            window.parent.name = \"\"\n                        }\n                    } else {\n                        window.location.href = ssoUrl\n                    }\n                } catch (error) {\n                    window.location.href = ssoUrl;\n                }\n            } else {\n                window.location.href = ssoUrl;\n            }\n    }\n\n    /**\n     * Handles the app when a XHR request returns 401 response\n     * If no user was logged in before 401 occurred, First time Login is simulated\n     * Else, a session timeout has occurred and the same is simulated\n     * @param page  if provided, represents the page name for which XHR request returned 401, on re-login\n     *              if not provided, a service request returned 401\n     * @param onSuccess success handler\n     * @param onError error handler\n     */\n    handle401(page?, options?) {\n        let sessionTimeoutConfig,\n            sessionTimeoutMethod,\n            loginConfig,\n            loginMethod;\n        const LOGIN_METHOD = {\n                'DIALOG' : 'DIALOG',\n                'PAGE'   : 'PAGE',\n                'SSO'    : 'SSO'\n            };\n\n        const config = this.$security.get();\n        let queryParamsObj = {};\n        loginConfig = config.loginConfig;\n        this.lastLoggedUserId = config.userInfo && config.userInfo.userId;\n        // if user found, 401 was thrown after session time\n        if (config.userInfo && config.userInfo.userName) {\n            config.authenticated = false;\n            sessionTimeoutConfig = loginConfig.sessionTimeout || {'type': LOGIN_METHOD.DIALOG};\n            sessionTimeoutMethod = sessionTimeoutConfig.type.toUpperCase();\n            switch (sessionTimeoutMethod) {\n                case LOGIN_METHOD.DIALOG:\n                    this.showLoginDialog();\n                    break;\n                case LOGIN_METHOD.PAGE:\n                    if (!page) {\n                        page = this.$security.getCurrentRoutePage();\n                    }\n                    queryParamsObj['redirectTo'] = page;\n                    // Adding query params(page params of page being redirected to) to the URL.\n                    queryParamsObj = merge(queryParamsObj, this.$security.getRedirectedRouteQueryParams());\n                    // the redirect page should not be same as session timeout login page\n                    if ( page !== sessionTimeoutConfig.pageName) {\n                        this.$router.navigate([sessionTimeoutConfig.pageName], {queryParams: queryParamsObj});\n                    }\n                    break;\n                case LOGIN_METHOD.SSO:\n                    this.handleSSOLogin(config, options);\n                    break;\n            }\n            this.setLandingPage();\n        } else {\n            // if no user found, 401 was thrown for first time login\n            loginMethod = loginConfig.type.toUpperCase();\n            switch (loginMethod) {\n                case LOGIN_METHOD.DIALOG:\n                    // Through loginDialog, user will remain in the current state and failed calls will be executed post login through LoginActionService.\n                    // NOTE: user will be redirected to respective landing page only if dialog is opened manually(not through a failed 401 call).\n                    this.noRedirect(true);\n                    this.showLoginDialog();\n                    break;\n                case LOGIN_METHOD.PAGE:\n                    // do not provide redirectTo page if fetching HOME page resulted 401\n                    // on app load, by default Home page is loaded\n                    page = this.$security.getRedirectPage(config, page);\n                    queryParamsObj['redirectTo'] = page;\n                    const extraQueryParams = (options && options.queryParams) || this.$security.getRedirectedRouteQueryParams();\n                    queryParamsObj = merge(queryParamsObj, extraQueryParams);\n                    this.$router.navigate([loginConfig.pageName], {queryParams: queryParamsObj});\n                    this.$app.landingPageName = loginConfig.pageName;\n                    break;\n                case LOGIN_METHOD.SSO:\n                    this.handleSSOLogin(config, options);\n                    break;\n            }\n        }\n    }\n\n    /**\n     * Updates data dependent on logged in user\n     * Reloads security config, metadata\n     * Updates the loggedInUserVariable\n     * @returns {Promise<void>}\n     */\n    reloadAppData() {\n        return this.loadSecurityConfig(true).then(() => {\n            return this.loadMetadata().then(() => {\n                return this.updateLoggedInUserVariable().then((config) => {\n                    return Promise.resolve(this.beforeAppReady())\n                        .then(() => Promise.resolve(config));\n                })\n            });\n        });\n    }\n\n    noRedirect(value?: boolean) {\n        if (isUndefined(value)) {\n            return this._noRedirect;\n        }\n\n        this._noRedirect = value;\n        return this._noRedirect;\n    }\n\n    /**\n     * invokes session failure requests\n     */\n    executeSessionFailureRequests() {\n        this.$http.executeSessionFailureRequests();\n    }\n\n    pushToSessionFailureRequests(callback) {\n        this.$http.pushToSessionFailureQueue(callback);\n    }\n\n    public getDeployedURL() {\n        return this.$app.deployedUrl ? this.$app.deployedUrl : $rootScope.project.deployedUrl;\n    }\n\n    /**\n     * Fetches the customurlscheme for a mobile app\n     * which is used for redirection back to the app from browser in implicit oAuth flow\n     * @returns {string}\n     */\n    public getCustomUrlScheme() {\n        return this.$app.customUrlScheme;\n    }\n\n    notify(eventName, data) {\n        this.$app.notify(eventName, data);\n    }\n\n    subscribe(eventName, data) {\n        return this.$app.subscribe(eventName, data);\n    }\n\n    getActivePage() {\n        return this.$app.activePage;\n    }\n\n    getAppLocale() {\n        return this.$app.appLocale;\n    }\n\n    getSelectedLocale() {\n        return this.$i18n.getSelectedLocale();\n    }\n\n    notifyApp(template, type, title?) {\n        this.$app.notifyApp(template, type, title);\n    }\n\n    /**\n     * Triggers the onBeforeService method defined in app.js of the app\n     * @param requestParams\n     */\n    appOnBeforeServiceCall(requestParams: any) {\n        return triggerFn(this.$app.onBeforeServiceCall, requestParams);\n    }\n\n    /**\n     * Triggers the onServiceSuccess method defined in app.js of the app\n     * @param data\n     * @param xhrObj\n     */\n    appOnServiceSuccess(data: any, xhrObj: any) {\n        return triggerFn(this.$app.onServiceSuccess, data, xhrObj);\n    }\n\n    /**\n     * Triggers the onServiceError method defined in app.js of the app\n     * @param data\n     * @param xhrOb\n     */\n    appOnServiceError(data: any, xhrOb?: any) {\n        return triggerFn(this.$app.onServiceError, data, xhrOb);\n    }\n\n    /**\n     * Triggers the appVariablesReady method defined in app.js of the app\n     */\n    appVariablesReady() {\n        triggerFn(this.$app.onAppVariablesReady);\n    }\n\n    /**\n     * Triggers the onBeforeAppReady method defined in app.js of the app\n     */\n    beforeAppReady() {\n        return triggerFn(this.$app.onBeforeAppReady);\n    }\n\n    /**\n     * Returns the pipe based on the input\n     */\n    getPipe(pipe) {\n        if (pipe === 'date') {\n            return this.$datePipe;\n        }\n    }\n\n    private setLandingPage() {\n        return this.$security.getPageByLoggedInUser().then(p => this.$app.landingPageName = <string> p);\n    }\n\n    /**\n     * return true if prefab type app\n     * @returns {boolean}\n     */\n    isPrefabType() {\n        return this.$app.isPrefabType;\n    }\n\n    /**\n     * return true if template bundle type app\n     * @returns {boolean}\n     */\n    isTemplateBundleType() {\n        return this.$app.isTemplateBundleType;\n    }\n\n    postMessage(content) {\n        window.top.postMessage(content, '*');\n    }\n\n    showTemplate(idx) {\n        const template = this.templates[idx];\n        // scope.activeTemplateIndex = idx;\n        this.$router.navigate([template.id]);\n    }\n    postTemplateBundleInfo() {\n\n        window.onmessage = (evt) => {\n            const msgData = evt.data;\n\n            if (!isObject(msgData)) {\n                return;\n            }\n\n            // @ts-ignore\n            const key = msgData.key;\n\n            switch (key) {\n                case POST_MESSAGES.HIDE_TEMPLATES_SHOW_CASE:\n                    // scope.hideShowCase = true;\n                    break;\n                case POST_MESSAGES.SELECT_TEMPLATE:\n                    // @ts-ignore\n                    this.showTemplate(msgData.templateIndex);\n                    break;\n            }\n        };\n\n        setTimeout(() => {\n            this.postMessage({key: POST_MESSAGES.ON_LOAD});\n        });\n\n        return fetchContent('json', './config.json', true, response => {\n            this.templates = [];\n            if (!response.error) {\n                this.templates = response.templates;\n                this.postMessage({'key': POST_MESSAGES.TEMPLATEBUNDLE_CONFIG, 'config': response});\n            }\n        });\n    }\n\n    postAppTypeInfo() {\n        if (this.isTemplateBundleType()) {\n            return this.postTemplateBundleInfo();\n        }\n    }\n\n    initAppModes(): void {\n        // get modes from local storage\n        let storedModes = getModesFromLocalStorage();\n\n        // Apply restored modes\n        this.$app.setMode(storedModes);\n\n        // Listener for postMessage-based mode changes\n        // MEMORY LEAK FIX: Store bound function reference for cleanup\n        this.windowMessageListener = (event) => {\n            const { key, modes, shouldPersist } = event.data || {};\n            if (key === 'switch-mode' && modes) {\n                this.$app.setMode(modes, !shouldPersist);\n            }\n        };\n        window.addEventListener('message', this.windowMessageListener);\n    }\n\n    ngOnDestroy() {\n        // MEMORY LEAK FIX: Unsubscribe from all app subscriptions\n        this.appSubscriptions.forEach(unsubscribe => {\n            if (unsubscribe) {\n                unsubscribe();\n            }\n        });\n        this.appSubscriptions = [];\n\n        // MEMORY LEAK FIX: Unsubscribe from session timeout\n        if (this.sessionTimeoutUnsubscribe) {\n            this.sessionTimeoutUnsubscribe();\n            this.sessionTimeoutUnsubscribe = null;\n        }\n\n        // MEMORY LEAK FIX: Remove window message listener\n        if (this.windowMessageListener) {\n            window.removeEventListener('message', this.windowMessageListener);\n            this.windowMessageListener = null;\n        }\n\n        // MEMORY LEAK FIX: Clear references\n        this.templates = null;\n        this.lastLoggedUserId = null;\n    }\n}\n"]}