🛡️ Text Shield


A powerful, lightweight, and framework-agnostic profanity filter library with built-in multilingual support for English and Arabic. Perfect for content moderation in Node.js, NestJS, React, Angular, Vue, and browser applications.

✨ Features

- 🌍 Multilingual Support - Built-in English and Arabic profanity detection
- ⚡ High Performance - O(1) lookup time with Set-based architecture
- 🎯 Flexible Matching - Whole word or partial matching modes
- 🔧 Framework Agnostic - Works with Node.js, React, Angular, Vue, NestJS, Express, and more
- 📦 Zero Dependencies - Lightweight with no external dependencies
- 💪 TypeScript First - Written in TypeScript with full type definitions
- 🎨 Customizable - Add custom words, change placeholders, configure sensitivity
- 📝 Easy Integration - Simple API that works everywhere
- 🔒 Privacy Focused - All processing done locally, no external API calls

📦 Installation

``bash
npm install @nzrm/text-shield
`

`bash
yarn add @nzrm/text-shield
`

`bash
pnpm add @nzrm/text-shield
`

🚀 Quick Start

`typescript
import { ProfanityFilter } from "@nzrm/text-shield";

// Initialize with English
const filter = new ProfanityFilter({ languages: ["en"] });

// Check if text contains profanity
if (filter.containsProfanity("This is a damn shame")) {
console.log("Profanity detected!");
}

// Clean the text
const cleaned = filter.clean("What the hell is this?");
console.log(cleaned); // "What the * is this?"

// Get specific profane words
const words = filter.getProfaneWords("This shit is bad");
console.log(words); // ['shit', 'bad']
`

🌐 Multilingual Support

$3

`typescript
const filter = new ProfanityFilter({ languages: ["en"] });
filter.isProfane("damn"); // true
`

$3

`typescript
const filter = new ProfanityFilter({ languages: ["ar"] });
filter.isProfane("كس"); // true
`

$3

`typescript
const filter = new ProfanityFilter({ languages: ["en", "ar"] });
filter.clean("This is shit وهذا كس أيضا"); // "This is وهذا أيضا"
`

📖 API Documentation

$3

`typescript
new ProfanityFilter(options?: ProfanityFilterOptions)
`

#### Options

`typescript
interface ProfanityFilterOptions {
languages?: ("en" | "ar")[]; // Default: ['en']
customWords?: string[]; // Additional words to filter
caseSensitive?: boolean; // Default: false
wholeWord?: boolean; // Default: true
placeholder?: string; // Default: '*'
}
`

$3

#### isProfane(word: string): boolean

Check if a single word is profane.

`typescript
filter.isProfane("damn"); // true
filter.isProfane("hello"); // false
`

#### containsProfanity(text: string): boolean

Check if text contains any profanity.

`typescript
filter.containsProfanity("This is bad"); // true
filter.containsProfanity("This is good"); // false
`

#### getProfaneWords(text: string): string[]

Get an array of all profane words found in the text.

`typescript
filter.getProfaneWords("damn this shit"); // ['damn', 'shit']
`

#### clean(text: string): string

Replace profane words with the placeholder.

`typescript
filter.clean("What the hell"); // 'What the *'
`

#### addWords(words: string[]): void

Add custom words to the filter dynamically.

`typescript
filter.addWords(["spam", "junk"]);
`

#### removeWords(words: string[]): void

Remove words from the filter.

`typescript
filter.removeWords(["damn", "hell"]);
`

#### getWordCount(): number

Get the total number of words in the filter.

`typescript
console.log(filter.getWordCount()); // 150
`

#### exportWords(): string[]

Export all filtered words as an array.

`typescript
const allWords = filter.exportWords();
`

$3

#### ProfanityFilter.fromFile(filePath: string, options?: ProfanityFilterOptions): Promise

Load custom word list from a JSON file.

`typescript
const filter = await ProfanityFilter.fromFile("./custom-words.json", {
languages: ["en"],
placeholder: "[CENSORED]",
});
`

🔧 Framework Integration Examples

$3

`javascript
const express = require("express");
const { ProfanityFilter } = require("text-shield");

const app = express();
app.use(express.json());

const filter = new ProfanityFilter({ languages: ["en", "ar"] });

app.post("/api/comment", (req, res) => {
if (filter.containsProfanity(req.body.text)) {
return res.status(400).json({
error: "Comment contains inappropriate content",
profaneWords: filter.getProfaneWords(req.body.text),
});
}

res.json({ message: "Comment posted successfully" });
});

app.listen(3000);
`

$3

`typescript
// profanity.service.ts
import { Injectable } from "@nestjs/common";
import { ProfanityFilter } from "@nzrm/text-shield";

@Injectable()
export class ProfanityService {
private filter: ProfanityFilter;

constructor() {
this.filter = new ProfanityFilter({
languages: ["en", "ar"],
});
}

validate(text: string): boolean {
return !this.filter.containsProfanity(text);
}

clean(text: string): string {
return this.filter.clean(text);
}
}
`

$3

`jsx
import { useState, useEffect } from "react";
import { ProfanityFilter } from "@nzrm/text-shield";

function CommentForm() {
const [filter, setFilter] = useState(null);
const [comment, setComment] = useState("");
const [error, setError] = useState("");

useEffect(() => {
const profanityFilter = new ProfanityFilter({
languages: ["en", "ar"],
});
setFilter(profanityFilter);
}, []);

const handleSubmit = (e) => {
e.preventDefault();

if (filter?.containsProfanity(comment)) {
setError("Comment contains inappropriate content");
return;
}

console.log("Comment approved");
};

return (