@umituz/react-native-ai-fal-provider 1.0.52 → 1.0.55

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-fal-provider",
-  "version": "1.0.52",
+  "version": "1.0.55",
   "description": "FAL AI provider for React Native - implements IAIProvider interface for unified AI generation",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/infrastructure/builders/image-feature-builder.ts

@@ -0,0 +1,78 @@
+/**
+ * Image Feature Input Builder
+ * Builds inputs for image-based AI features
+ */
+
+import type {
+  ImageFeatureType,
+  ImageFeatureInputData,
+} from "@umituz/react-native-ai-generation-content";
+import { buildSingleImageInput } from "../utils/base-builders.util";
+import {
+  buildUpscaleInput,
+  buildPhotoRestoreInput,
+  buildFaceSwapInput,
+  buildRemoveBackgroundInput,
+  buildReplaceBackgroundInput,
+  buildKontextStyleTransferInput,
+} from "../utils/image-feature-builders.util";
+
+export function buildImageFeatureInput(
+  feature: ImageFeatureType,
+  data: ImageFeatureInputData,
+): Record<string, unknown> {
+  const { imageBase64, targetImageBase64, prompt, options } = data;
+
+  switch (feature) {
+    case "upscale":
+    case "hd-touch-up":
+      return buildUpscaleInput(imageBase64, options);
+
+    case "photo-restore":
+      return buildPhotoRestoreInput(imageBase64, options);
+
+    case "face-swap":
+      if (!targetImageBase64) {
+        throw new Error("Face swap requires target image");
+      }
+      return buildFaceSwapInput(imageBase64, targetImageBase64, options);
+
+    case "remove-background":
+      return buildRemoveBackgroundInput(imageBase64, options);
+
+    case "remove-object":
+      return buildRemoveObjectInput(imageBase64, prompt, options);
+
+    case "replace-background":
+      if (!prompt) {
+        throw new Error("Replace background requires prompt");
+      }
+      return buildReplaceBackgroundInput(imageBase64, { prompt, ...options });
+
+    case "anime-selfie":
+      return buildKontextStyleTransferInput(imageBase64, {
+        prompt: prompt || (options?.prompt as string) ||
+          "Transform this person into anime style illustration. Keep the same gender, face structure, hair color, eye color, and expression. Make it look like a high-quality anime character portrait with vibrant colors and clean lineart.",
+        guidance_scale: (options?.guidance_scale as number) ?? 4.0,
+      });
+
+    default:
+      return buildSingleImageInput(imageBase64, options);
+  }
+}
+
+function buildRemoveObjectInput(
+  imageBase64: string,
+  prompt?: string,
+  options?: Record<string, unknown>,
+): Record<string, unknown> {
+  return {
+    inpaint_image_url: imageBase64.startsWith("data:")
+      ? imageBase64
+      : `data:image/jpeg;base64,${imageBase64}`,
+    prompt: prompt || (options?.prompt as string) ||
+      "Remove the object and fill with natural background",
+    inpaint_mode: "Modify Content (add objects, change background, etc.)",
+    guidance_scale: (options?.guidance_scale as number) ?? 4.0,
+  };
+}

package/src/infrastructure/builders/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Builders Module
+ * Exports all builder functions
+ */
+
+export { buildImageFeatureInput } from "./image-feature-builder";
+export { buildVideoFeatureInput } from "./video-feature-builder";

package/src/infrastructure/builders/video-feature-builder.ts

@@ -0,0 +1,31 @@
+/**
+ * Video Feature Input Builder
+ * Builds inputs for video-based AI features
+ */
+
+import type {
+  VideoFeatureType,
+  VideoFeatureInputData,
+} from "@umituz/react-native-ai-generation-content";
+import { buildVideoFromImageInput } from "../utils/video-feature-builders.util";
+
+const DEFAULT_VIDEO_PROMPTS: Record<VideoFeatureType, string> = {
+  "ai-kiss": "A romantic couple kissing tenderly, the two reference people sharing an intimate kiss moment, smooth natural movement, cinematic lighting, high quality video",
+  "ai-hug": "A heartwarming embrace between two people, the reference characters hugging warmly with genuine emotion, gentle natural movement, cinematic quality, touching moment",
+};
+
+export function buildVideoFeatureInput(
+  feature: VideoFeatureType,
+  data: VideoFeatureInputData,
+): Record<string, unknown> {
+  const { sourceImageBase64, targetImageBase64, prompt, options } = data;
+
+  const effectivePrompt = prompt || DEFAULT_VIDEO_PROMPTS[feature] || "Generate video with natural motion";
+
+  return buildVideoFromImageInput(sourceImageBase64, {
+    prompt: effectivePrompt,
+    target_image: targetImageBase64,
+    aspect_ratio: (options?.aspect_ratio as "16:9" | "9:16" | "1:1") || "9:16",
+    movement_amplitude: (options?.movement_amplitude as "auto" | "small" | "medium" | "large") || "medium",
+  });
+}

package/src/infrastructure/services/fal-provider.ts

@@ -20,20 +20,11 @@ import type {
 import type { FalQueueStatus } from "../../domain/entities/fal.types";
 import { DEFAULT_FAL_CONFIG, FAL_CAPABILITIES } from "./fal-provider.constants";
 import { mapFalStatusToJobStatus } from "./fal-status-mapper";
-import { NSFWContentError } from "./nsfw-content-error";
 import { FAL_IMAGE_FEATURE_MODELS, FAL_VIDEO_FEATURE_MODELS } from "../../domain/constants/feature-models.constants";
-import {
-  buildSingleImageInput,
-  buildUpscaleInput,
-  buildPhotoRestoreInput,
-  buildFaceSwapInput,
-  buildRemoveBackgroundInput,
-  buildReplaceBackgroundInput,
-  buildKontextStyleTransferInput,
-  buildVideoFromImageInput,
-} from "../utils/input-builders.util";
-
-declare const __DEV__: boolean;
+import { buildImageFeatureInput as buildImageFeatureInputImpl, buildVideoFeatureInput as buildVideoFeatureInputImpl } from "../builders";
+import { validateNSFWContent } from "../validators/nsfw-validator";
+
+declare const __DEV__: boolean | undefined;
 
 export class FalProvider implements IAIProvider {
   readonly providerId = "fal";
@@ -159,7 +150,7 @@ export class FalProvider implements IAIProvider {
 
   async run<T = unknown>(model: string, input: Record<string, unknown>, options?: RunOptions): Promise<T> {
     this.validateInitialization();
-    options?.onProgress?.({ progress: 10, status: "IN_PROGRESS" });
+    options?.onProgress?.({ progress: 10, status: "IN_PROGRESS" as const });
 
     if (typeof __DEV__ !== "undefined" && __DEV__) {
       console.log("[FalProvider] run() model:", model, "inputKeys:", Object.keys(input));
@@ -175,23 +166,12 @@ export class FalProvider implements IAIProvider {
 
     this.checkForNSFWContent(result as Record<string, unknown>);
 
-    options?.onProgress?.({ progress: 100, status: "COMPLETED" });
+    options?.onProgress?.({ progress: 100, status: "COMPLETED" as const });
     return result as T;
   }
 
   private checkForNSFWContent(result: Record<string, unknown>): void {
-    const nsfwConcepts = result?.has_nsfw_concepts as boolean[] | undefined;
-
-    if (nsfwConcepts && Array.isArray(nsfwConcepts)) {
-      const hasNSFW = nsfwConcepts.some((value) => value === true);
-
-      if (hasNSFW) {
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.log("[FalProvider] NSFW content detected, rejecting result");
-        }
-        throw new NSFWContentError();
-      }
-    }
+    validateNSFWContent(result);
   }
 
   reset(): void {
@@ -205,49 +185,7 @@ export class FalProvider implements IAIProvider {
   }
 
   buildImageFeatureInput(feature: ImageFeatureType, data: ImageFeatureInputData): Record<string, unknown> {
-    const { imageBase64, targetImageBase64, prompt, options } = data;
-
-    switch (feature) {
-      case "upscale":
-      case "hd-touch-up":
-        return buildUpscaleInput(imageBase64, options);
-
-      case "photo-restore":
-        return buildPhotoRestoreInput(imageBase64, options);
-
-      case "face-swap":
-        if (!targetImageBase64) throw new Error("Face swap requires target image");
-        return buildFaceSwapInput(imageBase64, targetImageBase64, options);
-
-      case "remove-background":
-        return buildRemoveBackgroundInput(imageBase64, options);
-
-      case "remove-object":
-        // Fooocus inpaint with "Modify Content" mode - no mask required
-        return {
-          inpaint_image_url: imageBase64.startsWith("data:")
-            ? imageBase64
-            : `data:image/jpeg;base64,${imageBase64}`,
-          prompt: prompt || (options?.prompt as string) ||
-            "Remove the object and fill with natural background",
-          inpaint_mode: "Modify Content (add objects, change background, etc.)",
-          guidance_scale: (options?.guidance_scale as number) ?? 4.0,
-        };
-
-      case "replace-background":
-        if (!prompt) throw new Error("Replace background requires prompt");
-        return buildReplaceBackgroundInput(imageBase64, { prompt, ...options });
-
-      case "anime-selfie":
-        return buildKontextStyleTransferInput(imageBase64, {
-          prompt: prompt || (options?.prompt as string) ||
-            "Transform this person into anime style illustration. Keep the same gender, face structure, hair color, eye color, and expression. Make it look like a high-quality anime character portrait with vibrant colors and clean lineart.",
-          guidance_scale: (options?.guidance_scale as number) ?? 4.0,
-        });
-
-      default:
-        return buildSingleImageInput(imageBase64, options);
-    }
+    return buildImageFeatureInputImpl(feature, data);
   }
 
   getVideoFeatureModel(feature: VideoFeatureType): string {
@@ -255,23 +193,8 @@ export class FalProvider implements IAIProvider {
   }
 
   buildVideoFeatureInput(feature: VideoFeatureType, data: VideoFeatureInputData): Record<string, unknown> {
-    const { sourceImageBase64, targetImageBase64, prompt, options } = data;
-
-    // Vidu Q1 optimized prompts for reference-to-video with multiple people
-    const defaultPrompts: Record<VideoFeatureType, string> = {
-      "ai-kiss": "A romantic couple kissing tenderly, the two reference people sharing an intimate kiss moment, smooth natural movement, cinematic lighting, high quality video",
-      "ai-hug": "A heartwarming embrace between two people, the reference characters hugging warmly with genuine emotion, gentle natural movement, cinematic quality, touching moment",
-    };
-
-    const effectivePrompt = prompt || defaultPrompts[feature] || "Generate video with natural motion";
-
-    return buildVideoFromImageInput(sourceImageBase64, {
-      prompt: effectivePrompt,
-      target_image: targetImageBase64,
-      aspect_ratio: (options?.aspect_ratio as "16:9" | "9:16" | "1:1") || "9:16",
-      movement_amplitude: (options?.movement_amplitude as "auto" | "small" | "medium" | "large") || "medium",
-    });
+    return buildVideoFeatureInputImpl(feature, data);
   }
 }
 
-export const falProvider = new FalProvider();
+export const falProvider = new FalProvider();

package/src/infrastructure/utils/base-builders.util.ts

@@ -0,0 +1,31 @@
+/**
+ * Base Input Builders
+ * Core builder functions for FAL API
+ */
+
+export function buildSingleImageInput(
+  base64: string,
+  extraParams?: Record<string, unknown>,
+): Record<string, unknown> {
+  return {
+    image_url: base64.startsWith("data:")
+      ? base64
+      : `data:image/jpeg;base64,${base64}`,
+    ...extraParams,
+  };
+}
+
+export function buildDualImageInput(
+  sourceBase64: string,
+  targetBase64: string,
+  extraParams?: Record<string, unknown>,
+): Record<string, unknown> {
+  const formatImage = (b64: string) =>
+    b64.startsWith("data:") ? b64 : `data:image/jpeg;base64,${b64}`;
+
+  return {
+    image_url: formatImage(sourceBase64),
+    second_image_url: formatImage(targetBase64),
+    ...extraParams,
+  };
+}

package/src/infrastructure/utils/image-feature-builders.util.ts

@@ -0,0 +1,100 @@
+/**
+ * Image Feature Input Builders
+ * Builder functions for specific image features
+ */
+
+import type {
+  UpscaleOptions,
+  PhotoRestoreOptions,
+  RemoveBackgroundOptions,
+  RemoveObjectOptions,
+  ReplaceBackgroundOptions,
+  FaceSwapOptions,
+} from "../../domain/types";
+import { buildSingleImageInput } from "./base-builders.util";
+
+export function buildUpscaleInput(
+  base64: string,
+  options?: UpscaleOptions,
+): Record<string, unknown> {
+  return buildSingleImageInput(base64, {
+    scale: options?.scaleFactor || 2,
+    face_enhance: options?.enhanceFaces || false,
+  });
+}
+
+export function buildPhotoRestoreInput(
+  base64: string,
+  options?: PhotoRestoreOptions,
+): Record<string, unknown> {
+  return buildSingleImageInput(base64, {
+    face_enhance: options?.enhanceFaces || true,
+  });
+}
+
+export function buildFaceSwapInput(
+  sourceBase64: string,
+  targetBase64: string,
+  _options?: FaceSwapOptions,
+): Record<string, unknown> {
+  const formatImage = (b64: string) =>
+    b64.startsWith("data:") ? b64 : `data:image/jpeg;base64,${b64}`;
+
+  return {
+    base_image_url: formatImage(sourceBase64),
+    swap_image_url: formatImage(targetBase64),
+  };
+}
+
+export function buildRemoveBackgroundInput(
+  base64: string,
+  _options?: RemoveBackgroundOptions,
+): Record<string, unknown> {
+  return buildSingleImageInput(base64, {
+    model: "General Use (Light)",
+    operating_resolution: "1024x1024",
+    output_format: "png",
+    refine_foreground: true,
+  });
+}
+
+export function buildRemoveObjectInput(
+  base64: string,
+  options?: RemoveObjectOptions,
+): Record<string, unknown> {
+  return buildSingleImageInput(base64, {
+    mask_url: options?.mask,
+    prompt: options?.prompt || "Remove the object and fill with background",
+  });
+}
+
+export function buildReplaceBackgroundInput(
+  base64: string,
+  options: ReplaceBackgroundOptions,
+): Record<string, unknown> {
+  return buildSingleImageInput(base64, {
+    prompt: options.prompt,
+  });
+}
+
+export function buildHDTouchUpInput(
+  base64: string,
+  options?: UpscaleOptions,
+): Record<string, unknown> {
+  return buildUpscaleInput(base64, options);
+}
+
+export interface KontextStyleTransferOptions {
+  prompt: string;
+  guidance_scale?: number;
+}
+
+export function buildKontextStyleTransferInput(
+  base64: string,
+  options: KontextStyleTransferOptions,
+): Record<string, unknown> {
+  return buildSingleImageInput(base64, {
+    prompt: options.prompt,
+    guidance_scale: options.guidance_scale ?? 3.5,
+  });
+}

package/src/infrastructure/utils/input-builders.util.ts

@@ -3,206 +3,6 @@
  * Provider-agnostic: accepts prompt config as parameter, not imported
  */
 
-import type {
-  UpscaleOptions,
-  PhotoRestoreOptions,
-  ImageToImagePromptConfig,
-  RemoveBackgroundOptions,
-  RemoveObjectOptions,
-  ReplaceBackgroundOptions,
-  VideoFromImageOptions,
-  FaceSwapOptions,
-} from "../../domain/types";
-
-/**
- * Build FAL single image input format
- */
-export function buildSingleImageInput(
-  base64: string,
-  extraParams?: Record<string, unknown>,
-): Record<string, unknown> {
-  return {
-    image_url: base64.startsWith("data:")
-      ? base64
-      : `data:image/jpeg;base64,${base64}`,
-    ...extraParams,
-  };
-}
-
-/**
- * Build FAL dual image input format
- */
-export function buildDualImageInput(
-  sourceBase64: string,
-  targetBase64: string,
-  extraParams?: Record<string, unknown>,
-): Record<string, unknown> {
-  const formatImage = (b64: string) =>
-    b64.startsWith("data:") ? b64 : `data:image/jpeg;base64,${b64}`;
-
-  return {
-    image_url: formatImage(sourceBase64),
-    second_image_url: formatImage(targetBase64),
-    ...extraParams,
-  };
-}
-
-// =============================================================================
-// FEATURE-SPECIFIC BUILDERS
-// =============================================================================
-
-/**
- * Build upscale input for FAL clarity-upscaler
- */
-export function buildUpscaleInput(
-  base64: string,
-  options?: UpscaleOptions,
-): Record<string, unknown> {
-  return buildSingleImageInput(base64, {
-    scale: options?.scaleFactor || 2,
-    face_enhance: options?.enhanceFaces || false,
-  });
-}
-
-/**
- * Build photo restore input for FAL aura-sr
- */
-export function buildPhotoRestoreInput(
-  base64: string,
-  options?: PhotoRestoreOptions,
-): Record<string, unknown> {
-  return buildSingleImageInput(base64, {
-    face_enhance: options?.enhanceFaces || true,
-  });
-}
-
-/**
- * Build reference-to-video input for FAL Vidu Q1
- * Supports up to 7 reference images for multi-person scenarios like kiss/hug
- * Uses reference_image_urls array for consistent character appearance
- */
-export function buildVideoFromImageInput(
-  base64: string,
-  options?: VideoFromImageOptions,
-): Record<string, unknown> {
-  const formatImage = (b64: string) =>
-    b64.startsWith("data:") ? b64 : `data:image/jpeg;base64,${b64}`;
-
-  // Build reference images array - both source and target for kiss/hug
-  const referenceImages: string[] = [formatImage(base64)];
-  if (options?.target_image) {
-    referenceImages.push(formatImage(options.target_image));
-  }
-
-  return {
-    prompt: options?.prompt || options?.motion_prompt || "Generate natural motion video",
-    reference_image_urls: referenceImages,
-    aspect_ratio: options?.aspect_ratio || "9:16",
-    movement_amplitude: options?.movement_amplitude || "auto",
-  };
-}
-
-/**
- * Build face swap input for FAL face-swap
- * FAL API requires: base_image_url (target face) and swap_image_url (face to swap in)
- */
-export function buildFaceSwapInput(
-  sourceBase64: string,
-  targetBase64: string,
-  _options?: FaceSwapOptions,
-): Record<string, unknown> {
-  const formatImage = (b64: string) =>
-    b64.startsWith("data:") ? b64 : `data:image/jpeg;base64,${b64}`;
-
-  return {
-    base_image_url: formatImage(sourceBase64),
-    swap_image_url: formatImage(targetBase64),
-  };
-}
-
-/**
- * Build image-to-image input for FAL flux/dev/image-to-image
- * Accepts prompt config as parameter for provider-agnostic usage
- */
-export function buildImageToImageInput(
-  base64: string,
-  promptConfig: ImageToImagePromptConfig,
-): Record<string, unknown> {
-  return buildSingleImageInput(base64, {
-    prompt: promptConfig.prompt,
-    negative_prompt: promptConfig.negativePrompt,
-    strength: promptConfig.strength ?? 0.85,
-    num_inference_steps: promptConfig.num_inference_steps ?? 50,
-    guidance_scale: promptConfig.guidance_scale ?? 7.5,
-  });
-}
-
-/**
- * Build remove background input for FAL birefnet
- * Uses General Use (Light) model for fast processing
- */
-export function buildRemoveBackgroundInput(
-  base64: string,
-  _options?: RemoveBackgroundOptions,
-): Record<string, unknown> {
-  return buildSingleImageInput(base64, {
-    model: "General Use (Light)",
-    operating_resolution: "1024x1024",
-    output_format: "png",
-    refine_foreground: true,
-  });
-}
-
-/**
- * Build remove object (inpaint) input for FAL flux-kontext-lora/inpaint
- */
-export function buildRemoveObjectInput(
-  base64: string,
-  options?: RemoveObjectOptions,
-): Record<string, unknown> {
-  return buildSingleImageInput(base64, {
-    mask_url: options?.mask,
-    prompt: options?.prompt || "Remove the object and fill with background",
-  });
-}
-
-/**
- * Build replace background input for FAL bria/background/replace
- */
-export function buildReplaceBackgroundInput(
-  base64: string,
-  options: ReplaceBackgroundOptions,
-): Record<string, unknown> {
-  return buildSingleImageInput(base64, {
-    prompt: options.prompt,
-  });
-}
-
-/**
- * Build HD touch up input (same as upscale)
- */
-export function buildHDTouchUpInput(
-  base64: string,
-  options?: UpscaleOptions,
-): Record<string, unknown> {
-  return buildUpscaleInput(base64, options);
-}
-
-/**
- * Build Kontext style transfer input for FAL flux-pro/kontext
- * Instruction-based editing that preserves character identity
- */
-export interface KontextStyleTransferOptions {
-  prompt: string;
-  guidance_scale?: number;
-}
-
-export function buildKontextStyleTransferInput(
-  base64: string,
-  options: KontextStyleTransferOptions,
-): Record<string, unknown> {
-  return buildSingleImageInput(base64, {
-    prompt: options.prompt,
-    guidance_scale: options.guidance_scale ?? 3.5,
-  });
-}
+export * from "./base-builders.util";
+export * from "./image-feature-builders.util";
+export * from "./video-feature-builders.util";

package/src/infrastructure/utils/video-feature-builders.util.ts

@@ -0,0 +1,43 @@
+/**
+ * Video Feature Input Builders
+ * Builder functions for video features
+ */
+
+import type {
+  ImageToImagePromptConfig,
+  VideoFromImageOptions,
+} from "../../domain/types";
+import { buildSingleImageInput } from "./base-builders.util";
+
+export function buildImageToImageInput(
+  base64: string,
+  promptConfig: ImageToImagePromptConfig,
+): Record<string, unknown> {
+  return buildSingleImageInput(base64, {
+    prompt: promptConfig.prompt,
+    negative_prompt: promptConfig.negativePrompt,
+    strength: promptConfig.strength ?? 0.85,
+    num_inference_steps: promptConfig.num_inference_steps ?? 50,
+    guidance_scale: promptConfig.guidance_scale ?? 7.5,
+  });
+}
+
+export function buildVideoFromImageInput(
+  base64: string,
+  options?: VideoFromImageOptions,
+): Record<string, unknown> {
+  const formatImage = (b64: string) =>
+    b64.startsWith("data:") ? b64 : `data:image/jpeg;base64,${b64}`;
+
+  const referenceImages: string[] = [formatImage(base64)];
+  if (options?.target_image) {
+    referenceImages.push(formatImage(options.target_image));
+  }
+
+  return {
+    prompt: options?.prompt || options?.motion_prompt || "Generate natural motion video",
+    reference_image_urls: referenceImages,
+    aspect_ratio: options?.aspect_ratio || "9:16",
+    movement_amplitude: options?.movement_amplitude || "auto",
+  };
+}

package/src/infrastructure/validators/index.ts

@@ -0,0 +1,6 @@
+/**
+ * Validators Module
+ * Exports all validator functions
+ */
+
+export { validateNSFWContent } from "./nsfw-validator";

package/src/infrastructure/validators/nsfw-validator.ts

@@ -0,0 +1,23 @@
+/**
+ * NSFW Content Validator
+ * Validates AI-generated content for NSFW material
+ */
+
+import { NSFWContentError } from "../services/nsfw-content-error";
+
+declare const __DEV__: boolean;
+
+export function validateNSFWContent(result: Record<string, unknown>): void {
+  const nsfwConcepts = result?.has_nsfw_concepts as boolean[] | undefined;
+
+  if (nsfwConcepts && Array.isArray(nsfwConcepts)) {
+    const hasNSFW = nsfwConcepts.some((value) => value === true);
+
+    if (hasNSFW) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[FalProvider] NSFW content detected, rejecting result");
+      }
+      throw new NSFWContentError();
+    }
+  }
+}