@sankhyalabs/core 0.0.0-bugfix-dev-KB-6165.0

package/test/util/MaskFormatter.spec.ts

@@ -0,0 +1,138 @@
+import { MaskFormatter } from '../../src/utils/MaskFormatter';
+
+describe('Mask Formatter', () => {
+
+  //CPF--------------------------------------
+  it('mask:CPF complete valid', async () => {
+    const mf: MaskFormatter = new MaskFormatter("###.###.###-##");
+    expect(mf.format("12345678901")).toEqual("123.456.789-01");
+  });
+
+  it('mask:CPF complete valid literals', async () => {
+    const mf: MaskFormatter = new MaskFormatter("###.###.###-##");
+    expect(mf.format("123.456.789-01")).toEqual("123.456.789-01");
+  });
+
+  it('mask:CPF incomplete valid', async () => {
+    const mf: MaskFormatter = new MaskFormatter("###.###.###-##");
+    expect(mf.format("123456")).toEqual("123.456.   -  ");
+  });
+
+  it('mask:CPF incomplete valid placeholder', async () => {
+    const mf: MaskFormatter = new MaskFormatter("###.###.###-##");
+    mf.placeholder = "_";
+    expect(mf.format("123456")).toEqual("123.456.___-__");
+  });
+
+  it('mask:CPF too long valid', async () => {
+    const mf: MaskFormatter = new MaskFormatter("###.###.###-##");
+    expect(mf.format("012345678901")).toEqual("012.345.678-90");
+  });
+
+  it('mask:CPF invalid for string', async () => {
+    const mf: MaskFormatter = new MaskFormatter("###.###.###-##");
+    expect(() => { mf.format("aaaaaaaaaaa"); }).toThrowError();
+  });
+
+  it('mask:CPF invalid for being too long', async () => {
+    const mf: MaskFormatter = new MaskFormatter("###.###.###-##");
+    expect(mf.format("10018297609")).toEqual("100.182.976-09");
+  });
+
+
+
+  //Car's Licence plate
+  it('mask:Licence plate valid uppercase', async () => {
+    const mf: MaskFormatter = new MaskFormatter("UUU-####");
+    expect(mf.format("zzz1234")).toEqual("ZZZ-1234");
+  });
+
+  it('mask:Licence plate valid lowercase', async () => {
+    const mf: MaskFormatter = new MaskFormatter("LLL-####");
+    expect(mf.format("ABC1234")).toEqual("abc-1234");
+  });
+
+  it('mask:Licence plate invalid', async () => {
+    const mf: MaskFormatter = new MaskFormatter("UUU-####");
+    expect(() => { mf.format("ABCD1234"); }).toThrowError();
+  });
+
+  it('mask:Licence plate invalid for being too short', async () => {
+    const mf: MaskFormatter = new MaskFormatter("UUU-####");
+    expect(mf.format("ABC123")).toEqual("ABC-123 ");
+  });
+
+
+  it('mask:Licence plate invalid for being too short with placeholder', async () => {
+    const mf: MaskFormatter = new MaskFormatter("UUU-####");
+    mf.placeholder = "_";
+    expect(mf.format("ABC123")).toEqual("ABC-123_");
+  });
+
+
+  it('mask:Licence plate invalid', async () => {
+    const mf: MaskFormatter = new MaskFormatter("UUU-####");
+    expect(() => { mf.format("1111111"); }).toThrowError();
+  });
+
+
+  //Alphanumerical Value
+  it('mask:Licence plate with AlphaNumerical Mask', async () => {
+    const mf: MaskFormatter = new MaskFormatter("AAA-####");
+    expect(mf.format("ABC123")).toEqual("ABC-123 ");
+  });
+
+
+  it('mask:Licence plate with AlphaNumerical Mask with placeholder', async () => {
+    const mf: MaskFormatter = new MaskFormatter("AAA-####");
+    mf.placeholder = "_";
+    expect(mf.format("ABC123")).toEqual("ABC-123_");
+  });
+
+  it('mask:Licence plate invalid', async () => {
+    const mf: MaskFormatter = new MaskFormatter("AAA-####");
+    expect(() => { mf.format("#3"); }).toThrowError();
+  });
+
+
+  //Character Value
+  it('mask:Licence plate with AlphaNumerical Mask', async () => {
+    const mf: MaskFormatter = new MaskFormatter("???-####");
+    expect(mf.format("ABC123")).toEqual("ABC-123 ");
+  });
+
+
+  it('mask:Licence plate with AlphaNumerical Mask with placeholder', async () => {
+    const mf: MaskFormatter = new MaskFormatter("???-####");
+    mf.placeholder = "_";
+    expect(mf.format("ABC123")).toEqual("ABC-123_");
+  });
+
+
+  it('mask:Licence plate invalid', async () => {
+    const mf: MaskFormatter = new MaskFormatter("???-####");
+    expect(() => { mf.format("111DDD"); }).toThrowError();
+  });
+
+
+
+  //Anything Value
+  it('mask:Licence plate with AlphaNumerical Mask', async () => {
+    const mf: MaskFormatter = new MaskFormatter("***-####");
+    expect(mf.format("ABC123")).toEqual("ABC-123 ");
+  });
+
+
+  it('mask:Licence plate with AlphaNumerical Mask with placeholder', async () => {
+    const mf: MaskFormatter = new MaskFormatter("***-####");
+    mf.placeholder = "_";
+    expect(mf.format("ABC123")).toEqual("ABC-123_");
+  });
+
+  it('mask:Licence plate invalid', async () => {
+    const mf: MaskFormatter = new MaskFormatter("***-####");
+    expect(() => { mf.format("111DDD"); }).toThrowError();
+  });
+
+
+});

package/test/util/NumberUtils.spec.ts

@@ -0,0 +1,182 @@
+import { NumberUtils } from '../../src/utils/NumberUtils';
+
+describe('StringUtils', function () {
+
+
+  // => STRING_TO_NUMBER
+  // ----------------------------------------------------------------------------------------
+
+  const arrayDataTest = [
+    { 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 },
+  ]
+
+  it('stringToNumber', function () {
+    let result: number;
+    arrayDataTest.forEach(e => {
+      result = NumberUtils.stringToNumber(e.valueInput);
+      expect(result).toBe(e.valueOutput);
+    })
+  });
+
+
+
+
+  // FORMAT
+  // ----------------------------------------------------------------------------------------
+
+
+  const casesStrValue = [
+
+    { 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' },
+
+
+  ];
+
+
+  it('format', function () {
+    let result: string = '';
+    casesStrValue.forEach(e => {
+      result = NumberUtils.format(e.strvalue, e.precision, e.prettyprecision);
+      expect(result).toBe(e.strvalueOutPut);
+    })
+
+  });
+
+
+
+
+  // keepOnlyDecimalSeparator
+  // ----------------------------------------------------------------------------------------
+  const testCasesTo_changeFormat = [
+
+    { 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' },
+
+  ]
+
+  it('format without formatnumber parameter', function () {
+    let result: string = '';
+    testCasesTo_changeFormat.forEach(e => {
+      result = NumberUtils.changeFormat(e.inputValue);
+      expect(result).toBe(e.outPutValue);
+    })
+
+  });
+
+
+  // keepOnlyDecimalSeparator
+  // ----------------------------------------------------------------------------------------
+  const testCasesTo_keepOnlyDecimalSeparator = [
+
+    { 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' },
+
+
+  ]
+
+  it('format without formatnumber parameter', function () {
+    let result: string = '';
+    testCasesTo_keepOnlyDecimalSeparator.forEach(e => {
+      result = NumberUtils.keepOnlyDecimalSeparator(e.inputValue, e.formatnumber);
+      expect(result).toBe(e.outPutValue);
+    })
+
+  });
+  
+
+  const testCasesTo_round = [
+    { 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 },
+  ]
+
+  it('format round number', function () {
+    let result: number;
+    testCasesTo_round.forEach(e => {
+      result = NumberUtils.round(e.inputValue, e.decimal);
+      expect(result).toBe(e.outPutValue);
+    })
+  });
+
+});

package/test/util/StringUtils.spec.ts

@@ -0,0 +1,51 @@
+import { StringUtils } from '../../src/utils/StringUtils';
+
+describe('StringUtils', function () {
+
+  it('valor vazio', function () {
+    let result = StringUtils.isEmpty('');
+    expect(result).toBe(true);
+  });
+
+  it('valor em branco', function () {
+    let result = StringUtils.isEmpty(' ');
+    expect(result).toBe(true);
+  });
+
+  it('valor null', function () {
+    let result = StringUtils.isEmpty(null);
+    expect(result).toBe(true);
+  });
+
+  it('valor undefined', function () {
+    let result = StringUtils.isEmpty(undefined);
+    expect(result).toBe(true);
+  });
+
+  it('valor 0', function () {
+    let result = StringUtils.isEmpty('0');
+    expect(result).toBe(false);
+  });
+
+  it('com valor', function () {
+    let result = StringUtils.isEmpty('ab');
+    expect(result).toBe(false);
+  });
+
+  it('substitui vogais com acento por vogais sem acento', function () {
+    
+    let resultadoInputMaiusculo = StringUtils.replaceAccentuatedChars('ÁÀÂÃÄ');
+    expect(resultadoInputMaiusculo).toBe('AAAAA');
+    
+    let resultInputMinusculo = StringUtils.replaceAccentuatedChars('áàâãä');
+    expect(resultInputMinusculo).toBe('aaaaa');
+    
+    let resultInputCedilhaMaiusculo = StringUtils.replaceAccentuatedChars('Ç');
+    expect(resultInputCedilhaMaiusculo).toBe('C');
+    
+    let resultInputCedilhaMinusculo = StringUtils.replaceAccentuatedChars('ç');
+    expect(resultInputCedilhaMinusculo).toBe('c');
+  
+  });
+
+});

package/test/util/TimeFormatter.spec.ts

@@ -0,0 +1,26 @@
+import { TimeFormatter } from '../../src/utils/TimeFormatter';
+
+describe('TimeFormatter', function () {
+    it("Case: input string unformated with showSeconds", function () {
+        let value = TimeFormatter.prepareValue("1110", false);
+        expect(value).toEqual("11:10");
+    });
+
+    it("Case: input string unformated without showSeconds", function () {
+        let value = TimeFormatter.prepareValue("1110", true);
+        expect(value).toEqual("00:11:10");
+    });
+
+    
+    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);
+    });
+    
+});

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+    "compilerOptions": {
+        "target": "ES6",
+        "lib": ["ESNext", "DOM"],
+        "sourceMap": true,
+        "outDir": "dist",
+        "rootDir": "./src",
+        "strict": true,
+        "moduleResolution": "node",
+        "declaration": true,
+    },
+    "removeComments": true,
+    "preserveConstEnums": true,
+    "include": ["src/**/*"],
+    "exclude": ["node_modules", "**/*.spec.ts"]
+}