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

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

@@ -0,0 +1,55 @@
+/**
+ * Generation Orchestrator - Type Definitions
+ */
+
+export type GenerationStatus = "idle" | "checking" | "generating" | "saving" | "success" | "error";
+
+export interface GenerationState<T> {
+  readonly status: GenerationStatus;
+  readonly isGenerating: boolean;
+  readonly result: T | null;
+  readonly error: GenerationError | null;
+}
+
+export interface GenerationError {
+  readonly type: "network" | "moderation" | "credits" | "generation" | "save" | "unknown";
+  readonly message: string;
+  readonly originalError?: Error;
+}
+
+export interface GenerationStrategy<TInput, TResult> {
+  readonly execute: (input: TInput, signal?: AbortSignal) => Promise<TResult>;
+  readonly save?: (result: TResult, userId: string) => Promise<void>;
+}
+
+export interface GenerationConfig {
+  readonly userId: string | null;
+  readonly alertMessages: {
+    readonly networkError?: string;
+    readonly moderationError?: string;
+    readonly insufficientCredits?: string;
+    readonly generationError?: string;
+    readonly saveFailed?: string;
+    readonly success?: string;
+  };
+  readonly onSuccess?: (result: unknown) => Promise<void>;
+  readonly onError?: (error: GenerationError) => Promise<void>;
+  readonly moderation?: {
+    readonly enabled?: boolean;
+    readonly onWarning?: (warning: string, onProceed: () => void, onCancel: () => void) => void;
+  };
+  readonly lifecycle?: {
+    readonly onStart?: () => void;
+    readonly onComplete?: (status: "success" | "error", result?: unknown, error?: GenerationError) => void;
+    readonly completeDelay?: number;
+  };
+}
+
+export interface UseGenerationOrchestratorReturn<TInput, TResult> {
+  readonly generate: (input: TInput) => Promise<TResult | void>;
+  readonly reset: () => void;
+  readonly status: GenerationStatus;
+  readonly isGenerating: boolean;
+  readonly result: TResult | null;
+  readonly error: GenerationError | null;
+}

package/src/presentation/hooks/generation/orchestrator-utils-index.ts

@@ -0,0 +1,29 @@
+/**
+ * Generation Orchestrator - Utility Functions
+ */
+
+export { getInitialState } from "./orchestrator-state-utils";
+export {
+  logGenerationStart,
+  logAlreadyGenerating,
+  logStateChange,
+  logOnlineCheck,
+  logModerationStart,
+  logExecutionStart,
+} from "./orchestrator-start-logs";
+export {
+  logAbortBeforeStart,
+  logAbortAfterCompletion,
+  logAbortBeforeSave,
+  logAbortBeforeSuccess,
+  logAborted,
+} from "./orchestrator-abort-logs";
+export {
+  logStateGenerating,
+  logExecuteCompleted,
+  logStateSaving,
+  logSaveSuccess,
+  logSaveFailed,
+  logGenerationSuccess,
+  logError,
+} from "./orchestrator-execution-logs";

package/src/presentation/hooks/generation/orchestrator-utils.ts

@@ -0,0 +1,25 @@
+/**
+ * Generation Orchestrator - Utility Functions
+ */
+
+export {
+  getInitialState,
+  logGenerationStart,
+  logAlreadyGenerating,
+  logStateChange,
+  logOnlineCheck,
+  logModerationStart,
+  logExecutionStart,
+  logAbortBeforeStart,
+  logStateGenerating,
+  logAbortAfterCompletion,
+  logExecuteCompleted,
+  logAbortBeforeSave,
+  logStateSaving,
+  logSaveSuccess,
+  logSaveFailed,
+  logAbortBeforeSuccess,
+  logGenerationSuccess,
+  logError,
+  logAborted,
+} from "./orchestrator-utils-index";

package/src/presentation/hooks/generation/useDualImageGeneration.ts

@@ -6,7 +6,7 @@
 import { useState, useCallback, useMemo } from "react";
 import { saveImageToGallery } from "@umituz/react-native-design-system/media";
 import { useAlert } from "@umituz/react-native-design-system/molecules";
-import { useGenerationOrchestrator } from "./orchestrator";
+import { useGenerationOrchestrator } from "./orchestrator-index";
 import { useImagePicker } from "./useImagePicker";
 import { executeMultiImageGeneration } from "../../../infrastructure/services/multi-image-generation.executor";
 import type { GenerationStrategy } from "./types";

package/src/presentation/hooks/generation/useImageGeneration.ts

@@ -4,7 +4,7 @@
  */
 
 import { useMemo, useCallback, useRef } from "react";
-import { useGenerationOrchestrator } from "./orchestrator";
+import { useGenerationOrchestrator } from "./orchestrator-index";
 import type { GenerationStrategy } from "./types";
 import { executeImageFeature } from "../../../infrastructure/services";
 import { createCreationsRepository } from "../../../domains/creations/infrastructure/adapters";

package/src/presentation/hooks/generation/useVideoGeneration.ts

@@ -5,7 +5,7 @@
  */
 
 import { useMemo, useCallback, useRef } from "react";
-import { useGenerationOrchestrator } from "./orchestrator";
+import { useGenerationOrchestrator } from "./orchestrator-index";
 import type { GenerationStrategy, AlertMessages } from "./types";
 import { executeVideoFeature } from "../../../infrastructure/services";
 import type { VideoFeatureType } from "../../../domain/interfaces";

package/src/shared/hooks/factories/generation-hook-index.ts

@@ -0,0 +1,12 @@
+/**
+ * Generic Generation Hook Factory
+ * Creates type-safe generation hooks with error handling, progress tracking, and abort support
+ */
+
+export { createGenerationHook, createGenerationHookWithProgress } from "./createGenerationHook";
+export type {
+  GenerationState,
+  GenerationCallbacks,
+  GenerationHookConfig,
+  GenerationHookReturn,
+} from "./generation-hook-types";

package/src/shared/hooks/factories/generation-hook-types.ts

@@ -0,0 +1,47 @@
+/**
+ * Generic Generation Hook Factory - Type Definitions
+ */
+
+/**
+ * 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;
+}

package/src/shared/hooks/factories/generation-hook-utils.ts

@@ -0,0 +1,94 @@
+/**
+ * Generic Generation Hook Factory - Utility Functions
+ */
+
+import type { GenerationState } from "./generation-hook-types";
+
+/**
+ * Initial generation state
+ */
+export const INITIAL_STATE: GenerationState = {
+  isGenerating: false,
+  progress: 0,
+  error: null,
+};
+
+/**
+ * Create abort handler
+ */
+export function createAbortHandler(
+  abortControllerRef: React.MutableRefObject<AbortController | null>,
+  setGenerationState: React.Dispatch<React.SetStateAction<GenerationState>>
+): () => void {
+  return () => {
+    abortControllerRef.current?.abort();
+    setGenerationState((prev) => ({
+      ...prev,
+      isGenerating: false,
+      error: "Generation aborted",
+    }));
+  };
+}
+
+/**
+ * Create progress setter
+ */
+export function createProgressSetter(
+  onProgressRef: React.MutableRefObject<((progress: number) => void) | undefined>,
+  setGenerationState: React.Dispatch<React.SetStateAction<GenerationState>>,
+  isMountedRef: React.MutableRefObject<boolean>
+): (progress: number) => void {
+  return (progress: number) => {
+    if (!isMountedRef.current) return;
+    setGenerationState((prev) => ({ ...prev, progress }));
+    onProgressRef.current?.(progress);
+  };
+}
+
+/**
+ * Create error setter
+ */
+export function createErrorSetter(
+  onErrorRef: React.MutableRefObject<((error: string) => void) | undefined>,
+  setGenerationState: React.Dispatch<React.SetStateAction<GenerationState>>,
+  isMountedRef: React.MutableRefObject<boolean>
+): (error: string | null) => void {
+  return (error: string | null) => {
+    if (!isMountedRef.current) return;
+    setGenerationState((prev) => ({ ...prev, error, isGenerating: false }));
+    if (error) {
+      onErrorRef.current?.(error);
+    }
+  };
+}
+
+/**
+ * Create cleanup effect
+ */
+export function createCleanupEffect(
+  isMountedRef: React.MutableRefObject<boolean>,
+  abortControllerRef: React.MutableRefObject<AbortController | null>
+): () => void {
+  return () => {
+    isMountedRef.current = false;
+    abortControllerRef.current?.abort();
+  };
+}
+
+/**
+ * Create callback updater effect
+ */
+export function createCallbackUpdater<T>(
+  onSuccessRef: React.MutableRefObject<((result: T) => void) | undefined>,
+  onErrorRef: React.MutableRefObject<((error: string) => void) | undefined>,
+  onProgressRef: React.MutableRefObject<((progress: number) => void) | undefined>,
+  callbacks: {
+    onSuccess?: (result: T) => void;
+    onError?: (error: string) => void;
+    onProgress?: (progress: number) => void;
+  }
+): void {
+  onSuccessRef.current = callbacks.onSuccess;
+  onErrorRef.current = callbacks.onError;
+  onProgressRef.current = callbacks.onProgress;
+}

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

@@ -18,4 +18,4 @@ export {
   type GenerationCallbacks,
   type GenerationHookConfig,
   type GenerationHookReturn,
-} from "./createGenerationHook";
+} from "./generation-hook-index";

package/src/shared/index.ts

@@ -13,4 +13,4 @@ export * from "./hooks";
 export * from "./utils/date";
 export * from "./utils/filters";
 export * from "./utils/debounce.util";
-export * from "./utils/calculations.util";
+export * from "./utils/calculations";

package/src/shared/utils/calculations/aspect-ratio-calculations.ts

@@ -0,0 +1,30 @@
+/**
+ * Aspect Ratio & Dimension 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);
+}

package/src/shared/utils/calculations/base64-calculations.ts

@@ -0,0 +1,26 @@
+/**
+ * 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;
+}

package/src/shared/utils/calculations/confidence-calculations.ts

@@ -0,0 +1,21 @@
+/**
+ * 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));
+}

package/src/shared/utils/calculations/cost-calculations-index.ts

@@ -0,0 +1,43 @@
+/**
+ * General Cost & Value Calculations
+ */
+
+export {
+  calculatePercentage,
+  calculateProgress,
+  calculateRemaining,
+} from "./percentage-calculations";
+
+export {
+  calculateFilteredCount,
+  calculatePaginationSlice,
+  calculateHasMore,
+} from "./pagination-calculations";
+
+export {
+  calculateBase64Size,
+  calculateBase64SizeMB,
+  isBase64SizeWithinLimit,
+} from "./base64-calculations";
+
+export {
+  calculateConfidenceScore,
+} from "./confidence-calculations";
+
+export {
+  calculateAspectRatio,
+  calculateHeightFromAspectRatio,
+  calculateWidthFromAspectRatio,
+} from "./aspect-ratio-calculations";
+
+export {
+  calculateImageMemoryUsage,
+  calculateMemoryMB,
+  calculateSafeBatchSize,
+} from "./memory-calculations";
+
+export {
+  clamp,
+  lerp,
+  mapRange,
+} from "./math-utilities";

package/src/shared/utils/calculations/cost-calculations.ts

@@ -0,0 +1,25 @@
+/**
+ * General Cost & Value Calculations
+ */
+
+export {
+  calculatePercentage,
+  calculateProgress,
+  calculateRemaining,
+  calculateFilteredCount,
+  calculatePaginationSlice,
+  calculateHasMore,
+  calculateBase64Size,
+  calculateBase64SizeMB,
+  isBase64SizeWithinLimit,
+  calculateConfidenceScore,
+  calculateAspectRatio,
+  calculateHeightFromAspectRatio,
+  calculateWidthFromAspectRatio,
+  calculateImageMemoryUsage,
+  calculateMemoryMB,
+  calculateSafeBatchSize,
+  clamp,
+  lerp,
+  mapRange,
+} from "./cost-calculations-index";

package/src/shared/utils/calculations/credit-calculations.ts

@@ -0,0 +1,37 @@
+/**
+ * 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);
+}

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

@@ -0,0 +1,46 @@
+/**
+ * Calculation Utilities
+ * Centralized calculation operations for better performance and maintainability
+ */
+
+// Credit & Cost Calculations
+export {
+  calculateCredits,
+  calculateResolutionMultiplier,
+  convertCostToCredits,
+} from "./credit-calculations";
+
+// Time & Duration Calculations
+export {
+  calculateAgeMs,
+  calculateAgeSeconds,
+  calculateAgeMinutes,
+  isOlderThan,
+  calculateDurationMs,
+  formatDuration,
+  calculatePollingInterval,
+  calculateEstimatedPollingTime,
+} from "./time-calculations";
+
+// General Cost & Value Calculations
+export {
+  calculatePercentage,
+  calculateProgress,
+  calculateRemaining,
+  calculateFilteredCount,
+  calculatePaginationSlice,
+  calculateHasMore,
+  calculateBase64Size,
+  calculateBase64SizeMB,
+  isBase64SizeWithinLimit,
+  calculateConfidenceScore,
+  calculateAspectRatio,
+  calculateHeightFromAspectRatio,
+  calculateWidthFromAspectRatio,
+  calculateImageMemoryUsage,
+  calculateMemoryMB,
+  calculateSafeBatchSize,
+  clamp,
+  lerp,
+  mapRange,
+} from "./cost-calculations";

package/src/shared/utils/calculations/math-utilities.ts

@@ -0,0 +1,32 @@
+/**
+ * General Math Utilities
+ */
+
+/**
+ * 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;
+}

package/src/shared/utils/calculations/memory-calculations.ts

@@ -0,0 +1,33 @@
+/**
+ * Memory Usage 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));
+}

package/src/shared/utils/calculations/pagination-calculations.ts

@@ -0,0 +1,38 @@
+/**
+ * Pagination 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;
+}

package/src/shared/utils/calculations/percentage-calculations.ts

@@ -0,0 +1,33 @@
+/**
+ * Percentage & Progress 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);
+}