@umituz/react-native-ai-generation-content 1.12.2 → 1.12.4

package/package.json

@@ -1,9 +1,14 @@
 {
   "name": "@umituz/react-native-ai-generation-content",
-  "version": "1.12.2",
+  "version": "1.12.4",
   "description": "Provider-agnostic AI generation orchestration for React Native",
   "main": "src/index.ts",
   "types": "src/index.ts",
+  "exports": {
+    ".": "./src/index.ts",
+    "./prompts": "./src/domains/prompts/index.ts",
+    "./content-moderation": "./src/domains/content-moderation/index.ts"
+  },
   "files": [
     "src"
   ],

package/src/domains/content-moderation/domain/entities/moderation.types.ts

@@ -0,0 +1,84 @@
+/**
+ * Content Moderation Types
+ * Core type definitions for content moderation system
+ */
+
+export type ContentType = "text" | "image" | "video" | "voice";
+
+export type ModerationSeverity = "low" | "medium" | "high" | "critical";
+
+export type AgeRating = "G" | "PG" | "PG-13" | "R" | "NC-17" | "18+";
+
+export type ViolationType =
+  | "explicit_content"
+  | "violence"
+  | "hate_speech"
+  | "harassment"
+  | "illegal_activity"
+  | "spam"
+  | "copyright"
+  | "personal_info"
+  | "dangerous_content";
+
+export interface ModerationRule {
+  id: string;
+  name: string;
+  description: string;
+  contentTypes: ContentType[];
+  severity: ModerationSeverity;
+  violationType: ViolationType;
+  patterns: string[];
+  enabled: boolean;
+}
+
+export interface ModerationResult {
+  isAllowed: boolean;
+  violations: Violation[];
+  confidence: number;
+  suggestedAction: "allow" | "warn" | "block";
+}
+
+export interface Violation {
+  ruleId: string;
+  ruleName: string;
+  violationType: ViolationType;
+  severity: ModerationSeverity;
+  matchedPattern: string;
+  context: string;
+  suggestion: string;
+}
+
+export interface ModerationContext {
+  userId?: string;
+  contentType: ContentType;
+  content: string;
+  metadata?: Record<string, unknown>;
+}
+
+export interface ModerationConfig {
+  strictMode: boolean;
+  autoBlock: boolean;
+  logViolations: boolean;
+  notifyUser: boolean;
+  customRules?: ModerationRule[];
+  suggestionMessages?: SuggestionMessages;
+}
+
+export interface SuggestionMessages {
+  explicit_content?: string;
+  violence?: string;
+  hate_speech?: string;
+  harassment?: string;
+  illegal_activity?: string;
+  spam?: string;
+  copyright?: string;
+  personal_info?: string;
+  dangerous_content?: string;
+  default?: string;
+}
+
+export interface ValidationLimits {
+  maxTextLength?: number;
+  maxVoiceTextLength?: number;
+  maxUriLength?: number;
+}

package/src/domains/content-moderation/domain/interfaces/content-filter.interface.ts

@@ -0,0 +1,24 @@
+/**
+ * Content Filter Interface
+ * Contract for content filtering implementations
+ */
+
+import type { Violation } from "../entities/moderation.types";
+
+export interface ContentFilterResult {
+  isAllowed: boolean;
+  violations: Violation[];
+}
+
+export interface IContentFilter {
+  filter(content: string): ContentFilterResult;
+  addBlockedWord(word: string): void;
+  addBlockedPattern(pattern: string): void;
+  removeBlockedWord(word: string): void;
+  removeBlockedPattern(pattern: string): void;
+  clearFilters(): void;
+}
+
+export interface IModerator {
+  moderate(content: string): ContentFilterResult;
+}

package/src/domains/content-moderation/index.ts

@@ -0,0 +1,67 @@
+/**
+ * @umituz/react-native-ai-content-moderation
+ * Content moderation service for AI applications
+ *
+ * Usage:
+ *   import {
+ *     contentModerationService,
+ *     ContentPolicyViolationError,
+ *     rulesRegistry
+ *   } from '@umituz/react-native-ai-content-moderation';
+ */
+
+// =============================================================================
+// DOMAIN LAYER - Types
+// =============================================================================
+
+export type {
+  ContentType,
+  ModerationSeverity,
+  AgeRating,
+  ViolationType,
+  ModerationRule,
+  ModerationResult,
+  Violation,
+  ModerationContext,
+  ModerationConfig,
+  SuggestionMessages,
+  ValidationLimits,
+} from "./domain/entities/moderation.types";
+
+export type {
+  ContentFilterResult,
+  IContentFilter,
+  IModerator,
+} from "./domain/interfaces/content-filter.interface";
+
+// =============================================================================
+// INFRASTRUCTURE LAYER - Services
+// =============================================================================
+
+export {
+  contentModerationService,
+  patternMatcherService,
+  textModerator,
+  imageModerator,
+  videoModerator,
+  voiceModerator,
+  BaseModerator,
+} from "./infrastructure/services";
+
+export type {
+  PatternMatch,
+  ModerationResult as ModeratorResult,
+} from "./infrastructure/services";
+
+// =============================================================================
+// INFRASTRUCTURE LAYER - Rules
+// =============================================================================
+
+export { rulesRegistry } from "./infrastructure/rules/rules-registry";
+export { defaultModerationRules } from "./infrastructure/rules/default-rules.data";
+
+// =============================================================================
+// PRESENTATION LAYER - Exceptions
+// =============================================================================
+
+export { ContentPolicyViolationError } from "./presentation/exceptions/content-policy-violation.exception";

package/src/domains/content-moderation/infrastructure/rules/default-rules.data.ts

@@ -0,0 +1,144 @@
+/**
+ * Default Moderation Rules
+ * Built-in rules for content filtering - can be extended via config
+ */
+
+import type { ModerationRule } from "../../domain/entities/moderation.types";
+
+const explicitContentRules: ModerationRule[] = [
+  {
+    id: "explicit-001",
+    name: "Sexual Content",
+    description: "Detects explicit sexual content and nudity",
+    contentTypes: ["text", "image"],
+    severity: "critical",
+    violationType: "explicit_content",
+    patterns: [
+      "\\bnude\\b",
+      "\\bnaked\\b",
+      "\\bnsfw\\b",
+      "\\bsexual\\b",
+      "\\berotic\\b",
+      "\\bporn\\b",
+      "\\bxxx\\b",
+      "\\badult content\\b",
+      "\\bexplicit\\b",
+    ],
+    enabled: true,
+  },
+  {
+    id: "explicit-002",
+    name: "Body Parts Focus",
+    description: "Detects inappropriate body part references",
+    contentTypes: ["text", "image"],
+    severity: "high",
+    violationType: "explicit_content",
+    patterns: [
+      "\\bbreasts?\\b",
+      "\\bbutt\\b",
+      "\\bass\\b",
+      "\\bchest\\b.*\\b(exposed|revealing|bare)\\b",
+      "\\bcleavage\\b",
+    ],
+    enabled: true,
+  },
+];
+
+const violenceRules: ModerationRule[] = [
+  {
+    id: "violence-001",
+    name: "Graphic Violence",
+    description: "Detects graphic violence and gore",
+    contentTypes: ["text", "image", "video"],
+    severity: "critical",
+    violationType: "violence",
+    patterns: [
+      "\\bgore\\b",
+      "\\bblood\\b.*\\b(splatter|dripping|pool)\\b",
+      "\\bmurder\\b",
+      "\\bkilling\\b",
+      "\\btorture\\b",
+      "\\bdismember\\b",
+      "\\bbeheading\\b",
+    ],
+    enabled: true,
+  },
+  {
+    id: "violence-002",
+    name: "Weapons Focus",
+    description: "Detects inappropriate weapon usage context",
+    contentTypes: ["text", "image", "video"],
+    severity: "medium",
+    violationType: "violence",
+    patterns: [
+      "\\bgun\\b.*\\b(pointing|aimed|shooting)\\b",
+      "\\bweapon\\b.*\\b(attack|assault|harm)\\b",
+      "\\bknife\\b.*\\b(stabbing|cutting|slashing)\\b",
+    ],
+    enabled: true,
+  },
+];
+
+const hateSpeechRules: ModerationRule[] = [
+  {
+    id: "hate-001",
+    name: "Discriminatory Language",
+    description: "Detects hate speech and discriminatory content",
+    contentTypes: ["text", "voice"],
+    severity: "critical",
+    violationType: "hate_speech",
+    patterns: [
+      "\\bhate\\b.*\\b(speech|crime|group)\\b",
+      "\\bracist\\b",
+      "\\bsexist\\b",
+      "\\bbigot\\b",
+      "\\bxenophobia\\b",
+    ],
+    enabled: true,
+  },
+];
+
+const illegalActivityRules: ModerationRule[] = [
+  {
+    id: "illegal-001",
+    name: "Drug Content",
+    description: "Detects drug-related content",
+    contentTypes: ["text", "image", "video"],
+    severity: "high",
+    violationType: "illegal_activity",
+    patterns: [
+      "\\bdrug\\b.*\\b(dealing|trafficking|manufacturing)\\b",
+      "\\bcocaine\\b",
+      "\\bheroin\\b",
+      "\\bmethamphetamine\\b",
+      "\\billegal\\b.*\\b(substance|drug)\\b",
+    ],
+    enabled: true,
+  },
+];
+
+const personalInfoRules: ModerationRule[] = [
+  {
+    id: "pii-001",
+    name: "Personal Information",
+    description: "Detects personal identifiable information",
+    contentTypes: ["text", "image"],
+    severity: "medium",
+    violationType: "personal_info",
+    patterns: [
+      "\\b\\d{3}-\\d{2}-\\d{4}\\b",
+      "\\b\\d{16}\\b",
+      "\\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,}\\b",
+      "\\b\\d{3}[-.]?\\d{3}[-.]?\\d{4}\\b",
+    ],
+    enabled: true,
+  },
+];
+
+export const defaultModerationRules: ModerationRule[] = [
+  ...explicitContentRules,
+  ...violenceRules,
+  ...hateSpeechRules,
+  ...illegalActivityRules,
+  ...personalInfoRules,
+];

package/src/domains/content-moderation/infrastructure/rules/rules-registry.ts

@@ -0,0 +1,75 @@
+/**
+ * Rules Registry
+ * Manages moderation rules - allows adding/removing custom rules
+ */
+
+import type {
+  ContentType,
+  ModerationRule,
+} from "../../domain/entities/moderation.types";
+import { defaultModerationRules } from "./default-rules.data";
+
+class RulesRegistry {
+  private rules: ModerationRule[] = [...defaultModerationRules];
+
+  getRules(): ModerationRule[] {
+    return this.rules;
+  }
+
+  getRulesByContentType(contentType: ContentType): ModerationRule[] {
+    return this.rules.filter(
+      (rule) => rule.enabled && rule.contentTypes.includes(contentType)
+    );
+  }
+
+  getRuleById(id: string): ModerationRule | undefined {
+    return this.rules.find((rule) => rule.id === id);
+  }
+
+  addRule(rule: ModerationRule): void {
+    const existing = this.getRuleById(rule.id);
+    if (existing) {
+      this.updateRule(rule.id, rule);
+      return;
+    }
+    this.rules.push(rule);
+  }
+
+  addRules(rules: ModerationRule[]): void {
+    rules.forEach((rule) => this.addRule(rule));
+  }
+
+  updateRule(id: string, updates: Partial<ModerationRule>): boolean {
+    const index = this.rules.findIndex((rule) => rule.id === id);
+    if (index === -1) return false;
+
+    this.rules[index] = { ...this.rules[index], ...updates };
+    return true;
+  }
+
+  removeRule(id: string): boolean {
+    const index = this.rules.findIndex((rule) => rule.id === id);
+    if (index === -1) return false;
+
+    this.rules.splice(index, 1);
+    return true;
+  }
+
+  enableRule(id: string): boolean {
+    return this.updateRule(id, { enabled: true });
+  }
+
+  disableRule(id: string): boolean {
+    return this.updateRule(id, { enabled: false });
+  }
+
+  resetToDefaults(): void {
+    this.rules = [...defaultModerationRules];
+  }
+
+  clearAllRules(): void {
+    this.rules = [];
+  }
+}
+
+export const rulesRegistry = new RulesRegistry();

package/src/domains/content-moderation/infrastructure/services/content-moderation.service.ts

@@ -0,0 +1,150 @@
+/**
+ * Content Moderation Service
+ * Orchestrates content moderation by type
+ */
+
+import type {
+  ContentType,
+  ModerationResult,
+  ModerationContext,
+  Violation,
+  SuggestionMessages,
+  ValidationLimits,
+  ModerationRule,
+} from "../../domain/entities/moderation.types";
+import { textModerator } from "./moderators/text.moderator";
+import { imageModerator } from "./moderators/image.moderator";
+import { videoModerator } from "./moderators/video.moderator";
+import { voiceModerator } from "./moderators/voice.moderator";
+import { rulesRegistry } from "../rules/rules-registry";
+
+declare const __DEV__: boolean;
+
+interface ServiceConfig {
+  suggestionMessages?: SuggestionMessages;
+  validationLimits?: ValidationLimits;
+  customRules?: ModerationRule[];
+}
+
+class ContentModerationService {
+  configure(config: ServiceConfig): void {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[ContentModeration] Configure:", {
+        hasSuggestionMessages: !!config.suggestionMessages,
+        hasValidationLimits: !!config.validationLimits,
+        customRulesCount: config.customRules?.length ?? 0,
+      });
+    }
+
+    if (config.suggestionMessages) {
+      textModerator.setSuggestionMessages(config.suggestionMessages);
+      voiceModerator.setSuggestionMessages(config.suggestionMessages);
+    }
+
+    if (config.validationLimits) {
+      const { maxTextLength, maxVoiceTextLength, maxUriLength } =
+        config.validationLimits;
+
+      if (maxTextLength) textModerator.setMaxLength(maxTextLength);
+      if (maxVoiceTextLength) voiceModerator.setMaxLength(maxVoiceTextLength);
+      if (maxUriLength) {
+        imageModerator.setMaxUriLength(maxUriLength);
+        videoModerator.setMaxUriLength(maxUriLength);
+      }
+    }
+
+    if (config.customRules) {
+      rulesRegistry.addRules(config.customRules);
+    }
+  }
+
+  async moderate(context: ModerationContext): Promise<ModerationResult> {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[ContentModeration] Moderate started:", {
+        contentType: context.contentType,
+        contentLength: context.content?.length ?? 0,
+      });
+    }
+
+    const result = this.moderateByType(context.contentType, context.content);
+    const moderationResult: ModerationResult = {
+      isAllowed: result.isAllowed,
+      violations: result.violations,
+      confidence: this.calculateConfidence(result.violations),
+      suggestedAction: this.determineAction(result.violations),
+    };
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[ContentModeration] Moderate completed:", {
+        contentType: context.contentType,
+        isAllowed: moderationResult.isAllowed,
+        violationsCount: moderationResult.violations?.length ?? 0,
+        suggestedAction: moderationResult.suggestedAction,
+      });
+    }
+
+    return moderationResult;
+  }
+
+  async isContentAllowed(
+    content: string,
+    contentType: ContentType
+  ): Promise<boolean> {
+    const result = this.moderateByType(contentType, content);
+    return result.isAllowed;
+  }
+
+  moderateSync(
+    content: string,
+    contentType: ContentType
+  ): { isAllowed: boolean; violations: Violation[] } {
+    return this.moderateByType(contentType, content);
+  }
+
+  private moderateByType(
+    contentType: ContentType,
+    content: string
+  ): { isAllowed: boolean; violations: Violation[] } {
+    switch (contentType) {
+      case "text":
+        return textModerator.moderate(content);
+      case "image":
+        return imageModerator.moderate(content);
+      case "video":
+        return videoModerator.moderate(content);
+      case "voice":
+        return voiceModerator.moderate(content);
+      default:
+        return { isAllowed: true, violations: [] };
+    }
+  }
+
+  private calculateConfidence(violations: Violation[]): number {
+    if (violations.length === 0) return 1.0;
+
+    const weights = { critical: 1.0, high: 0.75, medium: 0.5, low: 0.25 };
+    const score = violations.reduce(
+      (sum, v) => sum + (weights[v.severity] || 0.25),
+      0
+    );
+
+    return Math.min(1.0, score / 2);
+  }
+
+  private determineAction(
+    violations: Violation[]
+  ): "allow" | "warn" | "block" {
+    if (violations.length === 0) return "allow";
+
+    const hasCritical = violations.some((v) => v.severity === "critical");
+    const hasHigh = violations.some((v) => v.severity === "high");
+
+    if (hasCritical || hasHigh) return "block";
+    return "warn";
+  }
+}
+
+export const contentModerationService = new ContentModerationService();

package/src/domains/content-moderation/infrastructure/services/index.ts

@@ -0,0 +1,8 @@
+/**
+ * Services Index
+ * Exports all infrastructure services
+ */
+
+export { contentModerationService } from "./content-moderation.service";
+export { patternMatcherService, type PatternMatch } from "./pattern-matcher.service";
+export * from "./moderators";

package/src/domains/content-moderation/infrastructure/services/moderators/base.moderator.ts

@@ -0,0 +1,62 @@
+/**
+ * Base Moderator
+ * Shared functionality for all content moderators
+ */
+
+import type {
+  Violation,
+  ViolationType,
+  SuggestionMessages,
+} from "../../../domain/entities/moderation.types";
+
+export interface ModerationResult {
+  isAllowed: boolean;
+  violations: Violation[];
+}
+
+const DEFAULT_SUGGESTIONS: Record<string, string> = {
+  explicit_content: "Remove explicit content",
+  violence: "Remove violent content",
+  hate_speech: "Remove discriminatory language",
+  harassment: "Remove harassing content",
+  illegal_activity: "Remove illegal content references",
+  spam: "Remove spam content",
+  copyright: "Remove copyrighted content",
+  personal_info: "Remove personal information",
+  dangerous_content: "Remove dangerous content",
+  default: "Modify content to comply with guidelines",
+};
+
+export abstract class BaseModerator {
+  protected customSuggestions?: SuggestionMessages;
+
+  setSuggestionMessages(messages: SuggestionMessages): void {
+    this.customSuggestions = messages;
+  }
+
+  protected getSuggestion(type: ViolationType): string {
+    if (this.customSuggestions?.[type]) {
+      return this.customSuggestions[type] as string;
+    }
+    return DEFAULT_SUGGESTIONS[type] || DEFAULT_SUGGESTIONS.default;
+  }
+
+  protected createViolation(
+    id: string,
+    ruleName: string,
+    message: string,
+    violationType: ViolationType = "illegal_activity"
+  ): Violation {
+    return {
+      ruleId: id,
+      ruleName,
+      violationType,
+      severity: "high",
+      matchedPattern: "validation",
+      context: "",
+      suggestion: message,
+    };
+  }
+
+  abstract moderate(content: string): ModerationResult;
+}

package/src/domains/content-moderation/infrastructure/services/moderators/image.moderator.ts

@@ -0,0 +1,64 @@
+/**
+ * Image Content Moderator
+ * Validates and moderates image URIs
+ */
+
+import type { Violation } from "../../../domain/entities/moderation.types";
+import { BaseModerator, type ModerationResult } from "./base.moderator";
+
+const DEFAULT_PROTOCOLS = ["http:", "https:", "file:", "data:"];
+const DEFAULT_MAX_URI_LENGTH = 2048;
+
+class ImageModerator extends BaseModerator {
+  private allowedProtocols = DEFAULT_PROTOCOLS;
+  private maxUriLength = DEFAULT_MAX_URI_LENGTH;
+
+  setAllowedProtocols(protocols: string[]): void {
+    this.allowedProtocols = protocols;
+  }
+
+  setMaxUriLength(length: number): void {
+    this.maxUriLength = length;
+  }
+
+  moderate(imageUri: string): ModerationResult {
+    const validationError = this.validate(imageUri);
+    if (validationError) {
+      return { isAllowed: false, violations: [validationError] };
+    }
+
+    return { isAllowed: true, violations: [] };
+  }
+
+  private validate(uri: string): Violation | null {
+    if (!uri || typeof uri !== "string") {
+      return this.createViolation("empty-uri", "Image Validation", "empty URI");
+    }
+
+    if (uri.length > this.maxUriLength) {
+      return this.createViolation(
+        "uri-too-long",
+        "Image Validation",
+        "URI too long"
+      );
+    }
+
+    if (!this.hasValidProtocol(uri)) {
+      return this.createViolation(
+        "invalid-protocol",
+        "Image Validation",
+        "invalid protocol"
+      );
+    }
+
+    return null;
+  }
+
+  private hasValidProtocol(uri: string): boolean {
+    return this.allowedProtocols.some((protocol) =>
+      uri.toLowerCase().startsWith(protocol)
+    );
+  }
+}
+
+export const imageModerator = new ImageModerator();