allprofanity 1.1.0 → 2.1.0

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+export { default as englishBadWords } from "./languages/english-words.js";
 export { default as hindiBadWords } from "./languages/hindi-words.js";
 export { default as frenchBadWords } from "./languages/french-words.js";
 export { default as germanBadWords } from "./languages/german-words.js";
@@ -5,6 +6,14 @@ export { default as spanishBadWords } from "./languages/spanish-words.js";
 export { default as bengaliBadWords } from "./languages/bengali-words.js";
 export { default as tamilBadWords } from "./languages/tamil-words.js";
 export { default as teluguBadWords } from "./languages/telugu-words.js";
+/**
+ * Logging interface for the library
+ */
+export interface Logger {
+    info(message: string): void;
+    warn(message: string): void;
+    error(message: string): void;
+}
 /**
  * Configuration options for AllProfanity
  */
@@ -12,98 +21,174 @@ export interface AllProfanityOptions {
     languages?: string[];
     customDictionaries?: Record<string, string[]>;
     defaultPlaceholder?: string;
+    enableLeetSpeak?: boolean;
+    caseSensitive?: boolean;
+    whitelistWords?: string[];
+    strictMode?: boolean;
+    detectPartialWords?: boolean;
+    logger?: Logger;
+}
+/**
+ * Severity levels for profanity detection
+ */
+export declare enum ProfanitySeverity {
+    MILD = 1,
+    MODERATE = 2,
+    SEVERE = 3,
+    EXTREME = 4
 }
 /**
- * AllProfanity - Extended profanity filter with multi-language support
- * Based on leo-profanity with additional language capabilities
+ * Detection result interface
+ */
+export interface ProfanityDetectionResult {
+    hasProfanity: boolean;
+    detectedWords: string[];
+    cleanedText: string;
+    severity: ProfanitySeverity;
+    positions: Array<{
+        word: string;
+        start: number;
+        end: number;
+    }>;
+}
+/**
+ * Advanced AllProfanity - Fixed profanity filter with multi-language support
+ * Addresses all critical issues from the original implementation
  */
 export declare class AllProfanity {
-    private filter;
+    private readonly profanityTrie;
+    private readonly whitelistSet;
+    private readonly loadedLanguages;
+    private readonly logger;
     private defaultPlaceholder;
-    private loadedLanguages;
-    private availableLanguages;
+    private enableLeetSpeak;
+    private caseSensitive;
+    private strictMode;
+    private detectPartialWords;
+    private readonly availableLanguages;
+    private readonly leetMappings;
+    private readonly dynamicWords;
+    constructor(options?: AllProfanityOptions);
     /**
-     * Create a new AllProfanity instance
-     * @param options - Configuration options
+     * Normalize text by converting leet speak to regular characters.
      */
-    constructor(options?: AllProfanityOptions);
+    private normalizeLeetSpeak;
     /**
-     * Load a built-in language dictionary
-     * @param language - The language to load
-     * @returns boolean - True if loaded successfully, false otherwise
+     * Properly escape regex special characters
      */
-    loadLanguage(language: string): boolean;
+    private escapeRegex;
     /**
-     * Load multiple languages at once
-     * @param languages - Array of language names to load
-     * @returns number - Number of successfully loaded languages
+     * Check if a position has word boundaries (for strict mode)
      */
-    loadLanguages(languages: string[]): number;
+    private hasWordBoundaries;
     /**
-     * Load all Indian languages at once
-     * @returns number - Number of Indian languages loaded
+     * Helper method to verify whole-word matching.
      */
-    loadIndianLanguages(): number;
+    private isWholeWord;
     /**
-     * Load a custom dictionary with a given name
-     * @param name - Name to identify this dictionary
-     * @param words - Array of profanity words
+     * Check if a match is whitelisted (by actual matched substring and dictionary word)
      */
-    loadCustomDictionary(name: string, words: string[]): void;
+    private isWhitelistedMatch;
     /**
-     * Get the list of currently loaded languages
-     * @returns string[] - Array of loaded language names
+     * Remove overlapping matches, keep only the longest at each start position
      */
-    getLoadedLanguages(): string[];
+    private deduplicateMatches;
     /**
-     * Get the list of available language dictionaries
-     * @returns string[] - Array of available language names
+     * Advanced profanity detection using efficient trie-based algorithm
      */
-    getAvailableLanguages(): string[];
+    detect(text: string): ProfanityDetectionResult;
     /**
-     * Check if a string contains profanity
-     * @param string - The string to check
-     * @returns boolean - True if profanity found, false otherwise
+     * Main matching function, with whole-word logic.
      */
-    check(string: string): boolean;
+    private findMatches;
     /**
-     * Clean a string by replacing profanities with placeholders
-     * @param string - The string to clean
-     * @param placeholder - Optional custom placeholder (defaults to '*')
-     * @returns string - The cleaned string
+     * Generate cleaned text by replacing profane words (non-overlapping only)
      */
-    clean(string: string, placeholder?: string): string;
+    private generateCleanedText;
     /**
-     * Clean a string by replacing each profane word with a single placeholder
-     * @param string - The string to clean
-     * @param placeholder - The placeholder to use (defaults to '***')
-     * @returns string - The cleaned string
+     * Simple boolean check for profanity
      */
-    cleanWithWord(string: string, placeholder?: string): string;
+    check(text: string): boolean;
     /**
-     * Get the current list of profanity words
-     * @returns string[] - Array of all profanity words
+     * Clean text with custom placeholder
      */
-    list(): string[];
+    clean(text: string, placeholder?: string): string;
+    /**
+     * Clean text by replacing each profane word with a single placeholder (word-level)
+     */
+    cleanWithPlaceholder(text: string, placeholder?: string): string;
     /**
      * Add word(s) to the profanity list
-     * @param word - String or array of strings to add
      */
     add(word: string | string[]): void;
     /**
      * Remove word(s) from the profanity list
-     * @param word - String or array of strings to remove
      */
     remove(word: string | string[]): void;
     /**
-     * Clear the filter list and reset to default
+     * Add words to whitelist
+     */
+    addToWhitelist(words: string[]): void;
+    /**
+     * Remove words from whitelist
+     */
+    removeFromWhitelist(words: string[]): void;
+    /**
+     * Helper for whitelist checking with correct normalization
+     */
+    private isWhitelisted;
+    /**
+     * Load a built-in language dictionary
+     */
+    loadLanguage(language: string): boolean;
+    /**
+     * Load multiple languages at once
+     */
+    loadLanguages(languages: string[]): number;
+    /**
+     * Load all Indian languages
+     */
+    loadIndianLanguages(): number;
+    /**
+     * Load a custom dictionary
+     */
+    loadCustomDictionary(name: string, words: string[]): void;
+    /**
+     * Add a single word to the trie structure
+     */
+    private addWordToTrie;
+    /**
+     * Remove overlapping matches, keep only the longest at each start position
+     */
+    private calculateSeverity;
+    /**
+     * Clear all loaded dictionaries
      */
     clearList(): void;
     /**
-     * Change the character used as placeholder
-     * @param placeholder - Single character to use as placeholder
+     * Set placeholder character
      */
     setPlaceholder(placeholder: string): void;
+    /**
+     * Get loaded languages
+     */
+    getLoadedLanguages(): string[];
+    /**
+     * Get available languages
+     */
+    getAvailableLanguages(): string[];
+    /**
+     * Get current configuration
+     */
+    getConfig(): Partial<AllProfanityOptions>;
+    /**
+     * Rebuilds the profanity trie from loaded language dictionaries and dynamic words.
+     */
+    private rebuildTrie;
+    /**
+     * Update configuration. Rebuild trie if needed.
+     */
+    updateConfig(options: Partial<AllProfanityOptions>): void;
 }
 declare const allProfanity: AllProfanity;
 export default allProfanity;