@techextensor/tab-sdk 0.0.3 → 0.0.4

package/esm2022/lib/auth/auth.service.mjs

@@ -0,0 +1,95 @@
+import { inject, Injectable } from '@angular/core';
+import { AuthService } from '@techextensor/tab-core-utility';
+import { firstValueFrom } from 'rxjs';
+import * as i0 from "@angular/core";
+export class AuthUtilService {
+    _authService = inject(AuthService);
+    /**
+     * Authenticates a user based on the provided login credentials.
+     *
+     * @param credentials The login credentials.
+     * @returns The response from the server.
+     */
+    async login(credentials) {
+        // Use the firstValueFrom RxJs operator to wait for the observable to complete
+        const response = await firstValueFrom(this._authService.signIn(credentials));
+        return response;
+    }
+    /**
+     * Registers a new tenant based on the provided details.
+     *
+     * @param tenantDetails The tenant details.
+     * @returns The response from the server.
+     */
+    async registerTenant(tenantDetails) {
+        // Use the firstValueFrom RxJs operator to wait for the observable to complete
+        const response = await firstValueFrom(this._authService.registerTenant(tenantDetails));
+        return response;
+    }
+    /**
+     * Registers a new user based on the provided user details.
+     *
+     * @param userDetails The user details.
+     * @param headers Optional headers to pass to the server.
+     * @returns The response from the server.
+     */
+    async registerUser(userDetails, headers) {
+        // Use the firstValueFrom RxJs operator to wait for the observable to complete
+        const response = await firstValueFrom(this._authService.register(userDetails, headers));
+        return response;
+    }
+    /**
+     * Resets a user's password based on the provided reset password credentials.
+     *
+     * @param credentials The reset password credentials.
+     * @returns The response from the server.
+     */
+    async resetPassword(credentials) {
+        // Use the firstValueFrom RxJs operator to wait for the observable to complete
+        const response = await firstValueFrom(this._authService.resetPassword(credentials));
+        return response;
+    }
+    /**
+     * Changes a user's password based on the provided credentials.
+     *
+     * @param credentials The credentials containing the user's current and new password.
+     * @returns The response from the server.
+     */
+    async changePassword(credentials) {
+        // Use the firstValueFrom RxJs operator to wait for the observable to complete
+        const response = await firstValueFrom(this._authService.changePassword(credentials));
+        return response;
+    }
+    /**
+     * Refreshes a user's token based on the provided refresh token details.
+     *
+     * @param tokenDetails The refresh token details.
+     * @returns The response from the server.
+     */
+    async refreshToken(tokenDetails) {
+        // Use the firstValueFrom RxJs operator to wait for the observable to complete
+        const response = await firstValueFrom(this._authService.refreshToken(tokenDetails));
+        return response;
+    }
+    /**
+     * Gets the user details for the provided user details request.
+     *
+     * @param userDetailsRequest The user details request.
+     * @param headers Optional headers to pass to the server.
+     * @returns The response from the server.
+     */
+    async getUserDetails(userDetailsRequest, headers) {
+        // Use the firstValueFrom RxJs operator to wait for the observable to complete
+        const response = await firstValueFrom(this._authService.getUserDetails(userDetailsRequest, headers));
+        return response;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AuthUtilService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AuthUtilService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AuthUtilService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.service.js","sourceRoot":"","sources":["../../../../../projects/tab-sdk/src/lib/auth/auth.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAEH,WAAW,EAOd,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,cAAc,EAAE,MAAM,MAAM,CAAC;;AAKtC,MAAM,OAAO,eAAe;IACP,YAAY,GAAgB,MAAM,CAAC,WAAW,CAAC,CAAC;IAEjE;;;;;OAKG;IACH,KAAK,CAAC,KAAK,CAAC,WAA6B;QACrC,8EAA8E;QAC9E,MAAM,QAAQ,GAAG,MAAM,cAAc,CACjC,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,WAAW,CAAC,CACxC,CAAC;QACF,OAAO,QAAQ,CAAC;IACpB,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,cAAc,CAAC,aAA6B;QAC9C,8EAA8E;QAC9E,MAAM,QAAQ,GAAG,MAAM,cAAc,CACjC,IAAI,CAAC,YAAY,CAAC,cAAc,CAAC,aAAa,CAAC,CAClD,CAAC;QACF,OAAO,QAAQ,CAAC;IACpB,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,YAAY,CAAC,WAAgB,EAAE,OAAgC;QACjE,8EAA8E;QAC9E,MAAM,QAAQ,GAAG,MAAM,cAAc,CACjC,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC,CACnD,CAAC;QACF,OAAO,QAAQ,CAAC;IACpB,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,aAAa,CAAC,WAAqC;QACrD,8EAA8E;QAC9E,MAAM,QAAQ,GAAG,MAAM,cAAc,CACjC,IAAI,CAAC,YAAY,CAAC,aAAa,CAAC,WAAW,CAAC,CAC/C,CAAC;QACF,OAAO,QAAQ,CAAC;IACpB,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,cAAc,CAAC,WAAsC;QACvD,8EAA8E;QAC9E,MAAM,QAAQ,GAAG,MAAM,cAAc,CACjC,IAAI,CAAC,YAAY,CAAC,cAAc,CAAC,WAAW,CAAC,CAChD,CAAC;QACF,OAAO,QAAQ,CAAC;IACpB,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,YAAY,CAAC,YAAiC;QAChD,8EAA8E;QAC9E,MAAM,QAAQ,GAAG,MAAM,cAAc,CACjC,IAAI,CAAC,YAAY,CAAC,YAAY,CAAC,YAAY,CAAC,CAC/C,CAAC;QACF,OAAO,QAAQ,CAAC;IACpB,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,cAAc,CAAC,kBAAsC,EAAE,OAAgC;QACzF,8EAA8E;QAC9E,MAAM,QAAQ,GAAG,MAAM,cAAc,CACjC,IAAI,CAAC,YAAY,CAAC,cAAc,CAAC,kBAAkB,EAAE,OAAO,CAAC,CAChE,CAAC;QACF,OAAO,QAAQ,CAAC;IACpB,CAAC;wGArGQ,eAAe;4GAAf,eAAe,cAFZ,MAAM;;4FAET,eAAe;kBAH3B,UAAU;mBAAC;oBACR,UAAU,EAAE,MAAM;iBACrB","sourcesContent":["import { inject, Injectable } from '@angular/core';\nimport {\n    LoginUserRequest,\n    AuthService,\n    CommonApiResponse,\n    RegisterTenant,\n    ResetPasswordUserRequest,\n    RefreshTokenRequest,\n    UserDetailsRequest,\n    ChangePasswordUserRequest\n} from '@techextensor/tab-core-utility';\nimport { firstValueFrom } from 'rxjs';\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class AuthUtilService {\n    private readonly _authService: AuthService = inject(AuthService);\n\n    /**\n     * Authenticates a user based on the provided login credentials.\n     * \n     * @param credentials The login credentials.\n     * @returns The response from the server.\n     */\n    async login(credentials: LoginUserRequest): Promise<CommonApiResponse> {\n        // Use the firstValueFrom RxJs operator to wait for the observable to complete\n        const response = await firstValueFrom(\n            this._authService.signIn(credentials)\n        );\n        return response;\n    }\n\n    /**\n     * Registers a new tenant based on the provided details.\n     * \n     * @param tenantDetails The tenant details.\n     * @returns The response from the server.\n     */\n    async registerTenant(tenantDetails: RegisterTenant): Promise<CommonApiResponse> {\n        // Use the firstValueFrom RxJs operator to wait for the observable to complete\n        const response = await firstValueFrom(\n            this._authService.registerTenant(tenantDetails)\n        );\n        return response;\n    }\n\n    /**\n     * Registers a new user based on the provided user details.\n     * \n     * @param userDetails The user details.\n     * @param headers Optional headers to pass to the server.\n     * @returns The response from the server.\n     */\n    async registerUser(userDetails: any, headers?: Record<string, string>): Promise<CommonApiResponse> {\n        // Use the firstValueFrom RxJs operator to wait for the observable to complete\n        const response = await firstValueFrom(\n            this._authService.register(userDetails, headers)\n        );\n        return response;\n    }\n\n    /**\n     * Resets a user's password based on the provided reset password credentials.\n     * \n     * @param credentials The reset password credentials.\n     * @returns The response from the server.\n     */\n    async resetPassword(credentials: ResetPasswordUserRequest): Promise<CommonApiResponse> {\n        // Use the firstValueFrom RxJs operator to wait for the observable to complete\n        const response = await firstValueFrom(\n            this._authService.resetPassword(credentials)\n        );\n        return response;\n    }\n\n    /**\n     * Changes a user's password based on the provided credentials.\n     * \n     * @param credentials The credentials containing the user's current and new password.\n     * @returns The response from the server.\n     */\n    async changePassword(credentials: ChangePasswordUserRequest): Promise<CommonApiResponse> {\n        // Use the firstValueFrom RxJs operator to wait for the observable to complete\n        const response = await firstValueFrom(\n            this._authService.changePassword(credentials)\n        );\n        return response;\n    }\n\n    /**\n     * Refreshes a user's token based on the provided refresh token details.\n     * \n     * @param tokenDetails The refresh token details.\n     * @returns The response from the server.\n     */\n    async refreshToken(tokenDetails: RefreshTokenRequest): Promise<CommonApiResponse> {\n        // Use the firstValueFrom RxJs operator to wait for the observable to complete\n        const response = await firstValueFrom(\n            this._authService.refreshToken(tokenDetails)\n        );\n        return response;\n    }\n\n    /**\n     * Gets the user details for the provided user details request.\n     * \n     * @param userDetailsRequest The user details request.\n     * @param headers Optional headers to pass to the server.\n     * @returns The response from the server.\n     */\n    async getUserDetails(userDetailsRequest: UserDetailsRequest, headers?: Record<string, string>): Promise<CommonApiResponse> {\n        // Use the firstValueFrom RxJs operator to wait for the observable to complete\n        const response = await firstValueFrom(\n            this._authService.getUserDetails(userDetailsRequest, headers)\n        );\n        return response;\n    }\n}"]}

package/esm2022/lib/enums/ui.enum.mjs

@@ -0,0 +1,16 @@
+export var ScreenDisplayMode;
+(function (ScreenDisplayMode) {
+    ScreenDisplayMode["Sidebar"] = "sidebar";
+    ScreenDisplayMode["Popup"] = "popup";
+    ScreenDisplayMode["SameTab"] = "sameTab";
+    ScreenDisplayMode["NewTab"] = "newTab";
+    ScreenDisplayMode["NavigationInSameTab"] = "navigationInSameTab";
+    ScreenDisplayMode["NavigationInNewTab"] = "navigationInNewTab";
+})(ScreenDisplayMode || (ScreenDisplayMode = {}));
+export var NotificationType;
+(function (NotificationType) {
+    NotificationType["Success"] = "success";
+    NotificationType["Warning"] = "warning";
+    NotificationType["Error"] = "error";
+})(NotificationType || (NotificationType = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidWkuZW51bS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3RhYi1zZGsvc3JjL2xpYi9lbnVtcy91aS5lbnVtLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBTixJQUFZLGlCQU9YO0FBUEQsV0FBWSxpQkFBaUI7SUFDekIsd0NBQW1CLENBQUE7SUFDbkIsb0NBQWUsQ0FBQTtJQUNmLHdDQUFtQixDQUFBO0lBQ25CLHNDQUFpQixDQUFBO0lBQ2pCLGdFQUEyQyxDQUFBO0lBQzNDLDhEQUF5QyxDQUFBO0FBQzdDLENBQUMsRUFQVyxpQkFBaUIsS0FBakIsaUJBQWlCLFFBTzVCO0FBRUQsTUFBTSxDQUFOLElBQVksZ0JBSVg7QUFKRCxXQUFZLGdCQUFnQjtJQUN4Qix1Q0FBbUIsQ0FBQTtJQUNuQix1Q0FBbUIsQ0FBQTtJQUNuQixtQ0FBZSxDQUFBO0FBQ25CLENBQUMsRUFKVyxnQkFBZ0IsS0FBaEIsZ0JBQWdCLFFBSTNCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGVudW0gU2NyZWVuRGlzcGxheU1vZGUge1xuICAgIFNpZGViYXIgPSAnc2lkZWJhcicsXG4gICAgUG9wdXAgPSAncG9wdXAnLFxuICAgIFNhbWVUYWIgPSAnc2FtZVRhYicsXG4gICAgTmV3VGFiID0gJ25ld1RhYicsXG4gICAgTmF2aWdhdGlvbkluU2FtZVRhYiA9ICduYXZpZ2F0aW9uSW5TYW1lVGFiJyxcbiAgICBOYXZpZ2F0aW9uSW5OZXdUYWIgPSAnbmF2aWdhdGlvbkluTmV3VGFiJ1xufVxuXG5leHBvcnQgZW51bSBOb3RpZmljYXRpb25UeXBlIHtcbiAgICBTdWNjZXNzID0gJ3N1Y2Nlc3MnLFxuICAgIFdhcm5pbmcgPSAnd2FybmluZycsXG4gICAgRXJyb3IgPSAnZXJyb3InXG59XG4iXX0=

package/esm2022/lib/interfaces/ui.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/tab-sdk.service.mjs

@@ -1,17 +1,11 @@
 import { Injectable } from '@angular/core';
-import { DataService } from './data/data.service';
-import { UiService } from './ui/ui.service';
-import { FormService } from './ui/form.service';
-import { AuthService } from './core/auth.service';
-import { UtilsService } from './common/utils.service';
 import { MetadataHelper } from '@techextensor/tab-core-utility';
+import { UiService } from './ui/ui.service';
+import { AuthUtilService } from './auth/auth.service';
 import * as i0 from "@angular/core";
 export class TabSdk {
-    static data;
-    static ui;
-    static form;
     static auth;
-    static utils;
+    static ui;
     static metadataUtils;
     static context;
     /**
@@ -23,20 +17,12 @@ export class TabSdk {
         // external services
         this.context = context;
         // Initialize services
-        this.data = injector.get(DataService);
+        this.auth = injector.get(AuthUtilService);
         this.ui = injector.get(UiService);
-        this.form = injector.get(FormService);
-        this.auth = injector.get(AuthService);
-        this.utils = injector.get(UtilsService);
         this.metadataUtils = injector.get(MetadataHelper);
         // Freeze the global object to prevent modifications
         Object.freeze(this);
         Object.freeze(this.context);
-        Object.freeze(this.data);
-        Object.freeze(this.ui);
-        Object.freeze(this.form);
-        Object.freeze(this.auth);
-        Object.freeze(this.utils);
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TabSdk, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TabSdk, providedIn: 'root' });
@@ -47,4 +33,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
                     providedIn: 'root'
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/ui/ui.service.mjs

@@ -1,6 +1,144 @@
-import { Injectable } from "@angular/core";
+import { Injectable } from '@angular/core';
+import { NotificationType, ScreenDisplayMode } from '../enums/ui.enum';
+import { TabSdk } from '../tab-sdk.service';
 import * as i0 from "@angular/core";
 export class UiService {
+    _eventActionService = TabSdk.context?.EventActionService;
+    _tabUtilsService = TabSdk.context?.TabUtilsService;
+    _confirmationDialogService = TabSdk.context?.ConfirmationDialogService;
+    /**
+     * Open a screen with the given options. The mode determines how the screen is
+     * displayed.
+     *
+     * @param options The options for opening the screen.
+     */
+    openScreen(options) {
+        const { mode, screenId, reqtokens, submission, title, width, height, customClass } = options;
+        switch (mode) {
+            case ScreenDisplayMode.Sidebar:
+                this.showSidebar({ screenId, reqtokens, submission, title, width, height, customClass });
+                break;
+            case ScreenDisplayMode.Popup:
+                this.showDialog({ screenId, reqtokens, submission, title, width, height, customClass });
+                break;
+            case ScreenDisplayMode.SameTab:
+            case ScreenDisplayMode.NavigationInSameTab:
+                this.navigateTo({ screenId, reqtokens });
+                break;
+            case ScreenDisplayMode.NewTab:
+            case ScreenDisplayMode.NavigationInNewTab:
+                this.openInNewTab({ screenId, reqtokens });
+                break;
+        }
+    }
+    /**
+     * Opens a screen in a sidebar.
+     *
+     * @param options The options for opening the sidebar.
+     */
+    showSidebar(options) {
+        const otherConfiguration = {
+            ...(options.title && { title: options.title }),
+            ...(options.width && { width: options.width }),
+            ...(options.height && { height: options.height }),
+            ...(options.customClass && { customClass: options.customClass })
+        };
+        this._eventActionService.openScreen(ScreenDisplayMode.Sidebar, options.screenId, options.reqtokens || undefined, options.submission || undefined, Object.keys(otherConfiguration).length > 0 ? otherConfiguration : undefined);
+    }
+    /**
+     * Opens a screen in a popup dialog.
+     *
+     * @param options The options for opening the dialog.
+     */
+    showDialog(options) {
+        const otherConfiguration = {
+            ...(options.title && { title: options.title }),
+            ...(options.width && { width: options.width }),
+            ...(options.height && { height: options.height }),
+            ...(options.customClass && { customClass: options.customClass })
+        };
+        this._eventActionService.openScreen(ScreenDisplayMode.Popup, options.screenId, options.reqtokens || undefined, options.submission || undefined, Object.keys(otherConfiguration).length > 0 ? otherConfiguration : undefined);
+    }
+    /**
+     * Navigates to a screen within the same tab.
+     *
+     * @param options - The options for navigation, including screenId and optional reqtokens.
+     */
+    navigateTo(options) {
+        this._eventActionService.openScreen(ScreenDisplayMode.NavigationInSameTab, options.screenId, options.reqtokens || undefined);
+    }
+    /**
+     * Navigates to a screen in a new tab.
+     *
+     * @param options The options for navigation, including screenId and optional reqtokens.
+     */
+    openInNewTab(options) {
+        this._eventActionService.openScreen(ScreenDisplayMode.NavigationInNewTab, options.screenId, options.reqtokens || undefined);
+    }
+    /**
+     * Navigates to the specified URL.
+     *
+     * @param url - The URL to navigate to.
+     */
+    navigateToUrl(url) {
+        this._tabUtilsService.navigateToUrl({ Url: url });
+    }
+    /**
+     * Navigates to a specified subdomain using the provided options.
+     *
+     * @param options - The options for navigation, including subDomain, appCode, and url.
+     */
+    navigateToSubdomain(options) {
+        this._tabUtilsService.navigateToUrlWithSubdomain(options);
+    }
+    /**
+     * Show a notification to the user.
+     *
+     * @param options The options for the notification.
+     */
+    notify(options) {
+        this._tabUtilsService.notify(options);
+    }
+    /**
+     * Displays a success notification to the user.
+     *
+     * @param options - The options for the notification, including message, title, and configuration.
+     */
+    showSuccess(options) {
+        this.notify({ ...options, type: NotificationType.Success });
+    }
+    /**
+     * Displays a warning notification to the user.
+     *
+     * @param options - The options for the notification, including message, title, and configuration.
+     */
+    showWarning(options) {
+        this.notify({ ...options, type: NotificationType.Warning });
+    }
+    /**
+     * Displays an error notification to the user.
+     *
+     * @param options - The options for the notification, including message, title, and configuration.
+     */
+    showError(options) {
+        this.notify({ ...options, type: NotificationType.Error });
+    }
+    /**
+     * Displays a confirmation dialog to the user and returns a promise that resolves
+     * to a boolean indicating whether the user confirmed the action.
+     *
+     * @param options - The options for the confirmation dialog, including title, message,
+     * confirmText, cancelText, and visibility of buttons.
+     * @returns A promise that resolves to true if the user confirms, false otherwise.
+     */
+    confirm(options) {
+        return new Promise((resolve) => {
+            this._confirmationDialogService.confirm(options)
+                ?.subscribe((isConfirmed) => {
+                resolve(isConfirmed);
+            });
+        });
+    }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: UiService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: UiService, providedIn: 'root' });
 }
@@ -10,4 +148,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
                     providedIn: 'root'
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidWkuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3RhYi1zZGsvc3JjL2xpYi91aS91aS5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBSzNDLE1BQU0sT0FBTyxTQUFTO3dHQUFULFNBQVM7NEdBQVQsU0FBUyxjQUZOLE1BQU07OzRGQUVULFNBQVM7a0JBSHJCLFVBQVU7bUJBQUM7b0JBQ1IsVUFBVSxFQUFFLE1BQU07aUJBQ3JCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XG5cbkBJbmplY3RhYmxlKHtcbiAgICBwcm92aWRlZEluOiAncm9vdCdcbn0pXG5leHBvcnQgY2xhc3MgVWlTZXJ2aWNlIHt9Il19
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ui.service.js","sourceRoot":"","sources":["../../../../../projects/tab-sdk/src/lib/ui/ui.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport {\n    ScreenOpenOptions,\n    NotificationOptions,\n    ConfirmationDialogOptions,\n    NavigationOptions,\n    BaseNotificationOptions,\n    BaseScreenOptions,\n    NavigateToSubdomainOptions\n} from '../interfaces/ui.interface';\nimport { NotificationType, ScreenDisplayMode } from '../enums/ui.enum';\nimport { TabSdk } from '../tab-sdk.service';\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class UiService {\n    private readonly _eventActionService: any = TabSdk.context?.EventActionService;\n    private readonly _tabUtilsService: any = TabSdk.context?.TabUtilsService;\n    private readonly _confirmationDialogService: any = TabSdk.context?.ConfirmationDialogService;\n\n    /**\n     * Open a screen with the given options. The mode determines how the screen is\n     * displayed.\n     *\n     * @param options The options for opening the screen.\n     */\n    openScreen(options: ScreenOpenOptions): void {\n        const { mode, screenId, reqtokens, submission, title, width, height, customClass } = options;\n\n        switch (mode) {\n            case ScreenDisplayMode.Sidebar:\n                this.showSidebar({ screenId, reqtokens, submission, title, width, height, customClass });\n                break;\n\n            case ScreenDisplayMode.Popup:\n                this.showDialog({ screenId, reqtokens, submission, title, width, height, customClass });\n                break;\n\n            case ScreenDisplayMode.SameTab:\n            case ScreenDisplayMode.NavigationInSameTab:\n                this.navigateTo({ screenId, reqtokens });\n                break;\n\n            case ScreenDisplayMode.NewTab:\n            case ScreenDisplayMode.NavigationInNewTab:\n                this.openInNewTab({ screenId, reqtokens });\n                break;\n        }\n    }\n\n    /**\n     * Opens a screen in a sidebar.\n     *\n     * @param options The options for opening the sidebar.\n     */\n    showSidebar(options: BaseScreenOptions): void {\n        const otherConfiguration = {\n            ...(options.title && { title: options.title }),\n            ...(options.width && { width: options.width }),\n            ...(options.height && { height: options.height }),\n            ...(options.customClass && { customClass: options.customClass })\n        };\n\n        this._eventActionService.openScreen(\n            ScreenDisplayMode.Sidebar,\n            options.screenId,\n            options.reqtokens || undefined,\n            options.submission || undefined,\n            Object.keys(otherConfiguration).length > 0 ? otherConfiguration : undefined\n        );\n    }\n\n    /**\n     * Opens a screen in a popup dialog.\n     *\n     * @param options The options for opening the dialog.\n     */\n    showDialog(options: BaseScreenOptions): void {\n        const otherConfiguration = {\n            ...(options.title && { title: options.title }),\n            ...(options.width && { width: options.width }),\n            ...(options.height && { height: options.height }),\n            ...(options.customClass && { customClass: options.customClass })\n        };\n\n        this._eventActionService.openScreen(\n            ScreenDisplayMode.Popup,\n            options.screenId,\n            options.reqtokens || undefined,\n            options.submission || undefined,\n            Object.keys(otherConfiguration).length > 0 ? otherConfiguration : undefined\n        );\n    }\n\n    /**\n     * Navigates to a screen within the same tab.\n     *\n     * @param options - The options for navigation, including screenId and optional reqtokens.\n     */\n    navigateTo(options: NavigationOptions): void {\n        this._eventActionService.openScreen(\n            ScreenDisplayMode.NavigationInSameTab,\n            options.screenId,\n            options.reqtokens || undefined\n        );\n    }\n\n    /**\n     * Navigates to a screen in a new tab.\n     *\n     * @param options The options for navigation, including screenId and optional reqtokens.\n     */\n    openInNewTab(options: NavigationOptions): void {\n        this._eventActionService.openScreen(\n            ScreenDisplayMode.NavigationInNewTab,\n            options.screenId,\n            options.reqtokens || undefined\n        );\n    }\n\n    /**\n     * Navigates to the specified URL.\n     *\n     * @param url - The URL to navigate to.\n     */\n    navigateToUrl(url: string): void {\n        this._tabUtilsService.navigateToUrl({ Url: url });\n    }\n\n    /**\n     * Navigates to a specified subdomain using the provided options.\n     *\n     * @param options - The options for navigation, including subDomain, appCode, and url.\n     */\n    navigateToSubdomain(options: NavigateToSubdomainOptions): void {\n        this._tabUtilsService.navigateToUrlWithSubdomain(options);\n    }\n\n    /**\n     * Show a notification to the user.\n     *\n     * @param options The options for the notification.\n     */\n    notify(options: NotificationOptions): void {\n        this._tabUtilsService.notify(options);\n    }\n\n    /**\n     * Displays a success notification to the user.\n     *\n     * @param options - The options for the notification, including message, title, and configuration.\n     */\n    showSuccess(options: BaseNotificationOptions): void {\n        this.notify({ ...options, type: NotificationType.Success });\n    }\n\n    /**\n     * Displays a warning notification to the user.\n     *\n     * @param options - The options for the notification, including message, title, and configuration.\n     */\n    showWarning(options: BaseNotificationOptions): void {\n        this.notify({ ...options, type: NotificationType.Warning });\n    }\n\n    /**\n     * Displays an error notification to the user.\n     *\n     * @param options - The options for the notification, including message, title, and configuration.\n     */\n    showError(options: BaseNotificationOptions): void {\n        this.notify({ ...options, type: NotificationType.Error });\n    }\n\n    /**\n     * Displays a confirmation dialog to the user and returns a promise that resolves\n     * to a boolean indicating whether the user confirmed the action.\n     *\n     * @param options - The options for the confirmation dialog, including title, message,\n     * confirmText, cancelText, and visibility of buttons.\n     * @returns A promise that resolves to true if the user confirms, false otherwise.\n     */\n    confirm(options: ConfirmationDialogOptions): Promise<boolean> {\n        return new Promise((resolve) => {\n            this._confirmationDialogService.confirm(options)\n                ?.subscribe((isConfirmed: boolean) => {\n                    resolve(isConfirmed);\n                });\n        });\n    }\n}"]}