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

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

@@ -0,0 +1,93 @@
+import type { AIPromptVariable } from './value-objects';
+
+/**
+ * Future Prediction Configuration
+ * Generic configuration for generating future scenarios/visualizations
+ */
+
+export interface FuturePredictionSettings {
+    readonly scenarioType: string; // e.g. 'lifestyle', 'career', 'family', 'adventure'
+    readonly outputType: FuturePredictionOutputType;
+    readonly personCount: 1 | 2;
+    readonly includeDate: boolean;
+    readonly language: string;
+    readonly tone?: string; // e.g. 'romantic', 'professional', 'funny', 'dramatic'
+    readonly subjectRole?: string; // e.g. 'couple', 'best friends', 'business partners', 'parents'
+    readonly year?: number; // Optional specific year for prediction
+}
+
+export type FuturePredictionOutputType = 'image' | 'story' | 'both';
+
+export interface FuturePredictionConfig {
+    readonly scenarioId: string;
+    readonly scenarioTitle: string;
+    readonly promptModifier: string;
+    readonly subjectA: string;
+    readonly subjectB?: string;
+    readonly settings: FuturePredictionSettings;
+    readonly customPrompt?: string;
+}
+
+export interface FuturePredictionTemplate {
+    readonly id: string;
+    readonly name: string;
+    readonly description: string;
+    readonly imagePrompt: string;
+    readonly storyPrompt: string;
+    readonly variables: readonly FuturePredictionVariable[];
+}
+
+export interface FuturePredictionVariable extends AIPromptVariable {
+    readonly category: 'subject' | 'scenario' | 'output';
+}
+
+export interface FuturePredictionResult {
+    readonly imagePrompt: string;
+    readonly storyPrompt: string;
+    readonly metadata: FuturePredictionMetadata;
+}
+
+export interface FuturePredictionMetadata {
+    readonly scenarioId: string;
+    readonly personCount: number;
+    readonly language: string;
+    readonly generatedAt: number;
+}
+
+export const validateFuturePredictionConfig = (
+    config: FuturePredictionConfig
+): boolean => {
+    if (!config.scenarioId || typeof config.scenarioId !== 'string') {
+        return false;
+    }
+    if (!config.subjectA || typeof config.subjectA !== 'string') {
+        return false;
+    }
+    if (!config.settings) {
+        return false;
+    }
+    return true;
+};
+
+export const createFuturePredictionVariable = (
+    name: string,
+    type: 'string' | 'number' | 'boolean',
+    description: string,
+    category: 'subject' | 'scenario' | 'output',
+    required: boolean = true,
+    defaultValue?: string | number | boolean
+): FuturePredictionVariable => ({
+    name,
+    type,
+    description,
+    category,
+    required,
+    defaultValue,
+});
+
+export const getFutureYear = (): number => {
+    const currentYear = new Date().getFullYear();
+    // Typical future predictions are 1-50 years ahead
+    const offset = 1 + Math.floor(Math.random() * 50);
+    return currentYear + offset;
+};

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

@@ -0,0 +1,32 @@
+import type { AIPromptTemplate } from './AIPromptTemplate';
+
+export interface GeneratedPrompt {
+  readonly id: string;
+  readonly templateId: string;
+  readonly generatedText: string;
+  readonly variables: Record<string, unknown>;
+  readonly timestamp: Date;
+}
+
+export interface CreateGeneratedPromptParams {
+  templateId: string;
+  generatedText: string;
+  variables: Record<string, unknown>;
+}
+
+export const createGeneratedPrompt = (
+  params: CreateGeneratedPromptParams
+): GeneratedPrompt => ({
+  id: `prompt_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+  templateId: params.templateId,
+  generatedText: params.generatedText,
+  variables: params.variables,
+  timestamp: new Date(),
+});
+
+export const isPromptRecent = (prompt: GeneratedPrompt, hours: number = 24): boolean => {
+  const now = new Date();
+  const promptTime = new Date(prompt.timestamp);
+  const diffInHours = (now.getTime() - promptTime.getTime()) / (1000 * 60 * 60);
+  return diffInHours <= hours;
+};

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

@@ -0,0 +1,93 @@
+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

@@ -0,0 +1,64 @@
+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

@@ -0,0 +1,80 @@
+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

@@ -0,0 +1,100 @@
+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/domain/entities/types.ts

@@ -0,0 +1,27 @@
+export type AIPromptCategory =
+  | 'face-swap'
+  | 'photo-restoration'
+  | 'image-enhancement'
+  | 'style-transfer'
+  | 'background-removal'
+  | 'object-detection'
+  | 'text-generation'
+  | 'colorization'
+  | 'content-generation'
+  | 'text-processing'
+  | 'future-prediction';
+
+export type AIPromptVariableType = 'string' | 'number' | 'boolean' | 'select' | 'array';
+
+export type AIPromptError =
+  | 'TEMPLATE_NOT_FOUND'
+  | 'INVALID_VARIABLES'
+  | 'GENERATION_FAILED'
+  | 'STORAGE_ERROR'
+  | 'NETWORK_ERROR'
+  | 'VALIDATION_ERROR'
+  | 'SERVICE_UNAVAILABLE';
+
+export type AIPromptResult<T> =
+  | { success: true; data: T }
+  | { success: false; error: AIPromptError; message?: string };

package/src/domains/prompts/domain/entities/value-objects.ts

@@ -0,0 +1,33 @@
+import type { AIPromptVariableType } from './types';
+
+export interface AIPromptVariable {
+  name: string;
+  type: AIPromptVariableType;
+  description: string;
+  required: boolean;
+  defaultValue?: string | number | boolean;
+  options?: string[];
+}
+
+export interface AIPromptSafety {
+  contentFilter: boolean;
+  adultContentFilter: boolean;
+  violenceFilter: boolean;
+  hateSpeechFilter: boolean;
+  copyrightFilter: boolean;
+}
+
+export interface AIPromptVersion {
+  major: number;
+  minor: number;
+  patch: number;
+}
+
+export const createPromptVersion = (version: string): AIPromptVersion => {
+  const [major, minor, patch] = version.split('.').map(Number);
+  return { major: major || 1, minor: minor || 0, patch: patch || 0 };
+};
+
+export const formatVersion = (version: AIPromptVersion): string => {
+  return `${version.major}.${version.minor}.${version.patch}`;
+};

package/src/domains/prompts/domain/repositories/IAIPromptServices.ts

@@ -0,0 +1,106 @@
+import type { AIPromptTemplate } from '../entities/AIPromptTemplate';
+import type { AIPromptResult } from '../entities/types';
+import type { FaceSwapConfig, FaceSwapGenerationResult } from '../entities/FaceSwapConfig';
+import type {
+  PhotoRestorationConfig,
+  PhotoRestorationResult
+} from '../entities/PhotoRestorationConfig';
+import type {
+  ImageEnhancementConfig,
+  ImageEnhancementResult,
+  EnhancementAdjustments
+} from '../entities/ImageEnhancementConfig';
+import type {
+  StyleTransferConfig,
+  StyleTransferResult
+} from '../entities/StyleTransferConfig';
+import type {
+  BackgroundRemovalConfig,
+  BackgroundRemovalResult
+} from '../entities/BackgroundRemovalConfig';
+import type {
+  TextGenerationConfig,
+  TextGenerationResult
+} from '../entities/TextGenerationConfig';
+import type {
+  ColorizationConfig,
+  ColorizationResult
+} from '../entities/ColorizationConfig';
+import type {
+  FuturePredictionConfig,
+  FuturePredictionResult,
+} from '../entities/FuturePredictionConfig';
+
+export interface IFaceSwapService {
+  generateTemplate(config: FaceSwapConfig): Promise<AIPromptResult<AIPromptTemplate>>;
+  generatePrompt(template: AIPromptTemplate, config: FaceSwapConfig): Promise<AIPromptResult<string>>;
+  validateConfig(config: FaceSwapConfig): boolean;
+  getAvailableStyles(): Promise<string[]>;
+}
+
+export interface IPhotoRestorationService {
+  generateTemplate(config: PhotoRestorationConfig): Promise<AIPromptResult<AIPromptTemplate>>;
+  generatePrompt(template: AIPromptTemplate, config: PhotoRestorationConfig): Promise<AIPromptResult<string>>;
+  validateConfig(config: PhotoRestorationConfig): boolean;
+  estimateQuality(config: PhotoRestorationConfig): number;
+}
+
+export interface IImageEnhancementService {
+  generateTemplate(config: ImageEnhancementConfig): Promise<AIPromptResult<AIPromptTemplate>>;
+  generatePrompt(template: AIPromptTemplate, config: ImageEnhancementConfig): Promise<AIPromptResult<string>>;
+  validateConfig(config: ImageEnhancementConfig): boolean;
+  calculateAdjustments(config: ImageEnhancementConfig): EnhancementAdjustments;
+}
+
+export interface IStyleTransferService {
+  generateTemplate(config: StyleTransferConfig): Promise<AIPromptResult<AIPromptTemplate>>;
+  generatePrompt(template: AIPromptTemplate, config: StyleTransferConfig): Promise<AIPromptResult<string>>;
+  validateConfig(config: StyleTransferConfig): boolean;
+  getAvailableStyles(): Promise<string[]>;
+}
+
+export interface IBackgroundRemovalService {
+  generateTemplate(config: BackgroundRemovalConfig): Promise<AIPromptResult<AIPromptTemplate>>;
+  generatePrompt(template: AIPromptTemplate, config: BackgroundRemovalConfig): Promise<AIPromptResult<string>>;
+  validateConfig(config: BackgroundRemovalConfig): boolean;
+  estimateProcessingTime(config: BackgroundRemovalConfig): number;
+}
+
+export interface ITextGenerationService {
+  generateTemplate(config: TextGenerationConfig): Promise<AIPromptResult<AIPromptTemplate>>;
+  generatePrompt(template: AIPromptTemplate, config: TextGenerationConfig): Promise<AIPromptResult<string>>;
+  validateConfig(config: TextGenerationConfig): boolean;
+  estimateTokens(config: TextGenerationConfig): number;
+  getGenerationParameters(config: TextGenerationConfig): Record<string, number>;
+}
+
+export interface IColorizationService {
+  generateTemplate(config: ColorizationConfig): Promise<AIPromptResult<AIPromptTemplate>>;
+  generatePrompt(template: AIPromptTemplate, config: ColorizationConfig): Promise<AIPromptResult<string>>;
+  validateConfig(config: ColorizationConfig): boolean;
+  getColorPalette(config: ColorizationConfig): string[];
+  getQualityScore(config: ColorizationConfig): number;
+}
+
+export interface IPromptGenerationService {
+  generateFromTemplate(
+    template: AIPromptTemplate,
+    variables: Record<string, unknown>
+  ): Promise<AIPromptResult<string>>;
+  validateVariables(
+    template: AIPromptTemplate,
+    variables: Record<string, unknown>
+  ): AIPromptResult<void>;
+  replaceTemplateVariables(
+    template: string,
+    variables: Record<string, unknown>
+  ): string;
+}
+
+export interface IFuturePredictionService {
+  generateTemplate(config: FuturePredictionConfig): Promise<AIPromptResult<AIPromptTemplate>>;
+  generatePrompts(config: FuturePredictionConfig): Promise<AIPromptResult<FuturePredictionResult>>;
+  validateConfig(config: FuturePredictionConfig): boolean;
+  buildImagePrompt(config: FuturePredictionConfig): string;
+  buildStoryPrompt(config: FuturePredictionConfig): string;
+}

package/src/domains/prompts/domain/repositories/IPromptHistoryRepository.ts

@@ -0,0 +1,10 @@
+import type { GeneratedPrompt } from '../entities/GeneratedPrompt';
+import type { AIPromptResult } from '../entities/types';
+
+export interface IPromptHistoryRepository {
+  save(prompt: GeneratedPrompt): Promise<AIPromptResult<void>>;
+  findRecent(limit?: number): Promise<AIPromptResult<GeneratedPrompt[]>>;
+  findByTemplateId(templateId: string, limit?: number): Promise<AIPromptResult<GeneratedPrompt[]>>;
+  delete(id: string): Promise<AIPromptResult<void>>;
+  clear(): Promise<AIPromptResult<void>>;
+}

package/src/domains/prompts/domain/repositories/ITemplateRepository.ts

@@ -0,0 +1,11 @@
+import type { AIPromptTemplate } from '../entities/AIPromptTemplate';
+import type { AIPromptResult, AIPromptCategory } from '../entities/types';
+
+export interface ITemplateRepository {
+  findById(id: string): Promise<AIPromptResult<AIPromptTemplate | null>>;
+  findByCategory(category: AIPromptCategory): Promise<AIPromptResult<AIPromptTemplate[]>>;
+  findAll(): Promise<AIPromptResult<AIPromptTemplate[]>>;
+  save(template: AIPromptTemplate): Promise<AIPromptResult<void>>;
+  delete(id: string): Promise<AIPromptResult<void>>;
+  exists(id: string): Promise<boolean>;
+}