@umituz/react-native-ai-generation-content 1.46.1 → 1.47.0

package/src/domains/prompts/domain/entities/ImageEnhancementConfig.ts

@@ -1,93 +0,0 @@
-import type { AIPromptTemplate } from './AIPromptTemplate';
-
-export interface ImageEnhancementConfig {
-  enhancementType: 'brightness' | 'contrast' | 'saturation' | 'sharpness' | 'all';
-  intensity: number;
-  preserveNatural: boolean;
-  autoAdjust: boolean;
-  targetStyle: 'natural' | 'vivid' | 'dramatic' | 'professional';
-}
-
-export interface ImageEnhancementTemplate {
-  readonly id: string;
-  readonly name: string;
-  readonly description: string;
-  readonly basePrompt: string;
-  readonly variables: ImageEnhancementVariable[];
-  readonly enhancement: EnhancementSettings;
-}
-
-export interface ImageEnhancementVariable {
-  name: string;
-  description: string;
-  required: boolean;
-  type: 'number' | 'select';
-  min?: number;
-  max?: number;
-  options?: string[];
-}
-
-export interface EnhancementSettings {
-  brightnessRange: [number, number];
-  contrastRange: [number, number];
-  saturationRange: [number, number];
-  sharpnessRange: [number, number];
-}
-
-export interface ImageEnhancementResult {
-  template: AIPromptTemplate;
-  config: ImageEnhancementConfig;
-  adjustments: EnhancementAdjustments;
-}
-
-export interface EnhancementAdjustments {
-  brightness: number;
-  contrast: number;
-  saturation: number;
-  sharpness: number;
-  overall: number;
-}
-
-export const validateImageEnhancementConfig = (config: ImageEnhancementConfig): boolean => {
-  return !!(
-    config.enhancementType && 
-    config.intensity >= 0 && 
-    config.intensity <= 1 &&
-    config.targetStyle
-  );
-};
-
-export const createImageEnhancementVariable = (
-  name: string,
-  description: string,
-  type: ImageEnhancementVariable['type'] = 'select',
-  required: boolean = true,
-  options?: string[]
-): ImageEnhancementVariable => ({
-  name,
-  description,
-  type,
-  required,
-  options,
-});
-
-export const calculateAdjustments = (
-  config: ImageEnhancementConfig
-): EnhancementAdjustments => {
-  const baseIntensity = config.intensity;
-  const multiplier = config.targetStyle === 'dramatic' ? 1.5 : 
-                    config.targetStyle === 'vivid' ? 1.2 : 
-                    config.targetStyle === 'professional' ? 0.8 : 1;
-
-  return {
-    brightness: config.enhancementType === 'brightness' || config.enhancementType === 'all' 
-      ? baseIntensity * multiplier : 0,
-    contrast: config.enhancementType === 'contrast' || config.enhancementType === 'all' 
-      ? baseIntensity * multiplier : 0,
-    saturation: config.enhancementType === 'saturation' || config.enhancementType === 'all' 
-      ? baseIntensity * multiplier : 0,
-    sharpness: config.enhancementType === 'sharpness' || config.enhancementType === 'all' 
-      ? baseIntensity * multiplier : 0,
-    overall: baseIntensity * multiplier,
-  };
-};

package/src/domains/prompts/domain/entities/PhotoRestorationConfig.ts

@@ -1,64 +0,0 @@
-import type { AIPromptTemplate } from './AIPromptTemplate';
-
-export interface PhotoRestorationConfig {
-  severity: 'minor' | 'moderate' | 'severe';
-  preserveOriginal: boolean;
-  enhanceColors: boolean;
-  removeNoise: boolean;
-  fixBlur: boolean;
-  restoreDetails: boolean;
-}
-
-export interface PhotoRestorationTemplate {
-  readonly id: string;
-  readonly name: string;
-  readonly description: string;
-  readonly basePrompt: string;
-  readonly variables: PhotoRestorationVariable[];
-  readonly quality: PhotoRestorationQuality;
-}
-
-export interface PhotoRestorationVariable {
-  name: string;
-  description: string;
-  required: boolean;
-  options?: string[];
-}
-
-export interface PhotoRestorationQuality {
-  detailLevel: number;
-  noiseReduction: number;
-  colorAccuracy: number;
-  sharpness: number;
-}
-
-export interface PhotoRestorationResult {
-  template: AIPromptTemplate;
-  config: PhotoRestorationConfig;
-  estimatedQuality: number;
-}
-
-export const validatePhotoRestorationConfig = (config: PhotoRestorationConfig): boolean => {
-  return !!(config.severity && config.severity.trim().length > 0);
-};
-
-export const createPhotoRestorationVariable = (
-  name: string,
-  description: string,
-  required: boolean = true,
-  options?: string[]
-): PhotoRestorationVariable => ({
-  name,
-  description,
-  required,
-  options,
-});
-
-export const getQualityLevel = (severity: PhotoRestorationConfig['severity']): number => {
-  switch (severity) {
-    case 'minor': return 0.7;
-    case 'moderate': return 0.5;
-    case 'severe': return 0.3;
-    default: return 0.5;
-  }
-};

package/src/domains/prompts/domain/entities/StyleTransferConfig.ts

@@ -1,80 +0,0 @@
-import type { AIPromptTemplate } from './AIPromptTemplate';
-
-export interface StyleTransferConfig {
-  targetStyle: string;
-  preserveContent: boolean;
-  styleStrength: number;
-  artisticMode: 'photorealistic' | 'artistic' | 'abstract' | 'cartoon';
-  maintainColors: boolean;
-  adaptToSubject: boolean;
-}
-
-export interface StyleTransferTemplate {
-  readonly id: string;
-  readonly name: string;
-  readonly description: string;
-  readonly basePrompt: string;
-  readonly variables: StyleTransferVariable[];
-  readonly style: StyleTransferSettings;
-}
-
-export interface StyleTransferVariable {
-  name: string;
-  description: string;
-  required: boolean;
-  options?: string[];
-  type: 'string' | 'select';
-}
-
-export interface StyleTransferSettings {
-  supportedStyles: string[];
-  maxStyleStrength: number;
-  preserveContentLevels: number[];
-  qualityPresets: Record<string, number>;
-}
-
-export interface StyleTransferResult {
-  template: AIPromptTemplate;
-  config: StyleTransferConfig;
-  appliedStyle: string;
-  expectedQuality: number;
-}
-
-export const validateStyleTransferConfig = (config: StyleTransferConfig): boolean => {
-  return !!(
-    config.targetStyle && 
-    config.targetStyle.trim().length > 0 &&
-    config.styleStrength >= 0 && 
-    config.styleStrength <= 1 &&
-    config.artisticMode
-  );
-};
-
-export const createStyleTransferVariable = (
-  name: string,
-  description: string,
-  required: boolean = true,
-  options?: string[]
-): StyleTransferVariable => ({
-  name,
-  description,
-  required,
-  options,
-  type: 'string',
-});
-
-export const getStyleStrengthValue = (strength: number): string => {
-  if (strength <= 0.3) return 'subtle';
-  if (strength <= 0.6) return 'moderate';
-  return 'strong';
-};
-
-export const getArtisticModeDescription = (mode: StyleTransferConfig['artisticMode']): string => {
-  switch (mode) {
-    case 'photorealistic': return 'Maintain realistic appearance while applying style';
-    case 'artistic': return 'Apply artistic interpretation with creative freedom';
-    case 'abstract': return 'Transform into abstract artistic representation';
-    case 'cartoon': return 'Convert to cartoon/animated style';
-    default: return 'Apply selected artistic style';
-  }
-};

package/src/domains/prompts/domain/entities/TextGenerationConfig.ts

@@ -1,100 +0,0 @@
-import type { AIPromptTemplate } from './AIPromptTemplate';
-
-export interface TextGenerationConfig {
-  promptType: 'creative' | 'technical' | 'marketing' | 'educational' | 'conversational';
-  tone: 'formal' | 'casual' | 'professional' | 'friendly' | 'humorous';
-  length: 'short' | 'medium' | 'long';
-  language: string;
-  context?: string;
-  keywords?: string[];
-}
-
-export interface TextGenerationTemplate {
-  readonly id: string;
-  readonly name: string;
-  readonly description: string;
-  readonly basePrompt: string;
-  readonly variables: TextGenerationVariable[];
-  readonly generation: TextGenerationSettings;
-}
-
-export interface TextGenerationVariable {
-  name: string;
-  description: string;
-  required: boolean;
-  type: 'string' | 'select' | 'array';
-  options?: string[];
-}
-
-export interface TextGenerationSettings {
-  supportedLanguages: string[];
-  maxTokens: Record<string, number>;
-  temperaturePresets: Record<string, number>;
-}
-
-export interface TextGenerationResult {
-  template: AIPromptTemplate;
-  config: TextGenerationConfig;
-  estimatedTokens: number;
-  suggestedParameters: {
-    temperature: number;
-    maxTokens: number;
-    topP: number;
-  };
-}
-
-export const validateTextGenerationConfig = (config: TextGenerationConfig): boolean => {
-  return !!(
-    config.promptType &&
-    config.tone &&
-    config.length &&
-    config.language &&
-    config.language.trim().length > 0
-  );
-};
-
-export const createTextGenerationVariable = (
-  name: string,
-  description: string,
-  type: TextGenerationVariable['type'] = 'string',
-  required: boolean = true,
-  options?: string[]
-): TextGenerationVariable => ({
-  name,
-  description,
-  type,
-  required,
-  options,
-});
-
-export const getTokenCount = (length: TextGenerationConfig['length']): number => {
-  switch (length) {
-    case 'short': return 50;
-    case 'medium': return 200;
-    case 'long': return 500;
-    default: return 200;
-  }
-};
-
-export const getTemperature = (
-  promptType: TextGenerationConfig['promptType'],
-  tone: TextGenerationConfig['tone']
-): number => {
-  let temp = 0.7;
-  
-  if (promptType === 'creative') temp += 0.2;
-  if (promptType === 'technical') temp -= 0.3;
-  if (tone === 'humorous') temp += 0.1;
-  if (tone === 'formal') temp -= 0.2;
-  
-  return Math.max(0.1, Math.min(1.0, temp));
-};
-
-export const getTopP = (promptType: TextGenerationConfig['promptType']): number => {
-  switch (promptType) {
-    case 'creative': return 0.95;
-    case 'technical': return 0.8;
-    case 'educational': return 0.85;
-    default: return 0.9;
-  }
-};

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

@@ -1,142 +0,0 @@
-/**
- * AI Service Processor
- * Handles processing of different AI service types
- */
-
-import type {FaceSwapConfig} from '../../domain/entities/FaceSwapConfig';
-import type {PhotoRestorationConfig} from '../../domain/entities/PhotoRestorationConfig';
-import type {ImageEnhancementConfig} from '../../domain/entities/ImageEnhancementConfig';
-import type {StyleTransferConfig} from '../../domain/entities/StyleTransferConfig';
-import type {BackgroundRemovalConfig} from '../../domain/entities/BackgroundRemovalConfig';
-import type {TextGenerationConfig} from '../../domain/entities/TextGenerationConfig';
-import type {ColorizationConfig} from '../../domain/entities/ColorizationConfig';
-import type {
-    IFaceSwapService,
-    IPhotoRestorationService,
-    IImageEnhancementService,
-    IStyleTransferService,
-    IBackgroundRemovalService,
-    ITextGenerationService,
-    IColorizationService,
-} from '../../domain/repositories/IAIPromptServices';
-import type {AIPromptResult} from '../../domain/entities/types';
-import type {AIPromptTemplate} from '../../domain/entities/AIPromptTemplate';
-
-export type AIConfig =
-    | { type: 'face-swap'; config: FaceSwapConfig }
-    | { type: 'photo-restoration'; config: PhotoRestorationConfig }
-    | { type: 'image-enhancement'; config: ImageEnhancementConfig }
-    | { type: 'style-transfer'; config: StyleTransferConfig }
-    | { type: 'background-removal'; config: BackgroundRemovalConfig }
-    | { type: 'text-generation'; config: TextGenerationConfig }
-    | { type: 'colorization'; config: ColorizationConfig };
-
-export interface AIServices {
-    faceSwap: IFaceSwapService;
-    photoRestoration: IPhotoRestorationService;
-    imageEnhancement: IImageEnhancementService;
-    styleTransfer: IStyleTransferService;
-    backgroundRemoval: IBackgroundRemovalService;
-    textGeneration: ITextGenerationService;
-    colorization: IColorizationService;
-}
-
-export interface ProcessResult {
-    template: AIPromptTemplate;
-    prompt: string;
-    config: Record<string, unknown>;
-}
-
-export class AIServiceProcessor {
-    constructor(private services: AIServices) { }
-
-    async process(aiConfig: AIConfig): Promise<ProcessResult> {
-        const { templateResult, promptResult } = await this.executeService(aiConfig);
-
-        if (!templateResult?.success || !templateResult.data) {
-            throw new Error('Failed to generate template');
-        }
-
-        if (!promptResult?.success || !promptResult.data) {
-            throw new Error('Failed to generate prompt');
-        }
-
-        return {
-            template: templateResult.data,
-            prompt: promptResult.data,
-            config: aiConfig.config as unknown as Record<string, unknown>,
-        };
-    }
-
-    async getAvailableStyles(serviceType: string): Promise<string[]> {
-        switch (serviceType) {
-            case 'face-swap':
-                return await this.services.faceSwap.getAvailableStyles();
-            case 'style-transfer':
-                return await this.services.styleTransfer.getAvailableStyles();
-            default:
-                return [];
-        }
-    }
-
-    private async executeService(aiConfig: AIConfig): Promise<{
-        templateResult: AIPromptResult<AIPromptTemplate> | undefined;
-        promptResult: AIPromptResult<string> | undefined;
-    }> {
-        let templateResult: AIPromptResult<AIPromptTemplate> | undefined;
-        let promptResult: AIPromptResult<string> | undefined;
-
-        switch (aiConfig.type) {
-            case 'face-swap':
-                templateResult = await this.services.faceSwap.generateTemplate(aiConfig.config);
-                if (templateResult.success && templateResult.data) {
-                    promptResult = await this.services.faceSwap.generatePrompt(templateResult.data, aiConfig.config);
-                }
-                break;
-
-            case 'photo-restoration':
-                templateResult = await this.services.photoRestoration.generateTemplate(aiConfig.config);
-                if (templateResult.success && templateResult.data) {
-                    promptResult = await this.services.photoRestoration.generatePrompt(templateResult.data, aiConfig.config);
-                }
-                break;
-
-            case 'image-enhancement':
-                templateResult = await this.services.imageEnhancement.generateTemplate(aiConfig.config);
-                if (templateResult.success && templateResult.data) {
-                    promptResult = await this.services.imageEnhancement.generatePrompt(templateResult.data, aiConfig.config);
-                }
-                break;
-
-            case 'style-transfer':
-                templateResult = await this.services.styleTransfer.generateTemplate(aiConfig.config);
-                if (templateResult.success && templateResult.data) {
-                    promptResult = await this.services.styleTransfer.generatePrompt(templateResult.data, aiConfig.config);
-                }
-                break;
-
-            case 'background-removal':
-                templateResult = await this.services.backgroundRemoval.generateTemplate(aiConfig.config);
-                if (templateResult.success && templateResult.data) {
-                    promptResult = await this.services.backgroundRemoval.generatePrompt(templateResult.data, aiConfig.config);
-                }
-                break;
-
-            case 'text-generation':
-                templateResult = await this.services.textGeneration.generateTemplate(aiConfig.config);
-                if (templateResult.success && templateResult.data) {
-                    promptResult = await this.services.textGeneration.generatePrompt(templateResult.data, aiConfig.config);
-                }
-                break;
-
-            case 'colorization':
-                templateResult = await this.services.colorization.generateTemplate(aiConfig.config);
-                if (templateResult.success && templateResult.data) {
-                    promptResult = await this.services.colorization.generatePrompt(templateResult.data, aiConfig.config);
-                }
-                break;
-        }
-
-        return { templateResult, promptResult };
-    }
-}

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

@@ -1,75 +0,0 @@
-/**
- * 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 {AIPromptTemplate} from '../../domain/entities/AIPromptTemplate';
-import {validateBackgroundRemovalConfig, getProcessingTime, getQualityScore} from '../../domain/entities/BackgroundRemovalConfig';
-import { BasePromptService } from './base';
-
-const BASE_TEMPLATE = `
-You are an expert AI background removal specialist.
-This is a BACKGROUND REMOVAL task, not image generation.
-
-DETECTION PRINCIPLES:
-- Accurately identify foreground subject
-- Distinguish between subject and background
-- Handle complex edges (hair, fur, transparent objects)
-- Preserve fine details and textures
-
-SAFETY CONSTRAINTS:
-- Preserve subject completely
-- Do not alter foreground content
-- Maintain important details
-- Avoid over-removal of subject elements
-`.trim();
-
-export class BackgroundRemovalService
-  extends BasePromptService<BackgroundRemovalConfig>
-  implements IBackgroundRemovalService
-{
-  protected getServiceName(): string {
-    return 'background removal';
-  }
-
-  validateConfig(config: BackgroundRemovalConfig): boolean {
-    return validateBackgroundRemovalConfig(config);
-  }
-
-  estimateProcessingTime(config: BackgroundRemovalConfig): number {
-    return getProcessingTime(config.precision);
-  }
-
-  protected buildVariables(config: BackgroundRemovalConfig): Record<string, unknown> {
-    return {
-      precision: config.precision,
-      edgeRefinement: config.edgeRefinement,
-      preserveHair: config.preserveHair,
-      outputFormat: config.outputFormat,
-      addNewBackground: config.addNewBackground,
-      processingTime: getProcessingTime(config.precision),
-      qualityScore: getQualityScore(config),
-    };
-  }
-
-  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: `${BASE_TEMPLATE}
-
-PRECISION: ${config.precision}
-EDGE REFINEMENT: ${config.edgeRefinement}
-PRESERVE HAIR: ${config.preserveHair}
-OUTPUT: ${config.outputFormat}
-${config.addNewBackground ? `NEW BACKGROUND: ${config.addNewBackground}` : ''}
-
-QUALITY: ${Math.round(getQualityScore(config) * 100)}%
-EST. TIME: ${getProcessingTime(config.precision)}s`,
-    });
-  }
-}

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

@@ -1,90 +0,0 @@
-/**
- * Colorization Service
- * AI prompt generation for photo colorization
- */
-
-import type {IColorizationService} from '../../domain/repositories/IAIPromptServices';
-import type {ColorizationConfig} from '../../domain/entities/ColorizationConfig';
-import type {AIPromptTemplate} from '../../domain/entities/AIPromptTemplate';
-import {
-  validateColorizationConfig,
-  getColorizationQuality,
-  getSuggestedColorPalette,
-} from '../../domain/entities/ColorizationConfig';
-import { BasePromptService } from './base';
-
-const BASE_TEMPLATE = `
-You are an expert AI colorization specialist.
-This is a PHOTO COLORIZATION task, not image generation.
-
-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
-
-TECHNICAL:
-- Preserve edges and details during color application
-- Apply colors smoothly and naturally
-- Consider lighting and shadow relationships
-
-SAFETY:
-- Do not alter content or composition
-- Preserve important details and features
-- Avoid inappropriate or unrealistic colors
-`.trim();
-
-export class ColorizationService
-  extends BasePromptService<ColorizationConfig>
-  implements IColorizationService
-{
-  protected getServiceName(): string {
-    return 'colorization';
-  }
-
-  validateConfig(config: ColorizationConfig): boolean {
-    return validateColorizationConfig(config);
-  }
-
-  getColorPalette(config: ColorizationConfig): string[] {
-    return getSuggestedColorPalette(config.targetType, config.colorMode);
-  }
-
-  getQualityScore(config: ColorizationConfig): number {
-    return getColorizationQuality(config);
-  }
-
-  protected buildVariables(config: ColorizationConfig): Record<string, unknown> {
-    return {
-      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),
-    };
-  }
-
-  protected createTemplate(config: ColorizationConfig): AIPromptTemplate {
-    const quality = Math.round(getColorizationQuality(config) * 100);
-
-    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: `${BASE_TEMPLATE}
-
-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: ${quality}%`,
-    });
-  }
-}