@sideid/id-profanity-filter 1.9.5 → 1.10.4

package/examples/custom-list.ts

@@ -0,0 +1,140 @@
+import { IDProfanityFilter, idFilter, FilterOptions } from '../src/index';
+
+/**
+ * Contoh Penggunaan ID-Profanity-Filter dengan Daftar Kustom
+ * =======================================================
+ * File ini menunjukkan cara menggunakan library dengan daftar kata kustom.
+ */
+
+console.log('=== Contoh Penggunaan dengan Daftar Kata Kustom ===\n');
+
+// ===== Contoh 1: Menggunakan daftar kata kustom =====
+// Daftar kata kotor kustom
+const customBadWords = ['jelek', 'buruk', 'sampah', 'payah', 'lemah', 'amatir'];
+
+// Buat instance dengan daftar kata kustom
+const filter = new IDProfanityFilter({
+  wordList: customBadWords,
+  replaceWith: '#',
+});
+
+const teks1 = 'Film itu sangat jelek dan payah, sepertinya dibuat oleh amatir.';
+console.log('Teks asli:', teks1);
+console.log('Hasil filter kustom:', filter.filter(teks1).filtered);
+
+// ===== Contoh 2: Menggabungkan daftar kata kustom dengan daftar bawaan =====
+console.log('\n=== Menggabungkan Daftar Kata ===\n');
+
+// Reset filter ke pengaturan default
+filter.setOptions({});
+
+// Tambahkan kata-kata kustom tapi tetap deteksi kata-kata bawaan
+const teks2 = 'Film itu sangat jelek dan payah, dibuat oleh anjing amatir.';
+console.log('Teks asli:', teks2);
+
+// Analisis hanya dengan kata bawaan
+console.log('Analisis standar:');
+const standarAnalisis = filter.analyze(teks2);
+console.log('- Kata terdeteksi:', standarAnalisis.matches);
+
+// Tambahkan kata kustom
+filter.setWordList([...customBadWords]);
+console.log('\nAnalisis dengan kata kustom ditambahkan:');
+const customAnalisis = filter.analyze(teks2);
+console.log('- Kata terdeteksi:', customAnalisis.matches);
+
+// ===== Contoh 3: Whitelist untuk pengecualian kontekstual =====
+console.log('\n=== Penggunaan Whitelist ===\n');
+
+// Kita ingin kata "anjing" diperbolehkan jika dalam konteks binatang
+filter.setOptions({});
+filter.addToWhitelist('anjing');
+
+const teks3a = 'Anjing adalah hewan peliharaan yang setia.';
+const teks3b = 'Dasar anjing kamu, tidak punya perasaan!';
+
+console.log('Teks dengan konteks binatang:', teks3a);
+console.log('Terdeteksi sebagai kata kotor?', filter.isProfane(teks3a));
+
+// Tambahkan kembali "anjing" ke daftar kata kotor
+filter.removeFromWhitelist('anjing');
+console.log('\nSetelah dihapus dari whitelist:');
+console.log('Terdeteksi sebagai kata kotor?', filter.isProfane(teks3a));
+
+// ===== Contoh 4: Membuat preset kustom =====
+console.log('\n=== Membuat Preset Kustom ===\n');
+
+// Kita bisa membuat preset filter kustom
+const myCustomPreset: FilterOptions = {
+  replaceWith: '●', // Karakter pengganti
+  fullWordCensor: false,
+  keepFirstAndLast: true,
+  detectLeetSpeak: true,
+  indonesianVariation: true,
+  detectSplit: false,
+  useRandomGrawlix: false,
+  categories: ['insult', 'profanity'],
+  severityThreshold: 0.3,
+  whitelist: ['anjing'], // Untuk konteks binatang
+};
+
+const teks4 = 'Anjing itu lucu, tidak seperti si goblok dan bego itu.';
+console.log('Teks asli:', teks4);
+
+// Gunakan preset kustom
+filter.setOptions(myCustomPreset);
+console.log('Hasil preset kustom:', filter.filter(teks4).filtered);
+
+// ===== Contoh 5: Filter berdasarkan kategori atau daerah saja =====
+console.log('\n=== Filter Berdasarkan Kategori atau Daerah ===\n');
+
+// Filter hanya kata dari kategori "sexual"
+filter.setOptions({
+  categories: ['sexual'],
+  wordList: [], // Reset daftar kata kustom
+});
+
+const teks5 =
+  'Ngewe dan bokep itu kata kotor, bego dan anjing tidak terfilter.';
+console.log('Teks asli:', teks5);
+console.log('Filter hanya kategori sexual:', filter.filter(teks5).filtered);
+
+// Filter hanya kata dari daerah "jawa"
+filter.setOptions({
+  categories: [],
+  regions: ['jawa'],
+});
+
+const teks5b = 'Kata jancuk dan cuk dari Jawa, anjing adalah kata umum.';
+console.log('\nTeks asli:', teks5b);
+console.log('Filter hanya daerah jawa:', filter.filter(teks5b).filtered);
+
+// ===== Contoh 6: Custom wordList dengan metadata =====
+console.log('\n=== Custom wordList dengan Metadata ===\n');
+
+// Ini contoh jika Anda ingin membuat daftar kata lengkap dengan metadata
+const customWordsWithMetadata = [
+  {
+    word: 'jelek',
+    category: 'insult' as any,
+    region: 'general' as any,
+    severity: 0.4,
+    aliases: ['jelex', 'jlk'],
+  },
+  {
+    word: 'payah',
+    category: 'insult' as any,
+    region: 'general' as any,
+    severity: 0.3,
+    aliases: ['pyh', 'payaah'],
+  },
+];
+
+// Namun untuk filter sederhana, cukup gunakan kata-kata saja
+filter.setOptions({
+  wordList: customWordsWithMetadata.map((w) => w.word),
+});
+
+const teks6 = 'Performanya sangat jelek dan payah sekali.';
+console.log('Teks asli:', teks6);
+console.log('Filter dengan wordList kustom:', filter.filter(teks6).filtered);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sideid/id-profanity-filter",
-  "version": "1.9.5",
+  "version": "1.10.4",
   "description": "Library filter kata kotor dalam Bahasa Indonesia",
   "main": "dist/index.js",
   "module": "dist/index.esm.js",
@@ -8,7 +8,7 @@
   "scripts": {
     "build": "rollup -c",
     "test": "jest",
-    "lint": "eslint src/**/*.ts",
+    "lint": "eslint --ext .ts src/",
     "format": "prettier --write \"src/**/*.ts\""
   },
   "keywords": [

package/src/config/options.ts

@@ -7,6 +7,8 @@ export const DEFAULT_OPTIONS: FilterOptions = {
   checkSubstring: false,
   whitelist: [],
   severityThreshold: 0,
+  useLevenshtein: false,
+  maxLevenshteinDistance: 2,
 };
 
 export const FILTER_PRESETS = {

package/src/constants/regions/general.ts

@@ -6,7 +6,7 @@ export const general: ProfanityWord[] = [
     category: "profanity",
     region: "general",
     severity: 0.7,
-    aliases: ["anjay", "anjir", "anying", "njing", "anj"],
+    aliases: ["anjay", "anjir", "anying", "njing", "anj", "anjg", "ajg"],
     description: "Mengacu pada hewan anjing, digunakan sebagai umpatan",
     context: "Umpatan umum untuk menunjukkan kemarahan atau ketidaksetujuan",
   },
@@ -15,7 +15,7 @@ export const general: ProfanityWord[] = [
     category: "profanity",
     region: "general",
     severity: 0.6,
-    aliases: ["bab1", "b4b1"],
+    aliases: ["bab1", "b4b1", "b4bi", "8481", "8ab1", "ba81"],
     description: "Mengacu pada hewan babi, digunakan sebagai umpatan",
     context: "Umpatan umum untuk menunjukkan kemarahan atau ketidaksetujuan",
   },
@@ -104,6 +104,106 @@ export const general: ProfanityWord[] = [
     description: "Kata yang mengacu pada orang yang banyak bicara",
     context: "Hinaan untuk menyebut orang yang banyak bicara atau cerewet",
   },
+  {
+    word: "ngentot",
+    category: "sexual",
+    region: "general",
+    severity: 0.9,
+    aliases: ["ngentod", "ntot", "tod"],
+    description: "Istilah kasar untuk aktivitas seksual",
+    context: "Kata vulgar yang merujuk pada aktivitas seksual",
+  },
+  {
+    word: "sialan",
+    category: "insult",
+    region: "general",
+    severity: 0.5,
+    aliases: ["sialn", "sl"],
+    description: "Kata yang mengacu pada orang yang membawa sial",
+    context: "Hinaan untuk menyebut orang yang dianggap membawa sial",
+  },
+  {
+    word: "pler",
+    category: "sexual",
+    region: "general",
+    severity: 0.9,
+    aliases: ["peler", "plr", "biji"],
+    description: "Istilah kasar untuk alat kelamin laki-laki",
+    context: "Kata vulgar yang merujuk pada alat kelamin laki-laki",
+  },
+  {
+    word: "bokep",
+    category: "sexual",
+    region: "general",
+    severity: 0.7,
+    aliases: ["bkp", "bokap"],
+    description: "Istilah untuk video atau konten pornografi",
+    context: "Kata yang mengacu pada materi pornografi",
+  },
+  {
+    word: "coli",
+    category: "sexual",
+    region: "general",
+    severity: 0.8,
+    aliases: ["col", "coly"],
+    description: "Istilah untuk masturbasi laki-laki",
+    context: "Kata vulgar yang merujuk pada aktivitas seksual pribadi",
+  },
+  {
+    word: "desah",
+    category: "sexual",
+    region: "general",
+    severity: 0.6,
+    aliases: ["ds4h", "dsh"],
+    description: "Istilah untuk suara yang dibuat selama aktivitas seksual",
+    context: "Dapat menjadi vulgar tergantung konteks penggunaan",
+  },
+  {
+    word: "seks",
+    category: "sexual",
+    region: "general",
+    severity: 0.5,
+    aliases: ["sex", "ML"],
+    description: "Istilah untuk aktivitas seksual",
+    context: "Dapat menjadi vulgar tergantung konteks penggunaan",
+  },
+  {
+    word: "kondom",
+    category: "sexual",
+    region: "general",
+    severity: 0.5,
+    aliases: ["kndm", "kondom", "cd"],
+    description: "Alat kontrasepsi",
+    context: "Dapat menjadi vulgar tergantung konteks penggunaan",
+  },
+  {
+    word: "ngewe",
+    category: "sexual",
+    region: "general",
+    severity: 0.9,
+    aliases: ["ngew", "we"],
+    description: "Istilah kasar untuk aktivitas seksual",
+    context: "Kata vulgar yang merujuk pada aktivitas seksual",
+  },
+  {
+    word: "puki",
+    category: "sexual",
+    region: "general",
+    severity: 0.9,
+    aliases: ["puk", "pukih"],
+    description: "Kata vulgar yang mengacu pada alat kelamin perempuan",
+    context: "Kata vulgar yang merujuk pada anatomi seksual",
+  },
+  {
+    word: "xxx",
+    category: "sexual",
+    region: "general",
+    severity: 0.6,
+    aliases: ["xXx", "triplex"],
+    description:
+      "Simbol yang sering digunakan untuk menandai konten pornografi",
+    context: "Digunakan untuk menandai konten seksual eksplisit",
+  },
 ];
 
 export const generalWords = general.map((item) => item.word);

package/src/constants/regions/jawa.ts

@@ -95,6 +95,16 @@ export const jawa: ProfanityWord[] = [
     context:
       "Umpatan ringan untuk menanggapi sesuatu yang dianggap tidak benar",
   },
+  {
+    word: "itil",
+    category: "sexual",
+    region: "jawa",
+    severity: 0.9,
+    aliases: ["itl", "itul"],
+    description:
+      "Kata vulgar yang mengacu pada bagian dari alat kelamin perempuan",
+    context: "Kata vulgar yang merujuk pada anatomi seksual",
+  },
 ];
 
 export const jawaWords = jawa.map((item) => item.word);

package/src/constants/wordList.ts

@@ -1,18 +1,17 @@
-import { ProfanityWord } from "../types";
+import { ProfanityWord } from '../types';
+import { sexualWords } from './categories/sexual';
+import { insultWords } from './categories/insult';
+// import { profanityWords } from './categories/profanity';
+// import { slurWords } from './categories/slur';
+// import { drugsWords } from './categories/drugs';
+// import { disgustingWords } from './categories/disgusting';
+// import { blasphemyWords } from './categories/blasphemy';
 
-import { sexual, sexualWords } from "./categories/sexual";
-import { insult, insultWords } from "./categories/insult";
-// import { profanity, profanityWords } from './categories/profanity';
-// import { slur, slurWords } from './categories/slur';
-// import { drugs, drugsWords } from './categories/drugs';
-// import { disgusting, disgustingWords } from './categories/disgusting';
-// import { blasphemy, blasphemyWords } from './categories/blasphemy';
-
-import { general, generalWords } from "./regions/general";
-import { jawa, jawaWords } from "./regions/jawa";
-import { sunda, sundaWords } from "./regions/sunda";
-import { betawi, betawiWords } from "./regions/betawi";
-import { batak, batakWords } from "./regions/batak";
+import { general, generalWords } from './regions/general';
+import { jawa, jawaWords } from './regions/jawa';
+import { sunda, sundaWords } from './regions/sunda';
+import { betawi, betawiWords } from './regions/betawi';
+import { batak, batakWords } from './regions/batak';
 // import { minang, minangWords } from './regions/minang';
 // import { bali, baliWords } from './regions/bali';
 // import { madura, maduraWords } from './regions/madura';
@@ -96,6 +95,14 @@ export const severeWords: string[] = wordObjects
  * @returns Array dari kata kotor
  */
 export function getWordsByFilter(category?: string, region?: string): string[] {
+  if (category && !region && category in wordCategories) {
+    return wordCategories[category as keyof typeof wordCategories];
+  }
+
+  if (region && !category && region in wordRegions) {
+    return wordRegions[region as keyof typeof wordRegions];
+  }
+
   return wordObjects
     .filter((word) => {
       const matchCategory = category ? word.category === category : true;

package/src/core/analyzer.ts

@@ -1,26 +1,20 @@
 import {
   FilterOptions,
   AnalysisResult,
-  ProfanityWord,
   ProfanityCategory,
   Region,
-} from "../types";
+} from '../types';
 import {
   findProfanity,
   findProfanityWithMetadata,
   findCategories,
   findRegions,
   calculateSeverity,
-} from "./matcher";
-import {
-  normalizeText,
-  escapeRegExp,
-  splitIntoSentences,
-  getContextAroundIndex,
-} from "../utils/stringUtils";
-import { findPossibleProfanityBySimiliarity } from "../utils/similarityUtils";
-import { createContextRegex } from "../utils/regexUtils";
-import { DEFAULT_OPTIONS } from "../config/options";
+} from './matcher';
+import { splitIntoSentences } from '../utils/stringUtils';
+import { findPossibleProfanityBySimiliarity } from '../utils/similarityUtils';
+import { createContextRegex } from '../utils/regexUtils';
+import { DEFAULT_OPTIONS } from '../config/options';
 
 /**
  * Menganalisis teks untuk kata kotor
@@ -206,9 +200,9 @@ export function analyzeWithContext(
 
     let match;
     while ((match = regex.exec(text)) !== null) {
-      const beforeContext = match[1] || "";
+      const beforeContext = match[1] || '';
       const wordMatch = match[2];
-      const afterContext = match[3] || "";
+      const afterContext = match[3] || '';
 
       result.push({
         word: wordMatch,

package/src/core/filter.ts

@@ -1,12 +1,13 @@
-import { FilterOptions, FilterResult, ProfanityWord } from "../types";
-import { findProfanity, findProfanityWithMetadata } from "./matcher";
-import { censorWord, escapeRegExp, normalizeText } from "../utils/stringUtils";
-import { createWordRegex } from "../utils/regexUtils";
-import {
-  DEFAULT_OPTIONS,
-  makeRandomGrawlixString,
-  getRandomGrawlix,
-} from "../config/options";
+import { FilterOptions, FilterResult, ProfanityWord } from '../types';
+import { findProfanity, findProfanityWithMetadata } from './matcher';
+import { censorWord, escapeRegExp } from '../utils/stringUtils';
+import { createWordRegex } from '../utils/regexUtils';
+import { DEFAULT_OPTIONS, makeRandomGrawlixString } from '../config/options';
+
+interface FindProfanityFunction {
+  (text: string, options?: FilterOptions): string[];
+  lastActualMatches?: Map<string, string[]>;
+}
 
 /**
  * Menyensor kata kotor dalam teks
@@ -20,7 +21,7 @@ export function filter(
   options: FilterOptions = {},
 ): FilterResult {
   const {
-    replaceWith = "*",
+    replaceWith = '*',
     fullWordCensor = true,
     detectLeetSpeak = true,
     whitelist = [],
@@ -28,6 +29,11 @@ export function filter(
     useRandomGrawlix = false,
     keepFirstAndLast = false,
     indonesianVariation = false,
+    detectSplit = false,
+    detectSimilarity = false,
+    useLevenshtein = false,
+    maxLevenshteinDistance = 2,
+    similarityThreshold = 0.8,
   } = { ...DEFAULT_OPTIONS, ...options };
 
   const matches = findProfanity(text, {
@@ -36,8 +42,16 @@ export function filter(
     whitelist,
     checkSubstring,
     indonesianVariation,
+    detectSplit,
+    detectSimilarity,
+    useLevenshtein,
+    maxLevenshteinDistance,
+    similarityThreshold,
   });
 
+  const actualMatches: Map<string, string[]> =
+    (findProfanity as FindProfanityFunction).lastActualMatches || new Map();
+
   const matchDetails = findProfanityWithMetadata(text, options);
 
   if (matches.length === 0) {
@@ -66,49 +80,176 @@ export function filter(
           )),
     );
 
-    const regex = createWordRegex(word, {
-      wholeWord: true,
-      caseSensitive: false,
-      leetSpeak: false,
-      detectSplit: false,
-      indonesianVariation: false,
-    });
+    const variants = actualMatches.get(word.toLowerCase()) || [];
+    variants.push(word);
+
+    const uniqueVariants = [...new Set(variants)];
 
-    let match;
-    const textToSearch = filteredText;
+    uniqueVariants.forEach((variant) => {
+      const regex = new RegExp(`\\b${escapeRegExp(variant)}\\b`, 'gi');
 
-    regex.lastIndex = 0;
+      let match;
+      while ((match = regex.exec(filteredText)) !== null) {
+        const originalWord = match[0];
 
-    while ((match = regex.exec(textToSearch)) !== null) {
-      const originalWord = match[0];
+        if (whitelist.includes(originalWord.toLowerCase())) continue;
 
-      if (whitelist.includes(originalWord.toLowerCase())) continue;
+        let censoredWord;
+        if (useRandomGrawlix) {
+          censoredWord = makeRandomGrawlixString(originalWord.length);
+        } else {
+          censoredWord = censorWord(
+            originalWord,
+            replaceWith,
+            !fullWordCensor && keepFirstAndLast,
+          );
+        }
 
-      let censoredWord;
-      if (useRandomGrawlix) {
-        censoredWord = makeRandomGrawlixString(originalWord.length);
-      } else {
-        censoredWord = censorWord(
-          originalWord,
-          replaceWith,
-          !fullWordCensor && keepFirstAndLast,
+        replacements.push({
+          original: originalWord,
+          censored: censoredWord,
+          metadata,
+        });
+
+        filteredText = filteredText.replace(
+          new RegExp(`\\b${escapeRegExp(originalWord)}\\b`, 'g'),
+          censoredWord,
         );
       }
+    });
 
-      replacements.push({
-        original: originalWord,
-        censored: censoredWord,
-        metadata,
-      });
+    if (detectSplit || detectLeetSpeak) {
+      if (detectLeetSpeak) {
+        const leetRegex = createWordRegex(word, {
+          wholeWord: true,
+          caseSensitive: false,
+          leetSpeak: true,
+          detectSplit: false,
+          indonesianVariation: false,
+        });
 
-      const replaceRegex = new RegExp(
-        `\\b${escapeRegExp(originalWord)}\\b`,
-        "g",
-      );
-      filteredText = filteredText.replace(replaceRegex, censoredWord);
+        let match;
+        while ((match = leetRegex.exec(filteredText)) !== null) {
+          const originalWord = match[0];
+
+          if (whitelist.includes(originalWord.toLowerCase())) continue;
+
+          let censoredWord;
+          if (useRandomGrawlix) {
+            censoredWord = makeRandomGrawlixString(originalWord.length);
+          } else {
+            censoredWord = censorWord(
+              originalWord,
+              replaceWith,
+              !fullWordCensor && keepFirstAndLast,
+            );
+          }
+
+          replacements.push({
+            original: originalWord,
+            censored: censoredWord,
+            metadata,
+          });
+
+          filteredText = filteredText.replace(
+            new RegExp(escapeRegExp(originalWord), 'g'),
+            censoredWord,
+          );
+        }
+      }
+
+      if (detectSplit) {
+        const splitRegex = createWordRegex(word, {
+          wholeWord: false,
+          caseSensitive: false,
+          leetSpeak: false,
+          detectSplit: true,
+          indonesianVariation: false,
+        });
+
+        let match;
+        while ((match = splitRegex.exec(filteredText)) !== null) {
+          const originalWord = match[0];
+
+          if (whitelist.includes(originalWord.toLowerCase())) continue;
+
+          let censoredWord;
+          if (useRandomGrawlix) {
+            censoredWord = makeRandomGrawlixString(originalWord.length);
+          } else {
+            censoredWord = censorWord(
+              originalWord,
+              replaceWith,
+              !fullWordCensor && keepFirstAndLast,
+            );
+          }
+
+          replacements.push({
+            original: originalWord,
+            censored: censoredWord,
+            metadata,
+          });
+
+          filteredText = filteredText.replace(
+            new RegExp(escapeRegExp(originalWord), 'g'),
+            censoredWord,
+          );
+        }
+      }
     }
   });
 
+  if (detectSimilarity && useLevenshtein) {
+    matches.forEach((word) => {
+      const metadata = matchDetails.find(
+        (m) =>
+          m.word.toLowerCase() === word.toLowerCase() ||
+          (m.aliases &&
+            m.aliases.some(
+              (alias) => alias.toLowerCase() === word.toLowerCase(),
+            )),
+      );
+
+      const variants = actualMatches.get(word.toLowerCase()) || [];
+
+      variants.forEach((variant) => {
+        const exactVariantRegex = new RegExp(
+          `\\b${escapeRegExp(variant)}\\b`,
+          'gi',
+        );
+
+        let match;
+        while ((match = exactVariantRegex.exec(filteredText)) !== null) {
+          const originalWord = match[0];
+
+          if (whitelist.includes(originalWord.toLowerCase())) continue;
+
+          let censoredWord;
+          if (useRandomGrawlix) {
+            censoredWord = makeRandomGrawlixString(originalWord.length);
+          } else {
+            censoredWord = censorWord(
+              originalWord,
+              replaceWith,
+              !fullWordCensor && keepFirstAndLast,
+            );
+          }
+
+          replacements.push({
+            original: originalWord,
+            censored: censoredWord,
+            metadata,
+          });
+
+          filteredText = filteredText.replace(
+            new RegExp(`\\b${escapeRegExp(originalWord)}\\b`, 'g'),
+            censoredWord,
+          );
+        }
+      });
+    });
+  }
+
   return {
     filtered: filteredText,
     censored: replacements.length,