@sankhyalabs/core 0.0.0-bugfix-dev-KB-75210.1 → 0.0.0-bugfix-dev-KB-75940.0

package/src/dataunit/state/slice/LoadingControlSlice.ts

@@ -1,4 +1,5 @@
 
+import { ChangeOperation } from "../../DataUnit.js";
 import { LoadDataRequest } from "../../loading/LoadDataRequest.js";
 import { PaginationInfo } from "../../loading/PaginationInfo.js";
 import { Action } from "../action/DataUnitAction.js";
@@ -16,6 +17,9 @@ class LoadingControlReducerImpl implements ActionReducer {
                 return {...currentState, paginationInfo: action.payload?.paginationInfo};
             case Action.PAGINATION_UPDATED:
                 return {...currentState, paginationInfo: action.payload};
+            case Action.DATA_SAVED:
+                return {...currentState, paginationInfo: updatePaginationInfo(stateManager, action.payload)};
+
         }
         return currentState;
     }
@@ -56,7 +60,45 @@ export const hasPreviousPages = (stateManager: StateManager): boolean => {
     return paginationInfo ? paginationInfo.currentPage > 0 : false;
 }
 
+const updatePaginationInfo = (stateManager: StateManager, payload: Payload): PaginationInfo =>{
+    const paginationInfo = getPaginationInfo(stateManager);
+    let { records, changes } = payload;
+
+    if(!records || !changes || !paginationInfo || !validateNewRecordOperation(changes)) return paginationInfo as PaginationInfo;
+    
+    const { count, firstRecord, lastRecord, total } = paginationInfo;
+
+    return {
+        ...paginationInfo,
+        count: (count ?? 0) + records.length,
+        firstRecord: firstRecord === 0 && records.length > 0 ? 1 : firstRecord,
+        lastRecord: lastRecord + records.length,
+        total: (total ?? 0) + records.length
+    }
+    
+}
+
+const validateNewRecordOperation = (changes: Array<Change>): boolean => {
+    return changes.every(change => isNewRecordOperation(change._operation));
+};
+
+const isNewRecordOperation = (operation: string): operation is ChangeOperation => {
+    return ["INSERT", "COPY"].includes(operation);
+};
+
 interface LoadingControlState{
     lastRequest: LoadDataRequest;
     paginationInfo: PaginationInfo;
+}
+
+interface Change {
+    dataUnit: string;
+    record: Record<string, any>;
+    updatingFields: Record<string, any>;
+    _operation: string;
+}
+
+interface Payload {
+    changes: Change[];
+    records: Record<string, any>[];
 }

package/src/index.ts

@@ -123,5 +123,5 @@ export {
     OVERFLOWED_CLASS_NAME,
     DataUnitEventOptions,
     ServiceCanceledException,
-    SilentException,
+    SilentException
 };

package/src/utils/KeyboardManager/index.ts

@@ -9,6 +9,7 @@ import { keyCodeEventValues } from "./keyCodes/index.js";
  */
 export class KeyboardManager {
    private _options: IKeyboardOptions;
+   private _shadowRoots: ShadowRoot [] = [];
    private _mappedElements: IKeyboardMappedKeysElements = {};
 
    /**
@@ -22,10 +23,48 @@ export class KeyboardManager {
          propagate: false,
          element: document.body,
          debounceTime: 0,
+         enableShadowDom: false,
          ...options
       }
+
+      if(this._options.enableShadowDom) {
+         this._shadowRoots = this.findAllNestedShadowRoots(this._options.element);
+      }
    }
 
+   private findAllNestedShadowRoots(element: HTMLElement | Element | ChildNode | Document , results: ShadowRoot [] = []):  ShadowRoot [] {
+      if (!element) {
+         return results;
+      }
+      
+      const shadowRoot = (element as HTMLElement)?.shadowRoot;
+      if (shadowRoot) {
+        results.push(shadowRoot);
+    
+        shadowRoot.querySelectorAll("*").forEach((child) => {
+          this.findAllNestedShadowRoots(child, results);
+        });
+      }
+    
+      element.childNodes.forEach((child) => {
+        this.findAllNestedShadowRoots(child, results);
+      });
+
+      return results;
+    }
+
+   private addEventListenerToNestedShadowRoots(event: 'keydown' | 'keyup', callback: VoidFunction) {
+      this._shadowRoots.forEach((shadowRoot) => {
+         shadowRoot.addEventListener(event, callback);
+      });
+    }
+
+    private removeEventListenerToNestedShadowRoots(event: 'keydown' | 'keyup', callback: VoidFunction) {
+      this._shadowRoots.forEach((shadowRoot) => {
+        shadowRoot.removeEventListener(event, callback);
+      });
+    }
+
    /**
     * Associa um evento de teclado com uma função
     *
@@ -61,6 +100,10 @@ export class KeyboardManager {
 
       bindOptions.element.addEventListener(bindOptions.type, debounceFunction);
 
+      if(bindOptions.enableShadowDom) {
+         this.addEventListenerToNestedShadowRoots(bindOptions.type, debounceFunction);
+      }
+
       return this;
    }
 
@@ -86,6 +129,10 @@ export class KeyboardManager {
 
       element.removeEventListener(type, callback);
 
+      if(unbindElement.options.enableShadowDom) {
+         this.removeEventListenerToNestedShadowRoots(type, callback);
+      }
+
       return this;
    }
 

package/src/utils/KeyboardManager/interface.ts

@@ -1,6 +1,7 @@
 export interface IKeyboardOptions {
    type: 'keydown' | 'keyup',
    propagate: boolean,
+   enableShadowDom: boolean,
    element: HTMLElement | Document,
    debounceTime: number,
    description?: string,

package/src/utils/LockManager.ts

@@ -6,7 +6,11 @@ export enum LockManagerOperation {
     /**
         Operação de lock utilizada para controlar cliques nos botoes da taskbar.
     */
-    TASKBAR_CLICK = "taskbar_click"
+    TASKBAR_CLICK = "taskbar_click",
+    /**
+        Operação de lock utilizada para controlar carregamento da aplicação.
+    */
+    APP_LOADING = "app_loading"
 }
 
 type Lock = {
@@ -72,7 +76,7 @@ export class LockManager{
             }
         });
     };
-
+    
    /**
     * Cria um contexto de locker, caso nao exista, para todos elementos pais iniciados com ez- ou snk-.
     * 
@@ -103,6 +107,30 @@ export class LockManager{
         }
     }
     
+    /**
+     * 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
+     * @param operation - Operação específica para resetar os locks
+     * @returns Promise que será resolvida quando todos os locks forem resetados
+     */
+    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) {
+            await Promise.all(currentLocks.map(lock => {
+                lock.done = true;
+                lock.resolve?.();
+                return lock.promise;
+            }));
+
+            this._locks.delete(lockerId);            
+        }
+    }
+    
+ 
     /**
     * Inicia um locker baseado em um contexto e uma operação.
     * 
@@ -111,7 +139,7 @@ export class LockManager{
     * 
     * @returns - Uma função que fara a liberação do lock.
     */
-    public static lock(id:string|HTMLElement, operation:LockManagerOperation): any{
+    public static lock(id:string|HTMLElement, operation:LockManagerOperation): () => void {
         const lockerId = LockManager.buildLockerID(id, operation);
 
         if(!lockerId) return () => {};
@@ -122,7 +150,6 @@ export class LockManager{
 
         const currentLocks = LockManager._locks.get(lockerId) ?? [];
         currentLocks.push(lock);
-
         LockManager._locks.set(lockerId, currentLocks);
 
         return () => {
@@ -139,19 +166,48 @@ export class LockManager{
     * 
     * @returns - Promise que será resolvida quando todos lockers forem finalizados.
     */
-    public static async whenResolve(id:string|HTMLElement, operation:LockManagerOperation): 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(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) ?? [];
             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));
-
+            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> {
+        const lockerId = LockManager.buildLockerID(id, operation);
+
+        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;
+            }
+
+            await new Promise(resolve => setTimeout(resolve, 200));
         }
     }
 }

package/src/utils/UserAgentUtils/index.ts

@@ -15,6 +15,11 @@ export class UserAgentUtils {
         return !!browser.firefox;
     }
 
+    public static isElectron() {
+        const browser = this.getBrowserInfo();
+        return !!browser.electron;
+    }
+
     /**
      * Obtém nome e versão do navegador que está sendo utilizado.
      * @returns Objeto com o nome e versão do navegador.
@@ -40,6 +45,7 @@ export class UserAgentUtils {
                         }
                     } catch (e) {
                         //ignored
+                        console.warn(e);
                     }
 
                     browser = {
@@ -49,7 +55,6 @@ export class UserAgentUtils {
                         simpleVersion,
                         ...(Array.isArray(type) ? type.reduce((acc, val) => ({ ...acc, [val]: true}), {}) : { [type]: true })
                     }
-
                     return !hasFound;
                 }
             })