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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-generation-content",
-  "version": "1.17.170",
+  "version": "1.17.171",
   "description": "Provider-agnostic AI generation orchestration for React Native",
   "main": "src/index.ts",
   "types": "src/index.ts",

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

@@ -1,114 +1,49 @@
+/**
+ * Background Removal Service
+ * AI prompt generation for background removal tasks
+ */
+
 import type { IBackgroundRemovalService } from '../../domain/repositories/IAIPromptServices';
-import type {
-  BackgroundRemovalConfig,
-} from '../../domain/entities/BackgroundRemovalConfig';
+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 || {};
+import { validateBackgroundRemovalConfig, getProcessingTime, getQualityScore } from '../../domain/entities/BackgroundRemovalConfig';
+import { BasePromptService } from './base';
 
-  return `
+const BASE_TEMPLATE = `
 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();
+`.trim();
+
+export class BackgroundRemovalService
+  extends BasePromptService<BackgroundRemovalConfig>
+  implements IBackgroundRemovalService
+{
+  protected getServiceName(): string {
+    return 'background removal';
   }
 
-  generateTemplate(config: BackgroundRemovalConfig): Promise<AIPromptResult<AIPromptTemplate>> {
-    try {
-      if (!this.validateConfig(config)) {
-        return Promise.resolve({
-          success: false,
-          error: 'VALIDATION_ERROR',
-          message: 'Invalid background removal configuration'
-        });
-      }
+  validateConfig(config: BackgroundRemovalConfig): boolean {
+    return validateBackgroundRemovalConfig(config);
+  }
 
-      const template = this.createBackgroundRemovalTemplate(config);
-      return Promise.resolve({ success: true, data: template });
-    } catch {
-      return Promise.resolve({
-        success: false,
-        error: 'GENERATION_FAILED',
-        message: 'Failed to generate background removal template'
-      });
-    }
+  estimateProcessingTime(config: BackgroundRemovalConfig): number {
+    return getProcessingTime(config.precision);
   }
 
-  async generatePrompt(
-    template: AIPromptTemplate,
-    config: BackgroundRemovalConfig
-  ): Promise<AIPromptResult<string>> {
-    const variables = {
+  protected buildVariables(config: BackgroundRemovalConfig): Record<string, unknown> {
+    return {
       precision: config.precision,
       edgeRefinement: config.edgeRefinement,
       preserveHair: config.preserveHair,
@@ -117,93 +52,24 @@ export class BackgroundRemovalService implements IBackgroundRemovalService {
       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,
+  protected createTemplate(config: BackgroundRemovalConfig): AIPromptTemplate {
+    return this.createTemplateWithDefaults({
+      id: `background-removal-${config.precision}`,
       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}` : ''}
+      template: `${BASE_TEMPLATE}
 
-SPECIFIC REQUIREMENTS:
-${this.getSpecificRequirements(config)}
+PRECISION: ${config.precision}
+EDGE REFINEMENT: ${config.edgeRefinement}
+PRESERVE HAIR: ${config.preserveHair}
+OUTPUT: ${config.outputFormat}
+${config.addNewBackground ? `NEW BACKGROUND: ${config.addNewBackground}` : ''}
 
-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',
+QUALITY: ${Math.round(getQualityScore(config) * 100)}%
+EST. TIME: ${getProcessingTime(config.precision)}s`,
     });
   }
-
-  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

@@ -1,118 +1,61 @@
+/**
+ * Colorization Service
+ * AI prompt generation for photo colorization
+ */
+
 import type { IColorizationService } from '../../domain/repositories/IAIPromptServices';
-import type {
-  ColorizationConfig,
-} from '../../domain/entities/ColorizationConfig';
+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
+  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 || {};
+import { BasePromptService } from './base';
 
-  return `
+const BASE_TEMPLATE = `
 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`}
+- Ensure color harmony and balance
 
-TECHNICAL REQUIREMENTS:
+TECHNICAL:
 - Preserve edges and details during color application
 - Apply colors smoothly and naturally
 - Consider lighting and shadow relationships
-- Maintain image quality and resolution
 
-SAFETY CONSTRAINTS:
+SAFETY:
 - 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;
+`.trim();
+
+export class ColorizationService
+  extends BasePromptService<ColorizationConfig>
+  implements IColorizationService
+{
+  protected getServiceName(): string {
+    return 'colorization';
+  }
 
-  constructor() {
-    this.promptService = new PromptGenerationService();
+  validateConfig(config: ColorizationConfig): boolean {
+    return validateColorizationConfig(config);
   }
 
-  generateTemplate(config: ColorizationConfig): Promise<AIPromptResult<AIPromptTemplate>> {
-    try {
-      if (!this.validateConfig(config)) {
-        return Promise.resolve({
-          success: false,
-          error: 'VALIDATION_ERROR',
-          message: 'Invalid colorization configuration'
-        });
-      }
+  getColorPalette(config: ColorizationConfig): string[] {
+    return getSuggestedColorPalette(config.targetType, config.colorMode);
+  }
 
-      const template = this.createColorizationTemplate(config);
-      return Promise.resolve({ success: true, data: template });
-    } catch {
-      return Promise.resolve({
-        success: false,
-        error: 'GENERATION_FAILED',
-        message: 'Failed to generate colorization template'
-      });
-    }
+  getQualityScore(config: ColorizationConfig): number {
+    return getColorizationQuality(config);
   }
 
-  async generatePrompt(
-    template: AIPromptTemplate,
-    config: ColorizationConfig
-  ): Promise<AIPromptResult<string>> {
-    const variables = {
+  protected buildVariables(config: ColorizationConfig): Record<string, unknown> {
+    return {
       targetType: config.targetType,
       colorMode: config.colorMode,
       preserveOriginal: config.preserveOriginal,
@@ -122,111 +65,26 @@ export class ColorizationService implements IColorizationService {
       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);
-  }
+  protected createTemplate(config: ColorizationConfig): AIPromptTemplate {
+    const quality = Math.round(getColorizationQuality(config) * 100);
 
-  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,
+    return this.createTemplateWithDefaults({
+      id: `colorization-${config.targetType}-${config.colorMode}`,
       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)}
+      template: `${BASE_TEMPLATE}
 
-${config.era ? `ERA-SPECIFIC GUIDELINES:
-${getEraDescription(config.era)}
+TARGET: ${config.targetType}
+MODE: ${config.colorMode}
+PRESERVE ORIGINAL: ${config.preserveOriginal}
+ADJUST LIGHTING: ${config.adjustLighting}
+SKIN TONE PRESERVATION: ${config.skinTonePreservation}
+${config.era ? `ERA: ${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',
+QUALITY: ${quality}%`,
     });
   }
-
-  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';
-  }
-}
+}