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

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

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

@@ -0,0 +1,160 @@
+import type { IPhotoRestorationService } from '../../domain/repositories/IAIPromptServices';
+import type {
+  PhotoRestorationConfig,
+} from '../../domain/entities/PhotoRestorationConfig';
+import type { AIPromptTemplate } from '../../domain/entities/AIPromptTemplate';
+import type { AIPromptResult } from '../../domain/entities/types';
+import { createAIPromptTemplate } from '../../domain/entities/AIPromptTemplate';
+import { validatePhotoRestorationConfig, getQualityLevel } from '../../domain/entities/PhotoRestorationConfig';
+import { PromptGenerationService } from '../services/PromptGenerationService';
+
+const createPhotoRestorationBaseTemplate = (config?: {
+  targetQuality?: string;
+  preserveOriginal?: boolean;
+}): string => {
+  const {
+    targetQuality = 'high-quality',
+    preserveOriginal = true
+  } = config || {};
+
+  return `
+You are an expert AI photo restoration specialist.
+This is a PHOTO RESTORATION task, not image generation.
+
+RESTORATION OBJECTIVES:
+- Restore the original photo to ${targetQuality} condition
+- ${preserveOriginal ? 'Preserve the original content and composition' : 'Enhance with creative improvements'}
+- Remove imperfections while maintaining authenticity
+- Recover lost details and enhance overall quality
+
+RESTORATION TECHNIQUES:
+- Noise reduction and grain removal
+- Scratch and damage repair
+- Color correction and enhancement
+- Detail sharpening and clarity improvement
+- Exposure and contrast adjustment
+
+SAFETY CONSTRAINTS:
+- Do not add content that wasn't originally present
+- Maintain the original subject and composition
+- Avoid over-processing that creates unnatural results
+- Preserve important details and textures
+
+QUALITY STANDARDS:
+- Natural, authentic appearance
+- Balanced color reproduction
+- Appropriate level of detail enhancement
+- Clean, professional-grade result
+
+OUTPUT:
+A beautifully restored version of the original photo,
+maintaining its character while significantly improving quality.
+  `.trim();
+};
+
+export class PhotoRestorationService implements IPhotoRestorationService {
+  private promptService: PromptGenerationService;
+
+  constructor() {
+    this.promptService = new PromptGenerationService();
+  }
+
+  async generateTemplate(config: PhotoRestorationConfig): Promise<AIPromptResult<AIPromptTemplate>> {
+    try {
+      if (!this.validateConfig(config)) {
+        return {
+          success: false,
+          error: 'VALIDATION_ERROR',
+          message: 'Invalid photo restoration configuration'
+        };
+      }
+
+      const template = this.createPhotoRestorationTemplate(config);
+      return { success: true, data: template };
+    } catch (error) {
+      return {
+        success: false,
+        error: 'GENERATION_FAILED',
+        message: 'Failed to generate photo restoration template'
+      };
+    }
+  }
+
+  async generatePrompt(
+    template: AIPromptTemplate,
+    config: PhotoRestorationConfig
+  ): Promise<AIPromptResult<string>> {
+    const variables = {
+      severity: config.severity,
+      preserveOriginal: config.preserveOriginal,
+      enhanceColors: config.enhanceColors,
+      removeNoise: config.removeNoise,
+      fixBlur: config.fixBlur,
+      restoreDetails: config.restoreDetails,
+      qualityLevel: getQualityLevel(config.severity),
+    };
+
+    return this.promptService.generateFromTemplate(template, variables);
+  }
+
+  validateConfig(config: PhotoRestorationConfig): boolean {
+    return validatePhotoRestorationConfig(config);
+  }
+
+  estimateQuality(config: PhotoRestorationConfig): number {
+    let quality = 0.8;
+
+    if (config.restoreDetails) quality += 0.1;
+    if (config.enhanceColors) quality += 0.05;
+    if (config.removeNoise) quality += 0.05;
+
+    const severityMultiplier = getQualityLevel(config.severity);
+    return Math.min(quality * severityMultiplier, 1.0);
+  }
+
+  private createPhotoRestorationTemplate(config: PhotoRestorationConfig): AIPromptTemplate {
+    const templateId = `photo-restoration-${config.severity}`;
+    const qualityDesc = config.severity === 'minor' ? 'subtle restoration' :
+      config.severity === 'moderate' ? 'standard restoration' :
+        'deep restoration';
+
+    const baseTemplate = createPhotoRestorationBaseTemplate({
+      targetQuality: qualityDesc,
+      preserveOriginal: config.preserveOriginal,
+    });
+
+    return createAIPromptTemplate({
+      id: templateId,
+      name: `Photo Restoration: ${config.severity}`,
+      description: `Restore photos with ${qualityDesc}`,
+      category: 'photo-restoration',
+      template: `${baseTemplate}
+
+RESTORATION SEVERITY:
+${config.severity}
+
+SPECIFIC REQUIREMENTS:
+- ${config.removeNoise ? 'Remove noise and grain' : 'Maintain texture character'}
+- ${config.fixBlur ? 'Fix blur and sharpen details' : 'Preserve original sharpness'}
+- ${config.enhanceColors ? 'Enhance color vibrancy' : 'Maintain original colors'}
+- ${config.restoreDetails ? 'Recover lost details' : 'Preserve current detail level'}
+
+QUALITY TARGET:
+${getQualityLevel(config.severity) * 100}% quality improvement expected.
+
+OUTPUT:
+A professionally restored photo with ${qualityDesc},
+ready for display or further processing.
+      `.trim(),
+      variables: [],
+      safety: {
+        contentFilter: true,
+        adultContentFilter: true,
+        violenceFilter: true,
+        hateSpeechFilter: true,
+        copyrightFilter: true,
+      },
+      version: '1.0.0',
+    });
+  }
+}

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

@@ -0,0 +1,59 @@
+import type { IPromptGenerationService } from '../../domain/repositories/IAIPromptServices';
+import type { AIPromptTemplate } from '../../domain/entities/AIPromptTemplate';
+import type { AIPromptResult, AIPromptError } from '../../domain/entities/types';
+
+export class PromptGenerationService implements IPromptGenerationService {
+  generateFromTemplate(
+    template: AIPromptTemplate, 
+    variables: Record<string, unknown>
+  ): Promise<AIPromptResult<string>> {
+    return new Promise((resolve) => {
+      try {
+        const validation = this.validateVariables(template, variables);
+        if (!validation.success) {
+          resolve(validation as AIPromptResult<string>);
+          return;
+        }
+
+        const generatedText = this.replaceTemplateVariables(template.template, variables);
+        resolve({ success: true, data: generatedText });
+      } catch (error) {
+        resolve({ 
+          success: false, 
+          error: 'GENERATION_FAILED', 
+          message: 'Failed to generate prompt' 
+        });
+      }
+    });
+  }
+
+  validateVariables(
+    template: AIPromptTemplate, 
+    variables: Record<string, unknown>
+  ): AIPromptResult<void> {
+    for (const variable of template.variables) {
+      if (variable.required && !(variable.name in variables)) {
+        return { 
+          success: false, 
+          error: 'INVALID_VARIABLES', 
+          message: `Required variable ${variable.name} is missing` 
+        };
+      }
+    }
+    return { success: true, data: undefined };
+  }
+
+  replaceTemplateVariables(
+    template: string, 
+    variables: Record<string, unknown>
+  ): string {
+    let result = template;
+    
+    Object.entries(variables).forEach(([key, value]) => {
+      const regex = new RegExp(`\\$\\{${key}\\}`, 'g');
+      result = result.replace(regex, String(value || ''));
+    });
+
+    return result;
+  }
+}

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

@@ -0,0 +1,194 @@
+import type { IStyleTransferService } from '../../domain/repositories/IAIPromptServices';
+import type {
+  StyleTransferConfig,
+} from '../../domain/entities/StyleTransferConfig';
+import type { AIPromptTemplate } from '../../domain/entities/AIPromptTemplate';
+import type { AIPromptResult } from '../../domain/entities/types';
+import { createAIPromptTemplate } from '../../domain/entities/AIPromptTemplate';
+import {
+  validateStyleTransferConfig,
+  getStyleStrengthValue,
+  getArtisticModeDescription
+} from '../../domain/entities/StyleTransferConfig';
+import { PromptGenerationService } from '../services/PromptGenerationService';
+
+const createStyleTransferBaseTemplate = (config?: {
+  artisticMode?: string;
+  preserveContent?: boolean;
+}): string => {
+  const {
+    artisticMode = 'artistic',
+    preserveContent = true
+  } = config || {};
+
+  return `
+You are an expert AI style transfer specialist.
+This is a STYLE TRANSFER task, applying artistic styles while maintaining content.
+
+STYLE TRANSFER PRINCIPLES:
+- Apply target artistic style to the image
+- ${preserveContent ? 'Preserve original content and composition' : 'Allow creative reinterpretation'}
+- Maintain key features and subject recognition
+- Balance artistic expression with clarity
+
+ARTISTIC MODE: ${artisticMode}
+${getArtisticModeDescription(artisticMode as StyleTransferConfig['artisticMode'])}
+
+STYLE APPLICATION GUIDELINES:
+- Recognize and preserve important elements
+- Apply consistent style throughout the image
+- Maintain appropriate color relationships
+- Preserve facial features and expressions when present
+
+TECHNICAL REQUIREMENTS:
+- Smooth style transitions across the image
+- Appropriate detail preservation based on style
+- Consistent artistic treatment
+- Professional quality output
+
+CONTENT PRESERVATION:
+${preserveContent ?
+      '- Maintain key shapes and forms\n- Preserve facial features and expressions\n- Keep text readable if present\n- Maintain spatial relationships' :
+      '- Allow creative transformation\n- Artistic interpretation encouraged\n- Style over content fidelity'}
+
+SAFETY CONSTRAINTS:
+- Do not add inappropriate elements
+- Maintain appropriate content standards
+- Preserve important visual information
+- Avoid destructive transformations
+
+OUTPUT:
+A beautifully stylized image with the target artistic style,
+${preserveContent ? 'maintaining content integrity' : 'with artistic freedom'}.
+  `.trim();
+};
+
+export class StyleTransferService implements IStyleTransferService {
+  private promptService: PromptGenerationService;
+  private availableStyles: string[] = [];
+
+  constructor() {
+    this.promptService = new PromptGenerationService();
+    this.initializeDefaultStyles();
+  }
+
+  async generateTemplate(config: StyleTransferConfig): Promise<AIPromptResult<AIPromptTemplate>> {
+    try {
+      if (!this.validateConfig(config)) {
+        return {
+          success: false,
+          error: 'VALIDATION_ERROR',
+          message: 'Invalid style transfer configuration'
+        };
+      }
+
+      const template = this.createStyleTransferTemplate(config);
+      return { success: true, data: template };
+    } catch (error) {
+      return {
+        success: false,
+        error: 'GENERATION_FAILED',
+        message: 'Failed to generate style transfer template'
+      };
+    }
+  }
+
+  async generatePrompt(
+    template: AIPromptTemplate,
+    config: StyleTransferConfig
+  ): Promise<AIPromptResult<string>> {
+    const variables = {
+      targetStyle: config.targetStyle,
+      preserveContent: config.preserveContent,
+      styleStrength: config.styleStrength,
+      artisticMode: config.artisticMode,
+      maintainColors: config.maintainColors,
+      adaptToSubject: config.adaptToSubject,
+      strengthLevel: getStyleStrengthValue(config.styleStrength),
+    };
+
+    return this.promptService.generateFromTemplate(template, variables);
+  }
+
+  validateConfig(config: StyleTransferConfig): boolean {
+    return validateStyleTransferConfig(config);
+  }
+
+  async getAvailableStyles(): Promise<string[]> {
+    return Promise.resolve([...this.availableStyles]);
+  }
+
+  registerStyle(style: string): void {
+    if (!this.availableStyles.includes(style)) {
+      this.availableStyles.push(style);
+    }
+  }
+
+  registerStyles(styles: string[]): void {
+    styles.forEach(style => this.registerStyle(style));
+  }
+
+  private initializeDefaultStyles(): void {
+    this.availableStyles = [
+      'Impressionism',
+      'Cubism',
+      'Surrealism',
+      'Pop Art',
+      'Watercolor',
+      'Oil Painting',
+      'Pencil Sketch',
+      'Anime/Manga',
+      'Vintage Film',
+      'Cyberpunk',
+      'Steampunk',
+    ];
+  }
+
+  private createStyleTransferTemplate(config: StyleTransferConfig): AIPromptTemplate {
+    const templateId = `style-transfer-${config.targetStyle.toLowerCase().replace(/\s+/g, '-')}`;
+
+    const baseTemplate = createStyleTransferBaseTemplate({
+      artisticMode: config.artisticMode,
+      preserveContent: config.preserveContent,
+    });
+
+    return createAIPromptTemplate({
+      id: templateId,
+      name: `Style Transfer: ${config.targetStyle}`,
+      description: `Apply ${config.targetStyle} artistic style with ${config.artisticMode} mode`,
+      category: 'style-transfer',
+      template: `${baseTemplate}
+
+TARGET STYLE:
+${config.targetStyle}
+
+STYLE TRANSFER PARAMETERS:
+- Style Strength: ${getStyleStrengthValue(config.styleStrength)} (${Math.round(config.styleStrength * 100)}%)
+- Artistic Mode: ${config.artisticMode}
+- Preserve Content: ${config.preserveContent}
+- Maintain Colors: ${config.maintainColors}
+- Adapt to Subject: ${config.adaptToSubject}
+
+STYLE APPLICATION INSTRUCTIONS:
+Apply ${config.targetStyle} style with ${config.artisticMode} interpretation,
+using ${getStyleStrengthValue(config.styleStrength)} strength level.
+${config.preserveContent ? 'Focus on preserving content integrity while applying style.' : 'Allow artistic interpretation and transformation.'}
+${config.maintainColors ? 'Maintain original color palette where appropriate.' : 'Allow color changes to enhance style.'}
+
+EXPECTED RESULT:
+A beautifully stylized image in ${config.targetStyle} style,
+with ${config.artisticMode} artistic interpretation,
+using ${getStyleStrengthValue(config.styleStrength)} strength application.
+      `.trim(),
+      variables: [],
+      safety: {
+        contentFilter: true,
+        adultContentFilter: true,
+        violenceFilter: true,
+        hateSpeechFilter: true,
+        copyrightFilter: true,
+      },
+      version: '1.0.0',
+    });
+  }
+}