@umituz/react-native-ai-generation-content 1.17.169 → 1.17.171

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

@@ -1,108 +1,41 @@
+/**
+ * Image Enhancement Service
+ * AI prompt generation for image enhancement tasks
+ */
+
 import type { IImageEnhancementService } from '../../domain/repositories/IAIPromptServices';
-import type {
-  ImageEnhancementConfig,
-  EnhancementAdjustments,
-} from '../../domain/entities/ImageEnhancementConfig';
+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 || {};
+import { validateImageEnhancementConfig, calculateAdjustments } from '../../domain/entities/ImageEnhancementConfig';
+import { BasePromptService } from './base';
 
-  return `
+const BASE_TEMPLATE = `
 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();
-  }
-
-  generateTemplate(config: ImageEnhancementConfig): Promise<AIPromptResult<AIPromptTemplate>> {
-    try {
-      if (!this.validateConfig(config)) {
-        return Promise.resolve({
-          success: false,
-          error: 'VALIDATION_ERROR',
-          message: 'Invalid image enhancement configuration'
-        });
-      }
-
-      const template = this.createImageEnhancementTemplate(config);
-      return Promise.resolve({ success: true, data: template });
-    } catch {
-      return Promise.resolve({
-        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);
+`.trim();
+
+export class ImageEnhancementService
+  extends BasePromptService<ImageEnhancementConfig>
+  implements IImageEnhancementService
+{
+  protected getServiceName(): string {
+    return 'image enhancement';
   }
 
   validateConfig(config: ImageEnhancementConfig): boolean {
@@ -113,69 +46,30 @@ export class ImageEnhancementService implements IImageEnhancementService {
     return calculateAdjustments(config);
   }
 
-  private createImageEnhancementTemplate(config: ImageEnhancementConfig): AIPromptTemplate {
-    const templateId = `image-enhancement-${config.enhancementType}`;
-
-    const baseTemplate = createImageEnhancementBaseTemplate({
+  protected buildVariables(config: ImageEnhancementConfig): Record<string, unknown> {
+    return {
       enhancementType: config.enhancementType,
+      intensity: config.intensity,
+      preserveNatural: config.preserveNatural,
+      autoAdjust: config.autoAdjust,
       targetStyle: config.targetStyle,
-    });
+      adjustments: this.calculateAdjustments(config),
+    };
+  }
 
-    return createAIPromptTemplate({
-      id: templateId,
+  protected createTemplate(config: ImageEnhancementConfig): AIPromptTemplate {
+    return this.createTemplateWithDefaults({
+      id: `image-enhancement-${config.enhancementType}`,
       name: `Image Enhancement: ${config.enhancementType}`,
       description: `Enhance images with ${config.enhancementType} improvements`,
       category: 'image-enhancement',
-      template: `${baseTemplate}
+      template: `${BASE_TEMPLATE}
 
-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',
+TYPE: ${config.enhancementType}
+STYLE: ${config.targetStyle}
+INTENSITY: ${Math.round(config.intensity * 100)}%
+PRESERVE NATURAL: ${config.preserveNatural}
+AUTO ADJUST: ${config.autoAdjust}`,
     });
   }
-
-  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/ImagePromptBuilder.ts

@@ -1,23 +1,15 @@
 /**
- * ImagePromptBuilder
- * Fluent builder for composing AI image generation prompts
- *
- * @example
- * const { prompt, negativePrompt } = ImagePromptBuilder.create()
- *   .withIdentityPreservation()
- *   .withAnimeStyle()
- *   .withQuality()
- *   .build();
+ * ImagePromptBuilder - Fluent builder for composing AI image generation prompts
  */
 
 import {
+  IDENTITY_SEGMENTS,
   IDENTITY_NEGATIVE_SEGMENTS,
   ANIME_STYLE_SEGMENTS,
   QUALITY_SEGMENTS,
   QUALITY_NEGATIVE_SEGMENTS,
   ANTI_REALISM_SEGMENTS,
   ANATOMY_NEGATIVE_SEGMENTS,
-  PRESET_COLLECTIONS,
 } from "../../domain/entities/image-prompt-segments";
 
 export interface ImagePromptResult {
@@ -25,6 +17,12 @@ export interface ImagePromptResult {
   negativePrompt: string;
 }
 
+export interface AnimeSelfiePromptResult extends ImagePromptResult {
+  strength: number;
+  guidance_scale: number;
+  num_inference_steps: number;
+}
+
 export interface ImagePromptBuilderOptions {
   separator?: string;
 }
@@ -46,15 +44,10 @@ export class ImagePromptBuilder {
   }
 
   /**
-   * Add identity preservation prompts
-   * Ensures the AI preserves the original person's features
+   * Add identity preservation prompts - ensures AI preserves original person's features
    */
-  withIdentityPreservation(full = true): this {
-    const segments = full
-      ? PRESET_COLLECTIONS.fullIdentityPreservation
-      : PRESET_COLLECTIONS.basicIdentityPreservation;
-
-    this.positiveSegments.push(...segments);
+  withIdentityPreservation(): this {
+    this.positiveSegments.push(...Object.values(IDENTITY_SEGMENTS));
     this.negativeSegments.push(...Object.values(IDENTITY_NEGATIVE_SEGMENTS));
     return this;
   }
@@ -172,28 +165,38 @@ export class ImagePromptBuilder {
   }
 }
 
-// =============================================================================
-// PRESET BUILDERS
-// =============================================================================
-
 /**
- * Create an anime selfie prompt builder with identity preservation
+ * Create anime selfie prompt with recommended parameters
+ * IMPORTANT: Anime style FIRST (highest priority), identity preservation secondary
  */
-export function createAnimeSelfiePrompt(): ImagePromptResult {
-  return ImagePromptBuilder.create()
-    .withIdentityPreservation()
-    .withAnimeStyle()
-    .withAnatomySafety()
-    .build();
+export function createAnimeSelfiePrompt(customStyle?: string): AnimeSelfiePromptResult {
+  const builder = ImagePromptBuilder.create()
+    .withAnimeStyle()        // Anime style FIRST - highest priority
+    .withIdentityPreservation()  // Identity preservation secondary
+    .withAnatomySafety();
+
+  if (customStyle) {
+    builder.prependSegments([`${customStyle} style`]);
+  }
+
+  const { prompt, negativePrompt } = builder.build();
+
+  return {
+    prompt,
+    negativePrompt,
+    strength: 0.92,           // High strength for style transformation
+    guidance_scale: 8.5,      // Strong guidance for anime style
+    num_inference_steps: 50,  // More steps for quality
+  };
 }
 
 /**
- * Create a style transfer prompt builder with identity preservation
+ * Create a style transfer prompt with identity preservation
  */
 export function createStyleTransferPrompt(style: string): ImagePromptResult {
   return ImagePromptBuilder.create()
+    .withSegment(`${style} style`)  // Style first
     .withIdentityPreservation()
-    .withSegment(`${style} style`)
     .withQuality()
     .withAnatomySafety()
     .build();

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

@@ -1,90 +1,52 @@
+/**
+ * Photo Restoration Service
+ * AI prompt generation for photo restoration tasks
+ */
+
 import type { IPhotoRestorationService } from '../../domain/repositories/IAIPromptServices';
-import type {
-  PhotoRestorationConfig,
-} from '../../domain/entities/PhotoRestorationConfig';
+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 || {};
+import { BasePromptService } from './base';
 
-  return `
+const BASE_TEMPLATE = `
 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();
+`.trim();
+
+export class PhotoRestorationService
+  extends BasePromptService<PhotoRestorationConfig>
+  implements IPhotoRestorationService
+{
+  protected getServiceName(): string {
+    return 'photo restoration';
   }
 
-  generateTemplate(config: PhotoRestorationConfig): Promise<AIPromptResult<AIPromptTemplate>> {
-    try {
-      if (!this.validateConfig(config)) {
-        return Promise.resolve({
-          success: false,
-          error: 'VALIDATION_ERROR',
-          message: 'Invalid photo restoration configuration'
-        });
-      }
+  validateConfig(config: PhotoRestorationConfig): boolean {
+    return validatePhotoRestorationConfig(config);
+  }
 
-      const template = this.createPhotoRestorationTemplate(config);
-      return Promise.resolve({ success: true, data: template });
-    } catch {
-      return Promise.resolve({
-        success: false,
-        error: 'GENERATION_FAILED',
-        message: 'Failed to generate photo restoration template'
-      });
-    }
+  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;
+    return Math.min(quality * getQualityLevel(config.severity), 1.0);
   }
 
-  async generatePrompt(
-    template: AIPromptTemplate,
-    config: PhotoRestorationConfig
-  ): Promise<AIPromptResult<string>> {
-    const variables = {
+  protected buildVariables(config: PhotoRestorationConfig): Record<string, unknown> {
+    return {
       severity: config.severity,
       preserveOriginal: config.preserveOriginal,
       enhanceColors: config.enhanceColors,
@@ -93,68 +55,28 @@ export class PhotoRestorationService implements IPhotoRestorationService {
       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;
+  protected createTemplate(config: PhotoRestorationConfig): AIPromptTemplate {
+    const qualityDesc =
+      config.severity === 'minor' ? 'subtle' :
+      config.severity === 'moderate' ? 'standard' : 'deep';
 
-    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,
+    return this.createTemplateWithDefaults({
+      id: `photo-restoration-${config.severity}`,
       name: `Photo Restoration: ${config.severity}`,
-      description: `Restore photos with ${qualityDesc}`,
+      description: `Restore photos with ${qualityDesc} restoration`,
       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'}
+      template: `${BASE_TEMPLATE}
 
-QUALITY TARGET:
-${getQualityLevel(config.severity) * 100}% quality improvement expected.
+SEVERITY: ${config.severity}
+REQUIREMENTS:
+- ${config.removeNoise ? 'Remove noise' : 'Maintain texture'}
+- ${config.fixBlur ? 'Fix blur' : 'Preserve sharpness'}
+- ${config.enhanceColors ? 'Enhance colors' : 'Maintain colors'}
+- ${config.restoreDetails ? 'Recover details' : 'Preserve detail level'}
 
-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',
+QUALITY TARGET: ${Math.round(getQualityLevel(config.severity) * 100)}%`,
     });
   }
-}
+}