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

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

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

package/src/shared/utils/credit.ts

@@ -3,7 +3,7 @@
  * Provides consistent credit calculation operations
  */
 
-import { calculateCredits as calculateCreditsFromDuration } from "./calculations.util";
+import { calculateCredits as calculateCreditsFromDuration } from "./calculations";
 
 /**
  * Validates if a value is a valid credit amount

package/src/shared-kernel/application/hooks/index.ts

@@ -0,0 +1,8 @@
+/**
+ * Shared application hooks
+ * Exports all shared hooks for use across domains
+ */
+
+export { useFeatureState } from './use-feature-state';
+export type { GenerationHandlerConfig } from './use-generation-handler';
+export { useGenerationHandler } from './use-generation-handler';

package/src/shared-kernel/application/hooks/use-feature-state.ts

@@ -0,0 +1,107 @@
+/**
+ * Shared hook for managing feature state
+ * Eliminates duplicate state management across domains
+ */
+
+import { useState, useCallback, useReducer } from 'react';
+import type {
+  BaseFeatureState,
+  FeatureStateAction,
+  createInitialFeatureState,
+} from '../../base-types';
+
+/**
+ * Hook for managing feature state with consistent patterns
+ * Reduces state management duplication across domains
+ */
+export function useFeatureState<TOutput = string>() {
+  const [state, dispatch] = useReducer(
+    (currentState: BaseFeatureState<TOutput>, action: FeatureStateAction<TOutput>) => {
+      switch (action.type) {
+        case 'START':
+          return {
+            ...currentState,
+            isProcessing: true,
+            progress: 0,
+            error: null,
+            startedAt: Date.now(),
+            jobId: action.jobId,
+          } as BaseFeatureState<TOutput> & { startedAt: number; jobId?: string };
+
+        case 'PROGRESS':
+          return {
+            ...currentState,
+            progress: action.progress,
+            progressInfo: {
+              progress: action.progress,
+              status: action.status,
+            },
+          };
+
+        case 'SUCCESS':
+          return {
+            ...currentState,
+            isProcessing: false,
+            progress: 1,
+            output: action.output,
+            completedAt: Date.now(),
+          } as BaseFeatureState<TOutput> & { completedAt: number };
+
+        case 'ERROR':
+          return {
+            ...currentState,
+            isProcessing: false,
+            error: action.error,
+          };
+
+        case 'RESET':
+          return {
+            isProcessing: false,
+            progress: 0,
+            error: null,
+            output: null,
+          };
+
+        default:
+          return currentState;
+      }
+    },
+    useState<BaseFeatureState<TOutput>>(() => ({
+      isProcessing: false,
+      progress: 0,
+      error: null,
+      output: null,
+    }))[0]
+  );
+
+  const startProcessing = useCallback((jobId?: string) => {
+    dispatch({ type: 'START', jobId });
+  }, []);
+
+  const updateProgress = useCallback((progress: number, status?: string) => {
+    dispatch({ type: 'PROGRESS', progress, status });
+  }, []);
+
+  const setSuccess = useCallback((output: TOutput, metadata?: Record<string, unknown>) => {
+    dispatch({ type: 'SUCCESS', output, metadata });
+  }, []);
+
+  const setError = useCallback((error: string) => {
+    dispatch({ type: 'ERROR', error });
+  }, []);
+
+  const reset = useCallback(() => {
+    dispatch({ type: 'RESET' });
+  }, []);
+
+  return {
+    state,
+    actions: {
+      startProcessing,
+      updateProgress,
+      setSuccess,
+      setError,
+      reset,
+    },
+  };
+}

package/src/shared-kernel/application/hooks/use-generation-handler.ts

@@ -0,0 +1,110 @@
+/**
+ * Shared hook for handling generation operations
+ * Eliminates duplicate generation logic across domains
+ */
+
+import { useCallback } from 'react';
+import type {
+  BaseGenerationCallbacks,
+  BaseGenerationResult,
+  GenerationProgress,
+} from '../../base-types';
+
+/**
+ * Configuration for generation handler
+ */
+export interface GenerationHandlerConfig<TInput, TOutput> {
+  /** Function to execute the generation */
+  executeGeneration: (input: TInput) => Promise<BaseGenerationResult<TOutput>>;
+  /** Optional validation function */
+  validateInput?: (input: TInput) => boolean | Promise<boolean>;
+  /** Callbacks for generation lifecycle */
+  callbacks?: BaseGenerationCallbacks<TOutput>;
+}
+
+/**
+ * Hook for handling generation operations with consistent patterns
+ * Reduces generation logic duplication across domains
+ */
+export function useGenerationHandler<TInput, TOutput = string>(
+  config: GenerationHandlerConfig<TInput, TOutput>
+) {
+  const { executeGeneration, validateInput, callbacks } = config;
+
+  const handleGeneration = useCallback(
+    async (input: TInput): Promise<BaseGenerationResult<TOutput>> => {
+      try {
+        // Call onCreditCheck if provided
+        if (callbacks?.onCreditCheck) {
+          const hasCredits = await callbacks.onCreditCheck();
+          if (!hasCredits) {
+            callbacks.onShowPaywall?.();
+            return {
+              success: false,
+              error: 'Insufficient credits',
+              requestId: '',
+            };
+          }
+        }
+
+        // Validate input if validator provided
+        if (validateInput) {
+          const isValid = await validateInput(input);
+          if (!isValid) {
+            const error = new Error('Invalid input');
+            callbacks?.onError?.(error);
+            return {
+              success: false,
+              error: error.message,
+              requestId: '',
+            };
+          }
+        }
+
+        // Call onStart callback
+        callbacks?.onStart?.();
+
+        // Execute generation
+        const result = await executeGeneration(input);
+
+        // Handle result
+        if (result.success) {
+          callbacks?.onSuccess?.(result);
+          callbacks?.onCreditsConsumed?.(1); // Default credit cost
+        } else {
+          const error = new Error(result.error || 'Generation failed');
+          callbacks?.onError?.(error);
+        }
+
+        // Call onComplete
+        callbacks?.onComplete?.();
+
+        return result;
+      } catch (error) {
+        const err = error instanceof Error ? error : new Error('Unknown error');
+        callbacks?.onError?.(err);
+        callbacks?.onComplete?.();
+
+        return {
+          success: false,
+          error: err.message,
+          requestId: '',
+        };
+      }
+    },
+    [executeGeneration, validateInput, callbacks]
+  );
+
+  const handleProgress = useCallback(
+    (progress: number, status?: string) => {
+      const progressInfo: GenerationProgress = { progress, status };
+      callbacks?.onProgress?.(progressInfo);
+    },
+    [callbacks]
+  );
+
+  return {
+    handleGeneration,
+    handleProgress,
+  };
+}

package/src/shared-kernel/base-types/base-callbacks.types.ts

@@ -0,0 +1,73 @@
+/**
+ * Base callback types for AI generation operations
+ * Shared across all generation domains
+ */
+
+import type { BaseGenerationResult, GenerationProgress } from './base-generation.types';
+
+/**
+ * Credit-related callbacks for premium features
+ */
+export interface CreditCallbacks {
+  /** Called when credit check is needed before generation */
+  onCreditCheck?: () => Promise<boolean>;
+  /** Called when user needs to see paywall */
+  onShowPaywall?: () => void;
+  /** Called when credits are successfully consumed */
+  onCreditsConsumed?: (amount: number) => void;
+}
+
+/**
+ * Progress callbacks for long-running operations
+ */
+export interface ProgressCallbacks {
+  /** Called when generation progress updates */
+  onProgress?: (progress: GenerationProgress) => void;
+  /** Called when operation starts */
+  onStart?: () => void;
+  /** Called when operation completes (success or failure) */
+  onComplete?: () => void;
+}
+
+/**
+ * Result callbacks for generation operations
+ */
+export interface ResultCallbacks<TData = string> {
+  /** Called when generation succeeds */
+  onSuccess?: (result: BaseGenerationResult<TData>) => void;
+  /** Called when generation fails */
+  onError?: (error: Error) => void;
+  /** Called when generation is cancelled */
+  onCancel?: () => void;
+}
+
+/**
+ * Combined callbacks for generation operations
+ * Includes all callback types in a single interface
+ */
+export interface BaseGenerationCallbacks<TData = string>
+  extends CreditCallbacks,
+    ProgressCallbacks,
+    ResultCallbacks<TData> {}
+
+/**
+ * Validation callbacks for input validation
+ */
+export interface ValidationCallbacks {
+  /** Called when validation fails */
+  onValidationFailed?: (errors: Record<string, string>) => void;
+  /** Called when input is invalid */
+  onInvalidInput?: (field: string, reason: string) => void;
+}
+
+/**
+ * Lifecycle callbacks for feature components
+ */
+export interface LifecycleCallbacks {
+  /** Called when component mounts */
+  onMount?: () => void;
+  /** Called when component unmounts */
+  onUnmount?: () => void;
+  /** Called when component updates */
+  onUpdate?: (prevProps: unknown, nextProps: unknown) => void;
+}

package/src/shared-kernel/base-types/base-feature-state.types.ts

@@ -0,0 +1,77 @@
+/**
+ * Base feature state types for AI generation features
+ * Provides consistent state management across all domains
+ */
+
+import type { GenerationProgress } from './base-generation.types';
+
+/**
+ * Base state for all generation features
+ * Used by hooks and components for consistent state management
+ */
+export interface BaseFeatureState<TOutput = string> {
+  /** Whether a generation is currently in progress */
+  isProcessing: boolean;
+  /** Current generation progress (0-1) */
+  progress: number;
+  /** Error message if operation failed */
+  error: string | null;
+  /** Generated output data */
+  output: TOutput | null;
+  /** Additional progress information */
+  progressInfo?: GenerationProgress;
+}
+
+/**
+ * Feature state with additional metadata
+ */
+export interface FeatureStateWithMetadata<TOutput = string> extends BaseFeatureState<TOutput> {
+  /** Unique ID for the current generation job */
+  jobId?: string;
+  /** Timestamp when generation started */
+  startedAt?: number;
+  /** Timestamp when generation completed */
+  completedAt?: number;
+  /** Number of retry attempts */
+  retryCount?: number;
+}
+
+/**
+ * Actions that can be performed on feature state
+ */
+export type FeatureStateAction<TOutput = string> =
+  | { type: 'START'; jobId?: string }
+  | { type: 'PROGRESS'; progress: number; status?: string }
+  | { type: 'SUCCESS'; output: TOutput; metadata?: Record<string, unknown> }
+  | { type: 'ERROR'; error: string }
+  | { type: 'RESET' };
+
+/**
+ * Initial state factory
+ */
+export function createInitialFeatureState<TOutput = string>(): BaseFeatureState<TOutput> {
+  return {
+    isProcessing: false,
+    progress: 0,
+    error: null,
+    output: null,
+  };
+}
+
+/**
+ * Check if feature state is in an error state
+ */
+export function isFeatureStateError<TOutput = string>(
+  state: BaseFeatureState<TOutput>
+): boolean {
+  return state.error !== null;
+}
+
+/**
+ * Check if feature state has output
+ */
+export function hasFeatureStateOutput<TOutput = string>(
+  state: BaseFeatureState<TOutput>
+): boolean {
+  return state.output !== null;
+}

package/src/shared-kernel/base-types/base-generation.types.ts

@@ -0,0 +1,69 @@
+/**
+ * Base types for AI generation operations
+ * Shared across all generation domains (text-to-image, text-to-video, image-to-video, etc.)
+ */
+
+/**
+ * Common aspect ratios used across all generation types
+ */
+export type AspectRatio = '16:9' | '9:16' | '1:1' | '4:3' | '3:4';
+
+/**
+ * Base generation options that are common to most generation types
+ */
+export interface BaseGenerationOptions {
+  /** Output aspect ratio */
+  aspectRatio?: AspectRatio;
+  /** Number of steps/inference iterations */
+  steps?: number;
+  /** Guidance scale for generation (0-20 typically) */
+  guidanceScale?: number;
+  /** Random seed for reproducible results */
+  seed?: number;
+  /** Number of outputs to generate */
+  numOutputs?: number;
+}
+
+/**
+ * Common generation request metadata
+ */
+export interface BaseRequestMeta {
+  /** Unique identifier for this request */
+  requestId: string;
+  /** User ID making the request */
+  userId: string;
+  /** Timestamp when request was created */
+  timestamp: number;
+  /** Request priority for queue management */
+  priority?: 'low' | 'normal' | 'high';
+}
+
+/**
+ * Standard generation result structure
+ */
+export interface BaseGenerationResult<T = string> {
+  /** Whether the generation was successful */
+  success: boolean;
+  /** Generated content URL or data */
+  data?: T;
+  /** Error message if generation failed */
+  error?: string;
+  /** Request identifier */
+  requestId: string;
+  /** Time taken to complete generation (ms) */
+  duration?: number;
+  /** Additional metadata */
+  metadata?: Record<string, unknown>;
+}
+
+/**
+ * Generation progress information
+ */
+export interface GenerationProgress {
+  /** Current progress (0-1) */
+  progress: number;
+  /** Current status message */
+  status?: string;
+  /** Estimated time remaining (ms) */
+  eta?: number;
+}

package/src/shared-kernel/base-types/index.ts

@@ -0,0 +1,30 @@
+/**
+ * Shared kernel base types
+ * Exports all base types for use across domains
+ */
+
+export type {
+  AspectRatio,
+  BaseGenerationOptions,
+  BaseRequestMeta,
+  BaseGenerationResult,
+  GenerationProgress,
+} from './base-generation.types';
+
+export type {
+  BaseFeatureState,
+  FeatureStateWithMetadata,
+  FeatureStateAction,
+  createInitialFeatureState,
+  isFeatureStateError,
+  hasFeatureStateOutput,
+} from './base-feature-state.types';
+
+export type {
+  CreditCallbacks,
+  ProgressCallbacks,
+  ResultCallbacks,
+  BaseGenerationCallbacks,
+  ValidationCallbacks,
+  LifecycleCallbacks,
+} from './base-callbacks.types';