@umituz/react-native-ai-generation-content 1.26.2 → 1.26.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-generation-content",
-  "version": "1.26.2",
+  "version": "1.26.4",
   "description": "Provider-agnostic AI generation orchestration for React Native with result preview components",
   "main": "src/index.ts",
   "types": "src/index.ts",
@@ -11,7 +11,8 @@
     "./creations": "./src/domains/creations/index.ts",
     "./face-detection": "./src/domains/face-detection/index.ts",
     "./feature-background": "./src/domains/feature-background/index.ts",
-    "./wizard": "./src/domains/wizard/index.ts"
+    "./wizard": "./src/domains/wizard/index.ts",
+    "./generation": "./src/domains/generation/index.ts"
   },
   "files": [
     "src"

package/src/domains/generation/application/feature-registry.ts

@@ -0,0 +1,101 @@
+/**
+ * Feature Registry
+ * Centralized registry for all AI generation features
+ * Apps register features they need during initialization
+ */
+
+import type {
+  FeatureConfig,
+  FeatureRegistration,
+} from "../domain/feature-config.types";
+
+declare const __DEV__: boolean;
+
+class FeatureRegistryImpl implements FeatureRegistration {
+  private features = new Map<string, FeatureConfig>();
+
+  register(featureId: string, config: FeatureConfig): void {
+    if (this.features.has(featureId)) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.warn(
+          `[FeatureRegistry] Feature '${featureId}' already registered. Overwriting.`,
+        );
+      }
+    }
+
+    this.features.set(featureId, config);
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[FeatureRegistry] Feature registered", {
+        featureId,
+        type: config.type,
+        model: config.model,
+        creditCost: config.creditCost,
+        inputType: config.inputType,
+        outputType: config.outputType,
+      });
+    }
+  }
+
+  get(featureId: string): FeatureConfig {
+    const config = this.features.get(featureId);
+
+    if (!config) {
+      const availableFeatures = Array.from(this.features.keys()).join(", ");
+
+      throw new Error(
+        `Feature not found: ${featureId}.\n\n` +
+          `Available features: ${availableFeatures || "none"}.\n` +
+          `Please register '${featureId}' using featureRegistry.register() in your app initialization.`,
+      );
+    }
+
+    return config;
+  }
+
+  getAll(): FeatureConfig[] {
+    return Array.from(this.features.values());
+  }
+
+  has(featureId: string): boolean {
+    return this.features.has(featureId);
+  }
+
+  unregister(featureId: string): void {
+    const existed = this.features.delete(featureId);
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      if (existed) {
+        console.log("[FeatureRegistry] Feature unregistered", { featureId });
+      } else {
+        console.warn(
+          `[FeatureRegistry] Cannot unregister '${featureId}': not found`,
+        );
+      }
+    }
+  }
+
+  clear(): void {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[FeatureRegistry] Clearing all features");
+    }
+    this.features.clear();
+  }
+
+  logRegisteredFeatures(): void {
+    const features = this.getAll();
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[FeatureRegistry] Registered features:", {
+        count: features.length,
+        features: features.map((f) => ({
+          id: f.id,
+          type: f.type,
+          outputType: f.outputType,
+        })),
+      });
+    }
+  }
+}
+
+export const featureRegistry = new FeatureRegistryImpl();

package/src/domains/generation/application/generation-strategy.factory.ts

@@ -0,0 +1,128 @@
+/**
+ * Generation Strategy Factory
+ * Creates generation strategies from feature configs
+ */
+
+import type { GenerationStrategy } from "../../../presentation/hooks/generation/orchestrator";
+import type { FeatureConfig } from "../domain/feature-config.types";
+import type {
+  ImageGenerationInput,
+  VideoGenerationInput,
+  ImageGenerationOutput,
+  VideoGenerationOutput,
+} from "../domain/generation.types";
+import { ExecutorFactory } from "../../../infrastructure/executors/executor-factory";
+import { featureRegistry } from "./feature-registry";
+
+declare const __DEV__: boolean;
+
+interface CreationRepository {
+  create(userId: string, creation: unknown): Promise<void>;
+}
+
+interface StrategyFactoryOptions {
+  featureId: string;
+  userId?: string;
+  repository?: CreationRepository;
+}
+
+export function createGenerationStrategy(
+  options: StrategyFactoryOptions,
+): GenerationStrategy<unknown, unknown> {
+  const { featureId, userId, repository } = options;
+
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[StrategyFactory] Creating strategy", {
+      featureId,
+      hasUserId: !!userId,
+      hasRepository: !!repository,
+    });
+  }
+
+  const featureConfig = featureRegistry.get(featureId);
+  const executor = ExecutorFactory.create(featureConfig.type);
+
+  return {
+    execute: async (input: unknown, onProgress?: (progress: number) => void) => {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[StrategyFactory] Executing generation", {
+          featureId,
+          type: featureConfig.type,
+          model: featureConfig.model,
+        });
+      }
+
+      const result = await executor.generate(featureConfig.model, input, {
+        onProgress,
+      });
+
+      if (!result.success || !result.data) {
+        throw new Error(result.error || "Generation failed");
+      }
+
+      return result.data;
+    },
+
+    getCreditCost: () => {
+      return featureConfig.creditCost;
+    },
+
+    save: async (result: unknown, uid: string) => {
+      if (!repository) {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[StrategyFactory] No repository provided, skipping save");
+        }
+        return;
+      }
+
+      const creation = buildCreation(featureConfig, result);
+
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[StrategyFactory] Saving creation", {
+          featureId,
+          creationId: creation.id,
+          outputType: featureConfig.outputType,
+        });
+      }
+
+      await repository.create(uid, creation);
+
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[StrategyFactory] Creation saved successfully");
+      }
+    },
+  };
+}
+
+function buildCreation(featureConfig: FeatureConfig, result: unknown) {
+  const creationId = `${featureConfig.id}_${Date.now()}`;
+
+  let mainUri = "";
+  let output: Record<string, unknown> = {};
+
+  if (featureConfig.outputType === "image") {
+    const imageResult = result as ImageGenerationOutput;
+    mainUri = imageResult.imageUrl || "";
+    output = { imageUrl: imageResult.imageUrl };
+  } else if (featureConfig.outputType === "video") {
+    const videoResult = result as VideoGenerationOutput;
+    mainUri = videoResult.videoUrl || "";
+    output = { videoUrl: videoResult.videoUrl };
+  }
+
+  return {
+    id: creationId,
+    uri: mainUri,
+    type: featureConfig.id,
+    createdAt: new Date(),
+    isShared: false,
+    isFavorite: false,
+    metadata: {
+      featureId: featureConfig.id,
+      generationType: featureConfig.type,
+      outputType: featureConfig.outputType,
+      ...featureConfig.metadata,
+    },
+    output,
+  };
+}

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

@@ -0,0 +1,61 @@
+/**
+ * Feature Configuration Types
+ * Defines how apps configure AI features
+ */
+
+// ============================================================================
+// Feature Type Enums
+// ============================================================================
+
+export type GenerationType = "image" | "video" | "meme";
+
+export type InputType =
+  | "single-photo"
+  | "two-photos"
+  | "text"
+  | "photo-text"
+  | "photo-photo-text";
+
+export type OutputType = "image" | "video";
+
+// ============================================================================
+// Feature Configuration
+// ============================================================================
+
+export interface FeatureConfig {
+  /** Unique feature identifier (e.g., 'couple-future', 'ai-hug') */
+  readonly id: string;
+
+  /** Generation type (determines which executor to use) */
+  readonly type: GenerationType;
+
+  /** Model ID (from app's GENERATION_MODELS config) */
+  readonly model: string;
+
+  /** Credit cost for this feature */
+  readonly creditCost: number;
+
+  /** Input type (determines wizard steps) */
+  readonly inputType: InputType;
+
+  /** Output type (determines result preview) */
+  readonly outputType: OutputType;
+
+  /** Optional: Custom prompt template */
+  readonly promptTemplate?: string;
+
+  /** Optional: Feature-specific metadata */
+  readonly metadata?: Record<string, unknown>;
+}
+
+// ============================================================================
+// Feature Registration
+// ============================================================================
+
+export interface FeatureRegistration {
+  register(featureId: string, config: FeatureConfig): void;
+  get(featureId: string): FeatureConfig;
+  getAll(): FeatureConfig[];
+  has(featureId: string): boolean;
+  unregister(featureId: string): void;
+}

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

@@ -0,0 +1,74 @@
+/**
+ * Generation Domain Types
+ * Generic types for all AI generation features
+ */
+
+// ============================================================================
+// Generation Options
+// ============================================================================
+
+export interface GenerationOptions {
+  timeoutMs?: number;
+  onProgress?: (progress: number) => void;
+}
+
+// ============================================================================
+// Generation Result
+// ============================================================================
+
+export interface GenerationResult<T> {
+  success: boolean;
+  data?: T;
+  error?: string;
+}
+
+// ============================================================================
+// Input Types (by generation type)
+// ============================================================================
+
+export interface ImageGenerationInput {
+  imageUrls?: string[];
+  prompt: string;
+  aspectRatio?: string;
+  outputFormat?: "jpeg" | "png" | "webp";
+}
+
+export interface VideoGenerationInput {
+  sourceImageBase64: string;
+  targetImageBase64?: string;
+  prompt?: string;
+}
+
+export interface MemeGenerationInput {
+  text: string;
+  template?: string;
+}
+
+// ============================================================================
+// Output Types (by generation type)
+// ============================================================================
+
+export interface ImageGenerationOutput {
+  imageUrl: string;
+}
+
+export interface VideoGenerationOutput {
+  videoUrl: string;
+}
+
+export interface MemeGenerationOutput {
+  imageUrl: string;
+  caption?: string;
+}
+
+// ============================================================================
+// Generic Executor Interface
+// ============================================================================
+
+export interface GenerationExecutor<TInput, TOutput> {
+  generate(
+    model: string,
+    input: TInput,
+    options?: GenerationOptions,
+  ): Promise<GenerationResult<TOutput>>;
+}

package/src/domains/generation/index.ts

@@ -0,0 +1,37 @@
+/**
+ * Generation Domain
+ * Generic, feature-agnostic AI generation system
+ */
+
+// Presentation Layer
+export {
+  useAIGeneration,
+  type UseAIGenerationProps,
+  type UseAIGenerationReturn,
+  type AlertMessages,
+} from "./presentation/useAIGeneration.hook";
+
+// Application Layer
+export { featureRegistry } from "./application/feature-registry";
+export { createGenerationStrategy } from "./application/generation-strategy.factory";
+
+// Domain Layer
+export type {
+  FeatureConfig,
+  FeatureRegistration,
+  GenerationType,
+  InputType,
+  OutputType,
+} from "./domain/feature-config.types";
+
+export type {
+  GenerationExecutor,
+  GenerationOptions,
+  GenerationResult,
+  ImageGenerationInput,
+  ImageGenerationOutput,
+  VideoGenerationInput,
+  VideoGenerationOutput,
+  MemeGenerationInput,
+  MemeGenerationOutput,
+} from "./domain/generation.types";

package/src/domains/generation/presentation/useAIGeneration.hook.ts

@@ -0,0 +1,106 @@
+/**
+ * useAIGeneration Hook
+ * Universal hook for ALL AI generation features
+ * Replaces all feature-specific hooks (useCoupleFutureFlow, useAIHugFeature, etc.)
+ */
+
+import { useGenerationOrchestrator } from "../../../presentation/hooks/generation/orchestrator";
+import { createGenerationStrategy } from "../application/generation-strategy.factory";
+
+declare const __DEV__: boolean;
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export interface AlertMessages {
+  networkError: string;
+  policyViolation: string;
+  saveFailed: string;
+  creditFailed: string;
+  unknown: string;
+}
+
+export interface UseAIGenerationProps {
+  /** Feature ID from feature registry */
+  featureId: string;
+
+  /** User ID for saving creations */
+  userId?: string;
+
+  /** Alert messages for errors */
+  alertMessages?: AlertMessages;
+
+  /** Called when generation succeeds */
+  onSuccess?: (result: unknown) => void;
+
+  /** Called when generation fails */
+  onError?: (error: string) => void;
+
+  /** Called when credits are exhausted */
+  onCreditsExhausted?: () => void;
+
+  /** Optional: Custom repository for saving */
+  repository?: {
+    create(userId: string, creation: unknown): Promise<void>;
+  };
+}
+
+export interface UseAIGenerationReturn {
+  /** Trigger generation */
+  generate: (input: unknown) => Promise<void>;
+
+  /** Whether generation is in progress */
+  isGenerating: boolean;
+
+  /** Current progress (0-100) */
+  progress: number;
+}
+
+// ============================================================================
+// Hook
+// ============================================================================
+
+export function useAIGeneration(
+  props: UseAIGenerationProps,
+): UseAIGenerationReturn {
+  const {
+    featureId,
+    userId,
+    alertMessages,
+    onSuccess,
+    onError,
+    onCreditsExhausted,
+    repository,
+  } = props;
+
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[useAIGeneration] Initializing", {
+      featureId,
+      hasUserId: !!userId,
+      hasRepository: !!repository,
+    });
+  }
+
+  // Create generic strategy
+  const strategy = createGenerationStrategy({
+    featureId,
+    userId,
+    repository,
+  });
+
+  // Use orchestrator for lifecycle management
+  const orchestrator = useGenerationOrchestrator(strategy, {
+    userId,
+    alertMessages,
+    onSuccess,
+    onError,
+    onCreditsExhausted,
+  });
+
+  return {
+    generate: orchestrator.generate,
+    isGenerating: orchestrator.isGenerating,
+    progress: orchestrator.progress,
+  };
+}

package/src/domains/wizard/infrastructure/strategies/wizard-strategy.factory.ts

@@ -366,10 +366,9 @@ export const createWizardStrategy = (
           scenarioId: scenario.id,
           scenarioTitle: scenario.title || scenario.id,
         },
-        output: {
-          imageUrl,
-          videoUrl,
-        },
+        output: outputType === "image"
+          ? { imageUrl }
+          : { videoUrl },
       };
 
       if (typeof __DEV__ !== "undefined" && __DEV__) {

package/src/index.ts

@@ -143,28 +143,6 @@ export * from "./domains/content-moderation";
 export * from "./domains/creations";
 export * from "./domains/face-detection";
 export * from "./domains/scenarios";
-export * from "./features/image-to-image";
-export * from "./features/replace-background";
-export * from "./features/upscaling";
-export * from "./features/script-generator";
-export * from "./features/photo-restoration";
-export type { DualImageVideoProcessingStartData, DualImageVideoResult, DualImageVideoFeatureConfig } from "./features/shared/dual-image-video";
-export * from "./features/ai-hug";
-export * from "./features/ai-kiss";
-export * from "./features/face-swap";
-export * from "./features/anime-selfie";
-export * from "./features/remove-background";
-export * from "./features/remove-object";
-export * from "./features/text-to-video";
-export * from "./features/text-to-image";
-export * from "./features/image-to-video";
-export * from "./features/text-to-voice";
-export * from "./features/hd-touch-up";
-export * from "./features/meme-generator";
-export * from "./features/couple-future";
-export * from "./features/love-message";
-export * from "./features/partner-upload";
-export * from "./features/scenarios";
 export * from "./infrastructure/orchestration";
 
 // Generation Config Provider (App Configuration)
@@ -206,8 +184,6 @@ export type {
   PromptTranslationKeys,
 } from "./presentation/screens/ai-feature";
 
-// AIGenerationWizard - Generic wizard for all AI generation flows
-export * from "./features/wizard";
 
 // Flow System - Dynamic multi-step flow management
 export { createFlowStore, useFlow, resetFlowStore } from "./infrastructure/flow";
@@ -229,5 +205,5 @@ export type {
   FlowGenerationStatus,
 } from "./domain/entities/flow-config.types";
 
-// Wizard Domain - Generic, configuration-driven wizard system for ALL features
 export * from "./domains/wizard";
+export * from "./domains/generation";

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

@@ -0,0 +1,53 @@
+/**
+ * Executor Factory
+ * Creates appropriate executor based on generation type
+ */
+
+import type { GenerationExecutor } from "../../domains/generation/domain/generation.types";
+import { ImageExecutor } from "./image-executor";
+import { VideoExecutor } from "./video-executor";
+
+declare const __DEV__: boolean;
+
+type GenerationType = "image" | "video" | "meme";
+
+export class ExecutorFactory {
+  private static executors = new Map<
+    GenerationType,
+    GenerationExecutor<unknown, unknown>
+  >();
+
+  static create(type: GenerationType): GenerationExecutor<unknown, unknown> {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[ExecutorFactory] Creating executor", { type });
+    }
+
+    if (!this.executors.has(type)) {
+      switch (type) {
+        case "image":
+          this.executors.set(type, new ImageExecutor());
+          break;
+        case "video":
+          this.executors.set(type, new VideoExecutor());
+          break;
+        case "meme":
+          throw new Error("Meme executor not yet implemented");
+        default:
+          throw new Error(`Unknown executor type: ${type}`);
+      }
+
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[ExecutorFactory] Executor created and cached", { type });
+      }
+    }
+
+    return this.executors.get(type)!;
+  }
+
+  static clear(): void {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[ExecutorFactory] Clearing executor cache");
+    }
+    this.executors.clear();
+  }
+}