@jmlq/logger 0.1.0-alpha.6 → 0.1.0-alpha.7

package/README.md

@@ -103,7 +103,7 @@ src/
 export type PiiReplacement = {
   pattern: string;
   replaceWith: string;
-  flags?: string;
+  flags?: string; // regex (g, i, m, s, u, y)
 };
 
 export interface PiiConfig {
@@ -123,6 +123,7 @@ export const DEFAULT_PII_PATTERNS: PiiReplacement[] = [
     flags: "g",
   },
 ];
+// Ver abajo explicación flags
 
 // patrones “del cliente/proyecto”:
 export const clientPiiPatterns: PiiReplacement[] = [
@@ -183,6 +184,194 @@ export function buildPiiConfig(
 }
 ```
 
+> - **REGEX FLAGS**
+
+> > - `g` (**global**): Encuentra `todas las coincidencias` en el texto, no solo la primera.
+
+```ts
+const regex = /\d{2}/g;
+"123456".match(regex); // ["12", "34", "56"]
+
+// /\d{2}/ busca pares de dígitos.
+// "12" en índices 0-1
+// "34" en índices 2-3
+// "56" en índices 4-5
+```
+
+> > - `i` (**ignore case**): Ignora mayúsculas/minúsculas.
+
+```ts
+// Sin "i" (sensible a mayúsculas/minúsculas)
+const regexCaseSensitive = /secret/;
+"SECRET".match(regexCaseSensitive); // null
+"secret".match(regexCaseSensitive); // ["secret"]
+
+// Con "i" (ignora mayúsculas/minúsculas)
+const regexIgnoreCase = /secret/i;
+"SECRET".match(regexIgnoreCase); // ["SECRET"]
+"Secret".match(regexIgnoreCase); // ["Secret"]
+"sEcReT".match(regexIgnoreCase); // ["sEcReT"]
+```
+
+> > - `m` (**multiline**): Permite que `^` y `$` funcionen en cada línea, no solo al inicio/fin del string completo.
+
+```ts
+const texto = `uno
+FOO
+tres`;
+
+// Sin "m": ^ solo reconoce el inicio de *todo* el string
+const regexNormal = /^FOO/;
+console.log(texto.match(regexNormal)); // null
+
+// Con "m": ^ reconoce también el inicio de cada línea
+const regexMultiline = /^FOO/m;
+console.log(texto.match(regexMultiline)); // ["FOO"]
+```
+
+> > - `s` (**dotAll**): Permite que `.` coincida también con saltos de línea (`\n`).
+
+```ts
+const texto = "a\nb";
+
+// Sin "s": el punto (.) no captura saltos de línea
+const regexNormal = /a.b/;
+texto.match(regexNormal); // null
+
+// Con "s": el punto (.) sí captura saltos de línea
+const regexDotAll = /a.b/s;
+texto.match(regexDotAll); // ["a\nb"]
+```
+
+> > - `u` (**unicode**): Habilita soporte Unicode completo en regex (ejemplo, emojis o caracteres fuera del BMP).
+
+```ts
+const regex = /\u{1F600}/u; // 😀
+"😀".match(regex); // ["😀"]
+```
+
+> > - `y` (**sticky**): Solo encuentra coincidencias en la posición exacta del índice actual (lastIndex).
+
+```ts
+const regexSticky = /\d{2}/y;
+
+regexSticky.lastIndex = 0;
+regexSticky.exec("123456");
+// ["12"]
+
+regexSticky.lastIndex = 2;
+regexSticky.exec("123456");
+// ["34"]
+
+regexSticky.lastIndex = 4;
+regexSticky.exec("123456");
+// ["56"]
+
+regexSticky.lastIndex = 1;
+regexSticky.exec("123456");
+// null (porque en índice 1 hay "2", pero necesita empezar justo ahí y no hay 2 dígitos completos desde esa posición)
+```
+
+Ejemplos:
+
+```ts
+const text = "Usuario: 12345, Otro: 67890";
+const rules: PiiReplacement[] = [
+  { pattern: "\\d{5}", replaceWith: "[ID]", flags: "g" },
+];
+console.log(redact(text, rules));
+// Usuario: [ID], Otro: [ID]
+
+// Donde:
+// \d  → significa un dígito (0–9).
+// {5} → significa exactamente 5 repeticiones seguidas.
+```
+
+```ts
+const text = "Password=1234; PASSWORD=5678; password=9999";
+const rules: PiiReplacement[] = [
+  { pattern: "password=\\d+", replaceWith: "password=[REDACTED]", flags: "gi" },
+];
+console.log(redact(text, rules));
+// password=[REDACTED]; password=[REDACTED]; password=[REDACTED]
+
+// Donde:
+// \d  → significa un dígito (0–9).
+// +   → uno o más dígitos consecutivos.
+```
+
+```ts
+const text = `
+linea1: ok
+secret=12345
+linea3: done
+`;
+
+const rules: PiiReplacement[] = [
+  { pattern: "^secret=.*$", replaceWith: "secret=[REDACTED]", flags: "m" },
+];
+console.log(redact(text, rules));
+/*
+linea1: ok
+secret=[REDACTED]
+linea3: done
+*/
+
+// Donde
+// . → cualquier carácter (excepto salto de línea, a menos que uses el flag s).
+// * → cero o más repeticiones del carácter anterior (.).
+// $ → final de la línea o final de la cadena (dependiendo si usas flag m).
+```
+
+```ts
+const text = "BEGIN\n12345\nEND";
+const rules: PiiReplacement[] = [
+  { pattern: "BEGIN.*END", replaceWith: "[BLOCK REDACTED]", flags: "s" },
+];
+console.log(redact(text, rules));
+// [BLOCK REDACTED]
+
+// Donde
+// . → cualquier carácter (excepto salto de línea, a menos que uses el flag s).
+// * → cero o más repeticiones del carácter anterior (.).
+```
+
+```ts
+const text = "Cliente: 😀 secreto=123";
+const rules: PiiReplacement[] = [
+  { pattern: "\\p{Emoji}", replaceWith: "[EMOJI]", flags: "gu" },
+];
+console.log(redact(text, rules));
+// Cliente: [EMOJI] secreto=123
+
+// Donde
+// \p{...} → en regex con flag u (unicode), permite usar propiedades Unicode.
+// \p{Emoji} → coincide con cualquier carácter que esté clasificado en Unicode como un emoji.
+```
+
+```ts
+const text = "ID=1234 ID=5678";
+const regexRule: PiiReplacement = {
+  pattern: "ID=\\d{4}",
+  replaceWith: "ID=[REDACTED]",
+  flags: "y",
+};
+
+const regex = new RegExp(regexRule.pattern, regexRule.flags);
+regex.lastIndex = 0;
+console.log(regex.exec(text)); // ["ID=1234"]
+
+regex.lastIndex = 7;
+console.log(regex.exec(text)); // ["ID=5678"]
+
+regex.lastIndex = 3;
+console.log(regex.exec(text)); // null (porque no empieza justo ahí)
+
+// Donde:
+// \d → significa un dígito (0–9).
+// {4} → significa exactamente 4 repeticiones consecutivas.
+```
+
 ##### 2.2) loglevel.settings.ts (normalización de nivel)
 
 ```ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jmlq/logger",
-  "version": "0.1.0-alpha.6",
+  "version": "0.1.0-alpha.7",
   "author": "MLahuasi",
   "license": "MIT",
   "main": "dist/index.js",