@techextensor/tab-core-utility 2.2.175 → 2.2.177

package/esm2022/lib/tab-core-utility/app/helpers/common/meta-data.helpers.mjs

@@ -270,6 +270,27 @@ export class MetadataHelper {
         // If a filter function is given, apply it to the list of app screens.
         return filterFn ? list.filter(filterFn) : list;
     }
+    /**
+     * Clears all cached metadata safely.
+     * This should be called on context changes (e.g., when app, org, or session changes).
+     */
+    clearCache() {
+        try {
+            // Clear maps
+            this.appObjectMap.clear();
+            this.appScreenMap.clear();
+            this.orgInfoMap.clear();
+            this.appMenuMap.clear();
+            // Reset lists
+            this.allAppObjects = null;
+            this.allAppScreens = null;
+            this.allOrgInfos = null;
+            this.allAppMenus = null;
+        }
+        catch (error) {
+            console.warn('MetadataHelper Failed to clear cache:', error);
+        }
+    }
     static { this.ɵfac = function MetadataHelper_Factory(t) { return new (t || MetadataHelper)(); }; }
     static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: MetadataHelper, factory: MetadataHelper.ɵfac, providedIn: 'root' }); }
 }
@@ -277,4 +298,4 @@ export class MetadataHelper {
         type: Injectable,
         args: [{ providedIn: 'root' }]
     }], null, null); })();
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"meta-data.helpers.js","sourceRoot":"","sources":["../../../../../../../../../libs/data-access/src/lib/tab-core-utility/app/helpers/common/meta-data.helpers.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject, Injectable } from \"@angular/core\";\nimport { Common } from \"../../constants/common\";\nimport { AppObjectModel } from \"../../models/app-object.model\";\nimport { AppFieldModel } from \"../../models/app-field.model\";\nimport { DataSourceQueryModel } from \"../../models/data-source-query.model\";\nimport { MetadataEntityType } from \"../../interfaces/schema.interface\";\nimport { AppScreenModel } from \"../../models/app-screen.model\";\nimport { OrgInfoModel } from \"../../models/orgInfo.model\";\nimport { AppMenuModel } from \"../../models/app-menu.model\";\nimport { SessionStorageService } from \"../../../auth/session-storage.service\";\nimport { StorageConstants } from \"../../constants/storage-constants\";\n\n@Injectable({ providedIn: 'root' })\nexport class MetadataHelper {\n  private appObjectMap = new Map<string, AppObjectModel | null>();\n  private allAppObjects: AppObjectModel[] | null = null;\n\n  private appScreenMap = new Map<string, AppScreenModel | null>();\n  private allAppScreens: AppScreenModel[] | null = null;\n\n  private orgInfoMap = new Map<string, OrgInfoModel | null>();\n  private allOrgInfos: OrgInfoModel[] | null = null;\n\n  private appMenuMap = new Map<string, AppMenuModel | null>();\n  private allAppMenus: AppMenuModel[] | null = null;\n\n  private readonly sessionStorageService: SessionStorageService = inject(SessionStorageService);\n\n  /**\n   * Helper method to get current app ID from session\n   * @returns Current app ID or null if not available\n   */\n  private getCurrentAppId(): string | null {\n    try {\n      const appInfo = this.sessionStorageService.getSessionStorage(StorageConstants.appInfo);\n      const parsedAppInfo = appInfo ? JSON.parse(appInfo) : null;\n      return parsedAppInfo?.Id || null;\n    } catch (error) {\n      console.warn('Failed to get current app ID from session:', error);\n      return null;\n    }\n  }\n\n  /**\n   * Returns the value associated with the given key from the given map.\n   * If the key does not exist in the map, and the source list contains an item that matches\n   * the given condition, it creates a new model using the given model factory and adds it to the map.\n   * @param map The map to search in.\n   * @param key The key to search for.\n   * @param sourceList The list of items to search in.\n   * @param matchFn The condition to match.\n   * @param modelFactory The factory to create a new model if the key does not exist.\n   * @returns The value associated with the given key, or null if no match is found.\n   */\n  private getFromMapOrCreate<T>(\n    map: Map<string, T | null>,\n    key: string,\n    sourceList: T[],\n    matchFn: (item: T) => boolean,\n    modelFactory: (item: T) => T\n  ): T | null {\n    if (!key) return null;\n    if (map.has(key)) return map.get(key) || null;\n\n    const item = sourceList.find(matchFn);\n    const model = item ? modelFactory(item) : null;\n    map.set(key, model);\n    return model;\n  }\n\n  /**\n   * Lazily initializes a list of models from a source list.\n   * It creates a new model for each item in the source list and adds it to the given map.\n   * It also sets the list of models to the given setter.\n   * @param listRef The reference to the list of models.\n   * @param setter The setter to set the list of models.\n   * @param sourceList The source list of items.\n   * @param map The map to store the models.\n   * @param getKeys The function to get the keys for the given item.\n   * @param modelFactory The factory to create a new model for the given item.\n   * @returns The list of models.\n   */\n  private lazyInitList<T, M>(\n    listRef: M[] | null,\n    setter: (list: M[]) => void,\n    sourceList: T[],\n    map: Map<string, M | null>,\n    getKeys: (item: T) => string[],\n    modelFactory: (item: T) => M\n  ): M[] {\n    // If the list is already initialized, return it.\n    if (listRef) return listRef;\n\n    // Create a new model for each item in the source list and add it to the map.\n    const models = sourceList.map((item: T) => {\n      const model = modelFactory(item);\n      getKeys(item).forEach(key => map.set(key, model));\n      return model;\n    });\n\n    // Set the list of models to the given setter.\n    setter(models);\n\n    // Return the list of models.\n    return models;\n  }\n\n  /**\n   * Finds an app object in the map by its name or id.\n   * If the app object is not found, it creates a new one and adds it to the map.\n   * @param nameOrId The name or id of the app object to find.\n   * @returns The app object if found, or null if not found.\n   */\n  getAppObjectByIdOrName(nameOrId: string): AppObjectModel | null {\n    return this.getFromMapOrCreate(\n      this.appObjectMap,\n      nameOrId,\n      Common.tabJson.AppObjects,\n      obj => obj.ObjectName === nameOrId || obj.ID?.toLowerCase() === nameOrId?.toLowerCase(),\n      obj => new AppObjectModel(obj, this)\n    );\n  }\n\n  /**\n   * Returns a list of app objects in the metadata.\n   * If a filter function is given, it is applied to each app object.\n   * @param filterFn The filter function to apply to the app objects.\n   * @returns The list of app objects.\n   */\n  getAllAppObjects(filterFn?: (obj: AppObjectModel) => boolean, includeSystemData = false): AppObjectModel[] {\n    // Initialize the list of app objects lazily.\n    const list = this.lazyInitList(\n      this.allAppObjects,\n      val => (this.allAppObjects = val),\n      Common.tabJson.AppObjects,\n      this.appObjectMap,\n      (obj: any) => [obj.ID?.toLowerCase(), obj.ObjectName],\n      obj => new AppObjectModel(obj, this)\n    );\n\n    let filteredList: AppObjectModel[] = list;\n    if (!includeSystemData) {\n      const currentAppId = this.getCurrentAppId()?.toLowerCase();\n      filteredList = list.filter(obj => \n        !obj.AppId ||                    // Global data (app = null)\n        obj.AppId === currentAppId       // Current app data\n      );\n    }\n\n    // If a filter function is given, apply it to the list of app objects.\n    return filterFn ? filteredList.filter(filterFn) : filteredList;\n  }\n\n  /**\n   * Returns a list of fields in the metadata.\n   * If a filter function is given, it is applied to each field.\n   * @param filterFn The filter function to apply to the fields.\n   * @returns The list of fields.\n   */\n  getAllFields(filterFn?: (field: AppFieldModel) => boolean, includeSystemData = false): AppFieldModel[] {\n    // Get a list of all fields from all app objects.\n    const allFields = this.getAllAppObjects(undefined, includeSystemData).flatMap(obj => obj.fields());\n\n    // If a filter function is given, apply it to the list of fields.\n    return filterFn ? allFields.filter(filterFn) : allFields;\n  }\n\n  /**\n   * Finds a field by its ID across all app objects\n   * @param fieldId The ID of the field to find\n   * @returns The field if found, or null if not found\n   */\n  getFieldByIdOrName(nameOrId: string): AppFieldModel | null {\n    if (!nameOrId) return null;\n    return this.getAllFields(field => \n      field.ID?.toLowerCase() === nameOrId?.toLowerCase() || \n      field.FieldName === nameOrId,\n      true\n    )[0] || null;\n  }\n\n  /**\n   * Returns a list of data source queries in the metadata.\n   * If a filter function is given, it is applied to each data source query.\n   * @param filterFn The filter function to apply to the data source queries.\n   * @returns The list of data source queries.\n   */\n  getAllDataSourceQueries(filterFn?: (dsq: DataSourceQueryModel) => boolean,includeSystemData = false): DataSourceQueryModel[] {\n    // Get a list of all data source queries from all app objects.\n    const allDSQs = this.getAllAppObjects(undefined, includeSystemData).flatMap(obj => obj.dataSourceQueries());\n\n    // If a filter function is given, apply it to the list of data source queries.\n    return filterFn ? allDSQs.filter(filterFn) : allDSQs;\n  }\n\n  /**\n   * Retrieves a data source query by its ID, QueryName, or DisplayName.\n   * Searches through all data source queries and returns the first match.\n   * \n   * @param {string} nameOrId - The ID, QueryName, or DisplayName of the data source query to retrieve.\n   * @returns {DataSourceQueryModel | null} - The data source query model if found, otherwise null.\n   */\n  getDataSourceQueryByIdOrName(nameOrId: string): DataSourceQueryModel | null {\n    // Search for the data source query by ID, QueryName, or DisplayName\n    return this.getAllDataSourceQueries(undefined,true).find(\n      dsq => dsq?.ID?.toLowerCase() === nameOrId?.toLowerCase() || dsq?.QueryName === nameOrId || dsq?.DisplayName === nameOrId\n    ) || null;\n  }\n\n  /**\n   * Retrieves an app screen by its ID, Name, or DisplayName.\n   * Searches through all app screens and returns the first match.\n   * \n   * @param {string} nameOrId - The ID, Name, or DisplayName of the app screen to retrieve.\n   * @returns {AppScreenModel | null} - The app screen model if found, otherwise null.\n   */\n  getAppScreenByIdOrName(nameOrId: string): AppScreenModel | null {\n    return this.getFromMapOrCreate(\n      this.appScreenMap,\n      nameOrId,\n      Common.tabJson.AppScreens,\n      screen => screen?.ID?.toLowerCase() === nameOrId?.toLowerCase() || screen?.Name === nameOrId,\n      screen => new AppScreenModel(screen)\n    );\n  }\n\n  /**\n   * Retrieves a list of all app screens.\n   * If a filter function is given, it is applied to the list of app screens.\n   * \n   * @param {function} filterFn - The filter function to apply to the app screens.\n   * @returns {AppScreenModel[]} - The list of app screens.\n   */\n  getAllAppScreens(filterFn?: (screen: AppScreenModel) => boolean): AppScreenModel[] {\n    // Initialize the list of app screens lazily.\n    const list = this.lazyInitList(\n      this.allAppScreens,\n      val => (this.allAppScreens = val),\n      Common.tabJson.AppScreens,\n      this.appScreenMap,\n      (s: any) => [s?.ID?.toLowerCase(), s?.Name],\n      s => new AppScreenModel(s)\n    );\n\n    // If a filter function is given, apply it to the list of app screens.\n    return filterFn ? list.filter(filterFn) : list;\n  }\n\n  /**\n   * Retrieves an organization info by its ID or TenantCode.\n   * Searches through all organization info and returns the first match.\n   * \n   * @param {string} nameOrTenantCode - The ID or TenantCode of the organization info to retrieve.\n   * @returns {OrgInfoModel | null} - The organization info model if found, otherwise null.\n   */\n  getOrgInfoByIdOrTenantCode(nameOrTenantCode: string): OrgInfoModel | null {\n    return this.getFromMapOrCreate(\n      this.orgInfoMap,\n      nameOrTenantCode,\n      Common.tabJson.OrgInfos,\n      // Search for the organization info by ID or TenantCode\n      org => org.ID?.toLowerCase() === nameOrTenantCode?.toLowerCase() || org.TenantCode === nameOrTenantCode,\n      // Create a new OrgInfoModel if the organization info is found\n      org => new OrgInfoModel(org)\n    );\n  }\n\n  /**\n   * Retrieves a list of all organization info.\n   * If a filter function is given, it is applied to the list of organization info.\n   * \n   * @param {function} filterFn - The filter function to apply to the organization info.\n   * @returns {OrgInfoModel[]} - The list of organization info.\n   */\n  getAllOrgInfos(filterFn?: (org: OrgInfoModel) => boolean): OrgInfoModel[] {\n    // Initialize the list of organization info lazily.\n    const list = this.lazyInitList(\n      this.allOrgInfos,\n      val => (this.allOrgInfos = val),\n      Common.tabJson.OrgInfos,\n      this.orgInfoMap,\n      (org: any) => [org?.ID?.toLowerCase(), org?.TenantCode],\n      org => new OrgInfoModel(org)\n    );\n\n    // If a filter function is given, apply it to the list of organization info.\n    return filterFn ? list.filter(filterFn) : list;\n  }\n\n  /**\n   * Performs a global search across all metadata for a given search term.\n   * You can narrow the search by providing a list of entity types to search within.\n   * \n   * @param {string} term - The search term to search for.\n   * @param {MetadataEntityType[]} entityTypes - The list of entity types to search within. If omitted, all entity types are searched.\n   * @returns {Record<string, any[]>} - A dictionary with results grouped by entity type.\n   */\n  searchMetadata(term: string, entityTypes?: MetadataEntityType[]): Record<string, any[]> {\n    const searchTerm = term.toLowerCase();\n    const result: Record<string, any[]> = {};\n\n    /**\n     * Helper function to determine if a given entity type should be searched.\n     * @param {MetadataEntityType} type - The entity type to check.\n     * @returns {boolean} - Whether the entity type should be searched.\n     */\n    const shouldSearch = (type: MetadataEntityType) => !entityTypes || entityTypes.includes(type);\n\n    if (shouldSearch(MetadataEntityType.APP_OBJECTS)) {\n      // Search for app objects by ID, ObjectName, DisplayName, or SystemDBTableName\n      result[MetadataEntityType.APP_OBJECTS] = this.getAllAppObjects(obj =>\n        [obj?.ID, obj?.ObjectName, obj?.DisplayName, obj?.SystemDBTableName]\n          .some(val => val === searchTerm || val?.toLowerCase().includes(searchTerm))\n      );\n    }\n\n    if (shouldSearch(MetadataEntityType.APP_FIELDS)) {\n      // Search for app fields by using the search method\n      result[MetadataEntityType.APP_FIELDS] = this.getAllFields(field => field.search(searchTerm));\n    }\n\n    if (shouldSearch(MetadataEntityType.DATA_SOURCE_QUERIES)) {\n      // Search for data source queries by using the search method\n      result[MetadataEntityType.DATA_SOURCE_QUERIES] = this.getAllDataSourceQueries(dsq => dsq.search(searchTerm));\n    }\n\n    if (shouldSearch(MetadataEntityType.APP_SCREENS)) {\n      // Search for app screens by using the search method\n      result[MetadataEntityType.APP_SCREENS] = this.getAllAppScreens(screen => screen.search(searchTerm));\n    }\n\n    return result;\n  }\n\n  /**\n   * Retrieves an app menu by its ID or name.\n   * Searches through all app menus and returns the first match.\n   * \n   * @param {string} nameOrId - The ID or name of the app menu to retrieve.\n   * @returns {AppMenuModel | null} - The app menu model if found, otherwise null.\n   */\n  getAppMenuByIdOrName(nameOrId: string): AppMenuModel | null {\n    return this.getFromMapOrCreate(\n      this.appMenuMap,\n      nameOrId,\n      Common.tabJson.Menus,\n      // Search for the app menu by ID or name\n      menu => menu?.Id?.toLowerCase() === nameOrId?.toLowerCase() || menu?.MenuName === nameOrId,\n      // Create a new AppMenuModel if the app menu is found\n      menu => new AppMenuModel(menu)\n    );\n  }\n\n  /**\n   * Retrieves a list of all app menus.\n   * If a filter function is given, it is applied to the list of app menus.\n   * \n   * @param {function} filterFn - The filter function to apply to the app menus.\n   * @returns {AppMenuModel[]} - The list of app menus.\n   */\n  getAllAppMenus(filterFn?: (menu: AppMenuModel) => boolean): AppMenuModel[] {\n    // Initialize the list of app screens lazily.\n    const list = this.lazyInitList(\n      this.allAppMenus,\n      val => (this.allAppMenus = val),\n      Common.tabJson.Menus,\n      this.appMenuMap,\n      (m: any) => [m?.Id?.toLowerCase(), m?.Name],\n      s => new AppMenuModel(s)\n    );\n\n    // If a filter function is given, apply it to the list of app screens.\n    return filterFn ? list.filter(filterFn) : list;\n  }\n}"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"meta-data.helpers.js","sourceRoot":"","sources":["../../../../../../../../../libs/data-access/src/lib/tab-core-utility/app/helpers/common/meta-data.helpers.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject, Injectable } from \"@angular/core\";\r\nimport { Common } from \"../../constants/common\";\r\nimport { AppObjectModel } from \"../../models/app-object.model\";\r\nimport { AppFieldModel } from \"../../models/app-field.model\";\r\nimport { DataSourceQueryModel } from \"../../models/data-source-query.model\";\r\nimport { MetadataEntityType } from \"../../interfaces/schema.interface\";\r\nimport { AppScreenModel } from \"../../models/app-screen.model\";\r\nimport { OrgInfoModel } from \"../../models/orgInfo.model\";\r\nimport { AppMenuModel } from \"../../models/app-menu.model\";\r\nimport { SessionStorageService } from \"../../../auth/session-storage.service\";\r\nimport { StorageConstants } from \"../../constants/storage-constants\";\r\n\r\n@Injectable({ providedIn: 'root' })\r\nexport class MetadataHelper {\r\n  private appObjectMap = new Map<string, AppObjectModel | null>();\r\n  private allAppObjects: AppObjectModel[] | null = null;\r\n\r\n  private appScreenMap = new Map<string, AppScreenModel | null>();\r\n  private allAppScreens: AppScreenModel[] | null = null;\r\n\r\n  private orgInfoMap = new Map<string, OrgInfoModel | null>();\r\n  private allOrgInfos: OrgInfoModel[] | null = null;\r\n\r\n  private appMenuMap = new Map<string, AppMenuModel | null>();\r\n  private allAppMenus: AppMenuModel[] | null = null;\r\n\r\n  private readonly sessionStorageService: SessionStorageService = inject(SessionStorageService);\r\n\r\n  /**\r\n   * Helper method to get current app ID from session\r\n   * @returns Current app ID or null if not available\r\n   */\r\n  private getCurrentAppId(): string | null {\r\n    try {\r\n      const appInfo = this.sessionStorageService.getSessionStorage(StorageConstants.appInfo);\r\n      const parsedAppInfo = appInfo ? JSON.parse(appInfo) : null;\r\n      return parsedAppInfo?.Id || null;\r\n    } catch (error) {\r\n      console.warn('Failed to get current app ID from session:', error);\r\n      return null;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Returns the value associated with the given key from the given map.\r\n   * If the key does not exist in the map, and the source list contains an item that matches\r\n   * the given condition, it creates a new model using the given model factory and adds it to the map.\r\n   * @param map The map to search in.\r\n   * @param key The key to search for.\r\n   * @param sourceList The list of items to search in.\r\n   * @param matchFn The condition to match.\r\n   * @param modelFactory The factory to create a new model if the key does not exist.\r\n   * @returns The value associated with the given key, or null if no match is found.\r\n   */\r\n  private getFromMapOrCreate<T>(\r\n    map: Map<string, T | null>,\r\n    key: string,\r\n    sourceList: T[],\r\n    matchFn: (item: T) => boolean,\r\n    modelFactory: (item: T) => T\r\n  ): T | null {\r\n    if (!key) return null;\r\n    if (map.has(key)) return map.get(key) || null;\r\n\r\n    const item = sourceList.find(matchFn);\r\n    const model = item ? modelFactory(item) : null;\r\n    map.set(key, model);\r\n    return model;\r\n  }\r\n\r\n  /**\r\n   * Lazily initializes a list of models from a source list.\r\n   * It creates a new model for each item in the source list and adds it to the given map.\r\n   * It also sets the list of models to the given setter.\r\n   * @param listRef The reference to the list of models.\r\n   * @param setter The setter to set the list of models.\r\n   * @param sourceList The source list of items.\r\n   * @param map The map to store the models.\r\n   * @param getKeys The function to get the keys for the given item.\r\n   * @param modelFactory The factory to create a new model for the given item.\r\n   * @returns The list of models.\r\n   */\r\n  private lazyInitList<T, M>(\r\n    listRef: M[] | null,\r\n    setter: (list: M[]) => void,\r\n    sourceList: T[],\r\n    map: Map<string, M | null>,\r\n    getKeys: (item: T) => string[],\r\n    modelFactory: (item: T) => M\r\n  ): M[] {\r\n    // If the list is already initialized, return it.\r\n    if (listRef) return listRef;\r\n\r\n    // Create a new model for each item in the source list and add it to the map.\r\n    const models = sourceList.map((item: T) => {\r\n      const model = modelFactory(item);\r\n      getKeys(item).forEach(key => map.set(key, model));\r\n      return model;\r\n    });\r\n\r\n    // Set the list of models to the given setter.\r\n    setter(models);\r\n\r\n    // Return the list of models.\r\n    return models;\r\n  }\r\n\r\n  /**\r\n   * Finds an app object in the map by its name or id.\r\n   * If the app object is not found, it creates a new one and adds it to the map.\r\n   * @param nameOrId The name or id of the app object to find.\r\n   * @returns The app object if found, or null if not found.\r\n   */\r\n  getAppObjectByIdOrName(nameOrId: string): AppObjectModel | null {\r\n    return this.getFromMapOrCreate(\r\n      this.appObjectMap,\r\n      nameOrId,\r\n      Common.tabJson.AppObjects,\r\n      obj => obj.ObjectName === nameOrId || obj.ID?.toLowerCase() === nameOrId?.toLowerCase(),\r\n      obj => new AppObjectModel(obj, this)\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Returns a list of app objects in the metadata.\r\n   * If a filter function is given, it is applied to each app object.\r\n   * @param filterFn The filter function to apply to the app objects.\r\n   * @returns The list of app objects.\r\n   */\r\n  getAllAppObjects(filterFn?: (obj: AppObjectModel) => boolean, includeSystemData = false): AppObjectModel[] {\r\n    // Initialize the list of app objects lazily.\r\n    const list = this.lazyInitList(\r\n      this.allAppObjects,\r\n      val => (this.allAppObjects = val),\r\n      Common.tabJson.AppObjects,\r\n      this.appObjectMap,\r\n      (obj: any) => [obj.ID?.toLowerCase(), obj.ObjectName],\r\n      obj => new AppObjectModel(obj, this)\r\n    );\r\n\r\n    let filteredList: AppObjectModel[] = list;\r\n    if (!includeSystemData) {\r\n      const currentAppId = this.getCurrentAppId()?.toLowerCase();\r\n      filteredList = list.filter(obj =>\r\n        !obj.AppId ||                    // Global data (app = null)\r\n        obj.AppId === currentAppId       // Current app data\r\n      );\r\n    }\r\n\r\n    // If a filter function is given, apply it to the list of app objects.\r\n    return filterFn ? filteredList.filter(filterFn) : filteredList;\r\n  }\r\n\r\n  /**\r\n   * Returns a list of fields in the metadata.\r\n   * If a filter function is given, it is applied to each field.\r\n   * @param filterFn The filter function to apply to the fields.\r\n   * @returns The list of fields.\r\n   */\r\n  getAllFields(filterFn?: (field: AppFieldModel) => boolean, includeSystemData = false): AppFieldModel[] {\r\n    // Get a list of all fields from all app objects.\r\n    const allFields = this.getAllAppObjects(undefined, includeSystemData).flatMap(obj => obj.fields());\r\n\r\n    // If a filter function is given, apply it to the list of fields.\r\n    return filterFn ? allFields.filter(filterFn) : allFields;\r\n  }\r\n\r\n  /**\r\n   * Finds a field by its ID across all app objects\r\n   * @param fieldId The ID of the field to find\r\n   * @returns The field if found, or null if not found\r\n   */\r\n  getFieldByIdOrName(nameOrId: string): AppFieldModel | null {\r\n    if (!nameOrId) return null;\r\n    return this.getAllFields(field =>\r\n      field.ID?.toLowerCase() === nameOrId?.toLowerCase() ||\r\n      field.FieldName === nameOrId,\r\n      true\r\n    )[0] || null;\r\n  }\r\n\r\n  /**\r\n   * Returns a list of data source queries in the metadata.\r\n   * If a filter function is given, it is applied to each data source query.\r\n   * @param filterFn The filter function to apply to the data source queries.\r\n   * @returns The list of data source queries.\r\n   */\r\n  getAllDataSourceQueries(filterFn?: (dsq: DataSourceQueryModel) => boolean, includeSystemData = false): DataSourceQueryModel[] {\r\n    // Get a list of all data source queries from all app objects.\r\n    const allDSQs = this.getAllAppObjects(undefined, includeSystemData).flatMap(obj => obj.dataSourceQueries());\r\n\r\n    // If a filter function is given, apply it to the list of data source queries.\r\n    return filterFn ? allDSQs.filter(filterFn) : allDSQs;\r\n  }\r\n\r\n  /**\r\n   * Retrieves a data source query by its ID, QueryName, or DisplayName.\r\n   * Searches through all data source queries and returns the first match.\r\n   * \r\n   * @param {string} nameOrId - The ID, QueryName, or DisplayName of the data source query to retrieve.\r\n   * @returns {DataSourceQueryModel | null} - The data source query model if found, otherwise null.\r\n   */\r\n  getDataSourceQueryByIdOrName(nameOrId: string): DataSourceQueryModel | null {\r\n    // Search for the data source query by ID, QueryName, or DisplayName\r\n    return this.getAllDataSourceQueries(undefined, true).find(\r\n      dsq => dsq?.ID?.toLowerCase() === nameOrId?.toLowerCase() || dsq?.QueryName === nameOrId || dsq?.DisplayName === nameOrId\r\n    ) || null;\r\n  }\r\n\r\n  /**\r\n   * Retrieves an app screen by its ID, Name, or DisplayName.\r\n   * Searches through all app screens and returns the first match.\r\n   * \r\n   * @param {string} nameOrId - The ID, Name, or DisplayName of the app screen to retrieve.\r\n   * @returns {AppScreenModel | null} - The app screen model if found, otherwise null.\r\n   */\r\n  getAppScreenByIdOrName(nameOrId: string): AppScreenModel | null {\r\n    return this.getFromMapOrCreate(\r\n      this.appScreenMap,\r\n      nameOrId,\r\n      Common.tabJson.AppScreens,\r\n      screen => screen?.ID?.toLowerCase() === nameOrId?.toLowerCase() || screen?.Name === nameOrId,\r\n      screen => new AppScreenModel(screen)\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Retrieves a list of all app screens.\r\n   * If a filter function is given, it is applied to the list of app screens.\r\n   * \r\n   * @param {function} filterFn - The filter function to apply to the app screens.\r\n   * @returns {AppScreenModel[]} - The list of app screens.\r\n   */\r\n  getAllAppScreens(filterFn?: (screen: AppScreenModel) => boolean): AppScreenModel[] {\r\n    // Initialize the list of app screens lazily.\r\n    const list = this.lazyInitList(\r\n      this.allAppScreens,\r\n      val => (this.allAppScreens = val),\r\n      Common.tabJson.AppScreens,\r\n      this.appScreenMap,\r\n      (s: any) => [s?.ID?.toLowerCase(), s?.Name],\r\n      s => new AppScreenModel(s)\r\n    );\r\n\r\n    // If a filter function is given, apply it to the list of app screens.\r\n    return filterFn ? list.filter(filterFn) : list;\r\n  }\r\n\r\n  /**\r\n   * Retrieves an organization info by its ID or TenantCode.\r\n   * Searches through all organization info and returns the first match.\r\n   * \r\n   * @param {string} nameOrTenantCode - The ID or TenantCode of the organization info to retrieve.\r\n   * @returns {OrgInfoModel | null} - The organization info model if found, otherwise null.\r\n   */\r\n  getOrgInfoByIdOrTenantCode(nameOrTenantCode: string): OrgInfoModel | null {\r\n    return this.getFromMapOrCreate(\r\n      this.orgInfoMap,\r\n      nameOrTenantCode,\r\n      Common.tabJson.OrgInfos,\r\n      // Search for the organization info by ID or TenantCode\r\n      org => org.ID?.toLowerCase() === nameOrTenantCode?.toLowerCase() || org.TenantCode === nameOrTenantCode,\r\n      // Create a new OrgInfoModel if the organization info is found\r\n      org => new OrgInfoModel(org)\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Retrieves a list of all organization info.\r\n   * If a filter function is given, it is applied to the list of organization info.\r\n   * \r\n   * @param {function} filterFn - The filter function to apply to the organization info.\r\n   * @returns {OrgInfoModel[]} - The list of organization info.\r\n   */\r\n  getAllOrgInfos(filterFn?: (org: OrgInfoModel) => boolean): OrgInfoModel[] {\r\n    // Initialize the list of organization info lazily.\r\n    const list = this.lazyInitList(\r\n      this.allOrgInfos,\r\n      val => (this.allOrgInfos = val),\r\n      Common.tabJson.OrgInfos,\r\n      this.orgInfoMap,\r\n      (org: any) => [org?.ID?.toLowerCase(), org?.TenantCode],\r\n      org => new OrgInfoModel(org)\r\n    );\r\n\r\n    // If a filter function is given, apply it to the list of organization info.\r\n    return filterFn ? list.filter(filterFn) : list;\r\n  }\r\n\r\n  /**\r\n   * Performs a global search across all metadata for a given search term.\r\n   * You can narrow the search by providing a list of entity types to search within.\r\n   * \r\n   * @param {string} term - The search term to search for.\r\n   * @param {MetadataEntityType[]} entityTypes - The list of entity types to search within. If omitted, all entity types are searched.\r\n   * @returns {Record<string, any[]>} - A dictionary with results grouped by entity type.\r\n   */\r\n  searchMetadata(term: string, entityTypes?: MetadataEntityType[]): Record<string, any[]> {\r\n    const searchTerm = term.toLowerCase();\r\n    const result: Record<string, any[]> = {};\r\n\r\n    /**\r\n     * Helper function to determine if a given entity type should be searched.\r\n     * @param {MetadataEntityType} type - The entity type to check.\r\n     * @returns {boolean} - Whether the entity type should be searched.\r\n     */\r\n    const shouldSearch = (type: MetadataEntityType) => !entityTypes || entityTypes.includes(type);\r\n\r\n    if (shouldSearch(MetadataEntityType.APP_OBJECTS)) {\r\n      // Search for app objects by ID, ObjectName, DisplayName, or SystemDBTableName\r\n      result[MetadataEntityType.APP_OBJECTS] = this.getAllAppObjects(obj =>\r\n        [obj?.ID, obj?.ObjectName, obj?.DisplayName, obj?.SystemDBTableName]\r\n          .some(val => val === searchTerm || val?.toLowerCase().includes(searchTerm))\r\n      );\r\n    }\r\n\r\n    if (shouldSearch(MetadataEntityType.APP_FIELDS)) {\r\n      // Search for app fields by using the search method\r\n      result[MetadataEntityType.APP_FIELDS] = this.getAllFields(field => field.search(searchTerm));\r\n    }\r\n\r\n    if (shouldSearch(MetadataEntityType.DATA_SOURCE_QUERIES)) {\r\n      // Search for data source queries by using the search method\r\n      result[MetadataEntityType.DATA_SOURCE_QUERIES] = this.getAllDataSourceQueries(dsq => dsq.search(searchTerm));\r\n    }\r\n\r\n    if (shouldSearch(MetadataEntityType.APP_SCREENS)) {\r\n      // Search for app screens by using the search method\r\n      result[MetadataEntityType.APP_SCREENS] = this.getAllAppScreens(screen => screen.search(searchTerm));\r\n    }\r\n\r\n    return result;\r\n  }\r\n\r\n  /**\r\n   * Retrieves an app menu by its ID or name.\r\n   * Searches through all app menus and returns the first match.\r\n   * \r\n   * @param {string} nameOrId - The ID or name of the app menu to retrieve.\r\n   * @returns {AppMenuModel | null} - The app menu model if found, otherwise null.\r\n   */\r\n  getAppMenuByIdOrName(nameOrId: string): AppMenuModel | null {\r\n    return this.getFromMapOrCreate(\r\n      this.appMenuMap,\r\n      nameOrId,\r\n      Common.tabJson.Menus,\r\n      // Search for the app menu by ID or name\r\n      menu => menu?.Id?.toLowerCase() === nameOrId?.toLowerCase() || menu?.MenuName === nameOrId,\r\n      // Create a new AppMenuModel if the app menu is found\r\n      menu => new AppMenuModel(menu)\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Retrieves a list of all app menus.\r\n   * If a filter function is given, it is applied to the list of app menus.\r\n   * \r\n   * @param {function} filterFn - The filter function to apply to the app menus.\r\n   * @returns {AppMenuModel[]} - The list of app menus.\r\n   */\r\n  getAllAppMenus(filterFn?: (menu: AppMenuModel) => boolean): AppMenuModel[] {\r\n    // Initialize the list of app screens lazily.\r\n    const list = this.lazyInitList(\r\n      this.allAppMenus,\r\n      val => (this.allAppMenus = val),\r\n      Common.tabJson.Menus,\r\n      this.appMenuMap,\r\n      (m: any) => [m?.Id?.toLowerCase(), m?.Name],\r\n      s => new AppMenuModel(s)\r\n    );\r\n\r\n    // If a filter function is given, apply it to the list of app screens.\r\n    return filterFn ? list.filter(filterFn) : list;\r\n  }\r\n\r\n  /**\r\n   * Clears all cached metadata safely.\r\n   * This should be called on context changes (e.g., when app, org, or session changes).\r\n   */\r\n  clearCache(): void {\r\n    try {\r\n      // Clear maps\r\n      this.appObjectMap.clear();\r\n      this.appScreenMap.clear();\r\n      this.orgInfoMap.clear();\r\n      this.appMenuMap.clear();\r\n\r\n      // Reset lists\r\n      this.allAppObjects = null;\r\n      this.allAppScreens = null;\r\n      this.allOrgInfos = null;\r\n      this.allAppMenus = null;\r\n\r\n    } catch (error) {\r\n      console.warn('MetadataHelper Failed to clear cache:', error);\r\n    }\r\n  }\r\n\r\n}"]}

package/esm2022/lib/tab-core-utility/app/helpers/common/template.helpers.mjs

@@ -115,7 +115,7 @@ export class TemplateHelper {
                 }
                 obj = Object.getPrototypeOf(obj);
             }
-            if (service?.constructor?.name === 'UtilService') {
+            if (service?._isProxy) {
                 // Probe the context directly
                 const ctx = service._context;
                 if (ctx) {
@@ -252,4 +252,4 @@ export class TemplateHelper {
         type: Injectable,
         args: [{ providedIn: 'root' }]
     }], () => [], null); })();
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"template.helpers.js","sourceRoot":"","sources":["../../../../../../../../../libs/data-access/src/lib/tab-core-utility/app/helpers/common/template.helpers.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\r\nimport { Injectable, inject } from '@angular/core';\r\nimport { ApiService } from '../../../core/http-client/api.service';\r\nimport { API } from '../../constants/api-constants';\r\nimport { Liquid } from 'liquidjs';\r\nimport { catchError, from, map, Observable, of } from 'rxjs';\r\nimport { getHeaders } from '../../utils/req-res.util';\r\nimport { CommonApiResponse, TemplateParsePayload } from '../../interfaces/common.interface';\r\n\r\n@Injectable({ providedIn: 'root' })\r\nexport class TemplateHelper {\r\n  private readonly apiService = inject(ApiService);\r\n  private readonly serviceCache = new WeakMap<any, any>();\r\n  private engine = new Liquid();\r\n  \r\n  constructor() {\r\n    this.registerCallFilter();\r\n    this.registerPropFilter();\r\n  }\r\n\r\n  /**\r\n   * Parses the template using local rendering.\r\n   *\r\n   * @param template - The template to be parsed.\r\n   * @param templateVariables - The variables to be used for template rendering.\r\n   * @returns The rendered template result.\r\n   */\r\n  templateParseLocally(template: string, templateVariables: string): Promise<string> {\r\n    const data = {\r\n      ...(templateVariables?.length ? JSON.parse(templateVariables) : {}),\r\n      TabSdk: this.createSdkProxy(),\r\n    };\r\n    return this.engine.parseAndRender(template ?? '', data);\r\n  }\r\n\r\n  /**\r\n   * Parses the template universally, either using local rendering or server-side rendering.\r\n   *\r\n   * @param data - The data to be used for template parsing.\r\n   * @param shouldFailOnServerParse - Indicates whether to fail on server-side parse if local parsing fails.\r\n   * @returns An observable that emits the parsed template result.\r\n   */\r\n  templateParseUniversal(data: TemplateParsePayload, onFailedParseOnServer = true): Observable<any> {\r\n    return from(this.templateParseLocally(data.Value, data.Templatevariables)).pipe(\r\n      map((html) => ({ Result: html })),\r\n      catchError((error) => {\r\n        console.error('Local parse failed', error);\r\n        return onFailedParseOnServer ? this.templateParse(data) : of({ Result: '' });\r\n      })\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Parses the template using server-side rendering.\r\n   *\r\n   * @param data - The data to be used for template parsing.\r\n   * @returns An observable that emits the parsed template result.\r\n   */\r\n  private templateParse(data: TemplateParsePayload): Observable<CommonApiResponse> {\r\n    const headers = getHeaders();\r\n\r\n    // Makes a POST request to the server to parse the template.\r\n    return this.apiService.post(API.templateParse, data, headers);\r\n  }\r\n\r\n  /**\r\n   * Creates a proxy for the TabSdk object to expose its properties and methods.\r\n   * This allows templates to access SDK services and their properties.\r\n   *\r\n   * @returns An object containing the resolved SDK services.\r\n   */\r\n  private createSdkProxy(): any {\r\n    const sdkRoot = (window as any)?.TabSdk;\r\n    if (!sdkRoot) return {};\r\n\r\n    const resolvedSdk: any = {};\r\n    // Get static properties and resolve their values\r\n    Object.getOwnPropertyNames(sdkRoot).forEach(serviceName => {\r\n      if (serviceName === 'length' || serviceName === 'name' || serviceName === 'prototype') return;\r\n\r\n      const service = sdkRoot[serviceName];\r\n      if (!service) return;\r\n\r\n      // Create resolved service object\r\n      resolvedSdk[serviceName] = this.resolveServiceValues(service);\r\n    });\r\n\r\n    return resolvedSdk;\r\n  }\r\n\r\n  /**\r\n   * Resolves the properties and methods of a service object.\r\n   * This includes both static properties and methods, as well as prototype properties.\r\n   *\r\n   * @param service - The service object to resolve.\r\n   * @returns An object containing the resolved properties and methods.\r\n   */\r\n  private resolveServiceValues(service: any): any {\r\n    if (this.serviceCache.has(service)) {\r\n      return this.serviceCache.get(service);\r\n    }\r\n\r\n    const resolved: any = {};\r\n    try {\r\n      const deny = new Set(['__proto__', 'prototype', 'constructor']);\r\n      const seen = new Set<string>();\r\n\r\n      // walk the whole prototype chain (instance → base prototypes), stop at Object.prototype\r\n      let obj: any = service;\r\n      while (obj && obj !== Object.prototype) {\r\n        for (const prop of Object.getOwnPropertyNames(obj)) {\r\n          if (deny.has(prop) || seen.has(prop)) continue;\r\n          seen.add(prop);\r\n\r\n          let value: any;\r\n          try {\r\n            // always read off the original instance so getters see correct `this`\r\n            value = Reflect.get(service, prop);\r\n          } catch {\r\n            continue;\r\n          }\r\n\r\n          if (typeof value === 'function') {\r\n            // expose a handle so Liquid passes it through to the `call` filter\r\n            resolved[prop] = this.makeMethodHandle(service, prop);\r\n          } else if (value !== undefined) {\r\n            resolved[prop] = value;\r\n          }\r\n        }\r\n        obj = Object.getPrototypeOf(obj);\r\n      }\r\n\r\n      if (service?.constructor?.name === 'UtilService') {\r\n        // Probe the context directly\r\n        const ctx = (service as any)._context;\r\n        if (ctx) {\r\n          for (const svcName of Object.keys(ctx)) {\r\n            const svc = ctx[svcName];\r\n            if (!svc) continue;\r\n\r\n            for (const prop of Object.getOwnPropertyNames(svc.__proto__ || svc)) {\r\n              if (deny.has(prop) || seen.has(prop)) continue;\r\n              seen.add(prop);\r\n\r\n              let value: any;\r\n              try {\r\n                value = Reflect.get(service, prop); // forces proxy to resolve\r\n              } catch {\r\n                continue;\r\n              }\r\n\r\n              if (typeof value === 'function') {\r\n                resolved[prop] = this.makeMethodHandle(service, prop);\r\n              } else if (value !== undefined) {\r\n                resolved[prop] = value;\r\n              }\r\n            }\r\n          }\r\n        }\r\n      }\r\n    } catch (e) {\r\n      console.warn('TemplateHelper: resolveServiceValues failed', e);\r\n    }\r\n\r\n    this.serviceCache.set(service, resolved);\r\n    return resolved;\r\n  }\r\n\r\n  /**\r\n   * Creates a special handle object that wraps a function or method reference.\r\n   * The handle is used as a placeholder for the function or method in the\r\n   * template context, and is used by the `call` filter to invoke the\r\n   * function or method with provided arguments.\r\n   *\r\n   * @param parent - The object that the method belongs to.\r\n   * @param name - The name of the method.\r\n   * @returns A handle object that wraps the function or method.\r\n   */\r\n  private makeMethodHandle(parent: any, name: string): any {\r\n    const handle = Object.create(null);\r\n    Object.defineProperties(handle, {\r\n      __sdkHandle: { value: 'method', enumerable: false, writable: false, configurable: false },\r\n      __parent: { value: parent, enumerable: false, writable: false, configurable: false },\r\n      __name: { value: name, enumerable: false, writable: false, configurable: false }\r\n    });\r\n    return handle;\r\n  }\r\n\r\n  /**\r\n   * Registers a filter to call a function or method with provided arguments.\r\n   * This allows templates to invoke functions or methods dynamically.\r\n   */\r\n  private registerCallFilter(): void {\r\n    this.engine.registerFilter('call', async (input: any, ...args: any[]) => {\r\n      try {\r\n        // case A: input is our method handle (from resolveServiceValues)\r\n        if (input && input.__sdkHandle === 'method' && input.__parent && input.__name) {\r\n          const fn = Reflect.get(input.__parent, input.__name);\r\n          if (typeof fn !== 'function') {\r\n            return '';\r\n          }\r\n          const res = fn.apply(input.__parent, args);\r\n          return await res; // sync or async\r\n        }\r\n\r\n        // case B: input is an object and first arg is the method name\r\n        if (input && typeof input === 'object' && typeof args[0] === 'string') {\r\n          const methodName = args[0];\r\n          if (methodName === '__proto__' || methodName === 'prototype' || methodName === 'constructor') return '';\r\n          const method = Reflect.get(input, methodName);\r\n          const rest = args.slice(1);\r\n          if (typeof method === 'function') {\r\n            const res = method.apply(input, rest);\r\n            return await res;\r\n          }\r\n          // not a function → treat as property fallback\r\n          return method ?? '';\r\n        }\r\n\r\n        // (fallback) functions should not reach Liquid, but keep for safety\r\n        if (typeof input === 'function') {\r\n          const res = input(...args);\r\n          return await res;\r\n        }\r\n\r\n        return '';\r\n      } catch {\r\n        return '';\r\n      }\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Registers a filter to access properties of an object using dot or bracket notation.\r\n   * This allows templates to access nested properties safely.\r\n   */\r\n  private registerPropFilter(): void {\r\n    this.engine.registerFilter('prop', (input: any, path: any) => {\r\n      if (input == null) return '';\r\n      if (typeof path !== 'string' || !path.trim()) return '';\r\n\r\n      // support dot & simple bracket notation: a.b, a[0], a[key]\r\n      const segments = path\r\n        .replace(/\\[(\\d+)\\]/g, '.$1')     // [0] -> .0\r\n        .replace(/\\[(\\w+)\\]/g, '.$1')     // [key] -> .key\r\n        .split('.')\r\n        .map(s => s.trim())\r\n        .filter(Boolean);\r\n\r\n      let cur: any = input;\r\n\r\n      for (const seg of segments) {\r\n        if (cur == null) return '';\r\n\r\n        const idx = Number(seg);\r\n        const key: any = Number.isNaN(idx) ? seg : idx;\r\n\r\n        try {\r\n          cur = Reflect.get(cur, key);\r\n        } catch {\r\n          return '';\r\n        }\r\n      }\r\n\r\n      return cur ?? '';\r\n    });\r\n  }\r\n}\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"template.helpers.js","sourceRoot":"","sources":["../../../../../../../../../libs/data-access/src/lib/tab-core-utility/app/helpers/common/template.helpers.ts"],"names":[],"mappings":"AAAA,uDAAuD;AACvD,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,UAAU,EAAE,MAAM,uCAAuC,CAAC;AACnE,OAAO,EAAE,GAAG,EAAE,MAAM,+BAA+B,CAAC;AACpD,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,GAAG,EAAc,EAAE,EAAE,MAAM,MAAM,CAAC;AAC7D,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;;AAItD,MAAM,OAAO,cAAc;IAKzB;QAJiB,eAAU,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC;QAChC,iBAAY,GAAG,IAAI,OAAO,EAAY,CAAC;QAChD,WAAM,GAAG,IAAI,MAAM,EAAE,CAAC;QAG5B,IAAI,CAAC,kBAAkB,EAAE,CAAC;QAC1B,IAAI,CAAC,kBAAkB,EAAE,CAAC;IAC5B,CAAC;IAED;;;;;;OAMG;IACH,oBAAoB,CAAC,QAAgB,EAAE,iBAAyB;QAC9D,MAAM,IAAI,GAAG;YACX,GAAG,CAAC,iBAAiB,EAAE,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;YACnE,MAAM,EAAE,IAAI,CAAC,cAAc,EAAE;SAC9B,CAAC;QACF,OAAO,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,QAAQ,IAAI,EAAE,EAAE,IAAI,CAAC,CAAC;IAC1D,CAAC;IAED;;;;;;OAMG;IACH,sBAAsB,CAAC,IAA0B,EAAE,qBAAqB,GAAG,IAAI;QAC7E,OAAO,IAAI,CAAC,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC,IAAI,CAC7E,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC,EACjC,UAAU,CAAC,CAAC,KAAK,EAAE,EAAE;YACnB,OAAO,CAAC,KAAK,CAAC,oBAAoB,EAAE,KAAK,CAAC,CAAC;YAC3C,OAAO,qBAAqB,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,CAAC;QAC/E,CAAC,CAAC,CACH,CAAC;IACJ,CAAC;IAED;;;;;OAKG;IACK,aAAa,CAAC,IAA0B;QAC9C,MAAM,OAAO,GAAG,UAAU,EAAE,CAAC;QAE7B,4DAA4D;QAC5D,OAAO,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,aAAa,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;IAChE,CAAC;IAED;;;;;OAKG;IACK,cAAc;QACpB,MAAM,OAAO,GAAI,MAAc,EAAE,MAAM,CAAC;QACxC,IAAI,CAAC,OAAO;YAAE,OAAO,EAAE,CAAC;QAExB,MAAM,WAAW,GAAQ,EAAE,CAAC;QAC5B,iDAAiD;QACjD,MAAM,CAAC,mBAAmB,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE;YACxD,IAAI,WAAW,KAAK,QAAQ,IAAI,WAAW,KAAK,MAAM,IAAI,WAAW,KAAK,WAAW;gBAAE,OAAO;YAE9F,MAAM,OAAO,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;YACrC,IAAI,CAAC,OAAO;gBAAE,OAAO;YAErB,iCAAiC;YACjC,WAAW,CAAC,WAAW,CAAC,GAAG,IAAI,CAAC,oBAAoB,CAAC,OAAO,CAAC,CAAC;QAChE,CAAC,CAAC,CAAC;QAEH,OAAO,WAAW,CAAC;IACrB,CAAC;IAED;;;;;;OAMG;IACK,oBAAoB,CAAC,OAAY;QACvC,IAAI,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC;YACnC,OAAO,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;QACxC,CAAC;QAED,MAAM,QAAQ,GAAQ,EAAE,CAAC;QACzB,IAAI,CAAC;YACH,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,CAAC,WAAW,EAAE,WAAW,EAAE,aAAa,CAAC,CAAC,CAAC;YAChE,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAC;YAE/B,wFAAwF;YACxF,IAAI,GAAG,GAAQ,OAAO,CAAC;YACvB,OAAO,GAAG,IAAI,GAAG,KAAK,MAAM,CAAC,SAAS,EAAE,CAAC;gBACvC,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,mBAAmB,CAAC,GAAG,CAAC,EAAE,CAAC;oBACnD,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC;wBAAE,SAAS;oBAC/C,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;oBAEf,IAAI,KAAU,CAAC;oBACf,IAAI,CAAC;wBACH,sEAAsE;wBACtE,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;oBACrC,CAAC;oBAAC,MAAM,CAAC;wBACP,SAAS;oBACX,CAAC;oBAED,IAAI,OAAO,KAAK,KAAK,UAAU,EAAE,CAAC;wBAChC,mEAAmE;wBACnE,QAAQ,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,gBAAgB,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;oBACxD,CAAC;yBAAM,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;wBAC/B,QAAQ,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC;oBACzB,CAAC;gBACH,CAAC;gBACD,GAAG,GAAG,MAAM,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC;YACnC,CAAC;YAED,IAAI,OAAO,EAAE,QAAQ,EAAE,CAAC;gBACtB,6BAA6B;gBAC7B,MAAM,GAAG,GAAI,OAAe,CAAC,QAAQ,CAAC;gBACtC,IAAI,GAAG,EAAE,CAAC;oBACR,KAAK,MAAM,OAAO,IAAI,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;wBACvC,MAAM,GAAG,GAAG,GAAG,CAAC,OAAO,CAAC,CAAC;wBACzB,IAAI,CAAC,GAAG;4BAAE,SAAS;wBAEnB,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,mBAAmB,CAAC,GAAG,CAAC,SAAS,IAAI,GAAG,CAAC,EAAE,CAAC;4BACpE,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC;gCAAE,SAAS;4BAC/C,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;4BAEf,IAAI,KAAU,CAAC;4BACf,IAAI,CAAC;gCACH,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC,CAAC,0BAA0B;4BAChE,CAAC;4BAAC,MAAM,CAAC;gCACP,SAAS;4BACX,CAAC;4BAED,IAAI,OAAO,KAAK,KAAK,UAAU,EAAE,CAAC;gCAChC,QAAQ,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,gBAAgB,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;4BACxD,CAAC;iCAAM,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;gCAC/B,QAAQ,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC;4BACzB,CAAC;wBACH,CAAC;oBACH,CAAC;gBACH,CAAC;YACH,CAAC;QACH,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,OAAO,CAAC,IAAI,CAAC,6CAA6C,EAAE,CAAC,CAAC,CAAC;QACjE,CAAC;QAED,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;QACzC,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED;;;;;;;;;OASG;IACK,gBAAgB,CAAC,MAAW,EAAE,IAAY;QAChD,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QACnC,MAAM,CAAC,gBAAgB,CAAC,MAAM,EAAE;YAC9B,WAAW,EAAE,EAAE,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE;YACzF,QAAQ,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE;YACpF,MAAM,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE;SACjF,CAAC,CAAC;QACH,OAAO,MAAM,CAAC;IAChB,CAAC;IAED;;;OAGG;IACK,kBAAkB;QACxB,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,KAAK,EAAE,KAAU,EAAE,GAAG,IAAW,EAAE,EAAE;YACtE,IAAI,CAAC;gBACH,iEAAiE;gBACjE,IAAI,KAAK,IAAI,KAAK,CAAC,WAAW,KAAK,QAAQ,IAAI,KAAK,CAAC,QAAQ,IAAI,KAAK,CAAC,MAAM,EAAE,CAAC;oBAC9E,MAAM,EAAE,GAAG,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;oBACrD,IAAI,OAAO,EAAE,KAAK,UAAU,EAAE,CAAC;wBAC7B,OAAO,EAAE,CAAC;oBACZ,CAAC;oBACD,MAAM,GAAG,GAAG,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;oBAC3C,OAAO,MAAM,GAAG,CAAC,CAAC,gBAAgB;gBACpC,CAAC;gBAED,8DAA8D;gBAC9D,IAAI,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,OAAO,IAAI,CAAC,CAAC,CAAC,KAAK,QAAQ,EAAE,CAAC;oBACtE,MAAM,UAAU,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;oBAC3B,IAAI,UAAU,KAAK,WAAW,IAAI,UAAU,KAAK,WAAW,IAAI,UAAU,KAAK,aAAa;wBAAE,OAAO,EAAE,CAAC;oBACxG,MAAM,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,KAAK,EAAE,UAAU,CAAC,CAAC;oBAC9C,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;oBAC3B,IAAI,OAAO,MAAM,KAAK,UAAU,EAAE,CAAC;wBACjC,MAAM,GAAG,GAAG,MAAM,CAAC,KAAK,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;wBACtC,OAAO,MAAM,GAAG,CAAC;oBACnB,CAAC;oBACD,8CAA8C;oBAC9C,OAAO,MAAM,IAAI,EAAE,CAAC;gBACtB,CAAC;gBAED,oEAAoE;gBACpE,IAAI,OAAO,KAAK,KAAK,UAAU,EAAE,CAAC;oBAChC,MAAM,GAAG,GAAG,KAAK,CAAC,GAAG,IAAI,CAAC,CAAC;oBAC3B,OAAO,MAAM,GAAG,CAAC;gBACnB,CAAC;gBAED,OAAO,EAAE,CAAC;YACZ,CAAC;YAAC,MAAM,CAAC;gBACP,OAAO,EAAE,CAAC;YACZ,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;OAGG;IACK,kBAAkB;QACxB,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,CAAC,KAAU,EAAE,IAAS,EAAE,EAAE;YAC3D,IAAI,KAAK,IAAI,IAAI;gBAAE,OAAO,EAAE,CAAC;YAC7B,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE;gBAAE,OAAO,EAAE,CAAC;YAExD,2DAA2D;YAC3D,MAAM,QAAQ,GAAG,IAAI;iBAClB,OAAO,CAAC,YAAY,EAAE,KAAK,CAAC,CAAK,YAAY;iBAC7C,OAAO,CAAC,YAAY,EAAE,KAAK,CAAC,CAAK,gBAAgB;iBACjD,KAAK,CAAC,GAAG,CAAC;iBACV,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;iBAClB,MAAM,CAAC,OAAO,CAAC,CAAC;YAEnB,IAAI,GAAG,GAAQ,KAAK,CAAC;YAErB,KAAK,MAAM,GAAG,IAAI,QAAQ,EAAE,CAAC;gBAC3B,IAAI,GAAG,IAAI,IAAI;oBAAE,OAAO,EAAE,CAAC;gBAE3B,MAAM,GAAG,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;gBACxB,MAAM,GAAG,GAAQ,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC;gBAE/C,IAAI,CAAC;oBACH,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;gBAC9B,CAAC;gBAAC,MAAM,CAAC;oBACP,OAAO,EAAE,CAAC;gBACZ,CAAC;YACH,CAAC;YAED,OAAO,GAAG,IAAI,EAAE,CAAC;QACnB,CAAC,CAAC,CAAC;IACL,CAAC;+EAhQU,cAAc;uEAAd,cAAc,WAAd,cAAc,mBADD,MAAM;;iFACnB,cAAc;cAD1B,UAAU;eAAC,EAAE,UAAU,EAAE,MAAM,EAAE","sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\r\nimport { Injectable, inject } from '@angular/core';\r\nimport { ApiService } from '../../../core/http-client/api.service';\r\nimport { API } from '../../constants/api-constants';\r\nimport { Liquid } from 'liquidjs';\r\nimport { catchError, from, map, Observable, of } from 'rxjs';\r\nimport { getHeaders } from '../../utils/req-res.util';\r\nimport { CommonApiResponse, TemplateParsePayload } from '../../interfaces/common.interface';\r\n\r\n@Injectable({ providedIn: 'root' })\r\nexport class TemplateHelper {\r\n  private readonly apiService = inject(ApiService);\r\n  private readonly serviceCache = new WeakMap<any, any>();\r\n  private engine = new Liquid();\r\n  \r\n  constructor() {\r\n    this.registerCallFilter();\r\n    this.registerPropFilter();\r\n  }\r\n\r\n  /**\r\n   * Parses the template using local rendering.\r\n   *\r\n   * @param template - The template to be parsed.\r\n   * @param templateVariables - The variables to be used for template rendering.\r\n   * @returns The rendered template result.\r\n   */\r\n  templateParseLocally(template: string, templateVariables: string): Promise<string> {\r\n    const data = {\r\n      ...(templateVariables?.length ? JSON.parse(templateVariables) : {}),\r\n      TabSdk: this.createSdkProxy(),\r\n    };\r\n    return this.engine.parseAndRender(template ?? '', data);\r\n  }\r\n\r\n  /**\r\n   * Parses the template universally, either using local rendering or server-side rendering.\r\n   *\r\n   * @param data - The data to be used for template parsing.\r\n   * @param shouldFailOnServerParse - Indicates whether to fail on server-side parse if local parsing fails.\r\n   * @returns An observable that emits the parsed template result.\r\n   */\r\n  templateParseUniversal(data: TemplateParsePayload, onFailedParseOnServer = true): Observable<any> {\r\n    return from(this.templateParseLocally(data.Value, data.Templatevariables)).pipe(\r\n      map((html) => ({ Result: html })),\r\n      catchError((error) => {\r\n        console.error('Local parse failed', error);\r\n        return onFailedParseOnServer ? this.templateParse(data) : of({ Result: '' });\r\n      })\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Parses the template using server-side rendering.\r\n   *\r\n   * @param data - The data to be used for template parsing.\r\n   * @returns An observable that emits the parsed template result.\r\n   */\r\n  private templateParse(data: TemplateParsePayload): Observable<CommonApiResponse> {\r\n    const headers = getHeaders();\r\n\r\n    // Makes a POST request to the server to parse the template.\r\n    return this.apiService.post(API.templateParse, data, headers);\r\n  }\r\n\r\n  /**\r\n   * Creates a proxy for the TabSdk object to expose its properties and methods.\r\n   * This allows templates to access SDK services and their properties.\r\n   *\r\n   * @returns An object containing the resolved SDK services.\r\n   */\r\n  private createSdkProxy(): any {\r\n    const sdkRoot = (window as any)?.TabSdk;\r\n    if (!sdkRoot) return {};\r\n\r\n    const resolvedSdk: any = {};\r\n    // Get static properties and resolve their values\r\n    Object.getOwnPropertyNames(sdkRoot).forEach(serviceName => {\r\n      if (serviceName === 'length' || serviceName === 'name' || serviceName === 'prototype') return;\r\n\r\n      const service = sdkRoot[serviceName];\r\n      if (!service) return;\r\n\r\n      // Create resolved service object\r\n      resolvedSdk[serviceName] = this.resolveServiceValues(service);\r\n    });\r\n\r\n    return resolvedSdk;\r\n  }\r\n\r\n  /**\r\n   * Resolves the properties and methods of a service object.\r\n   * This includes both static properties and methods, as well as prototype properties.\r\n   *\r\n   * @param service - The service object to resolve.\r\n   * @returns An object containing the resolved properties and methods.\r\n   */\r\n  private resolveServiceValues(service: any): any {\r\n    if (this.serviceCache.has(service)) {\r\n      return this.serviceCache.get(service);\r\n    }\r\n\r\n    const resolved: any = {};\r\n    try {\r\n      const deny = new Set(['__proto__', 'prototype', 'constructor']);\r\n      const seen = new Set<string>();\r\n\r\n      // walk the whole prototype chain (instance → base prototypes), stop at Object.prototype\r\n      let obj: any = service;\r\n      while (obj && obj !== Object.prototype) {\r\n        for (const prop of Object.getOwnPropertyNames(obj)) {\r\n          if (deny.has(prop) || seen.has(prop)) continue;\r\n          seen.add(prop);\r\n\r\n          let value: any;\r\n          try {\r\n            // always read off the original instance so getters see correct `this`\r\n            value = Reflect.get(service, prop);\r\n          } catch {\r\n            continue;\r\n          }\r\n\r\n          if (typeof value === 'function') {\r\n            // expose a handle so Liquid passes it through to the `call` filter\r\n            resolved[prop] = this.makeMethodHandle(service, prop);\r\n          } else if (value !== undefined) {\r\n            resolved[prop] = value;\r\n          }\r\n        }\r\n        obj = Object.getPrototypeOf(obj);\r\n      }\r\n\r\n      if (service?._isProxy) {\r\n        // Probe the context directly\r\n        const ctx = (service as any)._context;\r\n        if (ctx) {\r\n          for (const svcName of Object.keys(ctx)) {\r\n            const svc = ctx[svcName];\r\n            if (!svc) continue;\r\n\r\n            for (const prop of Object.getOwnPropertyNames(svc.__proto__ || svc)) {\r\n              if (deny.has(prop) || seen.has(prop)) continue;\r\n              seen.add(prop);\r\n\r\n              let value: any;\r\n              try {\r\n                value = Reflect.get(service, prop); // forces proxy to resolve\r\n              } catch {\r\n                continue;\r\n              }\r\n\r\n              if (typeof value === 'function') {\r\n                resolved[prop] = this.makeMethodHandle(service, prop);\r\n              } else if (value !== undefined) {\r\n                resolved[prop] = value;\r\n              }\r\n            }\r\n          }\r\n        }\r\n      }\r\n    } catch (e) {\r\n      console.warn('TemplateHelper: resolveServiceValues failed', e);\r\n    }\r\n\r\n    this.serviceCache.set(service, resolved);\r\n    return resolved;\r\n  }\r\n\r\n  /**\r\n   * Creates a special handle object that wraps a function or method reference.\r\n   * The handle is used as a placeholder for the function or method in the\r\n   * template context, and is used by the `call` filter to invoke the\r\n   * function or method with provided arguments.\r\n   *\r\n   * @param parent - The object that the method belongs to.\r\n   * @param name - The name of the method.\r\n   * @returns A handle object that wraps the function or method.\r\n   */\r\n  private makeMethodHandle(parent: any, name: string): any {\r\n    const handle = Object.create(null);\r\n    Object.defineProperties(handle, {\r\n      __sdkHandle: { value: 'method', enumerable: false, writable: false, configurable: false },\r\n      __parent: { value: parent, enumerable: false, writable: false, configurable: false },\r\n      __name: { value: name, enumerable: false, writable: false, configurable: false }\r\n    });\r\n    return handle;\r\n  }\r\n\r\n  /**\r\n   * Registers a filter to call a function or method with provided arguments.\r\n   * This allows templates to invoke functions or methods dynamically.\r\n   */\r\n  private registerCallFilter(): void {\r\n    this.engine.registerFilter('call', async (input: any, ...args: any[]) => {\r\n      try {\r\n        // case A: input is our method handle (from resolveServiceValues)\r\n        if (input && input.__sdkHandle === 'method' && input.__parent && input.__name) {\r\n          const fn = Reflect.get(input.__parent, input.__name);\r\n          if (typeof fn !== 'function') {\r\n            return '';\r\n          }\r\n          const res = fn.apply(input.__parent, args);\r\n          return await res; // sync or async\r\n        }\r\n\r\n        // case B: input is an object and first arg is the method name\r\n        if (input && typeof input === 'object' && typeof args[0] === 'string') {\r\n          const methodName = args[0];\r\n          if (methodName === '__proto__' || methodName === 'prototype' || methodName === 'constructor') return '';\r\n          const method = Reflect.get(input, methodName);\r\n          const rest = args.slice(1);\r\n          if (typeof method === 'function') {\r\n            const res = method.apply(input, rest);\r\n            return await res;\r\n          }\r\n          // not a function → treat as property fallback\r\n          return method ?? '';\r\n        }\r\n\r\n        // (fallback) functions should not reach Liquid, but keep for safety\r\n        if (typeof input === 'function') {\r\n          const res = input(...args);\r\n          return await res;\r\n        }\r\n\r\n        return '';\r\n      } catch {\r\n        return '';\r\n      }\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Registers a filter to access properties of an object using dot or bracket notation.\r\n   * This allows templates to access nested properties safely.\r\n   */\r\n  private registerPropFilter(): void {\r\n    this.engine.registerFilter('prop', (input: any, path: any) => {\r\n      if (input == null) return '';\r\n      if (typeof path !== 'string' || !path.trim()) return '';\r\n\r\n      // support dot & simple bracket notation: a.b, a[0], a[key]\r\n      const segments = path\r\n        .replace(/\\[(\\d+)\\]/g, '.$1')     // [0] -> .0\r\n        .replace(/\\[(\\w+)\\]/g, '.$1')     // [key] -> .key\r\n        .split('.')\r\n        .map(s => s.trim())\r\n        .filter(Boolean);\r\n\r\n      let cur: any = input;\r\n\r\n      for (const seg of segments) {\r\n        if (cur == null) return '';\r\n\r\n        const idx = Number(seg);\r\n        const key: any = Number.isNaN(idx) ? seg : idx;\r\n\r\n        try {\r\n          cur = Reflect.get(cur, key);\r\n        } catch {\r\n          return '';\r\n        }\r\n      }\r\n\r\n      return cur ?? '';\r\n    });\r\n  }\r\n}\r\n"]}

package/esm2022/lib/tab-core-utility/app/helpers/common/user-personalization.helper.mjs

@@ -73,4 +73,4 @@ export class UserPersonalizationHelper {
         type: Injectable,
         args: [{ providedIn: 'root' }]
     }], null, null); })();
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"user-personalization.helper.js","sourceRoot":"","sources":["../../../../../../../../../libs/data-access/src/lib/tab-core-utility/app/helpers/common/user-personalization.helper.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\n\nimport { Injectable, inject } from '@angular/core';\nimport { IdbService } from '../../../auth/idb-storage.service';\nimport { Common } from '../../constants/common';\nimport { StorageConstants } from '../../constants/storage-constants';\n\n@Injectable({ providedIn: 'root' })\nexport class UserPersonalizationHelper {\n\n  private readonly idbService = inject(IdbService);\n\n  setUserPersonalizedData(data: any) {\n    Common.tabUserPersonalizedData = data;\n    this.idbService.setItem(StorageConstants.tabUserPersonalizedData, data);\n  }\n\n  getUserPersonalizedData(screenId: string, componentId: string, type: number, userId: string | null, key?: string | null, tenantId?: string | null) {\n    return this.filterUserPersonalizedData(Common?.tabUserPersonalizedData, screenId, componentId, type, userId, key, tenantId);\n  }\n\n  filterUserPersonalizedData(data: any, screenId: string, componentId: string, type: number, userId: string | null, key?: string | null, tenantId?: string | null) {\n    let filteredData = data?.filter((item: any) => item?.ScreenId?.toLowerCase() === screenId?.toLowerCase() && item?.ComponentId === componentId && item?.Type === type);\n\n    const keyFilteredData = filteredData?.filter((item: any) => item?.Key?.toLowerCase() === key?.toLowerCase());\n    if (keyFilteredData?.length > 0) {\n      filteredData = keyFilteredData;\n    } else {\n      filteredData = filteredData?.filter((item: any) => item?.Key === null);\n    }\n\n    const userFilteredData = filteredData?.filter((item: any) => item?.UserId?.toLowerCase() === userId?.toLowerCase());\n    if (userFilteredData?.length > 0) {\n      filteredData = userFilteredData;\n    } else {\n      const tenantDefaultData = filteredData?.filter((item: any) => item?.UserId === null && item?.RecordInfo?.TenantId?.toLowerCase() === tenantId?.toLowerCase());\n      if (tenantId && tenantDefaultData?.length > 0) {\n        filteredData = tenantDefaultData;\n      } else {\n        filteredData = filteredData?.filter((item: any) => item?.UserId === null);\n      }\n    }\n\n    return filteredData;\n  }\n\n  /**\n   * Finds a user's personalized data for a given key and type.\n   * Executes the following steps:\n   * 1. Filters out records where the Type does not match the specified type.\n   * 2. Sorts the data in descending order based on the UserId field. If the UserId\n   *    is null, it is placed at the end of the sorted array.\n   * 3. Filters out records where the UserId does not match the specified userId.\n   *    If the UserId is null, the record is not filtered out.\n   * 4. Finds the first record where the Key matches the specified key.\n   * @param key The key to search for.\n   * @param type The type of data to search for.\n   * @param userId The ID of the user to search for.\n   * @returns The user's personalized data, or undefined if not found.\n   * @author Parth B Thakkar\n   * @date 2023-11-28\n   */\n  getUserPersonalizedDataFromKey(key: string, type: number, userId: string) {\n    const data = (Common?.tabUserPersonalizedData || [])\n      .filter((item: any) => item?.Type === type)\n      .sort(\n        (a: any, b: any) =>\n          (a?.UserId === null ? 1 : 0) - (b?.UserId === null ? 1 : 0) ||\n          (a?.UserId?.toLowerCase() === userId?.toLowerCase() ? -1 : 1)\n      )\n      .filter((item: any) =>\n        item?.UserId\n          ? item?.UserId?.toLowerCase() === userId?.toLowerCase()\n          : true\n      )\n      .find((item: any) => item?.Key?.toLowerCase() === key?.toLowerCase());\n\n    return data;\n  }\n\n}"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"user-personalization.helper.js","sourceRoot":"","sources":["../../../../../../../../../libs/data-access/src/lib/tab-core-utility/app/helpers/common/user-personalization.helper.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\r\n\r\nimport { Injectable, inject } from '@angular/core';\r\nimport { IdbService } from '../../../auth/idb-storage.service';\r\nimport { Common } from '../../constants/common';\r\nimport { StorageConstants } from '../../constants/storage-constants';\r\n\r\n@Injectable({ providedIn: 'root' })\r\nexport class UserPersonalizationHelper {\r\n\r\n  private readonly idbService = inject(IdbService);\r\n\r\n  setUserPersonalizedData(data: any) {\r\n    Common.tabUserPersonalizedData = data;\r\n    this.idbService.setItem(StorageConstants.tabUserPersonalizedData, data);\r\n  }\r\n\r\n  getUserPersonalizedData(screenId: string, componentId: string, type: number, userId: string | null, key?: string | null, tenantId?: string | null) {\r\n    return this.filterUserPersonalizedData(Common?.tabUserPersonalizedData, screenId, componentId, type, userId, key, tenantId);\r\n  }\r\n\r\n  filterUserPersonalizedData(data: any, screenId: string, componentId: string, type: number, userId: string | null, key?: string | null, tenantId?: string | null) {\r\n    let filteredData = data?.filter((item: any) => item?.ScreenId?.toLowerCase() === screenId?.toLowerCase() && item?.ComponentId === componentId && item?.Type === type);\r\n\r\n    const keyFilteredData = filteredData?.filter((item: any) => item?.Key?.toLowerCase() === key?.toLowerCase());\r\n    if (keyFilteredData?.length > 0) {\r\n      filteredData = keyFilteredData;\r\n    } else {\r\n      filteredData = filteredData?.filter((item: any) => item?.Key === null);\r\n    }\r\n\r\n    const userFilteredData = filteredData?.filter((item: any) => item?.UserId?.toLowerCase() === userId?.toLowerCase());\r\n    if (userFilteredData?.length > 0) {\r\n      filteredData = userFilteredData;\r\n    } else {\r\n      const tenantDefaultData = filteredData?.filter((item: any) => item?.UserId === null && item?.RecordInfo?.TenantId?.toLowerCase() === tenantId?.toLowerCase());\r\n      if (tenantId && tenantDefaultData?.length > 0) {\r\n        filteredData = tenantDefaultData;\r\n      } else {\r\n        filteredData = filteredData?.filter((item: any) => item?.UserId === null);\r\n      }\r\n    }\r\n\r\n    return filteredData;\r\n  }\r\n\r\n  /**\r\n   * Finds a user's personalized data for a given key and type.\r\n   * Executes the following steps:\r\n   * 1. Filters out records where the Type does not match the specified type.\r\n   * 2. Sorts the data in descending order based on the UserId field. If the UserId\r\n   *    is null, it is placed at the end of the sorted array.\r\n   * 3. Filters out records where the UserId does not match the specified userId.\r\n   *    If the UserId is null, the record is not filtered out.\r\n   * 4. Finds the first record where the Key matches the specified key.\r\n   * @param key The key to search for.\r\n   * @param type The type of data to search for.\r\n   * @param userId The ID of the user to search for.\r\n   * @returns The user's personalized data, or undefined if not found.\r\n   * @author Parth B Thakkar\r\n   * @date 2023-11-28\r\n   */\r\n  getUserPersonalizedDataFromKey(key: string, type: number, userId: string) {\r\n    const data = (Common?.tabUserPersonalizedData || [])\r\n      .filter((item: any) => item?.Type === type)\r\n      .sort(\r\n        (a: any, b: any) =>\r\n          (a?.UserId === null ? 1 : 0) - (b?.UserId === null ? 1 : 0) ||\r\n          (a?.UserId?.toLowerCase() === userId?.toLowerCase() ? -1 : 1)\r\n      )\r\n      .filter((item: any) =>\r\n        item?.UserId\r\n          ? item?.UserId?.toLowerCase() === userId?.toLowerCase()\r\n          : true\r\n      )\r\n      .find((item: any) => item?.Key?.toLowerCase() === key?.toLowerCase());\r\n\r\n    return data;\r\n  }\r\n\r\n}"]}

package/esm2022/lib/tab-core-utility/app/interfaces/auth.interface.mjs

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0aC5pbnRlcmZhY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2RhdGEtYWNjZXNzL3NyYy9saWIvdGFiLWNvcmUtdXRpbGl0eS9hcHAvaW50ZXJmYWNlcy9hdXRoLmludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGludGVyZmFjZSBOZXdVc2VyUmVxdWVzdCB7XG4gIHVzZXJuYW1lPzogc3RyaW5nO1xuICBlbWFpbDogc3RyaW5nO1xuICBwYXNzd29yZDogc3RyaW5nO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIExvZ2luVXNlclJlcXVlc3Qge1xuICBlbWFpbDogc3RyaW5nO1xuICBwYXNzd29yZDogc3RyaW5nO1xufVxuXG4vLyBleHBvcnQgaW50ZXJmYWNlIEZvcmdvdFBhc3N3b3JkVXNlclJlcXVlc3Qge1xuLy8gICBlbWFpbDogc3RyaW5nO1xuLy8gfVxuXG5leHBvcnQgaW50ZXJmYWNlIFJlc2V0UGFzc3dvcmRVc2VyUmVxdWVzdCB7XG4gIEVtYWlsOiBzdHJpbmcsXG4gIE5ld1Bhc3N3b3JkOiBzdHJpbmdcbn1cblxuZXhwb3J0IGludGVyZmFjZSBDaGFuZ2VQYXNzd29yZFVzZXJSZXF1ZXN0IHtcbiAgRW1haWw6IHN0cmluZyxcbiAgTmV3UGFzc3dvcmQ6IHN0cmluZztcbiAgQ3VycmVudFBhc3N3b3JkOiBzdHJpbmdcbn1cblxuZXhwb3J0IGludGVyZmFjZSBSZWdpc3RlclRlbmFudCB7XG4gIEFkbWluRmlyc3ROYW1lOiBzdHJpbmcsXG4gIEFkbWluTGFzdE5hbWU6IHN0cmluZyxcbiAgQWRtaW5FbWFpbDogc3RyaW5nLFxuICBQYXNzd29yZDogc3RyaW5nLFxuICBUZW5hbnROYW1lOiBzdHJpbmcsXG4gIHRlcm1zOiBib29sZWFuXG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgUmVmcmVzaFRva2VuUmVxdWVzdCB7XG4gIFRva2VuOiBzdHJpbmc7XG4gIFJlZnJlc2hUb2tlbjogc3RyaW5nO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIFVzZXJEZXRhaWxzUmVxdWVzdCB7XG4gIFVzZXJuYW1lPzogc3RyaW5nOyBcbiAgVXNlcklkPzogc3RyaW5nXG59Il19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0aC5pbnRlcmZhY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2RhdGEtYWNjZXNzL3NyYy9saWIvdGFiLWNvcmUtdXRpbGl0eS9hcHAvaW50ZXJmYWNlcy9hdXRoLmludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGludGVyZmFjZSBOZXdVc2VyUmVxdWVzdCB7XHJcbiAgdXNlcm5hbWU/OiBzdHJpbmc7XHJcbiAgZW1haWw6IHN0cmluZztcclxuICBwYXNzd29yZDogc3RyaW5nO1xyXG59XHJcblxyXG5leHBvcnQgaW50ZXJmYWNlIExvZ2luVXNlclJlcXVlc3Qge1xyXG4gIGVtYWlsOiBzdHJpbmc7XHJcbiAgcGFzc3dvcmQ6IHN0cmluZztcclxufVxyXG5cclxuLy8gZXhwb3J0IGludGVyZmFjZSBGb3Jnb3RQYXNzd29yZFVzZXJSZXF1ZXN0IHtcclxuLy8gICBlbWFpbDogc3RyaW5nO1xyXG4vLyB9XHJcblxyXG5leHBvcnQgaW50ZXJmYWNlIFJlc2V0UGFzc3dvcmRVc2VyUmVxdWVzdCB7XHJcbiAgRW1haWw6IHN0cmluZyxcclxuICBOZXdQYXNzd29yZDogc3RyaW5nXHJcbn1cclxuXHJcbmV4cG9ydCBpbnRlcmZhY2UgQ2hhbmdlUGFzc3dvcmRVc2VyUmVxdWVzdCB7XHJcbiAgRW1haWw6IHN0cmluZyxcclxuICBOZXdQYXNzd29yZDogc3RyaW5nO1xyXG4gIEN1cnJlbnRQYXNzd29yZDogc3RyaW5nXHJcbn1cclxuXHJcbmV4cG9ydCBpbnRlcmZhY2UgUmVnaXN0ZXJUZW5hbnQge1xyXG4gIEFkbWluRmlyc3ROYW1lOiBzdHJpbmcsXHJcbiAgQWRtaW5MYXN0TmFtZTogc3RyaW5nLFxyXG4gIEFkbWluRW1haWw6IHN0cmluZyxcclxuICBQYXNzd29yZDogc3RyaW5nLFxyXG4gIFRlbmFudE5hbWU6IHN0cmluZyxcclxuICB0ZXJtczogYm9vbGVhblxyXG59XHJcblxyXG5leHBvcnQgaW50ZXJmYWNlIFJlZnJlc2hUb2tlblJlcXVlc3Qge1xyXG4gIFRva2VuOiBzdHJpbmc7XHJcbiAgUmVmcmVzaFRva2VuOiBzdHJpbmc7XHJcbn1cclxuXHJcbmV4cG9ydCBpbnRlcmZhY2UgVXNlckRldGFpbHNSZXF1ZXN0IHtcclxuICBVc2VybmFtZT86IHN0cmluZzsgXHJcbiAgVXNlcklkPzogc3RyaW5nXHJcbn0iXX0=

package/esm2022/lib/tab-core-utility/app/interfaces/common.interface.mjs

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

package/esm2022/lib/tab-core-utility/app/interfaces/grid.interface.mjs

@@ -1,3 +1,3 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 export {};
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"grid.interface.js","sourceRoot":"","sources":["../../../../../../../../libs/data-access/src/lib/tab-core-utility/app/interfaces/grid.interface.ts"],"names":[],"mappings":"AAAA,uDAAuD","sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\n\nimport { LookUpDetails } from \"../models/data-source-queries.class\";\n\nexport interface JqWidghtModel {\n  width?: number | any;\n  height?: number | any;\n  source?: SourceModel;\n  columns?: Array<ColumnDetailModel>;\n  isPageable?: boolean;\n  isAutoheight?: boolean;\n  isSortable?: boolean;\n  selectionmode?: string;\n  columngroups?: Array<ColumngroupModel>;\n  isAltRow?: boolean;\n  isenabletooltips?: boolean;\n  iseditable?: boolean;\n  sourceId?: string;\n  typeOfData?: string;\n  actualData?: Array<any>;\n  dataField?: Array<DataFieldsModel>;\n  actionArray?: Array<ActionModel>;\n  isShowToolbar?: boolean;\n  isShowStatusBar?: boolean;\n  actionsIn?: string;\n  isFilterable?: boolean;\n  isSortbackGroungColor?: boolean;\n  isautoshowfiltericon?: boolean;\n  isshowfilterrow?: boolean;\n  pagermode?: string;\n  isGroupable?: boolean;\n  isRowlevelEdit?: boolean;\n  isRowlevelDelete?: boolean;\n  isRowlevelView?: boolean;\n  primaryKeycolumnName?: string;\n  gridId?: string;\n  id?: string;\n  groups?: any;\n  groupColumns?: string;\n  gridColumnArr?: Array<string> | any;\n  theme?: string;\n  pagesizeoptions?: string;\n  defaultPageSize?: string;\n  currentScreenId?: string;\n  customNavigate?: string;\n  gridName?: string;\n  gridState?: string | any;\n  iscolumnsreorder?: boolean;\n  isStateB?: boolean;\n  addScreenId?: string;\n  editScreenId?: string;\n  viewScreenId?: string;\n}\n\nexport interface SourceModel {\n  datatype?: string;\n  datafields?: Array<DataFieldsModel>;\n  id?: string;\n  localdata?: any;\n  pagesize?: string;\n}\n\nexport interface DataFieldsModel {\n  name?: string;\n  type?: string;\n  seq?: number;\n}\n\nexport interface ColumnDetailModel {\n  text?: string;\n  dataField?: string;\n  width?: string;\n  cellsalign?: string;\n  cellsformat?: string;\n  columnType?: string;\n  columnGroup?: string;\n  editable?: boolean;\n  buttonclick?: any;\n  renderer?: any;\n  columntype?: string;\n  filtertype?: string;\n  seq?: number;\n  align?: string;\n  sortable?: boolean;\n  hidden?: boolean;\n  filterable?: boolean;\n  cellsrenderer?: any;\n  filterParameter?: string;\n  addScreenId?: string;\n  editScreenId?: string;\n  viewScreenId?: string;\n  appFieldId?: string;\n  isPrimaryKey?: boolean;\n  LookUpDetails?: any;\n  dropDownLookup?: any;\n  SystemDBFieldName?: any;\n}\n\nexport interface ColumngroupModel {\n  text?: string;\n  align?: string;\n  name?: string;\n}\n\nexport interface ActionModel {\n  name?: string;\n  imgSrc?: string;\n  buttonWidth?: number;\n  buttonHeight?: number;\n  buttonValue?: string;\n  imgPosition?: string;\n  textPosition?: string;\n  textImageRelation?: string;\n}\n\nexport interface ColumnLevelActions {\n  name?: string;\n  rowId?: number;\n  valueToShow?: string;\n}\n\n\n/**\n * Interface for a class Column\n */\nexport interface SyncfusionGridColumnModel {\n  // for edit tamplates\n  edit?: any;\n\n  LookUpDetails?: LookUpDetails;\n  /**\n   * Defines the field name of column which is mapped with mapping name of DataSource.\n   * The bounded columns can be sort, filter and group etc.,\n   * If the `field` name contains “dot”, then it is considered as complex binding.\n   * The `field` name must be a valid JavaScript identifier,\n   * the first character must be an alphabet and should not contain spaces and special characters.\n   *\n   * @default ''\n   */\n  field?: string;\n  /**\n   * Gets the unique identifier value of the column. It is used to get the object.\n   *\n   * @default ''\n   */\n  uid?: string;\n  /**\n   * Gets the unique identifier value of the column. It is used to get the object.\n   *\n   * @default null\n   */\n  index?: number;\n  /**\n   * Defines the header text of column which is used to display in column header.\n   * If `headerText` is not defined, then field name value will be assigned to header text.\n   *\n   * @default null\n   */\n  headerText?: string;\n  /**\n   * Defines the width of the column in pixels or percentage.\n   *\n   * @default ''\n   */\n  width?: string | number;\n  /**\n   * Defines the minimum width of the column in pixels or percentage.\n   *\n   * @default ''\n   */\n  minWidth?: string | number;\n  /**\n   * Defines the maximum width of the column in pixel or percentage, which will restrict resizing beyond this pixel or percentage.\n   *\n   * @default ''\n   */\n  maxWidth?: string | number;\n  /**\n   * Defines the alignment of the column in both header and content cells.\n   *\n   * @default Left\n   */\n  textAlign?: TextAlign;\n  /**\n   * Defines the cell content's overflow mode. The available modes are\n   * * `Clip` -  Truncates the cell content when it overflows its area.\n   * * `Ellipsis` -  Displays ellipsis when the cell content overflows its area.\n   * * `EllipsisWithTooltip` - Displays ellipsis when the cell content overflows its area\n   * also it will display tooltip while hover on ellipsis applied cell.\n   *\n   * @default Ellipsis\n   */\n  clipMode?: ClipMode;\n  /**\n   * Define the alignment of column header which is used to align the text of column header.\n   *\n   * @aspdefaultvalueignore\n   * @default null\n   */\n  headerTextAlign?: TextAlign;\n  /**\n   * If `disableHtmlEncode` is set to true, it encodes the HTML of the header and content cells.\n   *\n   * @default true\n   */\n  disableHtmlEncode?: boolean;\n  /**\n   * Defines the data type of the column.\n   *\n   * @default null\n   */\n  type?: string;\n  /**\n   * It is used to change display value with the given format and does not affect the original data.\n   * Gets the format from the user which can be standard or custom\n   * [`number`](../../common/internationalization/#manipulating-numbers)\n   * and [`date`](../../common/internationalization/#manipulating-datetime) formats.\n   *\n   * @default null\n   * @aspType string\n   */\n  // format?: string | NumberFormatOptions | DateFormatOptions;\n  format?: string;\n  /**\n   * If `visible` is set to false, hides the particular column. By default, all columns are displayed.\n   *\n   * @default true\n   */\n  visible?: boolean;\n  /**\n   * Defines the column template that renders customized element in each cell of the column.\n   * It accepts either [template string](../../common/template-engine/) or HTML element ID.\n   *\n   * @default null\n   * @aspType string\n   */\n  template?: string | Function;\n  /**\n   * Defines the column template as string or HTML element ID which is used to add customized element in the column header.\n   *\n   * @default null\n   * @aspType string\n   */\n  headerTemplate?: string | Function;\n  /**\n   * You can use this property to freeze selected columns in grid.\n   *\n   * @default false\n   */\n  isFrozen?: boolean;\n  /**\n   * If `allowSorting` set to false, then it disables sorting option of a particular column.\n   * By default all columns are sortable.\n   *\n   * @default true\n   */\n  allowSorting?: boolean;\n  /**\n   * If `allowResizing` set to false, it disables resize option of a particular column.\n   *\n   * @default true\n   */\n  allowResizing?: boolean;\n  /**\n   * If `showColumnMenu` set to false, then it disable the column menu of a particular column.\n   * By default column menu will show for all columns\n   *\n   * @default true\n   */\n  showColumnMenu?: boolean;\n  /**\n   * If `allowFiltering` set to false, then it disables filtering option and filter bar element of a particular column.\n   * By default all columns are filterable.\n   *\n   * @default true\n   */\n  allowFiltering?: boolean;\n  /**\n   * If `allowGrouping` set to false, then it disables grouping of a particular column.\n   * By default all columns are groupable.\n   *\n   * @default true\n   */\n  allowGrouping?: boolean;\n  /**\n   * If `allowReordering` set to false, then it disables reorder of a particular column.\n   * By default all columns can be reorder.\n   *\n   * @default true\n   */\n  allowReordering?: boolean;\n  /**\n   * If `enableGroupByFormat` set to true, then it groups the particular column by formatted values.\n   * By default no columns are group by format.\n   *\n   * @default true\n   */\n  enableGroupByFormat?: boolean;\n  /**\n   * If `allowEditing` set to false, then it disables editing of a particular column.\n   * By default all columns are editable.\n   *\n   * @default true\n   */\n  allowEditing?: boolean;\n  /**\n   * @hidden\n   * Gets the current view foreign key data.\n   * @default []\n   */\n  columnData?: Object[];\n  /**\n   * The CSS styles and attributes of the content cells of a particular column can be customized.\n   *\n   * ```html\n   * <div id=\"Grid\"></div>\n   * ```\n   * ```typescript\n   * let gridObj: Grid = new Grid({\n   * dataSource: filterData,\n   * columns: [\n   *    { field: 'OrderID', headerText: 'Order ID' },\n   *    {\n   *        field: 'EmployeeID', headerText: 'Employee ID', customAttributes: {\n   *           class: 'employeeid',\n   *           type: 'employee-id-cell'\n   *      }\n   *   }]\n   * });\n   * gridObj.appendTo('#Grid');\n   * ```\n   *\n   * @default null\n   */\n  customAttributes?: {\n      [x: string]: Object;\n  };\n  /**\n   * If `displayAsCheckBox` is set to true, it displays the column value as a check box instead of Boolean value.\n   *\n   * @default false\n   */\n  displayAsCheckBox?: boolean;\n  /**\n   * Defines the column data source  which will act as foreign data source.\n   *\n   * @default null\n   */\n  // dataSource?: Object[] | DataManager | DataResult;\n  dataSource?: Object[];\n  /**\n   * Defines the method which is used to achieve custom formatting from an external function.\n   * This function triggers before rendering of each cell.\n   *\n   * ```html\n   * <div id=\"Grid\"></div>\n   * ```\n   * ```typescript\n   * class ExtendedFormatter implements ICellFormatter {\n   * public getValue(column: Column, data: Object): Object {\n   *   return '<span style=\"color:' + (data['Verified'] ? 'green' : 'red') + '\"><i>' + data['Verified'] + '</i><span>';\n   * }\n   * }\n   * let gridObj: Grid = new Grid({\n   *     dataSource: filterData,\n   *     columns: [\n   *         { field: 'ShipName', headerText: 'Ship Name' },\n   *         { field: 'Verified', headerText: 'Verified Status', formatter: ExtendedFormatter }]\n   * });\n   * gridObj.appendTo('#Grid');\n   * ```\n   *\n   * @default null\n   */\n  // formatter?: {\n  //     new (): ICellFormatter;\n  // } | ICellFormatter | Function;\n  /**\n   * Defines the method used to apply custom cell values from external function and display this on each cell rendered.\n   *\n   * ```html\n   * <div id=\"Grid\"></div>\n   * ```\n   * ```typescript\n   * let gridObj: Grid = new Grid({\n   * dataSource: [{ EmployeeID: 1, EmployeeName: ['John', 'M'] }, { EmployeeID: 2, EmployeeName: ['Peter', 'A'] }],\n   * columns: [\n   *     { field: 'EmployeeID', headerText: 'Employee ID' },\n   *     { field: 'EmployeeName', headerText: 'Employee First Name',\n   *       valueAccessor: (field: string, data: Object, column: Column) => {\n   *             return data['EmployeeName'][0];\n   *         },\n   *     }]\n   * });\n   * ```\n   *\n   * @default null\n   */\n  // valueAccessor?: ValueAccessor | string;\n  valueAccessor?: string;\n  /**\n   * Defines the method used to apply custom header cell values from external function and display this on each cell rendered.\n   *\n   * ```html\n   * <div id=\"Grid\"></div>\n   * ```\n   * ```typescript\n   * let gridObj: Grid = new Grid({\n   * dataSource: [{ EmployeeID: 1, EmployeeName: ['John', 'M'] }, { EmployeeID: 2, EmployeeName: ['Peter', 'A'] }],\n   * columns: [\n   *     { field: 'EmployeeID', headerText: 'Employee ID' },\n   *     { field: 'EmployeeName', headerText: 'Employee First Name',\n   *       headerValueAccessor: (field: string,column: Column) => {\n   *             return \"newheadername\";\n   *         },\n   *     }]\n   * });\n   * ```\n   *\n   * @default null\n   */\n  // headerValueAccessor?: HeaderValueAccessor | string;\n  headerValueAccessor?: string;\n  /**\n   * The `filterBarTemplate` is used to add a custom component instead of default input component for filter bar.\n   * It have create and read functions.\n   * * create: It is used for creating custom components.\n   * * read: It is used to perform custom filter action.\n   *\n   * ```html\n   * <div id=\"Grid\"></div>\n   * ```\n   * ```typescript\n   * let gridObj: Grid = new Grid({\n   * dataSource: filterData,\n   * columns: [\n   *   { field: 'OrderID', headerText: 'Order ID' },\n   *   {\n   *      field: 'EmployeeID', filterBarTemplate: {\n   *         create: (args: { element: Element, column: Column }) => {\n   *              let input: HTMLInputElement = document.createElement('input');\n   *              input.id = 'EmployeeID';\n   *              input.type = 'text';\n   *              return input;\n   *         },\n   *         write: (args: { element: Element, column: Column }) => {\n   *             args.element.addEventListener('input', args.column.filterBarTemplate.read as EventListener);\n   *         },\n   *         read: (args: { element: HTMLInputElement, columnIndex: number, column: Column }) => {\n   *             gridObj.filterByColumn(args.element.id, 'equal', args.element.value);\n   *        }\n   *     }\n   *  }],\n   *   allowFiltering: true\n   * });\n   * gridObj.appendTo('#Grid');\n   * ```\n   *\n   * @default null\n   */\n  // filterBarTemplate?: IFilterUI;\n  /**\n   *  Defines the filter options to customize filtering for the particular column.\n   *\n   *  @default null\n   */\n  // filter?: IFilter;\n  /**\n   * Used to render multiple header rows(stacked headers) on the Grid header.\n   *\n   * @default null\n   */\n  // columns?: Column[] | string[] | ColumnModel[];\n  columns?: string[] | SyncfusionGridColumnModel[];\n  /**\n   * Defines the tool tip text for stacked headers.\n   *\n   * @hidden\n   * @default null\n   */\n  toolTip?: string;\n  /**\n   * If `isPrimaryKey` is set to true, considers this column as the primary key constraint.\n   *\n   * @default false\n   */\n  isPrimaryKey?: boolean;\n  /**\n   * Defines the type of component for editing.\n   *\n   * @default 'stringedit'\n   */\n  editType: EditType | string;\n  /**\n   * `editType`(../../grid/edit/#cell-edit-type-and-its-params) Defines rules to validate data before creating and updating.\n   *\n   * @default null\n   */\n  validationRules?: Object;\n  /**\n   * Defines default values for the component when adding a new record to the Grid.\n   *\n   * @default null\n   * @aspType object\n   */\n  defaultValue?: string;\n  /**\n   * Defines the `IEditCell`(../../grid/edit/#cell-edit-template) object to customize default edit cell.\n   *\n   * @default {}\n   */\n  // edit?: IEditCell;\n  /**\n   * If `isIdentity` is set to true, then this column is considered as identity column.\n   *\n   * @default false\n   */\n  isIdentity?: boolean;\n  /**\n   * Defines the mapping column name of the foreign data source.\n   * If it is not defined then the `columns.field` will be considered as mapping column name\n   *\n   * @default null\n   */\n  foreignKeyField?: string;\n  /**\n   * Defines the display column name from the foreign data source which will be obtained from comparing local and foreign data\n   *\n   * @default null\n   */\n  foreignKeyValue?: string;\n  /**\n   * column visibility can change based on its [`Media Queries`](http://cssmediaqueries.com/what-are-css-media-queries.html).\n   * `hideAtMedia` accepts only valid Media Queries.\n   *\n   * @default ''\n   */\n  hideAtMedia?: string;\n  /**\n   * If `showInColumnChooser` set to false, then hides the particular column in column chooser.\n   * By default all columns are displayed in column Chooser.\n   *\n   * @default true\n   */\n  showInColumnChooser?: boolean;\n  /**\n   * @hidden\n   * Defines the commands column template as string or HTML element ID which is used to add\n   * customized command buttons in each cells of the column.\n   */\n  commandsTemplate?: string | Function;\n  /**\n   * `commands` provides an option to display command buttons in every cell.\n   * The available built-in command buttons are\n   * * Edit - Edit the record.\n   * * Delete - Delete the record.\n   * * Save - Save the record.\n   * * Cancel - Cancel the edit state.\n   *\n   * The following code example implements the custom command column.\n   * ```html\n   * <style type=\"text/css\" class=\"cssStyles\">\n   * .details-icon:before\n   * {\n   *    content:\"\\e74d\";\n   * }\n   * </style>\n   * <div id=\"Grid\"></div>\n   * ```\n   * ```typescript\n   * var gridObj = new Grid({\n   * datasource: window.gridData,\n   * columns : [\n   *  { field: 'CustomerID', headerText: 'Customer ID' },\n   *  { field: 'CustomerName', headerText: 'Customer Name' },\n   *  {commands: [{buttonOption:{content: 'Details', click: onClick, cssClass: details-icon}}], headerText: 'Customer Details'}\n   * ]\n   * gridObj.appendTo(\"#Grid\");\n   * ```\n   *\n   * @default null\n   */\n  commands?: CommandModel[];\n  /**\n   * It defines the custom sort comparer function.\n   */\n  // sortComparer?: SortComparer | string;\n  sortComparer?: string;\n  /**\n   * @hidden\n   * It defines the column is foreign key column or not.\n   */\n  isForeignColumn?: () => boolean;\n  /**\n   * Defines the cell edit template that used as editor for a particular column.\n   * It accepts either template string or HTML element ID.\n   *\n   * @aspIgnore\n   */\n  editTemplate?: string | Function;\n  /**\n   * Defines the filter template/UI that used as filter for a particular column.\n   * It accepts either template string or HTML element ID.\n   *\n   * @aspIgnore\n   */\n  filterTemplate?: string | Function;\n  /**\n   * Defines the mapping column name of the foreign data source.\n   * If it is not defined then the `columns.field` will be considered as mapping column name\n   *\n   * @default false\n   */\n  lockColumn?: boolean;\n  /**\n   * If `allowSearching` set to false, then it disables Searching of a particular column.\n   * By default all columns allow Searching.\n   *\n   * @default true\n   */\n  allowSearching?: boolean;\n  /**\n   * If `autoFit` set to true, then the particular column content width will be\n   * adjusted based on its content in the initial rendering itself.\n   * Setting this property as true is equivalent to calling `autoFitColumns` method in the `dataBound` event.\n   *\n   * @default false\n   */\n  autoFit?: boolean;\n  /**\n   * defines which side the column need to freeze\n   * The available built-in freeze directions are\n   * * Left - Freeze the column at left side.\n   * * Right - Freeze the column at right side.\n   * * Fixed - Freeze the column at Center.\n   * * None - Does not freeze the column.\n   *\n   * @default None\n   */\n  freeze?: freezeDirection;\n}\n\n\n\n/**\n * Defines alignments of text, they are\n * ```props\n * * Left :- Defines Left alignment\n * * Right :- Defines Right alignment\n * * Center :- Defines Center alignment\n * * Justify :- Defines Justify alignment\n * ```\n */\nexport declare type TextAlign = 'Left' | 'Right' | 'Center' | 'Justify';\n\n/**\n * Defines the cell content's overflow mode. The available modes are\n * ```props\n * * `Clip` :-  Truncates the cell content when it overflows its area.\n * * `Ellipsis` :-  Displays ellipsis when the cell content overflows its area.\n * * `EllipsisWithTooltip` :- Displays ellipsis when the cell content overflows its area\n * also it will display tooltip while hover on ellipsis applied cell.\n * ```\n * {% codeBlock src='grid/clipMode/index.md' %}{% endcodeBlock %}\n */\nexport declare type ClipMode = 'Clip' | 'Ellipsis' | 'EllipsisWithTooltip';\n\n/**\n * Define options for custom command buttons.\n */\nexport interface CommandModel {\n  /**\n   * Define the command Button tooltip\n   */\n  title?: string;\n  /**\n   * Define the command Button type\n   *\n   * @blazorDefaultValue none\n   */\n  type?: CommandButtonType;\n  /**\n   * Define the button model\n   */\n  // buttonOption?: CommandButtonOptions;\n}\n\n/**\n * Defines the Command Buttons type.\n * ```props\n * * None :-  Edit the current record.\n * * Edit :-  Edit the current record.\n * * Delete :- Delete the current record.\n * * Save :- Save the current edited record.\n * * Cancel :- Cancel the edited state.\n * ```\n */\nexport declare type CommandButtonType = 'None' | 'Edit' | 'Delete' | 'Save' | 'Cancel';\n\n/**\n * Defines freeze direction of the grid columns\n * ```props\n * * Left :- freeze the columns at left.\n * * Right :- freeze the columns at right.\n * * Fixed :- freeze the columns at center.\n * * None :- does not freeze any columns.\n * ```\n */\nexport declare type freezeDirection = 'Left' | 'Right' | 'Fixed' | 'None';\n\n/**\n * Defines the Edit Type of the column\n * ```props\n * * DefaultEdit :- Defines EditType as DefaultEdit\n * * DropdownEdit :- Defines EditMode as Dropdownedit\n * * BooleanEdit :- Defines EditMode as Booleanedit\n * * DatepickerEdit :- Defines EditMode as Datepickeredit\n * * DatetimepickerEdit :- Defines EditType as Datetimepickeredit\n * * NumericEdit :- Defines EditMode as Numericedit\n * ```\n */\nexport declare type EditType = 'defaultEdit' | 'dropDownEdit' | 'booleanEdit' | 'datePickerEdit' | 'dateTimePickerEdit' | 'numericEdit';\n\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"grid.interface.js","sourceRoot":"","sources":["../../../../../../../../libs/data-access/src/lib/tab-core-utility/app/interfaces/grid.interface.ts"],"names":[],"mappings":"AAAA,uDAAuD","sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\r\n\r\nimport { LookUpDetails } from \"../models/data-source-queries.class\";\r\n\r\nexport interface JqWidghtModel {\r\n  width?: number | any;\r\n  height?: number | any;\r\n  source?: SourceModel;\r\n  columns?: Array<ColumnDetailModel>;\r\n  isPageable?: boolean;\r\n  isAutoheight?: boolean;\r\n  isSortable?: boolean;\r\n  selectionmode?: string;\r\n  columngroups?: Array<ColumngroupModel>;\r\n  isAltRow?: boolean;\r\n  isenabletooltips?: boolean;\r\n  iseditable?: boolean;\r\n  sourceId?: string;\r\n  typeOfData?: string;\r\n  actualData?: Array<any>;\r\n  dataField?: Array<DataFieldsModel>;\r\n  actionArray?: Array<ActionModel>;\r\n  isShowToolbar?: boolean;\r\n  isShowStatusBar?: boolean;\r\n  actionsIn?: string;\r\n  isFilterable?: boolean;\r\n  isSortbackGroungColor?: boolean;\r\n  isautoshowfiltericon?: boolean;\r\n  isshowfilterrow?: boolean;\r\n  pagermode?: string;\r\n  isGroupable?: boolean;\r\n  isRowlevelEdit?: boolean;\r\n  isRowlevelDelete?: boolean;\r\n  isRowlevelView?: boolean;\r\n  primaryKeycolumnName?: string;\r\n  gridId?: string;\r\n  id?: string;\r\n  groups?: any;\r\n  groupColumns?: string;\r\n  gridColumnArr?: Array<string> | any;\r\n  theme?: string;\r\n  pagesizeoptions?: string;\r\n  defaultPageSize?: string;\r\n  currentScreenId?: string;\r\n  customNavigate?: string;\r\n  gridName?: string;\r\n  gridState?: string | any;\r\n  iscolumnsreorder?: boolean;\r\n  isStateB?: boolean;\r\n  addScreenId?: string;\r\n  editScreenId?: string;\r\n  viewScreenId?: string;\r\n}\r\n\r\nexport interface SourceModel {\r\n  datatype?: string;\r\n  datafields?: Array<DataFieldsModel>;\r\n  id?: string;\r\n  localdata?: any;\r\n  pagesize?: string;\r\n}\r\n\r\nexport interface DataFieldsModel {\r\n  name?: string;\r\n  type?: string;\r\n  seq?: number;\r\n}\r\n\r\nexport interface ColumnDetailModel {\r\n  text?: string;\r\n  dataField?: string;\r\n  width?: string;\r\n  cellsalign?: string;\r\n  cellsformat?: string;\r\n  columnType?: string;\r\n  columnGroup?: string;\r\n  editable?: boolean;\r\n  buttonclick?: any;\r\n  renderer?: any;\r\n  columntype?: string;\r\n  filtertype?: string;\r\n  seq?: number;\r\n  align?: string;\r\n  sortable?: boolean;\r\n  hidden?: boolean;\r\n  filterable?: boolean;\r\n  cellsrenderer?: any;\r\n  filterParameter?: string;\r\n  addScreenId?: string;\r\n  editScreenId?: string;\r\n  viewScreenId?: string;\r\n  appFieldId?: string;\r\n  isPrimaryKey?: boolean;\r\n  LookUpDetails?: any;\r\n  dropDownLookup?: any;\r\n  SystemDBFieldName?: any;\r\n}\r\n\r\nexport interface ColumngroupModel {\r\n  text?: string;\r\n  align?: string;\r\n  name?: string;\r\n}\r\n\r\nexport interface ActionModel {\r\n  name?: string;\r\n  imgSrc?: string;\r\n  buttonWidth?: number;\r\n  buttonHeight?: number;\r\n  buttonValue?: string;\r\n  imgPosition?: string;\r\n  textPosition?: string;\r\n  textImageRelation?: string;\r\n}\r\n\r\nexport interface ColumnLevelActions {\r\n  name?: string;\r\n  rowId?: number;\r\n  valueToShow?: string;\r\n}\r\n\r\n\r\n/**\r\n * Interface for a class Column\r\n */\r\nexport interface SyncfusionGridColumnModel {\r\n  // for edit tamplates\r\n  edit?: any;\r\n\r\n  LookUpDetails?: LookUpDetails;\r\n  /**\r\n   * Defines the field name of column which is mapped with mapping name of DataSource.\r\n   * The bounded columns can be sort, filter and group etc.,\r\n   * If the `field` name contains “dot”, then it is considered as complex binding.\r\n   * The `field` name must be a valid JavaScript identifier,\r\n   * the first character must be an alphabet and should not contain spaces and special characters.\r\n   *\r\n   * @default ''\r\n   */\r\n  field?: string;\r\n  /**\r\n   * Gets the unique identifier value of the column. It is used to get the object.\r\n   *\r\n   * @default ''\r\n   */\r\n  uid?: string;\r\n  /**\r\n   * Gets the unique identifier value of the column. It is used to get the object.\r\n   *\r\n   * @default null\r\n   */\r\n  index?: number;\r\n  /**\r\n   * Defines the header text of column which is used to display in column header.\r\n   * If `headerText` is not defined, then field name value will be assigned to header text.\r\n   *\r\n   * @default null\r\n   */\r\n  headerText?: string;\r\n  /**\r\n   * Defines the width of the column in pixels or percentage.\r\n   *\r\n   * @default ''\r\n   */\r\n  width?: string | number;\r\n  /**\r\n   * Defines the minimum width of the column in pixels or percentage.\r\n   *\r\n   * @default ''\r\n   */\r\n  minWidth?: string | number;\r\n  /**\r\n   * Defines the maximum width of the column in pixel or percentage, which will restrict resizing beyond this pixel or percentage.\r\n   *\r\n   * @default ''\r\n   */\r\n  maxWidth?: string | number;\r\n  /**\r\n   * Defines the alignment of the column in both header and content cells.\r\n   *\r\n   * @default Left\r\n   */\r\n  textAlign?: TextAlign;\r\n  /**\r\n   * Defines the cell content's overflow mode. The available modes are\r\n   * * `Clip` -  Truncates the cell content when it overflows its area.\r\n   * * `Ellipsis` -  Displays ellipsis when the cell content overflows its area.\r\n   * * `EllipsisWithTooltip` - Displays ellipsis when the cell content overflows its area\r\n   * also it will display tooltip while hover on ellipsis applied cell.\r\n   *\r\n   * @default Ellipsis\r\n   */\r\n  clipMode?: ClipMode;\r\n  /**\r\n   * Define the alignment of column header which is used to align the text of column header.\r\n   *\r\n   * @aspdefaultvalueignore\r\n   * @default null\r\n   */\r\n  headerTextAlign?: TextAlign;\r\n  /**\r\n   * If `disableHtmlEncode` is set to true, it encodes the HTML of the header and content cells.\r\n   *\r\n   * @default true\r\n   */\r\n  disableHtmlEncode?: boolean;\r\n  /**\r\n   * Defines the data type of the column.\r\n   *\r\n   * @default null\r\n   */\r\n  type?: string;\r\n  /**\r\n   * It is used to change display value with the given format and does not affect the original data.\r\n   * Gets the format from the user which can be standard or custom\r\n   * [`number`](../../common/internationalization/#manipulating-numbers)\r\n   * and [`date`](../../common/internationalization/#manipulating-datetime) formats.\r\n   *\r\n   * @default null\r\n   * @aspType string\r\n   */\r\n  // format?: string | NumberFormatOptions | DateFormatOptions;\r\n  format?: string;\r\n  /**\r\n   * If `visible` is set to false, hides the particular column. By default, all columns are displayed.\r\n   *\r\n   * @default true\r\n   */\r\n  visible?: boolean;\r\n  /**\r\n   * Defines the column template that renders customized element in each cell of the column.\r\n   * It accepts either [template string](../../common/template-engine/) or HTML element ID.\r\n   *\r\n   * @default null\r\n   * @aspType string\r\n   */\r\n  template?: string | Function;\r\n  /**\r\n   * Defines the column template as string or HTML element ID which is used to add customized element in the column header.\r\n   *\r\n   * @default null\r\n   * @aspType string\r\n   */\r\n  headerTemplate?: string | Function;\r\n  /**\r\n   * You can use this property to freeze selected columns in grid.\r\n   *\r\n   * @default false\r\n   */\r\n  isFrozen?: boolean;\r\n  /**\r\n   * If `allowSorting` set to false, then it disables sorting option of a particular column.\r\n   * By default all columns are sortable.\r\n   *\r\n   * @default true\r\n   */\r\n  allowSorting?: boolean;\r\n  /**\r\n   * If `allowResizing` set to false, it disables resize option of a particular column.\r\n   *\r\n   * @default true\r\n   */\r\n  allowResizing?: boolean;\r\n  /**\r\n   * If `showColumnMenu` set to false, then it disable the column menu of a particular column.\r\n   * By default column menu will show for all columns\r\n   *\r\n   * @default true\r\n   */\r\n  showColumnMenu?: boolean;\r\n  /**\r\n   * If `allowFiltering` set to false, then it disables filtering option and filter bar element of a particular column.\r\n   * By default all columns are filterable.\r\n   *\r\n   * @default true\r\n   */\r\n  allowFiltering?: boolean;\r\n  /**\r\n   * If `allowGrouping` set to false, then it disables grouping of a particular column.\r\n   * By default all columns are groupable.\r\n   *\r\n   * @default true\r\n   */\r\n  allowGrouping?: boolean;\r\n  /**\r\n   * If `allowReordering` set to false, then it disables reorder of a particular column.\r\n   * By default all columns can be reorder.\r\n   *\r\n   * @default true\r\n   */\r\n  allowReordering?: boolean;\r\n  /**\r\n   * If `enableGroupByFormat` set to true, then it groups the particular column by formatted values.\r\n   * By default no columns are group by format.\r\n   *\r\n   * @default true\r\n   */\r\n  enableGroupByFormat?: boolean;\r\n  /**\r\n   * If `allowEditing` set to false, then it disables editing of a particular column.\r\n   * By default all columns are editable.\r\n   *\r\n   * @default true\r\n   */\r\n  allowEditing?: boolean;\r\n  /**\r\n   * @hidden\r\n   * Gets the current view foreign key data.\r\n   * @default []\r\n   */\r\n  columnData?: Object[];\r\n  /**\r\n   * The CSS styles and attributes of the content cells of a particular column can be customized.\r\n   *\r\n   * ```html\r\n   * <div id=\"Grid\"></div>\r\n   * ```\r\n   * ```typescript\r\n   * let gridObj: Grid = new Grid({\r\n   * dataSource: filterData,\r\n   * columns: [\r\n   *    { field: 'OrderID', headerText: 'Order ID' },\r\n   *    {\r\n   *        field: 'EmployeeID', headerText: 'Employee ID', customAttributes: {\r\n   *           class: 'employeeid',\r\n   *           type: 'employee-id-cell'\r\n   *      }\r\n   *   }]\r\n   * });\r\n   * gridObj.appendTo('#Grid');\r\n   * ```\r\n   *\r\n   * @default null\r\n   */\r\n  customAttributes?: {\r\n      [x: string]: Object;\r\n  };\r\n  /**\r\n   * If `displayAsCheckBox` is set to true, it displays the column value as a check box instead of Boolean value.\r\n   *\r\n   * @default false\r\n   */\r\n  displayAsCheckBox?: boolean;\r\n  /**\r\n   * Defines the column data source  which will act as foreign data source.\r\n   *\r\n   * @default null\r\n   */\r\n  // dataSource?: Object[] | DataManager | DataResult;\r\n  dataSource?: Object[];\r\n  /**\r\n   * Defines the method which is used to achieve custom formatting from an external function.\r\n   * This function triggers before rendering of each cell.\r\n   *\r\n   * ```html\r\n   * <div id=\"Grid\"></div>\r\n   * ```\r\n   * ```typescript\r\n   * class ExtendedFormatter implements ICellFormatter {\r\n   * public getValue(column: Column, data: Object): Object {\r\n   *   return '<span style=\"color:' + (data['Verified'] ? 'green' : 'red') + '\"><i>' + data['Verified'] + '</i><span>';\r\n   * }\r\n   * }\r\n   * let gridObj: Grid = new Grid({\r\n   *     dataSource: filterData,\r\n   *     columns: [\r\n   *         { field: 'ShipName', headerText: 'Ship Name' },\r\n   *         { field: 'Verified', headerText: 'Verified Status', formatter: ExtendedFormatter }]\r\n   * });\r\n   * gridObj.appendTo('#Grid');\r\n   * ```\r\n   *\r\n   * @default null\r\n   */\r\n  // formatter?: {\r\n  //     new (): ICellFormatter;\r\n  // } | ICellFormatter | Function;\r\n  /**\r\n   * Defines the method used to apply custom cell values from external function and display this on each cell rendered.\r\n   *\r\n   * ```html\r\n   * <div id=\"Grid\"></div>\r\n   * ```\r\n   * ```typescript\r\n   * let gridObj: Grid = new Grid({\r\n   * dataSource: [{ EmployeeID: 1, EmployeeName: ['John', 'M'] }, { EmployeeID: 2, EmployeeName: ['Peter', 'A'] }],\r\n   * columns: [\r\n   *     { field: 'EmployeeID', headerText: 'Employee ID' },\r\n   *     { field: 'EmployeeName', headerText: 'Employee First Name',\r\n   *       valueAccessor: (field: string, data: Object, column: Column) => {\r\n   *             return data['EmployeeName'][0];\r\n   *         },\r\n   *     }]\r\n   * });\r\n   * ```\r\n   *\r\n   * @default null\r\n   */\r\n  // valueAccessor?: ValueAccessor | string;\r\n  valueAccessor?: string;\r\n  /**\r\n   * Defines the method used to apply custom header cell values from external function and display this on each cell rendered.\r\n   *\r\n   * ```html\r\n   * <div id=\"Grid\"></div>\r\n   * ```\r\n   * ```typescript\r\n   * let gridObj: Grid = new Grid({\r\n   * dataSource: [{ EmployeeID: 1, EmployeeName: ['John', 'M'] }, { EmployeeID: 2, EmployeeName: ['Peter', 'A'] }],\r\n   * columns: [\r\n   *     { field: 'EmployeeID', headerText: 'Employee ID' },\r\n   *     { field: 'EmployeeName', headerText: 'Employee First Name',\r\n   *       headerValueAccessor: (field: string,column: Column) => {\r\n   *             return \"newheadername\";\r\n   *         },\r\n   *     }]\r\n   * });\r\n   * ```\r\n   *\r\n   * @default null\r\n   */\r\n  // headerValueAccessor?: HeaderValueAccessor | string;\r\n  headerValueAccessor?: string;\r\n  /**\r\n   * The `filterBarTemplate` is used to add a custom component instead of default input component for filter bar.\r\n   * It have create and read functions.\r\n   * * create: It is used for creating custom components.\r\n   * * read: It is used to perform custom filter action.\r\n   *\r\n   * ```html\r\n   * <div id=\"Grid\"></div>\r\n   * ```\r\n   * ```typescript\r\n   * let gridObj: Grid = new Grid({\r\n   * dataSource: filterData,\r\n   * columns: [\r\n   *   { field: 'OrderID', headerText: 'Order ID' },\r\n   *   {\r\n   *      field: 'EmployeeID', filterBarTemplate: {\r\n   *         create: (args: { element: Element, column: Column }) => {\r\n   *              let input: HTMLInputElement = document.createElement('input');\r\n   *              input.id = 'EmployeeID';\r\n   *              input.type = 'text';\r\n   *              return input;\r\n   *         },\r\n   *         write: (args: { element: Element, column: Column }) => {\r\n   *             args.element.addEventListener('input', args.column.filterBarTemplate.read as EventListener);\r\n   *         },\r\n   *         read: (args: { element: HTMLInputElement, columnIndex: number, column: Column }) => {\r\n   *             gridObj.filterByColumn(args.element.id, 'equal', args.element.value);\r\n   *        }\r\n   *     }\r\n   *  }],\r\n   *   allowFiltering: true\r\n   * });\r\n   * gridObj.appendTo('#Grid');\r\n   * ```\r\n   *\r\n   * @default null\r\n   */\r\n  // filterBarTemplate?: IFilterUI;\r\n  /**\r\n   *  Defines the filter options to customize filtering for the particular column.\r\n   *\r\n   *  @default null\r\n   */\r\n  // filter?: IFilter;\r\n  /**\r\n   * Used to render multiple header rows(stacked headers) on the Grid header.\r\n   *\r\n   * @default null\r\n   */\r\n  // columns?: Column[] | string[] | ColumnModel[];\r\n  columns?: string[] | SyncfusionGridColumnModel[];\r\n  /**\r\n   * Defines the tool tip text for stacked headers.\r\n   *\r\n   * @hidden\r\n   * @default null\r\n   */\r\n  toolTip?: string;\r\n  /**\r\n   * If `isPrimaryKey` is set to true, considers this column as the primary key constraint.\r\n   *\r\n   * @default false\r\n   */\r\n  isPrimaryKey?: boolean;\r\n  /**\r\n   * Defines the type of component for editing.\r\n   *\r\n   * @default 'stringedit'\r\n   */\r\n  editType: EditType | string;\r\n  /**\r\n   * `editType`(../../grid/edit/#cell-edit-type-and-its-params) Defines rules to validate data before creating and updating.\r\n   *\r\n   * @default null\r\n   */\r\n  validationRules?: Object;\r\n  /**\r\n   * Defines default values for the component when adding a new record to the Grid.\r\n   *\r\n   * @default null\r\n   * @aspType object\r\n   */\r\n  defaultValue?: string;\r\n  /**\r\n   * Defines the `IEditCell`(../../grid/edit/#cell-edit-template) object to customize default edit cell.\r\n   *\r\n   * @default {}\r\n   */\r\n  // edit?: IEditCell;\r\n  /**\r\n   * If `isIdentity` is set to true, then this column is considered as identity column.\r\n   *\r\n   * @default false\r\n   */\r\n  isIdentity?: boolean;\r\n  /**\r\n   * Defines the mapping column name of the foreign data source.\r\n   * If it is not defined then the `columns.field` will be considered as mapping column name\r\n   *\r\n   * @default null\r\n   */\r\n  foreignKeyField?: string;\r\n  /**\r\n   * Defines the display column name from the foreign data source which will be obtained from comparing local and foreign data\r\n   *\r\n   * @default null\r\n   */\r\n  foreignKeyValue?: string;\r\n  /**\r\n   * column visibility can change based on its [`Media Queries`](http://cssmediaqueries.com/what-are-css-media-queries.html).\r\n   * `hideAtMedia` accepts only valid Media Queries.\r\n   *\r\n   * @default ''\r\n   */\r\n  hideAtMedia?: string;\r\n  /**\r\n   * If `showInColumnChooser` set to false, then hides the particular column in column chooser.\r\n   * By default all columns are displayed in column Chooser.\r\n   *\r\n   * @default true\r\n   */\r\n  showInColumnChooser?: boolean;\r\n  /**\r\n   * @hidden\r\n   * Defines the commands column template as string or HTML element ID which is used to add\r\n   * customized command buttons in each cells of the column.\r\n   */\r\n  commandsTemplate?: string | Function;\r\n  /**\r\n   * `commands` provides an option to display command buttons in every cell.\r\n   * The available built-in command buttons are\r\n   * * Edit - Edit the record.\r\n   * * Delete - Delete the record.\r\n   * * Save - Save the record.\r\n   * * Cancel - Cancel the edit state.\r\n   *\r\n   * The following code example implements the custom command column.\r\n   * ```html\r\n   * <style type=\"text/css\" class=\"cssStyles\">\r\n   * .details-icon:before\r\n   * {\r\n   *    content:\"\\e74d\";\r\n   * }\r\n   * </style>\r\n   * <div id=\"Grid\"></div>\r\n   * ```\r\n   * ```typescript\r\n   * var gridObj = new Grid({\r\n   * datasource: window.gridData,\r\n   * columns : [\r\n   *  { field: 'CustomerID', headerText: 'Customer ID' },\r\n   *  { field: 'CustomerName', headerText: 'Customer Name' },\r\n   *  {commands: [{buttonOption:{content: 'Details', click: onClick, cssClass: details-icon}}], headerText: 'Customer Details'}\r\n   * ]\r\n   * gridObj.appendTo(\"#Grid\");\r\n   * ```\r\n   *\r\n   * @default null\r\n   */\r\n  commands?: CommandModel[];\r\n  /**\r\n   * It defines the custom sort comparer function.\r\n   */\r\n  // sortComparer?: SortComparer | string;\r\n  sortComparer?: string;\r\n  /**\r\n   * @hidden\r\n   * It defines the column is foreign key column or not.\r\n   */\r\n  isForeignColumn?: () => boolean;\r\n  /**\r\n   * Defines the cell edit template that used as editor for a particular column.\r\n   * It accepts either template string or HTML element ID.\r\n   *\r\n   * @aspIgnore\r\n   */\r\n  editTemplate?: string | Function;\r\n  /**\r\n   * Defines the filter template/UI that used as filter for a particular column.\r\n   * It accepts either template string or HTML element ID.\r\n   *\r\n   * @aspIgnore\r\n   */\r\n  filterTemplate?: string | Function;\r\n  /**\r\n   * Defines the mapping column name of the foreign data source.\r\n   * If it is not defined then the `columns.field` will be considered as mapping column name\r\n   *\r\n   * @default false\r\n   */\r\n  lockColumn?: boolean;\r\n  /**\r\n   * If `allowSearching` set to false, then it disables Searching of a particular column.\r\n   * By default all columns allow Searching.\r\n   *\r\n   * @default true\r\n   */\r\n  allowSearching?: boolean;\r\n  /**\r\n   * If `autoFit` set to true, then the particular column content width will be\r\n   * adjusted based on its content in the initial rendering itself.\r\n   * Setting this property as true is equivalent to calling `autoFitColumns` method in the `dataBound` event.\r\n   *\r\n   * @default false\r\n   */\r\n  autoFit?: boolean;\r\n  /**\r\n   * defines which side the column need to freeze\r\n   * The available built-in freeze directions are\r\n   * * Left - Freeze the column at left side.\r\n   * * Right - Freeze the column at right side.\r\n   * * Fixed - Freeze the column at Center.\r\n   * * None - Does not freeze the column.\r\n   *\r\n   * @default None\r\n   */\r\n  freeze?: freezeDirection;\r\n}\r\n\r\n\r\n\r\n/**\r\n * Defines alignments of text, they are\r\n * ```props\r\n * * Left :- Defines Left alignment\r\n * * Right :- Defines Right alignment\r\n * * Center :- Defines Center alignment\r\n * * Justify :- Defines Justify alignment\r\n * ```\r\n */\r\nexport declare type TextAlign = 'Left' | 'Right' | 'Center' | 'Justify';\r\n\r\n/**\r\n * Defines the cell content's overflow mode. The available modes are\r\n * ```props\r\n * * `Clip` :-  Truncates the cell content when it overflows its area.\r\n * * `Ellipsis` :-  Displays ellipsis when the cell content overflows its area.\r\n * * `EllipsisWithTooltip` :- Displays ellipsis when the cell content overflows its area\r\n * also it will display tooltip while hover on ellipsis applied cell.\r\n * ```\r\n * {% codeBlock src='grid/clipMode/index.md' %}{% endcodeBlock %}\r\n */\r\nexport declare type ClipMode = 'Clip' | 'Ellipsis' | 'EllipsisWithTooltip';\r\n\r\n/**\r\n * Define options for custom command buttons.\r\n */\r\nexport interface CommandModel {\r\n  /**\r\n   * Define the command Button tooltip\r\n   */\r\n  title?: string;\r\n  /**\r\n   * Define the command Button type\r\n   *\r\n   * @blazorDefaultValue none\r\n   */\r\n  type?: CommandButtonType;\r\n  /**\r\n   * Define the button model\r\n   */\r\n  // buttonOption?: CommandButtonOptions;\r\n}\r\n\r\n/**\r\n * Defines the Command Buttons type.\r\n * ```props\r\n * * None :-  Edit the current record.\r\n * * Edit :-  Edit the current record.\r\n * * Delete :- Delete the current record.\r\n * * Save :- Save the current edited record.\r\n * * Cancel :- Cancel the edited state.\r\n * ```\r\n */\r\nexport declare type CommandButtonType = 'None' | 'Edit' | 'Delete' | 'Save' | 'Cancel';\r\n\r\n/**\r\n * Defines freeze direction of the grid columns\r\n * ```props\r\n * * Left :- freeze the columns at left.\r\n * * Right :- freeze the columns at right.\r\n * * Fixed :- freeze the columns at center.\r\n * * None :- does not freeze any columns.\r\n * ```\r\n */\r\nexport declare type freezeDirection = 'Left' | 'Right' | 'Fixed' | 'None';\r\n\r\n/**\r\n * Defines the Edit Type of the column\r\n * ```props\r\n * * DefaultEdit :- Defines EditType as DefaultEdit\r\n * * DropdownEdit :- Defines EditMode as Dropdownedit\r\n * * BooleanEdit :- Defines EditMode as Booleanedit\r\n * * DatepickerEdit :- Defines EditMode as Datepickeredit\r\n * * DatetimepickerEdit :- Defines EditType as Datetimepickeredit\r\n * * NumericEdit :- Defines EditMode as Numericedit\r\n * ```\r\n */\r\nexport declare type EditType = 'defaultEdit' | 'dropDownEdit' | 'booleanEdit' | 'datePickerEdit' | 'dateTimePickerEdit' | 'numericEdit';\r\n\r\n"]}

package/esm2022/lib/tab-core-utility/app/interfaces/orgInfo.interface.mjs

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3JnSW5mby5pbnRlcmZhY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2RhdGEtYWNjZXNzL3NyYy9saWIvdGFiLWNvcmUtdXRpbGl0eS9hcHAvaW50ZXJmYWNlcy9vcmdJbmZvLmludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUmVjb3JkSW5mbyB9IGZyb20gXCIuL2NvbW1vbi5pbnRlcmZhY2VcIlxuXG5leHBvcnQgaW50ZXJmYWNlIE9yZ0luZm9SZXNwb25zZSB7XG4gICAgUmVxdWVzdElkOiBzdHJpbmdcbiAgICBJc1N1Y2Nlc3M6IGJvb2xlYW5cbiAgICBSZXN1bHQ6IFJlc3VsdFtdXG4gICAgU3RhdHVzQ29kZTogc3RyaW5nXG4gICAgUmVjb3JkQWZmZWN0dGVkOiBudW1iZXJcbiAgICBUb3RhbFJlY29yZHM6IG51bWJlclxuICAgIFRvdGFsRXhlY3V0aW9uVGltZTogbnVtYmVyXG4gICAgTG9nOiBzdHJpbmdbXVxuICAgIEVycm9yczogYW55W11cbn1cblxuZXhwb3J0IGludGVyZmFjZSBSZXN1bHQge1xuICAgIFJlY29yZEluZm86IFJlY29yZEluZm9cbiAgICBMb2NhbGVTZXR0aW5nczogc3RyaW5nXG4gICAgT3JnYW5pemF0aW9uTmFtZTogc3RyaW5nXG4gICAgSUQ6IHN0cmluZ1xuICAgIFByaW1hcnlDb250YWN0OiBhbnlcbiAgICBBZGRyZXNzOiBhbnlcbn1cblxuZXhwb3J0IGludGVyZmFjZSBJbmZvIHtcbiAgICBGYXZJY29uOiBzdHJpbmcsXG4gICAgT3JnX0JyYW5kX0NvbG9yOiBzdHJpbmcsXG4gICAgT3JnX0xvZ286IHN0cmluZyxcbiAgICBPcmdfTWVudV9Mb2dvOiBzdHJpbmcsXG4gICAgU2hvd1NpZ25VcDogc3RyaW5nLFxuICAgIFRhZ0xpbmU6IHN0cmluZyxcbiAgICBwcm9maWxlU2NyZWVuSUQ6IHN0cmluZyxcbiAgICB3b3JrRmxvd05hbWU6IHN0cmluZyxcbiAgICBPcmdhbml6YXRpb25OYW1lOiBzdHJpbmdcbn0iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3JnSW5mby5pbnRlcmZhY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2RhdGEtYWNjZXNzL3NyYy9saWIvdGFiLWNvcmUtdXRpbGl0eS9hcHAvaW50ZXJmYWNlcy9vcmdJbmZvLmludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUmVjb3JkSW5mbyB9IGZyb20gXCIuL2NvbW1vbi5pbnRlcmZhY2VcIlxyXG5cclxuZXhwb3J0IGludGVyZmFjZSBPcmdJbmZvUmVzcG9uc2Uge1xyXG4gICAgUmVxdWVzdElkOiBzdHJpbmdcclxuICAgIElzU3VjY2VzczogYm9vbGVhblxyXG4gICAgUmVzdWx0OiBSZXN1bHRbXVxyXG4gICAgU3RhdHVzQ29kZTogc3RyaW5nXHJcbiAgICBSZWNvcmRBZmZlY3R0ZWQ6IG51bWJlclxyXG4gICAgVG90YWxSZWNvcmRzOiBudW1iZXJcclxuICAgIFRvdGFsRXhlY3V0aW9uVGltZTogbnVtYmVyXHJcbiAgICBMb2c6IHN0cmluZ1tdXHJcbiAgICBFcnJvcnM6IGFueVtdXHJcbn1cclxuXHJcbmV4cG9ydCBpbnRlcmZhY2UgUmVzdWx0IHtcclxuICAgIFJlY29yZEluZm86IFJlY29yZEluZm9cclxuICAgIExvY2FsZVNldHRpbmdzOiBzdHJpbmdcclxuICAgIE9yZ2FuaXphdGlvbk5hbWU6IHN0cmluZ1xyXG4gICAgSUQ6IHN0cmluZ1xyXG4gICAgUHJpbWFyeUNvbnRhY3Q6IGFueVxyXG4gICAgQWRkcmVzczogYW55XHJcbn1cclxuXHJcbmV4cG9ydCBpbnRlcmZhY2UgSW5mbyB7XHJcbiAgICBGYXZJY29uOiBzdHJpbmcsXHJcbiAgICBPcmdfQnJhbmRfQ29sb3I6IHN0cmluZyxcclxuICAgIE9yZ19Mb2dvOiBzdHJpbmcsXHJcbiAgICBPcmdfTWVudV9Mb2dvOiBzdHJpbmcsXHJcbiAgICBTaG93U2lnblVwOiBzdHJpbmcsXHJcbiAgICBUYWdMaW5lOiBzdHJpbmcsXHJcbiAgICBwcm9maWxlU2NyZWVuSUQ6IHN0cmluZyxcclxuICAgIHdvcmtGbG93TmFtZTogc3RyaW5nLFxyXG4gICAgT3JnYW5pemF0aW9uTmFtZTogc3RyaW5nXHJcbn0iXX0=

package/esm2022/lib/tab-core-utility/app/interfaces/schema.interface.mjs

@@ -5,4 +5,4 @@ export var MetadataEntityType;
     MetadataEntityType["DATA_SOURCE_QUERIES"] = "DataSourceQueries";
     MetadataEntityType["APP_SCREENS"] = "AppScreens";
 })(MetadataEntityType || (MetadataEntityType = {}));
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NoZW1hLmludGVyZmFjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvZGF0YS1hY2Nlc3Mvc3JjL2xpYi90YWItY29yZS11dGlsaXR5L2FwcC9pbnRlcmZhY2VzL3NjaGVtYS5pbnRlcmZhY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBc0JBLE1BQU0sQ0FBTixJQUFZLGtCQUtYO0FBTEQsV0FBWSxrQkFBa0I7SUFDNUIsZ0RBQTBCLENBQUE7SUFDMUIsOENBQXdCLENBQUE7SUFDeEIsK0RBQXlDLENBQUE7SUFDekMsZ0RBQTBCLENBQUE7QUFDNUIsQ0FBQyxFQUxXLGtCQUFrQixLQUFsQixrQkFBa0IsUUFLN0IiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgaW50ZXJmYWNlIFNjaGVtYVJlc3BvbnNlIHtcbiAgUmVxdWVzdElkOiBzdHJpbmdcbiAgSXNTdWNjZXNzOiBib29sZWFuXG4gIFJlc3VsdDogc3RyaW5nXG4gIFN0YXR1c0NvZGU6IHN0cmluZ1xuICBSZWNvcmRBZmZlY3R0ZWQ6IG51bWJlclxuICBUb3RhbFJlY29yZHM6IG51bWJlclxuICBUb3RhbEV4ZWN1dGlvblRpbWU6IG51bWJlclxuICBMb2c6IGFueVtdXG4gIEVycm9yczogYW55W11cbn1cblxuZXhwb3J0IGludGVyZmFjZSBPcmdJbmZvIHtcbiAgSUQ6IHN0cmluZztcbiAgT3JnYW5pemF0aW9uTmFtZTogc3RyaW5nO1xuICBQcmltYXJ5Q29udGFjdDogYW55O1xuICBBZGRyZXNzOiBhbnk7XG4gIExvY2FsZVNldHRpbmdzOiBzdHJpbmcgfCBudWxsO1xuICBTdWJkb21haW46IHN0cmluZztcbiAgVGVuYW50Q29kZTogc3RyaW5nIHwgbnVsbDtcbn1cblxuZXhwb3J0IGVudW0gTWV0YWRhdGFFbnRpdHlUeXBlIHtcbiAgQVBQX09CSkVDVFMgPSAnQXBwT2JqZWN0cycsXG4gIEFQUF9GSUVMRFMgPSAnQXBwRmllbGRzJyxcbiAgREFUQV9TT1VSQ0VfUVVFUklFUyA9ICdEYXRhU291cmNlUXVlcmllcycsXG4gIEFQUF9TQ1JFRU5TID0gJ0FwcFNjcmVlbnMnXG59Il19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NoZW1hLmludGVyZmFjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvZGF0YS1hY2Nlc3Mvc3JjL2xpYi90YWItY29yZS11dGlsaXR5L2FwcC9pbnRlcmZhY2VzL3NjaGVtYS5pbnRlcmZhY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBc0JBLE1BQU0sQ0FBTixJQUFZLGtCQUtYO0FBTEQsV0FBWSxrQkFBa0I7SUFDNUIsZ0RBQTBCLENBQUE7SUFDMUIsOENBQXdCLENBQUE7SUFDeEIsK0RBQXlDLENBQUE7SUFDekMsZ0RBQTBCLENBQUE7QUFDNUIsQ0FBQyxFQUxXLGtCQUFrQixLQUFsQixrQkFBa0IsUUFLN0IiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgaW50ZXJmYWNlIFNjaGVtYVJlc3BvbnNlIHtcclxuICBSZXF1ZXN0SWQ6IHN0cmluZ1xyXG4gIElzU3VjY2VzczogYm9vbGVhblxyXG4gIFJlc3VsdDogc3RyaW5nXHJcbiAgU3RhdHVzQ29kZTogc3RyaW5nXHJcbiAgUmVjb3JkQWZmZWN0dGVkOiBudW1iZXJcclxuICBUb3RhbFJlY29yZHM6IG51bWJlclxyXG4gIFRvdGFsRXhlY3V0aW9uVGltZTogbnVtYmVyXHJcbiAgTG9nOiBhbnlbXVxyXG4gIEVycm9yczogYW55W11cclxufVxyXG5cclxuZXhwb3J0IGludGVyZmFjZSBPcmdJbmZvIHtcclxuICBJRDogc3RyaW5nO1xyXG4gIE9yZ2FuaXphdGlvbk5hbWU6IHN0cmluZztcclxuICBQcmltYXJ5Q29udGFjdDogYW55O1xyXG4gIEFkZHJlc3M6IGFueTtcclxuICBMb2NhbGVTZXR0aW5nczogc3RyaW5nIHwgbnVsbDtcclxuICBTdWJkb21haW46IHN0cmluZztcclxuICBUZW5hbnRDb2RlOiBzdHJpbmcgfCBudWxsO1xyXG59XHJcblxyXG5leHBvcnQgZW51bSBNZXRhZGF0YUVudGl0eVR5cGUge1xyXG4gIEFQUF9PQkpFQ1RTID0gJ0FwcE9iamVjdHMnLFxyXG4gIEFQUF9GSUVMRFMgPSAnQXBwRmllbGRzJyxcclxuICBEQVRBX1NPVVJDRV9RVUVSSUVTID0gJ0RhdGFTb3VyY2VRdWVyaWVzJyxcclxuICBBUFBfU0NSRUVOUyA9ICdBcHBTY3JlZW5zJ1xyXG59Il19

package/esm2022/lib/tab-core-utility/app/interfaces/user.interface.mjs

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