@umituz/react-native-ai-generation-content 1.37.17 → 1.37.20

package/package.json

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

package/src/domains/generation/wizard/infrastructure/utils/creation-persistence.util.ts

@@ -72,13 +72,14 @@ export function createCreationPersistence(config: CreationPersistenceConfig = {}
       creationId: string,
       data: CompletedCreationData,
     ): Promise<void> => {
+      const output: { imageUrl?: string; videoUrl?: string } = {};
+      if (data.imageUrl) output.imageUrl = data.imageUrl;
+      if (data.videoUrl) output.videoUrl = data.videoUrl;
+
       await repository.update(userId, creationId, {
         uri: data.uri,
         status: "completed" as const,
-        output: {
-          imageUrl: data.imageUrl,
-          videoUrl: data.videoUrl,
-        },
+        output,
       });
 
       if (typeof __DEV__ !== "undefined" && __DEV__) {

package/src/domains/scenarios/domain/category-groups.ts

@@ -0,0 +1,97 @@
+/**
+ * Category Groups
+ * Pre-defined category groups for easy filtering
+ */
+
+import { ScenarioCategory } from "./scenario-category.enum";
+
+/**
+ * Single person categories - scenarios that work with one person
+ */
+export const SINGLE_PERSON_CATEGORIES: readonly ScenarioCategory[] = [
+  ScenarioCategory.FANTASY,
+  ScenarioCategory.ADVENTURE,
+  ScenarioCategory.SPORTS,
+  ScenarioCategory.ARTISTIC,
+  ScenarioCategory.CINEMATIC,
+  ScenarioCategory.CREATIVE,
+  ScenarioCategory.FASHION,
+  ScenarioCategory.HOBBIES,
+  ScenarioCategory.EXTREME,
+  ScenarioCategory.GAMING,
+  ScenarioCategory.CAREER,
+  ScenarioCategory.EDUCATION,
+  ScenarioCategory.LIFESTYLE,
+  ScenarioCategory.LUXURY,
+  ScenarioCategory.CULINARY,
+  ScenarioCategory.SEASONAL,
+  ScenarioCategory.ANIMALS,
+  ScenarioCategory.CELEBRATIONS,
+  ScenarioCategory.WELLNESS,
+  ScenarioCategory.BUCKET_LIST,
+  ScenarioCategory.SOCIAL_MEDIA,
+  ScenarioCategory.MYTHOLOGY,
+  ScenarioCategory.FUTURE_TECH,
+  ScenarioCategory.ACTION_STEALTH,
+  ScenarioCategory.ECOLOGY,
+  ScenarioCategory.NOSTALGIA,
+  ScenarioCategory.MYSTICAL,
+  ScenarioCategory.SUPERHEROES,
+  ScenarioCategory.VILLAINOUS,
+  ScenarioCategory.ELITE,
+  ScenarioCategory.GOTHIC,
+  ScenarioCategory.DAILY_ESSENCE,
+  ScenarioCategory.MOVIE_LEGENDS,
+  ScenarioCategory.ICONIC_MOMENTS,
+  ScenarioCategory.FOLKLORE,
+  ScenarioCategory.MUSIC,
+  ScenarioCategory.STEAMPUNK,
+  ScenarioCategory.PERFORMANCE,
+  ScenarioCategory.FESTIVAL,
+  ScenarioCategory.HISTORICAL,
+  ScenarioCategory.CULTURAL,
+  ScenarioCategory.SCI_FI,
+  ScenarioCategory.TRAVEL,
+  ScenarioCategory.VINTAGE_SUMMER,
+  ScenarioCategory.DARK_ACADEMIA,
+  ScenarioCategory.RETRO_ARCADE,
+  ScenarioCategory.COZY_PLUSH,
+  ScenarioCategory.PIRATE_ERA,
+  ScenarioCategory.SAMURAI,
+  ScenarioCategory.SURREAL_DREAMS,
+  ScenarioCategory.MAGICAL_REALISM,
+  ScenarioCategory.VINTAGE_CIRCUS,
+  ScenarioCategory.ELEMENTAL,
+  ScenarioCategory.SPEED_DEMONS,
+  ScenarioCategory.UNDERWATER,
+  ScenarioCategory.ARABIAN_NIGHTS,
+  ScenarioCategory.PREHISTORIC,
+  ScenarioCategory.POST_APOCALYPTIC,
+];
+
+/**
+ * Couple categories - scenarios designed for two people
+ */
+export const COUPLE_CATEGORIES: readonly ScenarioCategory[] = [
+  ScenarioCategory.INTIMATE,
+  ScenarioCategory.WEDDING,
+  ScenarioCategory.AFFECTION,
+  ScenarioCategory.ROMANTIC_KISSES,
+  ScenarioCategory.SULTRY,
+  ScenarioCategory.STOLEN_MOMENTS,
+  ScenarioCategory.CONNECTION,
+  ScenarioCategory.FAMILY,
+  ScenarioCategory.TIME_TRAVEL,
+  ScenarioCategory.HOME_LIFE,
+  ScenarioCategory.ART_STUDIO,
+  ScenarioCategory.URBAN_NIGHTS,
+  ScenarioCategory.CASINO,
+];
+
+/**
+ * All categories
+ */
+export const ALL_CATEGORIES: readonly ScenarioCategory[] = [
+  ...SINGLE_PERSON_CATEGORIES,
+  ...COUPLE_CATEGORIES,
+];

package/src/domains/scenarios/index.ts

@@ -11,12 +11,18 @@ export type { Scenario } from "./domain/Scenario";
 // Scenario Data
 export { SCENARIOS } from "./infrastructure/ScenariosData";
 
+// Category Groups - Pre-defined category groups for filtering
+export {
+  SINGLE_PERSON_CATEGORIES,
+  COUPLE_CATEGORIES,
+  ALL_CATEGORIES,
+} from "./domain/category-groups";
+
 // Scenario Helpers - For app-level configuration
 export {
   createScenariosForApp,
   filterScenariosByOutputType,
   filterScenariosByCategory,
-  filterScenariosByWizardInputType,
   getScenarioCategories,
   findScenarioById,
 } from "./infrastructure/scenario-helpers";

package/src/domains/scenarios/infrastructure/scenario-helpers.ts

@@ -4,8 +4,6 @@
  */
 
 import type { Scenario, ScenarioOutputType } from "../domain/Scenario";
-import { WizardInputType } from "../configs/wizard-input.types";
-import { detectWizardInputType } from "../configs/wizard-input-detector";
 
 /**
  * Configuration for creating app-specific scenarios
@@ -15,49 +13,26 @@ export interface AppScenarioConfig {
   readonly outputType: ScenarioOutputType;
   /** Optional AI model to assign to all scenarios */
   readonly model?: string;
-  /** Optional filter to exclude certain scenarios by ID */
-  readonly excludeIds?: readonly string[];
-  /** Optional filter to include only certain category IDs */
-  readonly includeCategories?: readonly string[];
-  /** Optional filter to exclude wizard input types (uses pattern detection) */
-  readonly excludeWizardInputTypes?: readonly WizardInputType[];
+  /** Categories to include (whitelist) */
+  readonly categories: readonly string[];
 }
 
 /**
  * Creates app-configured scenarios from package scenarios
+ * Uses whitelist approach - only includes specified categories
  */
 export const createScenariosForApp = (
   scenarios: readonly Scenario[],
   config: AppScenarioConfig,
 ): Scenario[] => {
-  const {
-    outputType,
-    model,
-    excludeIds,
-    includeCategories,
-    excludeWizardInputTypes,
-  } = config;
+  const { outputType, model, categories } = config;
 
   return scenarios
     .filter((scenario) => {
-      if (excludeIds?.includes(scenario.id)) {
+      if (!scenario.category) {
         return false;
       }
-      if (
-        includeCategories &&
-        includeCategories.length > 0 &&
-        scenario.category &&
-        !includeCategories.includes(scenario.category)
-      ) {
-        return false;
-      }
-      if (excludeWizardInputTypes && excludeWizardInputTypes.length > 0) {
-        const detectedType = detectWizardInputType(scenario.id);
-        if (excludeWizardInputTypes.includes(detectedType)) {
-          return false;
-        }
-      }
-      return true;
+      return categories.includes(scenario.category);
     })
     .map((scenario) => ({
       ...scenario,
@@ -82,15 +57,6 @@ export const filterScenariosByCategory = (
   category: string,
 ): Scenario[] => scenarios.filter((s) => s.category === category);
 
-/**
- * Filters scenarios by wizard input type using pattern detection
- */
-export const filterScenariosByWizardInputType = (
-  scenarios: readonly Scenario[],
-  inputTypes: readonly WizardInputType[],
-): Scenario[] =>
-  scenarios.filter((s) => inputTypes.includes(detectWizardInputType(s.id)));
-
 /**
  * Gets unique categories from scenarios
  */