@sankhyalabs/core 5.20.0-dev.4 → 5.20.0-dev.40

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/util/ElementUtils.spec.ts

@@ -0,0 +1,34 @@
+import { calcMarginSize } from '../../src/utils/ElementUtils';
+import { OverflowDirection } from '../../src';
+
+describe('calcMarginSize', () => {
+  it('should calculate correctly the size of horizontal margin', () => {
+    const element = document.createElement('div');
+    element.style.marginLeft = '10px';
+    element.style.marginRight = '15px';
+    document.body.appendChild(element);
+
+    const size = calcMarginSize(element, OverflowDirection.HORIZONTAL);
+    expect(size).toBe(25);
+  });
+
+  it('should calculate correctly the size of vertical margin', () => {
+    const element = document.createElement('div');
+    element.style.marginTop = '5px';
+    element.style.marginBottom = '20px';
+    document.body.appendChild(element);
+
+    const size = calcMarginSize(element, OverflowDirection.VERTICAL);
+    expect(size).toBe(25);
+  });
+
+  it('should threat values defined as zero', () => {
+    const element = document.createElement('div');
+    document.body.appendChild(element);
+
+    const horizontalSize = calcMarginSize(element, OverflowDirection.HORIZONTAL);
+    const verticalSize = calcMarginSize(element, OverflowDirection.VERTICAL);
+    expect(horizontalSize).toBe(0);
+    expect(verticalSize).toBe(0);
+  });
+});

package/test/util/OverflowWatcher.spec.ts

@@ -0,0 +1,152 @@
+import OverflowWatcher, { OverFlowWatcherParams, OverflowDirection, OVERFLOWED_CLASS_NAME } from '../../src/utils/OverflowWatcher';
+
+describe('OverflowWatcher', () => {
+  let mockElement: HTMLElement;
+  let mockCallback: jest.Mock;
+  let watcherInstance: OverflowWatcher;
+
+  beforeEach(() => {
+    mockElement = document.createElement('div');
+    Object.defineProperty(mockElement, 'clientWidth', { value: 90, configurable: true });
+    document.body.appendChild(mockElement);
+    mockCallback = jest.fn();
+
+    const params: OverFlowWatcherParams = {
+      element: mockElement,
+      callback: mockCallback,
+      overFlowDirection: OverflowDirection.HORIZONTAL,
+      debounce: 1,
+      deltaSize: 1,
+      notOverFlow: ['testId'],
+    };
+
+    watcherInstance = new OverflowWatcher(params);
+    mockElement.getBoundingClientRect = jest.fn().mockReturnValue(getMockedRectClientValue(200));
+    setPrivateField(watcherInstance, '_lastContainerSize', 100);
+    setPrivateField(watcherInstance, '_lastContainerInstance', mockElement);
+  });
+
+  afterEach(() => {
+    watcherInstance.destroy();
+  });
+
+  it('should initialize with provided parameters', () => {
+    expect(watcherInstance).toBeDefined();
+  });
+
+  it('should disconect  ResizeObserver when destroy is called', () => {
+    const disconnectSpy = jest.spyOn(ResizeObserver.prototype, 'disconnect');
+    watcherInstance.destroy();
+    expect(disconnectSpy).toHaveBeenCalled();
+  });
+
+  it('Should call callback on forceUpdate', () => {
+    appendMockedChildren(mockElement);
+    watcherInstance.forceUpdate();
+    expect(mockCallback).toHaveBeenCalled();
+  });
+
+  it('Should call callback on forceUpdate with childSpan', () => {
+    appendMockedChildren(mockElement);
+    watcherInstance.forceUpdate();
+
+    const childSpan = mockElement.children[1];
+    expect(mockCallback).toHaveBeenCalledWith(expect.arrayContaining([childSpan]));
+  });
+
+  it('Should call callback on forceUpdate with childSpan when notOverFlow is empty', () => {
+    appendMockedChildren(mockElement);
+
+    const params: OverFlowWatcherParams = {
+      element: mockElement,
+      callback: mockCallback,
+      overFlowDirection: OverflowDirection.HORIZONTAL,
+      debounce: 1,
+      deltaSize: 1,
+    };
+
+    const withNoOverFlow = new OverflowWatcher(params);
+    setPrivateField(withNoOverFlow, '_lastContainerSize', 100);
+    setPrivateField(withNoOverFlow, '_lastContainerInstance', mockElement);
+
+    withNoOverFlow.forceUpdate();
+
+    const childSpan = mockElement.children[1];
+    expect(mockCallback).toHaveBeenCalledWith(expect.arrayContaining([childSpan]));
+  });
+
+  it('Should call callback on forceUpdate with childSpan considering overflowed elements', () => {
+    appendMockedChildren(mockElement);
+    const childButton = mockElement.children[0];
+    const childSpan = mockElement.children[1];
+    childSpan.classList.add(OVERFLOWED_CLASS_NAME);
+
+    const hiddemItemsMock: Map<Element, {size: number, margin: number}> = new Map();
+    hiddemItemsMock.set(childSpan, {size: 50, margin: 0});
+    hiddemItemsMock.set(childButton, {size: 0, margin: 50});
+    setPrivateField(watcherInstance, '_hiddenItemsProps', hiddemItemsMock);
+
+    watcherInstance.forceUpdate();
+
+    expect(mockCallback).toHaveBeenCalledWith(expect.arrayContaining([childSpan]));
+  });
+
+  it('Should call callback on forceUpdate with empty list', () => {
+    appendMockedChildren(mockElement);
+    setPrivateField(watcherInstance, '_lastContainerSize', 200);
+    watcherInstance.forceUpdate();
+    const childButton =  mockElement.children[0];
+    const childSpan = mockElement.children[1];
+
+    expect(mockCallback).not.toHaveBeenCalledWith(expect.arrayContaining([childButton, childSpan]));
+  });
+
+  it('should ignore elements that can not overflow', () => {
+    appendMockedChildren(mockElement);
+
+    const notOverflowElement = document.createElement('div');
+    notOverflowElement.setAttribute('data-element-id', 'testId') ;
+    notOverflowElement.getBoundingClientRect = jest.fn().mockReturnValue(getMockedRectClientValue(50));
+
+    const notOverflowElement2 = document.createElement('div');
+    notOverflowElement2.setAttribute('data-element-id', 'testId2') ;
+    notOverflowElement2.getBoundingClientRect = jest.fn().mockReturnValue(getMockedRectClientValue(50));
+
+    mockElement.appendChild(notOverflowElement);
+    mockElement.appendChild(notOverflowElement2);
+
+    watcherInstance.addNotOverFlowElement('testId');
+    watcherInstance.addNotOverFlowElement('testId2');
+
+    watcherInstance.forceUpdate();
+
+    expect(mockCallback).not.toHaveBeenCalledWith(expect.arrayContaining([notOverflowElement]));
+  });
+
+  it('Should not call callback on forceUpdate', () => {
+    watcherInstance.forceUpdate();
+    expect(mockCallback).not.toHaveBeenCalled();
+  });
+
+});
+
+function appendMockedChildren(mockElement: HTMLElement) {
+  const chilldButton = document.createElement('button');
+  const childSpan = document.createElement('span');
+
+  chilldButton.getBoundingClientRect = jest.fn().mockReturnValue(getMockedRectClientValue(50));
+  childSpan.getBoundingClientRect = jest.fn().mockReturnValue(getMockedRectClientValue(50));
+
+  mockElement.appendChild(chilldButton);
+  mockElement.appendChild(childSpan);
+}
+
+function getMockedRectClientValue(size: number) {
+  return {
+    x: 0, y: 0, width: size, height: 10, top: 0, right: 0, bottom: 0, left: 0, toJSON: () => {}
+  };
+}
+
+function setPrivateField<T>(instance: T, fieldName: string, value: any): void {
+  (instance as any)[fieldName] = value;
+}

package/.docs/.nojekyll

@@ -1 +0,0 @@
-TypeDoc added this file to prevent GitHub Pages from using Jekyll. You can turn off this behavior by setting the `githubPages` option to false.

package/.docs/enums/Action.md

@@ -1,305 +0,0 @@
-[@sankhyalabs/core](../README.md) / [Exports](../modules.md) / Action
-
-# Enumeration: Action
-
-## Table of contents
-
-### Enumeration Members
-
-- [CHANGE\_REDONE](Action.md#change_redone)
-- [CHANGE\_UNDONE](Action.md#change_undone)
-- [CHANGING\_DATA](Action.md#changing_data)
-- [CHILD\_CHANGED](Action.md#child_changed)
-- [DATA\_CHANGED](Action.md#data_changed)
-- [DATA\_LOADED](Action.md#data_loaded)
-- [DATA\_RESOLVED](Action.md#data_resolved)
-- [DATA\_SAVED](Action.md#data_saved)
-- [EDITION\_CANCELED](Action.md#edition_canceled)
-- [FIELD\_INVALIDATED](Action.md#field_invalidated)
-- [INVALIDATE\_CLEAN](Action.md#invalidate_clean)
-- [LOADING\_DATA](Action.md#loading_data)
-- [LOADING\_METADATA](Action.md#loading_metadata)
-- [LOADING\_RECORD](Action.md#loading_record)
-- [METADATA\_LOADED](Action.md#metadata_loaded)
-- [NEXT\_SELECTED](Action.md#next_selected)
-- [PAGINATION\_UPDATED](Action.md#pagination_updated)
-- [PREVIOUS\_SELECTED](Action.md#previous_selected)
-- [RECORDS\_ADDED](Action.md#records_added)
-- [RECORDS\_COPIED](Action.md#records_copied)
-- [RECORDS\_REMOVED](Action.md#records_removed)
-- [RECORD\_LOADED](Action.md#record_loaded)
-- [REMOVING\_RECORDS](Action.md#removing_records)
-- [SAVING\_DATA](Action.md#saving_data)
-- [SELECTION\_CHANGED](Action.md#selection_changed)
-- [STATE\_CHANGED](Action.md#state_changed)
-- [WAITING\_CHANGE\_CANCELED](Action.md#waiting_change_canceled)
-
-## Enumeration Members
-
-### CHANGE\_REDONE
-
-• **CHANGE\_REDONE** = ``"changeRedone"``
-
-#### Defined in
-
-src/dataunit/state/action/DataUnitAction.ts:52
-
-___
-
-### CHANGE\_UNDONE
-
-• **CHANGE\_UNDONE** = ``"changeUndone"``
-
-#### Defined in
-
-src/dataunit/state/action/DataUnitAction.ts:51
-
-___
-
-### CHANGING\_DATA
-
-• **CHANGING\_DATA** = ``"changingData"``
-
-#### Defined in
-
-src/dataunit/state/action/DataUnitAction.ts:45
-
-___
-
-### CHILD\_CHANGED
-
-• **CHILD\_CHANGED** = ``"childChanged"``
-
-#### Defined in
-
-src/dataunit/state/action/DataUnitAction.ts:63
-
-___
-
-### DATA\_CHANGED
-
-• **DATA\_CHANGED** = ``"dataChanged"``
-
-#### Defined in
-
-src/dataunit/state/action/DataUnitAction.ts:47
-
-___
-
-### DATA\_LOADED
-
-• **DATA\_LOADED** = ``"dataLoaded"``
-
-#### Defined in
-
-src/dataunit/state/action/DataUnitAction.ts:33
-
-___
-
-### DATA\_RESOLVED
-
-• **DATA\_RESOLVED** = ``"dataResolved"``
-
-#### Defined in
-
-src/dataunit/state/action/DataUnitAction.ts:48
-
-___
-
-### DATA\_SAVED
-
-• **DATA\_SAVED** = ``"dataSaved"``
-
-#### Defined in
-
-src/dataunit/state/action/DataUnitAction.ts:37
-
-___
-
-### EDITION\_CANCELED
-
-• **EDITION\_CANCELED** = ``"editionCanceled"``
-
-#### Defined in
-
-src/dataunit/state/action/DataUnitAction.ts:50
-
-___
-
-### FIELD\_INVALIDATED
-
-• **FIELD\_INVALIDATED** = ``"fieldInvalidated"``
-
-#### Defined in
-
-src/dataunit/state/action/DataUnitAction.ts:65
-
-___
-
-### INVALIDATE\_CLEAN
-
-• **INVALIDATE\_CLEAN** = ``"invalidateClean"``
-
-#### Defined in
-
-src/dataunit/state/action/DataUnitAction.ts:66
-
-___
-
-### LOADING\_DATA
-
-• **LOADING\_DATA** = ``"loadingData"``
-
-#### Defined in
-
-src/dataunit/state/action/DataUnitAction.ts:32
-
-___
-
-### LOADING\_METADATA
-
-• **LOADING\_METADATA** = ``"loadingMetadata"``
-
-#### Defined in
-
-src/dataunit/state/action/DataUnitAction.ts:29
-
-___
-
-### LOADING\_RECORD
-
-• **LOADING\_RECORD** = ``"loadingRecord"``
-
-#### Defined in
-
-src/dataunit/state/action/DataUnitAction.ts:60
-
-___
-
-### METADATA\_LOADED
-
-• **METADATA\_LOADED** = ``"metadataLoaded"``
-
-#### Defined in
-
-src/dataunit/state/action/DataUnitAction.ts:30
-
-___
-
-### NEXT\_SELECTED
-
-• **NEXT\_SELECTED** = ``"nextSelected"``
-
-#### Defined in
-
-src/dataunit/state/action/DataUnitAction.ts:55
-
-___
-
-### PAGINATION\_UPDATED
-
-• **PAGINATION\_UPDATED** = ``"paginationUpdated"``
-
-#### Defined in
-
-src/dataunit/state/action/DataUnitAction.ts:34
-
-___
-
-### PREVIOUS\_SELECTED
-
-• **PREVIOUS\_SELECTED** = ``"previousSelected"``
-
-#### Defined in
-
-src/dataunit/state/action/DataUnitAction.ts:56
-
-___
-
-### RECORDS\_ADDED
-
-• **RECORDS\_ADDED** = ``"recordsAdded"``
-
-#### Defined in
-
-src/dataunit/state/action/DataUnitAction.ts:42
-
-___
-
-### RECORDS\_COPIED
-
-• **RECORDS\_COPIED** = ``"recordsCopied"``
-
-#### Defined in
-
-src/dataunit/state/action/DataUnitAction.ts:43
-
-___
-
-### RECORDS\_REMOVED
-
-• **RECORDS\_REMOVED** = ``"recordsRemoved"``
-
-#### Defined in
-
-src/dataunit/state/action/DataUnitAction.ts:40
-
-___
-
-### RECORD\_LOADED
-
-• **RECORD\_LOADED** = ``"recordLoaded"``
-
-#### Defined in
-
-src/dataunit/state/action/DataUnitAction.ts:61
-
-___
-
-### REMOVING\_RECORDS
-
-• **REMOVING\_RECORDS** = ``"removingRecords"``
-
-#### Defined in
-
-src/dataunit/state/action/DataUnitAction.ts:39
-
-___
-
-### SAVING\_DATA
-
-• **SAVING\_DATA** = ``"savingData"``
-
-#### Defined in
-
-src/dataunit/state/action/DataUnitAction.ts:36
-
-___
-
-### SELECTION\_CHANGED
-
-• **SELECTION\_CHANGED** = ``"selectionChanged"``
-
-#### Defined in
-
-src/dataunit/state/action/DataUnitAction.ts:54
-
-___
-
-### STATE\_CHANGED
-
-• **STATE\_CHANGED** = ``"stateChanged"``
-
-#### Defined in
-
-src/dataunit/state/action/DataUnitAction.ts:58
-
-___
-
-### WAITING\_CHANGE\_CANCELED
-
-• **WAITING\_CHANGE\_CANCELED** = ``"waitingChangeCanceled"``
-
-#### Defined in
-
-src/dataunit/state/action/DataUnitAction.ts:46