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

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

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,106 @@
+/**
+ * Shared hook for managing feature state
+ * Eliminates duplicate state management across domains
+ */
+
+import { useState, useCallback, useReducer } from 'react';
+import type {
+  BaseFeatureState,
+  FeatureStateAction,
+} 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;
+}