@sideid/id-profanity-filter 1.1.0 → 1.9.5

package/dist/config/options.d.ts

@@ -0,0 +1,258 @@
+import { FilterOptions, ProfanityCategory, Region } from "../types";
+export declare const DEFAULT_OPTIONS: FilterOptions;
+export declare const FILTER_PRESETS: {
+    strict: {
+        checkSubstring: boolean;
+        detectLeetSpeak: boolean;
+        severityThreshold: number;
+        replaceWith?: string;
+        fullWordCensor?: boolean;
+        wordList?: string[];
+        whitelist?: string[];
+        categories?: ProfanityCategory[];
+        regions?: Region[];
+        useRandomGrawlix?: boolean;
+        keepFirstAndLast?: boolean;
+        indonesianVariation?: boolean;
+        detectSimilarity?: boolean;
+        similarityThreshold?: number;
+        detectSplit?: boolean;
+    };
+    moderate: {
+        severityThreshold: number;
+        replaceWith?: string;
+        fullWordCensor?: boolean;
+        detectLeetSpeak?: boolean;
+        checkSubstring?: boolean;
+        wordList?: string[];
+        whitelist?: string[];
+        categories?: ProfanityCategory[];
+        regions?: Region[];
+        useRandomGrawlix?: boolean;
+        keepFirstAndLast?: boolean;
+        indonesianVariation?: boolean;
+        detectSimilarity?: boolean;
+        similarityThreshold?: number;
+        detectSplit?: boolean;
+    };
+    light: {
+        severityThreshold: number;
+        categories: ProfanityCategory[];
+        replaceWith?: string;
+        fullWordCensor?: boolean;
+        detectLeetSpeak?: boolean;
+        checkSubstring?: boolean;
+        wordList?: string[];
+        whitelist?: string[];
+        regions?: Region[];
+        useRandomGrawlix?: boolean;
+        keepFirstAndLast?: boolean;
+        indonesianVariation?: boolean;
+        detectSimilarity?: boolean;
+        similarityThreshold?: number;
+        detectSplit?: boolean;
+    };
+    childSafe: {
+        checkSubstring: boolean;
+        detectLeetSpeak: boolean;
+        fullWordCensor: boolean;
+        severityThreshold: number;
+        replaceWith?: string;
+        wordList?: string[];
+        whitelist?: string[];
+        categories?: ProfanityCategory[];
+        regions?: Region[];
+        useRandomGrawlix?: boolean;
+        keepFirstAndLast?: boolean;
+        indonesianVariation?: boolean;
+        detectSimilarity?: boolean;
+        similarityThreshold?: number;
+        detectSplit?: boolean;
+    };
+};
+export declare const CATEGORY_PRESETS: {
+    sexual: {
+        categories: ProfanityCategory[];
+        replaceWith?: string;
+        fullWordCensor?: boolean;
+        detectLeetSpeak?: boolean;
+        checkSubstring?: boolean;
+        wordList?: string[];
+        whitelist?: string[];
+        regions?: Region[];
+        severityThreshold?: number;
+        useRandomGrawlix?: boolean;
+        keepFirstAndLast?: boolean;
+        indonesianVariation?: boolean;
+        detectSimilarity?: boolean;
+        similarityThreshold?: number;
+        detectSplit?: boolean;
+    };
+    insults: {
+        categories: ProfanityCategory[];
+        replaceWith?: string;
+        fullWordCensor?: boolean;
+        detectLeetSpeak?: boolean;
+        checkSubstring?: boolean;
+        wordList?: string[];
+        whitelist?: string[];
+        regions?: Region[];
+        severityThreshold?: number;
+        useRandomGrawlix?: boolean;
+        keepFirstAndLast?: boolean;
+        indonesianVariation?: boolean;
+        detectSimilarity?: boolean;
+        similarityThreshold?: number;
+        detectSplit?: boolean;
+    };
+    profanity: {
+        categories: ProfanityCategory[];
+        replaceWith?: string;
+        fullWordCensor?: boolean;
+        detectLeetSpeak?: boolean;
+        checkSubstring?: boolean;
+        wordList?: string[];
+        whitelist?: string[];
+        regions?: Region[];
+        severityThreshold?: number;
+        useRandomGrawlix?: boolean;
+        keepFirstAndLast?: boolean;
+        indonesianVariation?: boolean;
+        detectSimilarity?: boolean;
+        similarityThreshold?: number;
+        detectSplit?: boolean;
+    };
+};
+export declare const REGION_PRESETS: {
+    general: {
+        regions: Region[];
+        replaceWith?: string;
+        fullWordCensor?: boolean;
+        detectLeetSpeak?: boolean;
+        checkSubstring?: boolean;
+        wordList?: string[];
+        whitelist?: string[];
+        categories?: ProfanityCategory[];
+        severityThreshold?: number;
+        useRandomGrawlix?: boolean;
+        keepFirstAndLast?: boolean;
+        indonesianVariation?: boolean;
+        detectSimilarity?: boolean;
+        similarityThreshold?: number;
+        detectSplit?: boolean;
+    };
+    jawa: {
+        regions: Region[];
+        replaceWith?: string;
+        fullWordCensor?: boolean;
+        detectLeetSpeak?: boolean;
+        checkSubstring?: boolean;
+        wordList?: string[];
+        whitelist?: string[];
+        categories?: ProfanityCategory[];
+        severityThreshold?: number;
+        useRandomGrawlix?: boolean;
+        keepFirstAndLast?: boolean;
+        indonesianVariation?: boolean;
+        detectSimilarity?: boolean;
+        similarityThreshold?: number;
+        detectSplit?: boolean;
+    };
+    sunda: {
+        regions: Region[];
+        replaceWith?: string;
+        fullWordCensor?: boolean;
+        detectLeetSpeak?: boolean;
+        checkSubstring?: boolean;
+        wordList?: string[];
+        whitelist?: string[];
+        categories?: ProfanityCategory[];
+        severityThreshold?: number;
+        useRandomGrawlix?: boolean;
+        keepFirstAndLast?: boolean;
+        indonesianVariation?: boolean;
+        detectSimilarity?: boolean;
+        similarityThreshold?: number;
+        detectSplit?: boolean;
+    };
+    betawi: {
+        regions: Region[];
+        replaceWith?: string;
+        fullWordCensor?: boolean;
+        detectLeetSpeak?: boolean;
+        checkSubstring?: boolean;
+        wordList?: string[];
+        whitelist?: string[];
+        categories?: ProfanityCategory[];
+        severityThreshold?: number;
+        useRandomGrawlix?: boolean;
+        keepFirstAndLast?: boolean;
+        indonesianVariation?: boolean;
+        detectSimilarity?: boolean;
+        similarityThreshold?: number;
+        detectSplit?: boolean;
+    };
+    batak: {
+        regions: Region[];
+        replaceWith?: string;
+        fullWordCensor?: boolean;
+        detectLeetSpeak?: boolean;
+        checkSubstring?: boolean;
+        wordList?: string[];
+        whitelist?: string[];
+        categories?: ProfanityCategory[];
+        severityThreshold?: number;
+        useRandomGrawlix?: boolean;
+        keepFirstAndLast?: boolean;
+        indonesianVariation?: boolean;
+        detectSimilarity?: boolean;
+        similarityThreshold?: number;
+        detectSplit?: boolean;
+    };
+};
+export declare const REPLACEMENT_CHARS: {
+    asterisk: string;
+    hash: string;
+    dollar: string;
+    at: string;
+    percent: string;
+    underscore: string;
+    dash: string;
+    dot: string;
+    grawlix: string;
+};
+/**
+ * Membuat opsi custom dengan menggabungkan dengan default
+ *
+ * @param options Opsi yang akan digabungkan dengan default
+ * @returns Opsi yang sudah digabungkan
+ */
+export declare function createOptions(options?: Partial<FilterOptions>): FilterOptions;
+/**
+ * Mendapatkan opsi dari preset yang ada
+ *
+ * @param presetName Nama preset filter, kategori, atau region
+ * @param additionalOptions Opsi tambahan untuk mengganti preset
+ * @returns Opsi yang sudah digabungkan
+ */
+export declare function getPresetOptions(presetName: string, additionalOptions?: Partial<FilterOptions>): FilterOptions;
+/**
+ * Mendapatkan karakter pengganti
+ *
+ * @param type Tipe karakter pengganti
+ * @returns Karakter pengganti
+ */
+export declare function getReplacementChar(type?: keyof typeof REPLACEMENT_CHARS): string;
+/**
+ * Membuat karakter pengganti random dari grawlix
+ *
+ * @returns Karakter pengganti random
+ */
+export declare function getRandomGrawlix(): string;
+/**
+ * Membuat string pengganti untuk kata menggunakan grawlix random
+ *
+ * @param length Panjang string
+ * @returns String pengganti
+ */
+export declare function makeRandomGrawlixString(length: number): string;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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
  *
@@ -8,9 +8,9 @@ import { FilterOptions, AnalysisResult, ProfanityCategory, Region } from '../typ
  */
 export declare function analyze(text: string, options?: FilterOptions): AnalysisResult;
 /**
- * menganalisis daftar teks dan ringkasan
+ * Menganalisis daftar teks dan ringkasan
  *
- * @param texts Daftar teks yagn dianalisis
+ * @param texts Daftar teks yang dianalisis
  * @param options Opsi untuk analisis
  * @return Objek dengan ringkasan analisis
  */
@@ -40,7 +40,7 @@ export declare function analyzeBySentence(text: string, options?: FilterOptions)
  * Menganalisis teks untuk menemukan kata kotor pada konteks tertentu
  *
  * @param text Teks yang akan dianalisis
- * @param context Kata konteks untuk dicari di dekat kata kotor
+ * @param contextWindowSize Ukuran konteks (jumlah kata) di sekitar kata kotor
  * @param options Opsi untuk analisis
  * @returns Konteks di dekat 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
@@ -11,15 +11,15 @@ export declare function findProfanityWithMetadata(text: string, options?: Filter
 /**
  * Mencari kategory kata kotor yang ada dalam teks
  *
- * @param text matchDetails Hasil pencarian dari fingProfanityWithMetadata()
- * @param options Opsi untuk pencarian kategori
+ * @param matchDetails Hasil pencarian dari fingProfanityWithMetadata()
+ * @return Array kategori unik
  */
 export declare function findCategories(matchDetails: ProfanityWord[]): ProfanityCategory[];
 /**
  * Mencari region kata kotor yang ada dalam teks
  *
- * @param text matchDetails Hasil pencarian dari fingProfanityWithMetadata()
- * @param options Opsi untuk pencarian region
+ * @param matchDetails Hasil pencarian dari fingProfanityWithMetadata()
+ * @return Array region unik
  */
 export declare function findRegions(matchDetails: ProfanityWord[]): Region[];
 /**

package/dist/index.d.ts

@@ -1,8 +1,5 @@
-type ProfanityCategory = 'sexual' | 'insult' | 'profanity' | 'slur' | 'drugs' | 'disgusting' | 'blasphemy';
-type Region = 'general' | 'jawa' | 'sunda' | 'betawi' | 'batak' | 'minang' | 'bali' | 'madura' | 'bugis' | 'aceh' | 'ambon' | 'papua' | 'manado' | 'banjar' | 'palembang' | 'lampung' | 'ntt' | 'ntb';
-/**
- * Definisi kata kotor
- */
+type ProfanityCategory = "sexual" | "insult" | "profanity" | "slur" | "drugs" | "disgusting" | "blasphemy";
+type Region = "general" | "jawa" | "sunda" | "betawi" | "batak" | "minang" | "bali" | "madura" | "bugis" | "aceh" | "ambon" | "papua" | "manado" | "banjar" | "palembang" | "lampung" | "ntt" | "ntb";
 interface ProfanityWord {
     word: string;
     category: ProfanityCategory;
@@ -12,60 +9,51 @@ interface ProfanityWord {
     description?: string;
     context?: string;
 }
-/**
- * Opsi untuk konfigurasi filter
- */
 interface FilterOptions {
-    /** List kata yang ingin difilter */
-    wordList?: string[];
-    /** Karakter pengganti untuk kata yang disensor */
     replaceWith?: string;
-    /** Apakah harus menyensor seluruh kata atau hanya sebagian */
     fullWordCensor?: boolean;
-    /** Apakah harus mendeteksi kata dengan variasi penulisan */
     detectLeetSpeak?: boolean;
-    /** Mengabaikan kata-kata dalam konteks tertentu (misalnya nama) */
-    whitelist?: string[];
-    /** Apakah harus memeriksa substring (lebih ketat) */
     checkSubstring?: boolean;
-    /** Kategori kata yang ingin difilter */
+    wordList?: string[];
+    whitelist?: string[];
     categories?: ProfanityCategory[];
-    /** Daerah yang ingin difilter katanya */
     regions?: Region[];
-    /** Tingkat keparahan minimum yang akan difilter (0-1) */
     severityThreshold?: number;
+    useRandomGrawlix?: boolean;
+    keepFirstAndLast?: boolean;
+    indonesianVariation?: boolean;
+    detectSimilarity?: boolean;
+    similarityThreshold?: number;
+    detectSplit?: boolean;
+}
+interface FilterResult {
+    filtered: string;
+    censored: number;
+    replacements: Array<{
+        original: string;
+        censored: string;
+        metadata?: ProfanityWord;
+    }>;
 }
-/**
- * Hasil analisis dari teks
- */
 interface AnalysisResult {
-    /** Apakah teks mengandung kata kotor */
     hasProfanity: boolean;
-    /** Daftar kata kotor yang ditemukan */
     matches: string[];
-    /** Daftar kata kotor lengkap dengan metadata */
     matchDetails: ProfanityWord[];
-    /** Daftar kategori kata kotor yang ditemukan */
     categories: ProfanityCategory[];
-    /** Daftar daerah asal kata kotor yang ditemukan */
     regions: Region[];
-    /** Tingkat keparahan (0-1) berdasarkan jumlah dan jenis kata */
     severityScore: number;
-}
-/**
- * Hasil filter dari teks
- */
-interface FilterResult {
-    /** Teks hasil filter */
-    filtered: string;
-    /** Jumlah kata yang disensor */
-    censored: number;
-    /** Kata asli yang disensor dan penggantinya */
-    replacements: Array<{
+    similarWords?: Array<{
+        word: string;
         original: string;
-        censored: string;
-        metadata?: ProfanityWord;
+        similarity: number;
     }>;
 }
+interface RegexOptions {
+    wholeWord?: boolean;
+    caseSensitive?: boolean;
+    leetSpeak?: boolean;
+    detectSplit?: boolean;
+    indonesianVariation?: boolean;
+}
 
-export type { AnalysisResult, FilterOptions, FilterResult, ProfanityCategory, ProfanityWord, Region };
+export type { AnalysisResult, FilterOptions, FilterResult, ProfanityCategory, ProfanityWord, RegexOptions, Region };