@umituz/react-native-ai-generation-content 1.61.39 → 1.61.41

package/src/features/text-to-video/presentation/screens/TextToVideoWizardFlow.tsx

@@ -3,26 +3,19 @@
  * Step-based wizard flow for text-to-video generation
  */
 
-import React, { useMemo, useCallback, useEffect, useRef } from "react";
+import React, { useMemo } from "react";
 import { View, StyleSheet } from "react-native";
 import { useAppDesignTokens } from "@umituz/react-native-design-system";
 import { GenericWizardFlow } from "../../../../domains/generation/wizard/presentation/components";
 import { TEXT_TO_VIDEO_WIZARD_CONFIG } from "../../../../domains/generation/wizard/configs";
 import { useAIFeatureGate } from "../../../../domains/access-control";
-import type { WizardScenarioData } from "../../../../domains/generation/wizard/presentation/hooks/useWizardGeneration";
+import {
+  createDefaultAlerts,
+  createScenarioData,
+  useWizardFlowHandlers,
+  AutoSkipPreview,
+} from "../../../shared";
 import type { BaseWizardFlowProps } from "../../../../domains/generation/wizard/presentation/components/WizardFlow.types";
-import type { AlertMessages } from "../../../../presentation/hooks/generation/types";
-
-const AutoSkipPreview: React.FC<{ onContinue: () => void }> = ({ onContinue }) => {
-  const hasContinued = useRef(false);
-  useEffect(() => {
-    if (!hasContinued.current) {
-      hasContinued.current = true;
-      onContinue();
-    }
-  }, [onContinue]);
-  return null;
-};
 
 export type TextToVideoWizardFlowProps = BaseWizardFlowProps;
 
@@ -41,46 +34,33 @@ export const TextToVideoWizardFlow: React.FC<TextToVideoWizardFlowProps> = (prop
 
   const tokens = useAppDesignTokens();
 
-  // Centralized access control - handles offline, auth, credits, paywall
   const { requireFeature } = useAIFeatureGate({
     creditCost,
     onNetworkError,
   });
 
-  const scenario: WizardScenarioData = useMemo(
-    () => ({
-      id: "text-to-video",
-      outputType: "video",
-      inputType: "text",
-      model,
-      title: t("text2video.title"),
-    }),
-    [model, t],
-  );
-
-  const defaultAlerts = useMemo<AlertMessages>(
-    () => ({
-      networkError: t("common.errors.network"),
-      policyViolation: t("common.errors.policy"),
-      saveFailed: t("common.errors.saveFailed"),
-      creditFailed: t("common.errors.creditFailed"),
-      unknown: t("common.errors.unknown"),
-    }),
-    [t],
+  const scenario = useMemo(
+    () =>
+      createScenarioData(
+        {
+          id: "text-to-video",
+          outputType: "video",
+          inputType: "text",
+          model,
+          titleKey: "text2video.title",
+        },
+        t
+      ),
+    [model, t]
   );
 
-  const handleGenerationStart = useCallback(
-    (_data: Record<string, unknown>, proceed: () => void) => {
-      // Use centralized access control - checks offline, auth, credits
-      requireFeature(proceed);
-    },
-    [requireFeature],
-  );
+  const defaultAlerts = useMemo(() => createDefaultAlerts(t), [t]);
 
-  const handleGenerationComplete = useCallback(() => {
-    onGenerationComplete?.();
-    onBack();
-  }, [onGenerationComplete, onBack]);
+  const { handleGenerationStart, handleGenerationComplete } = useWizardFlowHandlers({
+    requireFeature,
+    onGenerationComplete,
+    onBack,
+  });
 
   return (
     <View style={[styles.container, { backgroundColor: tokens.colors.backgroundPrimary }]}>

package/src/infrastructure/logging/debug.util.ts

@@ -5,7 +5,7 @@
 
 type LogLevel = "log" | "warn" | "error" | "info";
 
-interface DebugOptions {
+export interface DebugOptions {
   readonly tag?: string;
 }
 

package/src/infrastructure/logging/index.ts

@@ -3,4 +3,4 @@
  */
 
 export { debug } from "./debug.util";
-export type { DebugOptions };
+export type { DebugOptions } from "./debug.util";

package/src/infrastructure/validation/advanced-validator.ts

@@ -0,0 +1,97 @@
+/**
+ * Advanced Validation Utilities
+ * Complex validators for objects, arrays, and combined validations
+ */
+
+import type { ValidationResult } from "./base-validator";
+import { validateString } from "./base-validator";
+import type { StringValidationOptions } from "./base-validator";
+
+/**
+ * Validates object structure
+ */
+export function validateObject(
+  input: unknown,
+  requiredFields: readonly string[] = []
+): ValidationResult {
+  const errors: string[] = [];
+
+  if (typeof input !== "object" || input === null) {
+    return { isValid: false, errors: ["Input must be an object"] };
+  }
+
+  for (const field of requiredFields) {
+    if (!(field in input)) {
+      errors.push(`Missing required field: ${field}`);
+    }
+  }
+
+  return { isValid: errors.length === 0, errors };
+}
+
+/**
+ * Validates array input
+ */
+export function validateArray(
+  input: unknown,
+  options: {
+    readonly minLength?: number;
+    readonly maxLength?: number;
+    readonly itemType?: "string" | "number" | "object";
+  } = {}
+): ValidationResult {
+  const errors: string[] = [];
+
+  if (!Array.isArray(input)) {
+    return { isValid: false, errors: ["Input must be an array"] };
+  }
+
+  if (options.minLength !== undefined && input.length < options.minLength) {
+    errors.push(`Array must have at least ${options.minLength} items`);
+  }
+
+  if (options.maxLength !== undefined && input.length > options.maxLength) {
+    errors.push(`Array must have at most ${options.maxLength} items`);
+  }
+
+  if (options.itemType) {
+    for (let i = 0; i < input.length; i++) {
+      const item = input[i];
+      const isValidType =
+        options.itemType === "string"
+          ? typeof item === "string"
+          : options.itemType === "number"
+          ? typeof item === "number"
+          : typeof item === "object" && item !== null;
+
+      if (!isValidType) {
+        errors.push(`Item at index ${i} is not a ${options.itemType}`);
+      }
+    }
+  }
+
+  return { isValid: errors.length === 0, errors };
+}
+
+/**
+ * Combines multiple validation results
+ */
+export function combineValidationResults(
+  results: readonly ValidationResult[]
+): ValidationResult {
+  const allErrors = results.flatMap((r) => r.errors);
+  return { isValid: allErrors.length === 0, errors: allErrors };
+}
+
+/**
+ * Sanitizes and validates user input in one step
+ */
+export function sanitizeAndValidate(
+  input: unknown,
+  sanitizeFn: (input: unknown) => string,
+  options: StringValidationOptions = {}
+): { readonly sanitized: string; readonly validation: ValidationResult } {
+  const sanitized = sanitizeFn(input);
+  const validation = validateString(sanitized, options);
+  return { sanitized, validation };
+}

package/src/infrastructure/validation/ai-validator.ts

@@ -0,0 +1,77 @@
+/**
+ * AI-Specific Validation Utilities
+ * Validators for AI generation prompts and image data
+ */
+
+import {
+  MAX_PROMPT_LENGTH,
+  MIN_PROMPT_LENGTH,
+} from "../constants/validation.constants";
+import { validateString, validateURL, validateBase64, type ValidationResult, type StringValidationOptions } from "./base-validator";
+
+/**
+ * Validates prompt/input text for AI generation
+ */
+export function validateAIPrompt(input: unknown): ValidationResult {
+  const options: StringValidationOptions = {
+    minLength: MIN_PROMPT_LENGTH,
+    maxLength: MAX_PROMPT_LENGTH,
+    trim: true,
+  };
+  return validateString(input, options);
+}
+
+/**
+ * Validates image data (base64 or URL)
+ */
+export function validateImageData(input: unknown): ValidationResult {
+  if (typeof input !== "string") {
+    return { isValid: false, errors: ["Image data must be a string"] };
+  }
+
+  if (input.startsWith("http://") || input.startsWith("https://")) {
+    return validateURL(input);
+  }
+
+  if (input.startsWith("data:image/")) {
+    const base64Part = input.split(",")[1];
+    if (!base64Part) {
+      return { isValid: false, errors: ["Invalid data URI format"] };
+    }
+    return validateBase64(base64Part);
+  }
+
+  return {
+    isValid: false,
+    errors: ["Image data must be a URL or base64 data URI"],
+  };
+}
+
+/**
+ * Validates video URL
+ */
+export function validateVideoUrl(input: unknown): ValidationResult {
+  if (typeof input !== "string") {
+    return { isValid: false, errors: ["Video URL must be a string"] };
+  }
+
+  const urlResult = validateURL(input);
+  if (!urlResult.isValid) {
+    return urlResult;
+  }
+
+  const url = new URL(input);
+  const validExtensions = [".mp4", ".mov", ".webm", ".gif"];
+  const hasValidExtension = validExtensions.some((ext) =>
+    url.pathname.toLowerCase().endsWith(ext)
+  );
+
+  if (!hasValidExtension) {
+    return {
+      isValid: false,
+      errors: ["Video URL must have a valid video extension"],
+    };
+  }
+
+  return { isValid: true, errors: [] };
+}

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

@@ -0,0 +1,149 @@
+/**
+ * Base Validation Utilities
+ * Core validation functions for strings, numbers, URLs, emails, and base64
+ */
+
+/**
+ * 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;
+}
+
+/**
+ * Validates a string input against provided rules
+ */
+export function validateString(
+  input: unknown,
+  options: StringValidationOptions = {}
+): ValidationResult {
+  const errors: string[] = [];
+
+  if (typeof input !== "string") {
+    return { isValid: false, errors: ["Input must be a string"] };
+  }
+
+  const value = options.trim !== false ? input.trim() : input;
+
+  if (options.minLength !== undefined && value.length < options.minLength) {
+    errors.push(`Input must be at least ${options.minLength} characters`);
+  }
+
+  if (options.maxLength !== undefined && value.length > options.maxLength) {
+    errors.push(`Input must be at most ${options.maxLength} characters`);
+  }
+
+  if (options.pattern && !options.pattern.test(value)) {
+    errors.push("Input format is invalid");
+  }
+
+  if (options.allowedCharacters && !options.allowedCharacters.test(value)) {
+    errors.push("Input contains invalid characters");
+  }
+
+  return { isValid: errors.length === 0, errors };
+}
+
+/**
+ * Validates a numeric input
+ */
+export function validateNumber(
+  input: unknown,
+  options: NumericValidationOptions = {}
+): ValidationResult {
+  const errors: string[] = [];
+
+  if (typeof input !== "number" || isNaN(input)) {
+    return { isValid: false, errors: ["Input must be a number"] };
+  }
+
+  if (options.integer && !Number.isInteger(input)) {
+    errors.push("Input must be an integer");
+  }
+
+  if (options.min !== undefined && input < options.min) {
+    errors.push(`Input must be at least ${options.min}`);
+  }
+
+  if (options.max !== undefined && input > options.max) {
+    errors.push(`Input must be at most ${options.max}`);
+  }
+
+  return { isValid: errors.length === 0, errors };
+}
+
+/**
+ * Validates URL format
+ */
+export function validateURL(input: unknown): ValidationResult {
+  if (typeof input !== "string") {
+    return { isValid: false, errors: ["URL must be a string"] };
+  }
+
+  try {
+    const url = new URL(input);
+    if (!["http:", "https:"].includes(url.protocol)) {
+      return { isValid: false, errors: ["Only HTTP and HTTPS protocols are allowed"] };
+    }
+    return { isValid: true, errors: [] };
+  } catch {
+    return { isValid: false, errors: ["Invalid URL format"] };
+  }
+}
+
+/**
+ * Validates email format
+ */
+export function validateEmail(input: unknown): ValidationResult {
+  if (typeof input !== "string") {
+    return { isValid: false, errors: ["Email must be a string"] };
+  }
+
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  if (!emailRegex.test(input)) {
+    return { isValid: false, errors: ["Invalid email format"] };
+  }
+
+  return { isValid: true, errors: [] };
+}
+
+/**
+ * Validates base64 string
+ */
+export function validateBase64(input: unknown): ValidationResult {
+  if (typeof input !== "string") {
+    return { isValid: false, errors: ["Input must be a string"] };
+  }
+
+  const base64Regex = /^[A-Za-z0-9+/]*={0,2}$/;
+  if (!base64Regex.test(input)) {
+    return { isValid: false, errors: ["Invalid base64 format"] };
+  }
+
+  if (input.length % 4 !== 0) {
+    return { isValid: false, errors: ["Base64 string length must be a multiple of 4"] };
+  }
+
+  return { isValid: true, errors: [] };
+}

package/src/infrastructure/validation/entity-validator.ts

@@ -0,0 +1,64 @@
+/**
+ * Entity Validation Utilities
+ * Validators for domain entities like user ID and creation ID
+ */
+
+import { validateString, type ValidationResult, type StringValidationOptions } from "./base-validator";
+
+/**
+ * Validates user ID
+ */
+export function validateUserId(input: unknown): ValidationResult {
+  const options: StringValidationOptions = {
+    minLength: 1,
+    maxLength: 100,
+    pattern: /^[a-zA-Z0-9_-]+$/,
+  };
+  return validateString(input, options);
+}
+
+/**
+ * Validates creation ID
+ */
+export function validateCreationId(input: unknown): ValidationResult {
+  const options: StringValidationOptions = {
+    minLength: 1,
+    maxLength: 100,
+  };
+  return validateString(input, options);
+}
+
+/**
+ * Validates scenario ID
+ */
+export function validateScenarioId(input: unknown): ValidationResult {
+  const options: StringValidationOptions = {
+    minLength: 1,
+    maxLength: 100,
+    pattern: /^[a-z0-9-]+$/,
+  };
+  return validateString(input, options);
+}
+
+/**
+ * Validates model name
+ */
+export function validateModelName(input: unknown): ValidationResult {
+  const options: StringValidationOptions = {
+    minLength: 1,
+    maxLength: 100,
+  };
+  return validateString(input, options);
+}
+
+/**
+ * Validates provider name
+ */
+export function validateProviderName(input: unknown): ValidationResult {
+  const options: StringValidationOptions = {
+    minLength: 1,
+    maxLength: 50,
+    pattern: /^[a-z0-9-]+$/,
+  };
+  return validateString(input, options);
+}