@sideid/id-profanity-filter 1.10.6 → 1.11.5

package/dist/types/index.d.ts

@@ -1,59 +1,377 @@
-export type ProfanityCategory = "sexual" | "insult" | "profanity" | "slur" | "drugs" | "disgusting" | "blasphemy";
-export type Region = "general" | "jawa" | "sunda" | "betawi" | "batak" | "minang" | "bali" | "madura" | "bugis" | "aceh" | "ambon" | "papua" | "manado" | "banjar" | "palembang" | "lampung" | "ntt" | "ntb";
-export interface ProfanityWord {
-    word: string;
-    category: ProfanityCategory;
-    region: Region;
-    severity: number;
-    aliases?: string[];
-    description?: string;
-    context?: string;
-}
-export interface FilterOptions {
-    replaceWith?: string;
-    fullWordCensor?: boolean;
-    detectLeetSpeak?: boolean;
-    checkSubstring?: boolean;
-    wordList?: string[];
-    whitelist?: string[];
-    categories?: ProfanityCategory[];
-    regions?: Region[];
-    severityThreshold?: number;
-    useRandomGrawlix?: boolean;
-    keepFirstAndLast?: boolean;
-    indonesianVariation?: boolean;
-    detectSimilarity?: boolean;
-    similarityThreshold?: number;
-    detectSplit?: boolean;
-    useLevenshtein?: boolean;
-    maxLevenshteinDistance?: number;
-}
-export interface FilterResult {
-    filtered: string;
-    censored: number;
-    replacements: Array<{
-        original: string;
-        censored: string;
-        metadata?: ProfanityWord;
-    }>;
-}
-export interface AnalysisResult {
-    hasProfanity: boolean;
-    matches: string[];
-    matchDetails: ProfanityWord[];
-    categories: ProfanityCategory[];
-    regions: Region[];
-    severityScore: number;
-    similarWords?: Array<{
+export * from './types';
+export * from './core/matcher';
+export * from './core/filter';
+export * from './core/analyzer';
+export * from './utils/stringUtils';
+export * from './utils/regexUtils';
+export * from './utils/similarityUtils';
+export * from './config/options';
+import { FilterOptions, FilterResult, AnalysisResult } from './types';
+import { getPresetOptions } from './config/options';
+export declare class IDProfanityFilter {
+    private options;
+    /**
+     * Membuat instance filter baru
+     * @param options Opsi untuk filter
+     */
+    constructor(options?: FilterOptions);
+    /**
+     * Menyensor teks yang diberikan
+     * @param text Teks yang akan disensor
+     * @returns Hasil filter
+     */
+    filter(text: string): FilterResult;
+    /**
+     * Memeriksa apakah teks mengandung kata kotor
+     * @param text Teks yang akan diperiksa
+     * @returns Boolean apakah teks mengandung kata kotor
+     */
+    isProfane(text: string): boolean;
+    /**
+     * Menganalisis teks untuk kata kotor
+     * @param text Teks yang akan dianalisis
+     * @returns Hasil analisis
+     */
+    analyze(text: string): AnalysisResult;
+    /**
+     * Menganalisis batch teks untuk kata kotor
+     * @param texts Array dari teks yang akan dianalisis
+     * @returns Hasil analisis batch
+     */
+    batchAnalyze(texts: string[]): {
+        totalTexts: number;
+        profaneTexts: number;
+        cleanTexts: number;
+        averageSeverity: number;
+        topCategories: import("./types").ProfanityCategory[];
+        topRegions: import("./types").Region[];
+        mostFrequentWords: Array<{
+            word: string;
+            count: number;
+        }>;
+    };
+    /**
+     * Menganalisis teks per-kalimat
+     * @param text Teks yang akan dianalisis
+     * @returns Array hasil analisis per-kalimat
+     */
+    analyzeBySentence(text: string): (AnalysisResult & {
+        sentence: string;
+    })[];
+    /**
+     * Menganalisis teks dengan konteks di sekitar kata kotor
+     * @param text Teks yang akan dianalisis
+     * @param contextWindowSize Jumlah kata konteks
+     * @returns Konteks di dekat kata kotor
+     */
+    analyzeWithContext(text: string, contextWindowSize?: number): {
         word: string;
-        original: string;
-        similarity: number;
-    }>;
-}
-export interface RegexOptions {
-    wholeWord?: boolean;
-    caseSensitive?: boolean;
-    leetSpeak?: boolean;
-    detectSplit?: boolean;
-    indonesianVariation?: boolean;
+        context: string;
+        position: {
+            start: number;
+            end: number;
+        };
+    }[];
+    /**
+     * Mengubah opsi filter
+     * @param options Opsi baru untuk filter
+     */
+    setOptions(options: Partial<FilterOptions>): void;
+    /**
+     * Menggunakan preset yang telah ditentukan
+     * @param presetName Nama preset yang akan digunakan
+     * @param additionalOptions Opsi tambahan untuk override
+     */
+    usePreset(presetName: string, additionalOptions?: Partial<FilterOptions>): void;
+    /**
+     * Menetapkan daftar kata kustom
+     * @param wordList Daftar kata untuk digunakan
+     */
+    setWordList(wordList: string[]): void;
+    /**
+     * Menambahkan kata ke whitelist
+     * @param word Kata yang akan diabaikan
+     */
+    addToWhitelist(word: string): void;
+    /**
+     * Menghapus kata dari whitelist
+     * @param word Kata yang akan dihapus dari whitelist
+     */
+    removeFromWhitelist(word: string): void;
+    /**
+     * Mengaktifkan deteksi variasi ejaan Indonesia
+     */
+    enableIndonesianVariations(): void;
+    /**
+     * Mengaktifkan deteksi kata yang dipisah
+     */
+    enableSplitWordDetection(): void;
+    /**
+     * Mengaktifkan deteksi berdasarkan kesamaan
+     * @param threshold Threshold kesamaan (0-1)
+     * @param useLevenshtein Gunakan algoritma Levenshtein untuk deteksi
+     * @param maxLevenshteinDistance Jarak maksimal Levenshtein (default: 2)
+     */
+    enableSimilarityDetection(threshold?: number, useLevenshtein?: boolean, maxLevenshteinDistance?: number): void;
+    /**
+     * Mengaktifkan deteksi berbasis Levenshtein distance
+     * @param threshold Threshold kesamaan (0-1)
+     * @param maxDistance Jarak maksimal Levenshtein (default: 2)
+     */
+    enableLevenshteinDetection(threshold?: number, maxDistance?: number): void;
 }
+export declare const idFilter: {
+    filter: (text: string, options?: FilterOptions) => FilterResult;
+    isProfane: (text: string, options?: FilterOptions) => boolean;
+    analyze: (text: string, options?: FilterOptions) => AnalysisResult;
+    batchAnalyze: (texts: string[], options?: FilterOptions) => {
+        totalTexts: number;
+        profaneTexts: number;
+        cleanTexts: number;
+        averageSeverity: number;
+        topCategories: import("./types").ProfanityCategory[];
+        topRegions: import("./types").Region[];
+        mostFrequentWords: Array<{
+            word: string;
+            count: number;
+        }>;
+    };
+    getPresetOptions: typeof getPresetOptions;
+    presets: {
+        filter: {
+            strict: {
+                checkSubstring: boolean;
+                detectLeetSpeak: boolean;
+                severityThreshold: number;
+                replaceWith?: string;
+                fullWordCensor?: boolean;
+                wordList?: string[];
+                whitelist?: string[];
+                categories?: import("./types").ProfanityCategory[];
+                regions?: import("./types").Region[];
+                useRandomGrawlix?: boolean;
+                keepFirstAndLast?: boolean;
+                indonesianVariation?: boolean;
+                detectSimilarity?: boolean;
+                similarityThreshold?: number;
+                detectSplit?: boolean;
+                useLevenshtein?: boolean;
+                maxLevenshteinDistance?: number;
+            };
+            moderate: {
+                severityThreshold: number;
+                replaceWith?: string;
+                fullWordCensor?: boolean;
+                detectLeetSpeak?: boolean;
+                checkSubstring?: boolean;
+                wordList?: string[];
+                whitelist?: string[];
+                categories?: import("./types").ProfanityCategory[];
+                regions?: import("./types").Region[];
+                useRandomGrawlix?: boolean;
+                keepFirstAndLast?: boolean;
+                indonesianVariation?: boolean;
+                detectSimilarity?: boolean;
+                similarityThreshold?: number;
+                detectSplit?: boolean;
+                useLevenshtein?: boolean;
+                maxLevenshteinDistance?: number;
+            };
+            light: {
+                severityThreshold: number;
+                categories: import("./types").ProfanityCategory[];
+                replaceWith?: string;
+                fullWordCensor?: boolean;
+                detectLeetSpeak?: boolean;
+                checkSubstring?: boolean;
+                wordList?: string[];
+                whitelist?: string[];
+                regions?: import("./types").Region[];
+                useRandomGrawlix?: boolean;
+                keepFirstAndLast?: boolean;
+                indonesianVariation?: boolean;
+                detectSimilarity?: boolean;
+                similarityThreshold?: number;
+                detectSplit?: boolean;
+                useLevenshtein?: boolean;
+                maxLevenshteinDistance?: number;
+            };
+            childSafe: {
+                checkSubstring: boolean;
+                detectLeetSpeak: boolean;
+                fullWordCensor: boolean;
+                severityThreshold: number;
+                replaceWith?: string;
+                wordList?: string[];
+                whitelist?: string[];
+                categories?: import("./types").ProfanityCategory[];
+                regions?: import("./types").Region[];
+                useRandomGrawlix?: boolean;
+                keepFirstAndLast?: boolean;
+                indonesianVariation?: boolean;
+                detectSimilarity?: boolean;
+                similarityThreshold?: number;
+                detectSplit?: boolean;
+                useLevenshtein?: boolean;
+                maxLevenshteinDistance?: number;
+            };
+        };
+        category: {
+            sexual: {
+                categories: import("./types").ProfanityCategory[];
+                replaceWith?: string;
+                fullWordCensor?: boolean;
+                detectLeetSpeak?: boolean;
+                checkSubstring?: boolean;
+                wordList?: string[];
+                whitelist?: string[];
+                regions?: import("./types").Region[];
+                severityThreshold?: number;
+                useRandomGrawlix?: boolean;
+                keepFirstAndLast?: boolean;
+                indonesianVariation?: boolean;
+                detectSimilarity?: boolean;
+                similarityThreshold?: number;
+                detectSplit?: boolean;
+                useLevenshtein?: boolean;
+                maxLevenshteinDistance?: number;
+            };
+            insults: {
+                categories: import("./types").ProfanityCategory[];
+                replaceWith?: string;
+                fullWordCensor?: boolean;
+                detectLeetSpeak?: boolean;
+                checkSubstring?: boolean;
+                wordList?: string[];
+                whitelist?: string[];
+                regions?: import("./types").Region[];
+                severityThreshold?: number;
+                useRandomGrawlix?: boolean;
+                keepFirstAndLast?: boolean;
+                indonesianVariation?: boolean;
+                detectSimilarity?: boolean;
+                similarityThreshold?: number;
+                detectSplit?: boolean;
+                useLevenshtein?: boolean;
+                maxLevenshteinDistance?: number;
+            };
+            profanity: {
+                categories: import("./types").ProfanityCategory[];
+                replaceWith?: string;
+                fullWordCensor?: boolean;
+                detectLeetSpeak?: boolean;
+                checkSubstring?: boolean;
+                wordList?: string[];
+                whitelist?: string[];
+                regions?: import("./types").Region[];
+                severityThreshold?: number;
+                useRandomGrawlix?: boolean;
+                keepFirstAndLast?: boolean;
+                indonesianVariation?: boolean;
+                detectSimilarity?: boolean;
+                similarityThreshold?: number;
+                detectSplit?: boolean;
+                useLevenshtein?: boolean;
+                maxLevenshteinDistance?: number;
+            };
+        };
+        region: {
+            general: {
+                regions: import("./types").Region[];
+                replaceWith?: string;
+                fullWordCensor?: boolean;
+                detectLeetSpeak?: boolean;
+                checkSubstring?: boolean;
+                wordList?: string[];
+                whitelist?: string[];
+                categories?: import("./types").ProfanityCategory[];
+                severityThreshold?: number;
+                useRandomGrawlix?: boolean;
+                keepFirstAndLast?: boolean;
+                indonesianVariation?: boolean;
+                detectSimilarity?: boolean;
+                similarityThreshold?: number;
+                detectSplit?: boolean;
+                useLevenshtein?: boolean;
+                maxLevenshteinDistance?: number;
+            };
+            jawa: {
+                regions: import("./types").Region[];
+                replaceWith?: string;
+                fullWordCensor?: boolean;
+                detectLeetSpeak?: boolean;
+                checkSubstring?: boolean;
+                wordList?: string[];
+                whitelist?: string[];
+                categories?: import("./types").ProfanityCategory[];
+                severityThreshold?: number;
+                useRandomGrawlix?: boolean;
+                keepFirstAndLast?: boolean;
+                indonesianVariation?: boolean;
+                detectSimilarity?: boolean;
+                similarityThreshold?: number;
+                detectSplit?: boolean;
+                useLevenshtein?: boolean;
+                maxLevenshteinDistance?: number;
+            };
+            sunda: {
+                regions: import("./types").Region[];
+                replaceWith?: string;
+                fullWordCensor?: boolean;
+                detectLeetSpeak?: boolean;
+                checkSubstring?: boolean;
+                wordList?: string[];
+                whitelist?: string[];
+                categories?: import("./types").ProfanityCategory[];
+                severityThreshold?: number;
+                useRandomGrawlix?: boolean;
+                keepFirstAndLast?: boolean;
+                indonesianVariation?: boolean;
+                detectSimilarity?: boolean;
+                similarityThreshold?: number;
+                detectSplit?: boolean;
+                useLevenshtein?: boolean;
+                maxLevenshteinDistance?: number;
+            };
+            betawi: {
+                regions: import("./types").Region[];
+                replaceWith?: string;
+                fullWordCensor?: boolean;
+                detectLeetSpeak?: boolean;
+                checkSubstring?: boolean;
+                wordList?: string[];
+                whitelist?: string[];
+                categories?: import("./types").ProfanityCategory[];
+                severityThreshold?: number;
+                useRandomGrawlix?: boolean;
+                keepFirstAndLast?: boolean;
+                indonesianVariation?: boolean;
+                detectSimilarity?: boolean;
+                similarityThreshold?: number;
+                detectSplit?: boolean;
+                useLevenshtein?: boolean;
+                maxLevenshteinDistance?: number;
+            };
+            batak: {
+                regions: import("./types").Region[];
+                replaceWith?: string;
+                fullWordCensor?: boolean;
+                detectLeetSpeak?: boolean;
+                checkSubstring?: boolean;
+                wordList?: string[];
+                whitelist?: string[];
+                categories?: import("./types").ProfanityCategory[];
+                severityThreshold?: number;
+                useRandomGrawlix?: boolean;
+                keepFirstAndLast?: boolean;
+                indonesianVariation?: boolean;
+                detectSimilarity?: boolean;
+                similarityThreshold?: number;
+                detectSplit?: boolean;
+                useLevenshtein?: boolean;
+                maxLevenshteinDistance?: number;
+            };
+        };
+    };
+};
+export default IDProfanityFilter;

package/dist/types/types/index.d.ts

@@ -0,0 +1,59 @@
+export type ProfanityCategory = "sexual" | "insult" | "profanity" | "slur" | "drugs" | "disgusting" | "blasphemy";
+export type Region = "general" | "jawa" | "sunda" | "betawi" | "batak" | "minang" | "bali" | "madura" | "bugis" | "aceh" | "ambon" | "papua" | "manado" | "banjar" | "palembang" | "lampung" | "ntt" | "ntb";
+export interface ProfanityWord {
+    word: string;
+    category: ProfanityCategory;
+    region: Region;
+    severity: number;
+    aliases?: string[];
+    description?: string;
+    context?: string;
+}
+export interface FilterOptions {
+    replaceWith?: string;
+    fullWordCensor?: boolean;
+    detectLeetSpeak?: boolean;
+    checkSubstring?: boolean;
+    wordList?: string[];
+    whitelist?: string[];
+    categories?: ProfanityCategory[];
+    regions?: Region[];
+    severityThreshold?: number;
+    useRandomGrawlix?: boolean;
+    keepFirstAndLast?: boolean;
+    indonesianVariation?: boolean;
+    detectSimilarity?: boolean;
+    similarityThreshold?: number;
+    detectSplit?: boolean;
+    useLevenshtein?: boolean;
+    maxLevenshteinDistance?: number;
+}
+export interface FilterResult {
+    filtered: string;
+    censored: number;
+    replacements: Array<{
+        original: string;
+        censored: string;
+        metadata?: ProfanityWord;
+    }>;
+}
+export interface AnalysisResult {
+    hasProfanity: boolean;
+    matches: string[];
+    matchDetails: ProfanityWord[];
+    categories: ProfanityCategory[];
+    regions: Region[];
+    severityScore: number;
+    similarWords?: Array<{
+        word: string;
+        original: string;
+        similarity: number;
+    }>;
+}
+export interface RegexOptions {
+    wholeWord?: boolean;
+    caseSensitive?: boolean;
+    leetSpeak?: boolean;
+    detectSplit?: boolean;
+    indonesianVariation?: boolean;
+}

package/dist/types/utils/ahoCorasick.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Implementasi algoritma Aho-Corasick untuk pencocokan string
+ * Algoritma ini memungkinkan pencarian banyak pola dalam satu kali pembacaan teks
+ */
+export declare class AhoCorasick {
+    private root;
+    private built;
+    constructor();
+    /**
+     * Menambahkan pola ke dalam trie
+     * @param pattern Pola yang akan ditambahkan
+     */
+    addPattern(pattern: string): void;
+    /**
+     * Membangun fungsi failure
+     */
+    build(): void;
+    /**
+     * Mencari semua kemunculan pola dalam teks
+     * @param text Teks yang akan dicari
+     * @returns Map pola yang ditemukan dengan jumlah kemunculannya
+     */
+    search(text: string): Map<string, number>;
+    /**
+     * Mencari semua kemunculan pola dalam teks dan mengembalikan hanya pola unik
+     * @param text Teks yang akan dicari
+     * @returns Set pola yang ditemukan
+     */
+    searchUnique(text: string): Set<string>;
+    /**
+     * Mengecek apakah teks mengandung setidaknya satu pola
+     * @param text Teks yang akan dicari
+     * @returns Boolean apakah pola ditemukan
+     */
+    containsAny(text: string): boolean;
+}

package/dist/{utils → types/utils}/similarityUtils.d.ts

@@ -54,12 +54,22 @@ export declare function isPossibleProfanityVariation(input: string, profanityWor
 export declare function clusterSimilarWords(words: string[], threshold?: number): string[][];
 /**
  * Cari kata-kata kotor yang mungkin dari teks menggunakan kesamaan string
+ * dengan optimasi untuk mengurangi kompleksitas
  *
  * @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
  */
+/**
+ * Cari kata-kata kotor yang mungkin dari teks berdasarkan kemiripan string
+ * dengan optimasi biar prosesnya nggak terlalu berat
+ *
+ * @param text Teks yang mau dicek
+ * @param profanityWords Daftar kata-kata kotor/kasar
+ * @param threshold Batas minimal kemiripan (default: 0.8)
+ * @returns Array kata yang kemungkinan kata kotor/kasar
+ */
 export declare function findPossibleProfanityBySimiliarity(text: string, profanityWords: string[], threshold?: number): Array<{
     word: string;
     original: string;

package/eslint.config.mjs

@@ -1,40 +1,40 @@
-import tseslint from '@typescript-eslint/eslint-plugin';
-import tsParser from '@typescript-eslint/parser';
-import eslintConfigPrettier from 'eslint-config-prettier';
-
-export default [
-  {
-    ignores: ['dist/', 'node_modules/', '*.js', '*.mjs', '*.d.ts'],
-  },
-  {
-    languageOptions: {
-      parser: tsParser,
-      parserOptions: {
-        ecmaVersion: 2020,
-        sourceType: 'module',
-        project: './tsconfig.json',
-      },
-    },
-    plugins: {
-      '@typescript-eslint': tseslint,
-    },
-    rules: {
-      // Enforce consistent code style
-      '@typescript-eslint/explicit-function-return-type': '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',
-    },
-  },
-  eslintConfigPrettier,
-];
+import tseslint from '@typescript-eslint/eslint-plugin';
+import tsParser from '@typescript-eslint/parser';
+import eslintConfigPrettier from 'eslint-config-prettier';
+
+export default [
+  {
+    ignores: ['dist/', 'node_modules/', '*.js', '*.mjs', '*.d.ts'],
+  },
+  {
+    languageOptions: {
+      parser: tsParser,
+      parserOptions: {
+        ecmaVersion: 2020,
+        sourceType: 'module',
+        project: './tsconfig.json',
+      },
+    },
+    plugins: {
+      '@typescript-eslint': tseslint,
+    },
+    rules: {
+      // Enforce consistent code style
+      '@typescript-eslint/explicit-function-return-type': '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',
+    },
+  },
+  eslintConfigPrettier,
+];