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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-generation-content",
-  "version": "1.61.63",
+  "version": "1.61.64",
   "description": "Provider-agnostic AI generation orchestration for React Native with result preview components",
   "main": "src/index.ts",
   "types": "src/index.ts",

package/src/core/index.ts

@@ -57,7 +57,7 @@ export type {
 // Segregated provider sub-interfaces
 export type { IAIProviderLifecycle } from "../domain/interfaces/provider-lifecycle.interface";
 export type { IAIProviderCapabilities } from "../domain/interfaces/provider-capabilities.interface";
-export type { IAIProviderJobManager } from "../domain/interfaces/provider-job-manager.interface";
+export type { IAIProviderJobManager } from "../domains/background/domain/interfaces/provider-job-manager.interface";
 export type { IAIProviderExecutor } from "../domain/interfaces/provider-executor.interface";
 export type { IAIProviderImageFeatures } from "../domain/interfaces/provider-image-features.interface";
 export type { IAIProviderVideoFeatures } from "../domain/interfaces/provider-video-features.interface";

package/src/domain/entities/index.ts

@@ -6,6 +6,6 @@
 export * from "./error.types";
 export * from "./generation.types";
 export * from "./polling.types";
-export * from "./job.types";
+export * from "../../domains/background/domain/entities/job.types";
 export * from "./processing-modes.types";
 export * from "./flow-config.types";

package/src/domain/interfaces/ai-provider.interface.ts

@@ -155,7 +155,7 @@ export interface VideoFeatureInputData {
 
 import type { IAIProviderLifecycle } from "./provider-lifecycle.interface";
 import type { IAIProviderCapabilities } from "./provider-capabilities.interface";
-import type { IAIProviderJobManager } from "./provider-job-manager.interface";
+import type { IAIProviderJobManager } from "../../domains/background/domain/interfaces/provider-job-manager.interface";
 import type { IAIProviderExecutor } from "./provider-executor.interface";
 import type { IAIProviderImageFeatures } from "./provider-image-features.interface";
 import type { IAIProviderVideoFeatures } from "./provider-video-features.interface";

package/src/domain/interfaces/index.ts

@@ -9,7 +9,7 @@ export * from "./app-services.interface";
 // Interface Segregation - Split provider interfaces
 export type { IAIProviderLifecycle } from "./provider-lifecycle.interface";
 export type { IAIProviderCapabilities } from "./provider-capabilities.interface";
-export type { IAIProviderJobManager } from "./provider-job-manager.interface";
+export type { IAIProviderJobManager } from "../../domains/background/domain/interfaces/provider-job-manager.interface";
 export type { IAIProviderExecutor } from "./provider-executor.interface";
 export type { IAIProviderImageFeatures } from "./provider-image-features.interface";
 export type { IAIProviderVideoFeatures } from "./provider-video-features.interface";

package/src/domains/background/domain/entities/index.ts

@@ -0,0 +1 @@
+export * from "./job.types";

package/src/domains/background/domain/interfaces/index.ts

@@ -0,0 +1 @@
+export * from "./provider-job-manager.interface";

package/src/{domain → domains/background/domain}/interfaces/provider-job-manager.interface.ts

@@ -3,7 +3,7 @@
  * Single Responsibility: Async job submission, status checking, and result retrieval
  */
 
-import type { JobSubmission, JobStatus } from "./ai-provider.interface";
+import type { JobSubmission, JobStatus } from "../../../../domain/interfaces/ai-provider.interface";
 
 export interface IAIProviderJobManager {
   /**

package/src/domains/background/domain/types/background-generation.types.ts

@@ -0,0 +1,28 @@
+import type {
+  BackgroundJob,
+  BackgroundQueueConfig,
+  JobExecutorConfig,
+} from "../entities/job.types";
+import type { executeDirectGeneration } from "../../infrastructure/executors/backgroundJobExecutor";
+
+export type { DirectExecutionResult } from "../../infrastructure/executors/backgroundJobExecutor";
+
+export interface UseBackgroundGenerationOptions<TInput, TResult>
+  extends Partial<BackgroundQueueConfig> {
+  readonly executor: JobExecutorConfig<TInput, TResult>;
+  readonly onJobComplete?: (job: BackgroundJob<TInput, TResult>) => void;
+  readonly onJobError?: (job: BackgroundJob<TInput, TResult>) => void;
+  readonly onAllComplete?: () => void;
+  readonly onProgress?: (progress: number) => void;
+}
+
+export interface UseBackgroundGenerationReturn<TInput, TResult> {
+  readonly startJob: (input: TInput, type: string) => Promise<string>;
+  readonly executeDirectly: (input: TInput) => ReturnType<typeof executeDirectGeneration<TInput, TResult>>;
+  readonly cancelJob: (id: string) => void;
+  readonly pendingJobs: BackgroundJob<TInput, TResult>[];
+  readonly activeJobCount: number;
+  readonly hasActiveJobs: boolean;
+  readonly isProcessing: boolean;
+  readonly progress: number;
+}

package/src/domains/background/infrastructure/executors/backgroundJobExecutor.ts

@@ -0,0 +1,105 @@
+import type { BackgroundJob, JobExecutorConfig } from "../../domain/entities/job.types";
+
+export interface DirectExecutionResult<TResult> {
+  readonly success: boolean;
+  readonly result?: TResult;
+  readonly error?: string;
+}
+
+interface DirectExecutionParams<TInput, TResult> {
+  input: TInput;
+  executor: JobExecutorConfig<TInput, TResult>;
+  onProgress?: (progress: number) => void;
+  setProgress: (progress: number) => void;
+  setIsProcessing: (isProcessing: boolean) => void;
+}
+
+export const executeDirectGeneration = async <TInput, TResult>(
+  params: DirectExecutionParams<TInput, TResult>,
+): Promise<DirectExecutionResult<TResult>> => {
+  const { input, executor, onProgress, setProgress, setIsProcessing } = params;
+
+  setIsProcessing(true);
+  setProgress(0);
+
+  try {
+    const result = await executor.execute(input, (p) => {
+      setProgress(p);
+      onProgress?.(p);
+    });
+
+    setProgress(100);
+    return { success: true, result };
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    return { success: false, error: errorMsg };
+  } finally {
+    setIsProcessing(false);
+  }
+};
+
+interface QueuedExecutionParams<TInput, TResult> {
+  jobId: string;
+  input: TInput;
+  executor: JobExecutorConfig<TInput, TResult>;
+  updateJob: (params: { id: string; updates: Partial<BackgroundJob<TInput, TResult>> }) => void;
+  removeJob: (id: string) => void;
+  getJob: (id: string) => BackgroundJob<TInput, TResult> | undefined;
+  activeJobsRef: React.MutableRefObject<Set<string>>;
+  onJobComplete?: (job: BackgroundJob<TInput, TResult>) => void;
+  onJobError?: (job: BackgroundJob<TInput, TResult>) => void;
+  onAllComplete?: () => void;
+}
+
+export const executeQueuedJob = async <TInput, TResult>(
+  params: QueuedExecutionParams<TInput, TResult>,
+): Promise<void> => {
+  const {
+    jobId,
+    input,
+    executor,
+    updateJob,
+    removeJob,
+    getJob,
+    activeJobsRef,
+    onJobComplete,
+    onJobError,
+    onAllComplete,
+  } = params;
+
+  try {
+    updateJob({ id: jobId, updates: { status: "processing", progress: 10 } });
+
+    const result = await executor.execute(input, (p) => {
+      updateJob({ id: jobId, updates: { progress: p } });
+    });
+
+    updateJob({
+      id: jobId,
+      updates: { status: "completed", progress: 100, result, completedAt: new Date() },
+    });
+
+    const completedJob = getJob(jobId);
+    if (completedJob) {
+      await executor.onComplete?.(completedJob);
+      onJobComplete?.(completedJob);
+    }
+
+    removeJob(jobId);
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+
+    updateJob({ id: jobId, updates: { status: "failed", error: errorMsg, progress: 0 } });
+
+    const failedJob = getJob(jobId);
+    if (failedJob) {
+      await executor.onError?.(failedJob, error instanceof Error ? error : new Error(errorMsg));
+      onJobError?.(failedJob);
+    }
+  } finally {
+    activeJobsRef.current.delete(jobId);
+    if (activeJobsRef.current.size === 0) {
+      onAllComplete?.();
+    }
+  }
+};

package/src/{infrastructure → domains/background/infrastructure}/services/job-poller-factory.ts

@@ -3,7 +3,7 @@
  * Creates pre-configured job poller instances
  */
 
-import type { PollingConfig } from "../../domain/entities";
+import type { PollingConfig } from "../../../../domain/entities/polling.types";
 import type { PollJobOptions } from "./job-poller.types";
 import { pollJob } from "./job-poller.service";
 

package/src/{infrastructure → domains/background/infrastructure}/services/job-poller.service.ts

@@ -4,7 +4,7 @@
  * Reports only real status - no fake progress
  */
 
-import { DEFAULT_POLLING_CONFIG } from "../../domain/entities";
+import { DEFAULT_POLLING_CONFIG } from "../../../../domain/entities/polling.types";
 import { calculatePollingInterval } from "../utils/polling-interval.util";
 import { checkStatusForErrors, isJobComplete } from "../utils/status-checker.util";
 import { validateResult } from "../utils/result-validator.util";

package/src/{infrastructure → domains/background/infrastructure}/services/job-poller.types.ts

@@ -2,8 +2,8 @@
  * Job Poller Type Definitions
  */
 
-import type { IAIProvider, JobStatus } from "../../domain/interfaces";
-import type { PollingConfig } from "../../domain/entities";
+import type { IAIProvider, JobStatus } from "../../../../domain/interfaces/ai-provider.interface";
+import type { PollingConfig } from "../../../../domain/entities/polling.types";
 
 export interface PollJobOptions {
   provider: IAIProvider;

package/src/{infrastructure → domains/background/infrastructure}/utils/polling-interval.util.ts

@@ -6,7 +6,7 @@
 import {
   DEFAULT_POLLING_CONFIG,
   type PollingConfig,
-} from "../../domain/entities";
+} from "../../../../domain/entities/polling.types";
 
 export interface IntervalOptions {
   attempt: number;

package/src/{infrastructure → domains/background/infrastructure}/utils/status-checker.util.ts

@@ -3,7 +3,7 @@
  * Checks job status responses for errors
  */
 
-import type { JobStatus, AILogEntry } from "../../domain/interfaces";
+import type { JobStatus, AILogEntry } from "../../../../domain/interfaces/ai-provider.interface";
 
 export interface StatusCheckResult {
   status: string;

package/src/domains/background/presentation/hooks/use-background-generation.ts

@@ -0,0 +1,97 @@
+import { useCallback, useRef, useState } from "react";
+import { usePendingJobs } from "./use-pending-jobs";
+import { executeDirectGeneration, executeQueuedJob } from "../../infrastructure/executors/backgroundJobExecutor";
+import { DEFAULT_QUEUE_CONFIG } from "../../domain/entities/job.types";
+import type {
+  UseBackgroundGenerationOptions,
+  UseBackgroundGenerationReturn,
+} from "../../domain/types/background-generation.types";
+
+export type { DirectExecutionResult, UseBackgroundGenerationOptions, UseBackgroundGenerationReturn } from "../../domain/types/background-generation.types";
+
+export function useBackgroundGeneration<TInput = unknown, TResult = unknown>(
+  options: UseBackgroundGenerationOptions<TInput, TResult>,
+): UseBackgroundGenerationReturn<TInput, TResult> {
+  const config = { ...DEFAULT_QUEUE_CONFIG, ...options };
+  const activeJobsRef = useRef<Set<string>>(new Set());
+  const jobInputsRef = useRef<Map<string, { input: TInput; type: string }>>(
+    new Map(),
+  );
+
+  const [isProcessing, setIsProcessing] = useState(false);
+  const [progress, setProgress] = useState(0);
+
+  const { jobs, addJobAsync, updateJob, removeJob, getJob } = usePendingJobs<
+    TInput,
+    TResult
+  >({
+    queryKey: config.queryKey,
+  });
+
+  const { executor, onProgress, onJobComplete, onJobError, onAllComplete } = options;
+
+  const executeDirectly = useCallback(
+    (input: TInput) =>
+      executeDirectGeneration({ input, executor, onProgress, setProgress, setIsProcessing }),
+    [executor, onProgress],
+  );
+
+  const executeJob = useCallback(
+    (jobId: string, input: TInput) =>
+      executeQueuedJob({
+        jobId,
+        input,
+        executor,
+        updateJob,
+        removeJob,
+        getJob,
+        activeJobsRef,
+        onJobComplete,
+        onJobError,
+        onAllComplete,
+      }),
+    [executor, onJobComplete, onJobError, onAllComplete, updateJob, removeJob, getJob],
+  );
+
+  const startJob = useCallback(
+    async (input: TInput, type: string): Promise<string> => {
+      const jobId = `job-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+
+      jobInputsRef.current.set(jobId, { input, type });
+
+      await addJobAsync({
+        id: jobId,
+        input,
+        type,
+        status: "queued",
+        progress: 0,
+      });
+
+      activeJobsRef.current.add(jobId);
+      void executeJob(jobId, input);
+
+      return jobId;
+    },
+    [addJobAsync, executeJob],
+  );
+
+  const cancelJob = useCallback(
+    (id: string) => {
+      activeJobsRef.current.delete(id);
+      jobInputsRef.current.delete(id);
+      removeJob(id);
+    },
+    [removeJob],
+  );
+
+  return {
+    startJob,
+    executeDirectly,
+    cancelJob,
+    pendingJobs: jobs,
+    activeJobCount: activeJobsRef.current.size,
+    hasActiveJobs: activeJobsRef.current.size > 0,
+    isProcessing,
+    progress,
+  };
+}

package/src/domains/creations/presentation/components/PendingJobsSection.tsx

@@ -6,7 +6,7 @@
 import React from "react";
 import { View, StyleSheet } from "react-native";
 import { AtomicText, useAppDesignTokens } from "@umituz/react-native-design-system";
-import type { BackgroundJob } from "../../../../domain/entities/job.types";
+import type { BackgroundJob } from "../../../background/domain/entities/job.types";
 import { PendingJobCard } from "../../../../presentation/components/PendingJobCard";
 
 export interface PendingJobsSectionProps {

package/src/domains/image-to-video/presentation/hooks/imageToVideoStrategy.ts

@@ -0,0 +1,77 @@
+import { executeImageToVideo } from "../../infrastructure/services";
+import type { GenerationStrategy } from "../../../../presentation/hooks/generation";
+import type {
+  ImageToVideoConfig,
+  ImageToVideoCallbacks,
+  ImageToVideoResult,
+  ImageToVideoOptions,
+  ImageToVideoInputBuilder,
+  ImageToVideoResultExtractor,
+} from "../../domain/types";
+
+interface VideoGenerationInput {
+  imageUrl: string;
+  prompt: string;
+  options?: ImageToVideoOptions;
+  creationId: string;
+}
+
+interface CreateStrategyParams {
+  config: ImageToVideoConfig;
+  callbacks: ImageToVideoCallbacks;
+  buildInput: ImageToVideoInputBuilder;
+  extractResult?: ImageToVideoResultExtractor;
+  userId: string;
+  currentPrompt: string;
+  creationIdRef: React.MutableRefObject<string>;
+  updateState: (videoUrl: string | null, thumbnailUrl: string | null) => void;
+}
+
+export const createImageToVideoStrategy = (
+  params: CreateStrategyParams,
+): GenerationStrategy<VideoGenerationInput, ImageToVideoResult> => {
+  const { config, callbacks, buildInput, extractResult, userId, currentPrompt, creationIdRef, updateState } = params;
+
+  return {
+    execute: async (input) => {
+      creationIdRef.current = input.creationId;
+
+      callbacks.onGenerationStart?.({
+        creationId: input.creationId,
+        type: "image-to-video",
+        imageUrl: input.imageUrl,
+        prompt: input.prompt,
+        metadata: input.options as Record<string, unknown> | undefined,
+      }).catch(() => {});
+
+      const result = await executeImageToVideo(
+        { imageUrl: input.imageUrl, 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: "image-to-video",
+          videoUrl: result.videoUrl,
+          thumbnailUrl: result.thumbnailUrl,
+          prompt: currentPrompt,
+        });
+      }
+    },
+  };
+};

package/src/domains/image-to-video/presentation/hooks/useImageToVideoFeature.ts

@@ -0,0 +1,102 @@
+import { useState, useCallback, useMemo, useRef } from "react";
+import { useGenerationOrchestrator } from "../../../../presentation/hooks/generation";
+import { createImageToVideoStrategy } from "./imageToVideoStrategy";
+import type {
+  UseImageToVideoFeatureProps,
+  UseImageToVideoFeatureReturn,
+  INITIAL_STATE,
+  DEFAULT_ALERT_MESSAGES,
+} from "./image-to-video-feature.types";
+
+export type {
+  UseImageToVideoFeatureProps,
+  UseImageToVideoFeatureReturn,
+} from "./image-to-video-feature.types";
+
+export function useImageToVideoFeature(props: UseImageToVideoFeatureProps): UseImageToVideoFeatureReturn {
+  const { config, callbacks, userId } = props;
+  const [state, setState] = useState(INITIAL_STATE);
+  const creationIdRef = useRef("");
+
+  const updateState = useCallback((videoUrl: string | null, thumbnailUrl: string | null) => {
+    setState((prev) => ({ ...prev, videoUrl, thumbnailUrl }));
+  }, []);
+
+  const strategy = useMemo(
+    () =>
+      createImageToVideoStrategy({
+        config,
+        callbacks,
+        buildInput: config.buildInput,
+        extractResult: config.extractResult,
+        userId,
+        currentPrompt: state.motionPrompt || "",
+        creationIdRef,
+        updateState,
+      }),
+    [config, callbacks, userId, state.motionPrompt, updateState],
+  );
+
+  const orchestrator = useGenerationOrchestrator(strategy, {
+    userId,
+    alertMessages: DEFAULT_ALERT_MESSAGES,
+    onCreditsExhausted: () => callbacks.onShowPaywall?.(config.creditCost ?? 0),
+    onSuccess: (result) => {
+      config.onProcessingComplete?.();
+      callbacks.onGenerate?.(result);
+    },
+    onError: (err) => {
+      config.onProcessingError?.(err.message);
+      callbacks.onError?.(err.message);
+    },
+  });
+
+  const setImageUri = useCallback((imageUri: string) => {
+    setState((prev) => ({ ...prev, imageUri, error: null }));
+  }, []);
+
+  const setMotionPrompt = useCallback((motionPrompt: string) => {
+    setState((prev) => ({ ...prev, motionPrompt, error: null }));
+  }, []);
+
+  const generate = useCallback(
+    async (params?: any) => {
+      const imageUri = params?.imageUri || state.imageUri;
+      if (!imageUri) {
+        const error = "Image is required";
+        setState((prev) => ({ ...prev, error }));
+        return { success: false, error };
+      }
+
+      setState((prev) => ({ ...prev, isProcessing: true, error: null }));
+
+      try {
+        const result = await orchestrator.generate({
+          imageUrl: imageUri,
+          prompt: state.motionPrompt || "",
+          options: params,
+          creationId: `image-to-video-${Date.now()}`,
+        });
+        setState((prev) => ({ ...prev, isProcessing: false }));
+        return result;
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Generation failed";
+        setState((prev) => ({ ...prev, isProcessing: false, error: message }));
+        return { success: false, error: message };
+      }
+    },
+    [state.imageUri, state.motionPrompt, orchestrator],
+  );
+
+  const reset = useCallback(() => setState(INITIAL_STATE), []);
+
+  return {
+    state,
+    setImageUri,
+    setMotionPrompt,
+    generate,
+    reset,
+    isReady: !orchestrator.isGenerating && !state.isProcessing,
+    canGenerate: !orchestrator.isGenerating && !state.isProcessing && !!state.imageUri,
+  };
+}