@umituz/react-native-ai-generation-content 1.61.54 → 1.61.56

package/package.json

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

package/src/domains/content-moderation/infrastructure/constants/moderation.constants.ts

@@ -0,0 +1,9 @@
+/**
+ * Content Moderation Constants
+ * Shared constants for content moderation validators
+ */
+
+export const DEFAULT_PROTOCOLS = ["http:", "https:", "file:", "data:"] as const;
+export const VIDEO_PROTOCOLS = ["http:", "https:", "file:"] as const;
+export const DEFAULT_MAX_URI_LENGTH = 2048;
+export const DEFAULT_MAX_TEXT_LENGTH = 5000;

package/src/domains/content-moderation/infrastructure/services/moderators/image.moderator.ts

@@ -5,12 +5,10 @@
 
 import type { Violation } from "../../../domain/entities/moderation.types";
 import { BaseModerator, type ModerationResult } from "./base.moderator";
-
-const DEFAULT_PROTOCOLS = ["http:", "https:", "file:", "data:"];
-const DEFAULT_MAX_URI_LENGTH = 2048;
+import { DEFAULT_PROTOCOLS, DEFAULT_MAX_URI_LENGTH } from "../../constants/moderation.constants";
 
 class ImageModerator extends BaseModerator {
-  private allowedProtocols = DEFAULT_PROTOCOLS;
+  private allowedProtocols: readonly string[] = DEFAULT_PROTOCOLS;
   private maxUriLength = DEFAULT_MAX_URI_LENGTH;
 
   setAllowedProtocols(protocols: string[]): void {

package/src/domains/content-moderation/infrastructure/services/moderators/text.moderator.ts

@@ -7,90 +7,12 @@ import type { Violation } from "../../../domain/entities/moderation.types";
 import { patternMatcherService } from "../pattern-matcher.service";
 import { rulesRegistry } from "../../rules/rules-registry";
 import { BaseModerator, type ModerationResult } from "./base.moderator";
-import { DEFAULT_MAX_TEXT_LENGTH } from "../../../../../infrastructure/constants/content.constants";
+import { DEFAULT_MAX_TEXT_LENGTH } from "../../constants/moderation.constants";
+import { containsMaliciousPatterns } from "../../utils/content-security.util";
+import { containsPromptInjection } from "../../utils/prompt-injection.util";
 
 declare const __DEV__: boolean;
 
-/**
- * HTML entity encoding detection
- * More reliable than regex for detecting encoded malicious content
- */
-function containsHTMLEntities(content: string): boolean {
-  const htmlEntities = [
-    /</gi, />/gi, /"/gi, /&/gi, /'/gi,
-    /&#\d+;/gi, /&#x[0-9a-fA-F]+;/gi,
-  ];
-  return htmlEntities.some(entity => entity.test(content));
-}
-
-/**
- * Safe string matching for malicious code detection
- * Uses string operations instead of regex where possible
- */
-function containsMaliciousPatterns(content: string): boolean {
-  const lowerContent = content.toLowerCase();
-
-  // Check for script tags (case-insensitive)
-  const scriptPatterns = ["<script", "</script>", "javascript:", "onclick=", "onerror=", "onload="];
-  for (const pattern of scriptPatterns) {
-    if (lowerContent.includes(pattern)) {
-      return true;
-    }
-  }
-
-  // Check for HTML entities (potential evasion)
-  if (containsHTMLEntities(content)) {
-    return true;
-  }
-
-  return false;
-}
-
-/**
- * Multi-layered prompt injection detection
- * Combines regex with string matching for better security
- */
-function containsPromptInjection(content: string): boolean {
-  const lowerContent = content.toLowerCase();
-
-  // Critical injection patterns (string-based for safety)
-  const criticalPatterns = [
-    "ignore all instructions",
-    "ignore previous instructions",
-    "disregard all instructions",
-    "forget all instructions",
-    "you are now a",
-    "jailbreak",
-    "dan mode",
-    "developer mode",
-    "system:",
-    "[system]",
-    "<<system>>",
-  ];
-
-  for (const pattern of criticalPatterns) {
-    if (lowerContent.includes(pattern)) {
-      return true;
-    }
-  }
-
-  // Additional regex patterns for more complex matching
-  const regexPatterns = [
-    /act\s+as\s+(if|though)\s+you/gi,
-    /pretend\s+(you\s+are|to\s+be)/gi,
-    /bypass\s+(your\s+)?(safety|content|moderation)/gi,
-    /override\s+(your\s+)?(restrictions?|limitations?|rules?)/gi,
-  ];
-
-  return regexPatterns.some(pattern => {
-    try {
-      return pattern.test(content);
-    } catch {
-      return false;
-    }
-  });
-}
-
 class TextModerator extends BaseModerator {
   private maxLength = DEFAULT_MAX_TEXT_LENGTH;
 
@@ -100,7 +22,6 @@ class TextModerator extends BaseModerator {
 
   moderate(content: string): ModerationResult {
     if (typeof __DEV__ !== "undefined" && __DEV__) {
-       
       console.log("[TextModerator] moderate() called", {
         contentLength: content?.length ?? 0,
       });
@@ -109,7 +30,6 @@ class TextModerator extends BaseModerator {
     const validationError = this.validate(content);
     if (validationError) {
       if (typeof __DEV__ !== "undefined" && __DEV__) {
-         
         console.log("[TextModerator] validation failed", {
           ruleId: validationError.ruleId,
           violationType: validationError.violationType,
@@ -121,7 +41,6 @@ class TextModerator extends BaseModerator {
     const violations = this.evaluateRules(content);
 
     if (typeof __DEV__ !== "undefined" && __DEV__) {
-       
       console.log("[TextModerator] moderate() completed", {
         isAllowed: violations.length === 0,
         violationsCount: violations.length,
@@ -149,7 +68,7 @@ class TextModerator extends BaseModerator {
       );
     }
 
-    if (this.containsPromptInjection(content)) {
+    if (containsPromptInjection(content)) {
       return this.createViolation(
         "prompt-injection",
         "Security",
@@ -165,10 +84,6 @@ class TextModerator extends BaseModerator {
     return containsMaliciousPatterns(content);
   }
 
-  private containsPromptInjection(content: string): boolean {
-    return containsPromptInjection(content);
-  }
-
   private evaluateRules(content: string): Violation[] {
     const rules = rulesRegistry.getRulesByContentType("text");
     const violations: Violation[] = [];

package/src/domains/content-moderation/infrastructure/services/moderators/video.moderator.ts

@@ -5,12 +5,10 @@
 
 import type { Violation } from "../../../domain/entities/moderation.types";
 import { BaseModerator, type ModerationResult } from "./base.moderator";
-
-const DEFAULT_PROTOCOLS = ["http:", "https:", "file:"];
-const DEFAULT_MAX_URI_LENGTH = 2048;
+import { VIDEO_PROTOCOLS, DEFAULT_MAX_URI_LENGTH } from "../../constants/moderation.constants";
 
 class VideoModerator extends BaseModerator {
-  private allowedProtocols = DEFAULT_PROTOCOLS;
+  private allowedProtocols: readonly string[] = VIDEO_PROTOCOLS;
   private maxUriLength = DEFAULT_MAX_URI_LENGTH;
 
   setAllowedProtocols(protocols: string[]): void {

package/src/domains/content-moderation/infrastructure/utils/content-security.util.ts

@@ -0,0 +1,39 @@
+/**
+ * Content Security Utilities
+ * Provides security validation for content including malicious code detection
+ */
+
+/**
+ * HTML entity encoding detection
+ * More reliable than regex for detecting encoded malicious content
+ */
+export function containsHTMLEntities(content: string): boolean {
+  const htmlEntities = [
+    /</gi, />/gi, /"/gi, /&/gi, /'/gi,
+    /&#\d+;/gi, /&#x[0-9a-fA-F]+;/gi,
+  ];
+  return htmlEntities.some(entity => entity.test(content));
+}
+
+/**
+ * Safe string matching for malicious code detection
+ * Uses string operations instead of regex where possible
+ */
+export function containsMaliciousPatterns(content: string): boolean {
+  const lowerContent = content.toLowerCase();
+
+  // Check for script tags (case-insensitive)
+  const scriptPatterns = ["<script", "</script>", "javascript:", "onclick=", "onerror=", "onload="];
+  for (const pattern of scriptPatterns) {
+    if (lowerContent.includes(pattern)) {
+      return true;
+    }
+  }
+
+  // Check for HTML entities (potential evasion)
+  if (containsHTMLEntities(content)) {
+    return true;
+  }
+
+  return false;
+}

package/src/domains/content-moderation/infrastructure/utils/prompt-injection.util.ts

@@ -0,0 +1,49 @@
+/**
+ * Prompt Injection Detection Utilities
+ * Detects various forms of prompt injection attacks
+ */
+
+/**
+ * Multi-layered prompt injection detection
+ * Combines regex with string matching for better security
+ */
+export function containsPromptInjection(content: string): boolean {
+  const lowerContent = content.toLowerCase();
+
+  // Critical injection patterns (string-based for safety)
+  const criticalPatterns = [
+    "ignore all instructions",
+    "ignore previous instructions",
+    "disregard all instructions",
+    "forget all instructions",
+    "you are now a",
+    "jailbreak",
+    "dan mode",
+    "developer mode",
+    "system:",
+    "[system]",
+    "<<system>>",
+  ];
+
+  for (const pattern of criticalPatterns) {
+    if (lowerContent.includes(pattern)) {
+      return true;
+    }
+  }
+
+  // Additional regex patterns for more complex matching
+  const regexPatterns = [
+    /act\s+as\s+(if|though)\s+you/gi,
+    /pretend\s+(you\s+are|to\s+be)/gi,
+    /bypass\s+(your\s+)?(safety|content|moderation)/gi,
+    /override\s+(your\s+)?(restrictions?|limitations?|rules?)/gi,
+  ];
+
+  return regexPatterns.some(pattern => {
+    try {
+      return pattern.test(content);
+    } catch {
+      return false;
+    }
+  });
+}

package/src/domains/content-moderation/infrastructure/utils/validators.util.ts

@@ -0,0 +1,51 @@
+/**
+ * Content Moderation Validators
+ * Reusable validation functions for content moderation
+ */
+
+/**
+ * Validates that content is not empty and is a string
+ */
+export function validateContentPresence(content: unknown): boolean {
+  return Boolean(content && typeof content === "string");
+}
+
+/**
+ * Validates content length against maximum
+ */
+export function validateContentLength(content: string, maxLength: number): boolean {
+  return content.length <= maxLength;
+}
+
+/**
+ * Validates URI protocol
+ */
+export function validateUriProtocol(uri: string, allowedProtocols: readonly string[]): boolean {
+  const lowerUri = uri.toLowerCase();
+  return allowedProtocols.some((protocol) => lowerUri.startsWith(protocol));
+}
+
+/**
+ * Validates URI
+ */
+export function validateUri(
+  uri: string,
+  options: {
+    maxLength?: number;
+    allowedProtocols?: readonly string[];
+  } = {}
+): { isValid: boolean; error?: { type: string; message: string } } {
+  if (!validateContentPresence(uri)) {
+    return { isValid: false, error: { type: "empty-uri", message: "empty URI" } };
+  }
+
+  if (options.maxLength && !validateContentLength(uri, options.maxLength)) {
+    return { isValid: false, error: { type: "uri-too-long", message: "URI too long" } };
+  }
+
+  if (options.allowedProtocols && !validateUriProtocol(uri, options.allowedProtocols)) {
+    return { isValid: false, error: { type: "invalid-protocol", message: "invalid protocol" } };
+  }
+
+  return { isValid: true };
+}

package/src/domains/creations/index.ts

@@ -168,7 +168,7 @@ export {
   getLocalizedTitle,
   getFilterCategoriesFromConfig,
   getTranslatedTypes,
-} from "./presentation/utils/filterUtils";
+} from "./presentation/utils/gallery-filters";
 
 // =============================================================================
 // PRESENTATION LAYER - Screens

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

@@ -136,4 +136,4 @@ export type { FilterButton, CreationsFilterBarProps } from "./CreationsFilterBar
 export {
   createMediaFilterButtons,
   createStatusFilterButtons,
-} from "./CreationsFilterBar.helpers";
+} from "./filter-bar-utils";

package/src/domains/creations/presentation/hooks/useGalleryState.ts

@@ -0,0 +1,74 @@
+/**
+ * useGalleryState Hook
+ * Manages the state for the gallery screen including selection and media URL handling
+ */
+
+import { useState, useEffect, useRef, useMemo } from "react";
+import type { Creation } from "../../domain/entities/Creation";
+import { getPreviewUrl } from "../../domain/utils";
+
+export interface GalleryStateOptions {
+  initialCreationId?: string;
+  creations: Creation[] | undefined;
+}
+
+export interface GalleryStateReturn {
+  selectedCreation: Creation | null;
+  showRatingPicker: boolean;
+  selectedImageUrl: string | undefined;
+  selectedVideoUrl: string | undefined;
+  hasMediaToShow: boolean;
+  showPreview: boolean;
+  setSelectedCreation: (creation: Creation | null) => void;
+  setShowRatingPicker: (show: boolean) => void;
+}
+
+export function useGalleryState(options: GalleryStateOptions): GalleryStateReturn {
+  const { initialCreationId, creations } = options;
+  const [selectedCreation, setSelectedCreation] = useState<Creation | null>(null);
+  const [showRatingPicker, setShowRatingPicker] = useState(false);
+  const hasAutoSelectedRef = useRef(false);
+
+  // Auto-select creation when initialCreationId is provided
+  useEffect(() => {
+    if (initialCreationId && creations && creations.length > 0 && !hasAutoSelectedRef.current) {
+      const creation = creations.find((c) => c.id === initialCreationId);
+      if (creation) {
+        hasAutoSelectedRef.current = true;
+        setSelectedCreation(creation);
+      }
+    }
+  }, [initialCreationId, creations]);
+
+  // Extract media URLs from selected creation
+  const selectedImageUrl = useMemo(
+    () => selectedCreation ? (getPreviewUrl(selectedCreation.output) || selectedCreation.uri) : undefined,
+    [selectedCreation]
+  );
+
+  const selectedVideoUrl = useMemo(
+    () => selectedCreation?.output?.videoUrl,
+    [selectedCreation]
+  );
+
+  const hasMediaToShow = useMemo(
+    () => Boolean(selectedImageUrl || selectedVideoUrl),
+    [selectedImageUrl, selectedVideoUrl]
+  );
+
+  const showPreview = useMemo(
+    () => Boolean(selectedCreation && hasMediaToShow),
+    [selectedCreation, hasMediaToShow]
+  );
+
+  return {
+    selectedCreation,
+    showRatingPicker,
+    selectedImageUrl,
+    selectedVideoUrl,
+    hasMediaToShow,
+    showPreview,
+    setSelectedCreation,
+    setShowRatingPicker,
+  };
+}

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

@@ -1,4 +1,4 @@
-import React, { useState, useMemo, useCallback, useEffect, useRef } from "react";
+import React, { useMemo, useCallback } from "react";
 import { View, FlatList, RefreshControl } from "react-native";
 import {
   useAppDesignTokens,
@@ -11,11 +11,11 @@ import { useDeleteCreation } from "../hooks/useDeleteCreation";
 import { useProcessingJobsPoller } from "../hooks/useProcessingJobsPoller";
 import { useGalleryFilters } from "../hooks/useGalleryFilters";
 import { useGalleryCallbacks } from "../hooks/useGalleryCallbacks";
+import { useGalleryState } from "../hooks/useGalleryState";
 import { GalleryHeader, CreationCard, GalleryEmptyStates } from "../components";
 import { GalleryResultPreview } from "../components/GalleryResultPreview";
 import { GalleryScreenHeader } from "../components/GalleryScreenHeader";
 import { MEDIA_FILTER_OPTIONS, STATUS_FILTER_OPTIONS } from "../../domain/types/creation-filter";
-import { getPreviewUrl } from "../../domain/utils";
 import { createFilterButtons, createItemTitle } from "../utils/filter-buttons.util";
 import type { Creation } from "../../domain/entities/Creation";
 import type { CreationsGalleryScreenProps } from "./creations-gallery.types";
@@ -37,9 +37,6 @@ export function CreationsGalleryScreen({
   getCreationTitle,
 }: CreationsGalleryScreenProps) {
   const tokens = useAppDesignTokens();
-  const [selectedCreation, setSelectedCreation] = useState<Creation | null>(null);
-  const [showRatingPicker, setShowRatingPicker] = useState(false);
-  const hasAutoSelectedRef = useRef(false);
 
   const { data: creations, isLoading, refetch } = useCreations({ userId, repository });
   const deleteMutation = useDeleteCreation({ userId, repository });
@@ -51,15 +48,8 @@ export function CreationsGalleryScreen({
     enabled: !!userId && (creations?.length ?? 0) > 0,
   });
 
-  useEffect(() => {
-    if (initialCreationId && creations && creations.length > 0 && !hasAutoSelectedRef.current) {
-      const creation = creations.find((c) => c.id === initialCreationId);
-      if (creation) {
-        hasAutoSelectedRef.current = true;
-        setSelectedCreation(creation);
-      }
-    }
-  }, [initialCreationId, creations]);
+  // Gallery state management
+  const galleryState = useGalleryState({ initialCreationId, creations });
 
   const callbacks = useGalleryCallbacks({
     userId,
@@ -68,9 +58,9 @@ export function CreationsGalleryScreen({
     t,
     deleteMutation,
     refetch: async () => { await refetch(); },
-    setSelectedCreation,
-    setShowRatingPicker,
-    selectedCreation,
+    setSelectedCreation: galleryState.setSelectedCreation,
+    setShowRatingPicker: galleryState.setShowRatingPicker,
+    selectedCreation: galleryState.selectedCreation,
     onTryAgain,
   });
 
@@ -145,30 +135,25 @@ export function CreationsGalleryScreen({
     />
   ), [isLoading, creations, filters.isFiltered, tokens, t, config, emptyActionLabel, onEmptyAction, filters.clearAllFilters]);
 
-  const selectedImageUrl = selectedCreation ? (getPreviewUrl(selectedCreation.output) || selectedCreation.uri) : undefined;
-  const selectedVideoUrl = selectedCreation?.output?.videoUrl;
-  const hasMediaToShow = selectedImageUrl || selectedVideoUrl;
-  const showPreview = selectedCreation && hasMediaToShow;
-
   const screenHeader = useMemo(() => {
     if (!onBack) return undefined;
     return <GalleryScreenHeader title={t(config.translations.title)} onBack={onBack} />;
   }, [onBack, t, config.translations.title]);
 
-  if (showPreview) {
+  if (galleryState.showPreview && galleryState.selectedCreation) {
     return (
       <GalleryResultPreview
-        selectedCreation={selectedCreation}
-        imageUrl={selectedVideoUrl ? undefined : selectedImageUrl}
-        videoUrl={selectedVideoUrl}
-        showRatingPicker={showRatingPicker}
+        selectedCreation={galleryState.selectedCreation}
+        imageUrl={galleryState.selectedVideoUrl ? undefined : galleryState.selectedImageUrl}
+        videoUrl={galleryState.selectedVideoUrl}
+        showRatingPicker={galleryState.showRatingPicker}
         config={config}
         t={t}
         onBack={callbacks.handleBack}
         onTryAgain={callbacks.handleTryAgain}
         onRate={callbacks.handleOpenRatingPicker}
         onSubmitRating={callbacks.handleSubmitRating}
-        onCloseRating={() => setShowRatingPicker(false)}
+        onCloseRating={() => galleryState.setShowRatingPicker(false)}
       />
     );
   }

package/src/domains/prompts/infrastructure/services/ImagePromptBuilder.ts

@@ -164,36 +164,5 @@ export class ImagePromptBuilder {
   }
 }
 
-/**
- * Create anime selfie prompt for Kontext model
- * Kontext uses instruction-based editing that preserves character identity automatically
- */
-export function createAnimeSelfiePrompt(customStyle?: string): AnimeSelfiePromptResult {
-  const stylePrefix = customStyle ? `${customStyle} anime style` : "anime style";
-
-  const prompt = [
-    `Transform this person into a ${stylePrefix} illustration.`,
-    "IMPORTANT: Preserve the exact same gender - if male keep male, if female keep female.",
-    "Keep the same face structure, hair color, eye color, skin tone, and facial expression.",
-    "Make it look like a high-quality Japanese anime character portrait.",
-    "Use vibrant anime colors, clean lineart, and cel-shaded rendering.",
-    "Large expressive anime eyes with detailed iris, smooth anime skin with subtle blush.",
-  ].join(" ");
-
-  return {
-    prompt,
-    guidance_scale: 4.0,
-  };
-}
-
-/**
- * Create a style transfer prompt with identity preservation
- */
-export function createStyleTransferPrompt(style: string): ImagePromptResult {
-  return ImagePromptBuilder.create()
-    .withSegment(`${style} style`)  // Style first
-    .withIdentityPreservation()
-    .withQuality()
-    .withAnatomySafety()
-    .build();
-}
+// Re-export prompt creation utilities for backward compatibility
+export { createAnimeSelfiePrompt, createStyleTransferPrompt } from "../utils/prompt-creators.util";

package/src/domains/prompts/infrastructure/utils/prompt-creators.util.ts

@@ -0,0 +1,41 @@
+/**
+ * Prompt Creation Utilities
+ * Provides helper functions for creating specific types of prompts
+ */
+
+import type { ImagePromptResult, AnimeSelfiePromptResult } from "../services/ImagePromptBuilder";
+import { ImagePromptBuilder } from "../services/ImagePromptBuilder";
+
+/**
+ * Create anime selfie prompt for Kontext model
+ * Kontext uses instruction-based editing that preserves character identity automatically
+ */
+export function createAnimeSelfiePrompt(customStyle?: string): AnimeSelfiePromptResult {
+  const stylePrefix = customStyle ? `${customStyle} anime style` : "anime style";
+
+  const prompt = [
+    `Transform this person into a ${stylePrefix} illustration.`,
+    "IMPORTANT: Preserve the exact same gender - if male keep male, if female keep female.",
+    "Keep the same face structure, hair color, eye color, skin tone, and facial expression.",
+    "Make it look like a high-quality Japanese anime character portrait.",
+    "Use vibrant anime colors, clean lineart, and cel-shaded rendering.",
+    "Large expressive anime eyes with detailed iris, smooth anime skin with subtle blush.",
+  ].join(" ");
+
+  return {
+    prompt,
+    guidance_scale: 4.0,
+  };
+}
+
+/**
+ * Create a style transfer prompt with identity preservation
+ */
+export function createStyleTransferPrompt(style: string): ImagePromptResult {
+  return ImagePromptBuilder.create()
+    .withSegment(`${style} style`)
+    .withIdentityPreservation()
+    .withQuality()
+    .withAnatomySafety()
+    .build();
+}

package/src/domains/scenarios/index.ts

@@ -20,8 +20,8 @@ export {
   filterScenariosByCategory,
   getScenarioCategories,
   findScenarioById,
-} from "./infrastructure/scenario-helpers";
-export type { AppScenarioConfig } from "./infrastructure/scenario-helpers";
+} from "./infrastructure/scenario-utils";
+export type { AppScenarioConfig } from "./infrastructure/scenario-utils";
 
 // Scenario Registry - Singleton for app configuration
 export {