@umituz/react-native-ai-generation-content 1.12.25 → 1.12.29

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

@@ -0,0 +1,142 @@
+/**
+ * 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/presentation/hooks/useAIServices.ts

@@ -1,50 +1,12 @@
-import { useState, useCallback } from 'react';
-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 { useState, useCallback, useMemo } from 'react';
 import type { ITemplateRepository } from '../../domain/repositories/ITemplateRepository';
 import type { IPromptHistoryRepository } from '../../domain/repositories/IPromptHistoryRepository';
 import type { GeneratedPrompt } from '../../domain/entities/GeneratedPrompt';
 import { createGeneratedPrompt } from '../../domain/entities/GeneratedPrompt';
 import { useAsyncState } from './useAsyncState';
-import type { AIPromptResult } from '../../domain/entities/types';
-import type { AIPromptTemplate } from '../../domain/entities/AIPromptTemplate';
+import { AIServiceProcessor, type AIConfig, type AIServices } from '../../infrastructure/services/AIServiceProcessor';
 
-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 type { AIConfig };
 
 export interface UseAIServicesState {
   generatedPrompt: GeneratedPrompt | null;
@@ -60,15 +22,7 @@ export interface UseAIServicesActions {
 }
 
 export const useAIServices = (
-  services: {
-    faceSwap: IFaceSwapService;
-    photoRestoration: IPhotoRestorationService;
-    imageEnhancement: IImageEnhancementService;
-    styleTransfer: IStyleTransferService;
-    backgroundRemoval: IBackgroundRemovalService;
-    textGeneration: ITextGenerationService;
-    colorization: IColorizationService;
-  },
+  services: AIServices,
   repositories: {
     template: ITemplateRepository;
     history: IPromptHistoryRepository;
@@ -85,110 +39,39 @@ export const useAIServices = (
 
   const [currentService, setCurrentService] = useState<string | null>(null);
 
+  const processor = useMemo(() => new AIServiceProcessor(services), [services]);
+
   const processRequest = useCallback(async (aiConfig: AIConfig): Promise<void> => {
     clearError();
     setCurrentService(aiConfig.type);
 
     try {
-      let templateResult: AIPromptResult<AIPromptTemplate> | undefined;
-      let promptResult: AIPromptResult<string> | undefined;
-
-      switch (aiConfig.type) {
-        case 'face-swap':
-          templateResult = await services.faceSwap.generateTemplate(aiConfig.config);
-          if (templateResult.success && templateResult.data) {
-            promptResult = await services.faceSwap.generatePrompt(templateResult.data, aiConfig.config);
-          }
-          break;
-
-        case 'photo-restoration':
-          templateResult = await services.photoRestoration.generateTemplate(aiConfig.config);
-          if (templateResult.success && templateResult.data) {
-            promptResult = await services.photoRestoration.generatePrompt(templateResult.data, aiConfig.config);
-          }
-          break;
-
-        case 'image-enhancement':
-          templateResult = await services.imageEnhancement.generateTemplate(aiConfig.config);
-          if (templateResult.success && templateResult.data) {
-            promptResult = await services.imageEnhancement.generatePrompt(templateResult.data, aiConfig.config);
-          }
-          break;
-
-        case 'style-transfer':
-          templateResult = await services.styleTransfer.generateTemplate(aiConfig.config);
-          if (templateResult.success && templateResult.data) {
-            promptResult = await services.styleTransfer.generatePrompt(templateResult.data, aiConfig.config);
-          }
-          break;
-
-        case 'background-removal':
-          templateResult = await services.backgroundRemoval.generateTemplate(aiConfig.config);
-          if (templateResult.success && templateResult.data) {
-            promptResult = await services.backgroundRemoval.generatePrompt(templateResult.data, aiConfig.config);
-          }
-          break;
-
-        case 'text-generation':
-          templateResult = await services.textGeneration.generateTemplate(aiConfig.config);
-          if (templateResult.success && templateResult.data) {
-            promptResult = await services.textGeneration.generatePrompt(templateResult.data, aiConfig.config);
-          }
-          break;
-
-        case 'colorization':
-          templateResult = await services.colorization.generateTemplate(aiConfig.config);
-          if (templateResult.success && templateResult.data) {
-            promptResult = await services.colorization.generatePrompt(templateResult.data, aiConfig.config);
-          }
-          break;
-
-        default:
-          setError('Unknown AI service type');
-          return;
-      }
-
-      if (!templateResult?.success || !templateResult.data) {
-        setError('Failed to generate template');
-        return;
-      }
-
-      if (!promptResult?.success || !promptResult.data) {
-        setError('Failed to generate prompt');
-        return;
-      }
+      const result = await processor.process(aiConfig);
 
       const newPrompt = createGeneratedPrompt({
-        templateId: templateResult.data.id,
-        generatedText: promptResult.data,
-        variables: aiConfig.config as unknown as Record<string, unknown>,
+        templateId: result.template.id,
+        generatedText: result.prompt,
+        variables: result.config,
       });
 
       await repositories.history.save(newPrompt);
       setGeneratedPrompt(newPrompt);
 
-    } catch {
-      setError('An unexpected error occurred');
+    } catch (err) {
+      setError(err instanceof Error ? err.message : 'An unexpected error occurred');
     } finally {
       setCurrentService(null);
     }
-  }, [services, repositories, setError, setGeneratedPrompt, clearError]);
+  }, [processor, repositories, setError, setGeneratedPrompt, clearError]);
 
   const getAvailableStyles = useCallback(async (serviceType: string): Promise<string[]> => {
     try {
-      switch (serviceType) {
-        case 'face-swap':
-          return await services.faceSwap.getAvailableStyles();
-        case 'style-transfer':
-          return await services.styleTransfer.getAvailableStyles();
-        default:
-          return [];
-      }
+      return await processor.getAvailableStyles(serviceType);
     } catch {
       setError('Failed to load available styles');
       return [];
     }
-  }, [services, setError]);
+  }, [processor, setError]);
 
   const clearPrompt = useCallback(() => {
     setGeneratedPrompt(null);

package/src/features/background/presentation/components/ComparisonSlider.tsx

@@ -129,7 +129,7 @@ export const ComparisonSlider: React.FC<ComparisonSliderProps> = memo(
                         <View style={[styles.label, styles.labelLeft, themedStyles.labelLeft]}>
                             <AtomicText
                                 
-                                color="textPrimary"
+                               
                             >
                                 {beforeLabel}
                             </AtomicText>
@@ -140,7 +140,7 @@ export const ComparisonSlider: React.FC<ComparisonSliderProps> = memo(
                         <View style={[styles.label, styles.labelRight, themedStyles.labelRight]}>
                             <AtomicText
                                 
-                                color="backgroundPrimary"
+                               
                             >
                                 {afterLabel}
                             </AtomicText>

package/src/features/background/presentation/components/ErrorDisplay.tsx

@@ -31,11 +31,11 @@ export const ErrorDisplay: React.FC<ErrorDisplayProps> = memo(
                 <AtomicIcon
                     name="alert-circle"
                     size="sm"
-                    color="error"
+                   
                 />
                 <AtomicText
                     
-                    color="error"
+                   
                     style={styles.errorText}
                 >
                     {error}

package/src/features/background/presentation/components/GenerateButton.tsx

@@ -45,10 +45,8 @@ export const GenerateButton: React.FC<GenerateButtonProps> = memo(
                             name="sparkles"
                             size="md"
                             color={disabled ? "surfaceVariant" : "onPrimary"}
-                            style={styles.icon}
                         />
                         <AtomicText
-                            
                             style={[
                                 styles.text,
                                 {

package/src/features/background/presentation/components/ImagePicker.tsx

@@ -45,7 +45,7 @@ export const ImagePicker: React.FC<ImagePickerProps> = memo(
                                     <AtomicIcon
                                         name="image-plus"
                                         size="md"
-                                        color="onPrimary"
+                                       
                                     />
                                 </View>
                             </View>
@@ -66,7 +66,7 @@ export const ImagePicker: React.FC<ImagePickerProps> = memo(
                                 <AtomicIcon
                                     name="upload"
                                     size="lg"
-                                    color="primary"
+                                   
                                 />
                             </View>
                             <AtomicText

package/src/features/background/presentation/components/ResultDisplay.tsx

@@ -48,7 +48,7 @@ export const ResultDisplay: React.FC<ResultDisplayProps> = memo(
                         <AtomicIcon
                             name="refresh-cw"
                             size="md"
-                            color="onSurface"
+                           
                         />
                         <AtomicText
                             
@@ -68,7 +68,7 @@ export const ResultDisplay: React.FC<ResultDisplayProps> = memo(
                         <AtomicIcon
                             name="download"
                             size="md"
-                            color="onPrimary"
+                           
                         />
                         <AtomicText
                             

package/src/index.ts

@@ -234,6 +234,12 @@ export * from "./domains/prompts";
 
 export * from "./domains/content-moderation";
 
+// =============================================================================
+// DOMAINS - Creations
+// =============================================================================
+
+export * from "./domains/creations";
+
 // =============================================================================
 // DOMAINS - Face Detection
 // =============================================================================

package/src/infrastructure/services/generation-orchestrator.service.ts

@@ -9,15 +9,10 @@ import type {
   GenerationProgress,
   PollingConfig,
 } from "../../domain/entities";
-import { DEFAULT_POLLING_CONFIG } from "../../domain/entities";
-import type { IAIProvider, JobStatus } from "../../domain/interfaces";
-import { providerRegistry } from "./provider-registry.service";
-import {
-  classifyError,
-  isTransientError,
-} from "../utils/error-classifier.util";
-import { createPollingDelay } from "../utils/polling-interval.util";
-import { createProgressTracker } from "../utils/progress-calculator.util";
+import { classifyError } from "../utils/error-classifier.util";
+import { ProgressManager } from "./progress-manager";
+import { JobPoller, type PollerConfig } from "./job-poller";
+import { ProviderValidator } from "./provider-validator";
 
 declare const __DEV__: boolean;
 
@@ -27,7 +22,9 @@ export interface OrchestratorConfig {
 }
 
 class GenerationOrchestratorService {
-  private config: OrchestratorConfig = {};
+  private progressManager = new ProgressManager();
+  private jobPoller = new JobPoller();
+  private providerValidator = new ProviderValidator();
 
   configure(config: OrchestratorConfig): void {
     if (typeof __DEV__ !== "undefined" && __DEV__) {
@@ -37,14 +34,19 @@ class GenerationOrchestratorService {
         hasStatusUpdate: !!config.onStatusUpdate,
       });
     }
-    this.config = { ...this.config, ...config };
+
+    const pollerConfig: PollerConfig = {
+      polling: config.polling,
+      onStatusUpdate: config.onStatusUpdate,
+    };
+
+    this.jobPoller.configure(pollerConfig);
   }
 
   async generate<T = unknown>(
     request: GenerationRequest,
   ): Promise<GenerationResult<T>> {
-    const provider = this.getProvider();
-    const progressTracker = createProgressTracker();
+    const provider = this.providerValidator.getProvider();
     const startTime = Date.now();
 
     if (typeof __DEV__ !== "undefined" && __DEV__) {
@@ -60,11 +62,7 @@ class GenerationOrchestratorService {
       stage: GenerationProgress["stage"],
       subProgress = 0,
     ) => {
-      const progress = progressTracker.setStatus(stage);
-      request.onProgress?.({
-        stage,
-        progress: progress + subProgress,
-      });
+      this.progressManager.updateProgress(stage, subProgress, request.onProgress);
     };
 
     try {
@@ -84,11 +82,19 @@ class GenerationOrchestratorService {
 
       updateProgress("generating");
 
-      const result = await this.pollForResult<T>(
+      const result = await this.jobPoller.pollForResult<T>(
         provider,
         request.model,
         submission.requestId,
         request.onProgress,
+        (status, attempt, config) => {
+          this.progressManager.updateProgressFromStatus(
+            status,
+            attempt,
+            config,
+            request.onProgress,
+          );
+        },
       );
 
       updateProgress("completed");
@@ -139,149 +145,6 @@ class GenerationOrchestratorService {
       };
     }
   }
-
-  private async pollForResult<T>(
-    provider: IAIProvider,
-    model: string,
-    requestId: string,
-    onProgress?: (progress: GenerationProgress) => void,
-  ): Promise<T> {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      // eslint-disable-next-line no-console
-      console.log("[Orchestrator] pollForResult() started", {
-        provider: provider.providerId,
-        model,
-        requestId,
-      });
-    }
-
-    const config = {
-      ...DEFAULT_POLLING_CONFIG,
-      ...this.config.polling,
-    };
-
-    let consecutiveErrors = 0;
-
-    for (let attempt = 0; attempt < config.maxAttempts; attempt++) {
-      await createPollingDelay(attempt, config);
-
-      if (typeof __DEV__ !== "undefined" && __DEV__ && attempt % 5 === 0) {
-        // eslint-disable-next-line no-console
-        console.log("[Orchestrator] pollForResult() attempt", {
-          attempt,
-          maxAttempts: config.maxAttempts,
-        });
-      }
-
-      try {
-        const status = await provider.getJobStatus(model, requestId);
-
-        consecutiveErrors = 0;
-
-        this.updateProgressFromStatus(status, attempt, config, onProgress);
-
-        if (status.status === "COMPLETED") {
-          if (typeof __DEV__ !== "undefined" && __DEV__) {
-            // eslint-disable-next-line no-console
-            console.log("[Orchestrator] pollForResult() job COMPLETED", {
-              requestId,
-              attempt,
-            });
-          }
-          return provider.getJobResult<T>(model, requestId);
-        }
-
-        if (status.status === "FAILED") {
-          throw new Error("Job failed on provider");
-        }
-
-        await this.config.onStatusUpdate?.(requestId, status.status);
-      } catch (error) {
-        if (isTransientError(error)) {
-          consecutiveErrors++;
-
-          if (consecutiveErrors >= config.maxConsecutiveErrors) {
-            throw error;
-          }
-
-          continue;
-        }
-
-        throw error;
-      }
-    }
-
-    throw new Error(
-      `Polling timeout after ${config.maxAttempts} attempts`,
-    );
-  }
-
-  private updateProgressFromStatus(
-    status: JobStatus,
-    attempt: number,
-    config: PollingConfig,
-    onProgress?: (progress: GenerationProgress) => void,
-  ): void {
-    const baseProgress = 25;
-    const maxProgress = 85;
-    const range = maxProgress - baseProgress;
-
-    let progress: number;
-
-    if (status.status === "IN_QUEUE") {
-      progress = baseProgress + range * 0.2;
-    } else if (status.status === "IN_PROGRESS") {
-      const ratio = Math.min(attempt / (config.maxAttempts * 0.7), 1);
-      progress = baseProgress + range * (0.2 + 0.6 * ratio);
-    } else {
-      progress = baseProgress;
-    }
-
-    onProgress?.({
-      stage: "generating",
-      progress: Math.round(progress),
-      eta: status.eta,
-    });
-  }
-
-  private getProvider(): IAIProvider {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      // eslint-disable-next-line no-console
-      console.log("[Orchestrator] getProvider() called");
-    }
-
-    const provider = providerRegistry.getActiveProvider();
-
-    if (!provider) {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        // eslint-disable-next-line no-console
-        console.error("[Orchestrator] No active provider found!");
-      }
-      throw new Error(
-        "No active AI provider. Register and set a provider first.",
-      );
-    }
-
-    if (!provider.isInitialized()) {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        // eslint-disable-next-line no-console
-        console.error("[Orchestrator] Provider not initialized:", provider.providerId);
-      }
-      throw new Error(
-        `Provider ${provider.providerId} is not initialized.`,
-      );
-    }
-
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      // eslint-disable-next-line no-console
-      console.log("[Orchestrator] getProvider() returning:", {
-        providerId: provider.providerId,
-        isInitialized: provider.isInitialized(),
-      });
-    }
-
-    return provider;
-  }
 }
 
 export const generationOrchestrator = new GenerationOrchestratorService();