@sankhyalabs/core 5.17.4 → 5.18.0-ms.1

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

@@ -0,0 +1,213 @@
+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",
+    /**
+        Operação de lock utilizada para controlar carregamento da aplicação.
+    */
+    APP_LOADING = "app_loading"
+}
+
+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 "";
+        }
+    }
+    
+    /**
+     * 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.
+    * 
+    * @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): () => void {
+        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, 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, 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/MaskFormatter.ts

@@ -58,7 +58,8 @@ export class MaskFormatter {
         "cnpj": "##.###.###/####-##",
         "cpf": "###.###.###-##",
         "phone": "(##) ####-####",
-        "cep": "##.###-###"
+        "cep": "##.###-###",
+        "cor_rgb" : "'#AAAAAA"
     };
 
 
@@ -92,13 +93,103 @@ 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.
      *
      * @param value Valor a ser formatado.
+     * @param trimBefore Executa um trim para remover espaços em branco.
      * @return O valor processado de acordo com o padrão.
      */
-    public format(value: string): string {
+    public format(value: string, trimBefore: boolean = false): string {
+        if(trimBefore){
+            value = value.trim();
+        }
         let result: string = '';
         const index: Array<number> = [0];
 

package/src/utils/ObjectUtils.ts

@@ -85,6 +85,31 @@ export default class ObjectUtils{
       return ObjectUtils.objectToString(obj1) === ObjectUtils.objectToString(obj2);
     }
 
+    /**
+     * Compara se o valor de dois items são equivalentes.
+     * Comparando tanto o valor do item em si, quanto sua propriedade "value"
+     *
+     * @param obj1 - Objeto a ser comparado.
+     * @param obj2 - Objeto a ser comparado.
+     * @param propToCompare - propriedade que deve ser comparada.
+     * @returns - Se o objeto 1 é equivalente ao objeto 2.
+     *
+     * * @example
+     * hasEquivalentProps('123', {value: '123', label: teste}, 'value') | Retorna: true
+     * @example
+     * hasEquivalentProps('xpto', {value: '123', label: teste}, 'propName') | Retorna: false
+     */
+    public static hasEquivalentProps(obj1: any, obj2: any, propToCompare:string = "value"): boolean{
+      return this.getComparableProp(obj1, propToCompare) == this.getComparableProp(obj2, propToCompare);
+    }
+
+    private static getComparableProp(value: any, propToCompare:string = "value"): boolean{
+      if (typeof value === 'object' && value !== null && propToCompare in value) {
+        return value[propToCompare];
+      }
+      return value;
+    }
+
     /**
     * Verifica se o objeto está vazio (sem atributos).
     * 
@@ -104,4 +129,15 @@ export default class ObjectUtils{
     public static isNotEmpty(obj: object): boolean{
       return !this.isEmpty(obj);
     }
+
+    /**
+     * Busca a propriedade de um objeto baseado em seu caminho.
+     * 
+     * @param obj - Objeto a ser verificado.
+     * @param keyPath - Caminho da propriedade a ser buscada.
+     * @returns - O valor da propriedade caso ela exista.
+     */
+    public static getProp(obj: Record<string, any>, keyPath: string): Record<string, any> | undefined {
+      return keyPath.split('.').reduce((previous, current) => previous?.[current], obj);
+    }
 }

package/src/utils/ServiceUtils.ts

@@ -0,0 +1,36 @@
+import { CacheManager } from './CacheManager/index.js';
+import { StorageType } from './CacheManager/interfaces/index.js';
+
+
+export class ServiceUtils {
+
+    
+    /**
+     * Auxilia no uso do CacheManager, gerando automaticamente uma chave de cache com base no identificador.
+     *
+     * @template T Tipo do dado a ser retornado.
+     * @param identifier Identificadores únicos usados para compor a chave de cache.
+     * @param fetchFunction 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: `'sessionStorage'` ou `'localStorage'`. O padrão é `'sessionStorage'`.
+     * @returns Uma `Promise` com o valor armazenado ou obtido via `fetchFunction`.
+     *
+     * @example
+     * ```typescript
+     * const actions = await useCacheWithService(
+     *  `${this.entityName} - ${this.resourceID}`,
+     *   async () => {
+     *     return await fetchActionsFromAPI();
+     *   }
+     * );
+     * console.log(actions);
+     * ```
+     */
+    public static async useCacheWithService<T>(
+        identifier: string,
+        fetchFunction: () => Promise<T>,
+        storageType: StorageType = StorageType.IN_MEMORY_CACHE
+    ): Promise<T> {
+        const cacheKey = `${identifier}`;
+        return CacheManager.getOrSet(cacheKey, fetchFunction, storageType);
+    }
+}

package/src/utils/SortingUtils.ts

@@ -0,0 +1,30 @@
+import DataUnit from "../dataunit/DataUnit.js";
+import { FieldDescriptor, Sort, SortMode } from "../dataunit/metadata/UnitMetadata.js";
+import { FieldComparator } from "../dataunit/sorting/FieldComparator.js";
+import { Record } from '../dataunit/DataUnit.js';
+
+/**
+ * `SortingUtils`: Utilizado para auxiliar na ordenacao de registros.
+ */
+export default class SortingUtils {    
+
+    public static getSortingFunction(dataUnit: DataUnit, sorting?: Array<Sort>): ((recordA: Record, recordB: Record) => number) | undefined {
+
+        if (sorting == undefined || sorting.length == 0) {
+            return undefined;
+        }
+
+        return (recordA, recordB) => {
+            for (const sort of sorting) {
+                if (sort.field){
+                    const result = FieldComparator.compare(dataUnit.getField(sort.field) as FieldDescriptor, recordA, recordB, sort.mode === SortMode.ASC);
+                    if (result != 0) {
+                        return result;
+                    }
+                }
+            }
+            return 0;
+        };
+    }
+    
+}

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