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

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

@@ -1,63 +1,287 @@
 import { StringUtils } from '../../src/utils/StringUtils';
+import {
+  isEmptyCases,
+  replaceAccentuatedCharsCases,
+  replaceAccentuatedCharsKeepSymbolsCases,
+  replaceBlankCharactersCases,
+  replaceToSpaceCases,
+  replaceAllCases,
+  removeSpecialCharactersCases,
+  isStringCases,
+  decodeHtmlEntitiesCases,
+  hashCodeCases,
+  getBooleanValueCases,
+  padStartCases,
+  padEndCases,
+  compareCases,
+  toCamelCaseCases,
+  toPascalCaseCases,
+  toSnakeCaseCases,
+  toKebabCaseCases,
+  formatBytesCases,
+  prettyPrecisionCases,
+  isCaseableCases,
+  isLowerCaseCases,
+  getOppositeCaseCases,
+  getSpecialCharactersCases,
+  getArgumentNumberCases,
+  highlightValueCases
+} from '../testCases/StringUtilsTestCases';
 
-describe('StringUtils', function () {
+describe('StringUtils', function() {
 
-  it('valor vazio', function () {
-    let result = StringUtils.isEmpty('');
-    expect(result).toBe(true);
+  describe('isEmpty', () => {
+    isEmptyCases.forEach(e => {
+      it(`should return ${e.valueOutput} when value is ${e.valueInput}`, () => {
+        expect(StringUtils.isEmpty(e.valueInput)).toBe(e.valueOutput);
+      });
+    });
   });
 
-  it('valor em branco', function () {
-    let result = StringUtils.isEmpty(' ');
-    expect(result).toBe(true);
+
+  describe('replaceAccentuatedChars', () => {
+
+    it('should return the original value when called with an object without a toString method', () => {
+      const objWithoutToString = { value: 'someValue' };
+      jest.spyOn(StringUtils, 'replaceAccentuatedChars');
+
+      StringUtils.replaceAccentuatedChars(objWithoutToString as any);
+      expect(StringUtils.replaceAccentuatedChars).toHaveBeenCalledWith(objWithoutToString as any);
+    });
+
+
+    it('should return the original value when called with undefined', () => {
+      const undefinedArg: any = undefined;
+      jest.spyOn(StringUtils, 'replaceAccentuatedChars');
+
+      StringUtils.replaceAccentuatedChars(undefinedArg);
+      expect(StringUtils.replaceAccentuatedChars).toHaveBeenCalledWith(undefinedArg);
+    });
+
+    replaceAccentuatedCharsCases.forEach(e => {
+      it(`should return ${e.valueOutput} when value is ${e.valueInput}`, () => {
+        expect(StringUtils.replaceAccentuatedChars(e.valueInput)).toBe(e.valueOutput);
+      });
+    });
+
+  });
+
+
+  describe('replaceAccentuatedCharsKeepSymbols', () => {
+    replaceAccentuatedCharsKeepSymbolsCases.forEach(e => {
+      it(`should return ${e.valueOutput} when value is ${e.valueInput}`, () => {
+        expect(StringUtils.replaceAccentuatedCharsKeepSymbols(e.valueInput)).toBe(e.valueOutput);
+      });
+    });
+  });
+
+
+  describe('replaceBlankCharacters', () => {
+    replaceBlankCharactersCases.forEach(e => {
+      it(`should return ${e.valueOutput} when value is ${e.valueInput}`, () => {
+        expect(StringUtils.replaceBlankCharacters(e.valueInput)).toBe(e.valueOutput);
+      });
+    });
+  });
+
+
+  describe('replaceToSpace', () => {
+    replaceToSpaceCases.forEach(e => {
+      it(`should return "${e.valueOutput}" when value is "${e.valueInput}" and replaceList is ${JSON.stringify(e.replaceList)}`, () => {
+        expect(StringUtils.replaceToSpace(e.valueInput, e.replaceList)).toBe(e.valueOutput);
+      });
+    });
+
+  });
+
+
+  describe('replaceAll', () => {
+    replaceAllCases.forEach(e => {
+      it(`should return "${e.valueOutput}" when value is "${e.valueInput}", strFrom is "${e.strFrom}", and strTo is "${e.strTo}"`, () => {
+        expect(StringUtils.replaceAll(e.valueInput, e.strFrom, e.strTo)).toBe(e.valueOutput);
+      });
+    });
+  });
+
+
+  describe('removeSpecialCharacters', () => {
+    removeSpecialCharactersCases.forEach(e => {
+      it(`should return "${e.valueOutput}" when value is "${e.valueInput}"`, () => {
+        expect(StringUtils.removeSpecialCharacters(e.valueInput)).toBe(e.valueOutput);
+      });
+    });
+  });
+
+
+  describe('isString', () => {
+    isStringCases.forEach(e => {
+      it(`should return ${e.valueOutput} when value is ${JSON.stringify(e.valueInput)}`, () => {
+        expect(StringUtils.isString(e.valueInput as any)).toBe(e.valueOutput);
+      });
+    });
+  });
+
+
+  describe('decodeHtmlEntities', () => {
+    decodeHtmlEntitiesCases.forEach(e => {
+      it(`should return "${e.valueOutput}" when value is "${e.valueInput}"`, () => {
+        expect(StringUtils.decodeHtmlEntities(e.valueInput as any)).toBe(e.valueOutput);
+      });
+    });
   });
 
-  it('valor null', function () {
-    let result = StringUtils.isEmpty(null);
-    expect(result).toBe(true);
+
+  describe('hashCode', () => {
+    hashCodeCases.forEach(e => {
+      it(`should return "${e.valueOutput}" when value is "${e.valueInput}"`, () => {
+        expect(StringUtils.hashCode(e.valueInput)).toBe(e.valueOutput);
+      });
+    });
+  });
+
+
+  describe('getBooleanValue', () => {
+    getBooleanValueCases.forEach(e => {
+      it(`should return ${e.valueOutput} when value is "${e.valueInput}" and defaultValue is ${e.defaultValue}`, () => {
+        expect(StringUtils.getBooleanValue(e.valueInput as any, e.defaultValue)).toBe(e.valueOutput);
+      });
+    });
+  });
+
+
+  describe('padStart', () => {
+    padStartCases.forEach(e => {
+      const { str, len, pad } = e.valueInput;
+      it(`should return "${e.valueOutput}" when str="${str}", len=${len}, pad="${pad}"`, () => {
+        expect(StringUtils.padStart(str as any, len, pad)).toBe(e.valueOutput);
+      });
+    });
+  });
+
+
+  describe('padEnd', () => {
+    padEndCases.forEach(e => {
+      const { str, len, pad } = e.valueInput;
+      it(`should return "${e.valueOutput}" when str="${str}", len=${len}, pad="${pad}"`, () => {
+        expect(StringUtils.padEnd(str as any, len, pad)).toBe(e.valueOutput);
+      });
+    });
+  });
+
+
+  describe('compare', () => {
+    compareCases.forEach(e => {
+      const { a, b } = e.valueInput;
+      it(`should return ${e.valueOutput} when a="${a}" and b="${b}"`, () => {
+        expect(StringUtils.compare(a as any, b as any)).toBe(e.valueOutput);
+      });
+    });
+  });
+
+
+  describe('toCamelCase', () => {
+    toCamelCaseCases.forEach(e => {
+      it(`should return "${e.valueOutput}" when value is "${e.valueInput}"`, () => {
+        expect(StringUtils.toCamelCase(e.valueInput as any)).toBe(e.valueOutput);
+      });
+    });
+  });
+
+
+  describe('toPascalCase', () => {
+    toPascalCaseCases.forEach(e => {
+      it(`should return "${e.valueOutput}" when value is "${e.valueInput}"`, () => {
+        expect(StringUtils.toPascalCase(e.valueInput as any)).toBe(e.valueOutput);
+      });
+    });
   });
 
-  it('valor undefined', function () {
-    let result = StringUtils.isEmpty(undefined);
-    expect(result).toBe(true);
+
+  describe('toSnakeCase', () => {
+    toSnakeCaseCases.forEach(e => {
+      it(`should return "${e.valueOutput}" when value is "${e.valueInput}"`, () => {
+        expect(StringUtils.toSnakeCase(e.valueInput as any)).toBe(e.valueOutput);
+      });
+    });
   });
 
-  it('valor 0', function () {
-    let result = StringUtils.isEmpty('0');
-    expect(result).toBe(false);
+
+  describe('toKebabCase', () => {
+    toKebabCaseCases.forEach(e => {
+      it(`should return "${e.valueOutput}" when value is "${e.valueInput}"`, () => {
+        expect(StringUtils.toKebabCase(e.valueInput as any)).toBe(e.valueOutput);
+      });
+    });
   });
 
-  it('com valor', function () {
-    let result = StringUtils.isEmpty('ab');
-    expect(result).toBe(false);
+
+  describe('formatBytes', () => {
+    formatBytesCases.forEach(e => {
+      it(`should return "${e.valueOutput}" when value is ${e.valueInput}`, () => {
+        expect(StringUtils.formatBytes(e.valueInput as any)).toBe(e.valueOutput);
+      });
+    });
   });
 
-  it('substitui vogais com acento por vogais sem acento', function () {
 
-    let resultadoInputMaiusculo = StringUtils.replaceAccentuatedChars('ÁÀÂÃÄ');
-    expect(resultadoInputMaiusculo).toBe('AAAAA');
+  describe('prettyPrecision', () => {
+    prettyPrecisionCases.forEach(e => {
+      it(`should return "${e.valueOutput}" when value is "${e.valueInput}"`, () => {
+        expect(StringUtils['prettyPrecision'](e.valueInput as any)).toBe(e.valueOutput);
+      });
+    });
+  });
+
+
+  describe('isCaseable', () => {
+    isCaseableCases.forEach(e => {
+      it(`should return ${e.valueOutput} when value is "${e.valueInput}"`, () => {
+        expect(StringUtils.isCaseable(e.valueInput as any)).toBe(e.valueOutput);
+      });
+    });
+  });
+
+  describe('isLowerCase', () => {
+    isLowerCaseCases.forEach(e => {
+      it(`should return ${e.valueOutput} when value is "${e.valueInput}"`, () => {
+        expect(StringUtils.isLowerCase(e.valueInput as any)).toBe(e.valueOutput);
+      });
+    });
+  });
+
+  describe('getOppositeCase', () => {
+    getOppositeCaseCases.forEach(e => {
+      it(`should return "${e.valueOutput}" when value is "${e.valueInput}"`, () => {
+        expect(StringUtils.getOppositeCase(e.valueInput as any)).toBe(e.valueOutput);
+      });
+    });
+  });
 
-    let resultInputMinusculo = StringUtils.replaceAccentuatedChars('áàâãä');
-    expect(resultInputMinusculo).toBe('aaaaa');
 
-    let resultInputCedilhaMaiusculo = StringUtils.replaceAccentuatedChars('Ç');
-    expect(resultInputCedilhaMaiusculo).toBe('C');
+  describe('getSpecialCharacters', () => {
+    getSpecialCharactersCases.forEach(e => {
+      it(`should return ${JSON.stringify(e.valueOutput)} when value is "${e.valueInput}"`, () => {
+        expect(StringUtils.getSpecialCharacters(e.valueInput as any)).toEqual(e.valueOutput);
+      });
+    });
   });
 
-  it('should return the original value when called with an object without a toString method', () => {
-    const objWithoutToString = { value: 'someValue' };
-    jest.spyOn(StringUtils, 'replaceAccentuatedCharsUpper');
 
-    StringUtils.replaceAccentuatedCharsUpper(objWithoutToString as any);
-    expect(StringUtils.replaceAccentuatedCharsUpper).toHaveBeenCalledWith(objWithoutToString as any);
+  describe('getArgumentNumber', () => {
+    getArgumentNumberCases.forEach(e => {
+      it(`should return ${e.valueOutput} when value is "${e.valueInput}"`, () => {
+        expect(StringUtils.getArgumentNumber(e.valueInput as any)).toBe(e.valueOutput);
+      });
+    });
   });
 
-  it('should return the original value when called with undefined', () => {
-    const undefinedArg: any = undefined;
-    jest.spyOn(StringUtils, 'replaceAccentuatedCharsUpper');
 
-    StringUtils.replaceAccentuatedCharsUpper(undefinedArg);
-    expect(StringUtils.replaceAccentuatedCharsUpper).toHaveBeenCalledWith(undefinedArg);
+  describe('highlightValue', () => {
+    highlightValueCases.forEach(e => {
+      it(`should return "${e.valueOutput}" when value is "${e.valueInput.value}" and argument is "${e.valueInput.argument}"`, () => {
+        expect(StringUtils.highlightValue(e.valueInput.argument as any, e.valueInput.matchFields, e.valueInput.value, e.valueInput.fieldMD, e.valueInput.forceMatch)).toBe(e.valueOutput);
+      });
+    });
   });
 
 });

package/test/util/TimeFormatter.spec.ts

@@ -1,26 +1,73 @@
 import { TimeFormatter } from '../../src/utils/TimeFormatter';
+import { validateTimeTestCases } from '../testCases/TimeFormatterTestUtils';
 
-describe('TimeFormatter', function () {
-    it("Case: input string unformated with showSeconds", function () {
-        let value = TimeFormatter.prepareValue("1110", false);
-        expect(value).toEqual("11:10");
+
+describe('TimeFormatter', () => {
+
+  describe('prepareValue', () => {
+
+    test('Case: input string unformated with showSeconds', () => {
+      let value = TimeFormatter.prepareValue('1110', false);
+      expect(value).toEqual('11:10');
+    });
+
+    test('Case: input string unformated without showSeconds', () => {
+      let value = TimeFormatter.prepareValue('1110', true);
+      expect(value).toEqual('00:11:10');
     });
 
-    it("Case: input string unformated without showSeconds", function () {
-        let value = TimeFormatter.prepareValue("1110", true);
-        expect(value).toEqual("00:11:10");
+    test('should format valid time without seconds', () => {
+      expect(TimeFormatter.prepareValue('1012', false)).toBe('10:12');
+      expect(TimeFormatter.prepareValue('12', false)).toBe('00:12');
+      expect(TimeFormatter.prepareValue('59', false)).toBe('00:59');
     });
 
-    
-    it("Case: validateTime", function () {
-        let isValid = TimeFormatter.validateTime("2525", false);
-        expect(isValid).toEqual(false);
-        isValid = TimeFormatter.validateTime("2525", true);
-        expect(isValid).toEqual(false);
-        isValid = TimeFormatter.validateTime("232920", true);
-        expect(isValid).toEqual(true);
-        isValid = TimeFormatter.validateTime("232920", false);
-        expect(isValid).toEqual(true);
+    test('should format valid time with seconds', () => {
+      expect(TimeFormatter.prepareValue('101200', true)).toBe('10:12:00');
+      expect(TimeFormatter.prepareValue('12', true)).toBe('00:00:12');
+      expect(TimeFormatter.prepareValue('1', true)).toBe('00:00:01');
     });
-    
+
+    test('should pad input with leading zeros for proper format', () => {
+      expect(TimeFormatter.prepareValue('1', false)).toBe('00:01');
+      expect(TimeFormatter.prepareValue('123', false)).toBe('01:23');
+      expect(TimeFormatter.prepareValue('12345', true)).toBe('01:23:45');
+    });
+
+    test('should return an empty string for invalid input', () => {
+      expect(TimeFormatter.prepareValue('', false)).toBe('');
+      expect(TimeFormatter.prepareValue(null as any, false)).toBe('');
+      expect(TimeFormatter.prepareValue(undefined as any, false)).toBe('');
+    });
+
+    test('should throw error when recieveng string', () => {
+      expect(() => {
+        TimeFormatter.prepareValue("abcd", false)
+      }).toThrow(Error);
+    })
+
+    test('should handle edge cases correctly', () => {
+      expect(TimeFormatter.prepareValue('0000', false)).toBe('00:00');
+      expect(TimeFormatter.prepareValue('2359', false)).toBe('23:59');
+      expect(TimeFormatter.prepareValue('000000', true)).toBe('00:00:00');
+      expect(TimeFormatter.prepareValue('235959', true)).toBe('23:59:59');
+    });
+
+    test('should format partially filled times correctly', () => {
+      expect(TimeFormatter.prepareValue('1', true)).toBe('00:00:01');
+      expect(TimeFormatter.prepareValue('123', true)).toBe('00:01:23');
+      expect(TimeFormatter.prepareValue('12', true)).toBe('00:00:12');
+    });
+
+  });
+
+
+  describe('validateTime', () => {
+    validateTimeTestCases.forEach(e => {
+      it(`should be ${e.expected} when [ value: ${e.value}, showSeconds: ${e.showSeconds}`, () => {
+        expect(TimeFormatter.validateTime(e.value, e.showSeconds)).toBe(e.expected);
+      });
+    });
+  });
+
 });