@umituz/react-native-ai-generation-content 1.17.86 → 1.17.88

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-generation-content",
-  "version": "1.17.86",
+  "version": "1.17.88",
   "description": "Provider-agnostic AI generation orchestration for React Native",
   "main": "src/index.ts",
   "types": "src/index.ts",
@@ -84,9 +84,9 @@
     "expo-haptics": "^15.0.8",
     "expo-image": "^3.0.11",
     "expo-linear-gradient": "~15.0.7",
-    "expo-video": "^2.0.0",
     "expo-localization": "^17.0.8",
     "expo-sharing": "^14.0.8",
+    "expo-video": "^2.0.0",
     "firebase": "^12.6.0",
     "i18next": "^25.7.3",
     "react": "19.1.0",

package/src/domains/creations/index.ts

@@ -149,10 +149,13 @@ export {
 // Gallery Components
 export { CreationsHomeCard } from "./presentation/components/CreationsHomeCard";
 export { EmptyState } from "./presentation/components/EmptyState";
+
+// Utilities
 export {
-  CreationsProvider,
-  useCreationsProvider,
-} from "./presentation/components/CreationsProvider";
+  getLocalizedTitle,
+  getFilterCategoriesFromConfig,
+  getTranslatedTypes,
+} from "./presentation/utils/filterUtils";
 
 // =============================================================================
 // PRESENTATION LAYER - Screens

package/src/domains/creations/presentation/components/CreationBadges.tsx

@@ -78,17 +78,17 @@ export function CreationBadges({
           paddingHorizontal: 8,
           paddingVertical: 4,
           borderRadius: 12,
-          backgroundColor: "rgba(0,0,0,0.6)",
+          backgroundColor: tokens.colors.modalOverlay,
           gap: 4,
         },
         typeText: {
           fontSize: 10,
           fontWeight: "600",
-          color: "white",
+          color: tokens.colors.textInverse,
           textTransform: "capitalize",
         },
       }),
-    [statusColor]
+    [statusColor, tokens]
   );
 
   return (

package/src/domains/creations/presentation/components/CreationDetail/DetailStory.tsx

@@ -2,7 +2,6 @@
 import React from 'react';
 import { View, StyleSheet } from 'react-native';
 import { AtomicText, useAppDesignTokens, type DesignTokens } from "@umituz/react-native-design-system";
-import { LinearGradient } from 'expo-linear-gradient';
 
 interface DetailStoryProps {
     readonly story: string;
@@ -16,16 +15,13 @@ export const DetailStory: React.FC<DetailStoryProps> = ({ story }) => {
 
     return (
         <View style={styles.container}>
-            <LinearGradient
-                colors={[tokens.colors.primary + '15', tokens.colors.primary + '05']}
-                style={styles.gradient}
-            >
+            <View style={styles.storyContainer}>
                 <AtomicText style={styles.quoteMark}>&quot;</AtomicText>
                 <AtomicText style={styles.text}>{story}</AtomicText>
                 <View style={styles.quoteEndRow}>
                     <AtomicText style={[styles.quoteMark, styles.quoteEnd]}>&quot;</AtomicText>
                 </View>
-            </LinearGradient>
+            </View>
         </View>
     );
 };
@@ -35,11 +31,12 @@ const useStyles = (tokens: DesignTokens) => StyleSheet.create({
         paddingHorizontal: tokens.spacing.lg,
         marginBottom: tokens.spacing.lg,
     },
-    gradient: {
+    storyContainer: {
         padding: tokens.spacing.lg,
         borderRadius: 20,
         borderWidth: 1,
-        borderColor: tokens.colors.primary + '20',
+        borderColor: tokens.colors.border,
+        backgroundColor: tokens.colors.surface,
     },
     quoteMark: {
         fontSize: 48,

package/src/domains/creations/presentation/components/CreationThumbnail.tsx

@@ -35,7 +35,7 @@ export function CreationThumbnail({
         },
         overlay: {
           ...StyleSheet.absoluteFillObject,
-          backgroundColor: "rgba(0, 0, 0, 0.5)",
+          backgroundColor: tokens.colors.modalOverlay,
           borderRadius: tokens.spacing.sm,
           justifyContent: "center",
           alignItems: "center",

package/src/domains/creations/presentation/components/index.ts

@@ -31,9 +31,6 @@ export { CreationsHomeCard } from "./CreationsHomeCard";
 export { CreationImageViewer } from "./CreationImageViewer";
 export { CreationsGrid } from "./CreationsGrid";
 
-// Provider
-export { CreationsProvider, useCreationsProvider } from "./CreationsProvider";
-
 // Detail Components
 export { DetailHeader } from "./CreationDetail/DetailHeader";
 export { DetailImage } from "./CreationDetail/DetailImage";

package/src/domains/creations/presentation/screens/CreationDetailScreen.tsx

@@ -3,20 +3,21 @@ import { View, ScrollView, StyleSheet } from 'react-native';
 import { useSafeAreaInsets } from 'react-native-safe-area-context';
 import { useAppDesignTokens } from "@umituz/react-native-design-system";
 import type { Creation } from '../../domain/entities/Creation';
+import type { CreationsConfig } from '../../domain/value-objects/CreationsConfig';
 import { hasVideoContent, getPreviewUrl } from '../../domain/utils';
 import { DetailHeader } from '../components/CreationDetail/DetailHeader';
 import { DetailImage } from '../components/CreationDetail/DetailImage';
 import { DetailVideo } from '../components/CreationDetail/DetailVideo';
 import { DetailStory } from '../components/CreationDetail/DetailStory';
 import { DetailActions } from '../components/CreationDetail/DetailActions';
-
-import { useCreationsProvider } from '../components/CreationsProvider';
+import { getLocalizedTitle } from '../utils/filterUtils';
 
 /** Video creation types */
 const VIDEO_TYPES = ['text-to-video', 'image-to-video'] as const;
 
 interface CreationDetailScreenProps {
     readonly creation: Creation;
+    readonly config: CreationsConfig;
     readonly onClose: () => void;
     readonly onShare: (creation: Creation) => void;
     readonly onDelete: (creation: Creation) => void;
@@ -32,6 +33,7 @@ interface CreationMetadata {
 
 export const CreationDetailScreen: React.FC<CreationDetailScreenProps> = ({
     creation,
+    config,
     onClose,
     onShare,
     onDelete,
@@ -39,7 +41,6 @@ export const CreationDetailScreen: React.FC<CreationDetailScreenProps> = ({
 }) => {
     const tokens = useAppDesignTokens();
     const insets = useSafeAreaInsets();
-    const { getLocalizedTitle } = useCreationsProvider();
 
     // Extract data safely
     const metadata = (creation.metadata || {}) as CreationMetadata;
@@ -48,7 +49,7 @@ export const CreationDetailScreen: React.FC<CreationDetailScreenProps> = ({
     // 1. Manually set names in metadata
     // 2. Localized title from config types mapping
     // 3. Fallback to raw creation type (formatted)
-    const title = metadata.names || getLocalizedTitle(creation.type);
+    const title = metadata.names || getLocalizedTitle(config, t, creation.type);
     const story = metadata.story || metadata.description || "";
     const date = metadata.date || new Date(creation.createdAt).toLocaleDateString();
 

package/src/domains/creations/presentation/screens/CreationsGalleryScreen.tsx

@@ -19,7 +19,6 @@ import type { Creation } from "../../domain/entities/Creation";
 import type { CreationsConfig } from "../../domain/value-objects/CreationsConfig";
 import type { ICreationsRepository } from "../../domain/repositories/ICreationsRepository";
 import { CreationDetailScreen } from "./CreationDetailScreen";
-import { CreationsProvider } from "../components/CreationsProvider";
 
 interface CreationsGalleryScreenProps {
   readonly userId: string | null;
@@ -34,15 +33,7 @@ interface CreationsGalleryScreenProps {
   readonly showFilter?: boolean;
 }
 
-export function CreationsGalleryScreen(props: CreationsGalleryScreenProps) {
-  return (
-    <CreationsProvider config={props.config} t={props.t}>
-      <CreationsGalleryScreenContent {...props} />
-    </CreationsProvider>
-  );
-}
-
-function CreationsGalleryScreenContent({
+export function CreationsGalleryScreen({
   userId,
   repository,
   config,
@@ -164,7 +155,7 @@ function CreationsGalleryScreenContent({
   ), [isLoading, creations, filters.isFiltered, tokens, t, config, emptyActionLabel, onEmptyAction, filters.clearAllFilters]);
 
   if (selectedCreation) {
-    return <CreationDetailScreen creation={selectedCreation} onClose={() => setSelectedCreation(null)} onShare={handleShare} onDelete={handleDelete} t={t} />;
+    return <CreationDetailScreen creation={selectedCreation} config={config} onClose={() => setSelectedCreation(null)} onShare={handleShare} onDelete={handleDelete} t={t} />;
   }
 
   return (

package/src/domains/creations/presentation/utils/filterUtils.ts

@@ -36,7 +36,7 @@ export const getFilterCategoriesFromConfig = (
 
 /**
  * Translates the creation types for display.
- * 
+ *
  * @param config The creations configuration object
  * @param t Translation function
  * @returns Array of types with translated labels
@@ -50,3 +50,20 @@ export const getTranslatedTypes = (
         labelKey: t(type.labelKey)
     }));
 };
+
+/**
+ * Gets the localized title for a creation type.
+ *
+ * @param config The creations configuration object
+ * @param t Translation function
+ * @param typeId The creation type ID
+ * @returns Localized title string
+ */
+export const getLocalizedTitle = (
+    config: CreationsConfig,
+    t: (key: string) => string,
+    typeId: string
+): string => {
+    const typeConfig = config.types.find(type => type.id === typeId);
+    return typeConfig ? t(typeConfig.labelKey) : typeId;
+};

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

@@ -3,328 +3,102 @@
  * AI-powered flashcard generation for educational content
  */
 
-export interface FlashcardGenerationRequest {
-  topic: string;
-  difficulty: "beginner" | "intermediate" | "advanced";
-  count: number;
-  language?: string;
-  format?: "qa" | "definition" | "fill_blank" | "multiple_choice";
-  context?: string;
-  tags?: string[];
-  includeImages?: boolean;
-}
-
-export interface GeneratedFlashcard {
-  id: string;
-  front: string;
-  back: string;
-  difficulty: "easy" | "medium" | "hard";
-  tags: string[];
-  source: "ai_generated";
-  generationRequest: FlashcardGenerationRequest;
-  confidence: number; // 0-1 score
-  createdAt?: string;
-}
-
-export interface FlashcardGenerationResult {
-  success: boolean;
-  flashcards: GeneratedFlashcard[];
-  creditsUsed: number;
-  tokensUsed: number;
-  processingTime: number; // milliseconds
-  error?: string;
-  requestId: string;
-}
-
-export class FlashcardGenerationService {
-  private static instance: FlashcardGenerationService;
-
-  static getInstance(): FlashcardGenerationService {
-    if (!FlashcardGenerationService.instance) {
-      FlashcardGenerationService.instance = new FlashcardGenerationService();
-    }
-    return FlashcardGenerationService.instance;
-  }
+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
-   */
-  async generateFlashcards(
-    request: FlashcardGenerationRequest,
-  ): Promise<FlashcardGenerationResult> {
-    try {
-      const startTime = Date.now();
-
-      // Create AI generation prompt
-      const prompt = this.buildFlashcardPrompt(request);
-
-      // Execute generation
-      const result = await this.executeGeneration(prompt, request.count);
-
-      // Parse AI response into flashcards
-      const flashcards = this.parseFlashcardsFromResult(result, request);
-      const processingTime = Date.now() - startTime;
-
-      return {
-        success: true,
-        flashcards,
-        creditsUsed: request.count * 2, // 2 credits per flashcard
-        tokensUsed: result.metadata?.tokensUsed || 0,
-        processingTime,
-        requestId: result.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: "",
-      };
-    }
-  }
+/**
+ * Generate flashcards using AI
+ */
+export async function generateFlashcards(
+  request: FlashcardGenerationRequest,
+): Promise<FlashcardGenerationResult> {
+  const startTime = Date.now();
 
-  /**
-   * Validate generated flashcard content
-   */
-  async validateFlashcard(
-    front: string,
-    back: string,
-  ): Promise<{
-    accuracy: number;
-    relevance: number;
-    clarity: number;
-    completeness: number;
-    overall: number;
-  }> {
-    // Simple validation heuristic
-    const accuracy = this.calculateAccuracy(front, back);
-    const relevance = this.calculateRelevance(front, back);
-    const clarity = this.calculateClarity(front, back);
-    const completeness = this.calculateCompleteness(front, back);
-    const overall = (accuracy + relevance + clarity + completeness) / 4;
+  try {
+    const prompt = buildFlashcardPrompt(request);
+    const response = await executeGeneration(prompt, request.count);
+    const flashcards = parseFlashcardsFromResponse(response, request);
 
     return {
-      accuracy,
-      relevance,
-      clarity,
-      completeness,
-      overall,
-    };
-  }
-
-  private buildFlashcardPrompt(request: FlashcardGenerationRequest): string {
-    const qualityMap = {
-      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 formatInstructions = {
-      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",
+      success: true,
+      flashcards,
+      creditsUsed: request.count * CREDITS_PER_FLASHCARD,
+      tokensUsed: response.metadata?.tokensUsed ?? 0,
+      processingTime: Date.now() - startTime,
+      requestId: response.jobId ?? `req_${Date.now()}`,
     };
-
-    return `Generate ${request.count} educational flashcards about "${request.topic}".
-    
-Topic Context: ${request.context || "General learning"}
-Difficulty Level: ${request.difficulty} - ${qualityMap[request.difficulty]}
-Format: ${request.format || "qa"} - ${formatInstructions[request.format || "qa"]}
-Language: ${request.language || "English"}
-Tags to include: ${request.tags?.join(", ") || "auto-generated"}
-
-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"]
-  }
-]`;
-  }
-
-  private calculateMaxTokens(count: number): number {
-    // Estimate ~50 tokens per flashcard + overhead
-    return Math.max(count * 50, 200);
-  }
-
-  private async executeGeneration(
-    prompt: string,
-    count: number,
-  ): Promise<{
-    success: boolean;
-    result: string;
-    metadata: { tokensUsed: number; processingTime: number };
-    jobId: string;
-  }> {
-    // This would integrate with the actual AI generation orchestrator
-    // For now, return mock result
-    await new Promise((resolve) => setTimeout(resolve, 2000));
-
-    const maxTokens = this.calculateMaxTokens(count);
+  } catch (error) {
     return {
-      success: true,
-      result: this.generateMockContent(maxTokens),
-      metadata: {
-        tokensUsed: maxTokens,
-        processingTime: 2000,
-      },
-      jobId: `job_${Date.now()}`,
+      success: false,
+      flashcards: [],
+      creditsUsed: 0,
+      tokensUsed: 0,
+      processingTime: 0,
+      error: error instanceof Error ? error.message : "Unknown error",
+      requestId: "",
     };
   }
+}
 
-  private generateMockContent(maxTokens: number): string {
-    const mockFlashcards = [
-      {
-        front: "What is photosynthesis?",
-        back: "The process by which plants convert sunlight, water, and carbon dioxide into glucose and oxygen.",
-        difficulty: "medium",
-        tags: ["biology", "science", "plants"],
-      },
-      {
-        front: "Define gravity",
-        back: "A fundamental force that attracts objects with mass toward each other.",
-        difficulty: "easy",
-        tags: ["physics", "science", "forces"],
-      },
-      {
-        front: "What is the formula for water?",
-        back: "H₂O",
-        difficulty: "easy",
-        tags: ["chemistry", "science", "molecules"],
-      },
-    ];
+/**
+ * Validate flashcard content quality
+ */
+export function validateFlashcardContent(
+  front: string,
+  back: string,
+): FlashcardValidationResult {
+  return validateFlashcard(front, back);
+}
 
-    return JSON.stringify(mockFlashcards.slice(0, Math.floor(maxTokens / 100)));
-  }
+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()}`,
+  };
+}
 
-  private parseFlashcardsFromResult(
-    result: {
-      success: boolean;
-      result: string | unknown[];
-      metadata: { tokensUsed: number; processingTime: number };
-      jobId: string;
+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"],
     },
-    request: FlashcardGenerationRequest,
-  ): GeneratedFlashcard[] {
-    try {
-      let flashcards: unknown[];
-
-      if (typeof result.result === "string") {
-        flashcards = JSON.parse(result.result);
-      } else if (Array.isArray(result.result)) {
-        flashcards = result.result;
-      } else {
-        throw new Error("Invalid AI response format");
-      }
-
-      return flashcards.map((item: unknown, index) => {
-        const flashcard = item as {
-          front?: string;
-          back?: string;
-          difficulty?: "easy" | "medium" | "hard";
-          tags?: string | string[];
-        };
-        return {
-          id: `generated_${Date.now()}_${index}`,
-          front: flashcard.front || "",
-          back: flashcard.back || "",
-          difficulty: flashcard.difficulty || "medium",
-          tags: Array.isArray(flashcard.tags)
-            ? flashcard.tags
-            : flashcard.tags
-              ? [flashcard.tags]
-              : [],
-          source: "ai_generated" as const,
-          generationRequest: request,
-          confidence: 0.8 + Math.random() * 0.2, // 0.8-1.0
-          createdAt: new Date().toISOString(),
-        };
-      });
-    } catch (error) {
-      if (__DEV__) {
-        // eslint-disable-next-line no-console
-        console.error("Failed to parse AI response:", error);
-      }
-      return [];
-    }
-  }
-
-  private calculateAccuracy(front: string, back: string): number {
-    // Simple heuristics for accuracy assessment
-    let score = 0.5; // Base score
-
-    // Check for reasonable length
-    if (front.length >= 5 && front.length <= 200) score += 0.2;
-    if (back.length >= 10 && back.length <= 500) score += 0.2;
-
-    // Check for balanced content
-    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);
-  }
-
-  private calculateRelevance(front: string, back: string): number {
-    // Simple relevance check
-    let score = 0.6; // Base score
-
-    // Check for educational content indicators
-    const educationalTerms = [
-      "define",
-      "explain",
-      "describe",
-      "what is",
-      "how does",
-      "formula",
-      "process",
-      "function",
-    ];
-    const hasEducationalTerms = educationalTerms.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);
-  }
-
-  private calculateClarity(front: string, back: string): number {
-    let score = 0.5; // Base score
-
-    // Check for clear structure
-    if (front.trim().endsWith("?")) score += 0.2;
-    if (!front.includes("...") && !back.includes("...")) score += 0.2;
-    if (!/[A-Z]{2,}/.test(front)) score += 0.1; // Not too many caps
-
-    return Math.min(score, 1.0);
-  }
-
-  private calculateCompleteness(front: string, back: string): number {
-    const frontScore = Math.min(front.length / 20, 1.0); // Ideal 20 chars
-    const backScore = Math.min(back.length / 50, 1.0); // Ideal 50 chars
+    {
+      front: "Define gravity",
+      back: "A force that attracts objects with mass toward each other.",
+      difficulty: "easy",
+      tags: ["physics", "science"],
+    },
+  ];
 
-    return (frontScore + backScore) / 2;
-  }
+  return JSON.stringify(mockFlashcards.slice(0, count));
 }