@umituz/react-native-ai-generation-content 1.12.1 → 1.12.3

package/src/domains/prompts/infrastructure/services/FaceSwapService.ts

@@ -0,0 +1,198 @@
+import type { IFaceSwapService } from '../../domain/repositories/IAIPromptServices';
+import type { 
+  AIPromptTemplate
+} from '../../domain/entities/AIPromptTemplate';
+import type { 
+  FaceSwapConfig, 
+  FaceSwapGenerationResult,
+  FaceSwapSafety
+} from '../../domain/entities/FaceSwapConfig';
+import type { AIPromptCategory } from '../../domain/entities/types';
+import { createAIPromptTemplate } from '../../domain/entities/AIPromptTemplate';
+import { validateFaceSwapConfig } from '../../domain/entities/FaceSwapConfig';
+import type { AIPromptResult } from '../../domain/entities/types';
+import { PromptGenerationService } from '../services/PromptGenerationService';
+
+const DEFAULT_FACE_SWAP_SAFETY: FaceSwapSafety = {
+  contentFilter: true,
+  identityPreservation: true,
+  adultContentFilter: true,
+};
+
+const createFaceSwapBaseTemplate = (config?: {
+  targetPerson?: string;
+  transformationType?: string;
+  quality?: string;
+}): string => {
+  const {
+    targetPerson = 'SAME PERSON',
+    transformationType = 'transformation',
+    quality = 'App Store–ready'
+  } = config || {};
+
+  return `
+You are an expert AI photo editor.
+This is a PHOTO EDITING task, not text-to-image generation.
+
+IDENTITY PRESERVATION (CRITICAL):
+The output must clearly depict the ${targetPerson} from the uploaded photo.
+The person must remain recognizable after transformation.
+
+FACE IDENTITY (DO NOT CHANGE):
+- Facial bone structure and proportions
+- Eye shape and eye color
+- Nose shape and size
+- Lip shape and proportions
+- Skin tone and natural facial texture
+
+ALLOWED NON-DESTRUCTIVE CHANGES:
+- Hair style and hair color (wig-like or costume-based)
+- Facial hair (beard, mustache) as costume elements
+- Accessories (hats, glasses, headwear)
+- Subtle expression adjustments that do NOT alter facial structure
+- Costume makeup that does NOT reshape the face
+
+STRICTLY FORBIDDEN:
+- Face replacement or face swapping with another identity
+- Changing the person into a different real individual
+- Changing gender or ethnicity
+- Extreme age transformation
+- Distorted faces or unrealistic anatomy
+
+SAFETY CONSTRAINTS:
+Do NOT add nudity, sexual content, violence, weapons, drugs, political or religious symbols,
+copyrighted characters, celebrities, text overlays, logos, or watermarks.
+
+STYLE & QUALITY:
+- Realistic photographic style
+- High-quality, natural lighting
+- Clean, premium, ${quality} result
+
+FINAL RULE:
+This is a fictional, cosmetic ${transformationType} for entertainment only.
+  `.trim();
+};
+
+export class FaceSwapService implements IFaceSwapService {
+  private promptService: PromptGenerationService;
+  private availableStyles: string[] = [];
+
+  constructor() {
+    this.promptService = new PromptGenerationService();
+    this.initializeDefaultStyles();
+  }
+
+  async generateTemplate(config: FaceSwapConfig): Promise<AIPromptResult<AIPromptTemplate>> {
+    try {
+      if (!this.validateConfig(config)) {
+        return { 
+          success: false, 
+          error: 'INVALID_VARIABLES', 
+          message: 'Invalid face swap configuration' 
+        };
+      }
+
+      const template = this.createFaceSwapTemplate(config);
+      return { success: true, data: template };
+    } catch (error) {
+      return { 
+        success: false, 
+        error: 'GENERATION_FAILED', 
+        message: 'Failed to generate face swap template' 
+      };
+    }
+  }
+
+  async generatePrompt(
+    template: AIPromptTemplate, 
+    config: FaceSwapConfig
+  ): Promise<AIPromptResult<string>> {
+    const variables = {
+      styleName: config.styleName,
+      environment: config.environment || 'Neutral studio background',
+      preserveIdentity: config.preserveIdentity,
+      allowHairStyle: config.allowHairStyle,
+      allowAccessories: config.allowAccessories,
+      allowExpression: config.allowExpression,
+    };
+
+    return this.promptService.generateFromTemplate(template, variables);
+  }
+
+  validateConfig(config: FaceSwapConfig): boolean {
+    return validateFaceSwapConfig(config);
+  }
+
+  async getAvailableStyles(): Promise<string[]> {
+    return Promise.resolve([...this.availableStyles]);
+  }
+
+  private initializeDefaultStyles(): void {
+    this.availableStyles = [];
+  }
+
+  public registerStyle(style: string): void {
+    if (!this.availableStyles.includes(style)) {
+      this.availableStyles.push(style);
+    }
+  }
+
+  public registerStyles(styles: string[]): void {
+    styles.forEach(style => this.registerStyle(style));
+  }
+
+  public clearStyles(): void {
+    this.availableStyles = [];
+  }
+
+  private createFaceSwapTemplate(config: FaceSwapConfig): AIPromptTemplate {
+    const templateId = `face-swap-${config.styleName.toLowerCase().replace(/\s+/g, '-')}`;
+    
+    return createAIPromptTemplate({
+      id: templateId,
+      name: `Face Swap: ${config.styleName}`,
+      description: `Transform face into ${config.styleName} style`,
+      category: 'face-swap' as AIPromptCategory,
+      template: this.buildFaceSwapTemplate(config),
+      variables: [],
+      safety: {
+        contentFilter: DEFAULT_FACE_SWAP_SAFETY.contentFilter,
+        adultContentFilter: DEFAULT_FACE_SWAP_SAFETY.adultContentFilter,
+        violenceFilter: true,
+        hateSpeechFilter: true,
+        copyrightFilter: true,
+      },
+      version: '1.0.0',
+    });
+  }
+
+  private buildFaceSwapTemplate(config: FaceSwapConfig): string {
+    const baseTemplate = createFaceSwapBaseTemplate({
+      targetPerson: 'SAME PERSON',
+      transformationType: 'transformation',
+      quality: 'App Store–ready',
+    });
+
+    return `${baseTemplate}
+
+STYLE NAME:
+${config.styleName}
+
+TRANSFORMATION GOAL:
+Transform the same person into this ${config.styleName} style
+${config.preserveIdentity ? 'while preserving their facial identity.' : ''}
+
+ENVIRONMENT:
+${config.environment || 'Neutral studio background'}
+
+EXPRESSION:
+- Natural expression
+- Subtle and natural, without changing facial structure
+
+OUTPUT:
+The same person from the uploaded photo,
+clearly recognizable,
+realistically transformed into a ${config.styleName} style.
+    `.trim();
+  }
+}

package/src/domains/prompts/infrastructure/services/FuturePredictionService.ts

@@ -0,0 +1,176 @@
+import type { IFuturePredictionService } from '../../domain/repositories/IAIPromptServices';
+import type { AIPromptTemplate } from '../../domain/entities/AIPromptTemplate';
+import type { AIPromptResult } from '../../domain/entities/types';
+import type {
+    FuturePredictionConfig,
+    FuturePredictionResult,
+} from '../../domain/entities/FuturePredictionConfig';
+import { createAIPromptTemplate } from '../../domain/entities/AIPromptTemplate';
+import {
+    validateFuturePredictionConfig,
+    getFutureYear,
+} from '../../domain/entities/FuturePredictionConfig';
+import { PromptGenerationService } from './PromptGenerationService';
+
+const IMAGE_PROMPT_TEMPLATE = `
+Generate a single high-quality, photorealistic image of {{subjectA}}{{#if subjectB}} and {{subjectB}}{{/if}}.
+Role/Relationship: {{subjectRole}}
+Context/Scenario: {{scenarioTitle}}
+Additional Details: {{promptModifier}}
+
+Requirements:
+- Maintain facial identity and key features of the individual(s) provided in input images.
+- Ensure lighting, environment, and skin tones are realistic and consistent.
+- Style: High detail, professional photography, 4k resolution.
+- No text, watermarks, or artificial artifacts.
+`.trim();
+
+const STORY_PROMPT_TEMPLATE = `
+Write a short, engaging, and evocative description for a future scene.
+Subjects: {{subjectA}}{{#if subjectB}} and {{subjectB}}{{/if}}
+Role: {{subjectRole}}
+Scenario: {{scenarioTitle}}
+Atmosphere/Tone: {{tone}}
+Context: {{promptModifier}}
+Imaginary Year: {{futureYear}}
+
+Style:
+- 2-3 sentences max.
+- Be vivid and imaginative.
+- Do not use hashtags.
+{{#if language}}Please respond in {{language}} language.{{/if}}
+`.trim();
+
+export class FuturePredictionService implements IFuturePredictionService {
+    private promptService: PromptGenerationService;
+
+    constructor() {
+        this.promptService = new PromptGenerationService();
+    }
+
+    async generateTemplate(
+        config: FuturePredictionConfig
+    ): Promise<AIPromptResult<AIPromptTemplate>> {
+        if (!this.validateConfig(config)) {
+            return {
+                success: false,
+                error: 'VALIDATION_ERROR',
+                message: 'Invalid future prediction configuration',
+            };
+        }
+
+        const template = this.createTemplate(config);
+        return { success: true, data: template };
+    }
+
+    async generatePrompts(
+        config: FuturePredictionConfig
+    ): Promise<AIPromptResult<FuturePredictionResult>> {
+        if (!this.validateConfig(config)) {
+            return {
+                success: false,
+                error: 'VALIDATION_ERROR',
+                message: 'Invalid configuration',
+            };
+        }
+
+        const imagePrompt = this.buildImagePrompt(config);
+        const storyPrompt = this.buildStoryPrompt(config);
+
+        return {
+            success: true,
+            data: {
+                imagePrompt,
+                storyPrompt,
+                metadata: {
+                    scenarioId: config.scenarioId,
+                    personCount: config.settings.personCount,
+                    language: config.settings.language,
+                    generatedAt: Date.now(),
+                },
+            },
+        };
+    }
+
+    validateConfig(config: FuturePredictionConfig): boolean {
+        return validateFuturePredictionConfig(config);
+    }
+
+    buildImagePrompt(config: FuturePredictionConfig): string {
+        const subjectRole = config.settings.subjectRole || 'individuals';
+
+        return IMAGE_PROMPT_TEMPLATE
+            .replace(/{{subjectA}}/g, config.subjectA)
+            .replace(/{{subjectB}}/g, config.subjectB || '')
+            .replace(/{{#if subjectB}} and {{subjectB}}{{\/if}}/g, config.subjectB ? ` and ${config.subjectB}` : '')
+            .replace(/{{subjectRole}}/g, subjectRole)
+            .replace(/{{scenarioTitle}}/g, config.scenarioTitle)
+            .replace(/{{promptModifier}}/g, config.promptModifier);
+    }
+
+    buildStoryPrompt(config: FuturePredictionConfig): string {
+        const futureYear = config.settings.year || getFutureYear();
+        const tone = config.settings.tone || 'neutral';
+        const subjectRole = config.settings.subjectRole || 'individuals';
+
+        let prompt = STORY_PROMPT_TEMPLATE
+            .replace(/{{subjectA}}/g, config.subjectA)
+            .replace(/{{subjectB}}/g, config.subjectB || '')
+            .replace(/{{#if subjectB}} and {{subjectB}}{{\/if}}/g, config.subjectB ? ` and ${config.subjectB}` : '')
+            .replace(/{{subjectRole}}/g, subjectRole)
+            .replace(/{{scenarioTitle}}/g, config.scenarioTitle)
+            .replace(/{{tone}}/g, tone)
+            .replace(/{{promptModifier}}/g, config.promptModifier)
+            .replace(/{{futureYear}}/g, String(futureYear));
+
+        if (config.settings.language && config.settings.language !== 'en') {
+            prompt = prompt.replace(
+                /{{#if language}}(.*?){{\/if}}/g,
+                `$1`.replace(/{{language}}/g, this.getLanguageName(config.settings.language))
+            );
+        } else {
+            prompt = prompt.replace(/{{#if language}}.*?{{\/if}}/g, '');
+        }
+
+        return prompt.trim();
+    }
+
+    private createTemplate(config: FuturePredictionConfig): AIPromptTemplate {
+        return createAIPromptTemplate({
+            id: `future-prediction-${config.scenarioId}`,
+            name: `Future Prediction: ${config.scenarioTitle}`,
+            description: `Generate future prediction for ${config.scenarioId} scenario`,
+            category: 'future-prediction',
+            template: this.buildImagePrompt(config),
+            variables: [],
+            safety: {
+                contentFilter: true,
+                adultContentFilter: true,
+                violenceFilter: true,
+                hateSpeechFilter: true,
+                copyrightFilter: true,
+            },
+            version: '1.0.0',
+        });
+    }
+
+    private getLanguageName(code: string): string {
+        const languages: Record<string, string> = {
+            tr: 'Turkish',
+            es: 'Spanish',
+            fr: 'French',
+            de: 'German',
+            it: 'Italian',
+            pt: 'Portuguese',
+            ru: 'Russian',
+            ja: 'Japanese',
+            ko: 'Korean',
+            zh: 'Chinese',
+            ar: 'Arabic',
+            hi: 'Hindi',
+            th: 'Thai',
+            vi: 'Vietnamese',
+        };
+        return languages[code] || 'English';
+    }
+}

package/src/domains/prompts/infrastructure/services/ImageEnhancementService.ts

@@ -0,0 +1,181 @@
+import type { IImageEnhancementService } from '../../domain/repositories/IAIPromptServices';
+import type {
+  ImageEnhancementConfig,
+  EnhancementAdjustments,
+} from '../../domain/entities/ImageEnhancementConfig';
+import type { AIPromptTemplate } from '../../domain/entities/AIPromptTemplate';
+import type { AIPromptResult } from '../../domain/entities/types';
+import { createAIPromptTemplate } from '../../domain/entities/AIPromptTemplate';
+import {
+  validateImageEnhancementConfig,
+  calculateAdjustments
+} from '../../domain/entities/ImageEnhancementConfig';
+import { PromptGenerationService } from '../services/PromptGenerationService';
+
+const createImageEnhancementBaseTemplate = (config?: {
+  enhancementType?: string;
+  targetStyle?: string;
+}): string => {
+  const {
+    enhancementType = 'comprehensive',
+    targetStyle = 'natural'
+  } = config || {};
+
+  return `
+You are an expert AI image enhancement specialist.
+This is an IMAGE ENHANCEMENT task, not image generation.
+
+ENHANCEMENT GOAL:
+Apply ${enhancementType} improvements with ${targetStyle} appearance
+while preserving the original content and composition.
+
+ENHANCEMENT PRINCIPLES:
+- Maintain natural appearance and authenticity
+- Apply subtle, professional-grade adjustments
+- Preserve important details and textures
+- Avoid over-processing or artificial results
+
+TECHNICAL REQUIREMENTS:
+- Proper exposure and brightness correction
+- Optimal contrast and dynamic range
+- Natural color balance and saturation
+- Appropriate sharpening and clarity
+- Noise reduction without losing details
+
+STYLE CONSIDERATIONS:
+${targetStyle === 'vivid' ? '- Vibrant colors with high impact' :
+      targetStyle === 'dramatic' ? '- Enhanced contrast and mood' :
+        targetStyle === 'professional' ? '- Conservative, polished look' :
+          '- Natural, balanced appearance'}
+
+SAFETY CONSTRAINTS:
+- Do not alter the subject or composition
+- Preserve skin tones and natural colors
+- Avoid artificial or over-enhanced results
+- Maintain photo authenticity
+
+OUTPUT:
+A professionally enhanced version with ${enhancementType} improvements,
+optimized for ${targetStyle} presentation.
+  `.trim();
+};
+
+export class ImageEnhancementService implements IImageEnhancementService {
+  private promptService: PromptGenerationService;
+
+  constructor() {
+    this.promptService = new PromptGenerationService();
+  }
+
+  async generateTemplate(config: ImageEnhancementConfig): Promise<AIPromptResult<AIPromptTemplate>> {
+    try {
+      if (!this.validateConfig(config)) {
+        return {
+          success: false,
+          error: 'VALIDATION_ERROR',
+          message: 'Invalid image enhancement configuration'
+        };
+      }
+
+      const template = this.createImageEnhancementTemplate(config);
+      return { success: true, data: template };
+    } catch (error) {
+      return {
+        success: false,
+        error: 'GENERATION_FAILED',
+        message: 'Failed to generate image enhancement template'
+      };
+    }
+  }
+
+  async generatePrompt(
+    template: AIPromptTemplate,
+    config: ImageEnhancementConfig
+  ): Promise<AIPromptResult<string>> {
+    const adjustments = this.calculateAdjustments(config);
+    const variables = {
+      enhancementType: config.enhancementType,
+      intensity: config.intensity,
+      preserveNatural: config.preserveNatural,
+      autoAdjust: config.autoAdjust,
+      targetStyle: config.targetStyle,
+      adjustments,
+    };
+
+    return this.promptService.generateFromTemplate(template, variables);
+  }
+
+  validateConfig(config: ImageEnhancementConfig): boolean {
+    return validateImageEnhancementConfig(config);
+  }
+
+  calculateAdjustments(config: ImageEnhancementConfig): EnhancementAdjustments {
+    return calculateAdjustments(config);
+  }
+
+  private createImageEnhancementTemplate(config: ImageEnhancementConfig): AIPromptTemplate {
+    const templateId = `image-enhancement-${config.enhancementType}`;
+
+    const baseTemplate = createImageEnhancementBaseTemplate({
+      enhancementType: config.enhancementType,
+      targetStyle: config.targetStyle,
+    });
+
+    return createAIPromptTemplate({
+      id: templateId,
+      name: `Image Enhancement: ${config.enhancementType}`,
+      description: `Enhance images with ${config.enhancementType} improvements`,
+      category: 'image-enhancement',
+      template: `${baseTemplate}
+
+ENHANCEMENT TYPE:
+${config.enhancementType}
+
+STYLE TARGET:
+${config.targetStyle}
+
+ADJUSTMENT PARAMETERS:
+- Intensity Level: ${Math.round(config.intensity * 100)}%
+- Preserve Natural: ${config.preserveNatural}
+- Auto Adjust: ${config.autoAdjust}
+- Target Style: ${config.targetStyle}
+
+SPECIFIC ENHANCEMENTS:
+${this.getSpecificEnhancements(config)}
+
+EXPECTED RESULT:
+Professional ${config.enhancementType} enhancement
+with ${config.targetStyle} presentation style,
+maintaining authenticity while improving quality.
+      `.trim(),
+      variables: [],
+      safety: {
+        contentFilter: true,
+        adultContentFilter: true,
+        violenceFilter: true,
+        hateSpeechFilter: true,
+        copyrightFilter: true,
+      },
+      version: '1.0.0',
+    });
+  }
+
+  private getSpecificEnhancements(config: ImageEnhancementConfig): string {
+    const enhancements: string[] = [];
+
+    if (config.enhancementType === 'brightness' || config.enhancementType === 'all') {
+      enhancements.push('- Brightness optimization for perfect exposure');
+    }
+    if (config.enhancementType === 'contrast' || config.enhancementType === 'all') {
+      enhancements.push('- Contrast enhancement for dynamic range');
+    }
+    if (config.enhancementType === 'saturation' || config.enhancementType === 'all') {
+      enhancements.push('- Saturation adjustment for color vibrancy');
+    }
+    if (config.enhancementType === 'sharpness' || config.enhancementType === 'all') {
+      enhancements.push('- Sharpness improvement for detail clarity');
+    }
+
+    return enhancements.join('\n') || '- General image quality improvement';
+  }
+}