allprofanity 2.0.0 → 2.1.1

package/dist/index.d.ts

@@ -7,7 +7,27 @@ 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";
 /**
- * Configuration options for AllProfanity
+ * Logger interface for the library.
+ */
+export interface Logger {
+    /**
+     * Log informational messages.
+     * @param message - The message to log.
+     */
+    info(message: string): void;
+    /**
+     * Log warning messages.
+     * @param message - The message to log.
+     */
+    warn(message: string): void;
+    /**
+     * Log error messages.
+     * @param message - The message to log.
+     */
+    error(message: string): void;
+}
+/**
+ * Configuration options for AllProfanity.
  */
 export interface AllProfanityOptions {
     languages?: string[];
@@ -18,9 +38,10 @@ export interface AllProfanityOptions {
     whitelistWords?: string[];
     strictMode?: boolean;
     detectPartialWords?: boolean;
+    logger?: Logger;
 }
 /**
- * Severity levels for profanity detection
+ * Severity levels for profanity detection.
  */
 export declare enum ProfanitySeverity {
     MILD = 1,
@@ -29,7 +50,7 @@ export declare enum ProfanitySeverity {
     EXTREME = 4
 }
 /**
- * Detection result interface
+ * Detection result for profanity detection.
  */
 export interface ProfanityDetectionResult {
     hasProfanity: boolean;
@@ -43,149 +64,204 @@ 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
+ * Main class for profanity detection and filtering.
  */
 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;
+    private readonly availableLanguages;
+    private readonly leetMappings;
+    private readonly dynamicWords;
     /**
-     * Create a new AllProfanity instance
-     * @param options - Configuration options
+     * Create an AllProfanity instance.
+     * @param options - Profanity filter configuration options.
      */
     constructor(options?: AllProfanityOptions);
     /**
-     * Normalize text by converting leet speak to regular characters
-     * @param text - Text to normalize
-     * @returns Normalized text
+     * Normalize leet speak to regular characters.
+     * @param text - The input text.
+     * @returns Normalized text.
      */
     private normalizeLeetSpeak;
-    private escapeRegex;
     /**
-     * Generate word variations with common prefixes and suffixes
+     * Escape regex special characters in a string.
+     * @param str - The string to escape.
+     * @returns The escaped string.
      */
-    private generateWordVariations;
+    private escapeRegex;
     /**
-     * Check if text contains word boundaries around a match
+     * Check if a match is bounded by word boundaries (strict mode).
+     * @param text - The text.
+     * @param start - Start index.
+     * @param end - End index.
+     * @returns True if match is at word boundaries, false otherwise.
      */
     private hasWordBoundaries;
     /**
-     * Calculate severity based on detected words
+     * Determine if a match is a whole word.
+     * @param text - The text.
+     * @param start - Start index.
+     * @param end - End index.
+     * @returns True if whole word, false otherwise.
      */
-    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.
+     * @param word - Word from dictionary.
+     * @param matchedText - Actual matched text.
+     * @returns True if whitelisted, false otherwise.
      */
-    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, keeping only the longest at each start position.
+     * @param matches - Array of match results.
+     * @returns Deduplicated matches.
      */
-    loadLanguages(languages: string[]): number;
+    private deduplicateMatches;
     /**
-     * Load all Indian languages at once
-     * @returns number - Number of Indian languages loaded
+     * Detect profanity in a given text.
+     * @param text - The text to check.
+     * @returns Profanity detection result.
      */
-    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.
+     * @param searchText - The normalized text to search.
+     * @param originalText - The original text.
+     * @param matches - Array to collect matches.
      */
-    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.
+     * @param originalText - The original text.
+     * @param matches - Array of matches.
+     * @returns Cleaned text.
+     */
+    private generateCleanedText;
+    /**
+     * Check if a string contains profanity.
+     * @param text - The text to check.
+     * @returns True if profanity is found, false otherwise.
+     */
+    check(text: string): boolean;
+    /**
+     * Clean text with a custom placeholder.
+     * @param text - The text to clean.
+     * @param placeholder - The placeholder to use.
+     * @returns Cleaned text.
+     */
+    clean(text: string, placeholder?: string): string;
+    /**
+     * Clean text by replacing each profane word with a single placeholder (word-level).
+     * @param text - The text to clean.
+     * @param placeholder - The placeholder to use.
+     * @returns Word-level cleaned text.
+     */
+    cleanWithPlaceholder(text: string, placeholder?: string): string;
+    /**
+     * Add word(s) to the profanity filter.
+     * @param word - Word or array of words to add.
+     */
+    add(word: string | string[]): void;
+    /**
+     * Remove word(s) from the profanity filter.
+     * @param word - Word or array of words to remove.
+     */
+    remove(word: string | string[]): void;
+    /**
+     * Add words to the whitelist.
+     * @param words - Words to whitelist.
      */
     addToWhitelist(words: string[]): void;
     /**
-     * Remove words from whitelist
-     * @param words - Array of words to remove from whitelist
+     * Remove words from the whitelist.
+     * @param words - 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
+     * Check if a word is whitelisted.
+     * @param word - The word to check.
+     * @returns True if whitelisted, false otherwise.
      */
-    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.
+     * @param language - The language key.
+     * @returns True if loaded, false otherwise.
      */
-    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 language dictionaries.
+     * @param languages - Array of languages to load.
+     * @returns Number of successfully loaded languages.
      */
-    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 supported Indian languages.
+     * @returns Number of loaded 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.
+     * @param name - Name of the dictionary.
+     * @param words - Words to add.
      */
-    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.
+     * @param word - The word to add.
+     * @returns True if added, false otherwise.
      */
-    add(word: string | string[]): void;
+    private addWordToTrie;
     /**
-     * Remove word(s) from the profanity list
-     * @param word - String or array of strings to remove
+     * Calculate severity from matches.
+     * @param matches - Array of matches.
+     * @returns Severity level.
      */
-    remove(word: string | string[]): void;
+    private calculateSeverity;
     /**
-     * Clear the filter list and reset to default
+     * Clear all loaded dictionaries and dynamic words.
      */
     clearList(): void;
     /**
-     * Change the character used as placeholder
-     * @param placeholder - Single character to use as placeholder
+     * Set the placeholder character for filtered words.
+     * @param placeholder - The placeholder character.
      */
     setPlaceholder(placeholder: string): void;
     /**
-     * Get the list of currently loaded languages
-     * @returns string[] - Array of loaded language names
+     * Get the list of loaded languages.
+     * @returns Array of loaded language keys.
      */
     getLoadedLanguages(): string[];
     /**
-     * Get the list of available language dictionaries
-     * @returns string[] - Array of available language names
+     * Get the list of available built-in languages.
+     * @returns Array of available language keys.
      */
     getAvailableLanguages(): string[];
     /**
-     * Get current configuration
+     * Get the current configuration of the profanity filter.
+     * @returns Partial configuration object.
      */
     getConfig(): Partial<AllProfanityOptions>;
     /**
-     * Update configuration
+     * Rebuild the profanity trie from loaded dictionaries and dynamic words.
+     */
+    private rebuildTrie;
+    /**
+     * Update configuration options for the profanity filter.
+     * @param options - Partial configuration object.
      */
     updateConfig(options: Partial<AllProfanityOptions>): void;
 }
+/**
+ * Singleton instance of AllProfanity with default configuration.
+ */
 declare const allProfanity: AllProfanity;
 export default allProfanity;