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

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/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);
     
@@ -538,4 +542,17 @@ export class StringUtils {
       
         return valueAux;
     }
+
+
+  /**
+   * Escapa caracteres especiais em uma string, usando sequencias de escape Unicode.
+   * @param str A string que deve sofrer alteração.
+   * @returns String com valores alterados.
+   */
+  public static escapeString(str: string): string {
+    // eslint-disable-next-line no-control-regex
+    return str.replace(/[\u0000-\u001F\u007F-\uFFFF<>=&"']/g, (char) => {
+      return "\\u" + char.charCodeAt(0).toString(16).padStart(4, "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;
                 }
             })

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

@@ -0,0 +1,177 @@
+import { getFormattedValue } from '../../../src/dataunit/formatting/PrettyFormatter';
+import { DataType, FieldDescriptor, UserInterface } from '../../../src';
+
+/**
+ * É preciso importart o utilitário DateUtils para que seus métodos
+ * estáticos sejam executados no ambiente de testes
+ */
+
+import { DateUtils } from '../../../src';
+
+describe('getFormattedValue', () => {
+  it('should return empty string when value is null', () => {
+    const value = null;
+    const descriptor = getFileFieldDescriptor();
+    expect(getFormattedValue(value, descriptor)).toBe('');
+  });
+
+  it('should return empty string when value is not an array', () => {
+    const value = 'not an array';
+    const descriptor = getFileFieldDescriptor();
+    expect(getFormattedValue(value, descriptor)).toBe('');
+  });
+
+  it('should return empty string when value is an empty array', () => {
+    const value: any[] = [];
+    const descriptor  = getFileFieldDescriptor();
+    expect(getFormattedValue(value, descriptor)).toBe('0 arquivos');
+  });
+
+  it('should return file name when value is an array with one file object', () => {
+    const value = [{ name: 'file1.txt' }];
+    const descriptor = getFileFieldDescriptor();
+    expect(getFormattedValue(value, descriptor)).toBe('file1.txt');
+  });
+
+  it('should return file count when value is an array with multiple file objects', () => {
+    const value = [{ name: 'file1.txt' }, { name: 'file2.txt' }];
+    const descriptor = getFileFieldDescriptor();
+    expect(getFormattedValue(value, descriptor)).toBe('2 arquivos');
+  });
+
+  it('should return empty string for undefined file', () => {
+    const value = undefined;
+    const descriptor = { userInterface: UserInterface.FILE } as FieldDescriptor;
+    expect(getFormattedValue(value, descriptor)).toBe('');
+  });
+
+  it('should handle OBJECT type with value field', () => {
+    const value = { value: 'code', label: 'label' };
+    const descriptor = { dataType: DataType.OBJECT, userInterface: UserInterface.SEARCH } as FieldDescriptor;
+    expect(getFormattedValue(value, descriptor)).toBe('code - label');
+  });
+
+  it('should return empty string when value is undefined', () => {
+    const value = undefined;
+    const descriptor = getObjectFieldDescriptor();
+    expect(getFormattedValue(value, descriptor)).toBe('');
+  });
+
+  it('should return value as string when value is not an object', () => {
+    const value = 12345;
+    const descriptor = getObjectFieldDescriptor();
+    expect(getFormattedValue(value, descriptor)).toBe('12345');
+  });
+
+  it('should return value.toString() when value is an object without value property', () => {
+    const value = { someProperty: 'someValue' };
+    const descriptor = getObjectFieldDescriptor();
+    expect(getFormattedValue(value, descriptor)).toBe(value.toString());
+  });
+
+  it('should handle BOOLEAN type', () => {
+    expect(getFormattedValue(true, { dataType: DataType.BOOLEAN } as FieldDescriptor)).toBe('Sim');
+    expect(getFormattedValue(false, { dataType: DataType.BOOLEAN } as FieldDescriptor)).toBe('Não');
+  });
+
+  it('should format numbers correctly', () => {
+    const value = 1234.567;
+    const descriptor = {
+      dataType: DataType.NUMBER,
+      properties: { precision: 2, prettyPrecision: 2 },
+    } as FieldDescriptor;
+    expect(getFormattedValue(value, descriptor)).toBe('1.234,57');
+  });
+
+  it('should format dates correctly', () => {
+    const value = new Date('2023-07-01T14:30:00');
+    const descriptor = { userInterface: UserInterface.DATE } as FieldDescriptor;
+    expect(getFormattedValue(value, descriptor)).toBe('01/07/2023');
+  });
+
+  it('should format times correctly', () => {
+    const value = new Date('2023-07-01T14:30:00');
+    const descriptor = { userInterface: UserInterface.TIME } as FieldDescriptor;
+    expect(getFormattedValue(value, descriptor)).toBe('14:30');
+  });
+
+  it('should format datetime correctly', () => {
+    const value = new Date('2023-07-01T14:30:00');
+    const descriptor = { userInterface: UserInterface.DATETIME } as FieldDescriptor;
+    expect(getFormattedValue(value, descriptor)).toBe('01/07/2023 14:30');
+  });
+
+  it('should call toString with correct parameters', () => {
+    const value = 123;
+    const descriptor = { dataType: DataType.NUMBER } as FieldDescriptor;
+    expect(getFormattedValue(value, descriptor)).toBe('123,00');
+  });
+
+  it('should handle undefined descriptor gracefully', () => {
+    const value = 123;
+    expect(getFormattedValue(value)).toBe('123');
+  });
+
+  it('should format value correctly with OPTIONSELECTOR and matching option', () => {
+    const value = 'option1';
+    const descriptor = buildOptionSelectorFieldDescriptor();
+    expect(getFormattedValue(value, descriptor)).toBe('option1');
+  });
+
+  it('should return value with OPTIONSELECTOR and no matching option', () => {
+    const value = 'option2';
+    const descriptor = buildOptionSelectorFieldDescriptor();
+    expect(getFormattedValue(value, descriptor)).toBe('option2');
+  });
+
+  it('should format value correctly with OPTIONSELECTOR and value as object', () => {
+    const value = { value: 'option1' };
+    const descriptor = buildOptionSelectorFieldDescriptor();
+    expect(getFormattedValue(value, descriptor)).toBe('option1');
+  });
+
+  it('should return empty string with OPTIONSELECTOR and value as null', () => {
+    const value = null;
+    const descriptor = buildOptionSelectorFieldDescriptor();
+    expect(getFormattedValue(value, descriptor)).toBe('');
+  });
+
+  it('should format value correctly with OPTIONSELECTOR and options as JSON string', () => {
+    const value = 'option1';
+    const descriptor: FieldDescriptor = {
+      userInterface: UserInterface.OPTIONSELECTOR,
+      properties: { options: JSON.stringify([{ label: 'Option 1', value: 'option1' }]) },
+    } as FieldDescriptor;
+    expect(getFormattedValue(value, descriptor)).toBe('option1');
+  });
+
+  it('should return value with OPTIONSELECTOR and options as empty array', () => {
+    const value = 'option1';
+    const descriptor: FieldDescriptor = {
+      userInterface: UserInterface.OPTIONSELECTOR,
+      properties: { options: [] },
+    } as FieldDescriptor;
+    expect(getFormattedValue(value, descriptor)).toBe('option1');
+  });
+
+  it('should format masked values correctly', () => {
+    const value = '12345678901';
+    const descriptor = { properties: { mask: 'cpf' } } as FieldDescriptor;
+    expect(getFormattedValue(value, descriptor)).toBe('123.456.789-01');
+  });
+});
+
+function buildOptionSelectorFieldDescriptor(): FieldDescriptor {
+  return {
+    userInterface: UserInterface.OPTIONSELECTOR,
+    properties: { options: [{ label: 'Option 1', value: 'option1' }] },
+  } as FieldDescriptor;
+}
+
+function getFileFieldDescriptor(): FieldDescriptor{
+  return { userInterface: UserInterface.FILE } as FieldDescriptor;
+}
+
+function getObjectFieldDescriptor(): FieldDescriptor{
+  return { dataType: DataType.OBJECT } as FieldDescriptor;
+}

package/test/dataunit/loader/dataUnitInMemoryLoader.spec.ts

@@ -0,0 +1,221 @@
+import { DataUnitInMemoryLoader } from '../../../src/dataunit/loader/dataUnitInMemoryLoader.js';
+import {
+  DataUnitInMemoryLoaderConfig,
+  RECORD_DATE_FORMAT,
+} from '../../../src/dataunit/loader/DataUnitInMemoryLoaderConfig.js';
+import { FieldDescriptor, UnitMetadata } from '../../../src/dataunit/metadata/UnitMetadata.js';
+import { DataType } from '../../../src/dataunit/metadata/DataType.js';
+import DateUtils from '../../../src/utils/DateUtils.js';
+import DataUnit, { Record } from '../../../src/dataunit/DataUnit.js';
+
+describe('DataUnitInMemoryLoader - loadData', () => {
+  const dataUnitMetetadata: UnitMetadata = {
+    name: 'test',
+    label: 'test',
+    fields: [],
+  };
+
+  it('should be called load data when auto load is true', async () => {
+    const config: DataUnitInMemoryLoaderConfig = {
+      autoLoad: true,
+    };
+    const inMemoryLoader = new DataUnitInMemoryLoader(dataUnitMetetadata, [], config);
+    const loadData = jest.spyOn(inMemoryLoader.dataUnit, 'loadData');
+    await inMemoryLoader.dataUnit.loadMetadata();
+    expect(loadData).toHaveBeenCalled();
+  });
+
+  it('should be called load data when auto load is undefined', async () => {
+    const config: DataUnitInMemoryLoaderConfig = {
+      autoLoad: undefined,
+    };
+    const inMemoryLoader = new DataUnitInMemoryLoader(dataUnitMetetadata, [], config);
+    const loadData = jest.spyOn(inMemoryLoader.dataUnit, 'loadData');
+    await inMemoryLoader.dataUnit.loadMetadata();
+    expect(loadData).toHaveBeenCalled();
+  });
+
+  it('should not be called load data when auto load is false', async () => {
+    const config: DataUnitInMemoryLoaderConfig = {
+      autoLoad: false,
+    };
+    const inMemoryLoader = new DataUnitInMemoryLoader(dataUnitMetetadata, [], config);
+    const loadData = jest.spyOn(inMemoryLoader.dataUnit, 'loadData');
+    await inMemoryLoader.dataUnit.loadMetadata();
+    expect(loadData).not.toHaveBeenCalled();
+  });
+
+  it('should be called load data when config is undefined', async () => {
+    const inMemoryLoader = new DataUnitInMemoryLoader(dataUnitMetetadata, []);
+    const loadData = jest.spyOn(inMemoryLoader.dataUnit, 'loadData');
+    await inMemoryLoader.dataUnit.loadMetadata();
+    expect(loadData).toHaveBeenCalled();
+  });
+});
+
+describe('DataUnitInMemoryLoader - getConvertedValue', () => {
+  let descriptor: FieldDescriptor;
+
+  beforeEach(() => {
+    descriptor = { name: 'testField', dataType: DataType.TEXT, label: 'mock' }; // Valor padrão para inicialização
+  });
+
+  it('should return the original string if descriptor is undefined', () => {
+    const result = DataUnitInMemoryLoader.getConvertedValue(undefined as any, 'testValue');
+    expect(result).toBe('testValue');
+  });
+
+  it('should return the original string if dataType is TEXT', () => {
+    descriptor.dataType = DataType.TEXT;
+    const result = DataUnitInMemoryLoader.getConvertedValue(descriptor, 'testValue');
+    expect(result).toBe('testValue');
+  });
+
+  it('should convert to boolean when dataType is BOOLEAN', () => {
+    descriptor.dataType = DataType.BOOLEAN;
+    expect(DataUnitInMemoryLoader.getConvertedValue(descriptor, 'S')).toBe(true);
+    expect(DataUnitInMemoryLoader.getConvertedValue(descriptor, 'N')).toBe(false);
+  });
+
+  it('should convert to number when dataType is NUMBER', () => {
+    descriptor.dataType = DataType.NUMBER;
+    expect(DataUnitInMemoryLoader.getConvertedValue(descriptor, '123')).toBe(123);
+    expect(DataUnitInMemoryLoader.getConvertedValue(descriptor, '45.67')).toBe(45.67);
+  });
+
+  it('should parse JSON when dataType is OBJECT', () => {
+    descriptor.dataType = DataType.OBJECT;
+    const jsonString = '{"key": "value"}';
+    const expectedObject = { key: 'value' };
+    expect(DataUnitInMemoryLoader.getConvertedValue(descriptor, jsonString)).toEqual(expectedObject);
+  });
+
+  it('should convert to date when dataType is DATE and format is ISO', () => {
+    descriptor.dataType = DataType.DATE;
+
+    const isoDate = '2023-01-01T00:00:00Z';
+    jest.spyOn(DateUtils, 'validateDate').mockImplementation((date) => date);
+
+    const result = DataUnitInMemoryLoader.getConvertedValue(descriptor, isoDate, RECORD_DATE_FORMAT.ISO);
+    expect(DateUtils.validateDate).toHaveBeenCalledWith(new Date(isoDate), true);
+    expect(result).toEqual(new Date(isoDate));
+  });
+
+  it('should convert to date when dataType is DATE and format is not ISO', () => {
+    descriptor.dataType = DataType.DATE;
+
+    const dateString = '01/01/2023';
+    jest.spyOn(DateUtils, 'strToDate').mockImplementation(() => new Date(2023, 0, 1));
+
+    const result = DataUnitInMemoryLoader.getConvertedValue(descriptor, dateString, RECORD_DATE_FORMAT.DD_MM_YYYY);
+    expect(DateUtils.strToDate).toHaveBeenCalledWith(dateString, true);
+    expect(result).toEqual(new Date(2023, 0, 1));
+  });
+
+  it('should return the original string if no dataType matches', () => {
+    descriptor.dataType = undefined as any; // Simula um caso inválido
+    const result = DataUnitInMemoryLoader.getConvertedValue(descriptor, 'testValue');
+    expect(result).toBe('testValue');
+  });
+});
+
+describe('DataUnitInMemoryLoader - removeLoader', () => {
+  let loader: DataUnitInMemoryLoader;
+  const mockedDataUnit = {} as DataUnit;
+
+  beforeEach(() => {
+    loader = new DataUnitInMemoryLoader();
+  });
+
+  it('should resolve with the provided record IDs', async () => {
+    const mockRecordIds = ['record1', 'record2', 'record3'];
+
+    const result = await loader.removeLoader(mockedDataUnit, mockRecordIds);
+
+    expect(result).toEqual(mockRecordIds);
+  });
+
+  it('should handle empty record ID array', async () => {
+    const mockRecordIds: string[] = [];
+
+    const result = await loader.removeLoader(mockedDataUnit, mockRecordIds);
+
+    expect(result).toEqual([]);
+  });
+
+  it('should resolve the promise', async () => {
+    const mockRecordIds = ['record1'];
+
+    await expect(loader.removeLoader(mockedDataUnit, mockRecordIds)).resolves.toEqual(mockRecordIds);
+  });
+});
+
+describe('DataUnitInMemoryLoader - buildInitialRecords (indiretamente via set records)', () => {
+  let loader: DataUnitInMemoryLoader;
+  let mockRecords: Array<Record> = [
+    { id: '1', amount: '100', isActive: 'S', createdAt: '01/01/2023' },
+    { id: '2', amount: '200.50', isActive: 'N', createdAt: '02/01/2023' },
+  ] as unknown as Record[];
+
+  let mockMetadata =  {
+    fields: [
+      { name: 'id', label: 'id', dataType: DataType.TEXT },
+      { name: 'amount', label: 'amount', dataType: DataType.NUMBER },
+      { name: 'isActive', label: 'isActive', dataType: DataType.BOOLEAN },
+      { name: 'createdAt', label: 'createdAt', dataType: DataType.DATE },
+    ],
+  };
+
+  beforeEach(() => {
+    loader = new DataUnitInMemoryLoader(mockMetadata as any, [], { recordDateFormat: RECORD_DATE_FORMAT.DD_MM_YYYY });
+  });
+
+  it('should build initial records and convert field values based on metadata', () => {
+    loader.records = mockRecords;
+    const initialRecords = loader['_initialRecords'];
+
+    expect(initialRecords).toHaveLength(2);
+
+    expect(initialRecords[0]).toEqual({
+      id: '1',
+      amount: 100,
+      isActive: true,
+      createdAt: expect.any(Date),
+      __record__id__: expect.any(String),
+    });
+
+    expect(initialRecords[1]).toEqual({
+      id: '2',
+      amount: 200.5,
+      isActive: false,
+      createdAt:  expect.any(Date),
+      __record__id__: expect.any(String),
+    });
+  });
+
+  it('should generate unique IDs for records without "__record__id__"', () => {
+    loader.records = [{ id: '3', amount: '300' }] as unknown as Record[];
+
+    const builtRecords = loader['_initialRecords'];
+    expect(builtRecords).toHaveLength(1);
+
+    expect(builtRecords[0]).toHaveProperty('__record__id__');
+    expect(typeof builtRecords[0]['__record__id__']).toBe('string');
+  });
+
+  it('should leave fields untouched if no matching metadata exists', () => {
+    mockRecords[0]['extraField'] = 'unchanged';
+    loader.records = mockRecords;
+
+    const builtRecords = loader['_initialRecords'];
+    expect(builtRecords[0]).toHaveProperty('extraField', 'unchanged');
+  });
+
+  it('should skip conversion for non-string field values', () => {
+    mockRecords[0].amount = 500;
+    loader.records = mockRecords;
+
+    const builtRecords = loader['_initialRecords'];
+    expect(builtRecords[0].amount).toBe(500);
+  });
+});