@sankhyalabs/core 6.0.1 → 6.1.0-dev.2

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

@@ -7,7 +7,7 @@ import { FieldDescriptor, UserInterface } from '../metadata/UnitMetadata.js';
 
 export const getFormattedValue = (value: any, descriptor?: FieldDescriptor) => {
     if(descriptor?.userInterface === UserInterface.FILE){
-        return getFileFotmat(value);
+        return getFileFormat(value);
     }
 
     if(descriptor?.dataType === DataType.OBJECT){
@@ -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;
 }
 
@@ -127,10 +131,9 @@ const getMask = (value: string, descriptor: FieldDescriptor | undefined): string
     return mask;
 }
 
-const getFileFotmat = (value: any) =>{
-    if (!value || !Array.isArray(value)) return '';
-
+const getFileFormat = (value: any) => {
+    if (value == undefined) return '';
+    if (!value || !Array.isArray(value)) return value;
     if (value.length === 1) return value[0].name;
-
     return `${value.length} arquivos`;
 }

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

@@ -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,

package/src/utils/LockManager.ts

@@ -94,7 +94,6 @@ export class LockManager {
             const ctxId = LockManager.findExistingCtxId(startElement) ?? LockManager.buildContextID();
             let currentElement: HTMLElement | null = startElement;
             LockManager.traverseAndAddAttr(currentElement, ctxId);
-
             return ctxId;
         } catch (err) {
             console.warn(`Erro ao registrar locks para o elemento: ${startElement?.tagName}`, err);

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

package/test/dataunit/formatting/PrettyFormatter.spec.ts

@@ -18,7 +18,7 @@ describe('getFormattedValue', () => {
   it('should return empty string when value is not an array', () => {
     const value = 'not an array';
     const descriptor = getFileFieldDescriptor();
-    expect(getFormattedValue(value, descriptor)).toBe('');
+    expect(getFormattedValue(value, descriptor)).toBe(value);
   });
 
   it('should return empty string when value is an empty array', () => {

package/test/testCases/NumberUtilsTestCases.ts

@@ -0,0 +1,190 @@
+export const stringToNumberCases = [
+  { valueInput: '100', valueOutput: 100 },
+  { valueInput: '100,12', valueOutput: 100.12 },
+  { valueInput: '11500,12', valueOutput: 11500.12 },
+  { valueInput: '11500', valueOutput: 11500 },
+  { valueInput: '1.000', valueOutput: 1 },
+  { valueInput: '11.500,003', valueOutput: 11500.003 },
+  { valueInput: '-100', valueOutput: -100 },
+  { valueInput: '-100,12', valueOutput: -100.12 },
+  { valueInput: '-11500,1', valueOutput: -11500.1 },
+  { valueInput: '-11500', valueOutput: -11500 },
+  { valueInput: '-11.500,003', valueOutput: -11500.003 },
+  { valueInput: 'R$100', valueOutput: 100 },
+  { valueInput: 'R$100,12', valueOutput: 100.12 },
+  { valueInput: 'R$11500,12', valueOutput: 11500.12 },
+  { valueInput: 'R$11500', valueOutput: 11500 },
+  { valueInput: 'R$11.500,003', valueOutput: 11500.003 },
+  { valueInput: '-R$100', valueOutput: -100 },
+  { valueInput: '-R$100,12', valueOutput: -100.12 },
+  { valueInput: '-R$11500,12', valueOutput: -11500.12 },
+  { valueInput: '-R$11500', valueOutput: -11500 },
+  { valueInput: '-R$11.500,003', valueOutput: -11500.003 },
+  { valueInput: '', valueOutput: NaN },
+  { valueInput: 'OrdinaryString', valueOutput: NaN },
+  { valueInput: '100.167.80', valueOutput: NaN },
+  { valueInput: 'uahsuhas,auhsuhasu', valueOutput: NaN },
+  { valueInput: '100,100,100', valueOutput: NaN },
+  { valueInput: 'OrdinaryString,.OrdinaryString', valueOutput: NaN },
+  { valueInput: 'OrdinaryString.,OrdinaryString', valueOutput: NaN },
+  { valueInput: '.121212', valueOutput: 0.121212 },
+  { valueInput: ',121212', valueOutput: 0.121212 },
+  { valueInput: '1,232,333.345', valueOutput: NaN },
+  { valueInput: '1232333,345', valueOutput: 1232333.345 },
+]
+
+export const formatCases = [
+
+  { precision: 4, prettyprecision: 2, strvalue: '1.200.999,3333', strvalueOutPut: '1.200.999,3333' },
+  { precision: 2, prettyprecision: 1, strvalue: '1.000', strvalueOutPut: '1,0' },
+  { precision: 2, prettyprecision: 1, strvalue: '1200999,99', strvalueOutPut: '1.200.999,99' },
+  { precision: 4, prettyprecision: 2, strvalue: '1,232,333.345', strvalueOutPut: 'NaN' },
+  { precision: 2, prettyprecision: 1, strvalue: '1,23', strvalueOutPut: '1,23' },
+  { precision: 4, prettyprecision: 2, strvalue: '1.200.999', strvalueOutPut: 'NaN' },
+  { precision: 4, prettyprecision: 0, strvalue: '1200.00001', strvalueOutPut: '1.200' },
+  { precision: 4, prettyprecision: 0, strvalue: 'String', strvalueOutPut: 'NaN' },
+  { precision: 4, prettyprecision: 0, strvalue: '', strvalueOutPut: 'NaN' },
+
+  { precision: 4, prettyprecision: undefined, strvalue: '1.200.999,3333', strvalueOutPut: '1.200.999,3333' },
+  { precision: 2, prettyprecision: undefined, strvalue: '1.000', strvalueOutPut: '1,00' },
+  { precision: 2, prettyprecision: undefined, strvalue: '1200999,99', strvalueOutPut: '1.200.999,99' },
+  { precision: 4, prettyprecision: undefined, strvalue: '1,232,333.345', strvalueOutPut: 'NaN' },
+  { precision: 2, prettyprecision: undefined, strvalue: '1,23', strvalueOutPut: '1,23' },
+  { precision: 4, prettyprecision: undefined, strvalue: '1.200.999', strvalueOutPut: 'NaN' },
+  { precision: 4, prettyprecision: undefined, strvalue: 'NaN', strvalueOutPut: 'NaN' },
+
+
+  { precision: 1, prettyprecision: -1, strvalue: '111,199', strvalueOutPut: '111,2' },
+  { precision: 1, prettyprecision: -1, strvalue: '111,1000', strvalueOutPut: '111,1' },
+  { precision: 1, prettyprecision: 1.3, strvalue: '111,100', strvalueOutPut: '111,1' },
+  { precision: -1, prettyprecision: 1, strvalue: '111,1009', strvalueOutPut: '111,1009' },
+  { precision: -1, prettyprecision: 1, strvalue: '111,1000', strvalueOutPut: '111,1' },
+  { precision: 1.2, prettyprecision: 1, strvalue: '111,1009', strvalueOutPut: '111,1009' },
+
+
+  { precision: 2, prettyprecision: -1, strvalue: '111,199', strvalueOutPut: '111,20' },
+  { precision: 2, prettyprecision: -1, strvalue: '111,1000', strvalueOutPut: '111,10' },
+  { precision: -2, prettyprecision: 1, strvalue: '111,1009', strvalueOutPut: '111,1009' },
+  { precision: -2, prettyprecision: 1, strvalue: '111,1000', strvalueOutPut: '111,1' },
+
+
+];
+
+export  const changeFormatCases = [
+  { inputValue: '1.200.999', outPutValue: '1,200,999' },
+  { inputValue: '1.000,99', outPutValue: '1,000.99' },
+  { inputValue: '1200999,99', outPutValue: '1200999.99' },
+  { inputValue: 'R$ 1,232,333.345', outPutValue: 'R$ 1.232.333,345' },
+  { inputValue: 'R$ 1.232.333,345', outPutValue: 'R$ 1,232,333.345' },
+]
+
+export const keepOnlyDecimalSeparatorCases = [
+
+  { formatnumber: 'pt-BR', inputValue: '1.200.999', outPutValue: '1200999' },
+  { formatnumber: 'pt-BR', inputValue: '1000,99', outPutValue: '1000,99' },
+  { formatnumber: 'pt-BR', inputValue: '1200999,99', outPutValue: '1200999,99' },
+  { formatnumber: 'pt-BR', inputValue: 'R$ 1.232.333,345', outPutValue: 'R$ 1232333,345' },
+
+  { formatnumber: 'en-US', inputValue: '1,200,999', outPutValue: '1200999' },
+  { formatnumber: 'en-US', inputValue: '1,000.99', outPutValue: '1000.99' },
+  { formatnumber: 'en-US', inputValue: '1200999.99', outPutValue: '1200999.99' },
+  { formatnumber: 'en-US', inputValue: 'EUR 1,232,333.345', outPutValue: 'EUR 1232333.345' },
+
+
+];
+
+export const roundTestCases = [
+  { decimal: undefined, inputValue: 100.12, outPutValue: 100.12 },
+  { decimal: 1, inputValue: 100.12, outPutValue: 100.1 },
+  { decimal: 2, inputValue: 100.12, outPutValue: 100.12 },
+  { decimal: 3, inputValue: 100.12, outPutValue: 100.12 },
+  { decimal: 1, inputValue: 100.15, outPutValue: 100.2 },
+  { decimal: 2, inputValue: 100.15, outPutValue: 100.15 },
+  { decimal: 3, inputValue: 100.15, outPutValue: 100.15 },
+  { decimal: 1, inputValue: 100.16, outPutValue: 100.2 },
+  { decimal: 2, inputValue: 100.16, outPutValue: 100.16 },
+  { decimal: 3, inputValue: 100.16, outPutValue: 100.16 },
+  { decimal: 12, inputValue: 2118000000000.0002, outPutValue: 2118000000000.0002 },
+  { decimal: 5, inputValue: 123.45, outPutValue: 123.45 },
+  { decimal: 0, inputValue: 123.45, outPutValue: 123 },
+];
+
+export const safeFormatCases = [
+
+  { precision: 4, prettyprecision: 2, strvalue: '1.200.999,3333', strvalueOutPut: '1.200.999,3333' },
+  { precision: 2, prettyprecision: 1, strvalue: '1.000', strvalueOutPut: '1,0' },
+  { precision: 2, prettyprecision: 1, strvalue: '1200999,99', strvalueOutPut: '1.200.999,99' },
+  { precision: 4, prettyprecision: 2, strvalue: '1,232,333.345', strvalueOutPut: '0,00' },
+  { precision: 2, prettyprecision: 1, strvalue: '1,23', strvalueOutPut: '1,23' },
+  { precision: 4, prettyprecision: 2, strvalue: '1.200.999', strvalueOutPut: '0,00' },
+  { precision: 4, prettyprecision: 0, strvalue: '1200.00001', strvalueOutPut: '1.200' },
+  { precision: 4, prettyprecision: 0, strvalue: 'String', strvalueOutPut: '0,00' },
+  { precision: 4, prettyprecision: 0, strvalue: '', strvalueOutPut: '0,00' },
+
+  { precision: 4, prettyprecision: undefined, strvalue: '1.200.999,3333', strvalueOutPut: '1.200.999,3333' },
+  { precision: 2, prettyprecision: undefined, strvalue: '1.000', strvalueOutPut: '1,00' },
+  { precision: 2, prettyprecision: undefined, strvalue: '1200999,99', strvalueOutPut: '1.200.999,99' },
+  { precision: 4, prettyprecision: undefined, strvalue: '1,232,333.345', strvalueOutPut: '0,00' },
+  { precision: 2, prettyprecision: undefined, strvalue: '1,23', strvalueOutPut: '1,23' },
+  { precision: 4, prettyprecision: undefined, strvalue: '1.200.999', strvalueOutPut: '0,00' },
+  { precision: 4, prettyprecision: undefined, strvalue: 'NaN', strvalueOutPut: '0,00' },
+
+
+  { precision: 1, prettyprecision: -1, strvalue: '111,199', strvalueOutPut: '111,2' },
+  { precision: 1, prettyprecision: -1, strvalue: '111,1000', strvalueOutPut: '111,1' },
+  { precision: 1, prettyprecision: 1.3, strvalue: '111,100', strvalueOutPut: '111,1' },
+  { precision: -1, prettyprecision: 1, strvalue: '111,1009', strvalueOutPut: '111,1009' },
+  { precision: -1, prettyprecision: 1, strvalue: '111,1000', strvalueOutPut: '111,1' },
+  { precision: 1.2, prettyprecision: 1, strvalue: '111,1009', strvalueOutPut: '111,1009' },
+
+
+  { precision: 2, prettyprecision: -1, strvalue: '111,199', strvalueOutPut: '111,20' },
+  { precision: 2, prettyprecision: -1, strvalue: '111,1000', strvalueOutPut: '111,10' },
+  { precision: -2, prettyprecision: 1, strvalue: '111,1009', strvalueOutPut: '111,1009' },
+  { precision: -2, prettyprecision: 1, strvalue: '111,1000', strvalueOutPut: '111,1' },
+];
+
+export const getValueOrDefaultCases = [
+  { value: undefined, defaultValue: 0, expected: 0 },
+  { value: null, defaultValue: 10, expected: 10 },
+  { value: '', defaultValue: 5, expected: 5 },
+  { value: '  ', defaultValue: 7, expected: 7 },
+  { value: '123', defaultValue: 0, expected: 123 },
+  { value: '-123', defaultValue: 0, expected: -123 },
+  { value: '123.45', defaultValue: 0, expected: 123.45 },
+  { value: 'abc', defaultValue: 8, expected: 8 },
+  { value: 'NaN', defaultValue: 15, expected: 15 },
+  { value: '0', defaultValue: 5, expected: 0 },
+  { value: 42, defaultValue: 0, expected: 42 },
+  { value: -42, defaultValue: 0, expected: -42 },
+  { value: 0, defaultValue: 100, expected: 0 },
+  { value: NaN, defaultValue: 50, expected: 50 },
+];
+
+export const getValueOrZeroCases = [
+  { value: undefined, expected: 0 },
+  { value: null, expected: 0 },
+  { value: '', expected: 0 },
+  { value: '  ', expected: 0 },
+  { value: '123', expected: 123 },
+  { value: '-123', expected: -123 },
+  { value: '123.45', expected: 123.45 },
+  { value: 'abc', expected: 0 },
+  { value: 'NaN', expected: 0 },
+  { value: '0', expected: 0 },
+  { value: 42, expected: 42 },
+  { value: -42, expected: -42 },
+  { value: 0, expected: 0 },
+  { value: NaN, expected: 0 },
+];
+
+export const compareCases = [
+  { a: 10, b: 5, expected: 1 },
+  { a: 5, b: 10, expected: -1 },
+  { a: 5, b: 5, expected: 0 },
+  { a: -10, b: -5, expected: -1 },
+  { a: -5, b: -10, expected: 1 },
+  { a: 0, b: 0, expected: 0 },
+  { a: 0, b: -1, expected: 1 },
+  { a: -1, b: 0, expected: -1 },
+];