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

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

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

@@ -0,0 +1,241 @@
+import type { ITextGenerationService } from '../../domain/repositories/IAIPromptServices';
+import type {
+  TextGenerationConfig,
+} from '../../domain/entities/TextGenerationConfig';
+import type { AIPromptTemplate } from '../../domain/entities/AIPromptTemplate';
+import type { AIPromptResult } from '../../domain/entities/types';
+import { createAIPromptTemplate } from '../../domain/entities/AIPromptTemplate';
+import {
+  validateTextGenerationConfig,
+  getTokenCount,
+  getTemperature,
+  getTopP
+} from '../../domain/entities/TextGenerationConfig';
+import { PromptGenerationService } from '../services/PromptGenerationService';
+
+const createTextGenerationBaseTemplate = (config?: {
+  promptType?: string;
+  tone?: string;
+  language?: string;
+}): string => {
+  const {
+    promptType = 'general',
+    tone = 'professional',
+    language = 'English'
+  } = config || {};
+
+  return `
+You are an expert text generation specialist.
+This is a TEXT GENERATION task with specific requirements.
+
+GENERATION OBJECTIVES:
+- Generate ${promptType} content with ${tone} tone
+- Write in ${language} language
+- Follow provided context and constraints
+- Deliver high-quality, appropriate content
+
+CONTENT STANDARDS:
+- Clear, coherent, and well-structured text
+- Appropriate for the specified tone and purpose
+- Natural language flow and readability
+- Relevant and informative content
+
+STYLE REQUIREMENTS:
+- Maintain ${tone} tone throughout
+- Use appropriate vocabulary and expressions
+- Follow conventions for ${promptType} content
+- Adapt complexity to intended audience
+
+LANGUAGE REQUIREMENTS:
+- Write fluently in ${language}
+- Use proper grammar and syntax
+- Consider cultural and regional variations
+- Maintain consistency in language usage
+
+SAFETY AND QUALITY:
+- Generate appropriate, non-offensive content
+- Avoid harmful or misleading information
+- Ensure factual accuracy when applicable
+- Respect copyright and intellectual property
+
+OUTPUT:
+Professional ${promptType} content in ${language},
+written with ${tone} tone,
+meeting all specified requirements.
+  `.trim();
+};
+
+export class TextGenerationService implements ITextGenerationService {
+  private promptService: PromptGenerationService;
+
+  constructor() {
+    this.promptService = new PromptGenerationService();
+  }
+
+  async generateTemplate(config: TextGenerationConfig): Promise<AIPromptResult<AIPromptTemplate>> {
+    try {
+      if (!this.validateConfig(config)) {
+        return {
+          success: false,
+          error: 'VALIDATION_ERROR',
+          message: 'Invalid text generation configuration'
+        };
+      }
+
+      const template = this.createTextGenerationTemplate(config);
+      return { success: true, data: template };
+    } catch (error) {
+      return {
+        success: false,
+        error: 'GENERATION_FAILED',
+        message: 'Failed to generate text template'
+      };
+    }
+  }
+
+  async generatePrompt(
+    template: AIPromptTemplate,
+    config: TextGenerationConfig
+  ): Promise<AIPromptResult<string>> {
+    const parameters = this.getGenerationParameters(config);
+    const variables = {
+      promptType: config.promptType,
+      tone: config.tone,
+      length: config.length,
+      language: config.language,
+      context: config.context || '',
+      keywords: config.keywords?.join(', ') || '',
+      ...parameters,
+    };
+
+    return this.promptService.generateFromTemplate(template, variables);
+  }
+
+  validateConfig(config: TextGenerationConfig): boolean {
+    return validateTextGenerationConfig(config);
+  }
+
+  estimateTokens(config: TextGenerationConfig): number {
+    return getTokenCount(config.length);
+  }
+
+  getGenerationParameters(config: TextGenerationConfig): Record<string, number> {
+    return {
+      temperature: getTemperature(config.promptType, config.tone),
+      maxTokens: this.estimateTokens(config),
+      topP: getTopP(config.promptType),
+      frequencyPenalty: config.tone === 'formal' ? 0.3 : 0.1,
+      presencePenalty: config.promptType === 'creative' ? 0.2 : 0.1,
+    };
+  }
+
+  private createTextGenerationTemplate(config: TextGenerationConfig): AIPromptTemplate {
+    const templateId = `text-generation-${config.promptType}`;
+
+    const baseTemplate = createTextGenerationBaseTemplate({
+      promptType: config.promptType,
+      tone: config.tone,
+      language: config.language,
+    });
+
+    return createAIPromptTemplate({
+      id: templateId,
+      name: `Text Generation: ${config.promptType}`,
+      description: `Generate ${config.promptType} content in ${config.language}`,
+      category: 'text-generation',
+      template: `${baseTemplate}
+
+GENERATION PARAMETERS:
+- Prompt Type: ${config.promptType}
+- Tone: ${config.tone}
+- Length: ${config.length}
+- Language: ${config.language}
+- Estimated Tokens: ${this.estimateTokens(config)}
+
+${config.context ? `CONTEXT:
+${config.context}
+
+` : ''}${config.keywords && config.keywords.length > 0 ? `KEYWORDS:
+${config.keywords.join(', ')}
+
+` : ''}CONTENT REQUIREMENTS:
+- Generate ${config.length} content appropriate for ${config.promptType}
+- Use ${config.tone} tone throughout the text
+- Follow conventions for ${config.promptType} writing
+- Write fluently in ${config.language}
+
+STYLE GUIDELINES:
+${this.getStyleGuidelines(config)}
+
+GENERATION PARAMETERS:
+- Temperature: ${getTemperature(config.promptType, config.tone)} (creativity level)
+- Max Tokens: ${this.estimateTokens(config)} (content length)
+- Top-P: ${getTopP(config.promptType)} (nucleus sampling)
+- Frequency Penalty: ${config.tone === 'formal' ? 0.3 : 0.1} (repetition reduction)
+- Presence Penalty: ${config.promptType === 'creative' ? 0.2 : 0.1} (new topic encouragement)
+
+EXPECTED OUTPUT:
+Professional ${config.promptType} content in ${config.language},
+approximately ${this.estimateTokens(config)} tokens long,
+with ${config.tone} tone and appropriate style.
+      `.trim(),
+      variables: [],
+      safety: {
+        contentFilter: true,
+        adultContentFilter: true,
+        violenceFilter: true,
+        hateSpeechFilter: true,
+        copyrightFilter: true,
+      },
+      version: '1.0.0',
+    });
+  }
+
+  private getStyleGuidelines(config: TextGenerationConfig): string {
+    const guidelines: string[] = [];
+
+    switch (config.promptType) {
+      case 'creative':
+        guidelines.push('- Use imaginative and engaging language');
+        guidelines.push('- Incorporate vivid descriptions and storytelling');
+        break;
+      case 'technical':
+        guidelines.push('- Use precise terminology and clear explanations');
+        guidelines.push('- Maintain logical structure and accuracy');
+        break;
+      case 'marketing':
+        guidelines.push('- Use persuasive and compelling language');
+        guidelines.push('- Include clear calls to action');
+        break;
+      case 'educational':
+        guidelines.push('- Present information clearly and progressively');
+        guidelines.push('- Include examples and explanations');
+        break;
+      case 'conversational':
+        guidelines.push('- Use natural, approachable language');
+        guidelines.push('- Include questions and engagement elements');
+        break;
+    }
+
+    switch (config.tone) {
+      case 'formal':
+        guidelines.push('- Maintain professional and respectful language');
+        guidelines.push('- Use proper grammar and complete sentences');
+        break;
+      case 'casual':
+        guidelines.push('- Use relaxed, natural language');
+        guidelines.push('- Include some conversational elements');
+        break;
+      case 'friendly':
+        guidelines.push('- Use warm and approachable tone');
+        guidelines.push('- Include encouraging and positive elements');
+        break;
+      case 'humorous':
+        guidelines.push('- Incorporate appropriate humor and wit');
+        guidelines.push('- Maintain lighthearted and engaging style');
+        break;
+    }
+
+    return guidelines.join('\n') || '- Follow standard writing conventions';
+  }
+}