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

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

@@ -0,0 +1,232 @@
+import type { IColorizationService } from '../../domain/repositories/IAIPromptServices';
+import type {
+  ColorizationConfig,
+} from '../../domain/entities/ColorizationConfig';
+import type { AIPromptTemplate } from '../../domain/entities/AIPromptTemplate';
+import type { AIPromptResult } from '../../domain/entities/types';
+import { createAIPromptTemplate } from '../../domain/entities/AIPromptTemplate';
+import {
+  validateColorizationConfig,
+  getColorizationQuality,
+  getEraDescription,
+  getSuggestedColorPalette
+} from '../../domain/entities/ColorizationConfig';
+import { PromptGenerationService } from '../services/PromptGenerationService';
+
+const createColorizationBaseTemplate = (config?: {
+  targetType?: string;
+  colorMode?: string;
+}): string => {
+  const {
+    targetType = 'black-and-white',
+    colorMode = 'realistic'
+  } = config || {};
+
+  return `
+You are an expert AI colorization specialist.
+This is a PHOTO COLORIZATION task, not image generation.
+
+COLORIZATION OBJECTIVES:
+- Add appropriate colors to ${targetType} images
+- Apply ${colorMode} color treatment while preserving authenticity
+- Maintain original composition and details
+- Create natural, pleasing color relationships
+
+COLORIZATION PRINCIPLES:
+- Research appropriate color schemes for image era/content
+- Apply colors that match scene context and lighting
+- Preserve details and textures while adding color
+- Ensure color harmony and balance throughout image
+
+${colorMode === 'realistic' ?
+      `REALISTIC COLORIZATION:
+- Use historically accurate colors when appropriate
+- Consider natural lighting conditions
+- Apply realistic skin tones and environmental colors
+- Maintain photographic authenticity` :
+      colorMode === 'vibrant' ?
+        `VIBRANT COLORIZATION:
+- Use rich, saturated colors for visual impact
+- Create bold color contrasts and relationships
+- Apply artistic color interpretations
+- Enhance visual interest and appeal` :
+        colorMode === 'artistic' ?
+          `ARTISTIC COLORIZATION:
+- Apply creative color interpretations
+- Use expressive color choices and combinations
+- Create mood and atmosphere through color
+- Allow artistic freedom in color selection` :
+          `VINTAGE COLORIZATION:
+- Use period-appropriate color palettes
+- Apply aged, authentic color treatments
+- Maintain historical color sensibilities
+- Create nostalgic, time-appropriate appearance`}
+
+TECHNICAL REQUIREMENTS:
+- Preserve edges and details during color application
+- Apply colors smoothly and naturally
+- Consider lighting and shadow relationships
+- Maintain image quality and resolution
+
+SAFETY CONSTRAINTS:
+- Do not alter content or composition
+- Preserve important details and features
+- Avoid inappropriate or unrealistic colors
+- Maintain appropriate content standards
+
+OUTPUT:
+Beautifully colorized version of the original ${targetType} image,
+with ${colorMode} color treatment that enhances rather than dominates.
+  `.trim();
+};
+
+export class ColorizationService implements IColorizationService {
+  private promptService: PromptGenerationService;
+
+  constructor() {
+    this.promptService = new PromptGenerationService();
+  }
+
+  async generateTemplate(config: ColorizationConfig): Promise<AIPromptResult<AIPromptTemplate>> {
+    try {
+      if (!this.validateConfig(config)) {
+        return {
+          success: false,
+          error: 'VALIDATION_ERROR',
+          message: 'Invalid colorization configuration'
+        };
+      }
+
+      const template = this.createColorizationTemplate(config);
+      return { success: true, data: template };
+    } catch (error) {
+      return {
+        success: false,
+        error: 'GENERATION_FAILED',
+        message: 'Failed to generate colorization template'
+      };
+    }
+  }
+
+  async generatePrompt(
+    template: AIPromptTemplate,
+    config: ColorizationConfig
+  ): Promise<AIPromptResult<string>> {
+    const variables = {
+      targetType: config.targetType,
+      colorMode: config.colorMode,
+      preserveOriginal: config.preserveOriginal,
+      adjustLighting: config.adjustLighting,
+      skinTonePreservation: config.skinTonePreservation,
+      era: config.era || '',
+      qualityScore: getColorizationQuality(config),
+      colorPalette: this.getColorPalette(config),
+    };
+
+    return this.promptService.generateFromTemplate(template, variables);
+  }
+
+  validateConfig(config: ColorizationConfig): boolean {
+    return validateColorizationConfig(config);
+  }
+
+  getColorPalette(config: ColorizationConfig): string[] {
+    return getSuggestedColorPalette(config.targetType, config.colorMode);
+  }
+
+  getQualityScore(config: ColorizationConfig): number {
+    return getColorizationQuality(config);
+  }
+
+  private createColorizationTemplate(config: ColorizationConfig): AIPromptTemplate {
+    const templateId = `colorization-${config.targetType}-${config.colorMode}`;
+
+    const baseTemplate = createColorizationBaseTemplate({
+      targetType: config.targetType,
+      colorMode: config.colorMode,
+    });
+
+    return createAIPromptTemplate({
+      id: templateId,
+      name: `Colorization: ${config.targetType} to ${config.colorMode}`,
+      description: `Colorize ${config.targetType} images with ${config.colorMode} treatment`,
+      category: 'colorization',
+      template: `${baseTemplate}
+
+COLORIZATION CONFIGURATION:
+- Target Type: ${config.targetType}
+- Color Mode: ${config.colorMode}
+- Preserve Original: ${config.preserveOriginal}
+- Adjust Lighting: ${config.adjustLighting}
+- Skin Tone Preservation: ${config.skinTonePreservation}
+${config.era ? `- Era: ${config.era}` : ''}
+
+COLOR REQUIREMENTS:
+${this.getColorRequirements(config)}
+
+${config.era ? `ERA-SPECIFIC GUIDELINES:
+${getEraDescription(config.era)}
+
+` : ''}QUALITY EXPECTATIONS:
+- Quality Score: ${Math.round(getColorizationQuality(config) * 100)}%
+- Color Mode: ${config.colorMode} treatment applied
+- Preserved Elements: ${config.preserveOriginal ? 'Original content preserved' : 'Enhanced interpretation'}
+- Skin Handling: ${config.skinTonePreservation ? 'Natural tones preserved' : 'Artistic interpretation allowed'}
+
+${this.getColorPalette(config).length > 0 ? `
+SUGGESTED COLOR PALETTE:
+${this.getColorPalette(config).join(', ')}
+
+` : ''}EXPECTED RESULT:
+Professionally colorized ${config.targetType} image,
+with ${config.colorMode} color treatment,
+${config.skinTonePreservation ? 'maintaining natural appearance' : 'allowing artistic interpretation'}.
+      `.trim(),
+      variables: [],
+      safety: {
+        contentFilter: true,
+        adultContentFilter: true,
+        violenceFilter: true,
+        hateSpeechFilter: true,
+        copyrightFilter: true,
+      },
+      version: '1.0.0',
+    });
+  }
+
+  private getColorRequirements(config: ColorizationConfig): string {
+    const requirements: string[] = [];
+
+    if (config.targetType === 'black-and-white') {
+      requirements.push('- Add natural colors to monochrome image');
+      requirements.push('- Consider original grayscale values for color mapping');
+    }
+
+    if (config.targetType === 'sepia') {
+      requirements.push('- Refresh and enhance sepia-toned image');
+      requirements.push('- Maintain vintage character while adding color');
+    }
+
+    if (config.colorMode === 'realistic') {
+      requirements.push('- Use historically and naturally accurate colors');
+      requirements.push('- Apply appropriate skin tones and environmental colors');
+    }
+
+    if (config.colorMode === 'vibrant') {
+      requirements.push('- Use rich, saturated colors for visual impact');
+      requirements.push('- Create bold color contrasts and relationships');
+    }
+
+    if (config.adjustLighting) {
+      requirements.push('- Adjust colors for optimal lighting conditions');
+      requirements.push('- Ensure appropriate contrast and brightness');
+    }
+
+    if (config.skinTonePreservation) {
+      requirements.push('- Maintain natural, appropriate skin tones');
+      requirements.push('- Avoid unrealistic or inappropriate skin colors');
+    }
+
+    return requirements.join('\n') || '- Apply appropriate color treatment based on configuration';
+  }
+}

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';
+    }
+}