@techextensor/tab-sdk 0.0.4 → 0.0.7

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

@@ -2,27 +2,75 @@ import { Injectable } from '@angular/core';
 import { MetadataHelper } from '@techextensor/tab-core-utility';
 import { UiService } from './ui/ui.service';
 import { AuthUtilService } from './auth/auth.service';
+import { FormService } from './ui/form.service';
+import { TransitionService } from './workflow/transition.service';
+import { AppService } from './app/app.service';
+import { FileService } from './app/file.service';
+import { ReportService } from './app/report.service';
+import { ReleaseService } from './app/release.service';
+import { AnalyticsService } from './app/analytics.service';
+import { TranslatorService } from './app/translator.service';
+import { CrudService } from './crud/crud.service';
+import { HttpService } from './http/http.service';
+import { StoreService } from './store/store.service';
+import { UtilService } from './util/util.service';
 import * as i0 from "@angular/core";
 export class TabSdk {
+    static app;
     static auth;
     static ui;
+    static form;
+    static transition;
     static metadataUtils;
-    static context;
+    static file;
+    static report;
+    static release;
+    static analytics;
+    static translator;
+    static crud;
+    static http;
+    static store;
+    static util;
     /**
      * Initialize the SDK with necessary services
      */
     static init(injector, context) {
         // Expose to window for global access if needed
         window.TabSdk = TabSdk;
-        // external services
-        this.context = context;
         // Initialize services
+        this.app = injector.get(AppService);
         this.auth = injector.get(AuthUtilService);
         this.ui = injector.get(UiService);
+        this.form = injector.get(FormService);
+        this.transition = injector.get(TransitionService);
         this.metadataUtils = injector.get(MetadataHelper);
+        this.file = injector.get(FileService);
+        this.report = injector.get(ReportService);
+        this.release = injector.get(ReleaseService);
+        this.analytics = injector.get(AnalyticsService);
+        this.translator = injector.get(TranslatorService);
+        this.crud = injector.get(CrudService);
+        this.http = injector.get(HttpService);
+        this.store = injector.get(StoreService);
+        // Initialize util service with context
+        const utilService = injector.get(UtilService);
+        this.util = utilService.init(context);
         // Freeze the global object to prevent modifications
         Object.freeze(this);
-        Object.freeze(this.context);
+        Object.freeze(this.app);
+        Object.freeze(this.auth);
+        Object.freeze(this.ui);
+        Object.freeze(this.form);
+        Object.freeze(this.transition);
+        Object.freeze(this.file);
+        Object.freeze(this.report);
+        Object.freeze(this.release);
+        Object.freeze(this.analytics);
+        Object.freeze(this.translator);
+        Object.freeze(this.crud);
+        Object.freeze(this.http);
+        Object.freeze(this.store);
+        Object.freeze(this.util);
     }
     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' });
@@ -33,4 +81,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,{"version":3,"file":"tab-sdk.service.js","sourceRoot":"","sources":["../../../../projects/tab-sdk/src/lib/tab-sdk.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Injector } from '@angular/core';\nimport { MetadataHelper } from '@techextensor/tab-core-utility';\nimport { UiService } from './ui/ui.service';\nimport { AuthUtilService } from './auth/auth.service';\nimport { FormService } from './ui/form.service';\nimport { TransitionService } from './workflow/transition.service';\nimport { AppService } from './app/app.service';\nimport { FileService } from './app/file.service';\nimport { ReportService } from './app/report.service';\nimport { ReleaseService } from './app/release.service';\nimport { AnalyticsService } from './app/analytics.service';\nimport { TranslatorService } from './app/translator.service';\nimport { CrudService } from './crud/crud.service';\nimport { HttpService } from './http/http.service';\nimport { StoreService } from './store/store.service';\nimport { UtilService } from './util/util.service';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class TabSdk {\n  public static app: AppService;\n  public static auth: AuthUtilService;\n  public static ui: UiService;\n  public static form: FormService;\n  public static transition: TransitionService;\n  public static metadataUtils: MetadataHelper;\n  public static file: FileService;\n  public static report: ReportService;\n  public static release: ReleaseService;\n  public static analytics: AnalyticsService;\n  public static translator: TranslatorService;\n  public static crud: CrudService;\n  public static http: HttpService;\n  public static store: StoreService;\n  public static util: any;\n\n\n  /**\n   * Initialize the SDK with necessary services\n   */\n  public static init(injector: Injector, context: any): void {\n    // Expose to window for global access if needed\n    (window as any).TabSdk = TabSdk;\n\n    // Initialize services\n    this.app = injector.get(AppService);\n    this.auth = injector.get(AuthUtilService);\n    this.ui = injector.get(UiService);\n    this.form = injector.get(FormService);\n    this.transition = injector.get(TransitionService);\n    this.metadataUtils = injector.get(MetadataHelper);\n    this.file = injector.get(FileService);\n    this.report = injector.get(ReportService);\n    this.release = injector.get(ReleaseService);\n    this.analytics = injector.get(AnalyticsService);\n    this.translator = injector.get(TranslatorService);\n    this.crud = injector.get(CrudService);\n    this.http = injector.get(HttpService);\n    this.store = injector.get(StoreService);\n\n    // Initialize util service with context\n    const utilService = injector.get(UtilService);\n    this.util = utilService.init(context);\n\n    // Freeze the global object to prevent modifications\n    Object.freeze(this);\n    \n    Object.freeze(this.app);\n    Object.freeze(this.auth);\n    Object.freeze(this.ui);\n    Object.freeze(this.form);\n    Object.freeze(this.transition);\n    Object.freeze(this.file);\n    Object.freeze(this.report);\n    Object.freeze(this.release);\n    Object.freeze(this.analytics);\n    Object.freeze(this.translator);\n    Object.freeze(this.crud);\n    Object.freeze(this.http);\n    Object.freeze(this.store);\n    Object.freeze(this.util);\n  }\n}"]}

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

@@ -0,0 +1,79 @@
+import { inject, Injectable } from '@angular/core';
+import { TabFormioService, TemplateHelper } from '@techextensor/tab-core-utility';
+import { firstValueFrom } from 'rxjs';
+import * as i0 from "@angular/core";
+export class FormService {
+    _tabFormioService = inject(TabFormioService);
+    _templateHelper = inject(TemplateHelper);
+    /**
+     * Retrieves a screen by its ID.
+     *
+     * @param screenId The ID of the screen to retrieve.
+     * @param config Optional configuration object for the request.
+     * @returns A promise of the response from the server.
+     */
+    async getScreen(screenId, config) {
+        const response = await firstValueFrom(this._tabFormioService.getScreen(screenId, config));
+        return response;
+    }
+    /**
+     * Retrieves the data for a screen by its ID.
+     *
+     * @param screenId The ID of the screen to retrieve the data for.
+     * @param requestPayload The request payload to send to the server.
+     * @returns A promise of the response from the server.
+     */
+    async getScreenData(screenId, requestPayload) {
+        // Send the request to the server and get the response.
+        const response = await firstValueFrom(this._tabFormioService.getScreenData(screenId, requestPayload));
+        // Return the response from the server.
+        return response;
+    }
+    /**
+     * Processes a request using the provided request payload.
+     *
+     * @param requestPayload The payload to be processed.
+     * @returns A promise of the response from the server.
+     */
+    async processRequest(requestPayload) {
+        // Send the request payload to the server and await the response.
+        const response = await firstValueFrom(this._tabFormioService.processRequest(requestPayload));
+        // Return the server's response.
+        return response;
+    }
+    /**
+     * Builds Form.io components for the specified app object ID and type.
+     *
+     * @param appObjectId The ID of the app object to build the components for.
+     * @param type The type of components to build.
+     * @returns A promise of the response from the server.
+     */
+    async buildFormIOComponents(appObjectId, type) {
+        // Send the request to the server to build the components.
+        const response = await firstValueFrom(this._tabFormioService.buildFormIOComponents(appObjectId, type));
+        // Return the response from the server.
+        return response;
+    }
+    /**
+     * Parses a template using the provided request payload.
+     *
+     * @param requestPayload The payload containing the template to be parsed.
+     * @param onFailedParseOnServer If the parsing should be done on the server.
+     * @returns A promise of the response from the server.
+     */
+    async parseTemplate(requestPayload, onFailedParseOnServer = false) {
+        // Send the request to the server to parse the template.
+        const response = await firstValueFrom(this._templateHelper.templateParseUniversal(requestPayload, onFailedParseOnServer));
+        // Return the response from the server.
+        return response;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FormService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FormService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FormService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,11 +1,11 @@
-import { Injectable } from '@angular/core';
-import { NotificationType, ScreenDisplayMode } from '../enums/ui.enum';
+import { inject, Injectable } from '@angular/core';
+import { NavigationType, ScreenDisplayMode } from '../enum/ui.enum';
 import { TabSdk } from '../tab-sdk.service';
+import { ConfirmationService, NotificationService, NotificationType } from '@techextensor/tab-core-utility';
 import * as i0 from "@angular/core";
 export class UiService {
-    _eventActionService = TabSdk.context?.EventActionService;
-    _tabUtilsService = TabSdk.context?.TabUtilsService;
-    _confirmationDialogService = TabSdk.context?.ConfirmationDialogService;
+    _notificationService = inject(NotificationService);
+    _confirmationService = inject(ConfirmationService);
     /**
      * Open a screen with the given options. The mode determines how the screen is
      * displayed.
@@ -22,11 +22,9 @@ export class UiService {
                 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;
         }
@@ -41,9 +39,11 @@ export class UiService {
             ...(options.title && { title: options.title }),
             ...(options.width && { width: options.width }),
             ...(options.height && { height: options.height }),
-            ...(options.customClass && { customClass: options.customClass })
+            ...(options.customClass && { customClass: options.customClass }),
+            ...(options.refresher && { refresher: options.refresher }),
+            ...(options.closer && { closer: options.closer })
         };
-        this._eventActionService.openScreen(ScreenDisplayMode.Sidebar, options.screenId, options.reqtokens || undefined, options.submission || undefined, Object.keys(otherConfiguration).length > 0 ? otherConfiguration : undefined);
+        TabSdk.util?.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.
@@ -55,9 +55,11 @@ export class UiService {
             ...(options.title && { title: options.title }),
             ...(options.width && { width: options.width }),
             ...(options.height && { height: options.height }),
-            ...(options.customClass && { customClass: options.customClass })
+            ...(options.customClass && { customClass: options.customClass }),
+            ...(options.refresher && { refresher: options.refresher }),
+            ...(options.closer && { closer: options.closer })
         };
-        this._eventActionService.openScreen(ScreenDisplayMode.Popup, options.screenId, options.reqtokens || undefined, options.submission || undefined, Object.keys(otherConfiguration).length > 0 ? otherConfiguration : undefined);
+        TabSdk.util?.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.
@@ -65,7 +67,7 @@ export class UiService {
      * @param options - The options for navigation, including screenId and optional reqtokens.
      */
     navigateTo(options) {
-        this._eventActionService.openScreen(ScreenDisplayMode.NavigationInSameTab, options.screenId, options.reqtokens || undefined);
+        TabSdk.util?.openScreen(ScreenDisplayMode.SameTab, options.screenId, options.reqtokens || undefined);
     }
     /**
      * Navigates to a screen in a new tab.
@@ -73,15 +75,18 @@ export class UiService {
      * @param options The options for navigation, including screenId and optional reqtokens.
      */
     openInNewTab(options) {
-        this._eventActionService.openScreen(ScreenDisplayMode.NavigationInNewTab, options.screenId, options.reqtokens || undefined);
+        TabSdk.util?.openScreen(ScreenDisplayMode.NewTab, options.screenId, options.reqtokens || undefined);
     }
     /**
      * Navigates to the specified URL.
      *
      * @param url - The URL to navigate to.
      */
-    navigateToUrl(url) {
-        this._tabUtilsService.navigateToUrl({ Url: url });
+    navigateToUrl(params) {
+        TabSdk.util?.navigateTo({
+            ...params,
+            type: NavigationType.NavigateToUrl
+        });
     }
     /**
      * Navigates to a specified subdomain using the provided options.
@@ -89,7 +94,46 @@ export class UiService {
      * @param options - The options for navigation, including subDomain, appCode, and url.
      */
     navigateToSubdomain(options) {
-        this._tabUtilsService.navigateToUrlWithSubdomain(options);
+        TabSdk.util?.navigateTo({
+            ...options,
+            type: NavigationType.NavigateToSubdomain
+        });
+    }
+    /**
+     * Retrieves the active screen ID from the current URL.
+     *
+     * @returns The screen ID if present in the URL, otherwise undefined.
+     */
+    getActiveUrlScreenId() {
+        // Split the URL pathname into parts using the '/' character as a delimiter
+        const urlParts = window?.location?.pathname?.split('/');
+        // Extract the screen ID part and remove any query parameters
+        const screenId = urlParts?.length > 1 ? urlParts?.[urlParts?.length - 1]?.split('?')[0] : undefined;
+        // Return the screen ID or undefined if not found
+        return screenId;
+    }
+    /**
+     * Retrieves the active redirect URL by combining the active screen ID and any query parameters.
+     *
+     * @returns The constructed redirect URL or undefined if no screen ID is present.
+     */
+    getActiveRedirectUrl() {
+        // Get the active screen ID from the current URL
+        const screenId = this.getActiveUrlScreenId();
+        let redirectURL;
+        // Check if the current URL contains a screen ID
+        if (screenId) {
+            // Initialize the redirect URL with the screen ID
+            redirectURL = screenId;
+            // Parse the current URL's query parameters
+            const queryParams = new URLSearchParams(window.location.search);
+            // If there are query parameters, append them to the redirect URL
+            if (queryParams.toString()) {
+                redirectURL += `&${queryParams.toString()}`;
+            }
+        }
+        // Return the constructed redirect URL or undefined
+        return redirectURL;
     }
     /**
      * Show a notification to the user.
@@ -97,7 +141,12 @@ export class UiService {
      * @param options The options for the notification.
      */
     notify(options) {
-        this._tabUtilsService.notify(options);
+        return this._notificationService.notify({
+            type: options.type,
+            message: TabSdk.translator.translate(options.message),
+            ...(options?.title ? { title: TabSdk.translator.translate(options.title) } : {}),
+            ...(options?.configuration ? { configuration: options.configuration } : {}),
+        });
     }
     /**
      * Displays a success notification to the user.
@@ -105,7 +154,11 @@ export class UiService {
      * @param options - The options for the notification, including message, title, and configuration.
      */
     showSuccess(options) {
-        this.notify({ ...options, type: NotificationType.Success });
+        return this.notify({
+            ...options,
+            type: NotificationType.Success,
+            title: options?.title ?? 'Success'
+        });
     }
     /**
      * Displays a warning notification to the user.
@@ -113,7 +166,23 @@ export class UiService {
      * @param options - The options for the notification, including message, title, and configuration.
      */
     showWarning(options) {
-        this.notify({ ...options, type: NotificationType.Warning });
+        return this.notify({
+            ...options,
+            type: NotificationType.Warning,
+            title: options?.title ?? 'Warning'
+        });
+    }
+    /**
+     * Displays an info notification to the user.
+     *
+     * @param options - The options for the notification, including message, title, and configuration.
+     */
+    showInfo(options) {
+        return this.notify({
+            ...options,
+            type: NotificationType.Info,
+            title: options?.title ?? 'Info'
+        });
     }
     /**
      * Displays an error notification to the user.
@@ -121,7 +190,20 @@ export class UiService {
      * @param options - The options for the notification, including message, title, and configuration.
      */
     showError(options) {
-        this.notify({ ...options, type: NotificationType.Error });
+        return this.notify({
+            ...options,
+            type: NotificationType.Error,
+            title: options?.title ?? 'Error'
+        });
+    }
+    /**
+     * Clears a notification by ID.
+     *
+     * @param notificationId - The ID of the notification to clear.
+     * @returns The cleared notification, or null if the notification doesn't exist.
+     */
+    clearNotification(notificationId) {
+        return this._notificationService.clearNotification(notificationId);
     }
     /**
      * Displays a confirmation dialog to the user and returns a promise that resolves
@@ -133,12 +215,123 @@ export class UiService {
      */
     confirm(options) {
         return new Promise((resolve) => {
-            this._confirmationDialogService.confirm(options)
+            this._confirmationService.confirm(options)
                 ?.subscribe((isConfirmed) => {
                 resolve(isConfirmed);
             });
         });
     }
+    /**
+     * Displays a confirmation dialog to the user with a title and message that indicates
+     * the user is about to delete an item. The confirmation dialog has a "Delete" and "Cancel"
+     * button.
+     *
+     * @param options - The options for the confirmation dialog, including the item name and
+     * optional message.
+     * @returns A promise that resolves to true if the user confirms, false otherwise.
+     */
+    confirmDelete(options) {
+        return this.confirm({
+            title: options?.title ?? `Are you sure you want to delete this record`,
+            message: options?.message ?? `You are about to delete the selected record. Are you sure you want to proceed?`,
+            primaryOption: 'Delete',
+        });
+    }
+    /**
+     * Displays a confirmation dialog to the user with a title and message that indicates
+     * the user is about to discard changes to an item. The confirmation dialog has a "Discard"
+     * and "Cancel" button.
+     *
+     * @param options - The options for the confirmation dialog, including the item name and
+     * optional message.
+     * @returns A promise that resolves to true if the user confirms, false otherwise.
+     */
+    confirmDiscard(options) {
+        return this.confirm({
+            title: `Are you sure you want to discard your changes`,
+            message: options?.message ?? `You are about to discard your changes. Are you sure you want to proceed?`,
+            primaryOption: 'Discard',
+        });
+    }
+    /**
+     * Closes the confirmation dialog.
+     *
+     * This method can be used to manually close the confirmation dialog.
+     */
+    closeConfirmationDialog() {
+        // Close the confirmation dialog
+        this._confirmationService.closeDialog();
+    }
+    /**
+     * Retrieves the confirmation emitter from the confirmation service.
+     *
+     * @returns The confirmation emitter used for emitting confirmation events.
+     */
+    getConformationEmitter() {
+        return this._confirmationService.getConformationEmitter();
+    }
+    /**
+     * Retrieves the dialog emitter from the confirmation service.
+     *
+     * The dialog emitter is an RxJS Subject that emits whenever a confirmation dialog is
+     * opened or closed. The value emitted is a boolean indicating whether a dialog is
+     * currently open.
+     *
+     * @returns The dialog emitter used for emitting confirmation dialog events.
+     */
+    getDialogEmitter() {
+        return this._confirmationService.getDialogEmitter();
+    }
+    /**
+     * Retrieves the remove emitter from the confirmation service.
+     *
+     * The remove emitter is an RxJS Subject that emits whenever a removal confirmation
+     * dialog is opened or closed. The value emitted is a boolean indicating whether a
+     * removal dialog is currently open.
+     *
+     * @returns The remove emitter used for emitting removal confirmation dialog events.
+     */
+    getRemoveEmitter() {
+        return this._confirmationService.getRemoveEmitter();
+    }
+    /**
+     * Copies the provided text to the clipboard and displays a success notification.
+     *
+     * @param text - The text to be copied to the clipboard.
+     */
+    copyToClipboard(text) {
+        // Create a temporary input element to hold the text
+        const tempInput = document.createElement("input");
+        // Set the input's value to the text to be copied
+        tempInput.value = text;
+        // Append the temporary input to the document body
+        document.body.appendChild(tempInput);
+        // Select the text in the input element
+        tempInput.select();
+        // Execute the copy command
+        document.execCommand("copy");
+        // Remove the temporary input from the document body
+        document.body.removeChild(tempInput);
+        // Show a success notification
+        this.showSuccess({
+            message: "",
+            title: "Copied to clipboard!",
+            configuration: {
+                timeOut: 1000,
+                positionClass: 'toast-top-center',
+                easing: 'ease-in',
+                easeTime: 300,
+                extendedTimeOut: 2000,
+            }
+        });
+    }
+    /**
+     * Copies the current URL to the clipboard and displays a success notification.
+     */
+    copyCurrentUrlToClipboard() {
+        // Use the copyToClipboard method to copy the current window URL
+        this.copyToClipboard(window.location.href);
+    }
     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' });
 }
@@ -148,4 +341,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
                     providedIn: 'root'
                 }]
         }] });
-//# 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}"]}
+//# 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 { inject, Injectable } from '@angular/core';\nimport {\n    ScreenOpenOptions,\n    NavigationOptions,\n    BaseScreenOptions,\n    NavigateToSubdomainOptions\n} from '../interface/ui.interface';\nimport { NavigationType, ScreenDisplayMode } from '../enum/ui.enum';\nimport { TabSdk } from '../tab-sdk.service';\nimport { BaseNotificationOptions, ConfirmationOptions, ConfirmationService, NotificationOptions, NotificationService, NotificationType } from '@techextensor/tab-core-utility';\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class UiService {\n    private readonly _notificationService: NotificationService = inject(NotificationService);\n    private readonly _confirmationService: ConfirmationService = inject(ConfirmationService);\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                this.navigateTo({ screenId, reqtokens });\n                break;\n\n            case ScreenDisplayMode.NewTab:\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            ...(options.refresher && { refresher: options.refresher }),\n            ...(options.closer && { closer: options.closer })\n        };\n\n        TabSdk.util?.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            ...(options.refresher && { refresher: options.refresher }),\n            ...(options.closer && { closer: options.closer })\n        };\n\n        TabSdk.util?.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        TabSdk.util?.openScreen(\n            ScreenDisplayMode.SameTab,\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        TabSdk.util?.openScreen(\n            ScreenDisplayMode.NewTab,\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(params: { url: string, extras?: any, replaceUrl?: boolean }): void {\n        TabSdk.util?.navigateTo({\n            ...params,\n            type: NavigationType.NavigateToUrl\n        })\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        TabSdk.util?.navigateTo({\n            ...options,\n            type: NavigationType.NavigateToSubdomain\n        })\n    }\n\n    /**\n     * Retrieves the active screen ID from the current URL.\n     *\n     * @returns The screen ID if present in the URL, otherwise undefined.\n     */\n    getActiveUrlScreenId(): string | undefined {\n        // Split the URL pathname into parts using the '/' character as a delimiter\n        const urlParts = window?.location?.pathname?.split('/');\n        // Extract the screen ID part and remove any query parameters\n        const screenId = urlParts?.length > 1 ? urlParts?.[urlParts?.length - 1]?.split('?')[0] : undefined;\n        // Return the screen ID or undefined if not found\n        return screenId;\n    }\n\n    /**\n     * Retrieves the active redirect URL by combining the active screen ID and any query parameters.\n     *\n     * @returns The constructed redirect URL or undefined if no screen ID is present.\n     */\n    getActiveRedirectUrl(): string | undefined {\n        // Get the active screen ID from the current URL\n        const screenId = this.getActiveUrlScreenId();\n        let redirectURL;\n\n        // Check if the current URL contains a screen ID\n        if (screenId) {\n            // Initialize the redirect URL with the screen ID\n            redirectURL = screenId;\n\n            // Parse the current URL's query parameters\n            const queryParams = new URLSearchParams(window.location.search);\n\n            // If there are query parameters, append them to the redirect URL\n            if (queryParams.toString()) {\n                redirectURL += `&${queryParams.toString()}`;\n            }\n        }\n\n        // Return the constructed redirect URL or undefined\n        return redirectURL;\n    }\n\n    /**\n     * Show a notification to the user.\n     *\n     * @param options The options for the notification.\n     */\n    notify(options: NotificationOptions) {\n        return this._notificationService.notify({\n            type: options.type,\n            message: TabSdk.translator.translate(options.message),\n            ...(options?.title ? { title: TabSdk.translator.translate(options.title) } : {}),\n            ...(options?.configuration ? { configuration: options.configuration } : {}),\n        });\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) {\n        return this.notify({\n            ...options,\n            type: NotificationType.Success,\n            title: options?.title ?? 'Success'\n        });\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) {\n        return this.notify({\n            ...options,\n            type: NotificationType.Warning,\n            title: options?.title ?? 'Warning'\n        });\n    }\n\n    /**\n     * Displays an info notification to the user.\n     *\n     * @param options - The options for the notification, including message, title, and configuration.\n     */\n    showInfo(options: BaseNotificationOptions) {\n        return this.notify({\n            ...options,\n            type: NotificationType.Info,\n            title: options?.title ?? 'Info'\n        });\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) {\n        return this.notify({\n            ...options,\n            type: NotificationType.Error,\n            title: options?.title ?? 'Error'\n        });\n    }\n\n    /**\n     * Clears a notification by ID.\n     *\n     * @param notificationId - The ID of the notification to clear.\n     * @returns The cleared notification, or null if the notification doesn't exist.\n     */\n    clearNotification(notificationId: number) {\n        return this._notificationService.clearNotification(notificationId);\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?: ConfirmationOptions): Promise<boolean> {\n        return new Promise((resolve) => {\n            this._confirmationService.confirm(options)\n                ?.subscribe((isConfirmed: boolean) => {\n                    resolve(isConfirmed);\n                });\n        });\n    }\n\n    /**\n     * Displays a confirmation dialog to the user with a title and message that indicates\n     * the user is about to delete an item. The confirmation dialog has a \"Delete\" and \"Cancel\"\n     * button.\n     *\n     * @param options - The options for the confirmation dialog, including the item name and\n     * optional message.\n     * @returns A promise that resolves to true if the user confirms, false otherwise.\n     */\n    confirmDelete(options?: ConfirmationOptions): Promise<boolean> {\n        return this.confirm({\n            title: options?.title ?? `Are you sure you want to delete this record`,\n            message: options?.message ?? `You are about to delete the selected record. Are you sure you want to proceed?`,\n            primaryOption: 'Delete',\n        });\n    }\n\n    /**\n     * Displays a confirmation dialog to the user with a title and message that indicates\n     * the user is about to discard changes to an item. The confirmation dialog has a \"Discard\"\n     * and \"Cancel\" button.\n     *\n     * @param options - The options for the confirmation dialog, including the item name and\n     * optional message.\n     * @returns A promise that resolves to true if the user confirms, false otherwise.\n     */\n    confirmDiscard(options?: ConfirmationOptions): Promise<boolean> {\n        return this.confirm({\n            title: `Are you sure you want to discard your changes`,\n            message: options?.message ?? `You are about to discard your changes. Are you sure you want to proceed?`,\n            primaryOption: 'Discard',\n        });\n    }\n\n    /**\n     * Closes the confirmation dialog.\n     *\n     * This method can be used to manually close the confirmation dialog.\n     */\n    closeConfirmationDialog() {\n        // Close the confirmation dialog\n        this._confirmationService.closeDialog();\n    }\n\n    /**\n     * Retrieves the confirmation emitter from the confirmation service.\n     * \n     * @returns The confirmation emitter used for emitting confirmation events.\n     */\n    getConformationEmitter() {\n        return this._confirmationService.getConformationEmitter();\n    }\n\n    /**\n     * Retrieves the dialog emitter from the confirmation service.\n     *\n     * The dialog emitter is an RxJS Subject that emits whenever a confirmation dialog is\n     * opened or closed. The value emitted is a boolean indicating whether a dialog is\n     * currently open.\n     *\n     * @returns The dialog emitter used for emitting confirmation dialog events.\n     */\n    getDialogEmitter() {\n        return this._confirmationService.getDialogEmitter();\n    }\n\n    /**\n     * Retrieves the remove emitter from the confirmation service.\n     * \n     * The remove emitter is an RxJS Subject that emits whenever a removal confirmation\n     * dialog is opened or closed. The value emitted is a boolean indicating whether a\n     * removal dialog is currently open.\n     * \n     * @returns The remove emitter used for emitting removal confirmation dialog events.\n     */\n    getRemoveEmitter() {\n        return this._confirmationService.getRemoveEmitter();\n    }\n\n    /**\n     * Copies the provided text to the clipboard and displays a success notification.\n     *\n     * @param text - The text to be copied to the clipboard.\n     */\n    copyToClipboard(text: string) {\n        // Create a temporary input element to hold the text\n        const tempInput = document.createElement(\"input\");\n\n        // Set the input's value to the text to be copied\n        tempInput.value = text;\n\n        // Append the temporary input to the document body\n        document.body.appendChild(tempInput);\n\n        // Select the text in the input element\n        tempInput.select();\n\n        // Execute the copy command\n        document.execCommand(\"copy\");\n\n        // Remove the temporary input from the document body\n        document.body.removeChild(tempInput);\n\n        // Show a success notification\n        this.showSuccess({\n            message: \"\",\n            title: \"Copied to clipboard!\",\n            configuration: {\n                timeOut: 1000,\n                positionClass: 'toast-top-center',\n                easing: 'ease-in',\n                easeTime: 300,\n                extendedTimeOut: 2000,\n            }\n        });\n    }\n\n    /**\n     * Copies the current URL to the clipboard and displays a success notification.\n     */\n    copyCurrentUrlToClipboard() {\n        // Use the copyToClipboard method to copy the current window URL\n        this.copyToClipboard(window.location.href);\n    }\n}"]}