investira.sdk 2.3.7 → 2.3.8

package/CHANGELOG.md

@@ -484,3 +484,7 @@ O contrutor para a criação das mensagem foi alterado.
 
 -   [arrays] Inclui função removeDuplicated
 -   [dates] Correção do nome da função para nextMonthAnniversary
+
+# 2.3.8
+
+-   [dates] Correção do cálculo de semanas

package/lib/utils/dates.js

@@ -18,6 +18,7 @@ const dates = {
     ONE_DAY: 864e5, //24 * 60 * 60 * 1000,
     ONE_WEEK: 6048e5, //24 * 60 * 60 * 1000 * 7,
     SCHEDULE_TYPE: ['D', 'W', 'M', 'Y'],
+    WEEKENDS_DAYS: [0, 6],
 
     /**
      * Configura o locale atual
@@ -99,12 +100,25 @@ const dates = {
      * Retorna date UTC a partir de uma string no formato ISO 8601 YYYY-MM-DD HH:mm:ss.
      * - ATENÇÃO: Fora deste formato o resultado pode ser imprevisível.
      * - A informação dos segundos(ss) e, horas(hh) + minutos(mm) são opcionais.
-     * @param {string} [pDate=null] String no formato informado em pFormat ou, quando não informado, no formato YYYY-MM-DD HH:mm:ss. ss, HH:mm são opcionais
-     * @param {string} [pFormat=null] Formato que se encontra a data informada
+     * @param {string | Date} [pDate=null] String no formato informado em pFormat ou, quando não informado, no formato YYYY-MM-DD HH:mm:ss. ss, HH:mm são opcionais
+     * @param {string | Date} [pFormat=null] Formato que se encontra a data informada
      * @returns {Date} Date
      */
     toDate: (pDate = null, pFormat = null) => {
         //TODO: Implemantar possibilidade configuração do timeZone. ex new Date().toLocaleString("pt-BR", {timeZone: "America/Sao_Paulo"});
+        // let xDate = null;
+        // if (pDate) {
+        //     if (pFormat) {
+        //         xDate = moment(pDate, pFormat);
+        //     } else {
+        //         xDate = moment(pDate);
+        //     }
+        //     if (xDate && xDate.isValid()) {
+        //         xDate = xDate.toDate();
+        //     }
+        //     return xDate;
+        // }
+        // return null;
         let xDate = null;
         if (!isNull(pFormat)) {
             if (!isEmpty(pDate)) {
@@ -151,19 +165,27 @@ const dates = {
      * Retorna quantidade de dias que são feriados.
      * Feriados que caem em dia não util não são considerados.
      *
-     * @param {Date} pDateStart
-     * @param {Date} pDateEnd
+     * @param {Date} pDateStart Data inicial
+     * @param {Date} pDateEnd Data final
      * @returns {number}
      */
     holidays: (pDateStart, pDateEnd) => {
         const xLocale = dates.localeData()._holidays;
+        let xDateStart = dates.toDate(pDateStart);
+        let xDateEnd = dates.toDate(pDateEnd);
+        let xSign = 1;
+        if (pDateEnd < pDateStart) {
+            [xDateStart, xDateEnd] = [xDateEnd, xDateStart];
+            xSign = -1;
+        }
+
         //Procura feriado posterior mais próximo data inicial, desconsiderando a própria data
-        const xI1 = seekDate(xLocale, pvToHolidayFormat(dates.addDays(pDateStart, 1)), true);
+        const xI1 = seekDate(xLocale, pvToHolidayFormat(xDateStart), true);
         //Procura feriado anterior mais próximo a data final
-        const xI2 = seekDate(xLocale, pvToHolidayFormat(pDateEnd), false);
+        const xI2 = seekDate(xLocale, pvToHolidayFormat(xDateEnd), false);
         //A quantidade de feriados será a diferença de itens entre as duas datas.
         if (xI1 <= xI2) {
-            return xI2 - xI1 + 1;
+            return (xI2 - xI1 + 1) * xSign;
         } else {
             return 0;
         }
@@ -275,11 +297,11 @@ const dates = {
         try {
             if (isNumber(pDate)) {
                 // @ts-ignore
-                const xSeconds = Math.floor((pDate / 1000) % 60);
+                const xSeconds = Math.floor((pDate / ONE_SECOND) % 60);
                 // @ts-ignore
-                const xMinutes = Math.floor((pDate / 1000 / 60) % 60);
+                const xMinutes = Math.floor((pDate / ONE_MINUTE) % 60);
                 // @ts-ignore
-                const xHours = Math.floor((pDate / (1000 * 60 * 60)) % 24);
+                const xHours = Math.floor((pDate / ONE_HOUR) % 24);
                 return `${xHours}:${xMinutes}:${xSeconds}`;
             } else if (isDate(pDate)) {
                 // @ts-ignore
@@ -398,29 +420,47 @@ const dates = {
 
     /**
      * Quantidade de dias úteis entre duas datas.
+     * Se a data inicial for superior a data fi:nal, as datas serão invertidas
+     * Exclui a data incial da contagem
      *
      * @param {Date} pDateStart
      * @param {Date} pDateEnd
      * @returns {number}
      */
-    workingDaysBetween: (pDateStart, pDateEnd) => {
-        let xDateStart = pDateStart;
-        let xDateEnd = pDateEnd;
-        let xD = 0;
-        if (pDateStart > pDateEnd) {
-            xDateEnd = pDateStart;
-            xDateStart = pDateEnd;
-            if (dates.isWorkingDay(xDateStart)) {
-                xD += 1;
+    workingDaysBetween: (pDateStart, pDateEnd, pCountDateStart = false) => {
+        //Força datas para o mesmo horário
+        let xDateStart = dates.toDate(pDateStart);
+        let xDateEnd = dates.toDate(pDateEnd);
+        if (xDateStart.getTime() === xDateEnd.getTime()) {
+            return 0;
+        }
+        let xSign = 1;
+        if (pDateEnd < pDateStart) {
+            xSign = -1;
+        }
+
+        //Calculo de dias entre duas datas
+        let xDays = pvDaysDif(xDateStart, xDateEnd);
+        if (!pCountDateStart) {
+            if (xDateEnd > xDateStart) {
+                //Desconsidera data inicial
+                xDateStart.setDate(xDateStart.getDate() + 1);
+            } else {
+                //Desconsidera data inicial
+                xDateStart.setDate(xDateStart.getDate() - 1);
             }
-            if (dates.isWorkingDay(xDateEnd)) {
-                xD -= 1;
+            if (xDateStart.getTime() === xDateEnd.getTime()) {
+                xDays = dates.isWorkingDay(xDateEnd) ? 1 : 0;
+                return xDays * xSign;
             }
         }
-        xD += dates.diff('day', xDateStart, xDateEnd, true);
-        const xW = dates.weekends(xDateStart, xDateEnd);
+        //Quantidade de feriados entre as datas
         const xH = dates.holidays(xDateStart, xDateEnd);
-        return xD - xW - xH;
+        //Quantidade de finais de semana entre as datas
+        const xW = dates.weekends(xDateStart, xDateEnd);
+        //Subtrai quantidade de feriados e finais de semana
+        xDays = xDays - xW - xH;
+        return xDays;
     },
     /**
      * Retorna quantidade de dias do mês informado
@@ -429,8 +469,8 @@ const dates = {
      * @returns {number}
      */
     workingDaysInMonth: pDate => {
-        let xDate1 = moment(pDate).utcOffset(0).startOf('month').add(-1, 'days').toDate();
-        let xDate2 = moment(pDate).utcOffset(0).endOf('month').toDate();
+        let xDate1 = dates.addDays(dates.startOf('month', dates.toUTCDate(pDate)), -1);
+        let xDate2 = dates.endOf('month', dates.toUTCDate(pDate));
         return dates.workingDaysBetween(xDate1, xDate2);
     },
     /**
@@ -442,7 +482,7 @@ const dates = {
     workingDaysInYear: pDate => {
         let xDate1 = moment(pDate).utcOffset(0).startOf('year').add(-1, 'days').toDate();
         let xDate2 = moment(pDate).utcOffset(0).endOf('year').toDate();
-        return dates.workingDaysBetween(xDate1, xDate2);
+        return dates.workingDaysBetween(xDate1, xDate2, true);
     },
     /**
      * Retorna diferença entre duas data conforma a unidade informada.
@@ -513,6 +553,25 @@ const dates = {
         return pDate.toISOString();
     },
 
+    /**
+     * Retorna string no formato UTC ISO 8601
+     *
+     * @param {Date | Number} pDateOrYear
+     * @param {Number} pMonth
+     * @param {Number} pDay
+     * @returns {Date}
+     */
+    toUTCDate: (pDateOrYear, pMonth = null, pDay = null) => {
+        if (isNumber(pDateOrYear)) {
+            // @ts-ignore
+            return new Date(Date.UTC(pDateOrYear, pMonth, pDay, 0, 0, 0, 0));
+        } else {
+            return new Date(
+                // @ts-ignore
+                Date.UTC(pDateOrYear.getFullYear(), pDateOrYear.getMonth(), pDateOrYear.getDate(), 0, 0, 0, 0)
+            );
+        }
+    },
     /**
      * Retorna datacom acréscimo dos milisegundos informados
      *
@@ -550,16 +609,71 @@ const dates = {
             pDays = 1;
         }
 
+        //Adiciona a quantidade de dias para se aproximar a data alvo
         let xDate = dates.add('days', pDate, pDays);
-        let xDays = dates.workingDaysBetween(pDate, xDate) * Math.sign(pDays);
-
+        //Conta a quantidade de dias úteis entre a data inicial e a data alvo
+        let xDays = dates.workingDaysBetween(pDate, xDate);
+        //Se resultado for a quantidade de dias informada, retorna a data alvo
         if (xDays === pDays) {
             return xDate;
         } else {
+            //Chada recursiva até encontrar a data alvo que contenha a quantidade de dias úteis informada
             const xDif = pDays - xDays;
             return dates.addWorkingDays(xDate, xDif);
         }
     },
+    /**
+     * Retorna a quantidade dias que são finais de semana(Sábados e Domingos) entre duas datas
+     * A data início e a data fim são incluídas na contagem
+     *
+     * @param {Date} pDateStart
+     * @param {Date} pDateEnd
+     * @returns {number}
+     */
+    weekends: (pDateStart, pDateEnd) => {
+        //Força datas para o mesmo horário
+        let xDateStart = dates.toDate(pDateStart);
+        let xDateEnd = dates.toDate(pDateEnd);
+        let xSign = 1;
+        if (pDateEnd < pDateStart) {
+            [xDateStart, xDateEnd] = [xDateEnd, xDateStart];
+            xSign = -1;
+        }
+        let xWeekends = 0;
+        // Calcula TOTAL de dias entre as datas, incluido o próprio dia.
+        // Ex: 01/01/2019 a 01/01/2019 = 1 dia
+        let xDays = pvDaysDif(xDateStart, xDateEnd) + 1;
+        // Ajusta contador se data inicial for sábado ou domingo
+        const xStartWeekDay = xDateStart.getDay();
+        const xEndWeekDay = xDateEnd.getDay();
+
+        //Se data inicial for sábado ou data for domingo
+        if (dates.WEEKENDS_DAYS.includes(xStartWeekDay) || dates.WEEKENDS_DAYS.includes(xEndWeekDay)) {
+            if (xStartWeekDay === 6) {
+                xDays -= 2;
+                xWeekends += 2;
+            }
+            if (xEndWeekDay === 0) {
+                xDays -= 2;
+                xWeekends += 2;
+            }
+            if (xStartWeekDay === 0) {
+                xDays -= 1;
+                xWeekends += 1;
+            }
+            if (xEndWeekDay === 6) {
+                xDays -= 1;
+                xWeekends += 1;
+            }
+        } else if (xStartWeekDay > xEndWeekDay) {
+            xDays -= 2;
+            xWeekends += 2;
+        }
+        // Calcula número de finais de semana. Sábado e domingo
+        xWeekends += Math.floor(xDays / 7) * 2;
+        return xWeekends * xSign;
+    },
+
     /**
      * Verifica se data é um dia útil.
      *
@@ -678,39 +792,6 @@ const dates = {
         return moment(pDate).endOf(pUnit).toDate();
     },
 
-    /**
-     * Retorna a quantidade de finais de semana(Sábados e Domingos) entre duas datas
-     *
-     * @param {Date} pDateStart
-     * @param {Date} pDateEnd
-     * @returns {number}
-     */
-    weekends: (pDateStart, pDateEnd) => {
-        //Quantidade sábados e domingos entre a datas
-        let xDateI = pDateStart;
-        let xDateF = pDateEnd;
-        if (pDateStart > pDateEnd) {
-            xDateI = pDateEnd;
-            xDateF = pDateStart;
-        }
-        let xWeekends = dates.daysBetween(xDateI, xDateF);
-        const xSemanas = numbers.apart(numbers.div(xWeekends, 7));
-        //Quantidade de semanas existentes entre as duas datas
-        xWeekends = Number(xSemanas.int) * 2;
-        const xWI = xDateI.getUTCDay();
-        //Artifício para não precisar fazer cálculo
-        const xDias = Math.trunc(Number('0.' + xSemanas.dec) * 7);
-        const xWF = xWI + xDias;
-        let xCalc = xWF - 5;
-        if (xCalc > 0) {
-            xWeekends += Math.min(2, xCalc);
-        }
-        if (xWI === 6) {
-            xWeekends--;
-        }
-        return xWeekends;
-    },
-
     /**
      * Verifica se string é uma hora válida
      *
@@ -1003,5 +1084,12 @@ const pvLoadDataPush = (pHolidays, pKey, pHolidayString) => {
         pHolidays.push(pHolidayString);
     }
 };
+
+const pvDaysDif = (pDateStart, pDateEnd) => {
+    const xDateStart = dates.toUTCDate(pDateStart);
+    const xDateEnd = dates.toUTCDate(pDateEnd);
+    let xDays = Math.floor((xDateEnd.getTime() - xDateStart.getTime()) / dates.ONE_DAY);
+    return xDays;
+};
 //Carrega informações dos feriados
 dates.loadData();

package/lib/utils/formats.js

@@ -179,62 +179,62 @@ const formats = {
         if (isEmpty(pValue) || !isNumber(pValue) || pValue < 1) {
             return '';
         }
-        const xData1 = new Date();
-        let xData2 = new Date();
+        const xDataI = new Date();
+        let xDataF = new Date();
 
         if (pType === 'd') {
-            xData2 = addDays(xData1, pValue);
+            xDataF = addDays(xDataI, pValue);
         }
 
         if (pType === 'm') {
-            xData2 = addMonths(xData1, pValue);
+            xDataF = addMonths(xDataI, pValue);
         }
 
         if (pType === 'y') {
-            xData2 = addYears(xData1, pValue);
+            xDataF = addYears(xDataI, pValue);
         }
 
-        return formats.friendlyBetweenDates(xData1, xData2);
+        return formats.friendlyBetweenDates(xDataI, xDataF);
     },
 
     /**
      * Retorna string no formado x ano(s) e/ou y (mês)es e/ou z dia(s).
      *
-     * @param {string | Date} pDate1 Data inicial
-     * @param {string | Date} pDate2 Data final
+     * @param {string | Date} pDateI Data inicial
+     * @param {string | Date} pDateF Data final
      * @returns
      */
-    friendlyBetweenDates: (pDate1, pDate2) => {
+    friendlyBetweenDates: (pDateI, pDateF) => {
         let xPeriod = '';
-        if (isEmpty(pDate1) || isEmpty(pDate2)) {
+        if (isEmpty(pDateI) || isEmpty(pDateF)) {
             return xPeriod;
         }
 
-        let xDate1 = pDate1;
-        let xDate2 = pDate2;
+        let xDateI = pDateI;
+        let xDateF = pDateF;
 
-        if (isString(pDate1)) {
+        if (isString(pDateI)) {
             // @ts-ignore
-            xDate1 = toDate(xDate1);
+            xDateI = toDate(xDateI);
         }
-        if (isString(pDate2)) {
+        if (isString(pDateF)) {
             // @ts-ignore
-            xDate2 = toDate(xDate2);
+            xDateF = toDate(xDateF);
         }
         // @ts-ignore
-        xDate1 = startOf('day', xDate1);
+        xDateI = startOf('day', xDateI);
         // @ts-ignore
-        xDate2 = startOf('day', xDate2);
+        xDateF = startOf('day', xDateF);
 
-        if (daysBetween(xDate1, xDate2) == 0) {
+        if (daysBetween(xDateI, xDateF) == 0) {
             return '';
         }
 
-        const xYears = Math.floor(yearsBetween(xDate1, xDate2));
-        xDate2 = addYears(xDate2, -xYears);
-        const xMonths = Math.floor(monthsBetween(xDate1, xDate2));
-        xDate2 = addMonths(xDate2, -xMonths);
-        const xDays = daysBetween(xDate1, xDate2, true);
+        const xYears = Math.floor(yearsBetween(xDateI, xDateF));
+        xDateF = addYears(xDateF, -xYears);
+        const xMonths = Math.floor(monthsBetween(xDateI, xDateF));
+        xDateF = addMonths(xDateF, -xMonths);
+        const xDays = daysBetween(xDateI, xDateF, true);
         const xSlugs = formats.slugPeriod(xYears, xMonths, xDays);
 
         if (xYears > 0 && xMonths > 0) {
@@ -256,7 +256,7 @@ const formats = {
     /**
      * Retorna string no formato: há 4 anos atrás.
      *
-     * @param {Date} pDate1 Data inicial
+     * @param {Date} pDate Data inicial
      * @param {boolean} pSuffix Sem sufixo
      * @returns
      */
@@ -266,7 +266,7 @@ const formats = {
     /**
      * Retorna string no formato: em 4 anos.
      *
-     * @param {Date} pDate1 Data inicial
+     * @param {Date} pDate Data inicial
      * @param {boolean} pPrefix Sem sufixo
      * @returns
      */

package/lib/utils/validators.js

@@ -98,6 +98,9 @@ const validators = {
      * @returns {boolean}
      */
     isUndefined: toValidate => {
+        if (toValidate === undefined) {
+            return true;
+        }
         return validators.trueTypeOf(toValidate) === 'undefined';
     },
 
@@ -165,7 +168,7 @@ const validators = {
 
     /**
      * Retorna se tamanho é maior que outro
-     * @param {object} toValidate Elemento a ser verificado
+     * @param {object} length Elemento a ser verificado
      * @returns
      */
     isLengthGreaterThen: length => toValidate => toValidate.length > length,
@@ -197,10 +200,7 @@ const validators = {
      */
     isTrue: pValue => {
         //Separado em vário if's para otimizar performance
-        if (pValue === null) {
-            return false;
-        }
-        if (validators.isUndefined(pValue)) {
+        if (pValue === null || validators.isUndefined(pValue)) {
             return false;
         }
         if (pValue === -1 || pValue === 1) {

package/package.json

@@ -1,16 +1,16 @@
 {
     "name": "investira.sdk",
-    "version": "2.3.7",
+    "version": "2.3.8",
     "author": "Investira",
     "description": "Investira SDK",
     "main": "index.js",
     "type": "commonjs",
     "registry": true,
-    "raw": "investira.sdk@2.3.7",
+    "raw": "investira.sdk@2.3.8",
     "escapedName": "investira.sdk",
-    "rawSpec": "2.3.7",
+    "rawSpec": "2.3.8",
     "saveSpec": null,
-    "fetchSpec": "2.3.7",
+    "fetchSpec": "2.3.8",
     "homepage": "https://investira.com.br/",
     "engines": {
         "node": ">=11.11.0 <=18.12",

package/.vscode/launch.json

@@ -1,14 +0,0 @@
-{
-    "version": "0.2.0",
-    "configurations": [
-        {
-            "trace": true,
-            "name": "debug node",
-            "type": "node",
-            "request": "attach",
-            "restart": true,
-            "cwd": "${workspaceFolder}",
-            "port": 9233,
-        }
-    ]
-  }

package/.vscode/settings.json

@@ -1,6 +0,0 @@
-{
-    "debug.node.autoAttach": "on",
-    "debug.javascript.usePreview": false,
-    "debug.javascript.usePreviewAutoAttach": false,
-    "debug.javascript.autoAttachFilter": "onlyWithFlag"
-}

package/lib/tests/index.js

@@ -1,9 +0,0 @@
-require('./test_formats');
-require('./test_dates');
-require('./test_invests');
-require('./test_numbers');
-require('./test_strings');
-require('./test_arrays');
-require('./test_spellChecker');
-require('./test_validators');
-require('./test_objects');

package/lib/tests/test_arrays.js

@@ -1,138 +0,0 @@
-const test = require('tape');
-const arrays = require('../utils/arrays');
-const dates = require('../utils/dates');
-const arrayNumber = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90];
-const arrayDate = [
-    new Date('2000-01-01'),
-    new Date('2000-02-01'),
-    new Date('2000-03-01'),
-    new Date('2000-04-01'),
-    new Date('2000-05-01'),
-    new Date('2000-06-01'),
-    new Date('2000-07-01'),
-    new Date('2000-08-01'),
-    new Date('2000-09-01'),
-    new Date('2000-10-01')
-];
-const arrayDateString = [
-    '2000-01-01',
-    '2000-02-01',
-    '2000-03-01',
-    '2000-04-01',
-    '2000-05-01',
-    '2000-06-01',
-    '2000-07-01',
-    '2000-08-01',
-    '2000-09-01',
-    '2000-10-01'
-];
-const arrayString = ['A', 'D', 'G', 'J', 'K', 'N', 'Q', 'T', 'W', 'Z'];
-
-test('\narrays seek number', t => {
-    //O mais próximo
-    t.equal(arrays.seek(arrayNumber, 30), arrayNumber.indexOf(30));
-    //O anterior mais próximo
-    t.equal(arrays.seek(arrayNumber, 30, false), arrayNumber.indexOf(30));
-    //O posterior mais próximo
-    t.equal(arrays.seek(arrayNumber, 30, true), arrayNumber.indexOf(30));
-
-    //O mais próximo
-    t.equal(arrays.seek(arrayNumber, 31), arrayNumber.indexOf(30));
-    //O anterior mais próximo
-    t.equal(arrays.seek(arrayNumber, 31, false), arrayNumber.indexOf(30));
-    //O posterior mais próximo
-    t.equal(arrays.seek(arrayNumber, 31, true), arrayNumber.indexOf(40));
-
-    //O mais próximo
-    t.equal(arrays.seek(arrayNumber, 29), arrayNumber.indexOf(30));
-    //O anterior mais próximo
-    t.equal(arrays.seek(arrayNumber, 29, false), arrayNumber.indexOf(20));
-    //O posterior mais próximo
-    t.equal(arrays.seek(arrayNumber, 29, true), arrayNumber.indexOf(30));
-
-    //O posterior mais próximo
-    t.equal(arrays.seek(arrayNumber, 1000), arrayNumber.indexOf(90));
-    //O anterior mais próximo
-    t.equal(arrays.seek(arrayNumber, 1000, false), arrayNumber.indexOf(90));
-    //O posterior mais próximo
-    t.equal(arrays.seek(arrayNumber, 1000, true), arrayNumber.indexOf(90));
-
-    //O posterior mais próximo
-    t.equal(arrays.seek(arrayNumber, -1000), arrayNumber.indexOf(0));
-    //O anterior mais próximo
-    t.equal(arrays.seek(arrayNumber, -1000, false), arrayNumber.indexOf(0));
-    //O posterior mais próximo
-    t.equal(arrays.seek(arrayNumber, -1000, true), arrayNumber.indexOf(0));
-    t.end();
-});
-
-test('\narrays seek date', t => {
-    //O mais próximo
-    t.equal(arrays.seek(arrayDate, new Date('2000-05-15')), 4);
-    //O anterior mais próximo
-    t.equal(arrays.seek(arrayDate, new Date('2000-05-15'), false), 4);
-    //O posterior mais próximo
-    t.equal(arrays.seek(arrayDate, new Date('2000-05-15'), true), 5);
-
-    //O mais próximo
-    t.equal(arrays.seek(arrayDate, new Date('2010-05-15')), 9);
-    //O anterior mais próximo
-    t.equal(arrays.seek(arrayDate, new Date('2010-05-15'), false), 9);
-    //O posterior mais próximo
-    t.equal(arrays.seek(arrayDate, new Date('2010-05-15'), true), 9);
-
-    //O mais próximo
-    t.equal(arrays.seek(arrayDate, new Date('1999-05-15')), 0);
-    //O anterior mais próximo
-    t.equal(arrays.seek(arrayDate, new Date('1999-05-15'), false), 0);
-    //O posterior mais próximo
-    t.equal(arrays.seek(arrayDate, new Date('1999-05-15'), true), 0);
-
-    t.end();
-});
-
-test('\narrays seek date string', t => {
-    //O mais próximo
-    t.equal(arrays.seekDate(arrayDateString, '2000-05-15'), arrayDateString.indexOf('2000-05-01'));
-    // //O anterior mais próximo
-    t.equal(arrays.seekDate(arrayDateString, '2000-05-15', false), arrayDateString.indexOf('2000-05-01'));
-    //O posterior mais próximo
-    t.equal(arrays.seekDate(arrayDateString, '2000-05-15', true), arrayDateString.indexOf('2000-06-01'));
-
-    //O mais próximo
-    t.equal(arrays.seekDate(arrayDateString, '2010-05-15'), arrayDateString.indexOf('2000-10-01'));
-    //O anterior mais próximo
-    t.equal(arrays.seekDate(arrayDateString, '2010-05-15', false), arrayDateString.indexOf('2000-10-01'));
-    //O posterior mais próximo
-    t.equal(arrays.seekDate(arrayDateString, '2010-05-15', true), arrayDateString.indexOf('2000-10-01'));
-
-    //O mais próximo
-    t.equal(arrays.seekDate(arrayDateString, '1999-05-15'), arrayDateString.indexOf('2000-01-01'));
-    //O anterior mais próximo
-    t.equal(arrays.seekDate(arrayDateString, '1999-05-15', false), arrayDateString.indexOf('2000-01-01'));
-    //O posterior mais próximo
-    t.equal(arrays.seekDate(arrayDateString, '1999-05-15', true), arrayDateString.indexOf('2000-01-01'));
-    t.end();
-});
-
-test('\ntoArray', t => {
-    t.deepEqual(arrays.toArray('uma frase qualquer,outra frase qualquer,terceira frase qualquer'), [
-        'uma frase qualquer',
-        'outra frase qualquer',
-        'terceira frase qualquer'
-    ]);
-    t.deepEqual(arrays.toArray('uma frase qualquer,outra frase qualquer,terceira frase qualquer', undefined, '%'), [
-        '%uma frase qualquer',
-        '%outra frase qualquer',
-        '%terceira frase qualquer'
-    ]);
-    t.deepEqual(
-        arrays.toArray('uma frase qualquer,outra frase qualquer,terceira frase qualquer', undefined, '%', '%'),
-        ['%uma frase qualquer%', '%outra frase qualquer%', '%terceira frase qualquer%']
-    );
-    t.deepEqual(
-        arrays.toArray(['uma frase qualquer', 'outra frase qualquer', 'terceira frase qualquer'], undefined, '%', '%'),
-        ['%uma frase qualquer%', '%outra frase qualquer%', '%terceira frase qualquer%']
-    );
-    t.end();
-});

package/lib/tests/test_dates.js

@@ -1,270 +0,0 @@
-const test = require('tape');
-const { formatDateCustom } = require('../utils/formats');
-
-const dates = require('../utils/dates');
-
-test('\ndates scheduleToDate', t => {
-    dates.locale('pt-BR');
-    t.deepEqual(
-        dates.scheduleToDate({ type: 'D', time: '08:30', workingDay: true }, dates.toDate('2001-01-01T00:00')),
-        dates.toDate('2001-01-02T08:30:00')
-    );
-    t.deepEqual(
-        dates.scheduleToDate({ type: 'M', time: '08:30', workingDay: true }, dates.toDate('2001-01-10T00:00')),
-        dates.toDate('2001-02-01T08:30:00')
-    );
-    t.deepEqual(
-        dates.scheduleToDate(
-            { type: 'W', time: '08:30', weekday: 2, workingDay: false },
-            dates.toDate('2020-09-28T00:00')
-        ),
-        dates.toDate('2020-09-29T08:30')
-    );
-    t.deepEqual(
-        dates.scheduleToDate(
-            { type: 'W', time: '08:30', weekday: 1, workingDay: false },
-            dates.toDate('2020-09-29T08:31')
-        ),
-        dates.toDate('2020-10-05T08:30')
-    );
-    t.end();
-});
-
-test('\ndates areDatesEqual', t => {
-    dates.locale('pt-BR');
-    t.equal(dates.areDatesEqual(dates.toDate('2001-01-01T00:00Z'), dates.toDate('2001-01-01T00:00Z')), true);
-    t.equal(dates.areDatesEqual(dates.toDate('2001-01-01T00:00Z'), dates.toDate('2001-01-01T00:01Z')), true);
-    t.equal(dates.areDatesEqual(dates.toDate('2001-01-01T00:00Z'), dates.toDate('2001-01-02T00:01Z')), false);
-    t.end();
-});
-
-test('\ndates areDateTimesEqual', t => {
-    dates.locale('pt-BR');
-    t.equal(dates.areDateTimesEqual(dates.toDate('2001-01-01T00:00Z'), dates.toDate('2001-01-01T00:00Z')), true);
-    t.equal(dates.areDateTimesEqual(dates.toDate('2001-01-01T00:00Z'), dates.toDate('2001-01-01T00:01Z')), false);
-    t.equal(dates.areDateTimesEqual(dates.toDate('2001-01-01T00:00Z'), dates.toDate('2001-01-02T00:01Z')), false);
-    t.end();
-});
-
-test('\ndates isWorkingDay', t => {
-    dates.locale('pt-BR');
-    t.equal(dates.isWorkingDay(dates.toDate('2019-08-03')), false);
-    t.equal(dates.isWorkingDay(dates.toDate('2019-08-05')), true);
-    t.equal(dates.isWorkingDay(dates.toDate('2019-09-07')), false);
-    t.end();
-});
-
-test('\ndates isTime', t => {
-    dates.locale('pt-BR');
-    t.equal(dates.isTime('25:00'), false);
-    t.equal(dates.isTime('24:01'), false);
-    t.equal(dates.isTime('24:00'), false);
-    t.equal(dates.isTime('00:00'), true);
-    t.equal(dates.isTime('00:60'), false);
-    t.equal(dates.isTime('00:01'), true);
-    t.equal(dates.isTime('0:0'), false);
-    t.equal(dates.isTime('00'), false);
-    t.end();
-});
-
-test('\ndates addWorkingDays', t => {
-    dates.locale('pt-BR');
-
-    t.deepEqual(dates.addWorkingDays(dates.toDate('2019-08-01'), -252), dates.toDate('2018-07-30T03:00:00.000Z'));
-    t.deepEqual(dates.addWorkingDays(dates.toDate('2018-07-30'), 252), dates.toDate('2019-08-01T03:00:00.000Z'));
-
-    t.deepEqual(dates.addWorkingDays(dates.toDate('2019-08-03'), -1), dates.toDate('2019-08-02T03:00:00.000Z'));
-    t.deepEqual(dates.addWorkingDays(dates.toDate('2019-08-04'), -1), dates.toDate('2019-08-02T03:00:00.000Z'));
-    t.deepEqual(dates.addWorkingDays(dates.toDate('2019-08-05'), -1), dates.toDate('2019-08-02T03:00:00.000Z'));
-    t.deepEqual(dates.addWorkingDays(dates.toDate('2019-08-06'), -1), dates.toDate('2019-08-05T03:00:00.000Z'));
-
-    t.deepEqual(dates.addWorkingDays(dates.toDate('2019-08-03'), 0), dates.toDate('2019-08-05T03:00:00.000Z'));
-    t.deepEqual(dates.addWorkingDays(dates.toDate('2019-08-05'), 0), dates.toDate('2019-08-05T03:00:00.000Z'));
-    t.deepEqual(dates.addWorkingDays(dates.toDate('2019-08-03'), 1), dates.toDate('2019-08-05T03:00:00.000Z'));
-    t.deepEqual(dates.addWorkingDays(dates.toDate('2019-08-05'), 1), dates.toDate('2019-08-06T03:00:00.000Z'));
-    t.deepEqual(dates.addWorkingDays(dates.toDate('2019-08-03'), 2), dates.toDate('2019-08-06T03:00:00.000Z'));
-    t.deepEqual(dates.addWorkingDays(dates.toDate('2019-08-05'), 4), dates.toDate('2019-08-09T03:00:00.000Z'));
-    t.end();
-});
-
-test('\ndates weekNames', t => {
-    dates.locale('pt-BR');
-    t.equal(dates.weekNames()[0], 'domingo');
-    dates.locale('en-US');
-    t.equal(dates.weekNames()[0], 'Sunday');
-    t.end();
-});
-
-test('\ndates workingDaysInMonth', t => {
-    dates.locale('pt-BR');
-    t.equal(dates.workingDaysInMonth(dates.toDate('2019-03-03')), 19);
-    t.equal(dates.workingDaysInMonth(dates.toDate('2019-04-03')), 21);
-    t.end();
-});
-
-test('\ndates holidays', t => {
-    dates.locale('pt-BR');
-    t.equal(dates.isHoliday(dates.toDate('2019-05-01T23:59Z')), true);
-    // t.equal(dates.isHoliday(dates.toDate('2019-05-01')), true);
-    t.equal(dates.isHoliday(dates.toDate('2019-04-21T23:59Z')), false);
-    t.equal(dates.isHoliday(dates.toDate('2019-11-11T23:59Z')), false);
-    dates.locale('en-US');
-    t.equal(dates.isHoliday(dates.toDate('2019-05-01T23:59Z')), false);
-    t.equal(dates.isHoliday(dates.toDate('2019-04-21T23:59Z')), false);
-    t.equal(dates.isHoliday(dates.toDate('2019-11-11T23:59Z')), true);
-    t.end();
-});
-
-test('\ndates workingDaysBetween', t => {
-    dates.locale('pt-BR');
-    let xData1 = dates.toDate('2019-01-03');
-    let xData2 = dates.toDate('2019-05-30');
-    t.equal(dates.workingDaysBetween(xData1, xData2), 101);
-    xData1 = dates.toDate('2019-05-01');
-    xData2 = dates.toDate('2019-05-02');
-    t.equal(dates.workingDaysBetween(xData1, xData2), 1);
-    xData1 = dates.toDate('2019-04-30');
-    xData2 = dates.toDate('2019-05-01');
-    t.equal(dates.workingDaysBetween(xData1, xData2), 0);
-    // xData1 = dates.toDate('1988-04-20');
-    // xData2 = dates.toDate('1988-04-21');
-    // t.equal(dates.workingDaysBetween(xData1, xData2), 0);
-    xData1 = dates.toDate('2019-04-30');
-    xData2 = dates.toDate('2019-05-02');
-    t.equal(dates.workingDaysBetween(xData1, xData2), 1);
-    xData1 = dates.toDate('1995-12-31');
-    xData2 = dates.toDate('2018-12-31');
-    t.equal(dates.workingDaysBetween(xData1, xData2), 5774);
-    xData1 = dates.toDate('1995-01-01');
-    xData2 = dates.toDate('2018-12-31');
-    t.equal(dates.workingDaysBetween(xData1, xData2), 6022);
-    xData1 = dates.toDate('1995-01-03');
-    xData2 = dates.toDate('2070-01-03');
-    t.equal(dates.workingDaysBetween(xData1, xData2), 18835);
-    xData1 = dates.toDate('2019-08-05');
-    xData2 = dates.toDate('2019-08-04');
-    t.equal(dates.workingDaysBetween(xData1, xData2), 0);
-    xData1 = dates.toDate('2019-08-03');
-    xData2 = dates.toDate('2019-08-02');
-    t.equal(dates.workingDaysBetween(xData1, xData2), 1);
-    xData1 = dates.toDate('2019-08-02');
-    xData2 = dates.toDate('2019-08-03');
-    t.equal(dates.workingDaysBetween(xData1, xData2), 0);
-    xData1 = dates.toDate('2019-05-01');
-    xData2 = dates.toDate('2019-05-01');
-    t.equal(dates.workingDaysBetween(xData1, xData2), 0);
-    xData1 = dates.toDate('2019-05-02');
-    xData2 = dates.toDate('2019-05-01');
-    t.equal(dates.workingDaysBetween(xData1, xData2), 0);
-    xData1 = dates.toDate('2019-05-01');
-    xData2 = dates.toDate('2019-05-02');
-    t.equal(dates.workingDaysBetween(xData1, xData2), 1);
-    xData1 = dates.toDate('2019-08-03');
-    xData2 = dates.toDate('2019-08-03');
-    t.equal(dates.workingDaysBetween(xData1, xData2), 0);
-    xData1 = dates.toDate('2019-08-02');
-    xData2 = dates.toDate('2019-08-03');
-    t.equal(dates.workingDaysBetween(xData1, xData2), 0);
-    xData1 = dates.toDate('2019-08-01');
-    xData2 = dates.toDate('2019-08-03');
-    t.equal(dates.workingDaysBetween(xData1, xData2), 1);
-
-    t.end();
-});
-
-test('\ndates addmonth', t => {
-    t.equal(formatDateCustom(dates.addMonths(dates.toDate('2019-01-31'), 1), 'DD/MM/YY'), '28/02/19');
-    t.equal(formatDateCustom(dates.addMonths(dates.toDate('2019-01-31T23:59:59'), 1), 'DD/MM/YY'), '28/02/19');
-    t.end();
-});
-
-test('\ndates isExpired', t => {
-    t.equal(dates.isExpired(dates.addDays(dates.toDate(), -1), 1), true);
-    t.equal(dates.isExpired(dates.addDays(dates.toDate(), 1), 1), false);
-    t.end();
-});
-
-test('\ndates addYears', t => {
-    t.equal(formatDateCustom(dates.addYears(dates.toDate('2019-01-31T23:59:59'), 1), 'DD/MM/YY'), '31/01/20');
-    t.end();
-});
-
-test('\ndates daysBetween', t => {
-    t.equal(dates.daysBetween(dates.toDate('2018-12-31'), dates.toDate('2018-12-31')), 0);
-    t.equal(dates.daysBetween(dates.toDate('2018-12-31'), dates.toDate('2018-12-30')), -1);
-    t.equal(dates.daysBetween(dates.toDate('2018-12-30'), dates.toDate('2018-12-31')), 1);
-    t.equal(dates.daysBetween(dates.toDate('2018-12-30T00:01Z'), dates.toDate('2018-12-31T23:01Z'), true), 1);
-    t.equal(dates.daysBetween(dates.toDate('2018-12-30T23:01Z'), dates.toDate('2018-12-31T00:01Z'), true), 1);
-    t.equal(dates.daysBetween(dates.toDate('2018-01-01T00:01Z'), dates.toDate('2018-01-02T23:59Z'), true), 1);
-    t.equal(
-        dates.daysBetween(dates.toDate('2018-01-01T00:01Z'), dates.toDate('2018-01-02T23:59Z')),
-        1.9986111111111111
-    );
-    t.end();
-});
-test('\ndates yearsBetween', t => {
-    t.equal(
-        dates.yearsBetween(dates.toDate('2018-12-31T23:59Z'), dates.toDate('2019-01-01T00:01Z')),
-        0.0000037335722819593786
-    );
-    t.equal(dates.yearsBetween(dates.toDate('2018-12-31T23:59Z'), dates.toDate('2019-01-01T00:01Z'), true), 1);
-    t.end();
-});
-
-test('\ndates getWeekends', t => {
-    t.equal(dates.weekends(dates.toDate('2019-04-27'), dates.toDate('2019-05-03')), 1, '2019-04-27 2019-05-03');
-    t.equal(dates.weekends(dates.toDate('2019-05-01'), dates.toDate('2019-05-03')), 0, '2019-05-01 2019-05-03');
-    t.equal(dates.weekends(dates.toDate('2019-05-01'), dates.toDate('2019-05-04')), 1, '2019-05-01 2019-05-04');
-    t.equal(dates.weekends(dates.toDate('2019-05-01'), dates.toDate('2019-05-05')), 2, '2019-05-01 2019-05-05');
-    t.equal(dates.weekends(dates.toDate('2019-05-01'), dates.toDate('2019-05-06')), 2, '2019-05-01 2019-05-06');
-    t.equal(dates.weekends(dates.toDate('2019-05-01'), dates.toDate('2019-05-07')), 2, '2019-05-01 2019-05-07');
-    t.equal(dates.weekends(dates.toDate('2019-05-01'), dates.toDate('2019-05-10')), 2, '2019-05-01 2019-05-10');
-    t.equal(dates.weekends(dates.toDate('2019-05-01'), dates.toDate('2019-05-11')), 3, '2019-05-01 2019-05-11');
-    t.equal(dates.weekends(dates.toDate('2019-05-01'), dates.toDate('2019-05-12')), 4, '2019-05-01 2019-05-12');
-    t.equal(dates.weekends(dates.toDate('2019-05-01'), dates.toDate('2019-05-13')), 4, '2019-05-01 2019-05-13');
-    t.equal(dates.weekends(dates.toDate('2019-05-13'), dates.toDate('2019-05-01')), 4, '2019-05-13 2019-05-01');
-    t.equal(dates.weekends(dates.toDate('2019-05-01'), dates.toDate('2019-05-14')), 4, '2019-05-01 2019-05-14');
-    t.equal(dates.weekends(dates.toDate('2019-05-04'), dates.toDate('2019-05-05')), 1, '2019-05-04 2019-05-05');
-    t.equal(dates.weekends(dates.toDate('2019-05-04'), dates.toDate('2019-05-06')), 1, '2019-05-04 2019-05-06');
-    t.equal(dates.weekends(dates.toDate('2019-05-04'), dates.toDate('2019-05-07')), 1, '2019-05-04 2019-05-07');
-
-    t.equal(dates.weekends(dates.toDate('2019-05-05'), dates.toDate('2019-05-06')), 0, '2019-05-05 2019-05-06');
-    t.equal(dates.weekends(dates.toDate('2019-05-05'), dates.toDate('2019-05-07')), 0, '2019-05-05 2019-05-07');
-    t.equal(dates.weekends(dates.toDate('2019-05-05'), dates.toDate('2019-05-08')), 0, '2019-05-05 2019-05-08');
-    t.end();
-});
-
-test('\ndates weekOfMonth (absolute)', t => {
-    t.equal(dates.weekOfMonth(dates.toDate('2022-01-01'), true), 1);
-    t.equal(dates.weekOfMonth(dates.toDate('2022-01-08'), true), 2);
-    t.equal(dates.weekOfMonth(dates.toDate('2022-01-15'), true), 3);
-    t.equal(dates.weekOfMonth(dates.toDate('2022-01-22'), true), 4);
-    t.equal(dates.weekOfMonth(dates.toDate('2022-01-25'), true), 5);
-    t.equal(dates.weekOfMonth(dates.toDate('2022-01-31'), true), 6);
-    t.end();
-});
-
-test('\ndates weekOfMonth', t => {
-    t.equal(dates.weekOfMonth(dates.toDate('2022-01-01')), 1);
-    t.equal(dates.weekOfMonth(dates.toDate('2022-01-08')), 2);
-    t.equal(dates.weekOfMonth(dates.toDate('2022-01-15')), 3);
-    t.equal(dates.weekOfMonth(dates.toDate('2022-01-25')), 4);
-    t.end();
-});
-
-test('\ndates weekOfYear', t => {
-    t.equal(dates.weekOfYear(dates.toDate('2022-01-01')), 1);
-    t.equal(dates.weekOfYear(dates.toDate('2022-01-08')), 2);
-    t.equal(dates.weekOfYear(dates.toDate('2022-01-15')), 3);
-    t.equal(dates.weekOfYear(dates.toDate('2022-01-22')), 4);
-    t.equal(dates.weekOfYear(dates.toDate('2022-01-24')), 5);
-    t.end();
-});
-
-test('\ndates weekOf "month"', t => {
-    t.deepEqual(dates.weekOf(dates.toDate('2022-01-01')), { month: 1, year: 1 });
-    t.deepEqual(dates.weekOf(dates.toDate('2022-01-08')), { month: 2, year: 2 });
-    t.deepEqual(dates.weekOf(dates.toDate('2022-01-15')), { month: 3, year: 3 });
-    t.deepEqual(dates.weekOf(dates.toDate('2022-01-25')), { month: 4, year: 5 });
-    t.end();
-});

package/lib/tests/test_formats.js

@@ -1,80 +0,0 @@
-const test = require('tape');
-
-const formats = require('../utils/formats');
-formats.LOCALE = 'pt-BR';
-formats.CURRENCY = 'BRL'; //'EUR';
-
-formats.locale('pt-BR');
-
-test('\nformats.formatPhone', t => {
-    t.equal(formats.formatPhone('12345678', '21', '55'), '+55 (21) 1234-5678');
-    t.equal(formats.formatPhone(12345678, '21', 55), '+55 (21) 1234-5678');
-    t.equal(formats.formatPhone(12345678, '21'), '(021) 1234-5678');
-    t.end();
-});
-
-test('\nformats.friendlyNumber', t => {
-    t.equal(formats.friendlyNumber(123, 0, true), `R$${String.fromCharCode(160)}123`);
-    t.equal(formats.friendlyNumber(123, 0, false), '123');
-    t.equal(formats.friendlyNumber(1234567, 0, false), '1 mi');
-    t.equal(formats.friendlyNumber(1234567, 1, false), '1,2 mi');
-    t.equal(formats.friendlyNumber(1234567, 2, false), '1,23 mi');
-    t.equal(formats.friendlyNumber(1234567, 3, false), '1,235 mi');
-    t.equal(formats.friendlyNumber(1234000, 0, false), '1 mi');
-    t.equal(formats.friendlyNumber(1234000, 1, false), '1,2 mi');
-    t.equal(formats.friendlyNumber(1234000, 2, false), '1,23 mi');
-    t.equal(formats.friendlyNumber(1234000, 3, false), '1,234 mi');
-    t.equal(formats.friendlyNumber(1234000, 0, true), `R$${String.fromCharCode(160)}1 mi`);
-    t.equal(formats.friendlyNumber(1234000, 1, true), `R$${String.fromCharCode(160)}1,2 mi`);
-    t.equal(formats.friendlyNumber(1234000, 2, true), `R$${String.fromCharCode(160)}1,23 mi`);
-    t.equal(formats.friendlyNumber(1234000, 3, true), `R$${String.fromCharCode(160)}1,234 mi`);
-    t.equal(formats.friendlyNumber(-1234000, 3, false), '-1,234 mi');
-    t.equal(formats.friendlyNumber(0, 3, false), '0');
-    t.equal(formats.friendlyNumber(0.9123123424, 2, false), '0,91');
-    t.equal(formats.friendlyNumber(0.9123123424, 2, true), `R$${String.fromCharCode(160)}0,91`);
-    t.end();
-});
-
-test('\nformats.friendlyBetweenDates', t => {
-    t.equal(formats.friendlyBetweenDates('2019-06-24T14:05:20.000Z', '2025-12-31T14:05:20.000Z'), '6 anos e 6 meses');
-    t.equal(formats.friendlyBetweenDates('2019-06-24T14:05:20.000Z', '2022-10-30T14:05:20.000Z'), '3 anos e 4 meses');
-    t.equal(formats.friendlyBetweenDates('2019-06-24T14:05:20.000Z', '2021-06-24T14:05:20.000Z'), '2 anos');
-    t.equal(formats.friendlyBetweenDates('2019-06-24T14:05:20.000Z', '2020-06-24T14:05:20.000Z'), 'um ano');
-    t.equal(formats.friendlyBetweenDates('2019-06-24T14:05:20.000Z', '2019-12-24T14:05:20.000Z'), '6 meses');
-    t.equal(formats.friendlyBetweenDates('2019-02-28T14:05:20.000Z', '2019-03-28T14:05:20.000Z'), 'um mês');
-
-    t.equal(formats.friendlyBetweenDates('2019-02-28T14:05:20.000Z', '2019-03-05T14:05:20.000Z'), '5 dias');
-
-    t.equal(formats.friendlyBetweenDates('2019-06-24T14:05:20.000Z', '2019-06-29T14:05:20.000Z'), '5 dias');
-
-    t.equal(formats.friendlyBetweenDates('2019-06-24T14:05:20.000Z', '2019-06-25T14:05:20.000Z'), 'um dia');
-
-    t.equal(formats.friendlyBetweenDates('2019-06-24T14:05:20.000Z', '2019-06-24T14:05:20.000Z'), '');
-
-    t.end();
-});
-
-test('\nformats.friendlyDate', t => {
-    t.equal(formats.friendlyDate(8), '8 dias');
-    t.equal(formats.friendlyDate(365), 'um ano');
-    t.equal(formats.friendlyDate(366), 'um ano e um dia');
-    t.equal(formats.friendlyDate(370), 'um ano e 5 dias');
-    t.equal(formats.friendlyDate(430), 'um ano e 2 meses');
-    t.equal(formats.friendlyDate(770), '2 anos e um mês');
-    t.equal(formats.friendlyDate(800), '2 anos e 2 meses');
-    //@ts-ignore
-    t.equal(formats.friendlyDate('d'), '');
-    t.equal(formats.friendlyDate(null), '');
-    t.end();
-});
-
-test('\nformats.duration', t => {
-    t.equal(formats.duration(100), 'poucos segundos');
-    t.equal(formats.duration(1000), 'poucos segundos');
-    t.equal(formats.duration(30000), 'poucos segundos');
-    t.equal(formats.duration(59999), 'um minuto');
-    t.equal(formats.duration(60000), 'um minuto');
-    t.equal(formats.duration(3600000), 'uma hora');
-    t.equal(formats.duration(86400000), 'um dia');
-    t.end();
-});

package/lib/tests/test_invests.js

@@ -1,26 +0,0 @@
-const test = require('tape');
-const invests = require('../utils/invests');
-
-test('\ninvests - i', t => {
-    let xData = {};
-    xData = { n: 24, pv: 2500000, pmt: -217972.55, fv: 0, type: 0 };
-    t.equal(invests.i(xData), 6.9999999);
-    xData = { n: 24, pv: 2500000, pmt: -217972.55, fv: 1000000, type: 0 };
-    t.equal(invests.i(xData), 5.94256711);
-    xData = { n: 24, pv: 1000000, pmt: -217972.55, fv: 0, type: 0 };
-    t.equal(invests.i(xData), 21.59763755);
-    t.end();
-});
-
-test('\ninvests - fv', t => {
-    let xData = {};
-    xData = { n: 12, pv: 400, pmt: -1040, i: 3, type: 0 };
-    t.equal(invests.fv(xData), 14189.40638926);
-    xData = { n: 12, pv: 0, pmt: -1040, i: 3, type: 0 };
-    t.equal(invests.fv(xData), 14759.710744);
-    xData = { n: 12, pv: 0, pmt: -1040, i: -3, type: 0 };
-    t.equal(invests.fv(xData), 10613.46481882);
-    xData = { n: 12, pv: 400, pmt: 1040, i: 3, type: 0 };
-    t.equal(invests.fv(xData), -15330.01509874);
-    t.end();
-});

package/lib/tests/test_messages.js

@@ -1,11 +0,0 @@
-const test = require('tape');
-
-const { CreatedMessage } = require('../messages/Success');
-const { BasicMessageSuccess } = require('../messages/BasicMessages');
-
-console.log(new CreatedMessage() instanceof BasicMessageSuccess);
-
-test('\nmessage', t => {
-    t.equal(new CreatedMessage() instanceof BasicMessageSuccess, true);
-    t.end();
-});

package/lib/tests/test_numbers.js

@@ -1,81 +0,0 @@
-const test = require('tape');
-
-const numbers = require('../utils/numbers');
-
-test('\nnumbers weightedMean', t => {
-    t.equal(numbers.weightedMean([300, 100, 10], [10, 20, 50]), 68.75);
-    t.end();
-});
-
-test('\nnumbers onlyNumbers', t => {
-    t.equal(numbers.onlyNumbers('00.332.123/0001-33'), '00332123000133');
-    t.equal(numbers.onlyNumbers(''), '');
-    t.equal(numbers.onlyNumbers(null), null);
-    t.equal(numbers.onlyNumbers('"#1.3.45678+-2'), '13456782');
-    t.end();
-});
-
-test('\nnumbers apart', t => {
-    t.deepEqual(numbers.apart(1.12), { sign: '', int: '1', dec: '12' });
-    t.deepEqual(numbers.apart(1.123456789012345678), {
-        sign: '',
-        int: '1',
-        dec: '1234567890123457'
-    });
-    t.deepEqual(numbers.apart(-1.123456789012345678), {
-        sign: '-',
-        int: '1',
-        dec: '1234567890123457'
-    });
-    t.end();
-});
-
-test('\nnumbers add', t => {
-    t.equal(numbers.add(1.13, 1.12), 2.25);
-    t.equal(numbers.add(1.000000013, 1.000000012), 2.000000025);
-    t.equal(numbers.add(1234.5689012345, 4.5689012345), 1239.137802469);
-    t.equal(numbers.add(-1.4689012345, -3314.5689012345), -3316.037802469);
-    t.equal(numbers.add(0.00000000001, 0.1), 0.10000000001);
-    t.equal(numbers.add(0.00000000001, 0.0000000001), 0.00000000011);
-    t.equal(numbers.add(0.000000000013, -0.000000000014), -0.000000000001);
-    t.equal(numbers.add(1234567890.123, 1.12), 1234567891.243);
-    t.end();
-});
-
-test('\nnumbers sub', t => {
-    t.equal(numbers.sub(1.13, 1.12), 0.01);
-    t.equal(numbers.sub(1.000000013, 1.000000012), 0.000000001);
-    t.equal(numbers.sub(1234.5689012345, 4.5689012345), 1230);
-    t.equal(numbers.sub(12.5689012345, -3314.5689012345), 3327.137802469);
-    t.equal(numbers.sub(0.00000000001, 0.1), -0.09999999999);
-    t.equal(numbers.sub(0.00000000001, -0.0000000001), 0.00000000011);
-    t.equal(numbers.sub(0.000000000013, 0.000000000014), -0.000000000001);
-    t.equal(numbers.sub(-1234567890.123, 1.12), -1234567891.243);
-    t.end();
-});
-
-test('\nnumbers mul', t => {
-    t.equal(numbers.mul(-2.2, -2.1), 4.62);
-    t.equal(numbers.mul(1.1, 1.1), 1.21);
-    t.equal(numbers.mul(3, 0.15), 0.45);
-    t.equal(numbers.mul(-0.000001, 1.01), -0.00000101);
-    t.equal(numbers.mul(244.123, 13), 3173.599);
-    t.equal(numbers.mul(1.123, 12), 13.476);
-    t.equal(numbers.mul(12.4344, 1.1), 13.67784);
-    t.equal(numbers.mul(0.4344, 0.0021), 0.00091224);
-    t.equal(numbers.mul(10.4344, 0.00021), 0.002191224);
-    t.equal(numbers.mul(2, 4.01), 8.02);
-    t.equal(numbers.mul(12345679.012, 1.021), 12604938.271252);
-    t.equal(numbers.mul(4.300000000000001, 5), 21.500000000000004);
-    t.equal(numbers.mul(4.0001, 5.0002), 20.00130002);
-    t.equal(numbers.mul(4.0001, 5.0002), 20.00130002);
-    t.equal(numbers.mul(2357.12345679, 1234567), 2910026834.6788597);
-    t.equal(numbers.mul(-0.123456789012345678901, -1230.123456789012345678901), 151.86709206393846); //151.86709206393883 = Se fosse bigDecimal
-    t.end();
-});
-
-test('\nnumbers div', t => {
-    t.equal(numbers.div(1222.1, 0.00000001), 122210000000);
-    t.equal(numbers.div(1.001, 1.1), 0.91);
-    t.end();
-});

package/lib/tests/test_objects.js

@@ -1,16 +0,0 @@
-const test = require('tape');
-const objects = require('../utils/objects');
-const object = {
-    nome: 'investira',
-    endereco: {
-        logradouro: 'Praia de Botafogo',
-        numero: 501
-    },
-    telefone: '(21) 2586-6322'
-};
-
-test('\ngetSize', t => {
-    const xObject = { ...object };
-    t.equal(objects.getSize(xObject), 3);
-    t.end();
-});

package/lib/tests/test_spellChecker.js

@@ -1,42 +0,0 @@
-const test = require('tape');
-
-const spellChecker = require('../utils/spellChecker');
-
-spellChecker.locale = 'br';
-test('\ncheck', t => {
-    t.equal(
-        spellChecker.check('Volnor Industria E Comercio Sa'),
-        'Volnor Indústria e Comércio S.A.'
-    );
-    t.equal(
-        spellChecker.check(
-            'Viver Incorp. E Construtora S.a.- Em Recuperação Judicial'
-        ),
-        'Viver Incorp. e Construtora S.A. em Recuperação Judicial'
-    );
-    t.equal(
-        spellChecker.check('Xx De Novembro Investimentos E Participações S.a'),
-        'XX de Novembro Investimentos e Participações S.A.'
-    );
-    t.equal(
-        spellChecker.check('Banco Do Estado De Sao Paulo S.a. - Banespa'),
-        'Banco do Estado de São Paulo S.A. - Banespa'
-    );
-    t.equal(
-        spellChecker.check('Sperb Do Ne Sa Ind Textil'),
-        'Sperb do Ne S.A. Indústria Textil'
-    );
-    t.equal(
-        spellChecker.check('São Carlos Empreends E Participações S.a'),
-        'São Carlos Empreendimentos e Participações S.A.'
-    );
-    t.equal(
-        spellChecker.check('Inds De Bebs Joaquim T A F Sa'),
-        'Indústria de Bebidas Joaquim T A F S.A.'
-    );
-    t.equal(
-        spellChecker.check('Cia Indl Schlosser Sa - Em Recuperação Judicial'),
-        'Cia Industrial Schlosser S.A. - em Recuperação Judicial'
-    );
-    t.end();
-});

package/lib/tests/test_strings.js

@@ -1,46 +0,0 @@
-const test = require('tape');
-
-const strings = require('../utils/strings');
-
-test('\nsplitFullName', t => {
-    t.deepEqual(strings.splitFullName('Robert Mariano de faria silva e souza'), {
-        first: 'Robert',
-        middle: 'Mariano de Faria Silva e',
-        last: 'Souza'
-    });
-    t.deepEqual(strings.splitFullName('Investira Soluções'), {
-        first: 'Investira',
-        middle: null,
-        last: 'Soluções'
-    });
-    t.end();
-});
-
-test('\nquerystringToObject', t => {
-    t.deepEqual(strings.querystringToObject('api/v1/metas/?meta_status=A,I,R&page=1&size=8'), {
-        meta_status: 'A,I,R',
-        page: '1',
-        size: '8'
-    });
-    t.end();
-});
-
-test('\ntoTitleCase', t => {
-    t.deepEqual(strings.toTitleCase('Robert mariano de faria silva e souza'), 'Robert Mariano de Faria Silva e Souza');
-    t.deepEqual(strings.toTitleCase('Investira soluções'), 'Investira Soluções');
-    t.deepEqual(strings.toTitleCase('maRtin lutHer king III'), 'Martin Luther King III');
-    t.deepEqual(strings.toTitleCase('maRtin lutHer king iv'), 'Martin Luther King IV');
-    t.deepEqual(strings.toTitleCase('joão adalberto da silva álves'), 'João Adalberto da Silva Álves');
-    t.deepEqual(strings.toTitleCase("Alberto D'avila"), "Alberto D'Avila");
-    t.deepEqual(strings.toTitleCase('Alberto D`avila'), 'Alberto D`Avila');
-    t.deepEqual(strings.toTitleCase('F.a.e.'), 'F.A.E.');
-    t.end();
-});
-
-test('\nwhitespacesCleaner', t => {
-    t.deepEqual(
-        strings.whitespacesCleaner(' Robert     mariano de     faria  silva e  souza '),
-        'Robert mariano de faria silva e souza'
-    );
-    t.end();
-});

package/lib/tests/test_validators.js

@@ -1,49 +0,0 @@
-const test = require('tape');
-
-const validators = require('../utils/validators');
-
-test('\nvalidators.isEmail', t => {
-    t.equal(validators.isEmail('12345678'), false);
-    t.equal(validators.isEmail('1234@5678'), false);
-    t.equal(validators.isEmail('1234@5678.'), false);
-    t.equal(validators.isEmail('1234@5678.v'), false);
-    t.equal(validators.isEmail('1234@5678.vc'), true);
-    t.equal(validators.isEmail('1234@5678.us'), true);
-    t.equal(validators.isEmail('123@asdocm.com.br'), true);
-    t.equal(validators.isEmail('wedweasdocm.com.br'), false);
-    t.end();
-});
-
-test('\nvalidators.isTrue', t => {
-    t.equal(validators.isTrue('1'), true);
-    t.equal(validators.isTrue('-1'), true);
-    t.equal(validators.isTrue(-1), true);
-    t.equal(validators.isTrue(1), true);
-    t.equal(validators.isTrue(true), true);
-    t.equal(validators.isTrue('true'), true);
-    t.equal(validators.isTrue('True'), true);
-    t.equal(validators.isTrue(2), false);
-    t.equal(validators.isTrue(), false);
-    t.equal(validators.isTrue(null), false);
-    t.equal(validators.isTrue(0), false);
-    t.equal(validators.isTrue('0'), false);
-    t.equal(validators.isTrue({}), false);
-    t.equal(validators.isTrue(undefined), false);
-    t.equal(validators.isTrue('-12'), false);
-    t.equal(validators.isTrue('false'), false);
-    t.equal(validators.isTrue(false), false);
-    t.end();
-});
-
-test('\nvalidators.isNumber', t => {
-    t.equal(validators.isNumber(1), true);
-    t.equal(validators.isNumber(-1), true);
-    t.equal(validators.isNumber(0), true);
-    t.equal(validators.isNumber('1'), false);
-    t.equal(validators.isNumber('-1'), false);
-    t.equal(validators.isNumber(1.5), true);
-    t.equal(validators.isNumber('1.5'), false);
-    t.equal(validators.isNumber('1,5'), false);
-    t.equal(validators.isNumber(NaN), false);
-    t.end();
-});