investira.sdk 2.4.30 → 2.4.32

package/.rgignore

@@ -0,0 +1,4 @@
+node_modules
+dist
+build
+coverage

package/CHANGELOG.md

@@ -649,3 +649,7 @@ O contrutor para a criação das mensagem foi alterado.
 # 2.4.30
 
 -   [formats] toBytes para converter bytes em formato legível
+
+# 2.4.31
+
+-   [rags] Novas funções de alias para embedding

package/index.js

@@ -9,6 +9,7 @@ module.exports.invests = require('./lib/utils/invests');
 module.exports.numbers = require('./lib/utils/numbers');
 module.exports.objects = require('./lib/utils/objects');
 module.exports.strings = require('./lib/utils/strings');
+module.exports.rags = require('./lib/utils/rags');
 module.exports.responses = require('./lib/utils/responses');
 module.exports.validators = require('./lib/utils/validators');
 module.exports.spellChecker = require('./lib/utils/spellChecker');

package/lib/utils/rags.js

@@ -0,0 +1,230 @@
+// const { dataHolidays } = require('investira.data');
+// @ts-ignore
+// const moment = require('moment/min/moment-with-locales');
+// const numbers = require('./numbers');
+// const { isEmpty, isNull, isNumber, isDate, isFunction } = require('./validators');
+
+
+moment.suppressDeprecationWarnings = true;
+
+const rags = {
+    /**
+     * Extrai aliases sem acentuação para tokens com diacríticos.
+     *
+     * Mantém apenas tokens cujo texto muda após remover acentos para reduzir ruído.
+     *
+     * @private
+     * @param {string} pText - Texto a processar
+     * @returns {string[]} Aliases sem acentuação
+     */
+    extractAccentlessAliases: pText => {
+        const xAliases = new Set();
+        const xTokens = String(pText || '').match(/[A-Za-zÀ-ÖØ-öø-ÿ0-9_/-]+/g) || [];
+
+        for (const xTokenRaw of xTokens) {
+            const xToken = String(xTokenRaw || '').trim();
+            if (!xToken || !/[À-ÖØ-öø-ÿ]/.test(xToken)) {
+                continue;
+            }
+
+            const xAccentlessToken = xToken
+                .normalize('NFD')
+                .replace(/[\u0300-\u036f]/g, '');
+
+            if (!xAccentlessToken || xAccentlessToken === xToken) {
+                continue;
+            }
+
+            xAliases.add(xAccentlessToken);
+        }
+
+        return [...xAliases].slice(0, 120);
+    },
+
+    /**
+     * Extrai aliases numéricos com delimitadores de milhares.
+     *
+     * @private
+     * @param {string} pText - Texto a processar
+     * @returns {string[]} Aliases numéricos
+     */
+    extractNumericAliases: pText => {
+        const xAliases = new Set();
+        const xMatches = String(pText || '').matchAll(/\b(?:\d{1,3}(?:[.\s]\d{3})+|\d{4,})\b/g);
+
+        for (const xMatch of xMatches) {
+            const xToken = String(xMatch?.[0] || '').trim();
+            if (!xToken) {
+                continue;
+            }
+
+            const xDigits = xToken.replace(/[^\d]/g, '');
+            if (xDigits.length < 4) {
+                continue;
+            }
+
+            const xDotVariant = pvFormatThousandsWithDelimiter(xDigits, '.');
+
+            xAliases.add(xDigits);
+            if (xDotVariant) {
+                xAliases.add(xDotVariant);
+            }
+        }
+
+        return [...xAliases];
+    },
+    /**
+     * Extrai aliases de datas do texto.
+     *
+     * @private
+     * @param {string} pText - Texto a processar
+     * @returns {string[]} Aliases de datas encontradas
+     */
+    extractDateAliases: pText => {
+        const xAliases = new Set();
+        const xText = String(pText || '');
+
+        const xDmyMatches = xText.matchAll(/\b(\d{1,2})[./-](\d{1,2})[./-](\d{2,4})\b/g);
+        for (const xMatch of xDmyMatches) {
+            const xVariants = pvBuildDateAliasesFromParts({
+                day: xMatch?.[1],
+                month: xMatch?.[2],
+                year: xMatch?.[3]
+            });
+            xVariants.forEach(rVariant => xAliases.add(rVariant));
+        }
+
+        const xYmdMatches = xText.matchAll(/\b(\d{4})[./-](\d{1,2})[./-](\d{1,2})\b/g);
+        for (const xMatch of xYmdMatches) {
+            const xVariants = pvBuildDateAliasesFromParts({
+                day: xMatch?.[3],
+                month: xMatch?.[2],
+                year: xMatch?.[1]
+            });
+            xVariants.forEach(rVariant => xAliases.add(rVariant));
+        }
+
+        return [...xAliases];
+    },
+    /**
+    * Extrai aliases canônicos para códigos com separadores.
+    *
+    * Exemplos:
+    * - NTN-B -> NTNB
+    * - LCI-2029 -> LCI2029
+    * - ABC/12 -> ABC12
+    *
+    * Não gera aliases com espaços.
+    *
+    * @private
+    * @param {string} pText - Texto a processar
+    * @returns {string[]} Aliases de códigos encontrados
+     */
+    extractAlphanumericCodeAliases: pText => {
+        const xAliases = new Set();
+        const xMatches = String(pText || '').matchAll(/\b(?=[A-Za-z0-9./-]*[A-Za-z])[A-Za-z0-9]+(?:[-./][A-Za-z0-9]+)+\b/g);
+
+        for (const xMatch of xMatches) {
+            const xToken = String(xMatch?.[0] || '').trim().toUpperCase();
+            if (!xToken) {
+                continue;
+            }
+
+            const xCanonicalToken = xToken.replace(/[-./]/g, '');
+            if (!xCanonicalToken || xCanonicalToken === xToken) {
+                continue;
+            }
+
+            xAliases.add(xCanonicalToken);
+        }
+
+        return [...xAliases];
+    }
+
+};
+
+module.exports = rags;
+
+/**
+ * Formata números com delimitador de milhares.
+ * 
+ * @private
+ * @param {string|number} pDigits - Dígitos a formatar
+ * @param {string} [pDelimiter='.'] - Delimitador a ser usado
+ * @returns {string} Número formatado
+ */
+const pvFormatThousandsWithDelimiter = (pDigits, pDelimiter) => {
+    const xRawDigits = String(pDigits || '').replace(/[^\d]/g, '');
+    if (xRawDigits.length < 4) {
+        return xRawDigits;
+    }
+
+    const xNormalizedDigits = xRawDigits.replace(/^0+(\d)/, '$1');
+    const xDelimiter = typeof pDelimiter === 'string' ? pDelimiter : '.';
+    return xNormalizedDigits.replace(/\B(?=(\d{3})+(?!\d))/g, xDelimiter);
+};
+
+
+/**
+ * Constrói aliases de datas a partir de partes.
+ *
+ * @private
+ * @param {Object} pParts - Partes da data
+ * @param {string} pParts.day - Dia
+ * @param {string} pParts.month - Mês
+ * @param {string} pParts.year - Ano
+ * @returns {string[]} Aliases de datas construídos
+ */
+const pvBuildDateAliasesFromParts = ({ day, month, year }) => {
+    const xAliases = new Set();
+
+    const xRawDay = String(day || '').trim();
+    const xRawMonth = String(month || '').trim();
+    const xRawYear = String(year || '').trim();
+
+    // Converte para número apenas quando o conteúdo é realmente numérico.
+    const xDayNumber = /^\d{1,2}$/.test(xRawDay) ? Number(xRawDay) : null;
+    const xMonthNumber = /^\d{1,2}$/.test(xRawMonth) ? Number(xRawMonth) : null;
+    const xYearLength = xRawYear.length === 2 ? 2 : xRawYear.length === 4 ? 4 : 0;
+    const xYearNumber = xYearLength && /^\d+$/.test(xRawYear) ? Number(xRawYear) : null;
+
+    const xHasValidDay = Number.isInteger(xDayNumber) && xDayNumber >= 1 && xDayNumber <= 31;
+    const xHasValidMonth = Number.isInteger(xMonthNumber) && xMonthNumber >= 1 && xMonthNumber <= 12;
+    const xHasValidYear = Number.isInteger(xYearNumber);
+
+    const xDay = xHasValidDay ? String(xDayNumber).padStart(2, '0') : null;
+    const xMonth = xHasValidMonth ? String(xMonthNumber).padStart(2, '0') : null;
+    const xYear = xHasValidYear ? String(xYearNumber).padStart(xYearLength, '0') : null;
+    let xHasValidDayMonthCombo = false;
+    if (xYearLength === 4 && xDay && xMonth && xYear && xHasValidDayMonthCombo) {
+        xAliases.add(`${xYear}-${xMonth}-${xDay}`);
+        xAliases.add(`${xYear}/${xMonth}/${xDay}`);
+        xAliases.add(`${xYear}.${xMonth}.${xDay}`);
+        xAliases.add(`${xYear}${xMonth}${xDay}`);
+        xAliases.add(`${xDay}-${xMonth}-${xYear}`);
+        xAliases.add(`${xDay}/${xMonth}/${xYear}`);
+        xAliases.add(`${xDay}.${xMonth}.${xYear}`);
+        xAliases.add(`${xDay}${xMonth}${xYear}`);
+    } else if (xDay && xMonth) {
+        xAliases.add(`${xDay}/${xMonth}`);
+        xAliases.add(`${xDay}-${xMonth}`);
+        xAliases.add(`${xDay}.${xMonth}`);
+        xAliases.add(`${xDay}${xMonth}`);
+    } else if (xMonth && xYear) {
+        if (xYearLength === 4) {
+            xAliases.add(`${xYear}-${xMonth}`);
+            xAliases.add(`${xYear}/${xMonth}`);
+            xAliases.add(`${xYear}.${xMonth}`);
+            xAliases.add(`${xYear}${xMonth}`);
+        } else {
+            xAliases.add(`${xMonth}/${xYear}`);
+            xAliases.add(`${xMonth}-${xYear}`);
+            xAliases.add(`${xMonth}.${xYear}`);
+            xAliases.add(`${xMonth}${xYear}`);
+        }
+    } else if (xYear && !xAliases.size) {
+        xAliases.add(xYear);
+    }
+
+    return [...xAliases];
+};

package/package.json

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