@umituz/react-native-ai-generation-content 1.65.1 → 1.65.2

package/src/infrastructure/utils/structure-guards.ts

@@ -0,0 +1,75 @@
+/**
+ * Complex Structure Type Guards
+ */
+
+import { isObject, isArray, isNonEmptyString, isNumber, isFunction } from "./primitive-guards";
+
+/**
+ * Checks if value is a plain object (not null, not array)
+ */
+export function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return isObject(value) && Object.prototype.toString.call(value) === "[object Object]";
+}
+
+/**
+ * Checks if value is a string URL
+ */
+export function isUrl(value: unknown): value is string {
+  if (!isNonEmptyString(value)) {
+    return false;
+  }
+
+  try {
+    new URL(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Checks if value is an array of strings
+ */
+export function isStringArray(value: unknown): value is string[] {
+  return isArray(value) && value.every((item) => typeof item === "string");
+}
+
+/**
+ * Checks if value is an array of numbers
+ */
+export function isNumberArray(value: unknown): value is number[] {
+  return isArray(value) && value.every(isNumber);
+}
+
+/**
+ * Checks if value has a specific property
+ */
+export function hasProperty<K extends PropertyKey>(
+  value: unknown,
+  key: K
+): value is Record<K, unknown> {
+  return isObject(value) && key in value;
+}
+
+/**
+ * Checks if object has all required properties
+ */
+export function hasProperties<K extends PropertyKey>(
+  value: unknown,
+  keys: K[]
+): value is Record<K, unknown> {
+  return isObject(value) && keys.every((key) => key in value);
+}
+
+/**
+ * Checks if value is a promise
+ */
+export function isPromise(value: unknown): value is Promise<unknown> {
+  return (
+    isObject(value) &&
+    "then" in value &&
+    isFunction(value.then) &&
+    "catch" in value &&
+    isFunction(value.catch)
+  );
+}

package/src/infrastructure/utils/type-guards.util.ts

@@ -1,153 +1,26 @@
 /**
- * Type Guard Utilities
+ * Type Guard Utilities - Barrel Export
  * Provides reusable type guards for common type checking patterns
  */
 
-/**
- * Checks if value is a non-null object
- */
-export function isObject(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-/**
- * Checks if value is a plain object (not null, not array)
- */
-export function isPlainObject(value: unknown): value is Record<string, unknown> {
-  return isObject(value) && Object.prototype.toString.call(value) === "[object Object]";
-}
-
-/**
- * Checks if value is an array
- */
-export function isArray(value: unknown): value is unknown[] {
-  return Array.isArray(value);
-}
-
-/**
- * Checks if value is a non-empty string
- */
-export function isNonEmptyString(value: unknown): value is string {
-  return typeof value === "string" && value.trim().length > 0;
-}
-
-/**
- * Checks if value is a number (excluding NaN)
- */
-export function isNumber(value: unknown): value is number {
-  return typeof value === "number" && !isNaN(value);
-}
-
-/**
- * Checks if value is a positive number
- */
-export function isPositiveNumber(value: unknown): value is number {
-  return isNumber(value) && value > 0;
-}
-
-/**
- * Checks if value is a boolean
- */
-export function isBoolean(value: unknown): value is boolean {
-  return typeof value === "boolean";
-}
-
-/**
- * Checks if value is a function
- */
-export function isFunction(value: unknown): value is (...args: unknown[]) => unknown {
-  return typeof value === "function";
-}
-
-/**
- * Checks if value is a promise
- */
-export function isPromise(value: unknown): value is Promise<unknown> {
-  return (
-    isObject(value) &&
-    "then" in value &&
-    isFunction(value.then) &&
-    "catch" in value &&
-    isFunction(value.catch)
-  );
-}
-
-/**
- * Checks if value has a specific property
- */
-export function hasProperty<K extends PropertyKey>(
-  value: unknown,
-  key: K
-): value is Record<K, unknown> {
-  return isObject(value) && key in value;
-}
-
-/**
- * Checks if value is a date object
- */
-export function isDate(value: unknown): value is Date {
-  return value instanceof Date && !isNaN(value.getTime());
-}
-
-/**
- * Checks if value is defined (not null or undefined)
- */
-export function isDefined<T>(value: T | null | undefined): value is T {
-  return value !== null && value !== undefined;
-}
-
-/**
- * Checks if value is a string URL
- */
-export function isUrl(value: unknown): value is string {
-  if (!isNonEmptyString(value)) {
-    return false;
-  }
-
-  try {
-    new URL(value);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Checks if value is an array of strings
- */
-export function isStringArray(value: unknown): value is string[] {
-  return isArray(value) && value.every((item) => typeof item === "string");
-}
-
-/**
- * Checks if value is an array of numbers
- */
-export function isNumberArray(value: unknown): value is number[] {
-  return isArray(value) && value.every(isNumber);
-}
-
-/**
- * Checks if object has all required properties
- */
-export function hasProperties<K extends PropertyKey>(
-  value: unknown,
-  keys: K[]
-): value is Record<K, unknown> {
-  return isObject(value) && keys.every((key) => key in value);
-}
-
-/**
- * Type guard for creation objects with output property
- */
-export function isCreationWithOutput(
-  value: unknown
-): value is { output: unknown } {
-  return hasProperty(value, "output") && isObject(value.output);
-}
-
-/**
- * Type guard for wizard data with id property
- */
-export function isWizardData(value: unknown): value is { id: string } {
-  return hasProperty(value, "id") && isNonEmptyString(value.id);
-}
+export {
+  isObject,
+  isArray,
+  isNonEmptyString,
+  isNumber,
+  isPositiveNumber,
+  isBoolean,
+  isFunction,
+  isDate,
+  isDefined,
+} from "./primitive-guards";
+export {
+  isPlainObject,
+  isUrl,
+  isStringArray,
+  isNumberArray,
+  hasProperty,
+  hasProperties,
+  isPromise,
+} from "./structure-guards";
+export { isCreationWithOutput, isWizardData } from "./domain-guards";

package/src/infrastructure/utils/validation-types.ts

@@ -0,0 +1,8 @@
+/**
+ * Validation Type Definitions
+ */
+
+export interface ValidationResult {
+  isValid: boolean;
+  error?: string;
+}

package/src/infrastructure/utils/validation.util.ts

@@ -1,188 +1,18 @@
 /**
- * Common Validation Utilities
+ * Common Validation Utilities - Barrel Export
  * Reusable validation functions for forms and data
  */
 
-import {
-  MAX_PROMPT_LENGTH,
-  MIN_PROMPT_LENGTH,
-  MAX_USER_ID_LENGTH,
-  MAX_CREATION_ID_LENGTH,
-  MAX_URL_LENGTH,
-  MIN_VIDEO_DURATION_SECONDS,
-  MAX_VIDEO_DURATION_SECONDS,
-} from "../constants/validation.constants";
-
-export interface ValidationResult {
-  isValid: boolean;
-  error?: string;
-}
-
-/**
- * Validates text prompt length
- */
-export function validatePrompt(prompt: string): ValidationResult {
-  if (!prompt || typeof prompt !== "string") {
-    return { isValid: false, error: "Prompt is required" };
-  }
-
-  if (prompt.length < MIN_PROMPT_LENGTH) {
-    return { isValid: false, error: "Prompt is too short" };
-  }
-
-  if (prompt.length > MAX_PROMPT_LENGTH) {
-    return { isValid: false, error: "Prompt is too long" };
-  }
-
-  return { isValid: true };
-}
-
-/**
- * Validates user ID
- */
-export function validateUserId(userId: string): ValidationResult {
-  if (!userId || typeof userId !== "string") {
-    return { isValid: false, error: "User ID is required" };
-  }
-
-  if (userId.length > MAX_USER_ID_LENGTH) {
-    return { isValid: false, error: "User ID is too long" };
-  }
-
-  return { isValid: true };
-}
-
-/**
- * Validates creation ID
- */
-export function validateCreationId(creationId: string): ValidationResult {
-  if (!creationId || typeof creationId !== "string") {
-    return { isValid: false, error: "Creation ID is required" };
-  }
-
-  if (creationId.length > MAX_CREATION_ID_LENGTH) {
-    return { isValid: false, error: "Creation ID is too long" };
-  }
-
-  return { isValid: true };
-}
-
-/**
- * Validates URL format
- */
-export function validateUrl(url: string): ValidationResult {
-  if (!url || typeof url !== "string") {
-    return { isValid: false, error: "URL is required" };
-  }
-
-  if (url.length > MAX_URL_LENGTH) {
-    return { isValid: false, error: "URL is too long" };
-  }
-
-  try {
-    new URL(url);
-    return { isValid: true };
-  } catch {
-    return { isValid: false, error: "Invalid URL format" };
-  }
-}
-
-/**
- * Validates video duration
- */
-export function validateVideoDuration(duration: number): ValidationResult {
-  if (typeof duration !== "number" || isNaN(duration)) {
-    return { isValid: false, error: "Duration must be a number" };
-  }
-
-  if (duration < MIN_VIDEO_DURATION_SECONDS) {
-    return {
-      isValid: false,
-      error: `Duration must be at least ${MIN_VIDEO_DURATION_SECONDS} seconds`,
-    };
-  }
-
-  if (duration > MAX_VIDEO_DURATION_SECONDS) {
-    return {
-      isValid: false,
-      error: `Duration must not exceed ${MAX_VIDEO_DURATION_SECONDS} seconds`,
-    };
-  }
-
-  return { isValid: true };
-}
-
-/**
- * Validates email format
- */
-export function validateEmail(email: string): ValidationResult {
-  if (!email || typeof email !== "string") {
-    return { isValid: false, error: "Email is required" };
-  }
-
-  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-  if (!emailRegex.test(email)) {
-    return { isValid: false, error: "Invalid email format" };
-  }
-
-  return { isValid: true };
-}
-
-/**
- * Validates that a value is not empty
- */
-export function validateNotEmpty(value: unknown, fieldName = "Value"): ValidationResult {
-  if (value === null || value === undefined) {
-    return { isValid: false, error: `${fieldName} is required` };
-  }
-
-  if (typeof value === "string" && value.trim().length === 0) {
-    return { isValid: false, error: `${fieldName} cannot be empty` };
-  }
-
-  if (Array.isArray(value) && value.length === 0) {
-    return { isValid: false, error: `${fieldName} cannot be empty` };
-  }
-
-  return { isValid: true };
-}
-
-/**
- * Validates numeric range
- */
-export function validateNumericRange(
-  value: number,
-  options: {
-    min?: number;
-    max?: number;
-    fieldName?: string;
-  }
-): ValidationResult {
-  const { min, max, fieldName = "Value" } = options;
-
-  if (typeof value !== "number" || isNaN(value)) {
-    return { isValid: false, error: `${fieldName} must be a number` };
-  }
-
-  if (min !== undefined && value < min) {
-    return { isValid: false, error: `${fieldName} must be at least ${min}` };
-  }
-
-  if (max !== undefined && value > max) {
-    return { isValid: false, error: `${fieldName} must not exceed ${max}` };
-  }
-
-  return { isValid: true };
-}
-
-/**
- * Combines multiple validation results
- */
-export function combineValidations(...results: ValidationResult[]): ValidationResult {
-  for (const result of results) {
-    if (!result.isValid) {
-      return result;
-    }
-  }
-  return { isValid: true };
-}
+export type { ValidationResult } from "./validation-types";
+export { validateUserId, validateCreationId } from "./id-validators";
+export {
+  validatePrompt,
+  validateUrl,
+  validateVideoDuration,
+  validateEmail,
+} from "./content-validators";
+export {
+  validateNotEmpty,
+  validateNumericRange,
+  combineValidations,
+} from "./general-validators";

package/src/presentation/hooks/ai-feature-callbacks-auth.hooks.ts

@@ -0,0 +1,43 @@
+/**
+ * AI Feature Callbacks - Authentication Hooks
+ * Authentication-related callback hooks
+ */
+
+import { useCallback } from "react";
+
+export interface UseAuthCallbacksParams {
+  isAuth: boolean;
+  userId: string | null;
+  showAuthModal: (callback?: () => void) => void;
+}
+
+export interface AuthCallbacks {
+  isAuthenticated: () => boolean;
+  onAuthRequired: () => void;
+  onAuthCheck: () => boolean;
+}
+
+/**
+ * Hook for authentication-related callbacks
+ */
+export function useAuthCallbacks(params: UseAuthCallbacksParams): AuthCallbacks {
+  const { isAuth, userId, showAuthModal } = params;
+
+  const isAuthenticated = useCallback(
+    (): boolean => isAuth && !!userId,
+    [isAuth, userId],
+  );
+
+  const onAuthRequired = useCallback(() => {
+    showAuthModal();
+  }, [showAuthModal]);
+
+  // Alias for different callback interfaces
+  const onAuthCheck = isAuthenticated;
+
+  return {
+    isAuthenticated,
+    onAuthRequired,
+    onAuthCheck,
+  };
+}

package/src/presentation/hooks/ai-feature-callbacks-cost.hooks.ts

@@ -0,0 +1,56 @@
+/**
+ * AI Feature Callbacks - Cost Management Hooks
+ * Credit and cost-related callback hooks
+ */
+
+import { useCallback } from "react";
+
+export interface UseCostCallbacksParams {
+  creditBalance: number;
+  creditCostPerUnit: number;
+  openPaywall: () => void;
+}
+
+export interface CostCallbacks {
+  canAfford: (cost: number) => boolean;
+  calculateCost: (multiplier?: number, _model?: string | null) => number;
+  onCreditsRequired: (cost?: number) => void;
+  onCreditCheck: (cost: number) => boolean;
+  onShowPaywall: (cost: number) => void;
+}
+
+/**
+ * Hook for cost and credit management callbacks
+ */
+export function useCostCallbacks(params: UseCostCallbacksParams): CostCallbacks {
+  const { creditBalance, creditCostPerUnit, openPaywall } = params;
+
+  const canAfford = useCallback(
+    (cost: number): boolean => creditBalance >= cost,
+    [creditBalance],
+  );
+
+  const calculateCost = useCallback(
+    (multiplier = 1, _model?: string | null): number => creditCostPerUnit * multiplier,
+    [creditCostPerUnit],
+  );
+
+  const onCreditsRequired = useCallback(
+    (_cost?: number) => {
+      openPaywall();
+    },
+    [openPaywall],
+  );
+
+  // Aliases for different callback interfaces
+  const onCreditCheck = canAfford;
+  const onShowPaywall = onCreditsRequired;
+
+  return {
+    canAfford,
+    calculateCost,
+    onCreditsRequired,
+    onCreditCheck,
+    onShowPaywall,
+  };
+}

package/src/presentation/hooks/ai-feature-callbacks-execution.hooks.ts

@@ -0,0 +1,66 @@
+/**
+ * AI Feature Callbacks - Execution Hooks
+ * Generation execution callback hooks
+ */
+
+import { useCallback } from "react";
+import type { AIFeatureGenerationResult } from "./ai-feature-callbacks.types";
+
+export interface UseExecutionCallbackParams<TRequest, TResult> {
+  executor: (request: TRequest) => Promise<{
+    success: boolean;
+    data?: TResult;
+    error?: string;
+    imageUrl?: string;
+    imageUrls?: string[];
+  }>;
+  deductCredits?: (amount: number) => Promise<void>;
+  creditCostPerUnit: number;
+  onSuccess?: (result: TResult) => void;
+  onError?: (error: string) => void;
+}
+
+export interface ExecutionCallbacks<TRequest> {
+  executeGeneration: (request: TRequest) => Promise<AIFeatureGenerationResult>;
+}
+
+/**
+ * Hook for generation execution callback
+ */
+export function useExecutionCallback<TRequest = unknown, TResult = unknown>(
+  params: UseExecutionCallbackParams<TRequest, TResult>,
+): ExecutionCallbacks<TRequest> {
+  const { executor, deductCredits, creditCostPerUnit, onSuccess, onError } = params;
+
+  const executeGeneration = useCallback(
+    async (request: TRequest): Promise<AIFeatureGenerationResult> => {
+      try {
+        const result = await executor(request);
+
+        if (result.success && deductCredits) {
+          await deductCredits(creditCostPerUnit);
+        }
+
+        if (result.success && result.data) {
+          onSuccess?.(result.data);
+        } else if (!result.success && result.error) {
+          onError?.(result.error);
+        }
+
+        if (result.success) {
+          return { success: true, imageUrls: result.imageUrls ?? [] };
+        }
+        return { success: false, error: result.error ?? "Unknown error" };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        onError?.(message);
+        return { success: false, error: message };
+      }
+    },
+    [executor, deductCredits, creditCostPerUnit, onSuccess, onError],
+  );
+
+  return {
+    executeGeneration,
+  };
+}

package/src/presentation/hooks/ai-feature-callbacks.types.ts

@@ -0,0 +1,69 @@
+/**
+ * AI Feature Callbacks Type Definitions
+ * Type definitions for universal AI feature callbacks adapter
+ */
+
+/**
+ * Configuration for AI feature callbacks hook
+ * Generic over TRequest and TResult for type safety
+ */
+export interface AIFeatureCallbacksConfig<TRequest = unknown, TResult = unknown> {
+  // App provides reactive state
+  userId: string | null;
+  isAuthenticated: boolean;
+  creditBalance: number;
+
+  // Cost config
+  creditCostPerUnit: number;
+
+  // Executor - the actual generation function
+  executor: (request: TRequest) => Promise<{
+    success: boolean;
+    data?: TResult;
+    error?: string;
+    imageUrl?: string;
+    imageUrls?: string[];
+  }>;
+
+  // Actions from app - showAuthModal accepts callback for post-auth resume
+  showAuthModal: (callback?: () => void) => void;
+  openPaywall: () => void;
+  deductCredits?: (amount: number) => Promise<void>;
+
+  // Optional callbacks
+  onSuccess?: (result: TResult) => void;
+  onError?: (error: string) => void;
+}
+
+/**
+ * Discriminated union result type for generation
+ */
+export type AIFeatureGenerationResult =
+  | { success: true; imageUrls: string[] }
+  | { success: false; error: string };
+
+/**
+ * Universal callbacks interface that maps to all feature-specific ones
+ * Compatible with TextToImageCallbacks, ImageToVideoCallbacks, TextToVideoCallbacks
+ */
+export interface AIFeatureCallbacks<TRequest = unknown, TResult = unknown> {
+  // User state - needed by orchestrator
+  userId: string | null;
+
+  // TextToImageCallbacks compatible
+  executeGeneration: (request: TRequest) => Promise<AIFeatureGenerationResult>;
+  calculateCost: (multiplier?: number, _model?: string | null) => number;
+  canAfford: (cost: number) => boolean;
+  isAuthenticated: () => boolean;
+  onAuthRequired: () => void;
+  onCreditsRequired: (cost?: number) => void;
+  onSuccess?: (result: TResult) => void;
+  onError?: (error: string) => void;
+
+  // ImageToVideoCallbacks compatible
+  onCreditCheck: (cost: number) => boolean;
+  onShowPaywall: (cost: number) => void;
+
+  // TextToVideoCallbacks compatible
+  onAuthCheck: () => boolean;
+}