@sideid/id-profanity-filter 1.1.0 → 1.9.4

package/src/utils/regexUtils.ts

@@ -0,0 +1,203 @@
+import { escapeRegExp } from "./stringUtils";
+import { RegexOptions } from "../types";
+
+/**
+ * Membuat pola regex untuk mencocokkan kata
+ *
+ * @param word Kata yang akan dibuat pola regex-nya
+ * @param options Opsi untuk pembuatan regex
+ * @returns Objek RegExp
+ */
+export function createWordRegex(
+  word: string,
+  options: RegexOptions = {},
+): RegExp {
+  const {
+    wholeWord = true,
+    caseSensitive = false,
+    leetSpeak = true,
+    detectSplit = false,
+    indonesianVariation = false,
+  } = options;
+
+  // Escape karakter khusus regex
+  let pattern = escapeRegExp(word);
+
+  // Tambahkan variasi leet speak jika diminta
+  if (leetSpeak) {
+    pattern = addLeetSpeakVariations(pattern);
+  }
+
+  // Tambahkan variasi ejaan Bahasa Indonesia jika diminta
+  if (indonesianVariation) {
+    pattern = addIndonesianVariations(pattern);
+  }
+
+  // Tambahkan kemungkinan split jika diminta
+  if (detectSplit) {
+    pattern = addSplitVariations(pattern);
+  }
+
+  // Tambahkan boundary untuk whole word jika diminta
+  if (wholeWord) {
+    pattern = `\\b${pattern}\\b`;
+  }
+
+  // Buat regex dengan flag case-insensitive jika diminta
+  return new RegExp(pattern, caseSensitive ? "g" : "gi");
+}
+
+/**
+ * Menambahkan variasi leet speak ke pola regex
+ *
+ * Contoh:
+ * - 'a' bisa jadi '4', '@'
+ * - 'i' bisa jadi '1', '!'
+ *
+ * @param pattern Pola regex asli
+ * @returns Pola regex dengan variasi leet speak
+ */
+export function addLeetSpeakVariations(pattern: string): string {
+  const leetMap: Record<string, string[]> = {
+    a: ["a", "4", "@"],
+    b: ["b", "8", "6"],
+    c: ["c", "(", "{", "<"],
+    e: ["e", "3"],
+    g: ["g", "6", "9"],
+    i: ["i", "1", "!", "|"],
+    l: ["l", "1", "|"],
+    o: ["o", "0"],
+    s: ["s", "5", "$"],
+    t: ["t", "7", "+"],
+    z: ["z", "2"],
+  };
+
+  // Ganti tiap karakter dengan variasinya dalam grup character class
+  return pattern
+    .split("")
+    .map((char) => {
+      const lowerChar = char.toLowerCase();
+      const variations = leetMap[lowerChar];
+
+      if (variations && variations.length > 1) {
+        return `[${variations.join("")}]`;
+      }
+
+      return char;
+    })
+    .join("");
+}
+
+/**
+ * Menambahkan kemungkinan split/pemisahan antar karakter
+ *
+ * @param pattern Pola regex asli
+ * @returns Pola regex dengan kemungkinan split
+ */
+export function addSplitVariations(pattern: string): string {
+  // Tambahkan kemungkinan spasi atau karakter penghubung di antara setiap huruf
+  return pattern.split("").join("[\\s\\-._*+]?");
+}
+
+/**
+ * Membuat regex untuk mencari kata dengan variasi spasi dan karakter penghubung
+ * Berguna untuk mendeteksi upaya menghindari filter dengan menambahkan spasi atau karakter lain
+ *
+ * @param word Kata yang akan dibuat pola regexnya
+ * @returns Objek RegExp
+ */
+export function createEvasionRegex(word: string): RegExp {
+  // Tambahkan kemungkinan spasi atau karakter penghubung di antara setiap huruf
+  const pattern = addSplitVariations(escapeRegExp(word));
+
+  return new RegExp(pattern, "gi");
+}
+
+/**
+ * Menambahkan variasi ejaan Bahasa Indonesia
+ *
+ * @param pattern Pola regex asli
+ * @returns Pola regex dengan variasi ejaan Bahasa Indonesia
+ */
+export function addIndonesianVariations(pattern: string): string {
+  // Variasi ejaan dalam Bahasa Indonesia
+  const variationMap: Record<string, string[]> = {
+    c: ["c", "k"], // contoh: becok/bekok
+    k: ["k", "c", "q"], // contoh: kacau/qacau
+    j: ["j", "dj"], // contoh: jualan/djualan (ejaan lama)
+    y: ["y", "j"], // contoh: ya/ja
+    u: ["u", "oe"], // contoh: untuk/oentoek (ejaan lama)
+    f: ["f", "p", "v"], // contoh: kafir/kapir
+    z: ["z", "j", "s"], // contoh: zaman/jaman
+    x: ["x", "ks"], // contoh: taxi/taksi
+  };
+
+  // Ganti tiap karakter dengan variasinya
+  return pattern
+    .split("")
+    .map((char) => {
+      const lowerChar = char.toLowerCase();
+      const variations = variationMap[lowerChar];
+
+      if (variations && variations.length > 1) {
+        return `[${variations.join("")}]`;
+      }
+
+      return char;
+    })
+    .join("");
+}
+
+/**
+ * Membuat regex untuk mencocokkan kata dengan mempertimbangkan variasi ejaan Bahasa Indonesia
+ *
+ * @param word Kata yang akan dibuat pola regexnya
+ * @returns Objek RegExp
+ */
+export function createIndonesianVariationRegex(word: string): RegExp {
+  const pattern = addIndonesianVariations(escapeRegExp(word));
+  return new RegExp(`\\b${pattern}\\b`, "gi");
+}
+
+/**
+ * Membuat regex untuk mencocokkan kata dengan konteks
+ *
+ * @param word Kata yang akan dibuat pola regexnya
+ * @param contextSize Jumlah kata konteks sebelum dan sesudah
+ * @returns Objek RegExp
+ */
+export function createContextRegex(
+  word: string,
+  contextSize: number = 3,
+): RegExp {
+  const wordPattern = escapeRegExp(word);
+
+  // Membuat pola yang menangkap beberapa kata sebelum dan setelah kata target
+  const pattern = `((?:\\S+\\s+){0,${contextSize}})(\\b${wordPattern}\\b)((?:\\s+\\S+){0,${contextSize}})`;
+
+  return new RegExp(pattern, "gi");
+}
+
+/**
+ * Membuat regex untuk mencocokkan variasi penulisan kata
+ *
+ * @param word Kata dasar
+ * @returns Objek RegExp untuk mencocokkan berbagai bentuk kata
+ */
+export function createWordFormRegex(word: string): RegExp {
+  // Implementasi sederhana untuk mencocokkan berbagai imbuhan
+  // Ini bisa dikembangkan lebih lanjut untuk mencocokkan bentukan kata yang lebih kompleks
+  const prefixes = ["", "me", "pe", "ber", "di", "ter", "se"];
+  const suffixes = ["", "kan", "an", "i", "nya"];
+
+  const patterns = [];
+
+  // Kombinasikan prefix dan suffix
+  for (const prefix of prefixes) {
+    for (const suffix of suffixes) {
+      patterns.push(`\\b${prefix}${escapeRegExp(word)}${suffix}\\b`);
+    }
+  }
+
+  return new RegExp(patterns.join("|"), "gi");
+}

package/src/utils/similarityUtils.ts

@@ -0,0 +1,195 @@
+/**
+ * Menghitung jarak Levenshtein antara dua string
+ * (Jumlah operasi insert, delete, atau replace untuk mengubah string1 menjadi string2)
+ *
+ * @param str1 String pertama
+ * @param str2 String kedua
+ * @returns Jarak Levenshtein
+ */
+export function levenshteinDistance(str1: string, str2: string): number {
+  const s1 = str1.toLowerCase();
+  const s2 = str2.toLowerCase();
+
+  const len1 = s1.length;
+  const len2 = s2.length;
+
+  // Inisialisasi matrix
+  const matrix: number[][] = [];
+
+  // Inisialisasi baris pertama
+  for (let i = 0; i <= len2; i++) {
+    matrix[0] = matrix[0] || [];
+    matrix[0][i] = i;
+  }
+
+  // Inisialisasi kolom pertama
+  for (let i = 0; i <= len1; i++) {
+    matrix[i] = matrix[i] || [];
+    matrix[i][0] = i;
+  }
+
+  // Isi matrix
+  for (let i = 1; i <= len1; i++) {
+    for (let j = 1; j <= len2; j++) {
+      const cost = s1[i - 1] === s2[j - 1] ? 0 : 1;
+
+      matrix[i][j] = Math.min(
+        matrix[i - 1][j] + 1, // deletion
+        matrix[i][j - 1] + 1, // insertion
+        matrix[i - 1][j - 1] + cost, // substitution
+      );
+    }
+  }
+
+  return matrix[len1][len2];
+}
+
+/**
+ * Menghitung tingkat kesamaan antara dua string
+ *
+ * @param str1 String pertama
+ * @param str2 String kedua
+ * @returns Nilai kesamaan (0-1, di mana 1 berarti identik)
+ */
+export function stringSimilarity(str1: string, str2: string): number {
+  if (!str1.length && !str2.length) return 1;
+  if (!str1.length || !str2.length) return 0;
+
+  const distance = levenshteinDistance(str1, str2);
+  const maxLength = Math.max(str1.length, str2.length);
+
+  return 1 - distance / maxLength;
+}
+
+/**
+ * Mencari string yang paling mirip dari array
+ *
+ * @param target String target
+ * @param candidates Array string kandidat
+ * @param threshold Minimum kesamaan yang diterima (0-1)
+ * @returns String yang paling mirip atau null jika tidak ada yang di atas threshold
+ */
+export function findMostSimilar(
+  target: string,
+  candidates: string[],
+  threshold: number = 0.7,
+): string | null {
+  if (!candidates.length) return null;
+
+  let maxSimilarity = 0;
+  let mostSimilar: string | null = null;
+
+  for (const candidate of candidates) {
+    const similarity = stringSimilarity(target, candidate);
+
+    if (similarity > maxSimilarity && similarity >= threshold) {
+      maxSimilarity = similarity;
+      mostSimilar = candidate;
+    }
+  }
+
+  return mostSimilar;
+}
+
+/**
+ * Cek apakah string mungkin merupakan variasi dari kata kotor
+ * menggunakan kesamaan string
+ *
+ * @param input String yang akan diperiksa
+ * @param profanityWords Daftar kata kotor
+ * @param threshold Batas minimum kesamaan (default: 0.75)
+ * @returns Array [Boolean (apakah variasi), String original (jika ditemukan)]
+ */
+export function isPossibleProfanityVariation(
+  input: string,
+  profanityWords: string[],
+  threshold: number = 0.75,
+): [boolean, string | null] {
+  if (!input || !profanityWords.length) return [false, null];
+
+  for (const word of profanityWords) {
+    const similarity = stringSimilarity(input, word);
+
+    if (similarity >= threshold) {
+      return [true, word];
+    }
+  }
+
+  return [false, null];
+}
+
+/**
+ * Mengelompokkan kata berdasarkan kesamaan
+ *
+ * @param words Daftar kata
+ * @param threshold Batas minimum kesamaan (default: 0.8)
+ * @returns Array kluster kata yang mirip
+ */
+export function clusterSimilarWords(
+  words: string[],
+  threshold: number = 0.8,
+): string[][] {
+  const clusters: string[][] = [];
+  const processed: Set<string> = new Set();
+
+  for (const word of words) {
+    if (processed.has(word)) continue;
+
+    const cluster: string[] = [word];
+    processed.add(word);
+
+    for (const otherWord of words) {
+      if (word === otherWord || processed.has(otherWord)) continue;
+
+      const similarity = stringSimilarity(word, otherWord);
+      if (similarity >= threshold) {
+        cluster.push(otherWord);
+        processed.add(otherWord);
+      }
+    }
+
+    clusters.push(cluster);
+  }
+
+  return clusters;
+}
+
+/**
+ * Cari kata-kata kotor yang mungkin dari teks menggunakan kesamaan string
+ *
+ * @param text Teks yang akan diperiksa
+ * @param profanityWords Daftar kata kotor
+ * @param threshold Batas minimum kesamaan (default: 0.8)
+ * @returns Array kata yang mungkin merupakan kata kotor
+ */
+export function findPossibleProfanityBySimiliarity(
+  text: string,
+  profanityWords: string[],
+  threshold: number = 0.8,
+): Array<{ word: string; original: string; similarity: number }> {
+  const result: Array<{ word: string; original: string; similarity: number }> =
+    [];
+
+  // Pisahkan teks menjadi kata-kata
+  const words = text.toLowerCase().split(/\s+/);
+
+  for (const word of words) {
+    // Lewati kata-kata yang terlalu pendek
+    if (word.length < 3) continue;
+
+    for (const profanity of profanityWords) {
+      const similarity = stringSimilarity(word, profanity);
+
+      if (similarity >= threshold) {
+        result.push({
+          word,
+          original: profanity,
+          similarity,
+        });
+        break;
+      }
+    }
+  }
+
+  return result;
+}

package/src/utils/stringUtils.ts

@@ -0,0 +1,213 @@
+/**
+ * Menyensor kata dengan karakter pengganti
+ *
+ * @param word Kata yang akan disensor
+ * @param replaceChar Karakter pengganti (default: '*')
+ * @param keepFirstAndLast Apakah harus menyimpan huruf pertama dan terakhir
+ * @returns Kata yang telah disensor
+ */
+export function censorWord(
+  word: string,
+  replaceChar: string = "*",
+  keepFirstAndLast: boolean = false,
+): string {
+  if (word.length <= 2) {
+    return replaceChar.repeat(word.length);
+  }
+
+  if (keepFirstAndLast) {
+    return `${word[0]}${replaceChar.repeat(word.length - 2)}${word[word.length - 1]}`;
+  }
+
+  return replaceChar.repeat(word.length);
+}
+
+/**
+ * Menormalisasi string untuk keperluan pembandingan
+ *
+ * @param text Teks yang akan dinormalisasi
+ * @returns Teks yang telah dinormalisasi
+ */
+export function normalizeText(text: string): string {
+  return text
+    .toLowerCase()
+    .normalize("NFD") // Normalisasi Unicode
+    .replace(/[\u0300-\u036f]/g, "") // Hapus diacritic marks
+    .replace(/[^\w\s]/g, "") // Hapus karakter non-alphanumeric
+    .trim(); // Hapus whitespace di awal dan akhir
+}
+
+/**
+ * Mendeteksi apakah string berisi sebagian atau keseluruhan kata dalam wordList
+ *
+ * @param text Teks yang akan diperiksa
+ * @param wordList Daftar kata yang dicari
+ * @param checkSubstring Apakah harus memeriksa substring
+ * @returns Boolean apakah teks mengandung kata-kata dalam wordList
+ */
+export function containsAnyWord(
+  text: string,
+  wordList: string[],
+  checkSubstring: boolean = false,
+): boolean {
+  const normalizedText = normalizeText(text);
+
+  return wordList.some((word) => {
+    const normalizedWord = normalizeText(word);
+    return checkSubstring
+      ? normalizedText.includes(normalizedWord)
+      : new RegExp(`\\b${escapeRegExp(normalizedWord)}\\b`, "i").test(
+          normalizedText,
+        );
+  });
+}
+
+/**
+ * Memerikasa apakah stirng merupakan kode untuk kata kotor
+ * (Menangkap kasus seperti disensor dengan titik atau garis: a**ing, b*bi, dll)
+ *
+ * @param text Teks yang akan diperika
+ * @param wordList daftar kata kotor
+ * @return Boolean apakah teks mengandung kata kotor
+ */
+export function containsEuphemism(text: string, wordList: string[]): boolean {
+  return wordList.some((word) => {
+    if (word.length <= 2) return false;
+
+    const firstChar = word[0];
+    const lastChar = word[word.length - 1];
+    const pattern = new RegExp(
+      `\\b${escapeRegExp(firstChar)}[*@#\\-_.!?\\s]{${word.length - 2}}${escapeRegExp(lastChar)}\\b`,
+      "i",
+    );
+
+    return pattern.test(text);
+  });
+}
+
+/**
+ * Mendeteksi upaya menghindari filter dengan pemisahan kata
+ * (Tangkap kasus seperti: a n j i n g, b-a-b-i, dll)
+ *
+ * @param text Teks yang akan diperiksa
+ * @param wordList Daftar kata kotor
+ * @returns Boolean apakah teks mengandung upaya menghindari filter
+ */
+export function detectSplitWords(text: string, wordList: string[]): boolean {
+  const compressedText = text.replace(/[\s\-_.!?*]/g, "").toLowerCase();
+
+  return wordList.some((word) => compressedText.includes(normalizeText(word)));
+}
+
+export function escapeRegExp(string: string): string {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+/**
+ * Mengganti sebagian kata dengan masking
+ * (berguna untuk email, nomor telepon, dll)
+ *
+ * @param text Teks untuk dimasking
+ * @param visibleStart Jumlah karakter yang terlihat di awal
+ * @param visibleEnd Jumlah karakter yang terlihat di akhir
+ * @param maskChar Karakter masking
+ * @returns Teks yang telah dimasking
+ */
+export function maskText(
+  text: string,
+  visibleStart: number = 1,
+  visibleEnd: number = 1,
+  maskChar: string = "*",
+): string {
+  if (!text) return "";
+  if (text.length <= visibleStart + visibleEnd) return text;
+
+  const start = text.substring(0, visibleStart);
+  const middle = maskChar.repeat(text.length - visibleStart - visibleEnd);
+  const end = text.substring(text.length - visibleEnd);
+
+  return start + middle + end;
+}
+
+/**
+ * menguabh sting menjadi bentuk leet speak
+ * (untuk testing filter bypass)
+ *
+ * @param text Teks yang akan diubah
+ * @return Teks yang telah diubah ke leet speak
+ */
+export function toLeetSpeak(text: string): string {
+  const leetMap: Record<string, string[]> = {
+    a: ["4", "@"],
+    b: ["8", "6"],
+    c: ["<", "(", "{"],
+    e: ["3"],
+    g: ["9"],
+    i: ["1", "!"],
+    l: ["1", "|"],
+    o: ["0"],
+    s: ["5", "$"],
+    t: ["7", "+"],
+    z: ["2"],
+  };
+
+  return text
+    .split("")
+    .map((char) => {
+      const lowerChar = char.toLowerCase();
+      return leetMap[lowerChar] || char;
+    })
+    .join("");
+}
+
+/**
+ * memisahkan teks menajdi kelimat
+ *
+ * @param text Teks yang akan dipisahkan
+ * @return Array kalimat yang telah dipisahkan
+ */
+export function splitIntoSentences(text: string): string[] {
+  // split berdasarkan titik, seru, taya yagn diikuti spasi atau akhir string
+  return text
+    .split(/(?<=[.!?])\s+|(?<=[.!?])$/)
+    .filter((sentence) => sentence.trim().length > 0);
+}
+
+/**
+ * mengambil kata-kata di sekitar indeks tertentu
+ *
+ * @param text Teks yang akan diambil
+ * @param index Indeks dalam teks
+ * @param windowSize jumlah kata di sekitar indeks
+ * @return Kata-kata di sekitar indeks
+ */
+export function getContextAroundIndex(
+  text: string,
+  index: number,
+  windowSize: number = 5,
+): string {
+  if (!text || index < 0 || index >= text.length) return "";
+
+  const words = text.split(/\s+/);
+
+  let currentPosition = 0;
+  let targetWordIndex = -1;
+
+  for (let i = 0; i < words.length; i++) {
+    const wordLength = words[i].length;
+    if (index >= currentPosition && index < currentPosition + wordLength) {
+      targetWordIndex = i;
+      break;
+    }
+    // Tambahkan panjang kata dan spasi
+    currentPosition += wordLength + 1;
+  }
+
+  if (targetWordIndex === -1) return "";
+
+  // Ambil kata-kata di sekitar
+  const startIndex = Math.max(0, targetWordIndex - windowSize);
+  const endIndex = Math.min(words.length, targetWordIndex + windowSize + 1);
+
+  return words.slice(startIndex, endIndex).join(" ");
+}