@umituz/react-native-ai-generation-content 1.17.143 → 1.17.145

package/src/features/shared/dual-image-video/presentation/hooks/useDualImageVideoFeature.ts

@@ -0,0 +1,124 @@
+/**
+ * useDualImageVideoFeature Hook
+ * Base hook for video features that take two images (ai-hug, ai-kiss, etc.)
+ * DRY: Consolidates common logic from useAIHugFeature and useAIKissFeature
+ */
+
+import { useState, useCallback } from "react";
+import { executeVideoFeature } from "../../../../../infrastructure/services";
+import type {
+  DualImageVideoFeatureState,
+  UseDualImageVideoFeatureProps,
+  UseDualImageVideoFeatureReturn,
+} from "../../domain/types/dual-image-video.types";
+
+const initialState: DualImageVideoFeatureState = {
+  sourceImageUri: null,
+  targetImageUri: null,
+  processedVideoUrl: null,
+  isProcessing: false,
+  progress: 0,
+  error: null,
+};
+
+export function useDualImageVideoFeature(
+  props: UseDualImageVideoFeatureProps,
+): UseDualImageVideoFeatureReturn {
+  const { featureType, config, onSelectSourceImage, onSelectTargetImage, onSaveVideo } = props;
+  const [state, setState] = useState<DualImageVideoFeatureState>(initialState);
+
+  const selectSourceImage = useCallback(async () => {
+    try {
+      const uri = await onSelectSourceImage();
+      if (uri) {
+        setState((prev) => ({ ...prev, sourceImageUri: uri, error: null }));
+        config.onSourceImageSelect?.(uri);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      setState((prev) => ({ ...prev, error: message }));
+    }
+  }, [onSelectSourceImage, config]);
+
+  const selectTargetImage = useCallback(async () => {
+    try {
+      const uri = await onSelectTargetImage();
+      if (uri) {
+        setState((prev) => ({ ...prev, targetImageUri: uri, error: null }));
+        config.onTargetImageSelect?.(uri);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      setState((prev) => ({ ...prev, error: message }));
+    }
+  }, [onSelectTargetImage, config]);
+
+  const handleProgress = useCallback((progress: number) => {
+    setState((prev) => ({ ...prev, progress }));
+  }, []);
+
+  const process = useCallback(async () => {
+    if (!state.sourceImageUri || !state.targetImageUri) return;
+
+    setState((prev) => ({
+      ...prev,
+      isProcessing: true,
+      progress: 0,
+      error: null,
+    }));
+
+    config.onProcessingStart?.();
+
+    const sourceImageBase64 = await config.prepareImage(state.sourceImageUri);
+    const targetImageBase64 = await config.prepareImage(state.targetImageUri);
+
+    const result = await executeVideoFeature(
+      featureType,
+      { sourceImageBase64, targetImageBase64 },
+      { extractResult: config.extractResult, onProgress: handleProgress },
+    );
+
+    if (result.success && result.videoUrl) {
+      setState((prev) => ({
+        ...prev,
+        isProcessing: false,
+        processedVideoUrl: result.videoUrl!,
+        progress: 100,
+      }));
+      config.onProcessingComplete?.({ success: true, videoUrl: result.videoUrl });
+    } else {
+      const errorMessage = result.error || "Processing failed";
+      setState((prev) => ({
+        ...prev,
+        isProcessing: false,
+        error: errorMessage,
+        progress: 0,
+      }));
+      config.onError?.(errorMessage);
+    }
+  }, [state.sourceImageUri, state.targetImageUri, featureType, config, handleProgress]);
+
+  const save = useCallback(async () => {
+    if (!state.processedVideoUrl) return;
+
+    try {
+      await onSaveVideo(state.processedVideoUrl);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      setState((prev) => ({ ...prev, error: message }));
+    }
+  }, [state.processedVideoUrl, onSaveVideo]);
+
+  const reset = useCallback(() => {
+    setState(initialState);
+  }, []);
+
+  return {
+    ...state,
+    selectSourceImage,
+    selectTargetImage,
+    process,
+    save,
+    reset,
+  };
+}

package/src/features/shared/index.ts

@@ -0,0 +1,6 @@
+/**
+ * Shared Features
+ * Common infrastructure for multiple feature types
+ */
+
+export * from "./dual-image-video";

package/src/infrastructure/utils/index.ts

@@ -7,6 +7,7 @@ export * from "./polling-interval.util";
 export * from "./progress-calculator.util";
 export * from "./status-checker.util";
 export * from "./result-validator.util";
+export * from "./url-extractor.util";
 export * from "./photo-generation";
 export * from "./feature-utils";
 export * from "./video-helpers";

package/src/infrastructure/utils/progress-calculator.util.ts

@@ -1,6 +1,7 @@
 /**
  * Progress Calculator Utility
  * Calculates progress based on generation stage
+ * Maps provider status to generation progress
  */
 
 import type { GenerationStatus } from "../../domain/entities";
@@ -8,6 +9,7 @@ import {
   DEFAULT_PROGRESS_STAGES,
   type ProgressStageConfig,
 } from "../../domain/entities";
+import type { AIJobStatusType } from "../../domain/interfaces/ai-provider.interface";
 
 export interface ProgressOptions {
   status: GenerationStatus;
@@ -95,3 +97,32 @@ export function createProgressTracker(stages?: ProgressStageConfig[]) {
     },
   };
 }
+
+/**
+ * Maps provider job status to generation status
+ * Provider: IN_QUEUE, IN_PROGRESS, COMPLETED, FAILED
+ * Generation: idle, preparing, submitting, generating, polling, finalizing, completed, failed
+ */
+export function mapJobStatusToGenerationStatus(
+  jobStatus: AIJobStatusType
+): GenerationStatus {
+  const statusMap: Record<AIJobStatusType, GenerationStatus> = {
+    IN_QUEUE: "submitting",
+    IN_PROGRESS: "generating",
+    COMPLETED: "completed",
+    FAILED: "failed",
+  };
+  return statusMap[jobStatus] ?? "generating";
+}
+
+/**
+ * Calculate progress from provider job status
+ * Uses default progress stages for consistent progress reporting
+ */
+export function getProgressFromJobStatus(
+  jobStatus: AIJobStatusType,
+  stages: ProgressStageConfig[] = DEFAULT_PROGRESS_STAGES
+): number {
+  const generationStatus = mapJobStatusToGenerationStatus(jobStatus);
+  return getProgressForStatus({ status: generationStatus, stages });
+}

package/src/infrastructure/utils/result-validator.util.ts

@@ -13,9 +13,7 @@ export interface ResultValidation {
 }
 
 export interface ValidateResultOptions {
-  /** Custom output field names to check */
   outputFields?: string[];
-  /** Whether empty results are allowed */
   allowEmpty?: boolean;
 }
 
@@ -44,7 +42,6 @@ export function validateResult(
   const { outputFields = DEFAULT_OUTPUT_FIELDS, allowEmpty = false } =
     options ?? {};
 
-  // Handle null/undefined
   if (result === null || result === undefined) {
     return {
       isValid: allowEmpty,
@@ -54,7 +51,6 @@ export function validateResult(
     };
   }
 
-  // Handle non-object results
   if (typeof result !== "object") {
     return {
       isValid: true,
@@ -65,7 +61,6 @@ export function validateResult(
 
   const resultObj = result as Record<string, unknown>;
 
-  // Check for error fields
   const errorValue = resultObj.error || resultObj.detail;
   const errorString = errorValue ? String(errorValue).toLowerCase() : "";
 
@@ -74,15 +69,12 @@ export function validateResult(
     errorString.includes("500") ||
     errorString === "internal server error";
 
-  // Check for empty object
   const isEmpty = Object.keys(resultObj).length === 0;
 
-  // Check for output in expected fields
   const hasOutput = outputFields.some((field) => {
     const value = resultObj[field];
     if (!value) return false;
 
-    // Handle nested output structures
     if (typeof value === "object" && value !== null) {
       const nested = value as Record<string, unknown>;
       return !!(
@@ -96,7 +88,6 @@ export function validateResult(
     return true;
   });
 
-  // Determine if result has error
   const hasError =
     hasInternalServerError || (isEmpty && !hasOutput && !allowEmpty);
 
@@ -113,213 +104,8 @@ export function validateResult(
       isValid: validation.isValid,
       hasOutput: validation.hasOutput,
       hasError: validation.hasError,
-      checkedFields: outputFields.join(", "),
     });
   }
 
   return validation;
 }
-
-/**
- * Extract output URL from result
- * Supports various AI provider response formats
- */
-export function extractOutputUrl(
-  result: unknown,
-  urlFields?: string[],
-): string | undefined {
-  if (!result || typeof result !== "object") {
-    return undefined;
-  }
-
-  const fields = urlFields ?? [
-    "url",
-    "image_url",
-    "video_url",
-    "output_url",
-    "result_url",
-  ];
-
-  const resultObj = result as Record<string, unknown>;
-
-  // Check top-level fields
-  for (const field of fields) {
-    const value = resultObj[field];
-    if (typeof value === "string" && value.length > 0) {
-      return value;
-    }
-  }
-
-  // Check nested data/output objects
-  const nested =
-    (resultObj.data as Record<string, unknown>) ||
-    (resultObj.output as Record<string, unknown>) ||
-    (resultObj.result as Record<string, unknown>);
-
-  if (nested && typeof nested === "object") {
-    for (const field of fields) {
-      const value = nested[field];
-      if (typeof value === "string" && value.length > 0) {
-        return value;
-      }
-    }
-
-    // Check for nested image/video objects
-    const media =
-      (nested.image as Record<string, unknown>) ||
-      (nested.video as Record<string, unknown>);
-    if (media && typeof media === "object" && typeof media.url === "string") {
-      return media.url;
-    }
-  }
-
-  return undefined;
-}
-
-/**
- * Extract multiple output URLs from result
- */
-export function extractOutputUrls(
-  result: unknown,
-  urlFields?: string[],
-): string[] {
-  if (!result || typeof result !== "object") {
-    return [];
-  }
-
-  const urls: string[] = [];
-  const resultObj = result as Record<string, unknown>;
-
-  // Check for arrays
-  const arrayFields = ["images", "videos", "outputs", "results", "urls"];
-  for (const field of arrayFields) {
-    const arr = resultObj[field];
-    if (Array.isArray(arr)) {
-      for (const item of arr) {
-        const url = extractOutputUrl(item, urlFields);
-        if (url) {
-          urls.push(url);
-        }
-      }
-    }
-  }
-
-  // Check nested data/output
-  const nested = resultObj.data || resultObj.output;
-  if (nested && typeof nested === "object") {
-    for (const field of arrayFields) {
-      const arr = (nested as Record<string, unknown>)[field];
-      if (Array.isArray(arr)) {
-        for (const item of arr) {
-          const url = extractOutputUrl(item, urlFields);
-          if (url) {
-            urls.push(url);
-          }
-        }
-      }
-    }
-  }
-
-  // If no array found, try single URL
-  if (urls.length === 0) {
-    const singleUrl = extractOutputUrl(result, urlFields);
-    if (singleUrl) {
-      urls.push(singleUrl);
-    }
-  }
-
-  return urls;
-}
-
-/**
- * Extract video URL from AI generation result
- */
-export function extractVideoUrl(result: unknown): string | undefined {
-  return extractOutputUrl(result, [
-    "video_url",
-    "videoUrl",
-    "video",
-    "url",
-  ]);
-}
-
-/**
- * Extract thumbnail URL from AI generation result
- */
-export function extractThumbnailUrl(result: unknown): string | undefined {
-  if (!result || typeof result !== "object") {
-    return undefined;
-  }
-
-  const resultObj = result as Record<string, unknown>;
-
-  // Check direct fields
-  const fields = ["thumbnail_url", "thumbnailUrl", "thumbnail", "poster"];
-  for (const field of fields) {
-    const value = resultObj[field];
-    if (typeof value === "string" && value.length > 0) {
-      return value;
-    }
-    if (value && typeof value === "object") {
-      const nested = value as Record<string, unknown>;
-      if (typeof nested.url === "string") {
-        return nested.url;
-      }
-    }
-  }
-
-  return undefined;
-}
-
-/**
- * Extract audio URL from AI generation result
- */
-export function extractAudioUrl(result: unknown): string | undefined {
-  return extractOutputUrl(result, [
-    "audio_url",
-    "audioUrl",
-    "audio",
-    "url",
-  ]);
-}
-
-/**
- * Extract image URLs from AI generation result
- */
-export function extractImageUrls(result: unknown): string[] {
-  if (!result || typeof result !== "object") {
-    return [];
-  }
-
-  const urls: string[] = [];
-  const resultObj = result as Record<string, unknown>;
-
-  // Check images array
-  if (Array.isArray(resultObj.images)) {
-    for (const img of resultObj.images) {
-      if (typeof img === "string" && img.length > 0) {
-        urls.push(img);
-      } else if (img && typeof img === "object") {
-        const imgObj = img as Record<string, unknown>;
-        if (typeof imgObj.url === "string") {
-          urls.push(imgObj.url);
-        }
-      }
-    }
-  }
-
-  // Check single image
-  if (urls.length === 0) {
-    const singleUrl = extractOutputUrl(result, [
-      "image_url",
-      "imageUrl",
-      "image",
-      "url",
-    ]);
-    if (singleUrl) {
-      urls.push(singleUrl);
-    }
-  }
-
-  return urls;
-}

package/src/infrastructure/utils/url-extractor.util.ts

@@ -0,0 +1,209 @@
+/**
+ * URL Extractor Utility
+ * Extracts output URLs from AI generation results
+ * Supports various provider response formats
+ */
+
+/**
+ * Extract output URL from result
+ * Supports various AI provider response formats
+ */
+export function extractOutputUrl(
+  result: unknown,
+  urlFields?: string[],
+): string | undefined {
+  if (!result || typeof result !== "object") {
+    return undefined;
+  }
+
+  const fields = urlFields ?? [
+    "url",
+    "image_url",
+    "video_url",
+    "output_url",
+    "result_url",
+  ];
+
+  const resultObj = result as Record<string, unknown>;
+
+  // Check top-level fields
+  for (const field of fields) {
+    const value = resultObj[field];
+    if (typeof value === "string" && value.length > 0) {
+      return value;
+    }
+  }
+
+  // Check nested data/output objects
+  const nested =
+    (resultObj.data as Record<string, unknown>) ||
+    (resultObj.output as Record<string, unknown>) ||
+    (resultObj.result as Record<string, unknown>);
+
+  if (nested && typeof nested === "object") {
+    for (const field of fields) {
+      const value = nested[field];
+      if (typeof value === "string" && value.length > 0) {
+        return value;
+      }
+    }
+
+    // Check for nested image/video objects
+    const media =
+      (nested.image as Record<string, unknown>) ||
+      (nested.video as Record<string, unknown>);
+    if (media && typeof media === "object" && typeof media.url === "string") {
+      return media.url;
+    }
+  }
+
+  return undefined;
+}
+
+/**
+ * Extract multiple output URLs from result
+ */
+export function extractOutputUrls(
+  result: unknown,
+  urlFields?: string[],
+): string[] {
+  if (!result || typeof result !== "object") {
+    return [];
+  }
+
+  const urls: string[] = [];
+  const resultObj = result as Record<string, unknown>;
+
+  // Check for arrays
+  const arrayFields = ["images", "videos", "outputs", "results", "urls"];
+  for (const field of arrayFields) {
+    const arr = resultObj[field];
+    if (Array.isArray(arr)) {
+      for (const item of arr) {
+        const url = extractOutputUrl(item, urlFields);
+        if (url) {
+          urls.push(url);
+        }
+      }
+    }
+  }
+
+  // Check nested data/output
+  const nested = resultObj.data || resultObj.output;
+  if (nested && typeof nested === "object") {
+    for (const field of arrayFields) {
+      const arr = (nested as Record<string, unknown>)[field];
+      if (Array.isArray(arr)) {
+        for (const item of arr) {
+          const url = extractOutputUrl(item, urlFields);
+          if (url) {
+            urls.push(url);
+          }
+        }
+      }
+    }
+  }
+
+  // If no array found, try single URL
+  if (urls.length === 0) {
+    const singleUrl = extractOutputUrl(result, urlFields);
+    if (singleUrl) {
+      urls.push(singleUrl);
+    }
+  }
+
+  return urls;
+}
+
+/**
+ * Extract video URL from AI generation result
+ */
+export function extractVideoUrl(result: unknown): string | undefined {
+  return extractOutputUrl(result, [
+    "video_url",
+    "videoUrl",
+    "video",
+    "url",
+  ]);
+}
+
+/**
+ * Extract thumbnail URL from AI generation result
+ */
+export function extractThumbnailUrl(result: unknown): string | undefined {
+  if (!result || typeof result !== "object") {
+    return undefined;
+  }
+
+  const resultObj = result as Record<string, unknown>;
+
+  // Check direct fields
+  const fields = ["thumbnail_url", "thumbnailUrl", "thumbnail", "poster"];
+  for (const field of fields) {
+    const value = resultObj[field];
+    if (typeof value === "string" && value.length > 0) {
+      return value;
+    }
+    if (value && typeof value === "object") {
+      const nested = value as Record<string, unknown>;
+      if (typeof nested.url === "string") {
+        return nested.url;
+      }
+    }
+  }
+
+  return undefined;
+}
+
+/**
+ * Extract audio URL from AI generation result
+ */
+export function extractAudioUrl(result: unknown): string | undefined {
+  return extractOutputUrl(result, [
+    "audio_url",
+    "audioUrl",
+    "audio",
+    "url",
+  ]);
+}
+
+/**
+ * Extract image URLs from AI generation result
+ */
+export function extractImageUrls(result: unknown): string[] {
+  if (!result || typeof result !== "object") {
+    return [];
+  }
+
+  const urls: string[] = [];
+  const resultObj = result as Record<string, unknown>;
+
+  // Check images array
+  if (Array.isArray(resultObj.images)) {
+    for (const img of resultObj.images) {
+      if (typeof img === "string" && img.length > 0) {
+        urls.push(img);
+      } else if (img && typeof img === "object") {
+        const imgObj = img as Record<string, unknown>;
+        if (typeof imgObj.url === "string") {
+          urls.push(imgObj.url);
+        }
+      }
+    }
+  }
+
+  // Check single image
+  if (urls.length === 0) {
+    const singleUrl = extractOutputUrl(result, [
+      "image_url",
+      "imageUrl",
+      "image",
+      "url",
+    ]);
+    if (singleUrl) {
+      urls.push(singleUrl);
+    }
+  }
+
+  return urls;
+}