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

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

@@ -0,0 +1,10 @@
+/**
+ * Moderators Index
+ * Exports all content moderators
+ */
+
+export { textModerator } from "./text.moderator";
+export { imageModerator } from "./image.moderator";
+export { videoModerator } from "./video.moderator";
+export { voiceModerator } from "./voice.moderator";
+export { BaseModerator, type ModerationResult } from "./base.moderator";

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

@@ -0,0 +1,144 @@
+/**
+ * Text Content Moderator
+ * Validates and moderates text content
+ */
+
+import type { Violation } from "../../../domain/entities/moderation.types";
+import { patternMatcherService } from "../pattern-matcher.service";
+import { rulesRegistry } from "../../rules/rules-registry";
+import { BaseModerator, type ModerationResult } from "./base.moderator";
+
+declare const __DEV__: boolean;
+
+const DEFAULT_MAX_LENGTH = 10000;
+
+const MALICIOUS_CODE_PATTERNS = [
+  /<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi,
+  /javascript:/gi,
+  /on\w+\s*=/gi,
+];
+
+const PROMPT_INJECTION_PATTERNS = [
+  /ignore\s+(all\s+)?(previous|prior|above)\s+(instructions?|prompts?|rules?)/gi,
+  /disregard\s+(all\s+)?(previous|prior|above)\s+(instructions?|prompts?)/gi,
+  /forget\s+(all\s+)?(previous|prior|your)\s+(instructions?|prompts?|rules?)/gi,
+  /you\s+are\s+now\s+(a|an)\s+/gi,
+  /act\s+as\s+(if|though)\s+you/gi,
+  /pretend\s+(you\s+are|to\s+be)/gi,
+  /bypass\s+(your\s+)?(safety|content|moderation)/gi,
+  /override\s+(your\s+)?(restrictions?|limitations?|rules?)/gi,
+  /jailbreak/gi,
+  /DAN\s*mode/gi,
+  /developer\s+mode\s+(enabled|on|activated)/gi,
+  /system\s*:\s*/gi,
+  /\[system\]/gi,
+  /<<\s*sys\s*>>/gi,
+];
+
+class TextModerator extends BaseModerator {
+  private maxLength = DEFAULT_MAX_LENGTH;
+
+  setMaxLength(length: number): void {
+    this.maxLength = length;
+  }
+
+  moderate(content: string): ModerationResult {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[TextModerator] moderate() called", {
+        contentLength: content?.length ?? 0,
+      });
+    }
+
+    const validationError = this.validate(content);
+    if (validationError) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        // eslint-disable-next-line no-console
+        console.log("[TextModerator] validation failed", {
+          ruleId: validationError.ruleId,
+          violationType: validationError.violationType,
+        });
+      }
+      return { isAllowed: false, violations: [validationError] };
+    }
+
+    const violations = this.evaluateRules(content);
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[TextModerator] moderate() completed", {
+        isAllowed: violations.length === 0,
+        violationsCount: violations.length,
+      });
+    }
+
+    return { isAllowed: violations.length === 0, violations };
+  }
+
+  private validate(content: string): Violation | null {
+    if (!content || typeof content !== "string") {
+      return this.createViolation("empty-content", "Validation", "empty");
+    }
+
+    if (content.length > this.maxLength) {
+      return this.createViolation("too-long", "Validation", "length exceeded");
+    }
+
+    if (this.containsMaliciousCode(content)) {
+      return this.createViolation(
+        "malicious",
+        "Security",
+        "malicious code",
+        "dangerous_content"
+      );
+    }
+
+    if (this.containsPromptInjection(content)) {
+      return this.createViolation(
+        "prompt-injection",
+        "Security",
+        "prompt injection",
+        "dangerous_content"
+      );
+    }
+
+    return null;
+  }
+
+  private containsMaliciousCode(content: string): boolean {
+    return MALICIOUS_CODE_PATTERNS.some((pattern) => pattern.test(content));
+  }
+
+  private containsPromptInjection(content: string): boolean {
+    return PROMPT_INJECTION_PATTERNS.some((pattern) => pattern.test(content));
+  }
+
+  private evaluateRules(content: string): Violation[] {
+    const rules = rulesRegistry.getRulesByContentType("text");
+    const violations: Violation[] = [];
+
+    for (const rule of rules) {
+      const matches = patternMatcherService.matchAnyPattern(
+        content,
+        rule.patterns
+      );
+      const matched = matches.find((m) => m.matched);
+
+      if (matched) {
+        violations.push({
+          ruleId: rule.id,
+          ruleName: rule.name,
+          violationType: rule.violationType,
+          severity: rule.severity,
+          matchedPattern: matched.matchedText || "",
+          context: content.slice(0, 100),
+          suggestion: this.getSuggestion(rule.violationType),
+        });
+      }
+    }
+
+    return violations;
+  }
+}
+
+export const textModerator = new TextModerator();

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

@@ -0,0 +1,64 @@
+/**
+ * Video Content Moderator
+ * Validates and moderates video URIs
+ */
+
+import type { Violation } from "../../../domain/entities/moderation.types";
+import { BaseModerator, type ModerationResult } from "./base.moderator";
+
+const DEFAULT_PROTOCOLS = ["http:", "https:", "file:"];
+const DEFAULT_MAX_URI_LENGTH = 2048;
+
+class VideoModerator 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(videoUri: string): ModerationResult {
+    const validationError = this.validate(videoUri);
+    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", "Video Validation", "empty URI");
+    }
+
+    if (uri.length > this.maxUriLength) {
+      return this.createViolation(
+        "uri-too-long",
+        "Video Validation",
+        "URI too long"
+      );
+    }
+
+    if (!this.hasValidProtocol(uri)) {
+      return this.createViolation(
+        "invalid-protocol",
+        "Video Validation",
+        "invalid protocol"
+      );
+    }
+
+    return null;
+  }
+
+  private hasValidProtocol(uri: string): boolean {
+    return this.allowedProtocols.some((protocol) =>
+      uri.toLowerCase().startsWith(protocol)
+    );
+  }
+}
+
+export const videoModerator = new VideoModerator();

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

@@ -0,0 +1,74 @@
+/**
+ * Voice Content Moderator
+ * Validates and moderates voice/TTS text content
+ */
+
+import type { Violation } from "../../../domain/entities/moderation.types";
+import { patternMatcherService } from "../pattern-matcher.service";
+import { rulesRegistry } from "../../rules/rules-registry";
+import { BaseModerator, type ModerationResult } from "./base.moderator";
+
+const DEFAULT_MAX_LENGTH = 5000;
+
+class VoiceModerator extends BaseModerator {
+  private maxLength = DEFAULT_MAX_LENGTH;
+
+  setMaxLength(length: number): void {
+    this.maxLength = length;
+  }
+
+  moderate(text: string): ModerationResult {
+    const validationError = this.validate(text);
+    if (validationError) {
+      return { isAllowed: false, violations: [validationError] };
+    }
+
+    const violations = this.evaluateRules(text);
+    return { isAllowed: violations.length === 0, violations };
+  }
+
+  private validate(text: string): Violation | null {
+    if (!text || typeof text !== "string") {
+      return this.createViolation("empty-text", "Voice Validation", "empty");
+    }
+
+    if (text.length > this.maxLength) {
+      return this.createViolation(
+        "too-long",
+        "Voice Validation",
+        "length exceeded"
+      );
+    }
+
+    return null;
+  }
+
+  private evaluateRules(text: string): Violation[] {
+    const rules = rulesRegistry.getRulesByContentType("voice");
+    const violations: Violation[] = [];
+
+    for (const rule of rules) {
+      const matches = patternMatcherService.matchAnyPattern(
+        text,
+        rule.patterns
+      );
+      const matched = matches.find((m) => m.matched);
+
+      if (matched) {
+        violations.push({
+          ruleId: rule.id,
+          ruleName: rule.name,
+          violationType: rule.violationType,
+          severity: rule.severity,
+          matchedPattern: matched.matchedText || "",
+          context: text.slice(0, 100),
+          suggestion: this.getSuggestion(rule.violationType),
+        });
+      }
+    }
+
+    return violations;
+  }
+}
+
+export const voiceModerator = new VoiceModerator();

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

@@ -0,0 +1,51 @@
+/**
+ * Pattern Matcher Service
+ * Utility service for regex pattern matching
+ */
+
+export interface PatternMatch {
+  pattern: string;
+  matched: boolean;
+  matchedText?: string;
+  position?: number;
+}
+
+class PatternMatcherService {
+  matchPattern(content: string, pattern: string): PatternMatch {
+    try {
+      const regex = new RegExp(pattern, "gi");
+      const match = regex.exec(content);
+
+      if (match) {
+        return {
+          pattern,
+          matched: true,
+          matchedText: match[0],
+          position: match.index,
+        };
+      }
+
+      return { pattern, matched: false };
+    } catch {
+      return { pattern, matched: false };
+    }
+  }
+
+  matchAnyPattern(content: string, patterns: string[]): PatternMatch[] {
+    return patterns.map((pattern) => this.matchPattern(content, pattern));
+  }
+
+  matchAllPatterns(content: string, patterns: string[]): boolean {
+    return patterns.every(
+      (pattern) => this.matchPattern(content, pattern).matched
+    );
+  }
+
+  hasAnyMatch(content: string, patterns: string[]): boolean {
+    return patterns.some(
+      (pattern) => this.matchPattern(content, pattern).matched
+    );
+  }
+}
+
+export const patternMatcherService = new PatternMatcherService();

package/src/domains/content-moderation/presentation/exceptions/content-policy-violation.exception.ts

@@ -0,0 +1,48 @@
+/**
+ * Content Policy Violation Exception
+ * Custom error class for content policy violations
+ */
+
+import type {
+  Violation,
+  ViolationType,
+} from "../../domain/entities/moderation.types";
+
+export class ContentPolicyViolationError extends Error {
+  public readonly violations: Violation[];
+
+  constructor(violations: Violation[], message?: string) {
+    const defaultMessage = `Content policy violation: ${violations
+      .map((v) => v.ruleName)
+      .join(", ")}`;
+    super(message || defaultMessage);
+    this.name = "ContentPolicyViolationError";
+    this.violations = violations;
+  }
+
+  getUserMessage(): string {
+    if (this.violations.length === 0) {
+      return "Content policy violation detected.";
+    }
+
+    const firstViolation = this.violations[0];
+    return firstViolation?.suggestion || "Please modify your content.";
+  }
+
+  getViolationTypes(): ViolationType[] {
+    return this.violations.map((v) => v.violationType);
+  }
+
+  hasViolationType(type: ViolationType): boolean {
+    return this.violations.some((v) => v.violationType === type);
+  }
+
+  getSeverityLevel(): "low" | "medium" | "high" | "critical" {
+    const severities = this.violations.map((v) => v.severity);
+
+    if (severities.includes("critical")) return "critical";
+    if (severities.includes("high")) return "high";
+    if (severities.includes("medium")) return "medium";
+    return "low";
+  }
+}

package/src/domains/prompts/domain/entities/AIPromptTemplate.ts

@@ -0,0 +1,48 @@
+import type { AIPromptCategory } from './types';
+import type { AIPromptVariable, AIPromptSafety, AIPromptVersion } from './value-objects';
+import { createPromptVersion, formatVersion } from './value-objects';
+
+export interface AIPromptTemplate {
+  readonly id: string;
+  readonly name: string;
+  readonly description: string;
+  readonly category: AIPromptCategory;
+  readonly template: string;
+  readonly variables: readonly AIPromptVariable[];
+  readonly safety: AIPromptSafety;
+  readonly version: AIPromptVersion;
+}
+
+export interface CreateAIPromptTemplateParams {
+  id: string;
+  name: string;
+  description: string;
+  category: AIPromptCategory;
+  template: string;
+  variables?: AIPromptVariable[];
+  safety: AIPromptSafety;
+  version: string;
+}
+
+export const createAIPromptTemplate = (
+  params: CreateAIPromptTemplateParams
+): AIPromptTemplate => ({
+  id: params.id,
+  name: params.name,
+  description: params.description,
+  category: params.category,
+  template: params.template,
+  variables: params.variables || [],
+  safety: params.safety,
+  version: createPromptVersion(params.version),
+});
+
+export const updateTemplateVersion = (
+  template: AIPromptTemplate,
+  newVersion: string
+): AIPromptTemplate => ({
+  ...template,
+  version: createPromptVersion(newVersion),
+});
+
+export const getTemplateString = (template: AIPromptTemplate): string => formatVersion(template.version);

package/src/domains/prompts/domain/entities/BackgroundRemovalConfig.ts

@@ -0,0 +1,86 @@
+import type { AIPromptTemplate } from './AIPromptTemplate';
+
+export interface BackgroundRemovalConfig {
+  precision: 'fast' | 'accurate' | 'ultra-accurate';
+  edgeRefinement: boolean;
+  preserveHair: boolean;
+  outputFormat: 'png' | 'webp' | 'transparent';
+  addNewBackground?: string;
+}
+
+export interface BackgroundRemovalTemplate {
+  readonly id: string;
+  readonly name: string;
+  readonly description: string;
+  readonly basePrompt: string;
+  readonly variables: BackgroundRemovalVariable[];
+  readonly processing: BackgroundRemovalSettings;
+}
+
+export interface BackgroundRemovalVariable {
+  name: string;
+  description: string;
+  required: boolean;
+  options?: string[];
+}
+
+export interface BackgroundRemovalSettings {
+  supportedFormats: string[];
+  maxResolution: number;
+  processingTimes: Record<string, number>;
+}
+
+export interface BackgroundRemovalResult {
+  template: AIPromptTemplate;
+  config: BackgroundRemovalConfig;
+  estimatedProcessingTime: number;
+  qualityScore: number;
+}
+
+export interface DetectedObject {
+  type: string;
+  confidence: number;
+  boundingBox: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+  };
+}
+
+export const validateBackgroundRemovalConfig = (config: BackgroundRemovalConfig): boolean => {
+  return !!(
+    config.precision && 
+    config.outputFormat &&
+    ['png', 'webp', 'transparent'].includes(config.outputFormat)
+  );
+};
+
+export const createBackgroundRemovalVariable = (
+  name: string,
+  description: string,
+  required: boolean = true,
+  options?: string[]
+): BackgroundRemovalVariable => ({
+  name,
+  description,
+  required,
+  options,
+});
+
+export const getProcessingTime = (precision: BackgroundRemovalConfig['precision']): number => {
+  switch (precision) {
+    case 'fast': return 2;
+    case 'accurate': return 5;
+    case 'ultra-accurate': return 10;
+    default: return 5;
+  }
+};
+
+export const getQualityScore = (config: BackgroundRemovalConfig): number => {
+  let score = config.edgeRefinement ? 0.9 : 0.7;
+  if (config.preserveHair) score += 0.05;
+  if (config.precision === 'ultra-accurate') score += 0.15;
+  if (config.precision === 'accurate') score += 0.1;
+  return Math.min(score, 1.0);
+};

package/src/domains/prompts/domain/entities/ColorizationConfig.ts

@@ -0,0 +1,101 @@
+import type { AIPromptTemplate } from './AIPromptTemplate';
+
+export interface ColorizationConfig {
+  targetType: 'black-and-white' | 'sepia' | 'faded' | 'damaged';
+  colorMode: 'realistic' | 'vibrant' | 'artistic' | 'vintage';
+  preserveOriginal: boolean;
+  adjustLighting: boolean;
+  skinTonePreservation: boolean;
+  era?: '1920s' | '1940s' | '1960s' | '1980s' | 'victorian';
+}
+
+export interface ColorizationTemplate {
+  readonly id: string;
+  readonly name: string;
+  readonly description: string;
+  readonly basePrompt: string;
+  readonly variables: ColorizationVariable[];
+  readonly colorization: ColorizationSettings;
+}
+
+export interface ColorizationVariable {
+  name: string;
+  description: string;
+  required: boolean;
+  options?: string[];
+}
+
+export interface ColorizationSettings {
+  supportedModes: string[];
+  eraPresets: Record<string, string>;
+  skinToneAdjustments: number;
+}
+
+export interface ColorizationResult {
+  template: AIPromptTemplate;
+  config: ColorizationConfig;
+  qualityScore: number;
+  colorPalette?: string[];
+}
+
+export const validateColorizationConfig = (config: ColorizationConfig): boolean => {
+  return !!(
+    config.targetType &&
+    config.colorMode &&
+    ['realistic', 'vibrant', 'artistic', 'vintage'].includes(config.colorMode)
+  );
+};
+
+export const createColorizationVariable = (
+  name: string,
+  description: string,
+  required: boolean = true,
+  options?: string[]
+): ColorizationVariable => ({
+  name,
+  description,
+  required,
+  options,
+});
+
+export const getColorizationQuality = (config: ColorizationConfig): number => {
+  let quality = 0.8;
+
+  if (config.preserveOriginal) quality += 0.1;
+  if (config.skinTonePreservation) quality += 0.05;
+  if (config.colorMode === 'realistic') quality += 0.1;
+  if (config.targetType === 'black-and-white') quality += 0.05;
+
+  return Math.min(quality, 1.0);
+};
+
+export const getEraDescription = (era?: string): string => {
+  switch (era) {
+    case '1920s': return '1920s vintage aesthetic with soft colors';
+    case '1940s': return '1940s wartime color palette';
+    case '1960s': return '1960s vibrant, saturated colors';
+    case '1980s': return '1980s neon and pastel tones';
+    case 'victorian': return 'Victorian era muted, elegant colors';
+    default: return 'Historically appropriate color palette';
+  }
+};
+
+export const getSuggestedColorPalette = (
+  targetType: ColorizationConfig['targetType'],
+  colorMode: ColorizationConfig['colorMode']
+): string[] => {
+  switch (targetType) {
+    case 'black-and-white':
+      return colorMode === 'vibrant'
+        ? ['#FF6B6B', '#4ECDC4', '#45B7D1', '#96CEB4', '#FFEAA7']
+        : ['#2C3E50', '#34495E', '#7F8C8D', '#95A5A6', '#BDC3C7'];
+    case 'sepia':
+      return ['#8B7355', '#A0826D', '#BC9A6A', '#D2B48C', '#DEB887'];
+    case 'faded':
+      return ['#E27D60', '#41B3A3', '#85DCBA', '#C1E1DC', '#E8DDCB'];
+    case 'damaged':
+      return ['#C9302C', '#F0AD4E', '#5BC0DE', '#5CB85C'];
+    default:
+      return [];
+  }
+};

package/src/domains/prompts/domain/entities/FaceSwapConfig.ts

@@ -0,0 +1,54 @@
+import type { AIPromptTemplate } from './AIPromptTemplate';
+import type { GeneratedPrompt } from './GeneratedPrompt';
+
+export interface FaceSwapConfig {
+  preserveIdentity: boolean;
+  allowHairStyle: boolean;
+  allowAccessories: boolean;
+  allowExpression: boolean;
+  environment?: string;
+  styleName: string;
+}
+
+export interface FaceSwapTemplate {
+  readonly id: string;
+  readonly name: string;
+  readonly description: string;
+  readonly basePrompt: string;
+  readonly variables: FaceSwapTemplateVariable[];
+  readonly safety: FaceSwapSafety;
+}
+
+export interface FaceSwapTemplateVariable {
+  name: string;
+  description: string;
+  required: boolean;
+  options?: string[];
+}
+
+export interface FaceSwapSafety {
+  contentFilter: boolean;
+  identityPreservation: boolean;
+  adultContentFilter: boolean;
+}
+
+export interface FaceSwapGenerationResult {
+  template: AIPromptTemplate;
+  prompt: GeneratedPrompt;
+}
+
+export const validateFaceSwapConfig = (config: FaceSwapConfig): boolean => {
+  return !!(config.styleName && config.styleName.trim().length > 0);
+};
+
+export const createFaceSwapVariable = (
+  name: string,
+  description: string,
+  required: boolean = true,
+  options?: string[]
+): FaceSwapTemplateVariable => ({
+  name,
+  description,
+  required,
+  options,
+});