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

package/src/infrastructure/validation/base-validator.types.ts

@@ -0,0 +1,32 @@
+/**
+ * Base Validation Utilities - Types
+ * Type definitions for base validation
+ */
+
+/**
+ * Validation result type
+ */
+export interface ValidationResult {
+  readonly isValid: boolean;
+  readonly errors: readonly string[];
+}
+
+/**
+ * String validation options
+ */
+export interface StringValidationOptions {
+  readonly minLength?: number;
+  readonly maxLength?: number;
+  readonly pattern?: RegExp;
+  readonly allowedCharacters?: RegExp;
+  readonly trim?: boolean;
+}
+
+/**
+ * Numeric validation options
+ */
+export interface NumericValidationOptions {
+  readonly min?: number;
+  readonly max?: number;
+  readonly integer?: boolean;
+}

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

@@ -4,7 +4,7 @@
  */
 
 // Core orchestrator
-export { useGenerationOrchestrator } from "./orchestrator";
+export { useGenerationOrchestrator } from "./orchestrator-index";
 
 // Generic feature hooks
 export { useImageGeneration } from "./useImageGeneration";

package/src/presentation/hooks/generation/orchestrator-abort-logs.ts

@@ -0,0 +1,48 @@
+/**
+ * Generation Orchestrator - Abort Logging
+ */
+
+/**
+ * Log abort before start
+ */
+export function logAbortBeforeStart(): void {
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[Orchestrator] Aborted before generation started");
+  }
+}
+
+/**
+ * Log abort after completion
+ */
+export function logAbortAfterCompletion(): void {
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[Orchestrator] Aborted after generation completed");
+  }
+}
+
+/**
+ * Log abort before save
+ */
+export function logAbortBeforeSave(): void {
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[Orchestrator] Aborted before save");
+  }
+}
+
+/**
+ * Log abort before success
+ */
+export function logAbortBeforeSuccess(): void {
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[Orchestrator] Aborted before success callback");
+  }
+}
+
+/**
+ * Log aborted
+ */
+export function logAborted(): void {
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[Orchestrator] Generation aborted");
+  }
+}

package/src/presentation/hooks/generation/orchestrator-execution-logs.ts

@@ -0,0 +1,67 @@
+/**
+ * Generation Orchestrator - Execution Logging
+ */
+
+/**
+ * Log state generating
+ */
+export function logStateGenerating(): void {
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[Orchestrator] State: generating - calling strategy.execute()");
+  }
+}
+
+/**
+ * Log execute completed
+ */
+export function logExecuteCompleted(): void {
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[Orchestrator] strategy.execute() completed");
+  }
+}
+
+/**
+ * Log state saving
+ */
+export function logStateSaving(): void {
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[Orchestrator] Saving result to Firestore");
+  }
+}
+
+/**
+ * Log save success
+ */
+export function logSaveSuccess(): void {
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[Orchestrator] Result saved successfully");
+  }
+}
+
+/**
+ * Log save failed
+ */
+export function logSaveFailed(error: unknown): void {
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[Orchestrator] ERROR: Save failed:", error);
+  }
+}
+
+/**
+ * Log generation success
+ */
+export function logGenerationSuccess(): void {
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[Orchestrator] ✅ Generation SUCCESS");
+    console.log("[Orchestrator] ========================================");
+  }
+}
+
+/**
+ * Log error
+ */
+export function logError(error: unknown): void {
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[Orchestrator] Error:", error);
+  }
+}

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

@@ -0,0 +1,14 @@
+/**
+ * Generation Orchestrator
+ * Handles AI generation execution with network check, moderation, credit deduction, and error handling
+ */
+
+export { useGenerationOrchestrator } from "./orchestrator";
+export type {
+  GenerationStatus,
+  GenerationState,
+  GenerationError,
+  GenerationStrategy,
+  GenerationConfig,
+  UseGenerationOrchestratorReturn,
+} from "./orchestrator-types";

package/src/presentation/hooks/generation/orchestrator-start-logs.ts

@@ -0,0 +1,65 @@
+/**
+ * Generation Orchestrator - Start Logging
+ */
+
+/**
+ * Log generation start
+ */
+export function logGenerationStart(input: unknown, userId: string | null, isGenerating: boolean): void {
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[Orchestrator] ========================================");
+    console.log("[Orchestrator] generate() called with input:", JSON.stringify(input).substring(0, 200));
+    console.log("[Orchestrator] isGenerating:", isGenerating);
+    console.log("[Orchestrator] userId:", userId);
+  }
+}
+
+/**
+ * Log already generating state
+ */
+export function logAlreadyGenerating(): void {
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[Orchestrator] BLOCKED: Already generating");
+  }
+}
+
+/**
+ * Log state change
+ */
+export function logStateChange(state: string): void {
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[Orchestrator] State set to '" + state + "', isGenerating: true");
+  }
+}
+
+/**
+ * Log online check result
+ */
+export function logOnlineCheck(online: boolean): void {
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    if (online) {
+      console.log("[Orchestrator] Online check passed");
+    } else {
+      console.log("[Orchestrator] ERROR: User is offline");
+    }
+  }
+}
+
+/**
+ * Log moderation start
+ */
+export function logModerationStart(): void {
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[Orchestrator] Starting moderation check");
+  }
+}
+
+/**
+ * Log execution start
+ */
+export function logExecutionStart(): void {
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[Orchestrator] ----------------------------------------");
+    console.log("[Orchestrator] executeGeneration() called");
+  }
+}

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

@@ -0,0 +1,17 @@
+/**
+ * Generation Orchestrator - State Utilities
+ */
+
+import type { GenerationState } from "./orchestrator-types";
+
+/**
+ * Get initial generation state
+ */
+export function getInitialState<T>(): GenerationState<T> {
+  return {
+    status: "idle",
+    isGenerating: false,
+    result: null,
+    error: null,
+  };
+}

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));
+}