@umituz/react-native-ai-generation-content 1.20.6 → 1.20.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-generation-content",
-  "version": "1.20.6",
+  "version": "1.20.8",
   "description": "Provider-agnostic AI generation orchestration for React Native with result preview components",
   "main": "src/index.ts",
   "types": "src/index.ts",

package/src/domain/entities/index.ts

@@ -9,3 +9,4 @@ export * from "./polling.types";
 export * from "./progress.types";
 export * from "./middleware.types";
 export * from "./job.types";
+export * from "./processing-modes.types";

package/src/features/text-to-image/index.ts

@@ -76,7 +76,7 @@ export {
 export type {
   UseFormStateOptions,
   UseFormStateReturn,
-  GenerationState,
+  TextToImageGenerationState,
   UseGenerationOptions,
   UseGenerationReturn,
   UseTextToImageFormOptions,

package/src/features/text-to-image/presentation/hooks/index.ts

@@ -10,7 +10,7 @@ export type { UseFormStateOptions, UseFormStateReturn } from "./useFormState";
 // Generation Hook
 export { useGeneration } from "./useGeneration";
 export type {
-  GenerationState,
+  TextToImageGenerationState,
   UseGenerationOptions,
   UseGenerationReturn,
 } from "./useGeneration";

package/src/features/text-to-image/presentation/hooks/useGeneration.ts

@@ -25,14 +25,14 @@ export interface UseGenerationOptions {
   onPromptCleared?: () => void;
 }
 
-export interface GenerationState {
+export interface TextToImageGenerationState {
   isGenerating: boolean;
   progress: number;
   error: string | null;
 }
 
 export interface UseGenerationReturn {
-  generationState: GenerationState;
+  generationState: TextToImageGenerationState;
   totalCost: number;
   handleGenerate: () => Promise<TextToImageGenerationResult | null>;
 }

package/src/features/text-to-image/presentation/hooks/useTextToImageForm.ts

@@ -5,7 +5,7 @@
 
 import { useMemo } from "react";
 import { useFormState, type UseFormStateOptions } from "./useFormState";
-import { useGeneration, type GenerationState } from "./useGeneration";
+import { useGeneration, type TextToImageGenerationState } from "./useGeneration";
 import type {
   TextToImageFormState,
   TextToImageFormActions,
@@ -19,7 +19,7 @@ export interface UseTextToImageFormOptions extends UseFormStateOptions {
 export interface UseTextToImageFormReturn {
   state: TextToImageFormState;
   actions: TextToImageFormActions;
-  generationState: GenerationState;
+  generationState: TextToImageGenerationState;
   totalCost: number;
   handleGenerate: () => Promise<void>;
   isReady: boolean;

package/src/infrastructure/utils/index.ts

@@ -11,3 +11,4 @@ export * from "./url-extractor.util";
 export * from "./photo-generation";
 export * from "./feature-utils";
 export * from "./video-helpers";
+export * from "./video-result-extractor.util";

package/src/domains/flashcard-generation/FlashcardGenerationService.ts

@@ -1,104 +0,0 @@
-/**
- * Flashcard Generation Service
- * AI-powered flashcard generation for educational content
- */
-
-import type {
-  FlashcardGenerationRequest,
-  FlashcardGenerationResult,
-  FlashcardGenerationResponse,
-  FlashcardValidationResult,
-} from "./types/flashcard.types";
-import { buildFlashcardPrompt, calculateMaxTokens } from "./builders/flashcard-prompt.builder";
-import { parseFlashcardsFromResponse } from "./parsers/flashcard-response.parser";
-import { validateFlashcard } from "./validators/flashcard.validator";
-
-// Re-export types for backward compatibility
-export type {
-  FlashcardGenerationRequest,
-  FlashcardGenerationResult,
-  FlashcardValidationResult,
-  GeneratedFlashcard,
-} from "./types/flashcard.types";
-
-const CREDITS_PER_FLASHCARD = 2;
-const MOCK_DELAY_MS = 2000;
-
-/**
- * Generate flashcards using AI
- */
-export async function generateFlashcards(
-  request: FlashcardGenerationRequest,
-): Promise<FlashcardGenerationResult> {
-  const startTime = Date.now();
-
-  try {
-    const prompt = buildFlashcardPrompt(request);
-    const response = await executeGeneration(prompt, request.count);
-    const flashcards = parseFlashcardsFromResponse(response, request);
-
-    return {
-      success: true,
-      flashcards,
-      creditsUsed: request.count * CREDITS_PER_FLASHCARD,
-      tokensUsed: response.metadata?.tokensUsed ?? 0,
-      processingTime: Date.now() - startTime,
-      requestId: response.jobId ?? `req_${Date.now()}`,
-    };
-  } catch (error) {
-    return {
-      success: false,
-      flashcards: [],
-      creditsUsed: 0,
-      tokensUsed: 0,
-      processingTime: 0,
-      error: error instanceof Error ? error.message : "Unknown error",
-      requestId: "",
-    };
-  }
-}
-
-/**
- * Validate flashcard content quality
- */
-export function validateFlashcardContent(
-  front: string,
-  back: string,
-): FlashcardValidationResult {
-  return validateFlashcard(front, back);
-}
-
-async function executeGeneration(
-  _prompt: string,
-  count: number,
-): Promise<FlashcardGenerationResponse> {
-  // Mock implementation - integrate with actual AI orchestrator
-  await new Promise((resolve) => setTimeout(resolve, MOCK_DELAY_MS));
-
-  const maxTokens = calculateMaxTokens(count);
-  return {
-    success: true,
-    result: generateMockContent(count),
-    metadata: { tokensUsed: maxTokens, processingTime: MOCK_DELAY_MS },
-    jobId: `job_${Date.now()}`,
-  };
-}
-
-function generateMockContent(count: number): string {
-  const mockFlashcards = [
-    {
-      front: "What is photosynthesis?",
-      back: "The process by which plants convert sunlight into glucose.",
-      difficulty: "medium",
-      tags: ["biology", "science"],
-    },
-    {
-      front: "Define gravity",
-      back: "A force that attracts objects with mass toward each other.",
-      difficulty: "easy",
-      tags: ["physics", "science"],
-    },
-  ];
-
-  return JSON.stringify(mockFlashcards.slice(0, count));
-}

package/src/domains/flashcard-generation/builders/flashcard-prompt.builder.ts

@@ -1,55 +0,0 @@
-/**
- * Flashcard Prompt Builder
- * Builds AI prompts for flashcard generation
- */
-
-import type { FlashcardGenerationRequest, FlashcardDifficulty, FlashcardFormat } from "../types/flashcard.types";
-
-const QUALITY_MAP: Record<FlashcardDifficulty, string> = {
-  beginner: "simple, clear language appropriate for learners just starting out",
-  intermediate: "moderate complexity with some technical terms expected to be known",
-  advanced: "complex content with specialized terminology and nuanced concepts",
-};
-
-const FORMAT_INSTRUCTIONS: Record<FlashcardFormat, string> = {
-  qa: "Format as Question-Answer pairs",
-  definition: "Format as Term-Definition pairs",
-  fill_blank: "Format as Fill-in-the-blank exercises",
-  multiple_choice: "Format as Multiple Choice questions with one correct answer",
-};
-
-export function buildFlashcardPrompt(request: FlashcardGenerationRequest): string {
-  const format = request.format ?? "qa";
-  const language = request.language ?? "English";
-  const tags = request.tags?.join(", ") ?? "auto-generated";
-  const context = request.context ?? "General learning";
-
-  return `Generate ${request.count} educational flashcards about "${request.topic}".
-
-Topic Context: ${context}
-Difficulty Level: ${request.difficulty} - ${QUALITY_MAP[request.difficulty]}
-Format: ${format} - ${FORMAT_INSTRUCTIONS[format]}
-Language: ${language}
-Tags to include: ${tags}
-
-Requirements:
-- Questions should be clear and concise
-- Answers should be accurate and comprehensive
-- Content should be age and difficulty appropriate
-- Include relevant educational context
-- Make it engaging and memorable
-
-Output format: JSON array with structure:
-[
-  {
-    "front": "Question text here",
-    "back": "Answer text here",
-    "difficulty": "easy|medium|hard",
-    "tags": ["tag1", "tag2"]
-  }
-]`;
-}
-
-export function calculateMaxTokens(count: number): number {
-  return Math.max(count * 50, 200);
-}

package/src/domains/flashcard-generation/parsers/flashcard-response.parser.ts

@@ -1,68 +0,0 @@
-/**
- * Flashcard Response Parser
- * Parses AI responses into structured flashcard data
- */
-
-import type {
-  FlashcardGenerationRequest,
-  FlashcardGenerationResponse,
-  GeneratedFlashcard,
-  FlashcardDifficultyLevel,
-} from "../types/flashcard.types";
-
-interface RawFlashcard {
-  front?: string;
-  back?: string;
-  difficulty?: FlashcardDifficultyLevel;
-  tags?: string | string[];
-}
-
-export function parseFlashcardsFromResponse(
-  response: FlashcardGenerationResponse,
-  request: FlashcardGenerationRequest,
-): GeneratedFlashcard[] {
-  try {
-    const rawFlashcards = extractRawFlashcards(response.result);
-    return rawFlashcards.map((item, index) => mapToGeneratedFlashcard(item, request, index));
-  } catch (error) {
-    if (__DEV__) {
-       
-      console.error("Failed to parse AI response:", error);
-    }
-    return [];
-  }
-}
-
-function extractRawFlashcards(result: string | unknown[]): RawFlashcard[] {
-  if (typeof result === "string") {
-    return JSON.parse(result) as RawFlashcard[];
-  }
-  if (Array.isArray(result)) {
-    return result as RawFlashcard[];
-  }
-  throw new Error("Invalid AI response format");
-}
-
-function mapToGeneratedFlashcard(
-  raw: RawFlashcard,
-  request: FlashcardGenerationRequest,
-  index: number,
-): GeneratedFlashcard {
-  return {
-    id: `generated_${Date.now()}_${index}`,
-    front: raw.front ?? "",
-    back: raw.back ?? "",
-    difficulty: raw.difficulty ?? "medium",
-    tags: normalizeTags(raw.tags),
-    source: "ai_generated",
-    generationRequest: request,
-    confidence: 0.8 + Math.random() * 0.2,
-    createdAt: new Date().toISOString(),
-  };
-}
-
-function normalizeTags(tags: string | string[] | undefined): string[] {
-  if (Array.isArray(tags)) return tags;
-  if (typeof tags === "string") return [tags];
-  return [];
-}

package/src/domains/flashcard-generation/types/flashcard.types.ts

@@ -1,56 +0,0 @@
-/**
- * Flashcard Types
- * Type definitions for flashcard generation feature
- */
-
-export type FlashcardDifficulty = "beginner" | "intermediate" | "advanced";
-export type FlashcardDifficultyLevel = "easy" | "medium" | "hard";
-export type FlashcardFormat = "qa" | "definition" | "fill_blank" | "multiple_choice";
-
-export interface FlashcardGenerationRequest {
-  topic: string;
-  difficulty: FlashcardDifficulty;
-  count: number;
-  language?: string;
-  format?: FlashcardFormat;
-  context?: string;
-  tags?: string[];
-  includeImages?: boolean;
-}
-
-export interface GeneratedFlashcard {
-  id: string;
-  front: string;
-  back: string;
-  difficulty: FlashcardDifficultyLevel;
-  tags: string[];
-  source: "ai_generated";
-  generationRequest: FlashcardGenerationRequest;
-  confidence: number;
-  createdAt?: string;
-}
-
-export interface FlashcardGenerationResult {
-  success: boolean;
-  flashcards: GeneratedFlashcard[];
-  creditsUsed: number;
-  tokensUsed: number;
-  processingTime: number;
-  error?: string;
-  requestId: string;
-}
-
-export interface FlashcardValidationResult {
-  accuracy: number;
-  relevance: number;
-  clarity: number;
-  completeness: number;
-  overall: number;
-}
-
-export interface FlashcardGenerationResponse {
-  success: boolean;
-  result: string | unknown[];
-  metadata: { tokensUsed: number; processingTime: number };
-  jobId: string;
-}

package/src/domains/flashcard-generation/validators/flashcard.validator.ts

@@ -1,67 +0,0 @@
-/**
- * Flashcard Validator
- * Validates and scores generated flashcard content
- */
-
-import type { FlashcardValidationResult } from "../types/flashcard.types";
-
-const EDUCATIONAL_TERMS = [
-  "define", "explain", "describe", "what is",
-  "how does", "formula", "process", "function",
-];
-
-export function validateFlashcard(front: string, back: string): FlashcardValidationResult {
-  const accuracy = calculateAccuracy(front, back);
-  const relevance = calculateRelevance(front, back);
-  const clarity = calculateClarity(front, back);
-  const completeness = calculateCompleteness(front, back);
-  const overall = (accuracy + relevance + clarity + completeness) / 4;
-
-  return { accuracy, relevance, clarity, completeness, overall };
-}
-
-function calculateAccuracy(front: string, back: string): number {
-  let score = 0.5;
-
-  if (front.length >= 5 && front.length <= 200) score += 0.2;
-  if (back.length >= 10 && back.length <= 500) score += 0.2;
-
-  const frontWords = front.split(/\s+/).length;
-  const backWords = back.split(/\s+/).length;
-  if (backWords >= frontWords * 0.5 && backWords <= frontWords * 3) {
-    score += 0.1;
-  }
-
-  return Math.min(score, 1.0);
-}
-
-function calculateRelevance(front: string, back: string): number {
-  let score = 0.6;
-
-  const hasEducationalTerms = EDUCATIONAL_TERMS.some(
-    (term) => front.toLowerCase().includes(term) || back.toLowerCase().includes(term),
-  );
-
-  if (hasEducationalTerms) score += 0.3;
-  if (front.includes("?") || front.toLowerCase().includes("what is")) {
-    score += 0.1;
-  }
-
-  return Math.min(score, 1.0);
-}
-
-function calculateClarity(front: string, back: string): number {
-  let score = 0.5;
-
-  if (front.trim().endsWith("?")) score += 0.2;
-  if (!front.includes("...") && !back.includes("...")) score += 0.2;
-  if (!/[A-Z]{2,}/.test(front)) score += 0.1;
-
-  return Math.min(score, 1.0);
-}
-
-function calculateCompleteness(front: string, back: string): number {
-  const frontScore = Math.min(front.length / 20, 1.0);
-  const backScore = Math.min(back.length / 50, 1.0);
-  return (frontScore + backScore) / 2;
-}

package/src/presentation/hooks/useFlashcardGeneration.ts

@@ -1,155 +0,0 @@
-/**
- * Flashcard Generation Hooks
- * React hooks for AI-powered flashcard generation
- */
-
-import React from "react";
-import type {
-  FlashcardGenerationRequest,
-  GeneratedFlashcard,
-  FlashcardGenerationResult,
-} from "../../domains/flashcard-generation/FlashcardGenerationService";
-
-export interface UseFlashcardGenerationResult {
-  generateFlashcards: (
-    request: FlashcardGenerationRequest,
-  ) => Promise<FlashcardGenerationResult>;
-  isGenerating: boolean;
-  result: FlashcardGenerationResult | null;
-  error: string | null;
-  reset: () => void;
-}
-
-export const useFlashcardGeneration = (): UseFlashcardGenerationResult => {
-  const [isGenerating, setIsGenerating] = React.useState(false);
-  const [result, setResult] = React.useState<FlashcardGenerationResult | null>(
-    null,
-  );
-  const [error, setError] = React.useState<string | null>(null);
-
-  const generateFlashcards = React.useCallback(
-    async (
-      request: FlashcardGenerationRequest,
-    ): Promise<FlashcardGenerationResult> => {
-      try {
-        setIsGenerating(true);
-        setError(null);
-
-        // This would use the actual FlashcardGenerationService
-        // For now, mock the implementation
-        await new Promise((resolve) => setTimeout(resolve, 2000));
-
-        const flashcards: GeneratedFlashcard[] = [];
-        for (let i = 0; i < request.count; i++) {
-          flashcards.push({
-            id: `generated_${Date.now()}_${i}`,
-            front: `Mock question ${i + 1} about ${request.topic}`,
-            back: `Mock answer ${i + 1} for ${request.topic}`,
-            difficulty: i % 3 === 0 ? "easy" : i % 3 === 1 ? "medium" : "hard",
-            tags: [
-              ...(request.tags || []),
-              request.topic.toLowerCase().replace(/\s+/g, "_"),
-            ],
-            source: "ai_generated",
-            generationRequest: request,
-            confidence: 0.8 + Math.random() * 0.2,
-            createdAt: new Date().toISOString(),
-          });
-        }
-
-        const generationResult: FlashcardGenerationResult = {
-          success: true,
-          flashcards,
-          creditsUsed: request.count * 2,
-          tokensUsed: request.count * 100,
-          processingTime: 2000,
-          requestId: `req_${Date.now()}`,
-        };
-
-        setResult(generationResult);
-        return generationResult;
-      } catch (err) {
-        const errorMessage =
-          err instanceof Error ? err.message : "Generation failed";
-        setError(errorMessage);
-        setIsGenerating(false);
-
-        return {
-          success: false,
-          flashcards: [],
-          creditsUsed: 0,
-          tokensUsed: 0,
-          processingTime: 0,
-          error: errorMessage,
-          requestId: `req_${Date.now()}`,
-        };
-      } finally {
-        setIsGenerating(false);
-      }
-    },
-    [],
-  );
-
-  const reset = React.useCallback(() => {
-    setResult(null);
-    setError(null);
-    setIsGenerating(false);
-  }, []);
-
-  return {
-    generateFlashcards,
-    isGenerating,
-    result,
-    error,
-    reset,
-  };
-};
-
-export interface UseFlashcardValidationResult {
-  validateFlashcard: (
-    front: string,
-    back: string,
-  ) => Promise<{
-    accuracy: number;
-    relevance: number;
-    clarity: number;
-    completeness: number;
-    overall: number;
-  }>;
-  isValidating: boolean;
-}
-
-export const useFlashcardValidation = (): UseFlashcardValidationResult => {
-  const [isValidating, setIsValidating] = React.useState(false);
-
-  const validateFlashcard = React.useCallback(
-    async (front: string, back: string) => {
-      setIsValidating(true);
-
-      // Mock validation - in production would use actual service
-      await new Promise((resolve) => setTimeout(resolve, 500));
-
-      const accuracy = Math.min(1, front.length / 10);
-      const relevance = Math.min(1, back.length / 25);
-      const clarity = Math.min(1, 1 - front.split(/\s+/).length / 20);
-      const completeness = Math.min(1, back.length / 50);
-      const overall = (accuracy + relevance + clarity + completeness) / 4;
-
-      setIsValidating(false);
-
-      return {
-        accuracy,
-        relevance,
-        clarity,
-        completeness,
-        overall,
-      };
-    },
-    [],
-  );
-
-  return {
-    validateFlashcard,
-    isValidating,
-  };
-};