@excofy/utils 2.4.0 → 2.5.1

package/dist/index.cjs

@@ -36,6 +36,7 @@ __export(index_exports, {
   cryptoUtils: () => cryptoUtils,
   generateCode: () => generateCode,
   htmlEntityDecode: () => htmlEntityDecode,
+  htmlToPlainText: () => sanitizeValue,
   numberUtils: () => number_exports,
   slugUtils: () => slug_exports,
   stringUtils: () => stringUtils
@@ -809,6 +810,19 @@ async function verifyDeterministicHash(inputCode, storedHash, secret) {
 }
 var cryptoUtils = {
   uuidV4: () => crypto.randomUUID(),
+  ulid: () => {
+    function randomChar() {
+      const chars = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+      return chars[Math.floor(Math.random() * chars.length)];
+    }
+    const timestamp = Date.now();
+    const timestampStr = timestamp.toString(36).toUpperCase().padStart(10, "0");
+    let randomPart = "";
+    for (let i = 0; i < 16; i++) {
+      randomPart += randomChar();
+    }
+    return timestampStr + randomPart;
+  },
   hash: async (password, salt = 10) => {
     const importedKey = await crypto.subtle.importKey(
       "raw",
@@ -960,6 +974,7 @@ var divide = (numerator, denominator) => {
   cryptoUtils,
   generateCode,
   htmlEntityDecode,
+  htmlToPlainText,
   numberUtils,
   slugUtils,
   stringUtils

package/dist/index.d.cts

@@ -6,6 +6,7 @@ type AllowedTag = Tag | {
     tag: Tag;
     attributes?: Attributes[];
 };
+declare function sanitizeValue(value: string, allowedTags?: AllowedTag[]): string;
 declare function htmlEntityDecode(str?: string): string;
 
 type TMessage = {
@@ -122,6 +123,7 @@ interface IValidateAccessToken {
 }
 interface ICrypto {
     uuidV4: () => string;
+    ulid: () => string;
     hash: (password: string, salt: number) => Promise<string>;
     isMatch: (password: string, hash: string, salt?: number) => Promise<boolean>;
     generateAccessToken: (data: IGenerateAccessToken) => Promise<string>;
@@ -240,4 +242,4 @@ declare class ExpiredTokenError extends CryptoError {
     constructor(message?: string);
 }
 
-export { ExpiredTokenError, InvalidTokenError, createValidator, cryptoUtils, generateCode, htmlEntityDecode, number as numberUtils, slug as slugUtils, stringUtils };
+export { ExpiredTokenError, InvalidTokenError, createValidator, cryptoUtils, generateCode, htmlEntityDecode, sanitizeValue as htmlToPlainText, number as numberUtils, slug as slugUtils, stringUtils };

package/dist/index.d.ts

@@ -6,6 +6,7 @@ type AllowedTag = Tag | {
     tag: Tag;
     attributes?: Attributes[];
 };
+declare function sanitizeValue(value: string, allowedTags?: AllowedTag[]): string;
 declare function htmlEntityDecode(str?: string): string;
 
 type TMessage = {
@@ -122,6 +123,7 @@ interface IValidateAccessToken {
 }
 interface ICrypto {
     uuidV4: () => string;
+    ulid: () => string;
     hash: (password: string, salt: number) => Promise<string>;
     isMatch: (password: string, hash: string, salt?: number) => Promise<boolean>;
     generateAccessToken: (data: IGenerateAccessToken) => Promise<string>;
@@ -240,4 +242,4 @@ declare class ExpiredTokenError extends CryptoError {
     constructor(message?: string);
 }
 
-export { ExpiredTokenError, InvalidTokenError, createValidator, cryptoUtils, generateCode, htmlEntityDecode, number as numberUtils, slug as slugUtils, stringUtils };
+export { ExpiredTokenError, InvalidTokenError, createValidator, cryptoUtils, generateCode, htmlEntityDecode, sanitizeValue as htmlToPlainText, number as numberUtils, slug as slugUtils, stringUtils };

package/dist/index.js

@@ -771,6 +771,19 @@ async function verifyDeterministicHash(inputCode, storedHash, secret) {
 }
 var cryptoUtils = {
   uuidV4: () => crypto.randomUUID(),
+  ulid: () => {
+    function randomChar() {
+      const chars = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+      return chars[Math.floor(Math.random() * chars.length)];
+    }
+    const timestamp = Date.now();
+    const timestampStr = timestamp.toString(36).toUpperCase().padStart(10, "0");
+    let randomPart = "";
+    for (let i = 0; i < 16; i++) {
+      randomPart += randomChar();
+    }
+    return timestampStr + randomPart;
+  },
   hash: async (password, salt = 10) => {
     const importedKey = await crypto.subtle.importKey(
       "raw",
@@ -921,6 +934,7 @@ export {
   cryptoUtils,
   generateCode,
   htmlEntityDecode,
+  sanitizeValue as htmlToPlainText,
   number_exports as numberUtils,
   slug_exports as slugUtils,
   stringUtils

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@excofy/utils",
-  "version": "2.4.0",
+  "version": "2.5.1",
   "description": "Biblioteca de utilitários para o Excofy",
   "main": "dist/index.js",
   "type": "module",
@@ -32,7 +32,7 @@
   "devDependencies": {
     "@biomejs/biome": "^1.9.4",
     "@types/big.js": "^6.2.2",
-    "@types/node": "^24.0.3",
+    "@types/node": "^24.10.13",
     "tsup": "^8.5.0",
     "tsx": "^4.20.4",
     "typescript": "^5.8.3"

package/src/helpers/crypto.ts

@@ -17,6 +17,7 @@ interface IValidateAccessToken {
 
 interface ICrypto {
   uuidV4: () => string;
+  ulid: () => string;
   hash: (password: string, salt: number) => Promise<string>;
   isMatch: (password: string, hash: string, salt?: number) => Promise<boolean>;
   generateAccessToken: (data: IGenerateAccessToken) => Promise<string>;
@@ -34,7 +35,7 @@ interface ICrypto {
   verifyDeterministicHash: (
     inputCode: string,
     storedHash: string,
-    secret: string
+    secret: string,
   ) => Promise<boolean>;
 }
 
@@ -54,7 +55,7 @@ const signatureKey = async (AUTH_SIGN_SECRET: string) =>
     encoder.encode(AUTH_SIGN_SECRET),
     { name: 'HMAC', hash: 'SHA-256' },
     false,
-    ['sign', 'verify']
+    ['sign', 'verify'],
   );
 
 const payloadKey = async (AUTH_PAYLOAD_SECRET: string) =>
@@ -63,7 +64,7 @@ const payloadKey = async (AUTH_PAYLOAD_SECRET: string) =>
     encoder.encode(AUTH_PAYLOAD_SECRET.substring(0, 32)),
     { name: 'AES-GCM', length: 256 },
     true,
-    ['encrypt', 'decrypt']
+    ['encrypt', 'decrypt'],
   );
 
 /* --------------------- Payload (encrypt/decrypt) --------------------- */
@@ -80,7 +81,7 @@ const encryptPayload = async ({
   const buffer = await crypto.subtle.encrypt(
     { name: 'AES-GCM', iv },
     key,
-    encoder.encode(payload)
+    encoder.encode(payload),
   );
 
   return `${toBase64(iv)}.${toBase64(buffer)}`;
@@ -99,7 +100,7 @@ const decryptPayload = async ({
   const buffer = await crypto.subtle.decrypt(
     { name: 'AES-GCM', iv: fromBase64(header).buffer as ArrayBuffer },
     key,
-    fromBase64(payload).buffer as ArrayBuffer
+    fromBase64(payload).buffer as ArrayBuffer,
   );
 
   return decoder.decode(buffer);
@@ -115,14 +116,14 @@ const decryptPayload = async ({
  */
 export async function generateDeterministicHash(
   code: string,
-  secret: string
+  secret: string,
 ): Promise<string> {
   const key = await crypto.subtle.importKey(
     'raw',
     encoder.encode(secret),
     { name: 'HMAC', hash: 'SHA-256' },
     false,
-    ['sign']
+    ['sign'],
   );
 
   const signature = await crypto.subtle.sign('HMAC', key, encoder.encode(code));
@@ -143,7 +144,7 @@ export async function generateDeterministicHash(
 export async function verifyDeterministicHash(
   inputCode: string,
   storedHash: string,
-  secret: string
+  secret: string,
 ): Promise<boolean> {
   const hash = await generateDeterministicHash(inputCode, secret);
   return hash === storedHash;
@@ -153,13 +154,30 @@ export async function verifyDeterministicHash(
 export const cryptoUtils: ICrypto = {
   uuidV4: (): string => crypto.randomUUID(),
 
+  ulid: (): string => {
+    function randomChar() {
+      const chars = '0123456789ABCDEFGHJKMNPQRSTVWXYZ'; // Crockford's Base32
+      return chars[Math.floor(Math.random() * chars.length)];
+    }
+
+    const timestamp = Date.now();
+    const timestampStr = timestamp.toString(36).toUpperCase().padStart(10, '0');
+
+    let randomPart = '';
+    for (let i = 0; i < 16; i++) {
+      randomPart += randomChar();
+    }
+
+    return timestampStr + randomPart;
+  },
+
   hash: async (password: string, salt = 10): Promise<string> => {
     const importedKey = await crypto.subtle.importKey(
       'raw',
       encoder.encode(password),
       { name: 'PBKDF2' },
       false,
-      ['deriveBits']
+      ['deriveBits'],
     );
 
     const derivedKey = await crypto.subtle.deriveBits(
@@ -170,7 +188,7 @@ export const cryptoUtils: ICrypto = {
         hash: 'SHA-256',
       },
       importedKey,
-      256
+      256,
     );
 
     return Array.from(new Uint8Array(derivedKey))
@@ -200,7 +218,7 @@ export const cryptoUtils: ICrypto = {
     const signatureBuffer = await crypto.subtle.sign(
       'HMAC',
       key,
-      encoder.encode(payload)
+      encoder.encode(payload),
     );
     const signature = toBase64(signatureBuffer);
 
@@ -227,7 +245,7 @@ export const cryptoUtils: ICrypto = {
         'HMAC',
         key,
         fromBase64(signature).buffer as ArrayBuffer,
-        encoder.encode(payloadDecrypted)
+        encoder.encode(payloadDecrypted),
       );
 
       if (!valid) throw new Error('Invalid access token');

package/src/index.ts

@@ -1,5 +1,8 @@
 import { createValidator } from './helpers/validator';
-import { htmlEntityDecode } from './helpers/sanitize';
+import {
+  htmlEntityDecode,
+  sanitizeValue as htmlToPlainText,
+} from './helpers/sanitize';
 import { generateCode } from './helpers/generateCode';
 import { stringUtils } from './helpers/string';
 import { cryptoUtils } from './helpers/crypto';
@@ -9,6 +12,7 @@ import * as numberUtils from './helpers/number';
 export {
   createValidator,
   htmlEntityDecode,
+  htmlToPlainText,
   slugUtils,
   numberUtils,
   stringUtils,

package/tests/helpers/validator.spec.ts

@@ -0,0 +1,75 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { createValidator } from '../../src/helpers/validator';
+
+describe('validator', () => {
+  describe('asNumber', () => {
+    it('deve converter uma string "10" para o número 10', () => {
+      type InputRaw = { limit: string };
+      type InputParsed = { limit: number };
+
+      const v = createValidator<InputRaw, InputParsed>();
+      v.setInputs({ limit: '10' });
+      v.validate('limit')
+        .isRequired('Limite é obrigatório')
+        .type('string', 'Limite deve ser uma string')
+        .asNumber('Limite deve ser um número válido');
+
+      const inputs = v.getSanitizedInputs();
+
+      assert.equal(inputs.limit, 10);
+      assert.equal(typeof inputs.limit, 'number');
+      assert.equal(v.hasErrors(), false);
+    });
+
+    it('deve adicionar erro quando o valor não pode ser convertido para número', () => {
+      type InputRaw = { limit: string };
+      type InputParsed = { limit: number };
+
+      const v = createValidator<InputRaw, InputParsed>();
+      v.setInputs({ limit: 'abc' });
+      v.validate('limit')
+        .isRequired('Limite é obrigatório')
+        .type('string', 'Limite deve ser uma string')
+        .asNumber('Limite deve ser um número válido');
+
+      assert.equal(v.hasErrors(), true);
+      const errors = v.getFlatErrors();
+      assert.equal(errors.limit[0].message, 'Limite deve ser um número válido');
+    });
+
+    it('deve converter um número diretamente', () => {
+      type InputRaw = { limit: number };
+      type InputParsed = { limit: number };
+
+      const v = createValidator<InputRaw, InputParsed>();
+      v.setInputs({ limit: 25 });
+      v.validate('limit')
+        .isRequired('Limite é obrigatório')
+        .type('number', 'Limite deve ser um número')
+        .asNumber('Limite deve ser um número válido');
+
+      const inputs = v.getSanitizedInputs();
+
+      assert.equal(inputs.limit, 25);
+      assert.equal(typeof inputs.limit, 'number');
+      assert.equal(v.hasErrors(), false);
+    });
+
+    it('deve lidar com valores opcionais quando não fornecidos', () => {
+      type InputRaw = { limit?: string };
+      type InputParsed = { limit?: number };
+
+      const v = createValidator<InputRaw, InputParsed>();
+      v.setInputs({});
+      v.validate('limit')
+        .isNotRequired()
+        .type('string', 'Limite deve ser uma string')
+        .asNumber('Limite deve ser um número válido');
+
+      assert.equal(v.hasErrors(), false);
+      const inputs = v.getSanitizedInputs();
+      assert.equal(inputs.limit, undefined);
+    });
+  });
+});

package/tsconfig.json

@@ -11,7 +11,8 @@
     "strict": true,
     "skipLibCheck": true,
     "resolveJsonModule": true,
-    "isolatedModules": true
+    "isolatedModules": true,
+    "types": ["node"]
   },
   "include": ["src", "tests"],
   "exclude": ["dist", "node_modules", "**/*.test.ts"]