@umituz/react-native-ai-generation-content 1.26.29 → 1.26.31

package/src/infrastructure/constants/progress.constants.ts

@@ -1,36 +0,0 @@
-/**
- * Progress Constants
- * Standardized progress values for generation pipelines
- */
-
-/** Image generation progress stages */
-export const IMAGE_PROGRESS = {
-  START: 10,
-  INPUT_PREPARED: 30,
-  REQUEST_SENT: 40,
-  RESULT_RECEIVED: 90,
-  COMPLETE: 100,
-} as const;
-
-/** Video generation progress stages */
-export const VIDEO_PROGRESS = {
-  START: 5,
-  INPUT_PREPARED: 10,
-  REQUEST_SENT: 15,
-  IN_QUEUE: 20,
-  IN_PROGRESS: 50,
-  RESULT_RECEIVED: 90,
-  COMPLETE: 100,
-} as const;
-
-/** Polling progress stages */
-export const POLLING_PROGRESS = {
-  RESULT_RECEIVED: 90,
-  COMPLETE: 100,
-} as const;
-
-/** Video generation timeout in milliseconds (5 minutes) */
-export const VIDEO_TIMEOUT_MS = 300000;
-
-/** Maximum consecutive transient errors before failing */
-export const MAX_TRANSIENT_ERRORS = 5;

package/src/infrastructure/services/generation-wrapper.service.ts

@@ -1,148 +0,0 @@
-/**
- * Generation Wrapper Service
- * Wraps orchestrator with middleware support
- * Enables credit checking, moderation, history via middleware pattern
- */
-
-import type {
-  GenerationRequest,
-  GenerationResult,
-  GenerationMiddleware,
-  MiddlewareContext,
-  MiddlewareResultContext,
-} from "../../domain/entities";
-import { generationOrchestrator } from "./generation-orchestrator.service";
-import type { OrchestratorConfig } from "./generation-orchestrator.service";
-
-export interface WrapperConfig {
-  /** Middleware to execute before/after generation */
-  middleware?: GenerationMiddleware[];
-  /** Orchestrator configuration */
-  orchestratorConfig?: OrchestratorConfig;
-}
-
-class GenerationWrapperService {
-  private middleware: GenerationMiddleware[] = [];
-  private orchestratorConfig?: OrchestratorConfig;
-
-  /**
-   * Configure wrapper with middleware
-   */
-  configure(config: WrapperConfig): void {
-    this.middleware = config.middleware || [];
-    this.orchestratorConfig = config.orchestratorConfig;
-
-    if (this.orchestratorConfig) {
-      generationOrchestrator.configure(this.orchestratorConfig);
-    }
-  }
-
-  /**
-   * Add middleware to chain
-   */
-  use(middleware: GenerationMiddleware): void {
-    this.middleware.push(middleware);
-  }
-
-  /**
-   * Clear all middleware
-   */
-  clearMiddleware(): void {
-    this.middleware = [];
-  }
-
-  /**
-   * Generate with middleware support
-   */
-  async generate<T = unknown>(
-    request: GenerationRequest,
-    userId?: string,
-    metadata?: Record<string, unknown>,
-  ): Promise<GenerationResult<T>> {
-    const startTime = Date.now();
-
-    const context: MiddlewareContext = {
-      request,
-      userId,
-      metadata,
-    };
-
-    try {
-      await this.executeBeforeHooks(context);
-
-      const result = await generationOrchestrator.generate<T>(request);
-
-      const resultContext: MiddlewareResultContext<T> = {
-        ...context,
-        result,
-      };
-
-      await this.executeAfterHooks(resultContext);
-
-      return result;
-    } catch (error) {
-      const errorResult: GenerationResult<T> = {
-        success: false,
-        error: error instanceof Error ? error.message : String(error),
-        metadata: {
-          model: request.model || "unknown",
-          startTime,
-          endTime: Date.now(),
-          duration: Date.now() - startTime,
-        },
-      };
-
-      const resultContext: MiddlewareResultContext<T> = {
-        ...context,
-        result: errorResult,
-      };
-
-      await this.executeAfterHooks(resultContext).catch(() => {
-        // Silent fail on afterHooks error
-      });
-
-      return errorResult;
-    }
-  }
-
-  /**
-   * Execute all beforeGenerate hooks
-   */
-  private async executeBeforeHooks(
-    context: MiddlewareContext,
-  ): Promise<void> {
-    for (const mw of this.middleware) {
-      if (mw.beforeGenerate) {
-        await mw.beforeGenerate(context);
-      }
-    }
-  }
-
-  /**
-   * Execute all afterGenerate hooks
-   */
-  private async executeAfterHooks<T>(
-    context: MiddlewareResultContext<T>,
-  ): Promise<void> {
-    for (const mw of this.middleware) {
-      if (mw.afterGenerate) {
-        await mw.afterGenerate(context);
-      }
-    }
-  }
-}
-
-export const generationWrapper = new GenerationWrapperService();
-
-/**
- * Create new wrapper instance
- */
-export function createGenerationWrapper(
-  config?: WrapperConfig,
-): GenerationWrapperService {
-  const wrapper = new GenerationWrapperService();
-  if (config) {
-    wrapper.configure(config);
-  }
-  return wrapper;
-}

package/src/infrastructure/services/progress-manager.ts

@@ -1,58 +0,0 @@
-/**
- * Progress Manager
- * Handles progress tracking and updates during generation
- */
-
-import type { GenerationProgress, PollingConfig } from "../../domain/entities";
-import type { JobStatus } from "../../domain/interfaces";
-import { createProgressTracker } from "../utils/progress-calculator.util";
-
-export class ProgressManager {
-    private progressTracker = createProgressTracker();
-
-    updateProgress(
-        stage: GenerationProgress["stage"],
-        subProgress: number,
-        onProgress?: (progress: GenerationProgress) => void,
-    ): void {
-        const progress = this.progressTracker.setStatus(stage);
-        onProgress?.({
-            stage,
-            progress: progress + subProgress,
-        });
-    }
-
-    updateProgressFromStatus(
-        status: JobStatus,
-        attempt: number,
-        config: PollingConfig,
-        onProgress?: (progress: GenerationProgress) => void,
-    ): void {
-        const baseProgress = 25;
-        const maxProgress = 85;
-        const range = maxProgress - baseProgress;
-
-        let progress: number;
-
-        if (status.status === "IN_QUEUE") {
-            progress = baseProgress + range * 0.2;
-        } else if (status.status === "IN_PROGRESS") {
-            const ratio = Math.min(attempt / (config.maxAttempts * 0.7), 1);
-            progress = baseProgress + range * (0.2 + 0.6 * ratio);
-        } else {
-            progress = baseProgress;
-        }
-
-        onProgress?.({
-            stage: "generating",
-            progress: Math.round(progress),
-            eta: status.eta,
-        });
-    }
-
-    reset(): void {
-        this.progressTracker = createProgressTracker();
-    }
-}
-
-export const progressManager = new ProgressManager();

package/src/infrastructure/wrappers/README.md

@@ -1,336 +0,0 @@
-# Infrastructure Wrappers
-
-Wrapper utilities and enhancements for AI generation operations.
-
-## Overview
-
-The wrappers module provides wrapper utilities that add additional functionality to core AI generation operations, such as language enhancement, moderation, and synchronous execution.
-
-## Features
-
-- Language enhancement for prompts
-- Content moderation wrapper
-- Synchronous generation support
-- Prompt augmentation
-- Result filtering
-
-## Language Enhancement
-
-### enhancePromptWithLanguage
-
-Enhance prompts with language support:
-
-```tsx
-import { enhancePromptWithLanguage } from '@umituz/react-native-ai-generation-content';
-
-// Enhance prompt for better results
-const enhanced = enhancePromptWithLanguage({
-  prompt: 'A beautiful sunset',
-  targetLanguage: 'en', // Translate to English first
-  enhance: true, // Add descriptive details
-});
-
-console.log('Enhanced prompt:', enhanced);
-// "A beautiful sunset over the ocean with vibrant orange and pink colors,
-//  captured during golden hour with dramatic cloud formations"
-```
-
-### getSupportedLanguages
-
-Get list of supported languages:
-
-```tsx
-import { getSupportedLanguages } from '@umituz/react-native-ai-generation-content';
-
-const languages = getSupportedLanguages();
-console.log('Supported languages:', languages);
-// [
-//   { code: 'en', name: 'English' },
-//   { code: 'es', name: 'Spanish' },
-//   { code: 'fr', name: 'French' },
-//   ...
-// ]
-```
-
-### getLanguageName
-
-Get language name from code:
-
-```tsx
-import { getLanguageName } from '@umituz/react-native-ai-generation-content';
-
-const name = getLanguageName('es');
-console.log('Language:', name); // "Spanish"
-```
-
-## Content Moderation
-
-### ModerationWrapper
-
-Wrap generation with content moderation:
-
-```tsx
-import { ModerationWrapper } from '@umituz/react-native-ai-generation-content';
-
-const wrapper = new ModerationWrapper({
-  enabled: true,
-  rules: [
-    {
-      id: 'no-violence',
-      category: 'violence',
-      severity: 'high',
-      enabled: true,
-      action: 'block',
-    },
-    {
-      id: 'no-adult',
-      category: 'sexual',
-      severity: 'high',
-      enabled: true,
-      action: 'block',
-    },
-  ],
-  onViolation: (result) => {
-    Alert.alert('Content Warning', result.warning, [
-      { text: 'OK', onPress: () => console.log('Acknowledged') },
-    ]);
-  },
-});
-
-// Wrap generation
-const wrapped = wrapper.wrap({
-  type: 'text-to-image',
-  generate: async (input) => {
-    return await generateImage(input);
-  },
-});
-
-// Execute with moderation
-const result = await wrapped.generate({
-  prompt: 'Your prompt here',
-});
-
-if (result.isModerated) {
-  console.log('Content was moderated');
-  console.log('Violations:', result.violations);
-} else {
-  console.log('Content is safe:', result.output);
-}
-```
-
-### Moderation Result
-
-```tsx
-interface ModerationResult {
-  isSafe: boolean;
-  isModerated: boolean;
-  violations: {
-    category: string;
-    severity: 'low' | 'medium' | 'high';
-    confidence: number;
-  }[];
-  warning?: string;
-  output?: any;
-}
-```
-
-## Synchronous Generation
-
-### generateSynchronously
-
-Generate content synchronously (blocks until complete):
-
-```tsx
-import { generateSynchronously } from '@umituz/react-native-ai-generation-content';
-
-// ⚠️ Warning: This blocks the thread
-const result = await generateSynchronously({
-  featureType: 'text-to-image',
-  inputData: {
-    prompt: 'A sunset',
-  },
-  userId: 'user-123',
-  timeout: 30000, // 30 second timeout
-});
-
-console.log('Result:', result);
-```
-
-**⚠️ Use with caution**: Synchronous generation blocks the UI thread. Only use for:
-- Testing
-- Very fast operations
-- Background workers
-
-### SynchronousGenerationConfig
-
-```tsx
-interface SynchronousGenerationConfig {
-  featureType: string;
-  inputData: any;
-  userId: string;
-  providerId?: string;
-  timeout?: number;
-  onProgress?: (progress: number) => void;
-}
-```
-
-## Prompt Augmentation
-
-### Auto-Enhance Prompts
-
-Automatically enhance prompts for better results:
-
-```tsx
-import { ModerationWrapper } from '@umituz/react-native-ai-generation-content';
-
-const wrapper = new ModerationWrapper({
-  enabled: true,
-  autoEnhance: true,
-  enhancementOptions: {
-    addDetail: true,
-    addStyle: true,
-    improveGrammar: true,
-  },
-});
-
-const enhanced = await wrapper.enhancePrompt('A cat');
-// "A highly detailed, professional photograph of a beautiful cat,
-//  with perfect lighting and composition, captured with a DSLR camera"
-```
-
-### Style Prompts
-
-Add style to prompts:
-
-```tsx
-import { enhancePromptWithLanguage } from '@umituz/react-native-ai-generation-content';
-
-const styled = enhancePromptWithLanguage({
-  prompt: 'A sunset',
-  style: 'photorealistic',
-  quality: 'high',
-});
-
-// "A photorealistic, high-quality image of a sunset over the ocean,
-//  with dramatic lighting and vivid colors"
-```
-
-## Result Filtering
-
-### FilterResults
-
-Filter and clean generation results:
-
-```tsx
-import { ModerationWrapper } from '@umituz/react-native-ai-generation-content';
-
-const wrapper = new ModerationWrapper({
-  enabled: true,
-  filterResults: true,
-  filterOptions: {
-    removeDuplicates: true,
-    qualityThreshold: 0.7,
-    maxResults: 4,
-  },
-});
-
-const filtered = await wrapper.filterResults(results);
-```
-
-## Usage Examples
-
-### Complete Moderation Setup
-
-```tsx
-import { ModerationWrapper } from '@umituz/react-native-ai-generation-content';
-
-const wrapper = new ModerationWrapper({
-  enabled: true,
-  autoEnhance: true,
-  rules: [
-    {
-      id: 'safety',
-      category: 'violence',
-      severity: 'high',
-      enabled: true,
-      action: 'block',
-    },
-  ],
-  onViolation: (result) => {
-    Alert.alert('Content Warning', result.warning);
-  },
-});
-
-const generateWithModeration = wrapper.wrap({
-  type: 'text-to-image',
-  generate: async (input) => {
-    return await generateImage(input);
-  },
-});
-
-// Use wrapped generation
-const result = await generateWithModeration({
-  prompt: userInput,
-});
-
-if (result.isSafe) {
-  setImage(result.output.imageUrl);
-} else {
-  showWarning(result.violations);
-}
-```
-
-### Multi-Language Support
-
-```tsx
-import { enhancePromptWithLanguage } from '@umituz/react-native-ai-generation-content';
-
-// User enters prompt in Spanish
-const userPrompt = 'Un hermoso atardecer';
-
-// Enhance and translate to English for AI
-const enhanced = enhancePromptWithLanguage({
-  prompt: userPrompt,
-  targetLanguage: 'en',
-  enhance: true,
-});
-
-// Use enhanced prompt for generation
-const result = await generateImage({
-  prompt: enhanced,
-});
-```
-
-## Best Practices
-
-1. **Moderation**: Always enable moderation in production
-2. **Language Enhancement**: Use for non-English prompts
-3. **Synchronous**: Avoid synchronous generation in production
-4. **Rule Configuration**: Customize rules based on your use case
-5. **Violation Handling**: Provide clear feedback to users
-
-## Error Handling
-
-```tsx
-try {
-  const result = await wrapped.generate({ prompt: '...' });
-} catch (error) {
-  if (error.type === 'MODERATION_ERROR') {
-    // Content was flagged
-    showModerationError(error.violations);
-  } else if (error.type === 'TIMEOUT_ERROR') {
-    // Generation timed out
-    showTimeoutError();
-  }
-}
-```
-
-## Related
-
-- [Middleware](../middleware/) - Request/response middleware
-- [Services](../services/) - AI generation services
-- [Utils](../utils/) - Utility functions
-
-## License
-
-MIT

package/src/infrastructure/wrappers/index.ts

@@ -1,19 +0,0 @@
-/**
- * Generation Wrappers
- * High-level API wrappers for generation orchestration
- */
-
-export {
-  enhancePromptWithLanguage,
-  getSupportedLanguages,
-  getLanguageName,
-} from "./language.wrapper";
-
-export { ModerationWrapper } from "./moderation.wrapper";
-export type { ModerationResult, ModerationConfig } from "./moderation.wrapper";
-
-export { generateSynchronously } from "./synchronous-generation.wrapper";
-export type {
-  SynchronousGenerationInput,
-  SynchronousGenerationConfig,
-} from "./synchronous-generation.wrapper";

package/src/infrastructure/wrappers/moderation.wrapper.ts

@@ -1,37 +0,0 @@
-/**
- * Moderation Wrapper
- * Generic content moderation interface (app provides implementation)
- */
-
-export interface ModerationResult {
-  allowed: boolean;
-  error?: string;
-  violations?: Array<{
-    rule: string;
-    suggestion?: string;
-  }>;
-}
-
-export interface ModerationConfig {
-  check: (content: string) => Promise<ModerationResult>;
-}
-
-export class ModerationWrapper {
-  private static config: ModerationConfig | null = null;
-
-  static configure(config: ModerationConfig): void {
-    this.config = config;
-  }
-
-  static async checkContent(content: string): Promise<ModerationResult> {
-    if (!this.config) {
-      return { allowed: true };
-    }
-
-    return this.config.check(content);
-  }
-
-  static isConfigured(): boolean {
-    return this.config !== null;
-  }
-}