allprofanity 2.0.0 → 2.1.0

package/dist/index.d.ts

@@ -6,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
  */
@@ -18,6 +26,7 @@ export interface AllProfanityOptions {
     whitelistWords?: string[];
     strictMode?: boolean;
     detectPartialWords?: boolean;
+    logger?: Logger;
 }
 /**
  * Severity levels for profanity detection
@@ -43,139 +52,129 @@ export interface ProfanityDetectionResult {
     }>;
 }
 /**
- * Advanced AllProfanity - Custom profanity filter with multi-language support and leet speak detection
- * No external dependencies - built from scratch for maximum performance and control
+ * Advanced AllProfanity - Fixed profanity filter with multi-language support
+ * Addresses all critical issues from the original implementation
  */
 export declare class AllProfanity {
-    private profanitySet;
-    private normalizedProfanityMap;
+    private readonly profanityTrie;
+    private readonly whitelistSet;
+    private readonly loadedLanguages;
+    private readonly logger;
     private defaultPlaceholder;
-    private loadedLanguages;
-    private whitelistSet;
     private enableLeetSpeak;
     private caseSensitive;
     private strictMode;
     private detectPartialWords;
-    private readonly leetMap;
-    private readonly wordBoundaryChars;
-    private readonly commonSuffixes;
-    private readonly commonPrefixes;
-    private availableLanguages;
-    /**
-     * Create a new AllProfanity instance
-     * @param options - Configuration options
-     */
+    private readonly availableLanguages;
+    private readonly leetMappings;
+    private readonly dynamicWords;
     constructor(options?: AllProfanityOptions);
     /**
-     * Normalize text by converting leet speak to regular characters
-     * @param text - Text to normalize
-     * @returns Normalized text
+     * Normalize text by converting leet speak to regular characters.
      */
     private normalizeLeetSpeak;
-    private escapeRegex;
     /**
-     * Generate word variations with common prefixes and suffixes
+     * Properly escape regex special characters
      */
-    private generateWordVariations;
+    private escapeRegex;
     /**
-     * Check if text contains word boundaries around a match
+     * Check if a position has word boundaries (for strict mode)
      */
     private hasWordBoundaries;
     /**
-     * Calculate severity based on detected words
+     * Helper method to verify whole-word matching.
      */
-    private calculateSeverity;
+    private isWholeWord;
     /**
-     * Load a built-in language dictionary
-     * @param language - The language to load
-     * @returns boolean - True if loaded successfully, false otherwise
+     * Check if a match is whitelisted (by actual matched substring and dictionary word)
      */
-    loadLanguage(language: string): boolean;
+    private isWhitelistedMatch;
     /**
-     * Load multiple languages at once
-     * @param languages - Array of language names to load
-     * @returns number - Number of successfully loaded languages
+     * Remove overlapping matches, keep only the longest at each start position
      */
-    loadLanguages(languages: string[]): number;
+    private deduplicateMatches;
     /**
-     * Load all Indian languages at once
-     * @returns number - Number of Indian languages loaded
+     * Advanced profanity detection using efficient trie-based algorithm
      */
-    loadIndianLanguages(): number;
+    detect(text: string): ProfanityDetectionResult;
     /**
-     * Load a custom dictionary with a given name
-     * @param name - Name to identify this dictionary
-     * @param words - Array of profanity words
+     * Main matching function, with whole-word logic.
      */
-    loadCustomDictionary(name: string, words: string[]): void;
+    private findMatches;
     /**
-     * Add words to whitelist (words that should never be flagged as profanity)
-     * @param words - Array of words to whitelist
+     * Generate cleaned text by replacing profane words (non-overlapping only)
+     */
+    private generateCleanedText;
+    /**
+     * Simple boolean check for profanity
+     */
+    check(text: string): boolean;
+    /**
+     * Clean text with custom placeholder
+     */
+    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
+     */
+    add(word: string | string[]): void;
+    /**
+     * Remove word(s) from the profanity list
+     */
+    remove(word: string | string[]): void;
+    /**
+     * Add words to whitelist
      */
     addToWhitelist(words: string[]): void;
     /**
      * Remove words from whitelist
-     * @param words - Array of words to remove from whitelist
      */
     removeFromWhitelist(words: string[]): void;
     /**
-     * Advanced profanity detection with detailed results
-     * @param text - The text to analyze
-     * @returns ProfanityDetectionResult - Detailed detection results
+     * Helper for whitelist checking with correct normalization
      */
-    detect(text: string): ProfanityDetectionResult;
+    private isWhitelisted;
     /**
-     * Check if a string contains profanity (simple boolean check)
-     * @param string - The string to check
-     * @returns boolean - True if profanity found, false otherwise
+     * Load a built-in language dictionary
      */
-    check(string: string): boolean;
+    loadLanguage(language: string): boolean;
     /**
-     * Clean a string by replacing profanities with placeholders
-     * @param string - The string to clean
-     * @param placeholder - Optional custom placeholder
-     * @returns string - The cleaned string
+     * Load multiple languages at once
      */
-    clean(string: string, placeholder?: string): string;
+    loadLanguages(languages: string[]): number;
     /**
-     * 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
+     * Load all Indian languages
      */
-    cleanWithWord(string: string, placeholder?: string): string;
+    loadIndianLanguages(): number;
     /**
-     * Get the current list of profanity words
-     * @returns string[] - Array of all profanity words
+     * Load a custom dictionary
      */
-    list(): string[];
+    loadCustomDictionary(name: string, words: string[]): void;
     /**
-     * Add word(s) to the profanity list
-     * @param word - String or array of strings to add
+     * Add a single word to the trie structure
      */
-    add(word: string | string[]): void;
+    private addWordToTrie;
     /**
-     * Remove word(s) from the profanity list
-     * @param word - String or array of strings to remove
+     * Remove overlapping matches, keep only the longest at each start position
      */
-    remove(word: string | string[]): void;
+    private calculateSeverity;
     /**
-     * Clear the filter list and reset to default
+     * 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 the list of currently loaded languages
-     * @returns string[] - Array of loaded language names
+     * Get loaded languages
      */
     getLoadedLanguages(): string[];
     /**
-     * Get the list of available language dictionaries
-     * @returns string[] - Array of available language names
+     * Get available languages
      */
     getAvailableLanguages(): string[];
     /**
@@ -183,7 +182,11 @@ export declare class AllProfanity {
      */
     getConfig(): Partial<AllProfanityOptions>;
     /**
-     * Update configuration
+     * Rebuilds the profanity trie from loaded language dictionaries and dynamic words.
+     */
+    private rebuildTrie;
+    /**
+     * Update configuration. Rebuild trie if needed.
      */
     updateConfig(options: Partial<AllProfanityOptions>): void;
 }