@sankhyalabs/core 5.20.0-dev.6 → 5.20.0-dev.61

package/src/dataunit/loading/PaginationInfo.ts

@@ -18,4 +18,9 @@ export interface PaginationInfo {
 
     /** Se ainda existem mais registros */
     hasMore: boolean;
+    
+    /** Informa se o carregamento de dados em background está sendo executado
+     *  Caso o dataunit não tenha carga paralela o valor será indefinido
+     */
+    loadingInProgress?: boolean;
 }

package/src/dataunit/metadata/DataType.ts

@@ -119,6 +119,9 @@ export const toString = ( dataType: DataType|undefined, value: any): string => {
         } else if (dataType === DataType.DATE) {
             if (typeof value === "string") {
                 value = DateUtils.strToDate(value);
+                if (value == undefined) {
+                    return value;
+                }
             }
             return DateUtils.formatRfc3339(value as Date);
         } else {

package/src/dataunit/state/action/DataUnitAction.ts

@@ -35,6 +35,8 @@ export enum Action{
 
     SAVING_DATA = "savingData",
     DATA_SAVED = "dataSaved",
+    SAVING_ERROR = "savingError",
+    SAVING_CANCELED = "savingCanceled",
 
     REMOVING_RECORDS = "removingRecords",
     RECORDS_REMOVED = "recordsRemoved",

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

@@ -15,6 +15,8 @@ class InvalidFieldsReducerImpl implements ActionReducer{
                 return makeInvalid(currentState, action.payload);
             case Action.INVALIDATE_CLEAN:
                 return clearRecord(currentState, action.payload);
+            case Action.EDITION_CANCELED:
+                return undefined;
         }
 
         return currentState;

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

@@ -47,7 +47,7 @@ class RecordsReducerImpl implements ActionReducer {
                         newRecords.push(newRecord);
                     }
                 });
-                return newRecords.concat(Array.from(recordsMap.values()));
+                return Array.from(recordsMap.values()).concat(newRecords);
 
             case Action.RECORD_LOADED:
                 action.payload.forEach((record: any) => {

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

@@ -31,7 +31,7 @@ class SelectionReducerImpl implements ActionReducer {
                 if (currentRecords && currentRecords.size > 0) {
                     let index: number;
                     if (!currentState || currentSelection.length === 0) {
-                        index = action.type === Action.PREVIOUS_SELECTED ? 0 : Math.min(1, currentRecords.size);
+                        index = action.type === Action.PREVIOUS_SELECTED ? 0 : Math.min(0, currentRecords.size);
                     } else {
                         index = getItemIndex(currentSelection[0], currentRecords) + (action.type === Action.PREVIOUS_SELECTED ? -1 : 1);
                     }
@@ -68,7 +68,7 @@ class SelectionReducerImpl implements ActionReducer {
                 if(currentState?.lastSelection){
                     return { currentSelection: currentState.lastSelection };
                 }
-                return { currentSelection: [] }
+                return { currentSelection: currentState?.currentSelection || [] }
         }
 
         return currentState;
@@ -94,8 +94,8 @@ export const getSelection = (stateManager: StateManager): Array<string> => {
 export const getSelectionInfo = (stateManager: StateManager): SelectionInfo => {
 
     const selection = getSelectionState(stateManager);
+    const currentRequest = getCurrentRequest(stateManager);
     if(selection && selection.mode === SelectionMode.ALL_RECORDS){
-        const currentRequest = getCurrentRequest(stateManager);
         const paginationInfo: PaginationInfo | undefined = getPaginationInfo(stateManager);
         return new SelectionInfo(
             [],
@@ -106,7 +106,7 @@ export const getSelectionInfo = (stateManager: StateManager): SelectionInfo => {
         );
     }
    
-    return new SelectionInfo(getSelectionRecords(stateManager) || [], SelectionMode.SOME_RECORDS, undefined);
+    return new SelectionInfo(getSelectionRecords(stateManager) || [], SelectionMode.SOME_RECORDS, undefined, undefined, currentRequest?.sort);
 }
 
 export const hasNext = (stateManager: StateManager): boolean => {

package/src/dataunit/state/slice/test/RecordsSlice.spec.ts

@@ -0,0 +1,45 @@
+
+import * as RecordsReducerModule from '../RecordsSlice';
+import StateManager from '../../StateManager';
+import { Record } from '../../../DataUnit';
+import { Action } from '../../action/DataUnitAction';
+
+jest.spyOn(RecordsReducerModule, "getRecords").mockImplementation(() => [
+    {
+        __record__id__: '0',
+    }, {
+    __record__id__: '1',
+    }]);
+
+describe('RecordsSlice', () => {
+    let stateManager: StateManager;
+    let currentState: Array<Record>;
+    
+    beforeEach(() => {
+        stateManager = new StateManager([RecordsReducerModule.RecordsReducer]);
+        currentState = [{
+            __record__id__: '0',
+        }, {
+        __record__id__: '1',
+        }]
+    });
+
+    it('should return newlines at the end', () => {
+        let records = RecordsReducerModule.RecordsReducer.reduce(stateManager, currentState, {
+            type: Action.DATA_SAVED,
+            payload: {
+                records: [
+                    {__record__id__: '0'},
+                    {__record__id__: '2'},
+                    {__record__id__: '1'},
+                ]
+            }
+        })
+        expect(records).toEqual([
+            {__record__id__: '0'},
+            {__record__id__: '1'},
+            {__record__id__: '2'}
+        ]);
+    });
+
+});

package/src/dataunit/test/DataUnit.spec.ts

@@ -0,0 +1,44 @@
+import DataUnit  from '../DataUnit';
+import { Action } from '../state/action/DataUnitAction';
+
+describe('DataUnit', () => {
+
+    let dataUnit: DataUnit;
+
+    beforeEach(() => {
+        dataUnit = new DataUnit();
+
+        dataUnit['dispatchAction'] = jest.fn();
+    });
+
+    it('should return false when not waiting to reload', () => {
+        expect(dataUnit.isWaitingToReload()).toBe(false);
+    });
+
+    it('should set waitingToReload to true', () => {
+        dataUnit.setWaitingToReload(true);
+        expect(dataUnit.isWaitingToReload()).toBe(true);
+    });
+
+    it('should set waitingToReload to false', () => {
+        dataUnit.setWaitingToReload(true);
+        dataUnit.setWaitingToReload(false);
+        expect(dataUnit.isWaitingToReload()).toBe(false);
+    });
+
+    it('should dispatch SAVING_CANCELED action with correct fields and recordId', () => {
+        const fields = [
+            { name: 'field1', message: 'error1' },
+            { name: 'field2', message: 'error2' }
+        ];
+        const recordId = '12345';
+
+        dataUnit.savingCanceled(fields, recordId);
+
+        expect(dataUnit['dispatchAction']).toHaveBeenCalledWith(
+            Action.SAVING_CANCELED,
+            { fields, recordId },
+            undefined
+        );
+    });
+});

package/src/exceptions/ServiceCanceledException.ts

@@ -0,0 +1,25 @@
+/**
+ * `ServiceCanceledException`: Exceção lançada quando ocorre o cancelamento de um serviço. 
+ */
+export default class ServiceCanceledException 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 = "Service Canceled";
+        this.title = title;
+        this.message = message;
+        this.errorCode = errorCode;
+    }
+}

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

@@ -9,7 +9,7 @@ import { HttpProvider } from "./http/HttpProvider.js";
 import { SkwHttpProvider } from "./http/SkwHttpProvider.js";
 import { RequestMetadata } from "./http/RequestMetadata.js";
 import { AuthorizedServiceCaller } from "./http/AuthorizedServiceCaller.js";
-import DataUnit, {SavedRecord, Record, Change, ChangeOperation, DUActionInterceptor, WaitingChange, PageRequest, QuickFilter, SelectionMode, SelectionInfo} from "./dataunit/DataUnit.js";
+import DataUnit, {SavedRecord, Record, Change, ChangeOperation, DUActionInterceptor, WaitingChange, PageRequest, QuickFilter, SelectionMode, SelectionInfo, DataUnitEventOptions} from "./dataunit/DataUnit.js";
 import { DataType } from "./dataunit/metadata/DataType.js";
 import { UnitMetadata, FieldDescriptor, UserInterface, Sort, SortMode, SortingProvider, Filter, DependencyType, ChildDescriptor, ChildLink } from "./dataunit/metadata/UnitMetadata.js";
 import { DataUnitAction, Action, ExecutionContext } from "./dataunit/state/action/DataUnitAction.js";
@@ -19,6 +19,8 @@ import ObjectUtils from "./utils/ObjectUtils.js";
 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";
@@ -39,9 +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,
@@ -106,4 +114,14 @@ export {
     defaultDataLoader,
     KeyboardManager,
     SearchUtils,
+    ServiceUtils,
+    StorageType,
+    OverflowWatcher,
+    OnOverflowCallBack,
+    OverflowDirection,
+    OverFlowWatcherParams,
+    OVERFLOWED_CLASS_NAME,
+    DataUnitEventOptions,
+    ServiceCanceledException,
+    SilentException,
 };

package/src/repository/IRepository.ts

@@ -79,4 +79,11 @@ export interface IRepository<T>{
      * @returns Promessa de quantidade
      */
     count(): Promise<number>;
+    
+    /**
+     * Retorna todos os registros que estão em cache no momento
+     *
+     * @returns Todos registros que estão em cache no momento
+     */
+    getFromCache(): Array<T> | undefined
 }

package/src/repository/indexeddb/IDBRepository.ts

@@ -320,6 +320,10 @@ export class IDBRepository<T> implements IRepository<T>{
         const tx = db.transaction(this._addedStoreName);
         return tx.objectStore(this._addedStoreName).getAll();
     }
+
+    public getFromCache(): Array<T> | undefined{
+        return undefined;
+    }
 }
 
 /**

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

@@ -39,6 +39,9 @@ export default class DateUtils{
      * @returns - Uma string com as horas no formato HH:MM ou HH:MM:SS.
      */
     public static formatTime(date: Date, showSeconds: boolean = false): string{
+        if (date == null){
+            return '';
+        }
         const timeOptions:Intl.DateTimeFormatOptions = {hour: "2-digit", minute: "2-digit", second: showSeconds ? "2-digit" : undefined};
         return new Intl.DateTimeFormat("pt-BR", timeOptions).format(date);
     }

package/src/utils/ElementUtils.ts

@@ -0,0 +1,10 @@
+import { OverflowDirection } from './OverflowWatcher/types/overflow-direction.js';
+
+export function calcMarginSize(el:Element, scrollDirection: OverflowDirection){
+  const computedStyle = getComputedStyle(el);
+  if(OverflowDirection.HORIZONTAL === scrollDirection){
+    return (parseInt(computedStyle.marginLeft || '0') + parseInt(computedStyle.marginRight || '0'));
+  }
+
+  return (parseInt(computedStyle.marginTop || '0') + parseInt(computedStyle.marginBottom || '0'));
+}

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));
+        }
+    }
+}