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

package/src/domains/prompts/infrastructure/repositories/TemplateRepository.ts

@@ -0,0 +1,77 @@
+import type { ITemplateRepository } from '../../domain/repositories/ITemplateRepository';
+import type { AIPromptTemplate } from '../../domain/entities/AIPromptTemplate';
+import type { AIPromptCategory, AIPromptResult } from '../../domain/entities/types';
+
+export class TemplateRepository implements ITemplateRepository {
+  private storage = new Map<string, AIPromptTemplate>();
+
+  async findById(id: string): Promise<AIPromptResult<AIPromptTemplate | null>> {
+    try {
+      const template = this.storage.get(id) || null;
+      return { success: true, data: template };
+    } catch (error) {
+      return { 
+        success: false, 
+        error: 'STORAGE_ERROR', 
+        message: 'Failed to retrieve template' 
+      };
+    }
+  }
+
+  async findByCategory(category: AIPromptCategory): Promise<AIPromptResult<AIPromptTemplate[]>> {
+    try {
+      const templates = Array.from(this.storage.values())
+        .filter(template => template.category === category);
+      return { success: true, data: templates };
+    } catch (error) {
+      return { 
+        success: false, 
+        error: 'STORAGE_ERROR', 
+        message: 'Failed to retrieve templates by category' 
+      };
+    }
+  }
+
+  async findAll(): Promise<AIPromptResult<AIPromptTemplate[]>> {
+    try {
+      const templates = Array.from(this.storage.values());
+      return { success: true, data: templates };
+    } catch (error) {
+      return { 
+        success: false, 
+        error: 'STORAGE_ERROR', 
+        message: 'Failed to retrieve all templates' 
+      };
+    }
+  }
+
+  async save(template: AIPromptTemplate): Promise<AIPromptResult<void>> {
+    try {
+      this.storage.set(template.id, template);
+      return { success: true, data: undefined };
+    } catch (error) {
+      return { 
+        success: false, 
+        error: 'STORAGE_ERROR', 
+        message: 'Failed to save template' 
+      };
+    }
+  }
+
+  async delete(id: string): Promise<AIPromptResult<void>> {
+    try {
+      this.storage.delete(id);
+      return { success: true, data: undefined };
+    } catch (error) {
+      return { 
+        success: false, 
+        error: 'STORAGE_ERROR', 
+        message: 'Failed to delete template' 
+      };
+    }
+  }
+
+  async exists(id: string): Promise<boolean> {
+    return this.storage.has(id);
+  }
+}

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

@@ -0,0 +1,209 @@
+import type { IBackgroundRemovalService } from '../../domain/repositories/IAIPromptServices';
+import type {
+  BackgroundRemovalConfig,
+} from '../../domain/entities/BackgroundRemovalConfig';
+import type { AIPromptTemplate } from '../../domain/entities/AIPromptTemplate';
+import type { AIPromptResult } from '../../domain/entities/types';
+import { createAIPromptTemplate } from '../../domain/entities/AIPromptTemplate';
+import {
+  validateBackgroundRemovalConfig,
+  getProcessingTime,
+  getQualityScore
+} from '../../domain/entities/BackgroundRemovalConfig';
+import { PromptGenerationService } from '../services/PromptGenerationService';
+
+const createBackgroundRemovalBaseTemplate = (config?: {
+  precision?: string;
+  edgeRefinement?: boolean;
+}): string => {
+  const {
+    precision = 'accurate',
+    edgeRefinement = true
+  } = config || {};
+
+  return `
+You are an expert AI background removal specialist.
+This is a BACKGROUND REMOVAL task, not image generation.
+
+BACKGROUND REMOVAL OBJECTIVES:
+- Remove background with ${precision} precision
+- ${edgeRefinement ? 'Refine edges for clean cutout' : 'Focus on speed over precision'}
+- Preserve subject integrity and details
+- Create professional-quality transparency
+
+DETECTION PRINCIPLES:
+- Accurately identify foreground subject
+- Distinguish between subject and background
+- Handle complex edges (hair, fur, transparent objects)
+- Preserve fine details and textures
+
+TECHNICAL REQUIREMENTS:
+${precision === 'ultra-accurate' ?
+      `- Maximum precision processing
+- Advanced edge detection algorithms
+- Multiple refinement passes
+- Subpixel accuracy for edges` :
+      precision === 'accurate' ?
+        `- Standard precision processing
+- Reliable edge detection
+- Single refinement pass
+- Good balance of speed/quality` :
+        `- Fast processing optimization
+- Basic edge detection
+- Quick subject isolation
+- Suitable for simple backgrounds`}
+
+EDGE HANDLING:
+${edgeRefinement ?
+      `- Feather edges naturally
+- Preserve hair and fine details
+- Remove halos and artifacts
+- Smooth transitions` :
+      `- Focus on speed
+- Basic edge processing
+- Minimal refinement
+- Quick turnaround time`}
+
+SAFETY CONSTRAINTS:
+- Preserve subject completely
+- Do not alter foreground content
+- Maintain important details
+- Avoid over-removal of subject elements
+
+OUTPUT:
+Subject with transparent background,
+ready for compositing or new background application.
+  `.trim();
+};
+
+export class BackgroundRemovalService implements IBackgroundRemovalService {
+  private promptService: PromptGenerationService;
+
+  constructor() {
+    this.promptService = new PromptGenerationService();
+  }
+
+  async generateTemplate(config: BackgroundRemovalConfig): Promise<AIPromptResult<AIPromptTemplate>> {
+    try {
+      if (!this.validateConfig(config)) {
+        return {
+          success: false,
+          error: 'VALIDATION_ERROR',
+          message: 'Invalid background removal configuration'
+        };
+      }
+
+      const template = this.createBackgroundRemovalTemplate(config);
+      return { success: true, data: template };
+    } catch (error) {
+      return {
+        success: false,
+        error: 'GENERATION_FAILED',
+        message: 'Failed to generate background removal template'
+      };
+    }
+  }
+
+  async generatePrompt(
+    template: AIPromptTemplate,
+    config: BackgroundRemovalConfig
+  ): Promise<AIPromptResult<string>> {
+    const variables = {
+      precision: config.precision,
+      edgeRefinement: config.edgeRefinement,
+      preserveHair: config.preserveHair,
+      outputFormat: config.outputFormat,
+      addNewBackground: config.addNewBackground,
+      processingTime: getProcessingTime(config.precision),
+      qualityScore: getQualityScore(config),
+    };
+
+    return this.promptService.generateFromTemplate(template, variables);
+  }
+
+  validateConfig(config: BackgroundRemovalConfig): boolean {
+    return validateBackgroundRemovalConfig(config);
+  }
+
+  estimateProcessingTime(config: BackgroundRemovalConfig): number {
+    return getProcessingTime(config.precision);
+  }
+
+  private createBackgroundRemovalTemplate(config: BackgroundRemovalConfig): AIPromptTemplate {
+    const templateId = `background-removal-${config.precision}`;
+
+    const baseTemplate = createBackgroundRemovalBaseTemplate({
+      precision: config.precision,
+      edgeRefinement: config.edgeRefinement,
+    });
+
+    return createAIPromptTemplate({
+      id: templateId,
+      name: `Background Removal: ${config.precision}`,
+      description: `Remove background with ${config.precision} precision`,
+      category: 'background-removal',
+      template: `${baseTemplate}
+
+REMOVAL CONFIGURATION:
+- Precision Level: ${config.precision}
+- Edge Refinement: ${config.edgeRefinement}
+- Preserve Hair: ${config.preserveHair}
+- Output Format: ${config.outputFormat}
+${config.addNewBackground ? `- New Background: ${config.addNewBackground}` : ''}
+
+SPECIFIC REQUIREMENTS:
+${this.getSpecificRequirements(config)}
+
+PROCESSING EXPECTATIONS:
+- Estimated Time: ${getProcessingTime(config.precision)} seconds
+- Quality Score: ${Math.round(getQualityScore(config) * 100)}%
+- Edge Detail: ${config.edgeRefinement ? 'High precision' : 'Standard precision'}
+- Hair Handling: ${config.preserveHair ? 'Preserved with detail' : 'Standard processing'}
+
+OUTPUT FORMAT:
+${config.outputFormat === 'transparent' ? 'Transparent PNG with alpha channel' :
+          config.outputFormat === 'png' ? 'PNG format with transparency' :
+            'WebP format with transparency support'}
+
+${config.addNewBackground ? `NEW BACKGROUND:
+Replace removed background with: ${config.addNewBackground}
+Ensure proper blending and integration with subject.` : ''}
+
+EXPECTED RESULT:
+Clean subject with background removed,
+${config.edgeRefinement ? 'with refined edges and preserved details' : 'with standard edge quality'},
+ready for ${config.outputFormat} output.
+      `.trim(),
+      variables: [],
+      safety: {
+        contentFilter: true,
+        adultContentFilter: true,
+        violenceFilter: true,
+        hateSpeechFilter: true,
+        copyrightFilter: true,
+      },
+      version: '1.0.0',
+    });
+  }
+
+  private getSpecificRequirements(config: BackgroundRemovalConfig): string {
+    const requirements: string[] = [];
+
+    if (config.preserveHair) {
+      requirements.push('- Advanced hair detection and preservation');
+      requirements.push('- Fine strand handling and transparency');
+    }
+
+    if (config.edgeRefinement) {
+      requirements.push('- Subpixel edge accuracy');
+      requirements.push('- Natural feathering and anti-aliasing');
+    }
+
+    if (config.precision === 'ultra-accurate') {
+      requirements.push('- Multi-pass refinement processing');
+      requirements.push('- Advanced artifact removal');
+    }
+
+    return requirements.join('\n') || '- Standard background removal processing';
+  }
+}

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