@umituz/react-native-ai-generation-content 1.90.2 → 1.90.3

package/src/shared/hooks/factories/createGenerationHook.ts

@@ -1,253 +0,0 @@
-/**
- * Generic Generation Hook Factory
- * Creates type-safe generation hooks with error handling, progress tracking, and abort support
- */
-
-import { useState, useCallback, useRef, useEffect } from "react";
-
-/**
- * Generation state
- */
-export interface GenerationState {
-  isGenerating: boolean;
-  progress: number;
-  error: string | null;
-}
-
-/**
- * Generation callbacks
- */
-export interface GenerationCallbacks<TResult> {
-  /** Called when generation succeeds */
-  onSuccess?: (result: TResult) => void;
-  /** Called when generation fails */
-  onError?: (error: string) => void;
-  /** Called on progress update */
-  onProgress?: (progress: number) => void;
-}
-
-/**
- * Generation hook configuration
- */
-export interface GenerationHookConfig<TRequest, TResult> {
-  /** Execute the generation request */
-  execute: (request: TRequest, signal?: AbortSignal) => Promise<TResult>;
-  /** Optional validation before execution */
-  validate?: (request: TRequest) => string | null;
-  /** Optional transform for errors */
-  transformError?: (error: unknown) => string;
-}
-
-/**
- * Generation hook return type
- */
-export interface GenerationHookReturn<TRequest, TResult> {
-  generationState: GenerationState;
-  handleGenerate: (request: TRequest) => Promise<TResult | null>;
-  setProgress: (progress: number) => void;
-  setError: (error: string | null) => void;
-  abort: () => void;
-}
-
-const INITIAL_STATE: GenerationState = {
-  isGenerating: false,
-  progress: 0,
-  error: null,
-};
-
-/**
- * Creates a type-safe generation hook
- * @param config - Generation hook configuration
- * @param callbacks - Generation callbacks
- * @returns Generation hook
- *
- * @example
- * ```ts
- * const useMyGeneration = createGenerationHook({
- *   execute: async (request) => {
- *     return await api.generate(request);
- *   },
- *   validate: (request) => {
- *     if (!request.prompt) return "Prompt is required";
- *     return null;
- *   },
- * });
- *
- * // Usage
- * const { generationState, handleGenerate } = useMyGeneration({
- *   onSuccess: (result) => console.log("Success!", result),
- *   onError: (error) => console.error("Error:", error),
- * });
- * ```
- */
-export function createGenerationHook<TRequest, TResult>(
-  config: GenerationHookConfig<TRequest, TResult>
-) {
-  return function useGeneration(
-    callbacks: GenerationCallbacks<TResult> = {}
-  ): GenerationHookReturn<TRequest, TResult> {
-    const [generationState, setGenerationState] = useState<GenerationState>(INITIAL_STATE);
-
-    const abortControllerRef = useRef<AbortController | null>(null);
-    const isMountedRef = useRef(true);
-
-    // Stabilize callbacks
-    const onSuccessRef = useRef(callbacks.onSuccess);
-    const onErrorRef = useRef(callbacks.onError);
-    const onProgressRef = useRef(callbacks.onProgress);
-
-    useEffect(() => {
-      onSuccessRef.current = callbacks.onSuccess;
-      onErrorRef.current = callbacks.onError;
-      onProgressRef.current = callbacks.onProgress;
-    }, [callbacks.onSuccess, callbacks.onError, callbacks.onProgress]);
-
-    // Cleanup on unmount
-    useEffect(() => {
-      isMountedRef.current = true;
-      return () => {
-        isMountedRef.current = false;
-        abortControllerRef.current?.abort();
-      };
-    }, []);
-
-    const setProgress = useCallback((progress: number) => {
-      if (!isMountedRef.current) return;
-      setGenerationState((prev) => ({ ...prev, progress }));
-      onProgressRef.current?.(progress);
-    }, []);
-
-    const setError = useCallback((error: string | null) => {
-      if (!isMountedRef.current) return;
-      setGenerationState((prev) => ({ ...prev, error, isGenerating: false }));
-      if (error) {
-        onErrorRef.current?.(error);
-      }
-    }, []);
-
-    const abort = useCallback(() => {
-      abortControllerRef.current?.abort();
-      if (isMountedRef.current) {
-        setGenerationState((prev) => ({
-          ...prev,
-          isGenerating: false,
-          error: "Generation aborted",
-        }));
-      }
-    }, []);
-
-    const handleGenerate = useCallback(
-      async (request: TRequest): Promise<TResult | null> => {
-        // Validate request
-        if (config.validate) {
-          const validationError = config.validate(request);
-          if (validationError) {
-            setError(validationError);
-            return null;
-          }
-        }
-
-        // Create new AbortController
-        abortControllerRef.current = new AbortController();
-
-        setGenerationState({
-          isGenerating: true,
-          progress: 0,
-          error: null,
-        });
-
-        try {
-          const result = await config.execute(
-            request,
-            abortControllerRef.current.signal
-          );
-
-          if (!isMountedRef.current || abortControllerRef.current.signal.aborted) {
-            return null;
-          }
-
-          setGenerationState((prev) => ({
-            ...prev,
-            isGenerating: false,
-            progress: 100
-          }));
-
-          onSuccessRef.current?.(result);
-          return result;
-        } catch (error) {
-          if (!isMountedRef.current || abortControllerRef.current.signal.aborted) {
-            return null;
-          }
-
-          const errorMessage = config.transformError
-            ? config.transformError(error)
-            : error instanceof Error
-            ? error.message
-            : String(error);
-
-          setError(errorMessage);
-          return null;
-        } finally {
-          abortControllerRef.current = null;
-        }
-      },
-      [config, setError]
-    );
-
-    return {
-      generationState,
-      handleGenerate,
-      setProgress,
-      setError,
-      abort,
-    };
-  };
-}
-
-/**
- * Creates a generation hook with progress updates
- * Useful when the generation API supports progress callbacks
- */
-export function createGenerationHookWithProgress<TRequest, TResult>(
-  config: GenerationHookConfig<TRequest, TResult> & {
-    /** Get progress stream or polling function */
-    subscribeToProgress?: (
-      request: TRequest,
-      onProgress: (progress: number) => void
-    ) => () => void;
-  }
-) {
-  const baseHook = createGenerationHook(config);
-
-  return function useGenerationWithProgress(
-    callbacks: GenerationCallbacks<TResult> = {}
-  ): GenerationHookReturn<TRequest, TResult> {
-    const hookResult = baseHook(callbacks);
-    const unsubscribeRef = useRef<(() => void) | null>(null);
-
-    const handleGenerateWithProgress = useCallback(
-      async (request: TRequest): Promise<TResult | null> => {
-        // Subscribe to progress if available
-        if (config.subscribeToProgress) {
-          unsubscribeRef.current = config.subscribeToProgress(
-            request,
-            hookResult.setProgress
-          );
-        }
-
-        try {
-          return await hookResult.handleGenerate(request);
-        } finally {
-          unsubscribeRef.current?.();
-          unsubscribeRef.current = null;
-        }
-      },
-      [hookResult, config.subscribeToProgress]
-    );
-
-    return {
-      ...hookResult,
-      handleGenerate: handleGenerateWithProgress,
-    };
-  };
-}

package/src/shared/utils/calculations.util.ts

@@ -1,366 +0,0 @@
-/**
- * Calculation Utilities
- * Centralized calculation operations for better performance and maintainability
- */
-
-/**
- * Time & Duration Calculations
- */
-
-/**
- * Calculate age in milliseconds from a timestamp
- */
-export function calculateAgeMs(timestamp: Date | number): number {
-  const time = typeof timestamp === "number" ? timestamp : timestamp.getTime();
-  return Date.now() - time;
-}
-
-/**
- * Calculate age in seconds from a timestamp
- */
-export function calculateAgeSeconds(timestamp: Date | number): number {
-  return Math.floor(calculateAgeMs(timestamp) / 1000);
-}
-
-/**
- * Calculate age in minutes from a timestamp
- */
-export function calculateAgeMinutes(timestamp: Date | number): number {
-  return Math.floor(calculateAgeSeconds(timestamp) / 60);
-}
-
-/**
- * Check if timestamp is older than specified milliseconds
- */
-export function isOlderThan(timestamp: Date | number, maxAgeMs: number): boolean {
-  return calculateAgeMs(timestamp) > maxAgeMs;
-}
-
-/**
- * Calculate duration between two timestamps in milliseconds
- */
-export function calculateDurationMs(
-  startTime: Date | number,
-  endTime: Date | number = Date.now()
-): number {
-  const start = typeof startTime === "number" ? startTime : startTime.getTime();
-  const end = typeof endTime === "number" ? endTime : endTime.getTime();
-  return end - start;
-}
-
-/**
- * Format duration in milliseconds to human-readable string
- */
-export function formatDuration(ms: number): string {
-  const seconds = Math.floor(ms / 1000);
-  const minutes = Math.floor(seconds / 60);
-  const hours = Math.floor(minutes / 60);
-
-  if (hours > 0) {
-    return `${hours}h ${minutes % 60}m`;
-  }
-  if (minutes > 0) {
-    return `${minutes}m ${seconds % 60}s`;
-  }
-  return `${seconds}s`;
-}
-
-/**
- * Polling Calculations
- */
-
-/**
- * Calculate polling interval with exponential backoff
- */
-export function calculatePollingInterval(options: {
-  attempt: number;
-  initialIntervalMs: number;
-  maxIntervalMs: number;
-  backoffMultiplier: number;
-}): number {
-  const { attempt, initialIntervalMs, maxIntervalMs, backoffMultiplier } = options;
-
-  if (attempt === 0) {
-    return 0;
-  }
-
-  const interval = initialIntervalMs * Math.pow(backoffMultiplier, attempt - 1);
-  return Math.min(interval, maxIntervalMs);
-}
-
-/**
- * Calculate estimated total polling time
- */
-export function calculateEstimatedPollingTime(options: {
-  maxAttempts: number;
-  initialIntervalMs: number;
-  maxIntervalMs: number;
-  backoffMultiplier: number;
-}): number {
-  let total = 0;
-  for (let attempt = 1; attempt < options.maxAttempts; attempt++) {
-    total += calculatePollingInterval({ ...options, attempt });
-    if (total >= options.maxIntervalMs * options.maxAttempts) {
-      break;
-    }
-  }
-  return total;
-}
-
-/**
- * Progress & Percentage Calculations
- */
-
-/**
- * Calculate percentage with bounds checking (0-100)
- */
-export function calculatePercentage(value: number, total: number): number {
-  if (total === 0) return 0;
-  const percentage = (value / total) * 100;
-  return Math.max(0, Math.min(100, percentage));
-}
-
-/**
- * Calculate progress with min/max bounds
- */
-export function calculateProgress(
-  current: number,
-  total: number,
-  min: number = 0,
-  max: number = 100
-): number {
-  if (total === 0) return min;
-  const percentage = (current / total) * (max - min) + min;
-  return Math.max(min, Math.min(max, percentage));
-}
-
-/**
- * Calculate remaining percentage
- */
-export function calculateRemaining(current: number, total: number): number {
-  return Math.max(0, total - current);
-}
-
-/**
- * Array & Collection Calculations
- */
-
-/**
- * Calculate filtered count with predicate
- */
-export function calculateFilteredCount<T>(
-  items: readonly T[],
-  predicate: (item: T) => boolean
-): number {
-  return items.reduce((count, item) => (predicate(item) ? count + 1 : count), 0);
-}
-
-/**
- * Calculate pagination slice
- */
-export function calculatePaginationSlice(
-  totalItems: number,
-  page: number,
-  pageSize: number
-): { start: number; end: number; count: number } {
-  const start = page * pageSize;
-  const end = Math.min(start + pageSize, totalItems);
-  const count = end - start;
-  return { start, end, count };
-}
-
-/**
- * Calculate if more items exist for pagination
- */
-export function calculateHasMore(
-  currentCount: number,
-  currentPage: number,
-  pageSize: number
-): boolean {
-  return currentCount >= currentPage * pageSize;
-}
-
-/**
- * Base64 & Size Calculations
- */
-
-/**
- * Calculate base64 size in bytes
- */
-export function calculateBase64Size(base64: string): number {
-  // Remove data URI prefix if present
-  const cleanBase64 = base64.replace(/^data:[^;]+;base64,/, "");
-  return (cleanBase64.length * 3) / 4;
-}
-
-/**
- * Calculate base64 size in megabytes
- */
-export function calculateBase64SizeMB(base64: string): number {
-  return calculateBase64Size(base64) / (1024 * 1024);
-}
-
-/**
- * Calculate if base64 size is within limit
- */
-export function isBase64SizeWithinLimit(base64: string, maxSizeMB: number): boolean {
-  return calculateBase64SizeMB(base64) <= maxSizeMB;
-}
-
-/**
- * Confidence Score Calculations
- */
-
-/**
- * Calculate confidence score from violations with weights
- */
-export function calculateConfidenceScore(
-  violations: readonly { severity: "critical" | "high" | "medium" | "low" }[]
-): number {
-  if (violations.length === 0) return 1.0;
-
-  const weights = { critical: 1.0, high: 0.75, medium: 0.5, low: 0.25 };
-  const score = violations.reduce(
-    (sum, v) => sum + (weights[v.severity] || 0.25),
-    0
-  );
-
-  // Normalize by number of violations, capped at 1.0
-  return Math.min(1.0, score / Math.max(1, violations.length));
-}
-
-/**
- * Credit & Cost Calculations
- */
-
-/**
- * Calculate cost in credits based on duration and resolution
- */
-export function calculateCredits(
-  durationSeconds: number,
-  resolutionMultiplier: number = 1,
-  baseCost: number = 1
-): number {
-  return Math.ceil((durationSeconds / 60) * resolutionMultiplier * baseCost);
-}
-
-/**
- * Calculate resolution multiplier for credits
- */
-export function calculateResolutionMultiplier(width: number, height: number): number {
-  const totalPixels = width * height;
-  const basePixels = 720 * 1280; // HD baseline
-
-  if (totalPixels <= basePixels) return 1;
-  if (totalPixels <= basePixels * 2) return 1.5;
-  if (totalPixels <= basePixels * 4) return 2;
-  return 3;
-}
-
-/**
- * Calculate cost to credits conversion
- */
-export function convertCostToCredits(
-  cost: number,
-  creditsPerDollar: number = 100
-): number {
-  return Math.ceil(cost * creditsPerDollar);
-}
-
-/**
- * Aspect Ratio Calculations
- */
-
-/**
- * Calculate aspect ratio from dimensions
- */
-export function calculateAspectRatio(width: number, height: number): number {
-  return width / height;
-}
-
-/**
- * Calculate height from width and aspect ratio
- */
-export function calculateHeightFromAspectRatio(
-  width: number,
-  aspectRatio: number
-): number {
-  return Math.round(width / aspectRatio);
-}
-
-/**
- * Calculate width from height and aspect ratio
- */
-export function calculateWidthFromAspectRatio(
-  height: number,
-  aspectRatio: number
-): number {
-  return Math.round(height * aspectRatio);
-}
-
-/**
- * Memory & Performance Calculations
- */
-
-/**
- * Calculate estimated memory usage for image
- */
-export function calculateImageMemoryUsage(
-  width: number,
-  height: number,
-  bytesPerPixel: number = 4 // RGBA
-): number {
-  return width * height * bytesPerPixel;
-}
-
-/**
- * Calculate estimated memory usage in MB
- */
-export function calculateMemoryMB(bytes: number): number {
-  return bytes / (1024 * 1024);
-}
-
-/**
- * Calculate safe batch size for processing
- */
-export function calculateSafeBatchSize(
-  availableMemoryMB: number,
-  itemSizeMB: number,
-  safetyFactor: number = 0.7
-): number {
-  const safeMemory = availableMemoryMB * safetyFactor;
-  return Math.max(1, Math.floor(safeMemory / itemSizeMB));
-}
-
-/**
- * Utility Functions
- */
-
-/**
- * Clamp value between min and max
- */
-export function clamp(value: number, min: number, max: number): number {
-  return Math.max(min, Math.min(max, value));
-}
-
-/**
- * Linear interpolation between two values
- */
-export function lerp(start: number, end: number, progress: number): number {
-  return start + (end - start) * clamp(progress, 0, 1);
-}
-
-/**
- * Map value from one range to another
- */
-export function mapRange(
-  value: number,
-  inMin: number,
-  inMax: number,
-  outMin: number,
-  outMax: number
-): number {
-  const inRange = inMax - inMin;
-  const outRange = outMax - outMin;
-  return outMin + ((value - inMin) / inRange) * outRange;
-}