@sankhyalabs/core 5.20.0-dev.55 → 5.20.0-dev.57

package/src/dataunit/DataUnit.ts

@@ -28,6 +28,7 @@ import { getInvalidFieldMessage, InvalidFieldsReducer } from "./state/slice/Inva
 import { getLoadingProperties, LoadingPropertiesReducer } from "./state/slice/LoadingProperties.js";
 import SortingUtils from "../utils/SortingUtils.js";
 import ServiceCanceledException from "../exceptions/ServiceCanceledException.js";
+import SilentException from "../exceptions/SilentException.js";
 
 /***
  * `DataUnit`: Atua como uma camada de abstração entre o back-end e a interface do usuário.
@@ -503,11 +504,13 @@ export default class DataUnit {
                                     this.dispatchAction(Action.SAVING_ERROR);
                                     this.dispatchAction(Action.LOADING_PROPERTIES_CLEANED);
                                     if(cause instanceof ServiceCanceledException){
-                                        console.debug("Service canceled: " + cause.message)
-                                        resolve()
-                                    } else{
-                                        fail(new ErrorException("Erro ao salvar alterações", cause, errorCode))
+                                        console.debug("Service canceled: " + cause.message);
+                                        resolve();
+                                    } 
+                                    if(cause instanceof SilentException){
+                                        fail();
                                     }
+                                    fail(new ErrorException("Erro ao salvar alterações", cause, errorCode));
                                 });
                             } else {
                                 this.dispatchAction(Action.LOADING_PROPERTIES_CLEANED);

package/src/exceptions/SilentException.ts

@@ -0,0 +1,25 @@
+/**
+ * `SilentException`: Exceção lançada quando uma exception silenciosa é. 
+ */
+export default class SilentException extends Error {
+    
+    /** Nome da exceção. */
+    public name: string;
+
+    /** Titulo do erro. */
+    public title: string;
+
+    /** Descrição do erro. */
+    public message: string;
+    
+    /** Código do erro, indica o erro disparado pelo backend. */
+    public errorCode: string;
+
+    constructor(title: string = "", message: string = "", errorCode: string = "") {
+        super(message);
+        this.name = "SilentException";
+        this.title = title;
+        this.message = message;
+        this.errorCode = errorCode;
+    }
+}

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";
@@ -43,9 +44,12 @@ 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,
@@ -118,5 +122,6 @@ export {
     OverFlowWatcherParams,
     OVERFLOWED_CLASS_NAME,
     DataUnitEventOptions,
-    ServiceCanceledException
+    ServiceCanceledException,
+    SilentException,
 };

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/MaskFormatter.ts

@@ -58,7 +58,8 @@ export class MaskFormatter {
         "cnpj": "##.###.###/####-##",
         "cpf": "###.###.###-##",
         "phone": "(##) ####-####",
-        "cep": "##.###-###"
+        "cep": "##.###-###",
+        "cor_rgb" : "'#AAAAAA"
     };
 
 
@@ -92,6 +93,92 @@ export class MaskFormatter {
         this.mask = mask;
     }
 
+    
+    /**
+    * Aplica a máscara quando o input é alterado
+    *
+    * @param value Valor a ser aplicado com a máscara.
+    * @return O valor processado de acordo com o padrão.
+    */
+    public applyMask(value: string) {
+        if (this.mask === MaskFormatter.DEFAULT_MASKS.cor_rgb) {
+            value = value.replace("#", "")
+
+            const expectedFormattedValue = this.format(value.replace(/\s/g, ""));
+
+            if (value === expectedFormattedValue) {
+                return value;
+            }
+
+            if (value.length >= 6) {
+                const formattedValue = this.format(value);
+                return formattedValue;
+            } else {
+                return value;
+            }
+        }
+
+        const expectedFormattedValue = this.format(value.replace(/\s/g, ""));
+
+        if (value === expectedFormattedValue) {
+            return value;
+        }
+        const maskPlaceholders = this.mask.match(/[UAL#?*']/g) || [];
+        const placeholderCount = maskPlaceholders.length;
+
+        const validValue = value.split('').filter((char, index) => {
+            const placeholder = maskPlaceholders[index];
+            if (!placeholder) return false;
+
+            switch (placeholder) {
+                case MaskFormatter.DIGIT_KEY:
+                    return /\d/.test(char);
+                case MaskFormatter.UPPERCASE_KEY:
+                    return /[a-zA-Z]/.test(char);
+                case MaskFormatter.LOWERCASE_KEY:
+                    return /[a-zA-Z]/.test(char);
+                case MaskFormatter.ALPHA_NUMERIC_KEY:
+                    return /[a-zA-Z0-9]/.test(char);
+                case MaskFormatter.CHARACTER_KEY:
+                    return /[a-zA-Z]/.test(char);
+                case MaskFormatter.ANYTHING_KEY:
+                    return true;
+                case MaskFormatter.LITERAL_KEY:
+                    const literalChar = this.mask.charAt(index);
+                    return char === literalChar;
+                default:
+                    return false;
+            }
+        });
+
+        if (validValue.length >= placeholderCount) {
+            const formattedValue = this.format(validValue.join(''));
+            return formattedValue;
+        } else {
+            const partialValue = validValue.join('');
+            return partialValue;
+        }
+    }
+
+    /**
+     * Remove a máscara formatando a string retornando sem máscara
+     *
+     * @param value Valor a ser formatado com máscara.
+     * @return O valor processado de acordo com o padrão.
+     */
+    public removeMask(value: string): string {
+        const maskString = this.mask.replace("#", "");
+        const maskElements = maskString.split("");
+
+        let valueMapped = value
+
+        maskElements.forEach(maskChar => {
+            valueMapped = valueMapped.replace(maskChar, "")
+        })
+
+        return valueMapped;
+    }
+
     /**
      * Formata a string passada baseada na máscara definda pelo atributo mask.
      *