@sankhyalabs/core 5.20.0-dev.79 → 5.20.0-dev.80

package/src/utils/LockManager.ts

@@ -1,7 +1,7 @@
 import { StringUtils } from "./StringUtils.js";
-    /**
-    * Define os tipos de operação que o locker pode controlar
-    */
+/**
+* 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.
@@ -19,7 +19,7 @@ type Lock = {
     done: boolean
 }
 
-export class LockManager{
+export class LockManager {
     private static _locks = new Map<string, Array<Lock>>();
 
     /**
@@ -27,18 +27,18 @@ export class LockManager{
     */
     public static ATTRIBUTE_NAME = "data-locker-manger-context-id";
 
-    private static buildContextID(): string{
+    private static buildContextID(): string {
         return StringUtils.generateUUID();
     }
 
-    private static buildLockerID(ctxId:string|HTMLElement, operation: LockManagerOperation): string | undefined{
-        if(ctxId == undefined) return undefined;
+    private static buildLockerID(ctxId: string | HTMLElement, operation: LockManagerOperation): string | undefined {
+        if (ctxId == undefined) return undefined;
 
-        let resolvedID:any = ctxId;
+        let resolvedID: any = ctxId;
 
-        if(resolvedID instanceof HTMLElement){
+        if (resolvedID instanceof HTMLElement) {
             resolvedID = (ctxId as HTMLElement).getAttribute(LockManager.ATTRIBUTE_NAME);
-            if(!resolvedID) return undefined;
+            if (!resolvedID) return undefined;
         }
 
         return `${resolvedID}_${operation}`;
@@ -46,23 +46,23 @@ export class LockManager{
 
     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;
+            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;
     }
 
@@ -76,37 +76,31 @@ export class LockManager{
             }
         });
     };
-    
-   /**
-    * 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.
-    */
+
+    /**
+     * 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{
+        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;
-            }
-
+            LockManager.traverseAndAddAttr(currentElement, ctxId);
             return ctxId;
-        }catch(err){
+        } catch (err) {
             console.warn(`Erro ao registrar locks para o elemento: ${startElement?.tagName}`, err);
             return "";
         }
     }
-    
+
     /**
      * Reseta todos os locks existentes para um determinado contexto e operação de forma assíncrona
      * @param id - ID do contexto ou elemento HTML contendo contexto
@@ -116,7 +110,7 @@ export class LockManager{
     public static async resetLocks(id: string | HTMLElement, operation: LockManagerOperation): Promise<void> {
         const lockerId = this.buildLockerID(id, operation);
         if (!lockerId) return;
-        
+
         const currentLocks = this._locks.get(lockerId);
 
         if (currentLocks?.length) {
@@ -126,11 +120,11 @@ export class LockManager{
                 return lock.promise;
             }));
 
-            this._locks.delete(lockerId);            
+            this._locks.delete(lockerId);
         }
     }
-    
- 
+
+
     /**
     * Inicia um locker baseado em um contexto e uma operação.
     * 
@@ -139,12 +133,12 @@ export class LockManager{
     * 
     * @returns - Uma função que fara a liberação do lock.
     */
-    public static lock(id:string|HTMLElement, operation:LockManagerOperation): () => void {
+    public static lock(id: string | HTMLElement, operation: LockManagerOperation): () => void {
         const lockerId = LockManager.buildLockerID(id, operation);
 
-        if(!lockerId) return () => {};
+        if (!lockerId) return () => { };
 
-        const lock:Lock = { done: false };
+        const lock: Lock = { done: false };
         const promise = new Promise<void>(resolve => lock.resolve = resolve);
         lock.promise = promise;
 
@@ -166,42 +160,42 @@ export class LockManager{
     * 
     * @returns - Promise que será resolvida quando todos lockers forem finalizados.
     */
-    public static async whenResolve(id:string|HTMLElement, operation:LockManagerOperation, debounce?: number, timeOut?: number): Promise<void> {
+    public static async whenResolve(id: string | HTMLElement, operation: LockManagerOperation, debounce?: number, timeOut?: number): Promise<void> {
         const lockerId = LockManager.buildLockerID(id, operation);
 
-        if(!lockerId) return;
+        if (!lockerId) return;
+
+        if (debounce) await new Promise(resolve => setTimeout(resolve, debounce));
 
-        if(debounce) await new Promise(resolve => setTimeout(resolve, debounce));
-        
         const startTime = Date.now();
-        
+
         while (LockManager._locks.get(lockerId)?.length) {
-            
+
             if (timeOut && Date.now() - startTime >= timeOut) {
                 await this.resetLocks(id, operation);
                 return;
             }
 
-            const locks:Array<Lock> = LockManager._locks.get(lockerId) ?? [];
+            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, debounce || 200));
-            
+
             LockManager._locks.set(lockerId, locks.filter(lock => !lock.done));
-        } 
-        
+        }
+
     }
-   
-    public static async whenHasLock(id:string|HTMLElement, operation:LockManagerOperation, timeOut?: number): Promise<void> {
+
+    public static async whenHasLock(id: string | HTMLElement, operation: LockManagerOperation, timeOut?: number): Promise<void> {
         const lockerId = LockManager.buildLockerID(id, operation);
 
-        if(!lockerId) return;
+        if (!lockerId) return;
 
         const startTime = Date.now();
 
         while (!LockManager._locks.get(lockerId)?.length) {
-            
+
             if (timeOut && Date.now() - startTime >= timeOut) {
                 await this.resetLocks(id, operation);
                 return;