@sankhyalabs/core 0.0.0-bugfix-dev-KB-77217.0 → 0.0.0-bugfix-dev-KB-87855.0

package/src/dataunit/DataUnit.ts

@@ -55,6 +55,8 @@ export default class DataUnit {
     private _allowReleaseCallbacks: boolean;
     private _waitingToReload: boolean = false;
     private _cancelPagination: boolean = false;
+    private _isMultipleEdition: boolean = false;
+    private _fieldSourceValue: Map<string, string> = new Map<string, string>();
     
     public metadataLoader?: (dataUnit: DataUnit) => Promise<UnitMetadata>;
     public dataLoader?: (dataUnit: DataUnit, request: LoadDataRequest) => Promise<LoadDataResponse>;
@@ -183,6 +185,21 @@ export default class DataUnit {
         this._cancelPagination = cancelPagination;
     }
 
+    /**
+     * Informa se o DataUnit está no modo de edição de múltiplos registros.
+     */
+    public get isMultipleEdition(): boolean {
+        return this._isMultipleEdition;
+    }
+
+    /**
+     * Define se o DataUnit está no modo de edição de múltiplos registros.
+     */
+    public set isMultipleEdition(isMultipleEdition) {
+        this._isMultipleEdition = isMultipleEdition;
+        this.dispatchAction(Action.MULTIPLE_EDITION_CHANGED, {isMultipleEdition});
+    }
+
     /**
      * 
      * Obtém o nome de identificação do DataUnit (geralmente em formato de URI - Uniform Resource Identifier).
@@ -1031,7 +1048,7 @@ export default class DataUnit {
         const typedValue = this.validateAndTypeValue(fieldName, newValue);
         const currentValue = this.getFieldValue(fieldName);
 
-        if(!(newValue instanceof Promise) && ObjectUtils.hasEquivalentProps(currentValue, typedValue)){
+        if(this.areEquivalentValues(newValue, currentValue, typedValue)) {
             return Promise.resolve(false);
         }
 
@@ -1046,7 +1063,7 @@ export default class DataUnit {
             return promise;
         }
 
-        if (currentValue !== typedValue) {
+        if (this.isMultipleEdition || currentValue !== typedValue) {
             const promise = this.dispatchAction(Action.DATA_CHANGED, { [fieldName]: typedValue, records }, undefined, options);
             this._savingLockers.push(promise);
             return promise;
@@ -1055,6 +1072,12 @@ export default class DataUnit {
         return Promise.resolve(false);
     }
 
+    private areEquivalentValues(newValue: any, currentValue: any, typedValue: any) {
+        return !(newValue instanceof Promise)
+          && ObjectUtils.hasEquivalentProps(currentValue, typedValue)
+          && !this.isMultipleEdition;
+    }
+
     /**
      * 
      *  Marca campos como inválidos.
@@ -1264,7 +1287,17 @@ export default class DataUnit {
      **/ 
     public getSelectionInfo(): SelectionInfo{
         const selectionInfo: SelectionInfo = getSelectionInfo(this._stateManager);
-        selectionInfo.getAllRecords = () => this.allRecordsLoader?.(this);
+        selectionInfo.getAllRecords = () => {
+           
+            let records = this.allRecordsLoader?.(this) ?? [];
+            
+            if (selectionInfo.sort != undefined && selectionInfo.sort.length > 0) {
+                const sortingFunction = SortingUtils.getSortingFunction(this, selectionInfo.sort)
+                records = [...records].sort(sortingFunction);
+            }
+
+            return records;
+        }
 
         if (selectionInfo.sort != undefined && selectionInfo.sort.length > 0) {
             const sortingFunction = SortingUtils.getSortingFunction(this, selectionInfo.sort)
@@ -1928,6 +1961,21 @@ export default class DataUnit {
         this._allowReleaseCallbacks = allow;
     }
 
+
+    /**
+     * Adiciona um mapeamento de origem dos dados de um determinado campo
+     */
+    public addSourceFieldValue(sourceFieldName:string, targetFieldName:string): void{
+        this._fieldSourceValue.set(sourceFieldName, targetFieldName);
+    }
+
+     /**
+     * Retornar o campo de origem dos dados caso exista mapeamento
+     */
+     public getSourceFieldValue(targetFieldName:string): string | undefined{
+        return this._fieldSourceValue.get(targetFieldName);
+    }
+
     private async processLoadingLockers(){
         if(this._loadingLockers.length) {
             await Promise.all(this._loadingLockers);

package/src/dataunit/formatting/PrettyFormatter.ts

@@ -77,6 +77,10 @@ const getSearchFormat = (value: any, descriptor: FieldDescriptor) => {
         return label ? `${codeValue} - ${label}` : codeValue;
     }
 
+    if(descriptor.userInterface === UserInterface.SEARCHPLUS){
+        return codeValue;
+    }
+
     return label ? label : codeValue;
 }
 

package/src/dataunit/metadata/DataType.ts

@@ -144,16 +144,20 @@ export const toString = ( dataType: DataType|undefined, value: any): string => {
     }
 }
 
-export const compareValues = (valueA: any, valueB: any, descriptor: FieldDescriptor): number => {
+const isSearchField = (userInterface:UserInterface | undefined): boolean => {
+    return userInterface === UserInterface.SEARCH || userInterface === UserInterface.SEARCHPLUS;
+}
+
+export const compareValues = (valueA: any, valueB: any, descriptor: FieldDescriptor, onlyLabel:boolean = false): number => {
     
     if(useStringForComparison(descriptor)){
         return (getFormattedValue(valueA, descriptor) as string).localeCompare(getFormattedValue(valueB, descriptor));
     }
 
     const {dataType, userInterface} = descriptor;
-    if(userInterface === UserInterface.SEARCH || userInterface === UserInterface.OPTIONSELECTOR){
-        const optionValueA = valueA?.value || valueA;
-        const optionValueB = valueB?.value || valueB;
+    if(isSearchField(userInterface) || userInterface === UserInterface.OPTIONSELECTOR){
+        const optionValueA = (onlyLabel ? valueA?.label : valueA?.value) || valueA;
+        const optionValueB = (onlyLabel ? valueB?.label : valueB?.value) || valueB;
         if(isNaN(optionValueA) || isNaN(optionValueB)){
             return (optionValueA as string).localeCompare(optionValueB);
         }

package/src/dataunit/metadata/UnitMetadata.ts

@@ -91,6 +91,7 @@ export enum UserInterface {
     DECIMALNUMBER = "DECIMALNUMBER",
     INTEGERNUMBER = "INTEGERNUMBER",
     SEARCH = "SEARCH",
+    SEARCHPLUS = "SEARCHPLUS",
     SHORTTEXT = "SHORTTEXT",
     PASSWORD = "PASSWORD",
     MASKEDTEXT = "MASKEDTEXT",

package/src/dataunit/sorting/FieldComparator.ts

@@ -4,16 +4,16 @@ import { FieldDescriptor } from '../metadata/UnitMetadata.js';
 
 export class FieldComparator {
 
-  public static compare(field: FieldDescriptor, recordA: Record, recordB: Record, asc: boolean = true): number {
+  public static compare(field: FieldDescriptor, recordA: Record, recordB: Record, asc: boolean = true, onlyLabel: boolean = false): number {
     const valueA = (asc ? recordA : recordB)[field.name];
     const valueB = (asc ? recordB : recordA)[field.name];
 
-    return FieldComparator.compareValues(field, valueA, valueB);
+    return FieldComparator.compareValues(field, valueA, valueB, onlyLabel);
   }
 
-  public static compareValues(descriptor: FieldDescriptor, valueA: any, valueB: any): number {
+  public static compareValues(descriptor: FieldDescriptor, valueA: any, valueB: any, onlyLabel: boolean = false): number {
     const undefinedComparison = this.compareUndefined(valueA == undefined, valueB == undefined);
-    return (undefinedComparison != undefined) ? undefinedComparison : compareValues(valueA, valueB, descriptor);
+    return (undefinedComparison != undefined) ? undefinedComparison : compareValues(valueA, valueB, descriptor, onlyLabel);
   }
 
   public static compareUndefined(isUndefinedA: boolean, isUndefinedB: boolean): number | undefined {

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

@@ -26,6 +26,8 @@ export interface ExecutionContext{
 
 export enum Action{
 
+    MULTIPLE_EDITION_CHANGED = "multipleEditionChanged",
+
     LOADING_METADATA = "loadingMetadata",
     METADATA_LOADED = "metadataLoaded",
     

package/src/utils/KeyboardManager/index.ts

@@ -107,6 +107,16 @@ export class KeyboardManager {
       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
     *

package/src/utils/LockManager.ts

@@ -1,7 +1,7 @@
 import { StringUtils } from "./StringUtils.js";
-    /**
-    * Define os tipos de operação que o locker pode controlar
-    */
+/**
+* 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.
@@ -19,7 +19,7 @@ type Lock = {
     done: boolean
 }
 
-export class LockManager{
+export class LockManager {
     private static _locks = new Map<string, Array<Lock>>();
 
     /**
@@ -27,18 +27,18 @@ export class LockManager{
     */
     public static ATTRIBUTE_NAME = "data-locker-manger-context-id";
 
-    private static buildContextID(): string{
+    private static buildContextID(): string {
         return StringUtils.generateUUID();
     }
 
-    private static buildLockerID(ctxId:string|HTMLElement, operation: LockManagerOperation): string | undefined{
-        if(ctxId == undefined) return undefined;
+    private static buildLockerID(ctxId: string | HTMLElement, operation: LockManagerOperation): string | undefined {
+        if (ctxId == undefined) return undefined;
 
-        let resolvedID:any = ctxId;
+        let resolvedID: any = ctxId;
 
-        if(resolvedID instanceof HTMLElement){
+        if (resolvedID instanceof HTMLElement) {
             resolvedID = (ctxId as HTMLElement).getAttribute(LockManager.ATTRIBUTE_NAME);
-            if(!resolvedID) return undefined;
+            if (!resolvedID) return undefined;
         }
 
         return `${resolvedID}_${operation}`;
@@ -46,23 +46,23 @@ export class LockManager{
 
     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;
+            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;
     }
 
@@ -76,37 +76,31 @@ export class LockManager{
             }
         });
     };
-    
-   /**
-    * 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.
-    */
+
+    /**
+     * 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{
+        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;
-            }
-
+            LockManager.traverseAndAddAttr(currentElement, ctxId);
             return ctxId;
-        }catch(err){
+        } 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
@@ -116,7 +110,7 @@ export class LockManager{
     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) {
@@ -126,11 +120,11 @@ export class LockManager{
                 return lock.promise;
             }));
 
-            this._locks.delete(lockerId);            
+            this._locks.delete(lockerId);
         }
     }
-    
- 
+
+
     /**
     * Inicia um locker baseado em um contexto e uma operação.
     * 
@@ -139,12 +133,12 @@ export class LockManager{
     * 
     * @returns - Uma função que fara a liberação do lock.
     */
-    public static lock(id:string|HTMLElement, operation:LockManagerOperation): () => void {
+    public static lock(id: string | HTMLElement, operation: LockManagerOperation): () => void {
         const lockerId = LockManager.buildLockerID(id, operation);
 
-        if(!lockerId) return () => {};
+        if (!lockerId) return () => { };
 
-        const lock:Lock = { done: false };
+        const lock: Lock = { done: false };
         const promise = new Promise<void>(resolve => lock.resolve = resolve);
         lock.promise = promise;
 
@@ -166,42 +160,42 @@ export class LockManager{
     * 
     * @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> {
+    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 (!lockerId) return;
+
+        if (debounce) await new Promise(resolve => setTimeout(resolve, debounce));
 
-        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) ?? [];
+            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> {
+
+    public static async whenHasLock(id: string | HTMLElement, operation: LockManagerOperation, timeOut?: number): Promise<void> {
         const lockerId = LockManager.buildLockerID(id, operation);
 
-        if(!lockerId) return;
+        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;

package/src/utils/ObjectUtils.ts

@@ -120,6 +120,17 @@ export default class ObjectUtils{
       return Object.keys(obj).length === 0 && obj.constructor === Object;
     }
 
+  /**
+   * Verifica se o objeto está vazio (sem atributos) e retorna true caso seja undefined ou null.
+   *
+   * @param obj - Objeto a ser verificado.
+   * @returns - True caso o objeto esteja vazio.
+   */
+  public static isEmptySafetyCheck(obj: object): boolean{
+    if(obj === null || obj === undefined) return true;
+    return Object.keys(obj).length === 0 && obj.constructor === Object;
+  }
+
     /**
      * Verifica se o objeto NÃO está vazio (sem atributos).
      * 
@@ -130,6 +141,16 @@ export default class ObjectUtils{
       return !this.isEmpty(obj);
     }
 
+  /**
+   * Verifica se o objeto NÃO está vazio (sem atributos) e retorna false caso objeto seja null ou undefined.
+   *
+   * @param obj - Objeto a ser verificado.
+   * @returns - True caso o objeto NÃO esteja vazio
+   */
+  public static isNotEmptySafetyCheck(obj: object): boolean{
+    return !this.isEmptySafetyCheck(obj);
+  }
+
     /**
      * Busca a propriedade de um objeto baseado em seu caminho.
      * 

package/src/utils/SortingUtils.ts

@@ -17,7 +17,16 @@ export default class SortingUtils {
         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);
+                    let field = dataUnit.getField(sort.field) as FieldDescriptor;
+                    let onlyLabel = false;
+                    if(!field){
+                        const sourceFieldName = dataUnit.getSourceFieldValue(sort.field) ?? "";
+
+                        field = dataUnit.getField(sourceFieldName) as FieldDescriptor;
+                        onlyLabel = true;
+                    }
+
+                    const result = FieldComparator.compare(field, recordA, recordB, sort.mode === SortMode.ASC, onlyLabel);
                     if (result != 0) {
                         return result;
                     }

package/src/utils/StringUtils.ts

@@ -289,7 +289,7 @@ export class StringUtils {
      * @returns String convertida em PascalCase.
      */
     static toPascalCase(value: string): string{
-        return value
+        return (value || "")
           .toLowerCase()
           .replace(/(?:^|\s)\w/g, (match: string) => match.toUpperCase())
           .replace(/[\s-_]/g,'');
@@ -301,7 +301,7 @@ export class StringUtils {
      * @returns String convertida em snake_case.
      */
     static toSnakeCase(value: string): string{
-        return value
+        return (value || "")
         .toLowerCase()
         .replace(/[A-Z]/g, (match: string) => `_${match.toLowerCase()}`)
         .replace(/[\s-]/g, '_')
@@ -314,7 +314,7 @@ export class StringUtils {
      * @returns String convertida em KebabCase.
      */
     static toKebabCase(value: string): string{
-        return value.replace(/([a-z])([A-Z])/g, '$1-$2').replace(/[\s_]+/g, '-').toLowerCase();
+        return (value || "").replace(/([a-z])([A-Z])/g, '$1-$2').replace(/[\s_]+/g, '-').toLowerCase();
     }
 
     /**
@@ -336,13 +336,13 @@ export class StringUtils {
         const units = ["B", "KB", "MB", "GB"];
 
         if (bytes < 1024) {
-          return `${bytes.toString()}B`;
+          return `${bytes?.toString()}B`;
         }
 
         const base = Math.log(bytes) / Math.log(1024);
         const offSet = Math.floor(base);
         if (offSet >= units.length) {
-          return `${bytes.toString()}B`;
+          return `${bytes?.toString()}B`;
         }
 
         const value = this.prettyPrecision(Math.pow(1024, base - offSet).toFixed(2).toString());
@@ -389,6 +389,8 @@ export class StringUtils {
      * @return {boolean} Se a string pode ser convertida
      */
     static isCaseable(original: string): boolean {
+        if(original == null) return false;
+
         const uppercase = original.toUpperCase()
         const lowercase = original.toLowerCase()
 
@@ -402,6 +404,7 @@ export class StringUtils {
      * @return {boolean} Se a string é minúscula
      */
     static isLowerCase(original: string): boolean {
+        if(original == null) return false;
         const uppercase = original.toUpperCase()
 
         return this.isCaseable(original) && uppercase !== original
@@ -414,6 +417,7 @@ export class StringUtils {
      * @return {string} A string invertida
      */
     static getOppositeCase(original: string): string {
+        if(original == null) return "";
         return this.isLowerCase(original) ? original.toUpperCase() : original.toLowerCase()
     }
 
@@ -487,7 +491,7 @@ export class StringUtils {
       }
 
     public static highlightValue(argument: String, matchFields: any, value: string, fieldMD: any, forceMatch: boolean) {
-        const startHighlightTag = "<span class='card-item__highlight'>";
+        const startHighlightTag = "<span class='card-item__highlight'>"; //FIXME: valor hardcoded, não podemos reaproveitar para outros cenários, dessa forma.
         const endHighlightTag = "</span>";
         let valueAux = JSUtils.replaceHtmlEntities(value);