@sankhyalabs/core 5.10.1 → 5.11.0-dev.2

package/src/repository/IRepository.ts

@@ -0,0 +1,82 @@
+import { ILoadResult } from "./ILoadResult.js";
+
+export interface IRepository<T>{
+
+    /**
+     * Recupera registros do repositório
+     * 
+     * @param filterFunction - Teste para determinar se um registro está no universo desejado
+     * @param sortingFunction - Critério comparação para ordenação
+     * @param offset - Determina que o resultado descarta os registros iniciais
+     * @param limit - Descarta o resultado a partir de uma quantidade de registros
+     * @returns Promessa de um array que satisfaça aos critérios informados
+     */   
+    load(filterFunction?: (value: T) => boolean, sortingFunction?: (itemA: T, itemB: T) => number, offset?: number, limit?: number): Promise<ILoadResult<T>>;
+
+    /**
+     * 
+     * Itera todos os items colecionando os valores distintos.
+     * 
+     * @param itemProcessor - Uma função que processa um item e gera a chave e valor
+     * @returns Promessa de array com os valores distintos.
+     */
+    distict(itemProcessor: (item: T) => {key: string, value: any}): Promise<Map<string, any>>;
+    
+    /**
+     * Adiciona registros no final do repositório
+     * 
+     * @param items - Os items a serem adicionados
+     * @returns Promessa de execução
+     */ 
+    push(items: Array<T>): Promise<void>;
+
+    /**
+     * Limpa todo o repositório
+     * 
+     * @returns Promessa de execução
+     */
+    clear(): Promise<void>;
+
+    /**
+     * Remove itens do repositório
+     * 
+     * @param items - Os itens a serem removidos
+     * @returns Promessa de execução
+     */
+    delete(items: Array<T>): Promise<void>;
+
+    /**
+     * Altera itens já persistido no repositório
+     * 
+     * @param items - Os itens a serem alterados
+     * @returns Promessa de execução
+     */
+    update(items: Array<T>): Promise<void>;
+
+    /**
+     * Insere itens em uma posição de referência
+     * 
+     * @param itemReference - O item posterior aos inseridos
+     * @param items - Os itens a serem inseridos
+     * @returns Promessa de execução
+     */
+    insert(itemReference: T, items: Array<T>): Promise<void>;
+
+    /**
+     * Determina se o repositório está em condições normais de funcionamento.
+     * Caso o banco tenha sido excluido, retorna false.
+     */
+    isOperating(): boolean;
+
+    /**
+     * Determina se o repositório está vazio ou ainda não foi criado.
+     */
+    isEmpty(): Promise<boolean>;
+
+    /**
+     * Conta os itens do repositório
+     * 
+     * @returns Promessa de quantidade
+     */
+    count(): Promise<number>;
+}

package/src/repository/indexeddb/IDBRepository.ts

@@ -0,0 +1,355 @@
+import ErrorException from "../../exceptions/ErrorException.js";
+import { ILoadResult } from "../ILoadResult.js";
+import { openDB, IDBPDatabase, IDBPTransaction } from 'idb';
+import { IRepositoryIndex } from "./IRepositoryIndex.js";
+import { IRepository } from "../IRepository.js";
+
+/**
+ * Abstração para simplificar o uso do indexed DB
+ * 
+ * Além de facilitar os comandos de incluir, remover alterar e obter
+ * objetos, esse repositório preserva a ordem de inserção na lista, 
+ * além de permitir filtros e ordenações compostas 
+ * (impossíveis com uso de índices).
+ * 
+ */
+export class IDBRepository<T> implements IRepository<T>{
+
+    private _dbName: string;
+    private _dbVersion: number;
+    private _storeName: string;
+    private _addedStoreName: string;
+    private _indexKeyPath: string;
+    private _indexes?: Array<IRepositoryIndex>;
+    private _db?: IDBPDatabase;
+    private _operating: boolean = true;
+
+    /**
+     * Construtor padrão
+     *  
+     * @param dbName - Nome do DB
+     * @param dbVersion - Versão do DB
+     * @param storeName - Nome da store
+     * @param indexKeyPath - Um atributo que identifique os objetos guardados
+     */
+    constructor(dbName: string, dbVersion: number, storeName: string, indexKeyPath: string, indexes?: Array<IRepositoryIndex>){
+        this._dbName = dbName;
+        this._dbVersion = dbVersion;
+        this._storeName = storeName;
+        this._addedStoreName = `${this._storeName}_ADDED__[REPOSITORY]`;
+        this._indexKeyPath = indexKeyPath;
+        this._indexes = indexes;
+    }
+
+    public async load(filterFunction?: (value: T) => boolean, sortingFunction?: (itemA: T, itemB: T) => number, offset?: number, limit?: number): Promise<ILoadResult<T>>{
+        try{
+            const db = await this.openDB();
+            const addedItems: Array<IAddedItem<T>> = await this.getAddedItems(db);
+
+            const tx =  db.transaction(this._storeName);
+            let cursor = await tx.objectStore(this._storeName).openCursor();
+            const collectedValues: Array<T> = [];
+            let itemsCount: number = 0;
+
+            while (cursor) {
+                appendResult(
+                    addedItems
+                        .filter(addedItem => addedItem.position === itemsCount)
+                        .map(addedItems => addedItems.item),
+                    collectedValues,
+                    filterFunction
+                );
+                appendResult(cursor.value, collectedValues, filterFunction);
+                itemsCount++;
+                cursor = await cursor.continue();
+            }
+
+            const returnValue = sortingFunction != undefined ? collectedValues.sort(sortingFunction) : collectedValues;
+            const start = offset||0;
+            const end = limit ? start + limit : returnValue.length;
+            
+            return Promise.resolve({result: returnValue.slice(start, end), count: collectedValues.length});
+        } catch (error){
+            console.error(error);
+            throw new ErrorException("Erro ao buscar itens", `Não foi possível listar a store "${this._storeName}". Verifique o console para maiores detalhes.`);
+        }
+    }
+
+    public async distict(itemProcessor: (item: T) => {key: string, value: any}): Promise<Map<string, any>>{
+        try{
+            const db = await this.openDB();
+            const tx =  db.transaction([this._storeName, this._addedStoreName]);
+            
+            const itemCollector = {
+                result: new Map<string, any>,
+                collect: (item: T) => {
+                    const processedItem = itemProcessor(item);
+                    if(processedItem != undefined){
+                        itemCollector.result.set(processedItem.key, processedItem.value);
+                    }
+                }
+            };
+
+            await iterateStore(this._storeName, tx, value => itemCollector.collect(value));
+            await iterateStore(this._addedStoreName, tx, value => itemCollector.collect(value.item));
+
+            return Promise.resolve(itemCollector.result);
+        } catch (error){
+            console.error(error);
+            throw new ErrorException("Erro ao buscar distinct", `Não foi possível listar a store "${this._storeName}". Verifique o console para maiores detalhes.`);
+        }
+    }
+    
+    public async push(items: Array<T>): Promise<void>{
+        if(items == undefined || items.length === 0){
+            return Promise.resolve();
+        }
+        try{
+            const db = await this.openDB();
+            return new Promise((accept, reject) =>{
+                Promise.all(items.map(item => db.add(this._storeName, item)))
+                .then(()=>accept())
+                .catch(reason => {
+                    console.error(reason);
+                    reject(new ErrorException("Erro ao adicionar registro", `Não foi possível adicionar registros no repositório ${this._storeName}. Verifique o console para maiores detalhes.`));
+                })
+            });
+        } catch (error){
+            console.error(error);
+            throw new ErrorException("Erro ao adicionar registro", `Não foi possível adicionar registros no repositório ${this._storeName}. Verifique o console para maiores detalhes.`);
+        }
+    }
+
+    public async clear(): Promise<void>{
+        try{
+            const db = await this.openDB();
+            [this._storeName, this._addedStoreName].forEach(storeName => {
+                if(db.objectStoreNames.contains(storeName)){
+                    db.clear(storeName);
+                }
+            });
+            return Promise.resolve();
+        } catch (error){
+            console.error(error);
+            throw new ErrorException("Erro ao limpar repositório", `Limpar o repositório ${this._storeName}. Verifique o console para maiores detalhes.`);
+        }
+    }
+
+    public async delete(items: Array<T>): Promise<void>{
+        try{
+            const db = await this.openDB();
+            const tx = db.transaction([this._storeName, this._addedStoreName], "readwrite");
+            const addedStore = tx.objectStore(this._addedStoreName);
+            const store = tx.objectStore(this._storeName);
+            
+            items.forEach(async item => {
+                let key = await addedStore.index(this._indexKeyPath).getKey(IDBKeyRange.only((item as any)[this._indexKeyPath]));
+                if(key != undefined){
+                    addedStore.delete(key);
+                } else {
+                    key = await store.index(this._indexKeyPath).getKey(IDBKeyRange.only((item as any)[this._indexKeyPath]));
+                    if(key == undefined){
+                        throw new ErrorException("Erro interno: Erro ao remover itens", "Tentando remover um item que não está no repositório.");
+                    }
+                    store.delete(key);
+                }
+            });
+            
+            return Promise.resolve();
+        } catch (error){
+            console.error(error);
+            throw new ErrorException("Erro ao remover itens", `Verifique o console para maiores detalhes.`);
+        }
+    }
+
+    public async update(items: Array<T>): Promise<void>{
+        try{
+            const db = await this.openDB();
+
+            const tx = db.transaction([this._storeName, this._addedStoreName], "readwrite");
+            const addedStore = tx.objectStore(this._addedStoreName);
+            const store = tx.objectStore(this._storeName);
+            
+            items.forEach(async item => {
+                let key = await addedStore.index(this._indexKeyPath).getKey(IDBKeyRange.only((item as any)[this._indexKeyPath]));
+                if(key != undefined){
+                    const {position} = await addedStore.get(IDBKeyRange.only(key)) as IAddedItem<T>;
+                    addedStore.put({position, item}, key);
+                } else {
+                    key = await store.index(this._indexKeyPath).getKey(IDBKeyRange.only((item as any)[this._indexKeyPath]));
+                    if(key == undefined){
+                        throw new ErrorException("Erro interno: Erro ao alterar itens", "Tentando modificar um item que não está no repositório.");
+                    }
+                    store.put(item, key);
+                }
+            });
+            
+            return Promise.resolve();
+        } catch (error){
+            console.error(error);
+            throw new ErrorException("Erro ao alterar itens", `Verifique o console para maiores detalhes.`);
+        }
+    }
+
+    public async insert(itemReference: T, items: Array<T>): Promise<void>{
+        try{
+            const db = await this.openDB();
+            const position = await this.getItemPosition(db, item => item[this._indexKeyPath] === (itemReference as any)[this._indexKeyPath]);
+            if(position == -1){
+                console.error(itemReference);
+                return Promise.reject("Erro interno: Item de referência não localizado na inclusão");
+            }
+
+            items.forEach(item =>{
+                const tx = db.transaction(this._addedStoreName, "readwrite");
+                tx.objectStore(this._addedStoreName).add({item, position});
+            });
+            return Promise.resolve();
+        } catch (error){
+            console.error(error);
+            throw new ErrorException("Falha ao tentar inserir item", `Verifique o console para maiores detalhes.`);
+        }
+    }
+
+    public isOperating(): boolean{
+        return this._operating;
+    }
+
+    public async isEmpty(): Promise<boolean>{
+        try{
+            if((await indexedDB.databases()).find(db => db.name === this._dbName) == undefined){
+                return Promise.resolve(false);
+            }
+            const db = await this.openDB();
+            if(!db.objectStoreNames.contains(this._storeName)){
+                return Promise.resolve(false);
+            }
+            const tx = db.transaction(this._storeName);
+            const store = tx.objectStore(this._storeName);
+            return Promise.resolve(await store.count() === 0);
+        } catch (error){
+            console.error(error);
+            throw new ErrorException("Falha ao verificar se o repositório está vazio", `Verifique o console para maiores detalhes.`);
+        }
+    }
+
+    public async count(): Promise<number>{
+        try{
+            if((await indexedDB.databases()).find(db => db.name === this._dbName) == undefined){
+                return Promise.resolve(0);
+            }
+            const db = await this.openDB();
+            const tx = db.transaction([this._storeName, this._addedStoreName]);
+            return Promise.resolve(await tx.objectStore(this._storeName).count() + await tx.objectStore(this._addedStoreName).count());
+        } catch (error){
+            console.error(error);
+            throw new ErrorException("Falha ao contar itens do repositório", `Verifique o console para maiores detalhes.`);
+        }
+    }
+
+    private async openDB(): Promise<IDBPDatabase>{
+        try{
+            if(this._db){
+                return this._db;
+            }
+            this._db = await openDB(this._dbName, this._dbVersion, {
+                upgrade: (db) => {
+                    this.createStore(db, this._storeName);
+                    this.createStore(db, this._addedStoreName, "item.");
+                },
+                terminated: () => {
+                    this._operating = false;
+                }
+            });
+            return this._db;
+        } catch (error){
+            console.error(error);
+            throw new ErrorException("Erro interno: Falha ao tentar abrir o indexedDB", `Verifique o console para maiores detalhes.`);
+        }
+    }
+
+    private createStore(db: IDBPDatabase, name: string, indexPrefix: string = "") {
+        if(!db.objectStoreNames.contains(name)){
+            const store = db.createObjectStore(name, {autoIncrement: true});
+            store.createIndex(this._indexKeyPath, `${indexPrefix}${this._indexKeyPath}`, {unique: true});
+            if(this._indexes == undefined || this._indexes.length === 0){
+                return;
+            }
+            this._indexes.forEach(index => {
+                store.createIndex(index.name, `${indexPrefix}${index.path}`, index);
+            });
+        }
+    }
+
+    private async getItemPosition(db: IDBPDatabase, itemTest: (item: any) => boolean): Promise<number>{
+
+        const addedIndex = await this.getItemPositionByAdded(db, itemTest);
+        if(addedIndex > -1){
+            return Promise.resolve(addedIndex);
+        }
+     
+        const tx =  db.transaction(this._storeName);
+        let cursor = await tx.objectStore(this._storeName).openCursor();
+        let found: boolean = false;
+        let position = 0;
+        while (cursor) {
+            if(itemTest(cursor.value)){
+                found = true;
+                break;
+            }
+            position++;
+            cursor = await cursor.continue();
+        }
+     
+        return Promise.resolve(found ? position : -1);
+    }
+
+    private async getItemPositionByAdded(db: IDBPDatabase, itemTest: (item: any) => boolean): Promise<number>{
+        const addedItems: Array<IAddedItem<T>> = await this.getAddedItems(db);
+        if(addedItems && addedItems.length > 0){
+            const foundItem = addedItems.find(addedItem => itemTest(addedItem.item))
+            if(foundItem != null){
+                return Promise.resolve(foundItem.position);
+            }
+        }
+
+        return Promise.resolve(-1);
+    }
+
+    private async getAddedItems(db: IDBPDatabase): Promise<Array<IAddedItem<T>>>{
+        const tx = db.transaction(this._addedStoreName);
+        return tx.objectStore(this._addedStoreName).getAll();
+    }
+}
+
+/**
+ * Metodo utilitário usado para iterar uma store.
+ */
+const iterateStore = async (storeName: string, tx: IDBPTransaction, callBack: (value: any) => void) =>{
+    let cursor = await tx.objectStore(storeName).openCursor();
+    while (cursor) {
+        callBack(cursor.value);
+        cursor = await cursor.continue();
+    }
+}
+
+/**
+ * Metodo utilitário usado para simplificar a lógica de coletar valores considerando um filtro.
+ */
+const appendResult = <T>(toAppend: Array<T>|T, collectedValues: Array<T>, filterFunction?: (value: T) => boolean) => {
+    if(toAppend != undefined){
+        (Array.isArray(toAppend) ? toAppend : [toAppend]).forEach(item => {
+            if(filterFunction == undefined || filterFunction(item)){
+                collectedValues.push(item);
+            }
+        });
+    }
+}
+
+/**
+ * Interface usada para armazenar items adicionados e a posição onde eles devem ficar.
+ */
+interface IAddedItem<T>{
+    item: T;
+    position: number
+}

package/src/repository/indexeddb/IRepositoryIndex.ts

@@ -0,0 +1,4 @@
+export interface IRepositoryIndex extends IDBIndexParameters{
+    name: string;
+    path: string;
+}

package/src/traking/ErrorTraking.ts

@@ -17,7 +17,7 @@ export class ErrorTracking {
         const rollbar = (window as any).Rollbar;
         if(rollbar){
             rollbar.configure({
-                checkIgnore: function(isUncaught:boolean, args:Array<any>, payload:any) {
+                checkIgnore: function(isUncaught:boolean, args:Array<any>, _payload:any) {
                     return args[1] ? ErrorTracking.isInternalException(args[1]) : false;
                 }
             });

package/src/ui/FloatingManager.ts

@@ -400,7 +400,7 @@ export default class FloatingManager {
     public static unsubscribeOverlayControl(identifier: HTMLElement | number){
         if(!identifier) return;
         
-        let item: HTMLElement = identifier instanceof HTMLElement ? identifier : this.overlayElements[identifier -1];
+        const item: HTMLElement = identifier instanceof HTMLElement ? identifier : this.overlayElements[identifier -1];
         
         const oldZIndex = item.getAttribute(FloatingManager.DATA_OLD_ZINDEX_ATTRIBUTE_NAME) || '';
         item.setAttribute(FloatingManager.DATA_OLD_ZINDEX_ATTRIBUTE_NAME, oldZIndex);

package/src/utils/ApplicationContext.ts

@@ -1,5 +1,3 @@
-import { StringUtils } from "./StringUtils.js";
-
 /***
  * `ApplicationContext`: Utilizado para manipulação do contexto.
  * - Evitar uso da classe sem alinhamento com a arquitetura devido ao uso de variáveis globais.

package/src/utils/DateUtils.ts

@@ -1,5 +1,3 @@
-import { number } from "yargs";
-
 /**
  * `DateUtils`: Utilizado para formatação, padronização e cálculos de datas. 
  */

package/src/utils/ElementIDUtils.ts

@@ -64,7 +64,7 @@ export class ElementIDUtils {
   * @returns - Atributo `data-element-id` do elemento modificado com sufixo e/ou ID.
   */ 
   private static getDataElementID(element: HTMLElement, suffix?: string, iDInfo?: IElementIDInfo) {
-    let dataElementID = ElementIDUtils.getDataElementIDAttribute(element);
+    const dataElementID = ElementIDUtils.getDataElementIDAttribute(element);
     if(dataElementID != null){
       return this.addSuffix(StringUtils.toCamelCase((dataElementID as string)), suffix, element);
     }
@@ -74,7 +74,7 @@ export class ElementIDUtils {
     if(validAttribute) return this.addSuffix(validAttribute, suffix, element);
     if(suffix) return String(suffix);
 
-    let tagName = StringUtils.toCamelCase(element.tagName);
+    const tagName = StringUtils.toCamelCase(element.tagName);
     element.setAttribute(ElementIDUtils.DATA_ELEMENT_ID_ATTRIBUTE_NAME, tagName);
 
     return tagName;

package/src/utils/NumberUtils.ts

@@ -164,7 +164,7 @@ export class NumberUtils {
         //keep only decimal character in order to correct format the string
         //This transformation is due the "stringtoNumber" method is a general method that tries to convert all formated strings
         if (formatnumber === 'EN-US') {
-            value = value.replace(/\,/g, '');
+            value = value.replace(/,/g, '');
         } else {
             value = value.replace(/\./g, '');
         }
@@ -185,7 +185,7 @@ export class NumberUtils {
     */
     static changeFormat = (value: string): string => {
         //Formatting output following formatnumber
-        return value.replace(/\./g, '_').replace(/\,/g, '.').replace(/\_/g, ',');
+        return value.replace(/\./g, '_').replace(/,/g, '.').replace(/_/g, ',');
     }
 
 

package/src/utils/StringUtils.ts

@@ -69,7 +69,7 @@ export class StringUtils {
             ['quot', '"']
         ];
 
-        for(let entity of entities) {
+        for(const entity of entities) {
             text = text.replace(new RegExp(`&${entity[0]};`), entity[1]);
         }
     
@@ -307,20 +307,19 @@ export class StringUtils {
      */
     static formatBytes(bytes: number): string {
         const units = ["B", "KB", "MB", "GB"];
-        let unit: string, value: string, base: number;
     
         if (bytes < 1024) {
           return `${bytes.toString()}B`;
         }
         
-        base = Math.log(bytes) / Math.log(1024);
+        const base = Math.log(bytes) / Math.log(1024);
         const offSet = Math.floor(base);
         if (offSet >= units.length) {
           return `${bytes.toString()}B`;
         }
     
-        value = this.prettyPrecision(Math.pow(1024, base - offSet).toFixed(2).toString());
-        unit = units[offSet];
+        const value = this.prettyPrecision(Math.pow(1024, base - offSet).toFixed(2).toString());
+        const unit = units[offSet];
     
         return `${value}${unit}`;
       }