@umituz/react-native-ai-generation-content 1.12.2 → 1.12.3

package/package.json

@@ -1,9 +1,13 @@
 {
   "name": "@umituz/react-native-ai-generation-content",
-  "version": "1.12.2",
+  "version": "1.12.3",
   "description": "Provider-agnostic AI generation orchestration for React Native",
   "main": "src/index.ts",
   "types": "src/index.ts",
+  "exports": {
+    ".": "./src/index.ts",
+    "./prompts": "./src/domains/prompts/index.ts"
+  },
   "files": [
     "src"
   ],

package/src/domains/prompts/domain/entities/AIPromptTemplate.ts

@@ -0,0 +1,48 @@
+import type { AIPromptCategory } from './types';
+import type { AIPromptVariable, AIPromptSafety, AIPromptVersion } from './value-objects';
+import { createPromptVersion, formatVersion } from './value-objects';
+
+export interface AIPromptTemplate {
+  readonly id: string;
+  readonly name: string;
+  readonly description: string;
+  readonly category: AIPromptCategory;
+  readonly template: string;
+  readonly variables: readonly AIPromptVariable[];
+  readonly safety: AIPromptSafety;
+  readonly version: AIPromptVersion;
+}
+
+export interface CreateAIPromptTemplateParams {
+  id: string;
+  name: string;
+  description: string;
+  category: AIPromptCategory;
+  template: string;
+  variables?: AIPromptVariable[];
+  safety: AIPromptSafety;
+  version: string;
+}
+
+export const createAIPromptTemplate = (
+  params: CreateAIPromptTemplateParams
+): AIPromptTemplate => ({
+  id: params.id,
+  name: params.name,
+  description: params.description,
+  category: params.category,
+  template: params.template,
+  variables: params.variables || [],
+  safety: params.safety,
+  version: createPromptVersion(params.version),
+});
+
+export const updateTemplateVersion = (
+  template: AIPromptTemplate,
+  newVersion: string
+): AIPromptTemplate => ({
+  ...template,
+  version: createPromptVersion(newVersion),
+});
+
+export const getTemplateString = (template: AIPromptTemplate): string => formatVersion(template.version);

package/src/domains/prompts/domain/entities/BackgroundRemovalConfig.ts

@@ -0,0 +1,86 @@
+import type { AIPromptTemplate } from './AIPromptTemplate';
+
+export interface BackgroundRemovalConfig {
+  precision: 'fast' | 'accurate' | 'ultra-accurate';
+  edgeRefinement: boolean;
+  preserveHair: boolean;
+  outputFormat: 'png' | 'webp' | 'transparent';
+  addNewBackground?: string;
+}
+
+export interface BackgroundRemovalTemplate {
+  readonly id: string;
+  readonly name: string;
+  readonly description: string;
+  readonly basePrompt: string;
+  readonly variables: BackgroundRemovalVariable[];
+  readonly processing: BackgroundRemovalSettings;
+}
+
+export interface BackgroundRemovalVariable {
+  name: string;
+  description: string;
+  required: boolean;
+  options?: string[];
+}
+
+export interface BackgroundRemovalSettings {
+  supportedFormats: string[];
+  maxResolution: number;
+  processingTimes: Record<string, number>;
+}
+
+export interface BackgroundRemovalResult {
+  template: AIPromptTemplate;
+  config: BackgroundRemovalConfig;
+  estimatedProcessingTime: number;
+  qualityScore: number;
+}
+
+export interface DetectedObject {
+  type: string;
+  confidence: number;
+  boundingBox: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+  };
+}
+
+export const validateBackgroundRemovalConfig = (config: BackgroundRemovalConfig): boolean => {
+  return !!(
+    config.precision && 
+    config.outputFormat &&
+    ['png', 'webp', 'transparent'].includes(config.outputFormat)
+  );
+};
+
+export const createBackgroundRemovalVariable = (
+  name: string,
+  description: string,
+  required: boolean = true,
+  options?: string[]
+): BackgroundRemovalVariable => ({
+  name,
+  description,
+  required,
+  options,
+});
+
+export const getProcessingTime = (precision: BackgroundRemovalConfig['precision']): number => {
+  switch (precision) {
+    case 'fast': return 2;
+    case 'accurate': return 5;
+    case 'ultra-accurate': return 10;
+    default: return 5;
+  }
+};
+
+export const getQualityScore = (config: BackgroundRemovalConfig): number => {
+  let score = config.edgeRefinement ? 0.9 : 0.7;
+  if (config.preserveHair) score += 0.05;
+  if (config.precision === 'ultra-accurate') score += 0.15;
+  if (config.precision === 'accurate') score += 0.1;
+  return Math.min(score, 1.0);
+};

package/src/domains/prompts/domain/entities/ColorizationConfig.ts

@@ -0,0 +1,101 @@
+import type { AIPromptTemplate } from './AIPromptTemplate';
+
+export interface ColorizationConfig {
+  targetType: 'black-and-white' | 'sepia' | 'faded' | 'damaged';
+  colorMode: 'realistic' | 'vibrant' | 'artistic' | 'vintage';
+  preserveOriginal: boolean;
+  adjustLighting: boolean;
+  skinTonePreservation: boolean;
+  era?: '1920s' | '1940s' | '1960s' | '1980s' | 'victorian';
+}
+
+export interface ColorizationTemplate {
+  readonly id: string;
+  readonly name: string;
+  readonly description: string;
+  readonly basePrompt: string;
+  readonly variables: ColorizationVariable[];
+  readonly colorization: ColorizationSettings;
+}
+
+export interface ColorizationVariable {
+  name: string;
+  description: string;
+  required: boolean;
+  options?: string[];
+}
+
+export interface ColorizationSettings {
+  supportedModes: string[];
+  eraPresets: Record<string, string>;
+  skinToneAdjustments: number;
+}
+
+export interface ColorizationResult {
+  template: AIPromptTemplate;
+  config: ColorizationConfig;
+  qualityScore: number;
+  colorPalette?: string[];
+}
+
+export const validateColorizationConfig = (config: ColorizationConfig): boolean => {
+  return !!(
+    config.targetType &&
+    config.colorMode &&
+    ['realistic', 'vibrant', 'artistic', 'vintage'].includes(config.colorMode)
+  );
+};
+
+export const createColorizationVariable = (
+  name: string,
+  description: string,
+  required: boolean = true,
+  options?: string[]
+): ColorizationVariable => ({
+  name,
+  description,
+  required,
+  options,
+});
+
+export const getColorizationQuality = (config: ColorizationConfig): number => {
+  let quality = 0.8;
+
+  if (config.preserveOriginal) quality += 0.1;
+  if (config.skinTonePreservation) quality += 0.05;
+  if (config.colorMode === 'realistic') quality += 0.1;
+  if (config.targetType === 'black-and-white') quality += 0.05;
+
+  return Math.min(quality, 1.0);
+};
+
+export const getEraDescription = (era?: string): string => {
+  switch (era) {
+    case '1920s': return '1920s vintage aesthetic with soft colors';
+    case '1940s': return '1940s wartime color palette';
+    case '1960s': return '1960s vibrant, saturated colors';
+    case '1980s': return '1980s neon and pastel tones';
+    case 'victorian': return 'Victorian era muted, elegant colors';
+    default: return 'Historically appropriate color palette';
+  }
+};
+
+export const getSuggestedColorPalette = (
+  targetType: ColorizationConfig['targetType'],
+  colorMode: ColorizationConfig['colorMode']
+): string[] => {
+  switch (targetType) {
+    case 'black-and-white':
+      return colorMode === 'vibrant'
+        ? ['#FF6B6B', '#4ECDC4', '#45B7D1', '#96CEB4', '#FFEAA7']
+        : ['#2C3E50', '#34495E', '#7F8C8D', '#95A5A6', '#BDC3C7'];
+    case 'sepia':
+      return ['#8B7355', '#A0826D', '#BC9A6A', '#D2B48C', '#DEB887'];
+    case 'faded':
+      return ['#E27D60', '#41B3A3', '#85DCBA', '#C1E1DC', '#E8DDCB'];
+    case 'damaged':
+      return ['#C9302C', '#F0AD4E', '#5BC0DE', '#5CB85C'];
+    default:
+      return [];
+  }
+};

package/src/domains/prompts/domain/entities/FaceSwapConfig.ts

@@ -0,0 +1,54 @@
+import type { AIPromptTemplate } from './AIPromptTemplate';
+import type { GeneratedPrompt } from './GeneratedPrompt';
+
+export interface FaceSwapConfig {
+  preserveIdentity: boolean;
+  allowHairStyle: boolean;
+  allowAccessories: boolean;
+  allowExpression: boolean;
+  environment?: string;
+  styleName: string;
+}
+
+export interface FaceSwapTemplate {
+  readonly id: string;
+  readonly name: string;
+  readonly description: string;
+  readonly basePrompt: string;
+  readonly variables: FaceSwapTemplateVariable[];
+  readonly safety: FaceSwapSafety;
+}
+
+export interface FaceSwapTemplateVariable {
+  name: string;
+  description: string;
+  required: boolean;
+  options?: string[];
+}
+
+export interface FaceSwapSafety {
+  contentFilter: boolean;
+  identityPreservation: boolean;
+  adultContentFilter: boolean;
+}
+
+export interface FaceSwapGenerationResult {
+  template: AIPromptTemplate;
+  prompt: GeneratedPrompt;
+}
+
+export const validateFaceSwapConfig = (config: FaceSwapConfig): boolean => {
+  return !!(config.styleName && config.styleName.trim().length > 0);
+};
+
+export const createFaceSwapVariable = (
+  name: string,
+  description: string,
+  required: boolean = true,
+  options?: string[]
+): FaceSwapTemplateVariable => ({
+  name,
+  description,
+  required,
+  options,
+});

package/src/domains/prompts/domain/entities/FuturePredictionConfig.ts

@@ -0,0 +1,93 @@
+import type { AIPromptVariable } from './value-objects';
+
+/**
+ * Future Prediction Configuration
+ * Generic configuration for generating future scenarios/visualizations
+ */
+
+export interface FuturePredictionSettings {
+    readonly scenarioType: string; // e.g. 'lifestyle', 'career', 'family', 'adventure'
+    readonly outputType: FuturePredictionOutputType;
+    readonly personCount: 1 | 2;
+    readonly includeDate: boolean;
+    readonly language: string;
+    readonly tone?: string; // e.g. 'romantic', 'professional', 'funny', 'dramatic'
+    readonly subjectRole?: string; // e.g. 'couple', 'best friends', 'business partners', 'parents'
+    readonly year?: number; // Optional specific year for prediction
+}
+
+export type FuturePredictionOutputType = 'image' | 'story' | 'both';
+
+export interface FuturePredictionConfig {
+    readonly scenarioId: string;
+    readonly scenarioTitle: string;
+    readonly promptModifier: string;
+    readonly subjectA: string;
+    readonly subjectB?: string;
+    readonly settings: FuturePredictionSettings;
+    readonly customPrompt?: string;
+}
+
+export interface FuturePredictionTemplate {
+    readonly id: string;
+    readonly name: string;
+    readonly description: string;
+    readonly imagePrompt: string;
+    readonly storyPrompt: string;
+    readonly variables: readonly FuturePredictionVariable[];
+}
+
+export interface FuturePredictionVariable extends AIPromptVariable {
+    readonly category: 'subject' | 'scenario' | 'output';
+}
+
+export interface FuturePredictionResult {
+    readonly imagePrompt: string;
+    readonly storyPrompt: string;
+    readonly metadata: FuturePredictionMetadata;
+}
+
+export interface FuturePredictionMetadata {
+    readonly scenarioId: string;
+    readonly personCount: number;
+    readonly language: string;
+    readonly generatedAt: number;
+}
+
+export const validateFuturePredictionConfig = (
+    config: FuturePredictionConfig
+): boolean => {
+    if (!config.scenarioId || typeof config.scenarioId !== 'string') {
+        return false;
+    }
+    if (!config.subjectA || typeof config.subjectA !== 'string') {
+        return false;
+    }
+    if (!config.settings) {
+        return false;
+    }
+    return true;
+};
+
+export const createFuturePredictionVariable = (
+    name: string,
+    type: 'string' | 'number' | 'boolean',
+    description: string,
+    category: 'subject' | 'scenario' | 'output',
+    required: boolean = true,
+    defaultValue?: string | number | boolean
+): FuturePredictionVariable => ({
+    name,
+    type,
+    description,
+    category,
+    required,
+    defaultValue,
+});
+
+export const getFutureYear = (): number => {
+    const currentYear = new Date().getFullYear();
+    // Typical future predictions are 1-50 years ahead
+    const offset = 1 + Math.floor(Math.random() * 50);
+    return currentYear + offset;
+};

package/src/domains/prompts/domain/entities/GeneratedPrompt.ts

@@ -0,0 +1,32 @@
+import type { AIPromptTemplate } from './AIPromptTemplate';
+
+export interface GeneratedPrompt {
+  readonly id: string;
+  readonly templateId: string;
+  readonly generatedText: string;
+  readonly variables: Record<string, unknown>;
+  readonly timestamp: Date;
+}
+
+export interface CreateGeneratedPromptParams {
+  templateId: string;
+  generatedText: string;
+  variables: Record<string, unknown>;
+}
+
+export const createGeneratedPrompt = (
+  params: CreateGeneratedPromptParams
+): GeneratedPrompt => ({
+  id: `prompt_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+  templateId: params.templateId,
+  generatedText: params.generatedText,
+  variables: params.variables,
+  timestamp: new Date(),
+});
+
+export const isPromptRecent = (prompt: GeneratedPrompt, hours: number = 24): boolean => {
+  const now = new Date();
+  const promptTime = new Date(prompt.timestamp);
+  const diffInHours = (now.getTime() - promptTime.getTime()) / (1000 * 60 * 60);
+  return diffInHours <= hours;
+};

package/src/domains/prompts/domain/entities/ImageEnhancementConfig.ts

@@ -0,0 +1,93 @@
+import type { AIPromptTemplate } from './AIPromptTemplate';
+
+export interface ImageEnhancementConfig {
+  enhancementType: 'brightness' | 'contrast' | 'saturation' | 'sharpness' | 'all';
+  intensity: number;
+  preserveNatural: boolean;
+  autoAdjust: boolean;
+  targetStyle: 'natural' | 'vivid' | 'dramatic' | 'professional';
+}
+
+export interface ImageEnhancementTemplate {
+  readonly id: string;
+  readonly name: string;
+  readonly description: string;
+  readonly basePrompt: string;
+  readonly variables: ImageEnhancementVariable[];
+  readonly enhancement: EnhancementSettings;
+}
+
+export interface ImageEnhancementVariable {
+  name: string;
+  description: string;
+  required: boolean;
+  type: 'number' | 'select';
+  min?: number;
+  max?: number;
+  options?: string[];
+}
+
+export interface EnhancementSettings {
+  brightnessRange: [number, number];
+  contrastRange: [number, number];
+  saturationRange: [number, number];
+  sharpnessRange: [number, number];
+}
+
+export interface ImageEnhancementResult {
+  template: AIPromptTemplate;
+  config: ImageEnhancementConfig;
+  adjustments: EnhancementAdjustments;
+}
+
+export interface EnhancementAdjustments {
+  brightness: number;
+  contrast: number;
+  saturation: number;
+  sharpness: number;
+  overall: number;
+}
+
+export const validateImageEnhancementConfig = (config: ImageEnhancementConfig): boolean => {
+  return !!(
+    config.enhancementType && 
+    config.intensity >= 0 && 
+    config.intensity <= 1 &&
+    config.targetStyle
+  );
+};
+
+export const createImageEnhancementVariable = (
+  name: string,
+  description: string,
+  type: ImageEnhancementVariable['type'] = 'select',
+  required: boolean = true,
+  options?: string[]
+): ImageEnhancementVariable => ({
+  name,
+  description,
+  type,
+  required,
+  options,
+});
+
+export const calculateAdjustments = (
+  config: ImageEnhancementConfig
+): EnhancementAdjustments => {
+  const baseIntensity = config.intensity;
+  const multiplier = config.targetStyle === 'dramatic' ? 1.5 : 
+                    config.targetStyle === 'vivid' ? 1.2 : 
+                    config.targetStyle === 'professional' ? 0.8 : 1;
+
+  return {
+    brightness: config.enhancementType === 'brightness' || config.enhancementType === 'all' 
+      ? baseIntensity * multiplier : 0,
+    contrast: config.enhancementType === 'contrast' || config.enhancementType === 'all' 
+      ? baseIntensity * multiplier : 0,
+    saturation: config.enhancementType === 'saturation' || config.enhancementType === 'all' 
+      ? baseIntensity * multiplier : 0,
+    sharpness: config.enhancementType === 'sharpness' || config.enhancementType === 'all' 
+      ? baseIntensity * multiplier : 0,
+    overall: baseIntensity * multiplier,
+  };
+};

package/src/domains/prompts/domain/entities/PhotoRestorationConfig.ts

@@ -0,0 +1,64 @@
+import type { AIPromptTemplate } from './AIPromptTemplate';
+
+export interface PhotoRestorationConfig {
+  severity: 'minor' | 'moderate' | 'severe';
+  preserveOriginal: boolean;
+  enhanceColors: boolean;
+  removeNoise: boolean;
+  fixBlur: boolean;
+  restoreDetails: boolean;
+}
+
+export interface PhotoRestorationTemplate {
+  readonly id: string;
+  readonly name: string;
+  readonly description: string;
+  readonly basePrompt: string;
+  readonly variables: PhotoRestorationVariable[];
+  readonly quality: PhotoRestorationQuality;
+}
+
+export interface PhotoRestorationVariable {
+  name: string;
+  description: string;
+  required: boolean;
+  options?: string[];
+}
+
+export interface PhotoRestorationQuality {
+  detailLevel: number;
+  noiseReduction: number;
+  colorAccuracy: number;
+  sharpness: number;
+}
+
+export interface PhotoRestorationResult {
+  template: AIPromptTemplate;
+  config: PhotoRestorationConfig;
+  estimatedQuality: number;
+}
+
+export const validatePhotoRestorationConfig = (config: PhotoRestorationConfig): boolean => {
+  return !!(config.severity && config.severity.trim().length > 0);
+};
+
+export const createPhotoRestorationVariable = (
+  name: string,
+  description: string,
+  required: boolean = true,
+  options?: string[]
+): PhotoRestorationVariable => ({
+  name,
+  description,
+  required,
+  options,
+});
+
+export const getQualityLevel = (severity: PhotoRestorationConfig['severity']): number => {
+  switch (severity) {
+    case 'minor': return 0.7;
+    case 'moderate': return 0.5;
+    case 'severe': return 0.3;
+    default: return 0.5;
+  }
+};

package/src/domains/prompts/domain/entities/StyleTransferConfig.ts

@@ -0,0 +1,80 @@
+import type { AIPromptTemplate } from './AIPromptTemplate';
+
+export interface StyleTransferConfig {
+  targetStyle: string;
+  preserveContent: boolean;
+  styleStrength: number;
+  artisticMode: 'photorealistic' | 'artistic' | 'abstract' | 'cartoon';
+  maintainColors: boolean;
+  adaptToSubject: boolean;
+}
+
+export interface StyleTransferTemplate {
+  readonly id: string;
+  readonly name: string;
+  readonly description: string;
+  readonly basePrompt: string;
+  readonly variables: StyleTransferVariable[];
+  readonly style: StyleTransferSettings;
+}
+
+export interface StyleTransferVariable {
+  name: string;
+  description: string;
+  required: boolean;
+  options?: string[];
+  type: 'string' | 'select';
+}
+
+export interface StyleTransferSettings {
+  supportedStyles: string[];
+  maxStyleStrength: number;
+  preserveContentLevels: number[];
+  qualityPresets: Record<string, number>;
+}
+
+export interface StyleTransferResult {
+  template: AIPromptTemplate;
+  config: StyleTransferConfig;
+  appliedStyle: string;
+  expectedQuality: number;
+}
+
+export const validateStyleTransferConfig = (config: StyleTransferConfig): boolean => {
+  return !!(
+    config.targetStyle && 
+    config.targetStyle.trim().length > 0 &&
+    config.styleStrength >= 0 && 
+    config.styleStrength <= 1 &&
+    config.artisticMode
+  );
+};
+
+export const createStyleTransferVariable = (
+  name: string,
+  description: string,
+  required: boolean = true,
+  options?: string[]
+): StyleTransferVariable => ({
+  name,
+  description,
+  required,
+  options,
+  type: 'string',
+});
+
+export const getStyleStrengthValue = (strength: number): string => {
+  if (strength <= 0.3) return 'subtle';
+  if (strength <= 0.6) return 'moderate';
+  return 'strong';
+};
+
+export const getArtisticModeDescription = (mode: StyleTransferConfig['artisticMode']): string => {
+  switch (mode) {
+    case 'photorealistic': return 'Maintain realistic appearance while applying style';
+    case 'artistic': return 'Apply artistic interpretation with creative freedom';
+    case 'abstract': return 'Transform into abstract artistic representation';
+    case 'cartoon': return 'Convert to cartoon/animated style';
+    default: return 'Apply selected artistic style';
+  }
+};