@umituz/react-native-ai-generation-content 1.61.62 → 1.61.64

package/src/domains/scenarios/presentation/containers/CategoryNavigationContainer.tsx

@@ -4,7 +4,7 @@
  * Main Category → Sub Category → Scenario List
  */
 
-import React, { useState, useCallback, useEffect } from "react";
+import React, { useState, useCallback } from "react";
 import type { ScenarioData } from "../../domain/scenario.types";
 import type { MainCategory, SubCategory } from "../../domain/category.types";
 import { MainCategoryScreen } from "../screens/MainCategoryScreen";
@@ -48,88 +48,34 @@ export const CategoryNavigationContainer: React.FC<
   const [selectedMainCategoryId, setSelectedMainCategoryId] = useState<string | null>(null);
   const [selectedSubCategoryId, setSelectedSubCategoryId] = useState<string | null>(null);
 
-  // Debug: Initial mount
-  useEffect(() => {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[CategoryNavigationContainer] Mounted", {
-        mainCategoriesCount: mainCategories.length,
-        subCategoriesCount: subCategories.length,
-        scenariosCount: scenarios.length,
-        currentStep,
-      });
-    }
-  }, []);
-
-  // Debug: Step changes
-  useEffect(() => {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[CategoryNavigationContainer] Step changed", {
-        currentStep,
-        selectedMainCategoryId,
-        selectedSubCategoryId,
-      });
-    }
-  }, [currentStep, selectedMainCategoryId, selectedSubCategoryId]);
-
   const handleSelectMainCategory = useCallback((categoryId: string) => {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[CategoryNavigationContainer] Main category selected", {
-        categoryId,
-      });
-    }
     setSelectedMainCategoryId(categoryId);
     setCurrentStep("sub_category");
-    if (onSelectMainCategory) {
-      onSelectMainCategory(categoryId);
-    }
+    onSelectMainCategory?.(categoryId);
   }, [onSelectMainCategory]);
 
   const handleSelectSubCategory = useCallback((subCategoryId: string) => {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[CategoryNavigationContainer] Sub category selected", {
-        subCategoryId,
-      });
-    }
     setSelectedSubCategoryId(subCategoryId);
     setCurrentStep("scenario_list");
-    if (onSelectSubCategory) {
-      onSelectSubCategory(subCategoryId);
-    }
+    onSelectSubCategory?.(subCategoryId);
   }, [onSelectSubCategory]);
 
   const handleBackFromSubCategory = useCallback(() => {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[CategoryNavigationContainer] Back from sub category");
-    }
     setSelectedMainCategoryId(null);
     setCurrentStep("main_category");
   }, []);
 
   const handleBackFromScenarioList = useCallback(() => {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[CategoryNavigationContainer] Back from scenario list");
-    }
     setSelectedSubCategoryId(null);
     setCurrentStep("sub_category");
   }, []);
 
-  const handleBackFromMainCategory = useCallback(() => {
-    if (onBack) {
-      onBack();
-    }
-  }, [onBack]);
-
   if (currentStep === "main_category") {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[CategoryNavigationContainer] Rendering MainCategoryScreen", {
-        mainCategoriesCount: mainCategories.length,
-      });
-    }
     return (
       <MainCategoryScreen
         mainCategories={mainCategories}
         onSelectCategory={handleSelectMainCategory}
-        onBack={onBack ? handleBackFromMainCategory : undefined}
+        onBack={onBack}
         t={t}
         headerTitle={headerTitle}
         headerDescription={headerDescription}
@@ -139,14 +85,6 @@ export const CategoryNavigationContainer: React.FC<
 
   if (currentStep === "sub_category" && selectedMainCategoryId) {
     const selectedMainCategory = mainCategories.find(c => c.id === selectedMainCategoryId);
-
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[CategoryNavigationContainer] Rendering SubCategoryScreen", {
-        selectedMainCategoryId,
-        subCategoriesCount: subCategories.length,
-        mainCategoryTitle: selectedMainCategory?.titleKey,
-      });
-    }
     return (
       <SubCategoryScreen
         mainCategoryId={selectedMainCategoryId}
@@ -161,12 +99,6 @@ export const CategoryNavigationContainer: React.FC<
   }
 
   if (currentStep === "scenario_list" && selectedSubCategoryId) {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[CategoryNavigationContainer] Rendering HierarchicalScenarioListScreen", {
-        selectedSubCategoryId,
-        scenariosCount: scenarios.length,
-      });
-    }
     return (
       <HierarchicalScenarioListScreen
         subCategoryId={selectedSubCategoryId}
@@ -181,13 +113,5 @@ export const CategoryNavigationContainer: React.FC<
     );
   }
 
-  if (typeof __DEV__ !== "undefined" && __DEV__) {
-    console.log("[CategoryNavigationContainer] Rendering NULL - no matching condition", {
-      currentStep,
-      selectedMainCategoryId,
-      selectedSubCategoryId,
-    });
-  }
-
   return null;
 };

package/src/{features → domains}/text-to-image/infrastructure/services/text-to-image-executor.ts

@@ -12,10 +12,8 @@ import type {
   TextToImageInputBuilder,
   TextToImageResultExtractor,
 } from "../../domain/types";
+import { defaultExtractImageResult, type ExtractedImageResult } from "../utils/imageResultExtractor";
 
-/**
- * Options for text-to-image execution
- */
 export interface ExecuteTextToImageOptions {
   model: string;
   buildInput: TextToImageInputBuilder;
@@ -23,84 +21,6 @@ export interface ExecuteTextToImageOptions {
   onProgress?: (progress: number) => void;
 }
 
-/**
- * Extracted result structure from provider response
- */
-interface ExtractedImageResult {
-  imageUrl?: string;
-  imageUrls?: string[];
-}
-
-/**
- * Extract images from provider response object
- */
-function extractImagesFromObject(
-  obj: Record<string, unknown>,
-): string[] | null {
-  // Direct images array
-  if (Array.isArray(obj.images)) {
-    const urls = obj.images
-      .map((img) => {
-        if (typeof img === "string") return img;
-        if (img && typeof img === "object" && "url" in img) {
-          return (img as { url: string }).url;
-        }
-        return null;
-      })
-      .filter((url): url is string => url !== null);
-
-    if (urls.length > 0) return urls;
-  }
-  return null;
-}
-
-/**
- * Default extractor for text-to-image results
- */
-function defaultExtractResult(
-  result: unknown,
-): ExtractedImageResult | undefined {
-  if (typeof result !== "object" || result === null) {
-    return undefined;
-  }
-
-  const r = result as Record<string, unknown>;
-
-  // Check nested 'data' object first (common API wrapper format)
-  if (r.data && typeof r.data === "object") {
-    const dataObj = r.data as Record<string, unknown>;
-    const urls = extractImagesFromObject(dataObj);
-    if (urls) {
-      return { imageUrl: urls[0], imageUrls: urls };
-    }
-  }
-
-  // Check direct 'images' array
-  const directUrls = extractImagesFromObject(r);
-  if (directUrls) {
-    return { imageUrl: directUrls[0], imageUrls: directUrls };
-  }
-
-  // Check for imageUrl (data URL)
-  if (typeof r.imageUrl === "string") {
-    return { imageUrl: r.imageUrl, imageUrls: [r.imageUrl] };
-  }
-
-  // Fallback: construct data URL from imageBase64
-  if (typeof r.imageBase64 === "string") {
-    const mimeType = typeof r.mimeType === "string" ? r.mimeType : "image/png";
-    const dataUrl = `data:${mimeType};base64,${r.imageBase64}`;
-    return { imageUrl: dataUrl, imageUrls: [dataUrl] };
-  }
-
-  // Check for 'image' field
-  if (typeof r.image === "string") {
-    return { imageUrl: r.image, imageUrls: [r.image] };
-  }
-
-  return undefined;
-}
-
 /**
  * Text-to-Image Executor using Template Method pattern
  * Eliminates code duplication through BaseExecutor
@@ -151,7 +71,7 @@ class TextToImageExecutor extends BaseExecutor<
   protected getDefaultExtractor(): (
     result: unknown,
   ) => ExtractedImageResult | undefined {
-    return defaultExtractResult;
+    return defaultExtractImageResult;
   }
 }
 

package/src/domains/text-to-image/infrastructure/utils/imageResultExtractor.ts

@@ -0,0 +1,58 @@
+export interface ExtractedImageResult {
+  imageUrl?: string;
+  imageUrls?: string[];
+}
+
+function extractImagesFromObject(obj: Record<string, unknown>): string[] | null {
+  if (Array.isArray(obj.images)) {
+    const urls = obj.images
+      .map((img) => {
+        if (typeof img === "string") return img;
+        if (img && typeof img === "object" && "url" in img) {
+          return (img as { url: string }).url;
+        }
+        return null;
+      })
+      .filter((url): url is string => url !== null);
+
+    if (urls.length > 0) return urls;
+  }
+  return null;
+}
+
+export function defaultExtractImageResult(result: unknown): ExtractedImageResult | undefined {
+  if (typeof result !== "object" || result === null) {
+    return undefined;
+  }
+
+  const r = result as Record<string, unknown>;
+
+  if (r.data && typeof r.data === "object") {
+    const dataObj = r.data as Record<string, unknown>;
+    const urls = extractImagesFromObject(dataObj);
+    if (urls) {
+      return { imageUrl: urls[0], imageUrls: urls };
+    }
+  }
+
+  const directUrls = extractImagesFromObject(r);
+  if (directUrls) {
+    return { imageUrl: directUrls[0], imageUrls: directUrls };
+  }
+
+  if (typeof r.imageUrl === "string") {
+    return { imageUrl: r.imageUrl, imageUrls: [r.imageUrl] };
+  }
+
+  if (typeof r.imageBase64 === "string") {
+    const mimeType = typeof r.mimeType === "string" ? r.mimeType : "image/png";
+    const dataUrl = `data:${mimeType};base64,${r.imageBase64}`;
+    return { imageUrl: dataUrl, imageUrls: [dataUrl] };
+  }
+
+  if (typeof r.image === "string") {
+    return { imageUrl: r.image, imageUrls: [r.image] };
+  }
+
+  return undefined;
+}

package/src/domains/text-to-video/presentation/hooks/textToVideoStrategy.ts

@@ -0,0 +1,75 @@
+import { executeTextToVideo } from "../../infrastructure/services";
+import type { GenerationStrategy } from "../../../../presentation/hooks/generation";
+import type {
+  TextToVideoConfig,
+  TextToVideoCallbacks,
+  TextToVideoResult,
+  TextToVideoOptions,
+  TextToVideoInputBuilder,
+  TextToVideoResultExtractor,
+} from "../../domain/types";
+
+interface VideoGenerationInput {
+  prompt: string;
+  options?: TextToVideoOptions;
+  creationId: string;
+}
+
+interface CreateStrategyParams {
+  config: TextToVideoConfig;
+  callbacks: TextToVideoCallbacks;
+  buildInput: TextToVideoInputBuilder;
+  extractResult?: TextToVideoResultExtractor;
+  userId: string;
+  currentPrompt: string;
+  creationIdRef: React.MutableRefObject<string>;
+  updateState: (videoUrl: string | null, thumbnailUrl: string | null) => void;
+}
+
+export const createTextToVideoStrategy = (
+  params: CreateStrategyParams,
+): GenerationStrategy<VideoGenerationInput, TextToVideoResult> => {
+  const { config, callbacks, buildInput, extractResult, userId, currentPrompt, creationIdRef, updateState } = params;
+
+  return {
+    execute: async (input) => {
+      creationIdRef.current = input.creationId;
+
+      callbacks.onGenerationStart?.({
+        creationId: input.creationId,
+        type: "text-to-video",
+        prompt: input.prompt,
+        metadata: input.options as Record<string, unknown> | undefined,
+      }).catch(() => {});
+
+      const result = await executeTextToVideo(
+        { prompt: input.prompt, userId, options: input.options },
+        { model: config.model, buildInput, extractResult },
+      );
+
+      if (!result.success || !result.videoUrl) {
+        throw new Error(result.error || "Generation failed");
+      }
+
+      updateState(result.videoUrl ?? null, result.thumbnailUrl ?? null);
+
+      return {
+        success: true,
+        videoUrl: result.videoUrl,
+        thumbnailUrl: result.thumbnailUrl,
+      };
+    },
+    getCreditCost: () => config.creditCost,
+    save: async (result) => {
+      if (result.success && result.videoUrl && creationIdRef.current) {
+        await callbacks.onCreationSave?.({
+          creationId: creationIdRef.current,
+          type: "text-to-video",
+          videoUrl: result.videoUrl,
+          thumbnailUrl: result.thumbnailUrl,
+          prompt: currentPrompt,
+        });
+      }
+    },
+  };
+};

package/src/domains/text-to-video/presentation/hooks/useTextToVideoFeature.ts

@@ -0,0 +1,120 @@
+import { useState, useCallback, useMemo, useRef } from "react";
+import { useGenerationOrchestrator } from "../../../../presentation/hooks/generation";
+import { DEFAULT_ALERT_MESSAGES } from "../../../../presentation/constants/alert-messages";
+import { generateCreationId } from "../../../../infrastructure/utils/id-generator.util";
+import { createTextToVideoStrategy } from "./textToVideoStrategy";
+import type {
+  TextToVideoFeatureState,
+  TextToVideoConfig,
+  TextToVideoCallbacks,
+  TextToVideoResult,
+  TextToVideoOptions,
+  TextToVideoInputBuilder,
+  TextToVideoResultExtractor,
+} from "../../domain/types";
+
+export interface UseTextToVideoFeatureProps {
+  config: TextToVideoConfig;
+  callbacks: TextToVideoCallbacks;
+  userId: string;
+  buildInput: TextToVideoInputBuilder;
+  extractResult?: TextToVideoResultExtractor;
+}
+
+export interface TextToVideoGenerateParams extends TextToVideoOptions {
+  prompt?: string;
+}
+
+export interface UseTextToVideoFeatureReturn {
+  state: TextToVideoFeatureState;
+  setPrompt: (prompt: string) => void;
+  generate: (params?: TextToVideoGenerateParams) => Promise<TextToVideoResult>;
+  reset: () => void;
+  isReady: boolean;
+  canGenerate: boolean;
+}
+
+const INITIAL_STATE: TextToVideoFeatureState = {
+  prompt: "",
+  videoUrl: null,
+  thumbnailUrl: null,
+  isProcessing: false,
+  progress: 0,
+  error: null,
+};
+
+export function useTextToVideoFeature(props: UseTextToVideoFeatureProps): UseTextToVideoFeatureReturn {
+  const { config, callbacks, userId, buildInput, extractResult } = props;
+  const [state, setState] = useState<TextToVideoFeatureState>(INITIAL_STATE);
+  const creationIdRef = useRef("");
+
+  const updateState = useCallback((videoUrl: string | null, thumbnailUrl: string | null) => {
+    setState((prev) => ({ ...prev, videoUrl, thumbnailUrl }));
+  }, []);
+
+  const strategy = useMemo(
+    () =>
+      createTextToVideoStrategy({
+        config,
+        callbacks,
+        buildInput,
+        extractResult,
+        userId,
+        currentPrompt: state.prompt,
+        creationIdRef,
+        updateState,
+      }),
+    [config, callbacks, buildInput, extractResult, userId, state.prompt, updateState],
+  );
+
+  const orchestrator = useGenerationOrchestrator(strategy, {
+    userId,
+    alertMessages: DEFAULT_ALERT_MESSAGES,
+    onCreditsExhausted: () => callbacks.onShowPaywall?.(config.creditCost),
+    onSuccess: (result) => callbacks.onGenerate?.(result as TextToVideoResult),
+    onError: (err) => callbacks.onError?.(err.message),
+  });
+
+  const setPrompt = useCallback((prompt: string) => {
+    setState((prev) => ({ ...prev, prompt, error: null }));
+  }, []);
+
+  const generate = useCallback(
+    async (params?: TextToVideoGenerateParams): Promise<TextToVideoResult> => {
+      const prompt = params?.prompt || state.prompt;
+      if (!prompt.trim()) {
+        const error = "Prompt is required";
+        setState((prev) => ({ ...prev, error }));
+        return { success: false, error };
+      }
+
+      setState((prev) => ({ ...prev, isProcessing: true, error: null, progress: 0 }));
+
+      try {
+        const result = await orchestrator.generate({
+          prompt: prompt.trim(),
+          options: params,
+          creationId: generateCreationId("text-to-video"),
+        });
+        setState((prev) => ({ ...prev, isProcessing: false }));
+        return { success: true, videoUrl: (result as TextToVideoResult)?.videoUrl };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Generation failed";
+        setState((prev) => ({ ...prev, isProcessing: false, error: message }));
+        return { success: false, error: message };
+      }
+    },
+    [state.prompt, orchestrator],
+  );
+
+  const reset = useCallback(() => setState(INITIAL_STATE), []);
+
+  return {
+    state,
+    setPrompt,
+    generate,
+    reset,
+    isReady: !orchestrator.isGenerating && !state.isProcessing,
+    canGenerate: !orchestrator.isGenerating && !state.isProcessing && state.prompt.trim().length > 0,
+  };
+}

package/src/exports/features.ts

@@ -18,7 +18,7 @@ export type {
   UseTextToImageFormOptions, UseTextToImageFormReturn,
   TextToImagePromptInputProps, TextToImageExamplePromptsProps, TextToImageStyleSelectorProps,
   TextToImageAspectRatioSelectorProps, TextToImageGenerateButtonProps, TextToImageSettingsSheetProps,
-} from "../features/text-to-image";
+} from "../domains/text-to-image";
 export {
   DEFAULT_IMAGE_STYLES, DEFAULT_NUM_IMAGES_OPTIONS, ASPECT_RATIO_VALUES, IMAGE_SIZE_VALUES,
   OUTPUT_FORMAT_VALUES, DEFAULT_FORM_VALUES, DEFAULT_TEXT_TO_IMAGE_PROMPTS, DEFAULT_TEXT_TO_VOICE_PROMPTS,
@@ -29,7 +29,7 @@ export {
   TextToImagePromptInput, TextToImageExamplePrompts, TextToImageNumImagesSelector,
   TextToImageStyleSelector, TextToImageAspectRatioSelector, TextToImageSizeSelector,
   TextToImageOutputFormatSelector, TextToImageGenerateButton, TextToImageSettingsSheet,
-} from "../features/text-to-image";
+} from "../domains/text-to-image";
 
 // Text-to-Video Feature
 export type {
@@ -45,13 +45,13 @@ export type {
   ExamplePrompt,
   UseTextToVideoFeatureProps, UseTextToVideoFeatureReturn, TextToVideoGenerateParams,
   UseTextToVideoFormProps, UseTextToVideoFormReturn, ExecuteTextToVideoOptions,
-} from "../features/text-to-video";
+} from "../domains/text-to-video";
 export {
   INITIAL_FORM_STATE, INITIAL_GENERATION_STATE,
   executeTextToVideo, hasTextToVideoSupport,
   useTextToVideoFeature, useTextToVideoForm,
   GenerationTabs, FrameSelector, OptionsPanel, HeroSection, HintCarousel,
-} from "../features/text-to-video";
+} from "../domains/text-to-video";
 
 // Image-to-Video Feature
 export type {
@@ -70,7 +70,7 @@ export type {
   ImageToVideoAnimationStyleSelectorProps, ImageToVideoDurationSelectorProps,
   ImageToVideoMusicMoodSelectorProps, ImageToVideoSelectionGridProps,
   ImageToVideoSelectionGridTranslations, ImageToVideoGenerateButtonProps,
-} from "../features/image-to-video";
+} from "../domains/image-to-video";
 export {
   IMAGE_TO_VIDEO_ANIMATION_STYLES, IMAGE_TO_VIDEO_DEFAULT_ANIMATION,
   IMAGE_TO_VIDEO_MUSIC_MOODS, IMAGE_TO_VIDEO_DEFAULT_MUSIC,
@@ -80,12 +80,12 @@ export {
   useImageToVideoFormState, useImageToVideoGeneration, useImageToVideoForm, useImageToVideoFeature,
   ImageToVideoAnimationStyleSelector, ImageToVideoDurationSelector,
   ImageToVideoMusicMoodSelector, ImageToVideoSelectionGrid, ImageToVideoGenerateButton,
-} from "../features/image-to-video";
+} from "../domains/image-to-video";
 
 // Wizard Flows
-export { TextToImageWizardFlow } from "../features/text-to-image/presentation/screens/TextToImageWizardFlow";
-export type { TextToImageWizardFlowProps } from "../features/text-to-image/presentation/screens/TextToImageWizardFlow";
-export { TextToVideoWizardFlow } from "../features/text-to-video/presentation/screens/TextToVideoWizardFlow";
-export type { TextToVideoWizardFlowProps } from "../features/text-to-video/presentation/screens/TextToVideoWizardFlow";
-export { ImageToVideoWizardFlow } from "../features/image-to-video/presentation/screens/ImageToVideoWizardFlow";
-export type { ImageToVideoWizardFlowProps } from "../features/image-to-video/presentation/screens/ImageToVideoWizardFlow";
+export { TextToImageWizardFlow } from "../domains/text-to-image/presentation/screens/TextToImageWizardFlow";
+export type { TextToImageWizardFlowProps } from "../domains/text-to-image/presentation/screens/TextToImageWizardFlow";
+export { TextToVideoWizardFlow } from "../domains/text-to-video/presentation/screens/TextToVideoWizardFlow";
+export type { TextToVideoWizardFlowProps } from "../domains/text-to-video/presentation/screens/TextToVideoWizardFlow";
+export { ImageToVideoWizardFlow } from "../domains/image-to-video/presentation/screens/ImageToVideoWizardFlow";
+export type { ImageToVideoWizardFlowProps } from "../domains/image-to-video/presentation/screens/ImageToVideoWizardFlow";

package/src/presentation/components/PendingJobCard.tsx

@@ -6,7 +6,7 @@
 import React from "react";
 import { View, StyleSheet } from "react-native";
 import { AtomicText, AtomicSpinner, useAppDesignTokens } from "@umituz/react-native-design-system";
-import type { BackgroundJob } from "../../domain/entities/job.types";
+import type { BackgroundJob } from "../../domains/background/domain/entities/job.types";
 import { PendingJobProgressBar } from "./PendingJobProgressBar";
 import { PendingJobCardActions } from "./PendingJobCardActions";