npm - @techextensor/tab-sdk - Versions diffs - 0.0.2 → 0.0.3 - Mend

@techextensor/tab-sdk 0.0.2 → 0.0.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (31) hide show

package/esm2022/lib/common/utils.service.mjs +163 -0
package/esm2022/lib/core/auth.service.mjs +48 -0
package/esm2022/lib/data/data.service.mjs +81 -0
package/esm2022/lib/tab-sdk.service.mjs +50 -0
package/esm2022/lib/ui/form.service.mjs +97 -0
package/esm2022/lib/ui/ui.service.mjs +13 -0
package/esm2022/public-api.mjs +5 -0
package/esm2022/techextensor-tab-sdk.mjs +5 -0
package/fesm2022/techextensor-tab-sdk.mjs +443 -0
package/fesm2022/techextensor-tab-sdk.mjs.map +1 -0
package/index.d.ts +5 -0
package/lib/common/utils.service.d.ts +58 -0
package/lib/core/auth.service.d.ts +28 -0
package/lib/data/data.service.d.ts +36 -0
package/lib/tab-sdk.service.d.ts +23 -0
package/lib/ui/form.service.d.ts +56 -0
package/lib/ui/ui.service.d.ts +5 -0
package/package.json +16 -6
package/public-api.d.ts +1 -0
package/ng-package.json +0 -7
package/project.json +0 -37
package/src/lib/common/utils.service.ts +0 -184
package/src/lib/core/auth.service.ts +0 -46
package/src/lib/data/data.service.ts +0 -75
package/src/lib/tab-sdk.service.ts +0 -45
package/src/lib/ui/form.service.ts +0 -118
package/src/lib/ui/ui.service.ts +0 -6
package/src/public-api.ts +0 -5
package/tsconfig.lib.json +0 -15
package/tsconfig.lib.prod.json +0 -11
package/tsconfig.spec.json +0 -15

package/esm2022/lib/common/utils.service.mjs ADDED Viewed

@@ -0,0 +1,163 @@
+import { inject, Injectable } from "@angular/core";
+import { AuthService } from "../core/auth.service";
+import { TabSdk } from "../tab-sdk.service";
+import * as i0 from "@angular/core";
+export class UtilsService {
+    _authService = inject(AuthService);
+    _helperFunctionService = TabSdk.context?.HelperFunctionService;
+    /**
+     * Extracts the event name from various event parameter structures
+     *
+     * @example
+     * const eventName = sdk.utils.extractEventName(screenParameters.event);
+     * if (eventName === 'deleteDocument') {
+     *   // Handle delete document event
+     * }
+     */
+    extractEventName(event) {
+        if (!event)
+            return '';
+        // Check common patterns for event names
+        return event.event?.component?.configuration?.configScreen?.componentValue?.eventName ??
+            event.detail?.type ??
+            event.type ??
+            event.name ??
+            '';
+    }
+    /**
+     * Builds an application URL with the specified path and parameters
+     *
+     * @example
+     * // Get full URL with protocol
+     * const fullUrl = sdk.utils.buildAppUrl('screen/12345', { id: '12345' });
+     */
+    buildAppUrl(path, parameters, includeProtocol = true) {
+        const appCode = this._authService.getAppCode();
+        const params = new URLSearchParams();
+        // Add parameters to the URL
+        if (parameters) {
+            Object.entries(parameters).forEach(([key, value]) => {
+                if (value !== undefined && value !== null) {
+                    params.append(key, String(value));
+                }
+            });
+        }
+        // Build query string
+        const queryString = params.toString() ? `?${params.toString()}` : '';
+        // Build URL
+        if (includeProtocol) {
+            const host = window.location.host;
+            return `http://${host}/${appCode}/${path}${queryString}`;
+        }
+        else {
+            return `/${appCode}/${path}${queryString}`;
+        }
+    }
+    /**
+     * Generates and copies a screen URL to the clipboard
+     *
+     * @example
+     * // Copy URL to clipboard
+     * sdk.utils.copyScreenLink('12345', { id: '12345' });
+     */
+    copyScreenLinkToClipboard(screenId, parameters) {
+        const url = this.buildAppUrl(`screen/${screenId}`, parameters);
+        return this._helperFunctionService.copyToClipboard(url);
+    }
+    /**
+     * Downloads a blob as a file
+     *
+     * @example
+     * // Download a blob as 'report.pdf'
+     * const pdfBlob = new Blob([pdfContent], { type: 'application/pdf' });
+     * sdk.utils.downloadBlob(pdfBlob, 'report.pdf');
+     */
+    downloadBlob(blob, filename) {
+        // Create object URL
+        const url = URL.createObjectURL(blob);
+        // Create download link
+        const downloadLink = document.createElement('a');
+        downloadLink.href = url;
+        downloadLink.download = filename;
+        // Append to body, click, and remove
+        document.body.appendChild(downloadLink);
+        downloadLink.click();
+        document.body.removeChild(downloadLink);
+        // Release object URL after a short delay to ensure download starts
+        setTimeout(() => URL.revokeObjectURL(url), 100);
+    }
+    /**
+     * Exports HTML content as a Word document (.doc)
+     *
+     * @example
+     * // Export editor content as Word document
+     * sdk.utils.exportAsWord(editorContent, 'report');
+     */
+    exportAsWord(content, filename = 'document') {
+        // Format content with Word-compatible namespaces
+        const docContent = `
+        <html xmlns:o="urn:schemas-microsoft-com:office:office"
+            xmlns:w="urn:schemas-microsoft-com:office:word"
+            xmlns="http://www.w3.org/TR/REC-html40">
+        <head>
+            <meta charset="utf-8">
+            <title>${filename}</title>
+        </head>
+        <body>${content}</body>
+        </html>`;
+        // Create blob with BOM for Word compatibility
+        const blob = new Blob(['\ufeff', docContent], {
+            type: 'application/msword'
+        });
+        // Use the downloadBlob utility
+        this.downloadBlob(blob, `${filename}.doc`);
+    }
+    /**
+     * Exports HTML content as PDF using browser print functionality
+     *
+     * @example
+     * // Export content as PDF
+     * sdk.utils.exportAsPdf(documentContent, 'Invoice');
+     */
+    exportAsPdf(content, title = 'Document') {
+        // Open new window
+        const printWindow = window.open('', '', 'width=800,height=600');
+        // Add content with basic styling
+        printWindow.document?.write(`
+            <html>
+            <head>
+                <title>${title}</title>
+                <style>
+                body { font-family: Arial, sans-serif; margin: 20px; }
+                @media print {
+                    body { margin: 0mm; }
+                }
+                </style>
+            </head>
+            <body>
+                ${content}
+            </body>
+            </html>
+        `);
+        // Prepare for printing
+        printWindow.document.close();
+        printWindow.focus();
+        // Use timeout to ensure content is rendered before printing
+        setTimeout(() => {
+            printWindow.print();
+            // Close window after print dialog is closed or printing is complete
+            printWindow.addEventListener('afterprint', () => {
+                printWindow.close();
+            });
+        }, 300);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: UtilsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: UtilsService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: UtilsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.service.js","sourceRoot":"","sources":["../../../../../projects/tab-sdk/src/lib/common/utils.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject, Injectable } from \"@angular/core\";\nimport { AuthService } from \"../core/auth.service\";\nimport { TabSdk } from \"../tab-sdk.service\";\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class UtilsService {\n    private readonly _authService: AuthService = inject(AuthService);\n    private readonly _helperFunctionService: any = TabSdk.context?.HelperFunctionService;\n    \n\n    /**\n     * Extracts the event name from various event parameter structures\n     * \n     * @example\n     * const eventName = sdk.utils.extractEventName(screenParameters.event);\n     * if (eventName === 'deleteDocument') {\n     *   // Handle delete document event\n     * }\n     */\n    extractEventName(event: any): string {\n        if (!event) return '';\n\n        // Check common patterns for event names\n        return event.event?.component?.configuration?.configScreen?.componentValue?.eventName ??\n            event.detail?.type ??\n            event.type ??\n            event.name ??\n            '';\n    }\n\n\n    /**\n     * Builds an application URL with the specified path and parameters\n     * \n     * @example\n     * // Get full URL with protocol\n     * const fullUrl = sdk.utils.buildAppUrl('screen/12345', { id: '12345' });\n     */\n    buildAppUrl(\n        path: string,\n        parameters?: Record<string, any>,\n        includeProtocol: boolean = true\n    ): string {\n        const appCode = this._authService.getAppCode();\n        const params = new URLSearchParams();\n\n        // Add parameters to the URL\n        if (parameters) {\n            Object.entries(parameters).forEach(([key, value]) => {\n                if (value !== undefined && value !== null) {\n                    params.append(key, String(value));\n                }\n            });\n        }\n\n        // Build query string\n        const queryString = params.toString() ? `?${params.toString()}` : '';\n\n        // Build URL\n        if (includeProtocol) {\n            const host = window.location.host;\n            return `http://${host}/${appCode}/${path}${queryString}`;\n\n        } else {\n            return `/${appCode}/${path}${queryString}`;\n        }\n    }\n\n    /**\n     * Generates and copies a screen URL to the clipboard\n     * \n     * @example\n     * // Copy URL to clipboard\n     * sdk.utils.copyScreenLink('12345', { id: '12345' });\n     */\n    copyScreenLinkToClipboard(\n        screenId: string,\n        parameters?: Record<string, any>\n    ): any {\n        const url = this.buildAppUrl(`screen/${screenId}`, parameters);        \n        return this._helperFunctionService.copyToClipboard(url);\n    }\n\n    /**\n     * Downloads a blob as a file\n     * \n     * @example\n     * // Download a blob as 'report.pdf'\n     * const pdfBlob = new Blob([pdfContent], { type: 'application/pdf' });\n     * sdk.utils.downloadBlob(pdfBlob, 'report.pdf');\n     */\n    downloadBlob(blob: Blob, filename: string): void {\n        // Create object URL\n        const url = URL.createObjectURL(blob);\n\n        // Create download link\n        const downloadLink = document.createElement('a');\n        downloadLink.href = url;\n        downloadLink.download = filename;\n\n        // Append to body, click, and remove\n        document.body.appendChild(downloadLink);\n        downloadLink.click();\n        document.body.removeChild(downloadLink);\n\n        // Release object URL after a short delay to ensure download starts\n        setTimeout(() => URL.revokeObjectURL(url), 100);\n    }\n\n    /**\n     * Exports HTML content as a Word document (.doc)\n     * \n     * @example\n     * // Export editor content as Word document\n     * sdk.utils.exportAsWord(editorContent, 'report');\n     */\n    exportAsWord(content: string, filename: string = 'document'): void {\n        // Format content with Word-compatible namespaces\n        const docContent = `\n        <html xmlns:o=\"urn:schemas-microsoft-com:office:office\" \n            xmlns:w=\"urn:schemas-microsoft-com:office:word\" \n            xmlns=\"http://www.w3.org/TR/REC-html40\">\n        <head>\n            <meta charset=\"utf-8\">\n            <title>${filename}</title>\n        </head>\n        <body>${content}</body>\n        </html>`;\n\n        // Create blob with BOM for Word compatibility\n        const blob = new Blob(['\\ufeff', docContent], {\n            type: 'application/msword'\n        });\n\n        // Use the downloadBlob utility\n        this.downloadBlob(blob, `${filename}.doc`);\n    }\n\n\n    /**\n     * Exports HTML content as PDF using browser print functionality\n     * \n     * @example\n     * // Export content as PDF\n     * sdk.utils.exportAsPdf(documentContent, 'Invoice');\n     */\n    exportAsPdf(content: string, title: string = 'Document'): void {\n        // Open new window\n        const printWindow: any = window.open('', '', 'width=800,height=600');\n\n        // Add content with basic styling\n        printWindow.document?.write(`\n            <html>\n            <head>\n                <title>${title}</title>\n                <style>\n                body { font-family: Arial, sans-serif; margin: 20px; }\n                @media print {\n                    body { margin: 0mm; }\n                }\n                </style>\n            </head>\n            <body>\n                ${content}\n            </body>\n            </html>\n        `);\n\n        // Prepare for printing\n        printWindow.document.close();\n        printWindow.focus();\n\n        // Use timeout to ensure content is rendered before printing\n        setTimeout(() => {\n            printWindow.print();\n            // Close window after print dialog is closed or printing is complete\n            printWindow.addEventListener('afterprint', () => {\n                printWindow.close();\n            });\n        }, 300);\n    }\n}"]}

package/esm2022/lib/core/auth.service.mjs ADDED Viewed

@@ -0,0 +1,48 @@
+import { inject, Injectable } from "@angular/core";
+import { LocalStorageService, SessionStorageService, StorageConstants } from "@techextensor/tab-core-utility";
+import * as i0 from "@angular/core";
+export class AuthService {
+    _sessionStorageService = inject(SessionStorageService);
+    _localStorageService = inject(LocalStorageService);
+    /**
+     * Get the current application code/identifier
+     *
+     * @example
+     * const appCode = sdk.config.getAppCode();
+     */
+    getAppCode() {
+        return this._sessionStorageService.getSessionStorage(StorageConstants.applicationCode) ?? '';
+    }
+    /**
+     * Get the current user ID
+     *
+     * @example
+     * const userId = sdk.auth.getCurrentUserId();
+     */
+    getCurrentUserId() {
+        const userInfo = this.getCurrentUser();
+        return userInfo?.user?.Id ?? '';
+    }
+    /**
+     * Get the current user information
+     *
+     * @example
+     * const user = sdk.auth.getCurrentUser();
+     */
+    getCurrentUser() {
+        const userInfoStr = this._localStorageService.getLocalStorage(StorageConstants.userInfo);
+        if (userInfoStr) {
+            return JSON.parse(userInfoStr);
+        }
+        return null;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AuthService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AuthService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AuthService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/data/data.service.mjs ADDED Viewed

@@ -0,0 +1,81 @@
+import { inject, Injectable } from "@angular/core";
+import { TabDeleteService, TabInsertService, TabUpdateService } from '@techextensor/tab-core-utility';
+import * as i0 from "@angular/core";
+export class DataService {
+    _tabInsertService = inject(TabInsertService);
+    _tabUpdateService = inject(TabUpdateService);
+    _tabDeleteService = inject(TabDeleteService);
+    /**
+     * Insert a new record
+     *
+     * @example
+     * const newRecord = await sdk.data.insert('123456', {
+     *   name: 'ACME Corp',
+     *   email: 'contact@acme.com'
+     * });
+     */
+    insert(objectId, data) {
+        return new Promise((resolve, reject) => {
+            this._tabInsertService.insertByObjectId(objectId, { data })
+                ?.subscribe((response) => {
+                if (response?.StatusCode == 200 && response?.Result) {
+                    resolve(response.Result);
+                }
+                else {
+                    reject(new Error('Failed to insert record'));
+                }
+            });
+        });
+    }
+    /**
+     * Update an existing record
+     *
+     * @example
+     * await sdk.data.update('12345', {
+     *   Id: '12345',
+     *   name: 'ACME Corporation',
+     *   status: 'active'
+     * });
+     */
+    update(objectId, data) {
+        return new Promise((resolve, reject) => {
+            this._tabUpdateService.updateByObjectId(objectId, { data })
+                ?.subscribe((response) => {
+                if (response?.StatusCode == 200 && response?.Result) {
+                    resolve(response.Result);
+                }
+                else {
+                    reject(new Error('Failed to update record'));
+                }
+            });
+        });
+    }
+    /**
+     * Delete a record
+     *
+     * @example
+     * await sdk.data.delete('12345', {Id: '12345'});
+     */
+    delete(objectId, data) {
+        return new Promise((resolve, reject) => {
+            this._tabDeleteService.deleteRecord('', { data }, objectId)
+                ?.subscribe((response) => {
+                if (response?.StatusCode == 200) {
+                    resolve();
+                }
+                else {
+                    reject(new Error('Failed to delete record'));
+                }
+            });
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DataService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DataService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DataService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,50 @@
+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 * as i0 from "@angular/core";
+export class TabSdk {
+    static data;
+    static ui;
+    static form;
+    static auth;
+    static utils;
+    static metadataUtils;
+    static context;
+    /**
+     * 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.data = injector.get(DataService);
+        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' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TabSdk, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,97 @@
+import { Injectable } from "@angular/core";
+import { TabSdk } from "../tab-sdk.service";
+import * as i0 from "@angular/core";
+export class FormService {
+    _helperFunctionService = TabSdk.context?.HelperFunctionService;
+    /**
+    * Processes form components with individual actions in a single pass
+    *
+    * @example
+    * // Process multiple components with different actions in one pass
+    * sdk.form.processComponents(
+    *   screenParameters.rendererInstance.form.components,
+    *   [
+    *     {
+    *       keys: 'documentDetails', // Single key
+    *       action: (component) => component.hidden = true,
+    *       type: 'columns' // Optional type filter
+    *     },
+    *     {
+    *       keys: 'documentPreview,documentComments', // Multiple keys as comma-separated string
+    *       action: (component) => component.hidden = false
+    *     }
+    *   ]
+    * );
+    */
+    processComponents(components, processors) {
+        if (!components || !Array.isArray(components) || !processors?.length) {
+            return;
+        }
+        this._helperFunctionService?.eachComponent(components, (component) => {
+            processors.forEach(processor => {
+                // Split the keys string into an array
+                const keyList = processor.keys.split(',').map(k => k.trim());
+                // Check if component key is in the list of keys to process
+                if (!keyList.includes(component.key))
+                    return;
+                // Check type match if specified
+                if (processor.type && component.type !== processor.type)
+                    return;
+                // All criteria matched, execute the action
+                processor.action(component);
+            });
+        });
+    }
+    /**
+     * Updates visibility of multiple form components at once
+     *
+     * @example
+     * sdk.form.setComponentsVisibility(
+     *   screenParameters.rendererInstance.form.components,
+     *   {
+     *     'documentDetails': false,
+     *     'documentComments': true
+     *   }
+     * );
+     */
+    setComponentsVisibility(components, visibilityMap) {
+        const keys = Object.keys(visibilityMap);
+        this.processComponents(components, keys.map(key => ({
+            keys: key,
+            action: (component) => {
+                component.hidden = visibilityMap[key];
+            }
+        })));
+    }
+    /**
+     * Finds components by key and returns them in a structured object
+     *
+     * @example
+     * const components = sdk.form.findComponentsByKeys(
+     *   form.components,
+     *   ['documentDetails', 'documentPreview', 'documentComments']
+     * );
+     */
+    findComponentsByKeys(components, keys, options) {
+        const result = {};
+        if (!components || !Array.isArray(components) || !keys?.length) {
+            return result;
+        }
+        // Use the existing eachComponent helper
+        this._helperFunctionService.eachComponent(components, (component) => {
+            if (!options?.type || component.type === options.type) {
+                result[component.key] = component;
+            }
+        }, keys);
+        return result;
+    }
+    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 ADDED Viewed

@@ -0,0 +1,13 @@
+import { Injectable } from "@angular/core";
+import * as i0 from "@angular/core";
+export class UiService {
+    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' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: UiService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidWkuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3RhYi1zZGsvc3JjL2xpYi91aS91aS5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBSzNDLE1BQU0sT0FBTyxTQUFTO3dHQUFULFNBQVM7NEdBQVQsU0FBUyxjQUZOLE1BQU07OzRGQUVULFNBQVM7a0JBSHJCLFVBQVU7bUJBQUM7b0JBQ1IsVUFBVSxFQUFFLE1BQU07aUJBQ3JCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XG5cbkBJbmplY3RhYmxlKHtcbiAgICBwcm92aWRlZEluOiAncm9vdCdcbn0pXG5leHBvcnQgY2xhc3MgVWlTZXJ2aWNlIHt9Il19

package/esm2022/public-api.mjs ADDED Viewed

@@ -0,0 +1,5 @@
+/*
+ * Public API Surface of tab-sdk
+ */
+export * from './lib/tab-sdk.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL3RhYi1zZGsvc3JjL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLHVCQUF1QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIFB1YmxpYyBBUEkgU3VyZmFjZSBvZiB0YWItc2RrXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9saWIvdGFiLXNkay5zZXJ2aWNlJztcbiJdfQ==

package/esm2022/techextensor-tab-sdk.mjs ADDED Viewed

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVjaGV4dGVuc29yLXRhYi1zZGsuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9wcm9qZWN0cy90YWItc2RrL3NyYy90ZWNoZXh0ZW5zb3ItdGFiLXNkay50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpYy1hcGknO1xuIl19