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

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,20 @@ 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";
+import { DataUnitInMemoryLoader } from "./dataunit/loader/dataUnitInMemoryLoader.js";
+import { DataUnitLoaderUtils, PaginationInfoBuilderParams } from "./dataunit/loader/utils/dataUnitLoaderUtils.js";
+import { ColumnFilterManager } from "./utils/ColumnFilterManager.js";
+import { DataUnitInMemoryLoaderConfig, RECORD_DATE_FORMAT } from "./dataunit/loader/DataUnitInMemoryLoaderConfig.js";
+import Base64Utils from "./utils/Base64Utils.js";
 
 /*Classes públicas no pacote*/
 export {
+    LockManager,
+    LockManagerOperation,
     StringUtils,
     MaskFormatter,
     NumberUtils,
@@ -106,4 +119,22 @@ export {
     defaultDataLoader,
     KeyboardManager,
     SearchUtils,
+    ServiceUtils,
+    StorageType,
+    OverflowWatcher,
+    OnOverflowCallBack,
+    OverflowDirection,
+    OverFlowWatcherParams,
+    OVERFLOWED_CLASS_NAME,
+    DataUnitEventOptions,
+    ServiceCanceledException,
+    SilentException,
+    DataUnitInMemoryLoader,
+    DataUnitLoaderUtils,
+    PaginationInfoBuilderParams,
+    ColumnFilterManager,
+    DataUnitInMemoryLoaderConfig,
+    RECORD_DATE_FORMAT,
+    Base64Utils,
+
 };

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

@@ -0,0 +1,13 @@
+export default class Base64Utils{
+  /**
+   * Adiciona caracteres de quebra de linha ao hash64 que representa o recordId do registro.
+   * @param base64String - id do registro
+   */
+  public static addBreakLineCharacters(base64String: string) {
+    const lineBreakPattern = /.{1,76}/g;
+    const result = base64String.match(lineBreakPattern)?.join('\n') ?? base64String;
+    return result.slice(0, 247) + '\n' + result.slice(247);
+  }
+
+
+}

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

@@ -0,0 +1,104 @@
+import { Filter } from '../dataunit/metadata/UnitMetadata.js';
+import DataUnit, { Record } from '../dataunit/DataUnit.js';
+import { FieldComparator } from '../dataunit/sorting/FieldComparator.js';
+import { LoadDataRequest } from '../dataunit/loading/LoadDataRequest.js';
+
+const COLUMN_FILTER_PATTERN = /FILTRO_COLUNA_(.+)/;
+
+export class ColumnFilterManager {
+
+  public static getColumnFilters(filters: Array<Filter>, fieldName: string): Map<string, IColumnFilter> {
+    const columnFilters: Map<string, IColumnFilter> = new Map();
+
+    if (!filters?.length) {
+      return columnFilters;
+    }
+
+    filters.forEach(filter => {
+      const result = COLUMN_FILTER_PATTERN.exec(filter.name);
+      if (result) {
+        if (fieldName !== result[1]) {
+          columnFilters.set(filter.name, { columnName: result[1], ...filter });
+        }
+      }
+    });
+
+    return columnFilters;
+  }
+
+  public static getFilterFunction(dataUnit: DataUnit, filters?: Array<IColumnFilter>): ((record: Record) => boolean) | undefined {
+    if (!filters?.length) return undefined;
+
+    return record => {
+      for (const filter of filters) {
+        if (!ColumnFilterManager.recordMatchesFilter(dataUnit, record, filter)) {
+          return false;
+        }
+      }
+      return true;
+    };
+  }
+
+  private static recordMatchesFilter(dataUnit: DataUnit, record: Record, columnFilter: IColumnFilter): boolean {
+    const fieldDescriptor = dataUnit.getField(columnFilter.columnName);
+
+    if (!columnFilter.params || !fieldDescriptor) return false;
+
+    const fieldValue = record[columnFilter.columnName];
+
+    for (let param of columnFilter.params) {
+      const paramValue = dataUnit.valueFromString(columnFilter.columnName, param.value);
+      if (FieldComparator.compareValues(fieldDescriptor, fieldValue, paramValue) === 0) {
+        return true;
+      }
+
+    }
+    return false;
+  }
+
+  public static compileDistinct(fieldName: string, dataUnit: DataUnit): Array<IMultiSelectionOption> {
+    const request = dataUnit.getLastLoadRequest();
+    let list = dataUnit.records;
+    return this.doCompileDistinct(request, fieldName, dataUnit, list);
+  }
+
+  public static compileDistinctFromArray(fieldName: string, dataUnit: DataUnit, records: Array<Record>): Array<IMultiSelectionOption> {
+    const request = dataUnit.getLastLoadRequest();
+    return this.doCompileDistinct(request, fieldName, dataUnit, records);
+  }
+
+  private static doCompileDistinct(request: LoadDataRequest | undefined, fieldName: string, dataUnit: DataUnit, list: Array<Record>) {
+    if (request != undefined) {
+      const columnFilters: Array<IColumnFilter> = Array.from(ColumnFilterManager.getColumnFilters(request?.filters ?? [], fieldName).values());
+      const filterFunction = ColumnFilterManager.getFilterFunction(dataUnit, columnFilters);
+      if (filterFunction != undefined) {
+        list = list.filter(filterFunction);
+      }
+    }
+
+    const distinct: Map<string, IMultiSelectionOption> = new Map(
+      list.map(record => {
+        const fieldValue = record[fieldName];
+        if (fieldValue == undefined) {
+          return [null, { label: null, value: null, check: true }];
+        }
+        const item = { label: dataUnit.getFormattedValue(fieldName, fieldValue), value: fieldValue, check: true };
+        return [item.label, item];
+      }) as any,
+    );
+
+    return Array.from(distinct.values());
+  }
+
+}
+
+
+interface IMultiSelectionOption {
+  value: string;
+  label: string;
+  check: boolean;
+}
+
+export interface IColumnFilter extends Filter {
+  columnName: string;
+}

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/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,9 +100,23 @@ export class KeyboardManager {
 
       bindOptions.element.addEventListener(bindOptions.type, debounceFunction);
 
+      if(bindOptions.enableShadowDom) {
+         this.addEventListenerToNestedShadowRoots(bindOptions.type, debounceFunction);
+      }
+
       return this;
    }
 
+
+   /**
+    * Remove todos os eventos de teclado ou de uma lista informada
+    *
+    */
+   public unbindAllShortcutKeys(listShortcutKeys?: string[]): void {
+      const mappedKeys = [...Object.keys(listShortcutKeys || this._mappedElements)];
+      mappedKeys?.forEach(keyMap => this.unbind(keyMap));
+  }
+  
    /**
     * Remove um evento de teclado
     *
@@ -86,6 +139,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,