@sideid/id-profanity-filter 1.9.5 → 1.10.4

package/.eslintrc.js

@@ -1,16 +1,44 @@
 module.exports = {
   parser: '@typescript-eslint/parser',
-  extends: ['plugin:@typescript-eslint/recommended', 'prettier'],
   parserOptions: {
     ecmaVersion: 2020,
     sourceType: 'module',
+    project: './tsconfig.json',
   },
+  extends: [
+    'eslint:recommended',
+    'plugin:@typescript-eslint/recommended',
+    'prettier', // Disables ESLint rules that might conflict with Prettier
+  ],
+  plugins: ['@typescript-eslint'],
   env: {
     node: true,
     jest: true,
   },
   rules: {
+    // Enforce consistent code style
     '@typescript-eslint/explicit-function-return-type': 'off',
-    '@typescript-eslint/no-explicit-any': 'off',
+    '@typescript-eslint/no-explicit-any': 'warn',
+    '@typescript-eslint/no-unused-vars': ['warn', { argsIgnorePattern: '^_' }],
+
+    // Allow certain TypeScript patterns
+    '@typescript-eslint/no-non-null-assertion': 'off',
+
+    // General ESLint rules
+    'no-console': ['warn', { allow: ['warn', 'error'] }],
+    'prefer-const': 'warn',
+    'no-var': 'error',
+
+    // Make sure imports are properly sorted
+    'sort-imports': [
+      'off',
+      {
+        ignoreCase: false,
+        ignoreDeclarationSort: true,
+        ignoreMemberSort: false,
+        memberSyntaxSortOrder: ['none', 'all', 'multiple', 'single'],
+      },
+    ],
   },
+  ignorePatterns: ['dist/', 'node_modules/', '*.js', '*.d.ts'],
 };

package/README.md

@@ -12,6 +12,9 @@ Library JavaScript/TypeScript untuk mendeteksi, menyensor, dan menganalisis kata
 - ⚠️ **Analisis Konten** - Menganalisis tingkat keparahan dan kategori kata kotor
 - 🔒 **Penyensoran** - Menyensor kata-kata kotor dengan berbagai opsi kustomisasi
 - 🗺️ **Dukungan Bahasa Daerah** - Mencakup kata-kata dari berbagai daerah di Indonesia (Jawa, Sunda, Batak, dll)
+- 🧠 **Deteksi Cerdas** - Mendeteksi variasi ejaan, kata terpisah, dan kesamaan kata
+- 🔠 **Deteksi Levenshtein** - Mendeteksi kata kotor yang dimodifikasi dengan typo atau sengaja disamarkan
+- 🛡️ **Preset** - Preset filter siap pakai untuk berbagai kebutuhan
 - 🔧 **Kustomisasi** - Opsi untuk menambahkan whitelist dan daftar kata kustom
 
 ## Instalasi
@@ -42,7 +45,7 @@ console.log(hasProfanity); // Output: true
 
 // Filter kata kotor (sensorisasi)
 const hasil = filter.filter(teks);
-console.log(hasil.filtered); // Output: "Dasar **** kamu, jangan banyak ****!"
+console.log(hasil.filtered); // Output: "Dasar ***** kamu, jangan banyak *****!"
 console.log(hasil.censored); // Output: 2 (jumlah kata yang disensor)
 
 // Analisis konten
@@ -51,6 +54,26 @@ console.log(analisis.severityScore); // Output: 0.65 (contoh skor keparahan)
 console.log(analisis.categories); // Output: ["profanity", "insult"]
 ```
 
+### Menggunakan Preset
+
+```typescript
+import IDProfanityFilter from '@sideid/id-profanity-filter';
+
+// Buat instance filter dengan preset
+const filter = new IDProfanityFilter();
+filter.usePreset('strict');
+
+// Atau dengan opsi tambahan
+filter.usePreset('childSafe', {
+  replaceWith: '#',
+  useRandomGrawlix: true,
+});
+
+const teks = 'Dasar anjing kamu, jangan banyak bacot!';
+const hasil = filter.filter(teks);
+console.log(hasil.filtered); // Output: "Dasar #@$%& kamu, jangan banyak $!@#%!"
+```
+
 ### Utilitas Langsung
 
 Anda juga dapat menggunakan fungsi utilitas langsung tanpa membuat instance:
@@ -60,7 +83,13 @@ import { idFilter } from '@sideid/id-profanity-filter';
 
 const teks = 'Dasar anjing kamu, jangan banyak bacot!';
 const hasil = idFilter.filter(teks);
-console.log(hasil.filtered); // Output: "Dasar **** kamu, jangan banyak ****!"
+console.log(hasil.filtered); // Output: "Dasar ***** kamu, jangan banyak *****!"
+
+// Menggunakan preset dengan API fungsi statis
+const presetResult = idFilter.filter(
+  teks,
+  idFilter.getPresetOptions('moderate'),
+);
 ```
 
 ## Dokumentasi API
@@ -103,6 +132,7 @@ Menganalisis teks untuk mendapatkan informasi detail tentang kata kotor yang dit
   - `categories`: Kategori kata kotor yang ditemukan
   - `regions`: Daerah asal kata kotor yang ditemukan
   - `severityScore`: Skor keparahan (0-1)
+  - `similarWords`: Kata-kata yang mirip dengan kata kotor (jika deteksi kesamaan diaktifkan)
 
 ##### `batchAnalyze(texts: string[])`
 
@@ -122,6 +152,13 @@ Menganalisis teks dengan konteks di sekitar kata kotor.
 
 - **Hasil**: Array dari kata kotor dengan konteks di sekitarnya
 
+##### `usePreset(presetName: string, additionalOptions?: Partial<FilterOptions>)`
+
+Menggunakan preset filter yang telah ditentukan.
+
+- **presetName**: Nama preset ('strict', 'moderate', 'light', 'childSafe', dll)
+- **additionalOptions**: Opsi tambahan untuk override preset (opsional)
+
 ##### `setOptions(options: Partial<FilterOptions>)`
 
 Mengubah opsi filter.
@@ -138,10 +175,34 @@ Menambahkan kata ke whitelist (akan diabaikan dalam filter).
 
 Menghapus kata dari whitelist.
 
+##### `enableIndonesianVariations()`
+
+Mengaktifkan deteksi variasi ejaan Bahasa Indonesia.
+
+##### `enableSplitWordDetection()`
+
+Mengaktifkan deteksi kata yang dipisah.
+
+##### `enableSimilarityDetection(threshold: number = 0.8, useLevenshtein: boolean = false, maxLevenshteinDistance: number = 2)`
+
+Mengaktifkan deteksi berdasarkan kesamaan kata.
+
+- **threshold**: Ambang batas kesamaan (0-1, default: 0.8)
+- **useLevenshtein**: Gunakan algoritma Levenshtein untuk deteksi (default: false)
+- **maxLevenshteinDistance**: Jarak edit maksimum yang diizinkan (default: 2)
+
+##### `enableLevenshteinDetection(threshold: number = 0.8, maxDistance: number = 2)`
+
+Mengaktifkan deteksi berbasis jarak Levenshtein.
+
+- **threshold**: Ambang batas kesamaan (0-1, default: 0.8)
+- **maxDistance**: Jarak edit maksimum yang diizinkan (default: 2)
+
 ### Opsi Filter
 
 ```typescript
 interface FilterOptions {
+  // Opsi dasar
   wordList?: string[]; // List kata yang ingin difilter
   replaceWith?: string; // Karakter pengganti untuk kata yang disensor
   fullWordCensor?: boolean; // Apakah menyensor seluruh kata atau sebagian
@@ -151,9 +212,44 @@ interface FilterOptions {
   categories?: ProfanityCategory[]; // Kategori kata yang difilter
   regions?: Region[]; // Daerah asal kata yang difilter
   severityThreshold?: number; // Tingkat keparahan minimum (0-1)
+
+  // Opsi lanjutan
+  useRandomGrawlix?: boolean; // Gunakan karakter acak untuk sensor (#@$%&!)
+  keepFirstAndLast?: boolean; // Simpan huruf pertama dan terakhir (a***g)
+  indonesianVariation?: boolean; // Deteksi variasi ejaan Bahasa Indonesia
+  detectSimilarity?: boolean; // Deteksi kata berdasarkan kesamaan
+  similarityThreshold?: number; // Ambang batas kesamaan (0-1)
+  detectSplit?: boolean; // Deteksi kata yang dipisah (a-n-j-i-n-g)
+  useLevenshtein?: boolean; // Gunakan algoritma Levenshtein untuk deteksi kesamaan
+  maxLevenshteinDistance?: number; // Jarak edit maksimum untuk deteksi Levenshtein
 }
 ```
 
+## Preset Filter
+
+Library ini menyediakan beberapa preset yang dapat digunakan:
+
+### Preset Filter
+
+- **strict**: Filter paling ketat, mendeteksi semua jenis kata kotor
+- **moderate**: Filter tingkat menengah, mengabaikan kata-kata dengan tingkat keparahan rendah
+- **light**: Filter ringan, hanya untuk kata-kata paling sensitif
+- **childSafe**: Filter untuk konten anak-anak, sangat ketat
+
+### Preset Kategori
+
+- **sexual**: Hanya memfilter kata-kata berbau seksual
+- **insults**: Hanya memfilter kata-kata penghinaan
+- **profanity**: Hanya memfilter umpatan umum
+
+### Preset Regional
+
+- **general**: Hanya memfilter kata-kata umum di Indonesia
+- **jawa**: Hanya memfilter kata-kata dari Jawa
+- **sunda**: Hanya memfilter kata-kata dari Sunda
+- **betawi**: Hanya memfilter kata-kata dari Betawi
+- **batak**: Hanya memfilter kata-kata dari Batak
+
 ## Contoh Penggunaan Lanjutan
 
 ### Kustomisasi Opsi Filter
@@ -166,12 +262,16 @@ const filter = new IDProfanityFilter({
   categories: ['sexual', 'slur'], // Hanya filter kategori tertentu
   regions: ['jawa', 'general'], // Hanya filter dari daerah tertentu
   severityThreshold: 0.7, // Hanya filter kata dengan tingkat keparahan ≥ 0.7
-});
 
-// Atau mengubah opsi setelah inisialisasi
-filter.setOptions({
-  replaceWith: '@',
-  fullWordCensor: true,
+  // Opsi lanjutan
+  useRandomGrawlix: true, // Gunakan #@$%&! sebagai karakter pengganti
+  keepFirstAndLast: true, // Simpan huruf pertama dan terakhir (a***g)
+  indonesianVariation: true, // Deteksi variasi ejaan Indonesia
+  detectSimilarity: true, // Deteksi kata yang mirip
+  similarityThreshold: 0.8, // Ambang batas kesamaan
+  detectSplit: true, // Deteksi kata yang dipisah
+  useLevenshtein: true, // Gunakan algoritma Levenshtein
+  maxLevenshteinDistance: 2, // Jarak Levenshtein maksimum
 });
 ```
 
@@ -191,6 +291,102 @@ console.log(hasil.filtered);
 // Output: "Anjing itu hewan peliharaan yang setia, tidak seperti ******* itu"
 ```
 
+### Deteksi Variasi Ejaan dan Kata Terpisah
+
+```typescript
+// Aktifkan deteksi variasi ejaan dan kata terpisah
+const filter = new IDProfanityFilter({
+  indonesianVariation: true,
+  detectSplit: true,
+  detectLeetSpeak: true,
+});
+
+// Uji dengan variasi ejaan
+const teks1 = 'Dasar kamu ini sangat bodoh, benar-benar b0d0h dan b-o-d-o-h!';
+const hasil1 = filter.filter(teks1);
+console.log(hasil1.filtered);
+// Output: "Dasar kamu ini sangat *****, benar-benar ***** dan *********!"
+
+// Uji dengan ejaan Indonesia yang berbeda
+const teks2 = 'Dia sangat djail dan djudes dengan temannya';
+const hasil2 = filter.filter(teks2);
+console.log(hasil2.filtered);
+// Output: "Dia sangat ***** dan ****** dengan temannya"
+```
+
+### Deteksi Berdasarkan Kesamaan (Similarity Detection)
+
+```typescript
+// Aktifkan deteksi kesamaan standar
+const filter = new IDProfanityFilter();
+filter.enableSimilarityDetection(0.75); // Set threshold kesamaan ke 0.75
+
+const teks = 'Dia benar-benar anjiing dan gooblok!';
+const analisis = filter.analyze(teks);
+
+console.log(analisis.similarWords);
+/* Output:
+[
+  { word: "anjiing", original: "anjing", similarity: 0.83 },
+  { word: "gooblok", original: "goblok", similarity: 0.85 }
+]
+*/
+
+const hasil = filter.filter(teks);
+console.log(hasil.filtered);
+// Output: "Dia benar-benar ****** dan *******!"
+```
+
+### Deteksi dengan Algoritma Levenshtein Distance
+
+```typescript
+// Aktifkan deteksi menggunakan algoritma Levenshtein Distance
+const filter = new IDProfanityFilter();
+filter.enableLevenshteinDetection(0.85, 2);
+// Threshold 0.85, maksimal 2 karakter berbeda
+
+const teks = 'Dia benar-benar konntol dan anjiing sekali!';
+const hasil = filter.filter(teks);
+
+console.log(hasil.filtered);
+// Output: "Dia benar-benar ******* dan ****** sekali!"
+
+// Atau menggunakan opsi langsung:
+const filterCustom = new IDProfanityFilter({
+  detectSimilarity: true,
+  useLevenshtein: true,
+  similarityThreshold: 0.85,
+  maxLevenshteinDistance: 2,
+});
+
+// Mendeteksi typo atau variasi disengaja
+const teksVariasi = 'kontool kamu kwontol anjiing';
+console.log(filterCustom.filter(teksVariasi).filtered);
+// Output: "******* kamu ******* ******"
+```
+
+### Variasi Sensor Kata
+
+```typescript
+// Sensor standar (asterisk)
+const filter1 = new IDProfanityFilter();
+console.log(filter1.filter('Dasar anjing kamu!').filtered);
+// Output: "Dasar ***** kamu!"
+
+// Sensor dengan grawlix random
+const filter2 = new IDProfanityFilter({ useRandomGrawlix: true });
+console.log(filter2.filter('Dasar anjing kamu!').filtered);
+// Output: "Dasar #@$%& kamu!"
+
+// Sensor dengan menyimpan huruf pertama dan terakhir
+const filter3 = new IDProfanityFilter({
+  fullWordCensor: false,
+  keepFirstAndLast: true,
+});
+console.log(filter3.filter('Dasar anjing kamu!').filtered);
+// Output: "Dasar a***g kamu!"
+```
+
 ### Analisis Konten Mendalam
 
 ```typescript
@@ -217,6 +413,57 @@ console.log(analisis);
 */
 ```
 
+### Analisis Konteks
+
+```typescript
+const filter = new IDProfanityFilter();
+const teks =
+  'Saya sangat marah dengan sikapnya, dia benar-benar anjing dan bajingan!';
+
+// Analisis konteks
+const konteks = filter.analyzeWithContext(teks, 3);
+console.log(konteks);
+
+/* Output:
+[
+  {
+    word: "anjing",
+    context: "benar-benar anjing dan bajingan",
+    position: { start: 43, end: 62 }
+  },
+  {
+    word: "bajingan",
+    context: "anjing dan bajingan!",
+    position: { start: 54, end: 63 }
+  }
+]
+*/
+```
+
+### Analisis Per-Kalimat
+
+```typescript
+const filter = new IDProfanityFilter();
+const teks =
+  'Filmnya bagus sekali. Tetapi pemainnya seperti anjing, sangat buruk aktingnya.';
+
+// Analisis per-kalimat
+const kalimat = filter.analyzeBySentence(teks);
+console.log(
+  kalimat.map(
+    (k) =>
+      k.sentence + (k.hasProfanity ? ' (Mengandung kata kotor)' : ' (Bersih)'),
+  ),
+);
+
+/* Output:
+[
+  "Filmnya bagus sekali. (Bersih)",
+  "Tetapi pemainnya seperti anjing, sangat buruk aktingnya. (Mengandung kata kotor)"
+]
+*/
+```
+
 ### Analisis Batch
 
 ```typescript
@@ -258,8 +505,6 @@ Library ini mendukung kata-kata kotor dari berbagai daerah di Indonesia:
 - 🏙️ **Betawi** - Kata-kata dari bahasa Betawi
 - 🌋 **Batak** - Kata-kata dari bahasa Batak
 
-Dan daerah lainnya yang terus bertambah.
-
 ## Kategori Kata
 
 Kata-kata dikelompokkan berdasarkan kategori:
@@ -276,6 +521,24 @@ Kata-kata dikelompokkan berdasarkan kategori:
 
 Kami sangat menghargai kontribusi Anda! Untuk berkontribusi, silakan lihat [panduan kontribusi](CONTRIBUTING.md).
 
+### Menambahkan Kata Baru
+
+Jika Anda ingin menambahkan kata baru ke database, silakan buat pull request dengan mengubah file yang sesuai di `src/constants/categories/` atau `src/constants/regions/`.
+
+Format untuk menambahkan kata baru:
+
+```json
+{
+  "word": "kata_kotor", // Kata yang akan difilter
+  "category": "insult", // Kategori kata
+  "region": "general", // Daerah asal kata
+  "severity": 0.7, // Tingkat keparahan (0-1)
+  "aliases": ["k4t4_kotor", "kata_k0t0r"], // Alias atau variasi umum
+  "description": "Deskripsi tentang kata", // Penjelasan tentang kata (opsional)
+  "context": "Konteks penggunaan kata" // Konteks penggunaan (opsional)
+}
+```
+
 ## Lisensi
 
 Proyek ini dilisensikan di bawah [MIT License](LICENSE).

package/dist/config/options.d.ts

@@ -17,6 +17,8 @@ export declare const FILTER_PRESETS: {
         detectSimilarity?: boolean;
         similarityThreshold?: number;
         detectSplit?: boolean;
+        useLevenshtein?: boolean;
+        maxLevenshteinDistance?: number;
     };
     moderate: {
         severityThreshold: number;
@@ -34,6 +36,8 @@ export declare const FILTER_PRESETS: {
         detectSimilarity?: boolean;
         similarityThreshold?: number;
         detectSplit?: boolean;
+        useLevenshtein?: boolean;
+        maxLevenshteinDistance?: number;
     };
     light: {
         severityThreshold: number;
@@ -51,6 +55,8 @@ export declare const FILTER_PRESETS: {
         detectSimilarity?: boolean;
         similarityThreshold?: number;
         detectSplit?: boolean;
+        useLevenshtein?: boolean;
+        maxLevenshteinDistance?: number;
     };
     childSafe: {
         checkSubstring: boolean;
@@ -68,6 +74,8 @@ export declare const FILTER_PRESETS: {
         detectSimilarity?: boolean;
         similarityThreshold?: number;
         detectSplit?: boolean;
+        useLevenshtein?: boolean;
+        maxLevenshteinDistance?: number;
     };
 };
 export declare const CATEGORY_PRESETS: {
@@ -87,6 +95,8 @@ export declare const CATEGORY_PRESETS: {
         detectSimilarity?: boolean;
         similarityThreshold?: number;
         detectSplit?: boolean;
+        useLevenshtein?: boolean;
+        maxLevenshteinDistance?: number;
     };
     insults: {
         categories: ProfanityCategory[];
@@ -104,6 +114,8 @@ export declare const CATEGORY_PRESETS: {
         detectSimilarity?: boolean;
         similarityThreshold?: number;
         detectSplit?: boolean;
+        useLevenshtein?: boolean;
+        maxLevenshteinDistance?: number;
     };
     profanity: {
         categories: ProfanityCategory[];
@@ -121,6 +133,8 @@ export declare const CATEGORY_PRESETS: {
         detectSimilarity?: boolean;
         similarityThreshold?: number;
         detectSplit?: boolean;
+        useLevenshtein?: boolean;
+        maxLevenshteinDistance?: number;
     };
 };
 export declare const REGION_PRESETS: {
@@ -140,6 +154,8 @@ export declare const REGION_PRESETS: {
         detectSimilarity?: boolean;
         similarityThreshold?: number;
         detectSplit?: boolean;
+        useLevenshtein?: boolean;
+        maxLevenshteinDistance?: number;
     };
     jawa: {
         regions: Region[];
@@ -157,6 +173,8 @@ export declare const REGION_PRESETS: {
         detectSimilarity?: boolean;
         similarityThreshold?: number;
         detectSplit?: boolean;
+        useLevenshtein?: boolean;
+        maxLevenshteinDistance?: number;
     };
     sunda: {
         regions: Region[];
@@ -174,6 +192,8 @@ export declare const REGION_PRESETS: {
         detectSimilarity?: boolean;
         similarityThreshold?: number;
         detectSplit?: boolean;
+        useLevenshtein?: boolean;
+        maxLevenshteinDistance?: number;
     };
     betawi: {
         regions: Region[];
@@ -191,6 +211,8 @@ export declare const REGION_PRESETS: {
         detectSimilarity?: boolean;
         similarityThreshold?: number;
         detectSplit?: boolean;
+        useLevenshtein?: boolean;
+        maxLevenshteinDistance?: number;
     };
     batak: {
         regions: Region[];
@@ -208,6 +230,8 @@ export declare const REGION_PRESETS: {
         detectSimilarity?: boolean;
         similarityThreshold?: number;
         detectSplit?: boolean;
+        useLevenshtein?: boolean;
+        maxLevenshteinDistance?: number;
     };
 };
 export declare const REPLACEMENT_CHARS: {

package/dist/constants/categories/index.d.ts

@@ -0,0 +1,9 @@
+import { sexual } from './sexual';
+import { insult } from './insult';
+export declare const categories: {
+    sexual: import("../..").ProfanityWord[];
+    insult: import("../..").ProfanityWord[];
+};
+export { sexual, insult };
+export declare const allCategoryWords: import("../..").ProfanityWord[];
+export default allCategoryWords;

package/dist/constants/regions/index.d.ts

@@ -0,0 +1,8 @@
+import { general } from './general';
+import { jawa } from './jawa';
+import { sunda } from './sunda';
+import { betawi } from './betawi';
+import { batak } from './batak';
+export { general, jawa, sunda, betawi, batak, };
+export declare const allRegionWords: import("../..").ProfanityWord[];
+export default allRegionWords;

package/dist/constants/wordList.d.ts

@@ -1,4 +1,4 @@
-import { ProfanityWord } from "../types";
+import { ProfanityWord } from '../types';
 export declare const wordCategories: {
     sexual: string[];
     insult: string[];

package/dist/core/analyzer.d.ts

@@ -1,4 +1,4 @@
-import { FilterOptions, AnalysisResult, ProfanityCategory, Region } from "../types";
+import { FilterOptions, AnalysisResult, ProfanityCategory, Region } from '../types';
 /**
  * Menganalisis teks untuk kata kotor
  *

package/dist/core/filter.d.ts

@@ -1,4 +1,4 @@
-import { FilterOptions, FilterResult } from "../types";
+import { FilterOptions, FilterResult } from '../types';
 /**
  * Menyensor kata kotor dalam teks
  *

package/dist/core/matcher.d.ts

@@ -1,4 +1,4 @@
-import { ProfanityWord, ProfanityCategory, Region, FilterOptions } from "../types";
+import { ProfanityWord, ProfanityCategory, Region, FilterOptions } from '../types';
 export declare function findProfanity(text: string, options?: FilterOptions): string[];
 /**
  * Mencari kata kotor lengkap dengan metadata

package/dist/index.d.ts

@@ -25,6 +25,8 @@ interface FilterOptions {
     detectSimilarity?: boolean;
     similarityThreshold?: number;
     detectSplit?: boolean;
+    useLevenshtein?: boolean;
+    maxLevenshteinDistance?: number;
 }
 interface FilterResult {
     filtered: string;