@umituz/react-native-ai-generation-content 1.27.10 → 1.27.12

package/package.json

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

package/src/domain/entities/flow-config.types.ts

@@ -5,17 +5,39 @@
 
 /** Step Types */
 export enum StepType {
+  // Gate steps - auth and credits check
+  AUTH_GATE = "auth_gate",
+  CREDIT_GATE = "credit_gate",
+  // Content steps
   CATEGORY_SELECTION = "category_selection",
   SCENARIO_SELECTION = "scenario_selection",
   SCENARIO_PREVIEW = "scenario_preview",
   PARTNER_UPLOAD = "partner_upload",
   TEXT_INPUT = "text_input",
   FEATURE_SELECTION = "feature_selection",
+  // Generation steps
   GENERATING = "generating",
   RESULT_PREVIEW = "result_preview",
   CUSTOM = "custom",
 }
 
+/** Gate Step Result */
+export type GateResult = "passed" | "blocked" | "pending";
+
+/** Auth Gate Configuration */
+export interface AuthGateConfig {
+  readonly allowAnonymous?: boolean;
+  readonly onAuthRequired?: () => void;
+  readonly onAuthSuccess?: () => void;
+}
+
+/** Credit Gate Configuration */
+export interface CreditGateConfig {
+  readonly requiredCredits: number;
+  readonly onCreditsExhausted?: () => void;
+  readonly onCreditsAvailable?: () => void;
+}
+
 /** Partner Configuration */
 export interface PartnerConfig {
   readonly partnerId: "A" | "B" | "single";

package/src/domains/generation/domain/feature-config.types.ts

@@ -7,11 +7,18 @@
 // Feature Type Enums
 // ============================================================================
 
-export type GenerationType = "image" | "video" | "meme";
+export type GenerationType =
+  | "image"
+  | "video"
+  | "text-to-image"
+  | "text-to-video"
+  | "image-to-video"
+  | "meme";
 
 export type InputType =
   | "single-photo"
   | "two-photos"
+  | "text-only"
   | "text"
   | "photo-text"
   | "photo-photo-text";

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

@@ -33,6 +33,22 @@ export interface ImageGenerationInput {
   outputFormat?: "jpeg" | "png" | "webp";
 }
 
+export interface TextToImageInput {
+  prompt: string;
+  negativePrompt?: string;
+  aspectRatio?: string;
+  size?: string;
+  numImages?: number;
+  guidanceScale?: number;
+  style?: string;
+  outputFormat?: "jpeg" | "png" | "webp";
+}
+
+export interface TextToImageOutput {
+  imageUrl: string;
+  imageUrls: string[];
+}
+
 export interface VideoGenerationInput {
   sourceImageBase64: string;
   targetImageBase64?: string;

package/src/domains/generation/index.ts

@@ -27,7 +27,24 @@ export type {
   VideoGenerationOutput,
   MemeGenerationInput,
   MemeGenerationOutput,
+  TextToImageInput,
+  TextToImageOutput,
 } from "./domain/generation.types";
 
+export { ExecutorFactory, type GenerationType as ExecutorGenerationType } from "./infrastructure/executors/executor-factory";
+
 export * from "./wizard";
 export * from "./infrastructure/flow";
+
+// Flow config types from domain
+export {
+  StepType,
+  type GateResult,
+  type AuthGateConfig,
+  type CreditGateConfig,
+  type FlowState,
+  type FlowActions,
+  type FlowCallbacks,
+  type FlowConfiguration,
+  type StepDefinition,
+} from "../../domain/entities/flow-config.types";

package/src/domains/generation/infrastructure/executors/executor-factory.ts

@@ -6,10 +6,11 @@
 import type { GenerationExecutor } from "../../domain/generation.types";
 import { ImageExecutor } from "./image-executor";
 import { VideoExecutor } from "./video-executor";
+import { TextToImageExecutor } from "./text-to-image-executor";
 
 declare const __DEV__: boolean;
 
-type GenerationType = "image" | "video" | "meme";
+export type GenerationType = "image" | "video" | "text-to-image" | "text-to-video" | "image-to-video" | "meme";
 
 export class ExecutorFactory {
   private static executors = new Map<
@@ -27,7 +28,12 @@ export class ExecutorFactory {
         case "image":
           this.executors.set(type, new ImageExecutor());
           break;
+        case "text-to-image":
+          this.executors.set(type, new TextToImageExecutor());
+          break;
         case "video":
+        case "text-to-video":
+        case "image-to-video":
           this.executors.set(type, new VideoExecutor());
           break;
         case "meme":

package/src/domains/generation/infrastructure/executors/text-to-image-executor.ts

@@ -0,0 +1,173 @@
+/**
+ * Text-to-Image Executor
+ * Uses provider.run() for quick prompt-based image generation
+ */
+
+import type {
+  GenerationExecutor,
+  GenerationOptions,
+  GenerationResult,
+} from "../../domain/generation.types";
+import { providerRegistry } from "../../../../infrastructure/services/provider-registry.service";
+
+declare const __DEV__: boolean;
+
+export interface TextToImageInput {
+  prompt: string;
+  negativePrompt?: string;
+  aspectRatio?: string;
+  size?: string;
+  numImages?: number;
+  guidanceScale?: number;
+  style?: string;
+  outputFormat?: "jpeg" | "png" | "webp";
+}
+
+export interface TextToImageOutput {
+  imageUrl: string;
+  imageUrls: string[];
+}
+
+export class TextToImageExecutor
+  implements GenerationExecutor<TextToImageInput, TextToImageOutput>
+{
+  async generate(
+    model: string,
+    input: TextToImageInput,
+    options?: GenerationOptions,
+  ): Promise<GenerationResult<TextToImageOutput>> {
+    try {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[TextToImageExecutor] Starting", {
+          model,
+          promptLength: input.prompt?.length || 0,
+          aspectRatio: input.aspectRatio,
+          numImages: input.numImages,
+        });
+      }
+
+      const provider = providerRegistry.getActiveProvider();
+
+      if (!provider?.isInitialized()) {
+        return { success: false, error: "AI provider not initialized" };
+      }
+
+      if (!input.prompt?.trim()) {
+        return { success: false, error: "Prompt is required" };
+      }
+
+      options?.onProgress?.(10);
+
+      const modelInput = this.buildModelInput(input);
+      options?.onProgress?.(20);
+
+      const result = await provider.run(model, modelInput);
+      options?.onProgress?.(90);
+
+      const extracted = this.extractResult(result);
+      options?.onProgress?.(100);
+
+      if (!extracted?.imageUrl) {
+        return { success: false, error: "No image in response" };
+      }
+
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[TextToImageExecutor] Success", {
+          imageCount: extracted.imageUrls.length,
+        });
+      }
+
+      return { success: true, data: extracted };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.error("[TextToImageExecutor] Error:", message);
+      }
+
+      return { success: false, error: message };
+    }
+  }
+
+  private buildModelInput(input: TextToImageInput): Record<string, unknown> {
+    const {
+      prompt,
+      negativePrompt,
+      aspectRatio,
+      size,
+      numImages,
+      guidanceScale,
+      style,
+      outputFormat,
+    } = input;
+
+    let finalPrompt = prompt;
+    if (style && style !== "none") {
+      finalPrompt = `${prompt}, ${style} style`;
+    }
+
+    return {
+      prompt: finalPrompt,
+      ...(negativePrompt && { negative_prompt: negativePrompt }),
+      ...(aspectRatio && { aspect_ratio: aspectRatio }),
+      ...(size && { image_size: size }),
+      ...(numImages && { num_images: numImages }),
+      ...(guidanceScale && { guidance_scale: guidanceScale }),
+      ...(outputFormat && { output_format: outputFormat }),
+    };
+  }
+
+  private extractResult(
+    result: unknown,
+  ): { imageUrl: string; imageUrls: string[] } | undefined {
+    if (typeof result !== "object" || result === null) {
+      return undefined;
+    }
+
+    const r = result as Record<string, unknown>;
+
+    // Check nested 'data' object
+    if (r.data && typeof r.data === "object") {
+      const urls = this.extractImagesFromObject(r.data as Record<string, unknown>);
+      if (urls.length > 0) {
+        return { imageUrl: urls[0], imageUrls: urls };
+      }
+    }
+
+    // Check direct images array
+    const directUrls = this.extractImagesFromObject(r);
+    if (directUrls.length > 0) {
+      return { imageUrl: directUrls[0], imageUrls: directUrls };
+    }
+
+    // Check for imageUrl
+    if (typeof r.imageUrl === "string") {
+      return { imageUrl: r.imageUrl, imageUrls: [r.imageUrl] };
+    }
+
+    // Fallback: base64
+    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] };
+    }
+
+    return undefined;
+  }
+
+  private extractImagesFromObject(obj: Record<string, unknown>): string[] {
+    if (!Array.isArray(obj.images)) {
+      return [];
+    }
+
+    return 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);
+  }
+}

package/src/domains/generation/wizard/domain/entities/wizard-config.types.ts

@@ -72,10 +72,32 @@ export interface PreviewStepConfig extends BaseStepConfig {
   readonly showContinueButton?: boolean;
 }
 
+/**
+ * Auth Gate Step Configuration
+ * Blocks flow if user is not authenticated
+ */
+export interface AuthGateStepConfig extends BaseStepConfig {
+  readonly type: "auth_gate";
+  readonly allowAnonymous?: boolean;
+  readonly messageKey?: string;
+}
+
+/**
+ * Credit Gate Step Configuration
+ * Blocks flow if user doesn't have enough credits
+ */
+export interface CreditGateStepConfig extends BaseStepConfig {
+  readonly type: "credit_gate";
+  readonly requiredCredits: number;
+  readonly messageKey?: string;
+}
+
 /**
  * Union of all step config types
  */
 export type WizardStepConfig =
+  | AuthGateStepConfig
+  | CreditGateStepConfig
   | PhotoUploadStepConfig
   | TextInputStepConfig
   | SelectionStepConfig

package/src/domains/generation/wizard/index.ts

@@ -7,6 +7,8 @@
 // Domain Entities - Configuration Types
 export type {
   BaseStepConfig,
+  AuthGateStepConfig,
+  CreditGateStepConfig,
   PhotoUploadStepConfig,
   TextInputStepConfig,
   SelectionStepConfig,

package/src/domains/generation/wizard/presentation/hooks/useGateStep.ts

@@ -0,0 +1,138 @@
+/**
+ * useGateStep Hook
+ * Handles auth and credit gate steps in wizard flow
+ *
+ * Gates are "invisible" steps that:
+ * - Auto-advance when condition is met
+ * - Show modal/paywall when blocked
+ * - Never show UI themselves
+ */
+
+import { useEffect, useRef, useCallback } from "react";
+import type { GateResult } from "../../../../../domain/entities/flow-config.types";
+
+declare const __DEV__: boolean;
+
+export interface GateCallbacks {
+  /** Called when auth is required - should show auth modal */
+  readonly onAuthRequired?: () => void;
+  /** Called when credits are exhausted - should show paywall */
+  readonly onCreditsExhausted?: () => void;
+  /** Called when gate passes - auto advance to next step */
+  readonly onGatePassed?: () => void;
+}
+
+export interface AuthGateState {
+  readonly isAuthenticated: boolean;
+  readonly isAnonymous: boolean;
+  readonly userId: string | null;
+}
+
+export interface CreditGateState {
+  readonly creditBalance: number;
+  readonly requiredCredits: number;
+}
+
+export interface UseGateStepProps {
+  readonly gateType: "auth" | "credit";
+  readonly authState?: AuthGateState;
+  readonly creditState?: CreditGateState;
+  readonly callbacks: GateCallbacks;
+  readonly allowAnonymous?: boolean;
+}
+
+export interface UseGateStepReturn {
+  readonly gateResult: GateResult;
+  readonly checkGate: () => GateResult;
+}
+
+/**
+ * Hook to manage gate step logic
+ * Automatically triggers callbacks and advances when conditions are met
+ */
+export function useGateStep(props: UseGateStepProps): UseGateStepReturn {
+  const { gateType, authState, creditState, callbacks, allowAnonymous = false } = props;
+
+  const hasChecked = useRef(false);
+
+  const checkAuthGate = useCallback((): GateResult => {
+    if (!authState) return "pending";
+
+    const { isAuthenticated, isAnonymous, userId } = authState;
+
+    // Allow anonymous if configured
+    if (allowAnonymous && userId) {
+      return "passed";
+    }
+
+    // Must be authenticated and not anonymous
+    if (isAuthenticated && !isAnonymous && userId) {
+      return "passed";
+    }
+
+    return "blocked";
+  }, [authState, allowAnonymous]);
+
+  const checkCreditGate = useCallback((): GateResult => {
+    if (!creditState) return "pending";
+
+    const { creditBalance, requiredCredits } = creditState;
+
+    if (creditBalance >= requiredCredits) {
+      return "passed";
+    }
+
+    return "blocked";
+  }, [creditState]);
+
+  const checkGate = useCallback((): GateResult => {
+    if (gateType === "auth") {
+      return checkAuthGate();
+    }
+    return checkCreditGate();
+  }, [gateType, checkAuthGate, checkCreditGate]);
+
+  // Auto-check and trigger callbacks on mount
+  useEffect(() => {
+    if (hasChecked.current) return;
+
+    const result = checkGate();
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log(`[useGateStep] ${gateType} gate check:`, result);
+    }
+
+    if (result === "passed") {
+      hasChecked.current = true;
+      callbacks.onGatePassed?.();
+    } else if (result === "blocked") {
+      hasChecked.current = true;
+      if (gateType === "auth") {
+        callbacks.onAuthRequired?.();
+      } else {
+        callbacks.onCreditsExhausted?.();
+      }
+    }
+  }, [gateType, checkGate, callbacks]);
+
+  // Re-check when auth/credit state changes
+  useEffect(() => {
+    if (!hasChecked.current) return;
+
+    const result = checkGate();
+
+    if (result === "passed") {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log(`[useGateStep] ${gateType} gate now passed, advancing...`);
+      }
+      callbacks.onGatePassed?.();
+    }
+  }, [authState, creditState, gateType, checkGate, callbacks]);
+
+  return {
+    gateResult: checkGate(),
+    checkGate,
+  };
+}
+
+export default useGateStep;

package/src/features/text-to-image/domain/types/config.types.ts

@@ -39,6 +39,8 @@ export type TextToImageGenerationResult =
   | TextToImageGenerationResultError;
 
 export interface TextToImageCallbacks {
+  /** User ID for orchestrator - required for credit deduction */
+  userId: string | null;
   executeGeneration: (
     request: TextToImageGenerationRequest,
   ) => Promise<TextToImageGenerationResult>;

package/src/features/text-to-image/presentation/hooks/useGeneration.ts

@@ -46,7 +46,10 @@ const DEFAULT_ALERT_MESSAGES: AlertMessages = {
 };
 
 export function useGeneration(options: UseGenerationOptions): UseGenerationReturn {
-  const { formState, callbacks, userId, onPromptCleared } = options;
+  const { formState, callbacks, onPromptCleared } = options;
+
+  // Get userId from callbacks (from app layer via useAIFeatureCallbacks)
+  const userId = callbacks.userId ?? undefined;
 
   const totalCost = callbacks.calculateCost(formState.numImages, formState.selectedModel);
 
@@ -100,6 +103,24 @@ export function useGeneration(options: UseGenerationOptions): UseGenerationRetur
       return { success: false, error: "Prompt is required" };
     }
 
+    // Auth check BEFORE generation
+    if (!callbacks.isAuthenticated()) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[TextToImage] Auth required");
+      }
+      callbacks.onAuthRequired?.();
+      return { success: false, error: "Authentication required" };
+    }
+
+    // Credit check BEFORE generation
+    if (!callbacks.canAfford(totalCost)) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[TextToImage] Insufficient credits", { totalCost });
+      }
+      callbacks.onCreditsRequired?.(totalCost);
+      return { success: false, error: "Insufficient credits" };
+    }
+
     const request: TextToImageGenerationRequest = {
       prompt: trimmedPrompt,
       model: formState.selectedModel ?? undefined,
@@ -120,7 +141,7 @@ export function useGeneration(options: UseGenerationOptions): UseGenerationRetur
 
     // Return result based on orchestrator state
     return null; // Result handled via callbacks
-  }, [formState, generate, callbacks]);
+  }, [formState, generate, callbacks, totalCost]);
 
   return {
     generationState: {

package/src/presentation/components/buttons/GenerateButton.tsx

@@ -86,13 +86,20 @@ export const GenerateButton: React.FC<GenerateButtonProps> = ({
         >
           <View style={styles.buttonContent}>
             {isProcessing ? (
-              <AtomicSpinner size="sm" color={tokens.colors.textInverse} />
+              <AtomicSpinner size="sm" color={disabled ? tokens.colors.textSecondary : tokens.colors.textInverse} />
             ) : (
-              <AtomicIcon name={icon} customSize={iconSize} customColor={tokens.colors.textInverse} />
+              <AtomicIcon 
+                name={icon} 
+                customSize={iconSize} 
+                customColor={disabled ? tokens.colors.textSecondary : tokens.colors.textInverse} 
+              />
             )}
             <AtomicText
               type="bodyLarge"
-              style={[styles.buttonText, { color: tokens.colors.textInverse }]}
+              style={[
+                styles.buttonText, 
+                { color: disabled ? tokens.colors.textSecondary : tokens.colors.textInverse }
+              ]}
             >
               {finalDisplayText}
             </AtomicText>

package/src/presentation/hooks/useAIFeatureCallbacks.ts

@@ -45,6 +45,9 @@ export type AIFeatureGenerationResult =
  * Universal callbacks interface that maps to all feature-specific ones
  */
 export interface AIFeatureCallbacks<TRequest = unknown, TResult = unknown> {
+  // User state - needed by orchestrator
+  userId: string | null;
+
   // TextToImageCallbacks compatible
   executeGeneration: (request: TRequest) => Promise<AIFeatureGenerationResult>;
   calculateCost: (multiplier?: number, _model?: string | null) => number;
@@ -140,6 +143,7 @@ export function useAIFeatureCallbacks<TRequest = unknown, TResult = unknown>(
 
   return useMemo(
     () => ({
+      userId,
       executeGeneration,
       calculateCost,
       canAfford,
@@ -153,6 +157,7 @@ export function useAIFeatureCallbacks<TRequest = unknown, TResult = unknown>(
       onShowPaywall,
     }),
     [
+      userId,
       executeGeneration,
       calculateCost,
       canAfford,