@sankhyalabs/core 5.20.0-dev.54 → 5.20.0-dev.56

package/src/index.ts

@@ -20,6 +20,7 @@ import WarningException from "./exceptions/WarningException.js";
 import WaitingChangeException from "./exceptions/WaitingChangeException.js";
 import ErrorException from "./exceptions/ErrorException.js";
 import ServiceCanceledException from "./exceptions/ServiceCanceledException.js";
+import SilentException from "./exceptions/SilentException.js";
 import { ErrorTracking } from "./traking/ErrorTraking.js";
 import { PaginationInfo } from "./dataunit/loading/PaginationInfo.js";
 import { LoadDataRequest } from "./dataunit/loading/LoadDataRequest.js";
@@ -40,10 +41,15 @@ import { IRepositoryIndex } from "./repository/indexeddb/IRepositoryIndex.js"
 import { FieldComparator } from "./dataunit/sorting/FieldComparator.js";
 import { KeyboardManager } from "./utils/KeyboardManager/index.js";
 import { SearchUtils } from "./utils/SearchUtils.js";
+import { ServiceUtils }  from "./utils/ServiceUtils.js";
+import { StorageType } from "./utils/CacheManager/index.js";
 import OverflowWatcher, { OnOverflowCallBack, OverflowDirection, OverFlowWatcherParams, OVERFLOWED_CLASS_NAME } from "./utils/OverflowWatcher/index.js";
+import {LockManager, LockManagerOperation} from "./utils/LockManager.js";
 
 /*Classes públicas no pacote*/
 export {
+    LockManager,
+    LockManagerOperation,
     StringUtils,
     MaskFormatter,
     NumberUtils,
@@ -108,11 +114,14 @@ export {
     defaultDataLoader,
     KeyboardManager,
     SearchUtils,
+    ServiceUtils,
+    StorageType,
     OverflowWatcher,
     OnOverflowCallBack,
     OverflowDirection,
     OverFlowWatcherParams,
     OVERFLOWED_CLASS_NAME,
     DataUnitEventOptions,
-    ServiceCanceledException
+    ServiceCanceledException,
+    SilentException,
 };

package/src/utils/CacheManager/index.ts

@@ -0,0 +1,103 @@
+import { StorageType } from './interfaces/index.js';
+
+export * from "./interfaces/index.js";
+
+export class CacheManager {
+    /**
+     * Nome da chave utilizada para armazenar o cache no armazenamento.
+     */
+    private static readonly storageKey = 'cacheManager';
+
+    /**
+     * Estrutura de armazenamento em memória.
+     */
+    private static inMemoryCache = new Map<string, any>();
+
+    /**
+     * Recupera ou define o valor no cache.
+     *
+     * @param key Identificador único para armazenar e recuperar o valor.
+     * @param fetchCallback Função que retorna uma `Promise` com o valor a ser armazenado no cache caso ele não exista ou tenha expirado.
+     * @param storageType Tipo de armazenamento: `'inMemoryCache'`, `'sessionStorage'` ou `'localStorage'`.
+     * @returns Uma `Promise` com o valor armazenado ou obtido via `fetchCallback`.
+     */
+    public static async getOrSet<T>(
+        key: string,
+        fetchCallback: () => Promise<T>,
+        storageType: StorageType = StorageType.IN_MEMORY_CACHE
+    ): Promise<T> {
+        const cache = this.getCache(storageType);
+
+        if (cache[key]) {
+            return cache[key].data;
+        }
+
+        const data = await fetchCallback();
+        cache[key] = { data };
+        this.saveCache(cache, storageType);
+        return data;
+    }
+
+    /**
+     * Remove uma entrada específica do cache.
+     *
+     * @param key Identificador único da entrada a ser removida.
+     * @param storageType Tipo de armazenamento: `'inMemoryCache'`, `'sessionStorage'` ou `'localStorage'`.
+     */
+    public static clear(key: string, storageType: StorageType = StorageType.IN_MEMORY_CACHE): void {
+        const cache = this.getCache(storageType);
+        delete cache[key];
+        this.saveCache(cache, storageType);
+    }
+
+    /**
+     * Remove todas as entradas do cache.
+     *
+     * @param storageType Tipo de armazenamento: `'inMemoryCache'`, `'sessionStorage'` ou `'localStorage'`. 
+     */
+    public static clearAll(storageType: StorageType = StorageType.IN_MEMORY_CACHE): void {
+        if (storageType === StorageType.IN_MEMORY_CACHE) {
+            this.inMemoryCache.clear();
+        } else {
+            this.getStorage(storageType).removeItem(this.storageKey);
+        }
+    }
+
+    /**
+     * Obtém o cache armazenado no armazenamento especificado.
+     * @param storageType Tipo de armazenamento: `'inMemoryCache'`, `'sessionStorage'` ou `'localStorage'`.
+     * @returns Um objeto representando o cache armazenado.
+     */
+    private static getCache(storageType: StorageType): Record<string, any> {
+        if (storageType === StorageType.IN_MEMORY_CACHE) {
+            return Object.fromEntries(this.inMemoryCache);
+        }
+
+        const storage = this.getStorage(storageType);
+        const cache = storage.getItem(this.storageKey);
+        return cache ? JSON.parse(cache) : {};
+    }
+
+    /**
+     * Salva o cache no armazenamento especificado.
+     * @param cache O objeto representando o cache a ser salvo.
+     * @param storageType Tipo de armazenamento: `'inMemoryCache'`, `'sessionStorage'` ou `'localStorage'`.
+     */
+    private static saveCache(cache: Record<string, any>, storageType: StorageType): void {
+        if (storageType === StorageType.IN_MEMORY_CACHE) {
+            this.inMemoryCache = new Map(Object.entries(cache));
+        } else {
+            const storage = this.getStorage(storageType);
+            storage.setItem(this.storageKey, JSON.stringify(cache));
+        }
+    }
+
+    /**
+     * Retorna o armazenamento correspondente ao tipo especificado.
+     * @param storageType Tipo de armazenamento: `'sessionStorage'` ou `'localStorage'`.
+     * @returns O objeto de armazenamento correspondente.
+     */
+    private static getStorage(storageType: StorageType): Storage {
+        return storageType === StorageType.LOCAL_STORAGE ? localStorage : sessionStorage;
+    }
+}

package/src/utils/CacheManager/interfaces/index.ts

@@ -0,0 +1,5 @@
+export enum StorageType{
+    IN_MEMORY_CACHE = 'inMemoryCache',
+    SESSION_STORAGE = 'sessionStorage',
+    LOCAL_STORAGE = 'localStorage'
+}

package/src/utils/LockManager.ts

@@ -0,0 +1,157 @@
+import { StringUtils } from "./StringUtils.js";
+    /**
+    * Define os tipos de operação que o locker pode controlar
+    */
+export enum LockManagerOperation {
+    /**
+        Operação de lock utilizada para controlar cliques nos botoes da taskbar.
+    */
+    TASKBAR_CLICK = "taskbar_click"
+}
+
+type Lock = {
+    promise?: Promise<unknown>,
+    resolve?: () => void,
+    done: boolean
+}
+
+export class LockManager{
+    private static _locks = new Map<string, Array<Lock>>();
+
+    /**
+    * Nome do atributo que será utilizado para controlar contexto de locks nos elementos da DOM.
+    */
+    public static ATTRIBUTE_NAME = "data-locker-manger-context-id";
+
+    private static buildContextID(): string{
+        return StringUtils.generateUUID();
+    }
+
+    private static buildLockerID(ctxId:string|HTMLElement, operation: LockManagerOperation): string | undefined{
+        if(ctxId == undefined) return undefined;
+
+        let resolvedID:any = ctxId;
+
+        if(resolvedID instanceof HTMLElement){
+            resolvedID = (ctxId as HTMLElement).getAttribute(LockManager.ATTRIBUTE_NAME);
+            if(!resolvedID) return undefined;
+        }
+
+        return `${resolvedID}_${operation}`;
+    }
+
+    private static findExistingCtxId = (element: HTMLElement): string | null => {
+        let currentElement: HTMLElement | null = element;
+    
+        while (currentElement) {
+          if (currentElement.hasAttribute(LockManager.ATTRIBUTE_NAME)) {
+            return currentElement.getAttribute(LockManager.ATTRIBUTE_NAME);
+          }
+
+          const childWithCtxId = Array.from(currentElement.children).find(child =>
+            (child instanceof HTMLElement) && child.hasAttribute(LockManager.ATTRIBUTE_NAME)
+          ) as HTMLElement | undefined;
+    
+          if (childWithCtxId) {
+            return childWithCtxId.getAttribute(LockManager.ATTRIBUTE_NAME);
+          }
+
+          currentElement = currentElement.parentElement;
+        }
+    
+        return null;
+    }
+
+    private static traverseAndAddAttr = (element: HTMLElement, ctxId: string): void => {
+        if (element.tagName.startsWith('EZ-') || element.tagName.startsWith('SNK-')) {
+            element.setAttribute(LockManager.ATTRIBUTE_NAME, ctxId);
+        }
+        Array.from(element.children).forEach((child) => {
+            if (child instanceof HTMLElement) {
+                LockManager.traverseAndAddAttr(child, ctxId);
+            }
+        });
+    };
+
+   /**
+    * Cria um contexto de locker, caso nao exista, para todos elementos pais iniciados com ez- ou snk-.
+    * 
+    * @param startElement - Elemento de de onde o lock deve começar.
+    * 
+    * @returns - O id do locker, que pode ser usado para iniciar ou aguardar um lock do contexto.
+    */
+    public static addLockManagerCtxId(startElement: HTMLElement): string {
+        try{
+            if (!startElement) {
+                console.error("Elemento inicial não fornecido.");
+                return "";
+            }
+
+            const ctxId = LockManager.findExistingCtxId(startElement) ?? LockManager.buildContextID();
+            
+            let currentElement: HTMLElement | null = startElement;
+            
+            while (currentElement && currentElement.tagName != 'BODY') {
+                LockManager.traverseAndAddAttr(currentElement, ctxId);
+                currentElement = currentElement.parentElement;
+            }
+
+            return ctxId;
+        }catch(err){
+            console.warn(`Erro ao registrar locks para o elemento: ${startElement?.tagName}`, err);
+            return "";
+        }
+    }
+    
+    /**
+    * Inicia um locker baseado em um contexto e uma operação.
+    * 
+    * @param id - Pode ser um ID do contexto de locker, ou, o elemento contendo um contexto de locker.
+    * @param operation - Operação do contexto que o lock deve ser feito.
+    * 
+    * @returns - Uma função que fara a liberação do lock.
+    */
+    public static lock(id:string|HTMLElement, operation:LockManagerOperation): any{
+        const lockerId = LockManager.buildLockerID(id, operation);
+
+        if(!lockerId) return () => {};
+
+        const lock:Lock = { done: false };
+        const promise = new Promise<void>(resolve => lock.resolve = resolve);
+        lock.promise = promise;
+
+        const currentLocks = LockManager._locks.get(lockerId) ?? [];
+        currentLocks.push(lock);
+
+        LockManager._locks.set(lockerId, currentLocks);
+
+        return () => {
+            lock.done = true;
+            lock.resolve?.();
+        }
+    }
+
+    /**
+    * Aguarda todos os lockers de um contexto e operação serem resolvidos.
+    * 
+    * @param id - Pode ser um ID do contexto de locker, ou, o elemento contendo um contexto de locker.
+    * @param operation - Operação do contexto que devera aguardar.
+    * 
+    * @returns - Promise que será resolvida quando todos lockers forem finalizados.
+    */
+    public static async whenResolve(id:string|HTMLElement, operation:LockManagerOperation): Promise<void> {
+        const lockerId = LockManager.buildLockerID(id, operation);
+
+        if(!lockerId) return;
+
+        while (LockManager._locks.get(lockerId)?.length) {
+            const locks:Array<Lock> = LockManager._locks.get(lockerId) ?? [];
+            await Promise.all(locks.map(lock => lock.promise));
+            
+            //Aguarda listeners da tela reagirem as mudancas de estado do dataunit
+            await new Promise(resolve => setTimeout(resolve, 200));
+
+            LockManager._locks.set(lockerId, locks.filter(lock => !lock.done));
+        }
+    }
+}

package/src/utils/ServiceUtils.ts

@@ -0,0 +1,36 @@
+import { CacheManager } from './CacheManager/index.js';
+import { StorageType } from './CacheManager/interfaces/index.js';
+
+
+export class ServiceUtils {
+
+    
+    /**
+     * Auxilia no uso do CacheManager, gerando automaticamente uma chave de cache com base no identificador.
+     *
+     * @template T Tipo do dado a ser retornado.
+     * @param identifier Identificadores únicos usados para compor a chave de cache.
+     * @param fetchFunction Função que retorna uma `Promise` com o valor a ser armazenado no cache caso ele não exista ou tenha expirado.
+     * @param storageType Tipo de armazenamento: `'sessionStorage'` ou `'localStorage'`. O padrão é `'sessionStorage'`.
+     * @returns Uma `Promise` com o valor armazenado ou obtido via `fetchFunction`.
+     *
+     * @example
+     * ```typescript
+     * const actions = await useCacheWithService(
+     *  `${this.entityName} - ${this.resourceID}`,
+     *   async () => {
+     *     return await fetchActionsFromAPI();
+     *   }
+     * );
+     * console.log(actions);
+     * ```
+     */
+    public static async useCacheWithService<T>(
+        identifier: string,
+        fetchFunction: () => Promise<T>,
+        storageType: StorageType = StorageType.IN_MEMORY_CACHE
+    ): Promise<T> {
+        const cacheKey = `${identifier}`;
+        return CacheManager.getOrSet(cacheKey, fetchFunction, storageType);
+    }
+}