@propmix/profet-common-header 3.5.0 → 3.6.0-beta.0

package/README.md

@@ -95,8 +95,53 @@ Use the configuration option in the app.module.ts file
 
 ## Input
 
-INACTIVITY_LIMIT - Provide the value in milliseconds. The default value is 30 minutes
+| Input | Type | Description |
+|-------|------|-------------|
+| `INACTIVITY_LIMIT` | `number` | Inactivity timeout in milliseconds. Default is 30 minutes. |
+| `appLogoNavigationUrl` | `string` | URL to navigate when the app logo is clicked. Overrides the value set in `HeaderConfig` if provided. |
+| `disableAppMenu` | `boolean` | Disables the app menu when `true`. Overrides the value set in `HeaderConfig` if provided. |
+
+Example:
+```html
+        <lib-header
+            [appLogoNavigationUrl]="'https://example.com'"
+            [disableAppMenu]="true">
+        </lib-header>
+```
+
+## Outputs
+
+`logoutEvent` - Emitted during the logout process. It outputs an object with details about why the logout happened and its current lifecycle stage:
+
+*Example:*
+
+*HTML* -
+
+        <lib-header (logoutEvent)="handleLogout($event)"></lib-header>
+
+*Typescript* -
 
+        import { LogoutReason, LogoutStatus } from '@propmix/profet-common-header';
+
+        handleLogout(event: { reason: LogoutReason, status: LogoutStatus }) {
+            if (event.status === LogoutStatus.INITIATED) {
+                // Logout has started - clean up app state, save data, etc.
+                // e.g. clear local storage, cancel pending requests
+            }
+
+            if (event.status === LogoutStatus.COMPLETED) {
+                // Sign out is complete, redirect is about to happen
+            }
+
+            if (event.reason === LogoutReason.SESSION_TIMEOUT) {
+                // Triggered by inactivity timer
+            }
+
+            if (event.reason === LogoutReason.USER_INITIATED) {
+                // Triggered by user clicking the logout button
+            }
+        }
+        
 ### Optional Observables
 
 The library provides two observables that can be consumed by the application if needed. However, using these observables is not mandatory.

package/esm2020/lib/api-endpoints.def.mjs

@@ -0,0 +1,14 @@
+export class EndPoints {
+}
+EndPoints.API_URLS = {
+    getAppsApi: '/api/company/getAllUserAccessApplications',
+    getCompanyApplications: '/api/company/getCompanyApplications',
+    getUserCompanies: '/api/profile/getUserCompanies',
+    updateUserCompany: '/api/company/updateUserCompany',
+    fetchCompanyProfile: '/fetchCompanyProfile',
+    getUserDetails: '/api/user/getUserInformation',
+    getCompanyList: '/api/user/getUserCompanies',
+    getAppMenu: '/api/user/getAppMenu',
+    updateLastAccessedApplication: '/api/user/updateLastAccessedApplication'
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBpLWVuZHBvaW50cy5kZWYuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9jb21tb24taGVhZGVyL3NyYy9saWIvYXBpLWVuZHBvaW50cy5kZWYudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxPQUFPLFNBQVM7O0FBQ0osa0JBQVEsR0FBRztJQUNyQixVQUFVLEVBQUUsMkNBQTJDO0lBQ3ZELHNCQUFzQixFQUFFLHFDQUFxQztJQUM3RCxnQkFBZ0IsRUFBRSwrQkFBK0I7SUFDakQsaUJBQWlCLEVBQUUsZ0NBQWdDO0lBQ25ELG1CQUFtQixFQUFFLHNCQUFzQjtJQUMzQyxjQUFjLEVBQUUsOEJBQThCO0lBRTlDLGNBQWMsRUFBRSw0QkFBNEI7SUFDNUMsVUFBVSxFQUFFLHNCQUFzQjtJQUNsQyw2QkFBNkIsRUFBRSx5Q0FBeUM7Q0FDM0UsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjbGFzcyBFbmRQb2ludHMge1xuICAgIHB1YmxpYyBzdGF0aWMgQVBJX1VSTFMgPSB7XG4gICAgICAgIGdldEFwcHNBcGk6ICcvYXBpL2NvbXBhbnkvZ2V0QWxsVXNlckFjY2Vzc0FwcGxpY2F0aW9ucycsXG4gICAgICAgIGdldENvbXBhbnlBcHBsaWNhdGlvbnM6ICcvYXBpL2NvbXBhbnkvZ2V0Q29tcGFueUFwcGxpY2F0aW9ucycsXG4gICAgICAgIGdldFVzZXJDb21wYW5pZXM6ICcvYXBpL3Byb2ZpbGUvZ2V0VXNlckNvbXBhbmllcycsICAvLyBUT0RPIC0tIE5lZWRzIHRvIHJlbW92ZVxuICAgICAgICB1cGRhdGVVc2VyQ29tcGFueTogJy9hcGkvY29tcGFueS91cGRhdGVVc2VyQ29tcGFueScsXG4gICAgICAgIGZldGNoQ29tcGFueVByb2ZpbGU6ICcvZmV0Y2hDb21wYW55UHJvZmlsZScsXG4gICAgICAgIGdldFVzZXJEZXRhaWxzOiAnL2FwaS91c2VyL2dldFVzZXJJbmZvcm1hdGlvbicsXG5cbiAgICAgICAgZ2V0Q29tcGFueUxpc3Q6ICcvYXBpL3VzZXIvZ2V0VXNlckNvbXBhbmllcycsXG4gICAgICAgIGdldEFwcE1lbnU6ICcvYXBpL3VzZXIvZ2V0QXBwTWVudScsXG4gICAgICAgIHVwZGF0ZUxhc3RBY2Nlc3NlZEFwcGxpY2F0aW9uOiAnL2FwaS91c2VyL3VwZGF0ZUxhc3RBY2Nlc3NlZEFwcGxpY2F0aW9uJ1xuICAgIH1cbn0iXX0=

package/esm2020/lib/api-gateway.service.mjs

@@ -0,0 +1,69 @@
+import { HttpClient } from '@angular/common/http';
+import { Injectable, inject } from '@angular/core';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export class ApiGatewayService {
+    constructor() {
+        this._http = inject(HttpClient);
+    }
+    doGet(url, config) {
+        return new Observable(observer => {
+            if (!config) {
+                config = {
+                    isLoaderHidden: false
+                };
+            }
+            ;
+            let headers;
+            if (config.isUnauthorized) {
+                headers = {
+                    skip: "true"
+                };
+            }
+            // this._loaderService.requestStarted(config);
+            this._http
+                .get(url, { headers: headers })
+                .subscribe({
+                next: (data) => {
+                    // this._loaderService.requestEnded();
+                    observer.next(data);
+                    observer.complete();
+                },
+                error: (error) => {
+                    // this.handleError(error, config, observer);
+                }
+            });
+        });
+    }
+    doPost(url, req_body) {
+        return new Observable(observer => {
+            let headers;
+            this._http
+                .post(url, req_body, { headers: headers })
+                .subscribe({
+                next: (data) => {
+                    if (data && data.hasOwnProperty('status')) {
+                        observer.next(data);
+                        observer.complete();
+                    }
+                    else {
+                        observer.next(data);
+                        observer.complete();
+                    }
+                },
+                error: (error) => {
+                    // this.handleError(error, config, observer);
+                }
+            });
+        });
+    }
+}
+ApiGatewayService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ApiGatewayService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+ApiGatewayService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ApiGatewayService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ApiGatewayService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/common-header.interface.mjs

@@ -0,0 +1,11 @@
+export var LogoutReason;
+(function (LogoutReason) {
+    LogoutReason["USER_INITIATED"] = "USER_INITIATED";
+    LogoutReason["SESSION_TIMEOUT"] = "SESSION_TIMEOUT";
+})(LogoutReason || (LogoutReason = {}));
+export var LogoutStatus;
+(function (LogoutStatus) {
+    LogoutStatus["INITIATED"] = "INITIATED";
+    LogoutStatus["COMPLETED"] = "COMPLETED";
+})(LogoutStatus || (LogoutStatus = {}));
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2022 → esm2020}/lib/common-header.module.mjs

@@ -21,39 +21,39 @@ import { SessionExpiryInfoComponent } from './session-expiry-info/session-expiry
 import { MillisecondsToMinutePipe } from './pipes/milliseconds-to-minute.pipe';
 import * as i0 from "@angular/core";
 export class CommonHeaderModule {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CommonHeaderModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.12", ngImport: i0, type: CommonHeaderModule, declarations: [HeaderComponent, CompanySwitchWarningComponent, ActiveRoutePipe, SessionExpiryInfoComponent, MillisecondsToMinutePipe], imports: [CommonModule,
-            MatToolbarModule,
-            MatIconModule,
-            HttpClientModule,
-            MatButtonModule,
-            MatSidenavModule,
-            MatMenuModule,
-            MatSnackBarModule,
-            MatTooltipModule,
-            MatDividerModule,
-            MatListModule,
-            MatFormFieldModule,
-            MatSelectModule,
-            ReactiveFormsModule,
-            MatDialogModule], exports: [HeaderComponent] }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CommonHeaderModule, providers: [TitleCasePipe, LowerCasePipe], imports: [CommonModule,
-            MatToolbarModule,
-            MatIconModule,
-            HttpClientModule,
-            MatButtonModule,
-            MatSidenavModule,
-            MatMenuModule,
-            MatSnackBarModule,
-            MatTooltipModule,
-            MatDividerModule,
-            MatListModule,
-            MatFormFieldModule,
-            MatSelectModule,
-            ReactiveFormsModule,
-            MatDialogModule] }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CommonHeaderModule, decorators: [{
+CommonHeaderModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: CommonHeaderModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+CommonHeaderModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.10", ngImport: i0, type: CommonHeaderModule, declarations: [HeaderComponent, CompanySwitchWarningComponent, ActiveRoutePipe, SessionExpiryInfoComponent, MillisecondsToMinutePipe], imports: [CommonModule,
+        MatToolbarModule,
+        MatIconModule,
+        HttpClientModule,
+        MatButtonModule,
+        MatSidenavModule,
+        MatMenuModule,
+        MatSnackBarModule,
+        MatTooltipModule,
+        MatDividerModule,
+        MatListModule,
+        MatFormFieldModule,
+        MatSelectModule,
+        ReactiveFormsModule,
+        MatDialogModule], exports: [HeaderComponent] });
+CommonHeaderModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: CommonHeaderModule, providers: [TitleCasePipe, LowerCasePipe], imports: [CommonModule,
+        MatToolbarModule,
+        MatIconModule,
+        HttpClientModule,
+        MatButtonModule,
+        MatSidenavModule,
+        MatMenuModule,
+        MatSnackBarModule,
+        MatTooltipModule,
+        MatDividerModule,
+        MatListModule,
+        MatFormFieldModule,
+        MatSelectModule,
+        ReactiveFormsModule,
+        MatDialogModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: CommonHeaderModule, decorators: [{
             type: NgModule,
             args: [{
                     declarations: [HeaderComponent, CompanySwitchWarningComponent, ActiveRoutePipe, SessionExpiryInfoComponent, MillisecondsToMinutePipe],
@@ -78,4 +78,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
                     exports: [HeaderComponent],
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/common-header.service.mjs

@@ -0,0 +1,177 @@
+import { Inject, inject, Injectable } from '@angular/core';
+import { MatDialog } from '@angular/material/dialog';
+import { reduce, ReplaySubject } from 'rxjs';
+import { APP_DOMAIN } from '../public-api';
+import { EndPoints } from './api-endpoints.def';
+import { ApiGatewayService } from './api-gateway.service';
+import { SessionExpiryInfoComponent } from './session-expiry-info/session-expiry-info.component';
+import { Utilities } from './utils/Utilities';
+import * as i0 from "@angular/core";
+export class CommonHeaderService {
+    constructor(config) {
+        this.config = config;
+        this.SESSION_EXPIRED_KEY = 'session_expired';
+        this.LAST_ACTIVE_SESSION_KEY = 'lastActiveSessionTime';
+        this.baseUrl = '';
+        this.isSessionExpiryDialogOpen = false;
+        this._apiGatewayService = inject(ApiGatewayService);
+        this._dialog = inject(MatDialog);
+        this.menuStateSubject = new ReplaySubject(1);
+        this.activeMenuList$ = this.menuStateSubject.asObservable();
+        this.companyListSubject = new ReplaySubject(1);
+        this.companyList$ = this.companyListSubject.asObservable();
+        this.headerConfig = config;
+        this.baseUrl = config.apiUrl;
+    }
+    setMenuState(data) {
+        this.menuStateSubject.next(data);
+    }
+    setCompanyList(data) {
+        this.companyListSubject.next(data);
+    }
+    obtainDataByUrl(url) {
+        return this._apiGatewayService.doGet(url);
+    }
+    openSessionExpireInfo(sessioninfo) {
+        let info = {};
+        if (sessioninfo) {
+            info = sessioninfo;
+        }
+        this.isSessionExpiryDialogOpen = true;
+        this._dialog.open(SessionExpiryInfoComponent, { data: sessioninfo });
+    }
+    getDomainInfo() {
+        let dom = document.location.host.split('.');
+        let domainInfo = APP_DOMAIN.find(x => x.domain === dom[0]);
+        if (domainInfo) {
+            return domainInfo;
+        }
+        // Check if the second part of the domain exists before using it
+        domainInfo = dom[1] ? APP_DOMAIN.find(x => x.domain === dom[1]) : undefined;
+        return domainInfo || undefined;
+    }
+    getApps() {
+        let url = `${this.baseUrl + EndPoints.API_URLS.getAppsApi}`;
+        return this._apiGatewayService.doGet(url);
+    }
+    getCompanyApplications() {
+        let url = `${this.baseUrl + EndPoints.API_URLS.getCompanyApplications}`;
+        return this._apiGatewayService.doGet(url);
+    }
+    // TODO -- need to remove
+    getUserCompanies() {
+        let url = `${this.baseUrl + EndPoints.API_URLS.getUserCompanies}`;
+        return this._apiGatewayService.doGet(url);
+    }
+    updateUserCompany(reqBody) {
+        let url = `${this.baseUrl + EndPoints.API_URLS.updateUserCompany}`;
+        return this._apiGatewayService.doPost(url, reqBody);
+    }
+    fetchCompanyProfile(reqBody) {
+        let config = {
+            isUnauthorized: true
+        };
+        let url = `${this.baseUrl + EndPoints.API_URLS.fetchCompanyProfile + '?' + Utilities.convertObjectToQueryString(reqBody)}`;
+        return this._apiGatewayService.doGet(url, config).pipe(reduce((acc, res) => {
+            if (res?.data) {
+                acc = res.data;
+            }
+            return acc;
+        }, {}));
+    }
+    getUserDetails() {
+        let url = `${this.baseUrl + EndPoints.API_URLS.getUserDetails}`;
+        return this._apiGatewayService.doGet(url);
+    }
+    getCompanyList() {
+        let url = `${this.baseUrl + EndPoints.API_URLS.getCompanyList}`;
+        return this._apiGatewayService.doGet(url).pipe(reduce((acc, res) => {
+            if (res?.data?.companies) {
+                acc = res?.data?.companies;
+            }
+            return acc;
+        }, {}));
+    }
+    getMenuList() {
+        let url = `${this.baseUrl + EndPoints.API_URLS.getAppMenu}`;
+        return this._apiGatewayService.doGet(url).pipe(reduce((acc, res) => {
+            if (res?.data?.AppMenu) {
+                acc = res?.data?.AppMenu;
+            }
+            return acc;
+        }, {}));
+    }
+    updateLastAccessedApplication(reqBody) {
+        let url = `${this.baseUrl + EndPoints.API_URLS.updateLastAccessedApplication}`;
+        return this._apiGatewayService.doPost(url, reqBody);
+    }
+    /**
+     * Helper to get the root domain (e.g. .profet.ai) to share cookies across subdomains/ports.
+     * If on localhost or an IP, it falls back to the hostname.
+     */
+    getRootDomain() {
+        const hostname = window.location.hostname;
+        const parts = hostname.split('.');
+        if (parts.length > 2 && !/^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(hostname)) {
+            // If we have 4+ parts (e.g. app1.local.profet.ai), we want to include the environment (local.profet.ai)
+            // to avoid sharing cookies with app1.dev.profet.ai or app1.profet.ai.
+            if (parts.length > 3) {
+                return '.' + parts.slice(-3).join('.');
+            }
+            // For standard 3 parts (app1.profet.ai), share on .profet.ai
+            return '.' + parts.slice(-2).join('.');
+        }
+        return hostname;
+    }
+    /**
+     * Generates a unique cookie name based on the environment root domain.
+     * e.g. 'lastActive' on .qa.profet.ai -> 'lastActive_qa_profet_ai'
+     * @param name Base cookie name
+     */
+    getSuffixedCookieName(name) {
+        const rootDomain = this.getRootDomain();
+        // Replace dots with underscores to create a clean suffix
+        const suffix = rootDomain.replace(/\./g, '_');
+        return `${name}${suffix}`;
+    }
+    setCookie(name, value, days) {
+        const uniqueName = this.getSuffixedCookieName(name);
+        let expires = "";
+        if (days) {
+            const date = new Date();
+            date.setTime(date.getTime() + (days * 24 * 60 * 60 * 1000));
+            expires = "; expires=" + date.toUTCString();
+        }
+        // Important: set domain to allow sharing across subdomains
+        const domain = "; domain=" + this.getRootDomain();
+        document.cookie = uniqueName + "=" + (value || "") + expires + domain + "; path=/";
+    }
+    getCookie(name) {
+        const uniqueName = this.getSuffixedCookieName(name);
+        const nameEQ = uniqueName + "=";
+        const ca = document.cookie.split(';');
+        for (let i = 0; i < ca.length; i++) {
+            let c = ca[i];
+            while (c.charAt(0) == ' ')
+                c = c.substring(1, c.length);
+            if (c.indexOf(nameEQ) == 0)
+                return c.substring(nameEQ.length, c.length);
+        }
+        return null;
+    }
+    deleteCookie(name) {
+        this.setCookie(name, '', -1);
+    }
+}
+CommonHeaderService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: CommonHeaderService, deps: [{ token: 'headerConfig' }], target: i0.ɵɵFactoryTarget.Injectable });
+CommonHeaderService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: CommonHeaderService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: CommonHeaderService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['headerConfig']
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"common-header.service.js","sourceRoot":"","sources":["../../../../projects/common-header/src/lib/common-header.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, inject, Injectable } from '@angular/core';\nimport { MatDialog } from '@angular/material/dialog';\nimport { reduce, ReplaySubject } from 'rxjs';\nimport { APP_DOMAIN } from '../public-api';\nimport { EndPoints } from './api-endpoints.def';\nimport { ApiGatewayService } from './api-gateway.service';\nimport { AppMenu, Company, HeaderConfig, SessionOutInfo } from './common-header.interface';\nimport { SessionExpiryInfoComponent } from './session-expiry-info/session-expiry-info.component';\nimport { Utilities } from './utils/Utilities';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class CommonHeaderService {\n  public readonly SESSION_EXPIRED_KEY = 'session_expired';\n  public readonly LAST_ACTIVE_SESSION_KEY = 'lastActiveSessionTime';\n\n  private baseUrl: string = '';\n  headerConfig: HeaderConfig;\n  isSessionExpiryDialogOpen = false;\n  private _apiGatewayService = inject(ApiGatewayService);\n  public _dialog = inject(MatDialog);\n\n  private menuStateSubject = new ReplaySubject<AppMenu[] | null>(1);\n  public activeMenuList$ = this.menuStateSubject.asObservable();\n\n  private companyListSubject = new ReplaySubject<Company[] | null>(1);\n  public companyList$ = this.companyListSubject.asObservable();\n\n  constructor(@Inject('headerConfig') private config: HeaderConfig) {\n    this.headerConfig = config;\n    this.baseUrl = config.apiUrl;\n  }\n\n  setMenuState(data: AppMenu[]): void {\n    this.menuStateSubject.next(data);\n  }\n  setCompanyList(data: Company[]): void {\n    this.companyListSubject.next(data);\n  }\n\n  obtainDataByUrl(url: string) {\n    return this._apiGatewayService.doGet(url);\n  }\n\n  openSessionExpireInfo(sessioninfo?: SessionOutInfo) {\n    let info: SessionOutInfo = {};\n    if (sessioninfo) {\n      info = sessioninfo;\n    }\n    this.isSessionExpiryDialogOpen = true;\n    this._dialog.open(SessionExpiryInfoComponent, { data: sessioninfo });\n  }\n\n  getDomainInfo() {\n    let dom = document.location.host.split('.');\n    let domainInfo = APP_DOMAIN.find(x => x.domain === dom[0]);\n    if (domainInfo) {\n      return domainInfo;\n    }\n\n    // Check if the second part of the domain exists before using it\n    domainInfo = dom[1] ? APP_DOMAIN.find(x => x.domain === dom[1]) : undefined;\n    return domainInfo || undefined;\n  }\n\n  getApps() {\n    let url = `${this.baseUrl + EndPoints.API_URLS.getAppsApi}`;\n    return this._apiGatewayService.doGet(url);\n  }\n  getCompanyApplications() {\n    let url = `${this.baseUrl + EndPoints.API_URLS.getCompanyApplications}`;\n    return this._apiGatewayService.doGet(url);\n  }\n\n  // TODO -- need to remove\n  getUserCompanies() {\n    let url = `${this.baseUrl + EndPoints.API_URLS.getUserCompanies}`;\n    return this._apiGatewayService.doGet(url);\n  }\n  updateUserCompany(reqBody: any) {\n    let url = `${this.baseUrl + EndPoints.API_URLS.updateUserCompany}`;\n    return this._apiGatewayService.doPost(url, reqBody);\n  }\n\n  fetchCompanyProfile(reqBody: any) {\n    let config: any = {\n      isUnauthorized: true\n    }\n    let url = `${this.baseUrl + EndPoints.API_URLS.fetchCompanyProfile + '?' + Utilities.convertObjectToQueryString(reqBody)}`;\n    return this._apiGatewayService.doGet(url, config).pipe(\n      reduce((acc, res) => {\n        if (res?.data) {\n          acc = res.data;\n        }\n        return acc;\n      }, {})\n    );\n  }\n  getUserDetails() {\n    let url = `${this.baseUrl + EndPoints.API_URLS.getUserDetails}`;\n    return this._apiGatewayService.doGet(url);\n  }\n\n  getCompanyList() {\n    let url = `${this.baseUrl + EndPoints.API_URLS.getCompanyList}`;\n    return this._apiGatewayService.doGet(url).pipe(\n      reduce((acc, res) => {\n        if (res?.data?.companies) {\n          acc = res?.data?.companies;\n        }\n        return acc;\n      }, {})\n    );\n  }\n  getMenuList() {\n    let url = `${this.baseUrl + EndPoints.API_URLS.getAppMenu}`;\n    return this._apiGatewayService.doGet(url).pipe(\n      reduce((acc, res) => {\n        if (res?.data?.AppMenu) {\n          acc = res?.data?.AppMenu;\n        }\n        return acc;\n      }, {})\n    );\n  }\n\n  updateLastAccessedApplication(reqBody: any) {\n    let url = `${this.baseUrl + EndPoints.API_URLS.updateLastAccessedApplication}`;\n    return this._apiGatewayService.doPost(url, reqBody);\n  }\n\n  /**\n   * Helper to get the root domain (e.g. .profet.ai) to share cookies across subdomains/ports.\n   * If on localhost or an IP, it falls back to the hostname.\n   */\n  public getRootDomain(): string {\n    const hostname = window.location.hostname;\n    const parts = hostname.split('.');\n\n    if (parts.length > 2 && !/^\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}$/.test(hostname)) {\n      // If we have 4+ parts (e.g. app1.local.profet.ai), we want to include the environment (local.profet.ai)\n      // to avoid sharing cookies with app1.dev.profet.ai or app1.profet.ai.\n      if (parts.length > 3) {\n        return '.' + parts.slice(-3).join('.');\n      }\n      // For standard 3 parts (app1.profet.ai), share on .profet.ai\n      return '.' + parts.slice(-2).join('.');\n    }\n    return hostname;\n  }\n\n  /**\n   * Generates a unique cookie name based on the environment root domain.\n   * e.g. 'lastActive' on .qa.profet.ai -> 'lastActive_qa_profet_ai'\n   * @param name Base cookie name\n   */\n  public getSuffixedCookieName(name: string): string {\n    const rootDomain = this.getRootDomain();\n    // Replace dots with underscores to create a clean suffix\n    const suffix = rootDomain.replace(/\\./g, '_');\n    return `${name}${suffix}`;\n  }\n\n  public setCookie(name: string, value: string, days: number) {\n    const uniqueName = this.getSuffixedCookieName(name);\n    let expires = \"\";\n    if (days) {\n      const date = new Date();\n      date.setTime(date.getTime() + (days * 24 * 60 * 60 * 1000));\n      expires = \"; expires=\" + date.toUTCString();\n    }\n    // Important: set domain to allow sharing across subdomains\n    const domain = \"; domain=\" + this.getRootDomain();\n    document.cookie = uniqueName + \"=\" + (value || \"\") + expires + domain + \"; path=/\";\n  }\n\n  public getCookie(name: string): string | null {\n    const uniqueName = this.getSuffixedCookieName(name);\n    const nameEQ = uniqueName + \"=\";\n    const ca = document.cookie.split(';');\n    for (let i = 0; i < ca.length; i++) {\n      let c = ca[i];\n      while (c.charAt(0) == ' ') c = c.substring(1, c.length);\n      if (c.indexOf(nameEQ) == 0) return c.substring(nameEQ.length, c.length);\n    }\n    return null;\n  }\n\n  public deleteCookie(name: string) {\n    this.setCookie(name, '', -1);\n  }\n}\n"]}

package/{esm2022 → esm2020}/lib/company-switch-warning/company-switch-warning.component.mjs

@@ -7,14 +7,14 @@ export class CompanySwitchWarningComponent {
     constructor(comInfo) {
         this.comInfo = comInfo;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CompanySwitchWarningComponent, deps: [{ token: MAT_DIALOG_DATA }], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: CompanySwitchWarningComponent, selector: "lib-company-switch-warning", ngImport: i0, template: "<div class=\"switchCompanyDialog\">\n    <h3 mat-dialog-title class=\"mb-5\">Switch Company</h3>\n    <p class=\"confirmation-msg\">\n        Switching company to <span>{{comInfo?.switchingCompany}}.</span> <br />\n        Are you sure to continue?\n    </p>\n    <mat-dialog-actions class=\"switchCompanyActions\">\n        <button color=\"primary\" mat-button mat-dialog-close>Cancel</button>\n        <button color=\"primary\" class=\"proceedBtn\" mat-flat-button [mat-dialog-close]=\"true\"\n            cdkFocusInitial>Yes, Switch Company</button>\n    </mat-dialog-actions>\n</div>  ", styles: [".switchCompanyDialog{min-width:320px}.switchCompanyDialog h3{padding:0;text-align:center}.switchCompanyDialog p{width:100%;text-align:center;color:#292929}.switchCompanyDialog p span{font-weight:500;color:#000}.switchCompanyActions{text-align:center;display:block}.proceedBtn{color:#fff}.confirmation-msg{font-size:1rem}\n"], dependencies: [{ kind: "component", type: i1.MatButton, selector: "    button[mat-button], button[mat-raised-button], button[mat-flat-button],    button[mat-stroked-button]  ", exportAs: ["matButton"] }, { kind: "directive", type: i2.MatDialogClose, selector: "[mat-dialog-close], [matDialogClose]", inputs: ["aria-label", "type", "mat-dialog-close", "matDialogClose"], exportAs: ["matDialogClose"] }, { kind: "directive", type: i2.MatDialogTitle, selector: "[mat-dialog-title], [matDialogTitle]", inputs: ["id"], exportAs: ["matDialogTitle"] }, { kind: "directive", type: i2.MatDialogActions, selector: "[mat-dialog-actions], mat-dialog-actions, [matDialogActions]", inputs: ["align"] }] }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CompanySwitchWarningComponent, decorators: [{
+CompanySwitchWarningComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: CompanySwitchWarningComponent, deps: [{ token: MAT_DIALOG_DATA }], target: i0.ɵɵFactoryTarget.Component });
+CompanySwitchWarningComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: CompanySwitchWarningComponent, selector: "lib-company-switch-warning", ngImport: i0, template: "<div class=\"switchCompanyDialog\">\n    <h3 mat-dialog-title class=\"mb-5\">Switch Company</h3>\n    <p class=\"confirmation-msg\">\n        Switching company to <span>{{comInfo?.switchingCompany}}.</span> <br />\n        Are you sure to continue?\n    </p>\n    <mat-dialog-actions class=\"switchCompanyActions\">\n        <button color=\"primary\" mat-button mat-dialog-close>Cancel</button>\n        <button color=\"primary\" class=\"proceedBtn\" mat-flat-button [mat-dialog-close]=\"true\"\n            cdkFocusInitial>Yes, Switch Company</button>\n    </mat-dialog-actions>\n</div>  ", styles: [".switchCompanyDialog{min-width:320px}.switchCompanyDialog h3{padding:0;text-align:center}.switchCompanyDialog p{width:100%;text-align:center;color:#292929}.switchCompanyDialog p span{font-weight:500;color:#000}.switchCompanyActions{text-align:center;display:block}.proceedBtn{color:#fff}.confirmation-msg{font-size:1rem}\n"], dependencies: [{ kind: "component", type: i1.MatButton, selector: "    button[mat-button], button[mat-raised-button], button[mat-flat-button],    button[mat-stroked-button]  ", inputs: ["disabled", "disableRipple", "color"], exportAs: ["matButton"] }, { kind: "directive", type: i2.MatDialogClose, selector: "[mat-dialog-close], [matDialogClose]", inputs: ["aria-label", "type", "mat-dialog-close", "matDialogClose"], exportAs: ["matDialogClose"] }, { kind: "directive", type: i2.MatDialogTitle, selector: "[mat-dialog-title], [matDialogTitle]", inputs: ["id"], exportAs: ["matDialogTitle"] }, { kind: "directive", type: i2.MatDialogActions, selector: "[mat-dialog-actions], mat-dialog-actions, [matDialogActions]", inputs: ["align"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: CompanySwitchWarningComponent, decorators: [{
             type: Component,
             args: [{ selector: 'lib-company-switch-warning', template: "<div class=\"switchCompanyDialog\">\n    <h3 mat-dialog-title class=\"mb-5\">Switch Company</h3>\n    <p class=\"confirmation-msg\">\n        Switching company to <span>{{comInfo?.switchingCompany}}.</span> <br />\n        Are you sure to continue?\n    </p>\n    <mat-dialog-actions class=\"switchCompanyActions\">\n        <button color=\"primary\" mat-button mat-dialog-close>Cancel</button>\n        <button color=\"primary\" class=\"proceedBtn\" mat-flat-button [mat-dialog-close]=\"true\"\n            cdkFocusInitial>Yes, Switch Company</button>\n    </mat-dialog-actions>\n</div>  ", styles: [".switchCompanyDialog{min-width:320px}.switchCompanyDialog h3{padding:0;text-align:center}.switchCompanyDialog p{width:100%;text-align:center;color:#292929}.switchCompanyDialog p span{font-weight:500;color:#000}.switchCompanyActions{text-align:center;display:block}.proceedBtn{color:#fff}.confirmation-msg{font-size:1rem}\n"] }]
-        }], ctorParameters: () => [{ type: undefined, decorators: [{
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
                     type: Inject,
                     args: [MAT_DIALOG_DATA]
-                }] }] });
-//# sourceMappingURL=data:application/json;base64,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
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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