@umituz/react-native-ai-generation-content 1.6.0 → 1.8.0

package/package.json

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

package/src/domain/entities/job.types.ts

@@ -42,7 +42,10 @@ export interface JobExecutorConfig<TInput = unknown, TResult = unknown> {
   readonly timeoutMs?: number;
 }
 
+export type GenerationMode = "direct" | "queued";
+
 export interface BackgroundQueueConfig {
+  readonly mode?: GenerationMode;
   readonly maxConcurrent?: number;
   readonly retryCount?: number;
   readonly retryDelayMs?: number;
@@ -50,6 +53,7 @@ export interface BackgroundQueueConfig {
 }
 
 export const DEFAULT_QUEUE_CONFIG: Required<BackgroundQueueConfig> = {
+  mode: "queued",
   maxConcurrent: 1,
   retryCount: 2,
   retryDelayMs: 2000,

package/src/index.ts

@@ -55,6 +55,7 @@ export type {
   UpdateJobInput,
   JobExecutorConfig,
   BackgroundQueueConfig,
+  GenerationMode,
 } from "./domain/entities";
 
 export { DEFAULT_POLLING_CONFIG, DEFAULT_PROGRESS_STAGES, DEFAULT_QUEUE_CONFIG } from "./domain/entities";
@@ -146,6 +147,7 @@ export type {
   UsePendingJobsReturn,
   UseBackgroundGenerationOptions,
   UseBackgroundGenerationReturn,
+  DirectExecutionResult,
 } from "./presentation/hooks";
 
 // =============================================================================

package/src/presentation/components/GenerationProgressModal.tsx

@@ -4,7 +4,13 @@
  */
 
 import React from "react";
-import { Modal, View, Text, StyleSheet } from "react-native";
+import {
+  Modal,
+  View,
+  Text,
+  TouchableOpacity,
+  StyleSheet,
+} from "react-native";
 
 export interface GenerationProgressModalProps {
   visible: boolean;
@@ -12,11 +18,14 @@ export interface GenerationProgressModalProps {
   title?: string;
   message?: string;
   hint?: string;
+  dismissLabel?: string;
+  onDismiss?: () => void;
   overlayColor?: string;
   modalBackgroundColor?: string;
   textColor?: string;
   progressColor?: string;
   progressBackgroundColor?: string;
+  dismissButtonColor?: string;
   renderContent?: (props: GenerationProgressRenderProps) => React.ReactNode;
 }
 
@@ -25,6 +34,7 @@ export interface GenerationProgressRenderProps {
   title?: string;
   message?: string;
   hint?: string;
+  onDismiss?: () => void;
 }
 
 export const GenerationProgressModal: React.FC<
@@ -35,11 +45,14 @@ export const GenerationProgressModal: React.FC<
   title,
   message,
   hint,
+  dismissLabel = "Got it",
+  onDismiss,
   overlayColor = "rgba(0, 0, 0, 0.7)",
   modalBackgroundColor = "#1C1C1E",
   textColor = "#FFFFFF",
   progressColor = "#007AFF",
   progressBackgroundColor = "#3A3A3C",
+  dismissButtonColor = "#007AFF",
   renderContent,
 }) => {
   const clampedProgress = Math.max(0, Math.min(100, progress));
@@ -53,7 +66,13 @@ export const GenerationProgressModal: React.FC<
         statusBarTranslucent
       >
         <View style={[styles.overlay, { backgroundColor: overlayColor }]}>
-          {renderContent({ progress: clampedProgress, title, message, hint })}
+          {renderContent({
+            progress: clampedProgress,
+            title,
+            message,
+            hint,
+            onDismiss,
+          })}
         </View>
       </Modal>
     );
@@ -105,6 +124,18 @@ export const GenerationProgressModal: React.FC<
           {hint && (
             <Text style={[styles.hint, { color: textColor }]}>{hint}</Text>
           )}
+
+          {onDismiss && (
+            <TouchableOpacity
+              style={[
+                styles.dismissButton,
+                { backgroundColor: dismissButtonColor },
+              ]}
+              onPress={onDismiss}
+            >
+              <Text style={styles.dismissText}>{dismissLabel}</Text>
+            </TouchableOpacity>
+          )}
         </View>
       </View>
     </Modal>
@@ -162,5 +193,19 @@ const styles = StyleSheet.create({
     textAlign: "center",
     fontStyle: "italic",
     opacity: 0.6,
+    marginBottom: 16,
+  },
+  dismissButton: {
+    marginTop: 8,
+    paddingVertical: 14,
+    paddingHorizontal: 32,
+    borderRadius: 12,
+    minWidth: 140,
+    alignItems: "center",
+  },
+  dismissText: {
+    color: "#FFFFFF",
+    fontSize: 16,
+    fontWeight: "600",
   },
 });

package/src/presentation/hooks/index.ts

@@ -18,4 +18,5 @@ export { useBackgroundGeneration } from "./use-background-generation";
 export type {
   UseBackgroundGenerationOptions,
   UseBackgroundGenerationReturn,
+  DirectExecutionResult,
 } from "./use-background-generation";

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

@@ -1,9 +1,11 @@
 /**
  * useBackgroundGeneration Hook
- * Executes AI generation tasks in the background with queue management
+ * Executes AI generation tasks with optional queue management
+ * - mode: 'direct' - Execute immediately, no queue UI (for images)
+ * - mode: 'queued' - Use pending jobs queue with UI (for videos)
  */
 
-import { useCallback, useRef } from "react";
+import { useCallback, useRef, useState } from "react";
 import { usePendingJobs } from "./use-pending-jobs";
 import type {
   BackgroundJob,
@@ -18,15 +20,27 @@ export interface UseBackgroundGenerationOptions<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 DirectExecutionResult<TResult> {
+  readonly success: boolean;
+  readonly result?: TResult;
+  readonly error?: string;
 }
 
 export interface UseBackgroundGenerationReturn<TInput, TResult> {
   readonly startJob: (input: TInput, type: string) => Promise<string>;
+  readonly executeDirectly: (
+    input: TInput,
+  ) => Promise<DirectExecutionResult<TResult>>;
   readonly cancelJob: (id: string) => void;
   readonly retryJob: (id: string) => void;
   readonly pendingJobs: BackgroundJob<TInput, TResult>[];
   readonly activeJobCount: number;
   readonly hasActiveJobs: boolean;
+  readonly isProcessing: boolean;
+  readonly progress: number;
 }
 
 export function useBackgroundGeneration<TInput = unknown, TResult = unknown>(
@@ -38,16 +52,41 @@ export function useBackgroundGeneration<TInput = unknown, TResult = unknown>(
     new Map(),
   );
 
-  const {
-    jobs,
-    addJobAsync,
-    updateJob,
-    removeJob,
-    getJob,
-  } = usePendingJobs<TInput, TResult>({
+  const [isProcessing, setIsProcessing] = useState(false);
+  const [progress, setProgress] = useState(0);
+
+  const { jobs, addJobAsync, updateJob, removeJob, getJob } = usePendingJobs<
+    TInput,
+    TResult
+  >({
     queryKey: config.queryKey,
   });
 
+  const executeDirectly = useCallback(
+    async (input: TInput): Promise<DirectExecutionResult<TResult>> => {
+      const { executor } = options;
+
+      setIsProcessing(true);
+      setProgress(0);
+
+      try {
+        const result = await executor.execute(input, (p) => {
+          setProgress(p);
+          options.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);
+      }
+    },
+    [options],
+  );
+
   const executeJob = useCallback(
     async (jobId: string, input: TInput) => {
       const { executor } = options;
@@ -58,8 +97,8 @@ export function useBackgroundGeneration<TInput = unknown, TResult = unknown>(
           updates: { status: "processing", progress: 10 },
         });
 
-        const result = await executor.execute(input, (progress) => {
-          updateJob({ id: jobId, updates: { progress } });
+        const result = await executor.execute(input, (p) => {
+          updateJob({ id: jobId, updates: { progress: p } });
         });
 
         updateJob({
@@ -84,11 +123,7 @@ export function useBackgroundGeneration<TInput = unknown, TResult = unknown>(
 
         updateJob({
           id: jobId,
-          updates: {
-            status: "failed",
-            error: errorMsg,
-            progress: 0,
-          },
+          updates: { status: "failed", error: errorMsg, progress: 0 },
         });
 
         const failedJob = getJob(jobId);
@@ -101,7 +136,6 @@ export function useBackgroundGeneration<TInput = unknown, TResult = unknown>(
         }
       } finally {
         activeJobsRef.current.delete(jobId);
-
         if (activeJobsRef.current.size === 0) {
           options.onAllComplete?.();
         }
@@ -125,7 +159,6 @@ export function useBackgroundGeneration<TInput = unknown, TResult = unknown>(
       });
 
       activeJobsRef.current.add(jobId);
-
       executeJob(jobId, input);
 
       return jobId;
@@ -146,7 +179,6 @@ export function useBackgroundGeneration<TInput = unknown, TResult = unknown>(
     (id: string) => {
       const jobData = jobInputsRef.current.get(id);
       if (!jobData) return;
-
       removeJob(id);
       startJob(jobData.input, jobData.type);
     },
@@ -155,10 +187,13 @@ export function useBackgroundGeneration<TInput = unknown, TResult = unknown>(
 
   return {
     startJob,
+    executeDirectly,
     cancelJob,
     retryJob,
     pendingJobs: jobs,
     activeJobCount: activeJobsRef.current.size,
     hasActiveJobs: activeJobsRef.current.size > 0,
+    isProcessing,
+    progress,
   };
 }