@umituz/react-native-ai-generation-content 1.17.308 → 1.17.310

package/src/presentation/hooks/base/use-single-image-feature.ts

@@ -1,154 +0,0 @@
-/**
- * useSingleImageFeature Hook
- * Provider-agnostic hook for single image processing features
- * App provides processRequest callback with their AI provider
- */
-
-import { useCallback, useState } from "react";
-import type {
-  BaseFeatureState,
-  BaseFeatureActions,
-  FeatureProcessResult,
-  OnProgressCallback,
-  OnSelectImageCallback,
-  OnSaveCallback,
-} from "./types";
-
-/**
- * Request passed to processRequest callback
- */
-export interface SingleImageProcessRequest {
-  readonly imageUri: string;
-  readonly onProgress: OnProgressCallback;
-}
-
-/**
- * Configuration for single image feature
- */
-export interface UseSingleImageFeatureConfig {
-  readonly onSelectImage: OnSelectImageCallback;
-  readonly processRequest: (
-    request: SingleImageProcessRequest
-  ) => Promise<FeatureProcessResult>;
-  readonly onSave?: OnSaveCallback;
-  readonly onError?: (error: string) => void;
-  readonly onSuccess?: (url: string) => void;
-}
-
-/**
- * State for single image feature
- */
-export interface SingleImageFeatureState extends BaseFeatureState {
-  readonly imageUri: string | null;
-}
-
-/**
- * Return type for single image feature hook
- */
-export interface UseSingleImageFeatureReturn
-  extends SingleImageFeatureState,
-    BaseFeatureActions {
-  readonly selectImage: () => Promise<void>;
-  readonly process: () => Promise<void>;
-  readonly save: () => Promise<void>;
-}
-
-export function useSingleImageFeature(
-  config: UseSingleImageFeatureConfig
-): UseSingleImageFeatureReturn {
-  const [imageUri, setImageUri] = useState<string | null>(null);
-  const [processedUrl, setProcessedUrl] = useState<string | null>(null);
-  const [isProcessing, setIsProcessing] = useState(false);
-  const [progress, setProgress] = useState(0);
-  const [error, setError] = useState<string | null>(null);
-
-  const selectImage = useCallback(async (): Promise<void> => {
-    try {
-      const uri = await config.onSelectImage();
-      if (uri) {
-        setImageUri(uri);
-        setError(null);
-        setProcessedUrl(null);
-      }
-    } catch (err) {
-      const message = err instanceof Error ? err.message : "error.selectImage";
-      setError(message);
-      config.onError?.(message);
-    }
-  }, [config]);
-
-  const process = useCallback(async (): Promise<void> => {
-    if (!imageUri) {
-      const message = "error.noImage";
-      setError(message);
-      config.onError?.(message);
-      return;
-    }
-
-    setIsProcessing(true);
-    setProgress(0);
-    setError(null);
-
-    try {
-      const result = await config.processRequest({
-        imageUri,
-        onProgress: setProgress,
-      });
-
-      if (result.success && result.outputUrl) {
-        setProcessedUrl(result.outputUrl);
-        config.onSuccess?.(result.outputUrl);
-      } else {
-        const message = result.error || "error.processing";
-        setError(message);
-        config.onError?.(message);
-      }
-    } catch (err) {
-      const message = err instanceof Error ? err.message : "error.processing";
-      setError(message);
-      config.onError?.(message);
-    } finally {
-      setIsProcessing(false);
-      setProgress(0);
-    }
-  }, [imageUri, config]);
-
-  const save = useCallback(async (): Promise<void> => {
-    if (!processedUrl || !config.onSave) {
-      return;
-    }
-
-    try {
-      await config.onSave(processedUrl);
-    } catch (err) {
-      const message = err instanceof Error ? err.message : "error.save";
-      setError(message);
-      config.onError?.(message);
-    }
-  }, [processedUrl, config]);
-
-  const reset = useCallback((): void => {
-    setImageUri(null);
-    setProcessedUrl(null);
-    setIsProcessing(false);
-    setProgress(0);
-    setError(null);
-  }, []);
-
-  const clearError = useCallback((): void => {
-    setError(null);
-  }, []);
-
-  return {
-    imageUri,
-    processedUrl,
-    isProcessing,
-    progress,
-    error,
-    selectImage,
-    process,
-    save,
-    reset,
-    clearError,
-  };
-}

package/src/presentation/hooks/base/utils/feature-state.factory.ts

@@ -1,133 +0,0 @@
-/**
- * Feature State Factory
- * Factory functions for creating feature state handlers
- * Reduces code duplication across feature hooks
- */
-
-import { useCallback } from "react";
-
-export interface FeatureStateActions {
-  reset: () => void;
-  clearError: () => void;
-}
-
-export interface CreateStateHandlersParams<TState> {
-  setState: React.Dispatch<React.SetStateAction<TState>>;
-  initialState: TState;
-}
-
-/**
- * Creates reset and clearError handlers for feature state
- */
-export function createFeatureStateHandlers<TState extends { error: string | null }>({
-  setState,
-  initialState,
-}: CreateStateHandlersParams<TState>): FeatureStateActions {
-  const reset = useCallback(() => {
-    setState(initialState);
-  }, [setState, initialState]);
-
-  const clearError = useCallback(() => {
-    setState((prev) => ({
-      ...prev,
-      error: null,
-    }));
-  }, [setState]);
-
-  return { reset, clearError };
-}
-
-/**
- * Creates error handler with logging
- */
-export interface ErrorHandlerParams {
-  setError: (error: string | null) => void;
-  onError?: (error: string) => void;
-  errorKey: string;
-}
-
-export function createErrorHandler({
-  setError,
-  onError,
-  errorKey,
-}: ErrorHandlerParams) {
-  return useCallback((error: unknown) => {
-    const message = error instanceof Error ? error.message : errorKey;
-    setError(message);
-    onError?.(message);
-  }, [setError, onError, errorKey]);
-}
-
-/**
- * Creates process handler with common logic
- */
-export interface ProcessHandlerParams<TResult> {
-  canProcess: () => boolean;
-  setError: (error: string | null) => void;
-  setProcessing: (processing: boolean) => void;
-  onError?: (error: string) => void;
-  processFn: () => Promise<TResult>;
-  onSuccess?: (result: TResult) => void;
-  onProgress?: (progress: number) => void;
-}
-
-export async function executeProcess<TResult>({
-  canProcess,
-  setError,
-  setProcessing,
-  onError,
-  processFn,
-  onSuccess,
-  onProgress,
-}: ProcessHandlerParams<TResult>): Promise<TResult | null> {
-  if (!canProcess()) {
-    return null;
-  }
-
-  setProcessing(true);
-  setError(null);
-  onProgress?.(0);
-
-  try {
-    const result = await processFn();
-    onProgress?.(100);
-    onSuccess?.(result);
-    return result;
-  } catch (err) {
-    const message = err instanceof Error ? err.message : "error.processing";
-    setError(message);
-    onError?.(message);
-    return null;
-  } finally {
-    setProcessing(false);
-  }
-}
-
-/**
- * Creates save handler
- */
-export interface SaveHandlerParams {
-  processedUrl: string | null;
-  onSave?: (url: string) => Promise<void>;
-  setError: (error: string | null) => void;
-  onError?: (error: string) => void;
-}
-
-export async function executeSave({
-  processedUrl,
-  onSave,
-  setError,
-  onError,
-}: SaveHandlerParams): Promise<void> {
-  if (!processedUrl || !onSave) {
-    return;
-  }
-
-  try {
-    await onSave(processedUrl);
-  } catch (err) {
-    const message = err instanceof Error ? err.message : "error.save";
-    setError(message);
-    onError?.(message);
-  }
-}

package/src/presentation/hooks/generation-callbacks.types.ts

@@ -1,42 +0,0 @@
-/**
- * Generation Callbacks Types
- * Type definitions for unified generation flow
- */
-
-export type CreditType = "image" | "text" | "video" | "audio";
-
-export interface GenerationExecutionResult<T = unknown> {
-  success: boolean;
-  data?: T;
-  error?: string;
-}
-
-export interface GenerationCallbacksConfig<TRequest, TResult> {
-  userId: string | null;
-  isAuthenticated: boolean;
-  creditBalance: number;
-  creditCost: number;
-  creditType: CreditType;
-  executor: (request: TRequest) => Promise<GenerationExecutionResult<TResult>>;
-  deductCredit: (type: CreditType) => Promise<void>;
-  openPaywall: () => void;
-  showAuthModal?: () => void;
-  saveCreation?: (result: TResult) => Promise<void>;
-  onNavigateAfterSuccess?: () => void;
-  invalidateQueryKeys?: string[];
-}
-
-export interface GenerationCallbacks<TRequest, TResult> {
-  canAfford: (cost?: number) => boolean;
-  isAuthenticated: () => boolean;
-  calculateCost: (multiplier?: number) => number;
-  execute: (request: TRequest) => Promise<GenerationExecutionResult<TResult>>;
-  onAuthRequired: () => void;
-  onCreditsRequired: () => void;
-}
-
-export interface UseGenerationCallbacksBuilderOptions<TRequest, TResult> {
-  config: GenerationCallbacksConfig<TRequest, TResult>;
-  onSuccess?: (result: TResult) => void;
-  onError?: (error: string) => void;
-}

package/src/presentation/hooks/photo-generation.types.ts

@@ -1,61 +0,0 @@
-/**
- * Photo Generation Types
- * Generic types for photo-based AI generation workflows
- */
-
-export interface PhotoGenerationInput<TMetadata = unknown> {
-  photos: Array<{ uri: string; base64: string }>;
-  metadata?: TMetadata;
-}
-
-export interface PhotoGenerationResult<TResult = unknown> {
-  success: boolean;
-  data?: TResult;
-  error?: PhotoGenerationError;
-}
-
-export interface PhotoGenerationError {
-  type: "network_error" | "policy_violation" | "save_failed" | "credit_failed" | "unknown";
-  message: string;
-  originalError?: Error;
-}
-
-export interface AlertMessages {
-  networkError: string;
-  policyViolation: string;
-  saveFailed: string;
-  creditFailed: string;
-  unknown: string;
-}
-
-export interface PhotoGenerationConfig<TInput, TResult, TSaveInput> {
-  /** User ID for credit operations - required for credit check/deduct */
-  userId: string | undefined;
-  /** Credit cost per generation (default: 1) */
-  creditCost?: number;
-  /** Generation function */
-  generate: (input: TInput, onProgress?: (progress: number) => void) => Promise<TResult>;
-  /** Save result function */
-  save?: (result: TResult, input: TInput) => Promise<TSaveInput>;
-  /** Build metadata for tracking */
-  buildMetadata?: (input: TInput) => Record<string, unknown>;
-  /** Called when credits are exhausted */
-  onCreditsExhausted?: () => void;
-  /** Success callback */
-  onSuccess?: (result: TResult) => void;
-  /** Error callback */
-  onError?: (error: PhotoGenerationError) => void;
-  /** Save complete callback */
-  onSaveComplete?: (saveResult: TSaveInput) => void;
-  /** Alert messages for errors */
-  alertMessages: AlertMessages;
-}
-
-export interface PhotoGenerationState<TResult = unknown> {
-  isGenerating: boolean;
-  result: TResult | null;
-  error: PhotoGenerationError | null;
-  progress: number;
-}
-
-export type PhotoGenerationStatus = "idle" | "validating" | "generating" | "saving" | "success" | "error";

package/src/presentation/hooks/useGenerationCallbacksBuilder.ts

@@ -1,126 +0,0 @@
-/**
- * Generic Generation Callbacks Builder
- * Unified hook for ALL generation types (image, video, audio, text)
- */
-
-import { useCallback, useMemo, useRef } from "react";
-import { useQueryClient } from "@umituz/react-native-design-system";
-import type {
-  GenerationExecutionResult,
-  GenerationCallbacks,
-  UseGenerationCallbacksBuilderOptions,
-} from "./generation-callbacks.types";
-
-declare const __DEV__: boolean;
-
-export function useGenerationCallbacksBuilder<TRequest, TResult>(
-  options: UseGenerationCallbacksBuilderOptions<TRequest, TResult>,
-): { callbacks: GenerationCallbacks<TRequest, TResult> } {
-  const { config, onSuccess, onError } = options;
-  const queryClient = useQueryClient();
-  const isExecutingRef = useRef(false);
-
-  const canAfford = useCallback(
-    (cost?: number): boolean => {
-      const actualCost = cost ?? config.creditCost;
-      return config.creditBalance >= actualCost;
-    },
-    [config.creditBalance, config.creditCost],
-  );
-
-  const isAuthenticated = useCallback(
-    (): boolean => config.isAuthenticated,
-    [config.isAuthenticated],
-  );
-
-  const calculateCost = useCallback(
-    (multiplier = 1): number => config.creditCost * multiplier,
-    [config.creditCost],
-  );
-
-  const onAuthRequired = useCallback(() => {
-    if (config.showAuthModal) {
-      config.showAuthModal();
-    } else {
-      config.openPaywall();
-    }
-  }, [config]);
-
-  const onCreditsRequired = useCallback(() => {
-    config.openPaywall();
-  }, [config]);
-
-  const execute = useCallback(
-    async (request: TRequest): Promise<GenerationExecutionResult<TResult>> => {
-      if (isExecutingRef.current) {
-        return { success: false, error: "Generation already in progress" };
-      }
-
-      if (!config.isAuthenticated || !config.userId) {
-        onAuthRequired();
-        return { success: false, error: "Authentication required" };
-      }
-
-      if (!canAfford()) {
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-           
-          console.log("[Generation] Insufficient credits", {
-            balance: config.creditBalance,
-            cost: config.creditCost,
-          });
-        }
-        onCreditsRequired();
-        return { success: false, error: "Insufficient credits" };
-      }
-
-      isExecutingRef.current = true;
-
-      try {
-        const result = await config.executor(request);
-
-        if (!result.success || !result.data) {
-          return { success: false, error: result.error || "Generation failed" };
-        }
-
-        await config.deductCredit(config.creditType);
-
-        if (config.saveCreation) {
-          try {
-            await config.saveCreation(result.data);
-          } catch {
-            // Silent fail for save
-          }
-        }
-
-        const keys = config.invalidateQueryKeys ?? ["creations"];
-        keys.forEach((key) => queryClient.invalidateQueries({ queryKey: [key] }));
-
-        onSuccess?.(result.data);
-        config.onNavigateAfterSuccess?.();
-
-        return { success: true, data: result.data };
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        onError?.(message);
-        return { success: false, error: message };
-      } finally {
-        isExecutingRef.current = false;
-      }
-    },
-    [config, canAfford, onAuthRequired, onCreditsRequired, queryClient, onSuccess, onError],
-  );
-
-  const callbacks = useMemo<GenerationCallbacks<TRequest, TResult>>(
-    () => ({
-      canAfford,
-      isAuthenticated,
-      calculateCost,
-      execute,
-      onAuthRequired,
-      onCreditsRequired,
-    }),
-    [canAfford, isAuthenticated, calculateCost, execute, onAuthRequired, onCreditsRequired],
-  );
-
-  return { callbacks };
-}

package/src/presentation/hooks/useGenerationCredits.ts

@@ -1,77 +0,0 @@
-/**
- * useGenerationCredits Hook
- * Centralized credit management for all AI generation features
- * Provides server-side credit validation before generation
- */
-
-import { useCallback } from "react";
-import { useDeductCredit } from "@umituz/react-native-subscription";
-
-export interface UseGenerationCreditsParams {
-  userId: string | undefined;
-  onCreditsExhausted?: () => void;
-}
-
-export interface GenerationCreditsError {
-  type: "no_credits" | "deduct_failed";
-  message: string;
-}
-
-export interface UseGenerationCreditsReturn {
-  /** Server-side credit check */
-  checkCredits: (cost?: number) => Promise<boolean>;
-  /** Deduct credits after successful generation */
-  deductCredits: (cost?: number) => Promise<boolean>;
-  /** Whether credit operation is in progress */
-  isProcessing: boolean;
-  /** Execute generation with automatic credit check and deduct */
-  withCredits: <T>(
-    generate: () => Promise<T>,
-    cost?: number,
-  ) => Promise<T>;
-}
-
-export const useGenerationCredits = ({
-  userId,
-  onCreditsExhausted,
-}: UseGenerationCreditsParams): UseGenerationCreditsReturn => {
-  const { checkCredits, deductCredit, isDeducting } = useDeductCredit({
-    userId,
-    onCreditsExhausted,
-  });
-
-  const withCredits = useCallback(
-    async <T>(generate: () => Promise<T>, cost: number = 1): Promise<T> => {
-      const hasCredits = await checkCredits(cost);
-      if (!hasCredits) {
-        throw new CreditError("no_credits", "Insufficient credits");
-      }
-
-      const result = await generate();
-
-      await deductCredit(cost);
-
-      return result;
-    },
-    [checkCredits, deductCredit],
-  );
-
-  return {
-    checkCredits,
-    deductCredits: deductCredit,
-    isProcessing: isDeducting,
-    withCredits,
-  };
-};
-
-class CreditError extends Error {
-  constructor(
-    public type: GenerationCreditsError["type"],
-    message: string,
-  ) {
-    super(message);
-    this.name = "CreditError";
-  }
-}
-
-export { CreditError };