@umituz/react-native-ai-generation-content 1.27.11 → 1.27.12

package/package.json

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

package/src/domain/entities/flow-config.types.ts

@@ -5,17 +5,39 @@
 
 /** Step Types */
 export enum StepType {
+  // Gate steps - auth and credits check
+  AUTH_GATE = "auth_gate",
+  CREDIT_GATE = "credit_gate",
+  // Content steps
   CATEGORY_SELECTION = "category_selection",
   SCENARIO_SELECTION = "scenario_selection",
   SCENARIO_PREVIEW = "scenario_preview",
   PARTNER_UPLOAD = "partner_upload",
   TEXT_INPUT = "text_input",
   FEATURE_SELECTION = "feature_selection",
+  // Generation steps
   GENERATING = "generating",
   RESULT_PREVIEW = "result_preview",
   CUSTOM = "custom",
 }
 
+/** Gate Step Result */
+export type GateResult = "passed" | "blocked" | "pending";
+
+/** Auth Gate Configuration */
+export interface AuthGateConfig {
+  readonly allowAnonymous?: boolean;
+  readonly onAuthRequired?: () => void;
+  readonly onAuthSuccess?: () => void;
+}
+
+/** Credit Gate Configuration */
+export interface CreditGateConfig {
+  readonly requiredCredits: number;
+  readonly onCreditsExhausted?: () => void;
+  readonly onCreditsAvailable?: () => void;
+}
+
 /** Partner Configuration */
 export interface PartnerConfig {
   readonly partnerId: "A" | "B" | "single";

package/src/domains/generation/index.ts

@@ -35,3 +35,16 @@ export { ExecutorFactory, type GenerationType as ExecutorGenerationType } from "
 
 export * from "./wizard";
 export * from "./infrastructure/flow";
+
+// Flow config types from domain
+export {
+  StepType,
+  type GateResult,
+  type AuthGateConfig,
+  type CreditGateConfig,
+  type FlowState,
+  type FlowActions,
+  type FlowCallbacks,
+  type FlowConfiguration,
+  type StepDefinition,
+} from "../../domain/entities/flow-config.types";

package/src/domains/generation/wizard/domain/entities/wizard-config.types.ts

@@ -72,10 +72,32 @@ export interface PreviewStepConfig extends BaseStepConfig {
   readonly showContinueButton?: boolean;
 }
 
+/**
+ * Auth Gate Step Configuration
+ * Blocks flow if user is not authenticated
+ */
+export interface AuthGateStepConfig extends BaseStepConfig {
+  readonly type: "auth_gate";
+  readonly allowAnonymous?: boolean;
+  readonly messageKey?: string;
+}
+
+/**
+ * Credit Gate Step Configuration
+ * Blocks flow if user doesn't have enough credits
+ */
+export interface CreditGateStepConfig extends BaseStepConfig {
+  readonly type: "credit_gate";
+  readonly requiredCredits: number;
+  readonly messageKey?: string;
+}
+
 /**
  * Union of all step config types
  */
 export type WizardStepConfig =
+  | AuthGateStepConfig
+  | CreditGateStepConfig
   | PhotoUploadStepConfig
   | TextInputStepConfig
   | SelectionStepConfig

package/src/domains/generation/wizard/index.ts

@@ -7,6 +7,8 @@
 // Domain Entities - Configuration Types
 export type {
   BaseStepConfig,
+  AuthGateStepConfig,
+  CreditGateStepConfig,
   PhotoUploadStepConfig,
   TextInputStepConfig,
   SelectionStepConfig,

package/src/domains/generation/wizard/presentation/hooks/useGateStep.ts

@@ -0,0 +1,138 @@
+/**
+ * useGateStep Hook
+ * Handles auth and credit gate steps in wizard flow
+ *
+ * Gates are "invisible" steps that:
+ * - Auto-advance when condition is met
+ * - Show modal/paywall when blocked
+ * - Never show UI themselves
+ */
+
+import { useEffect, useRef, useCallback } from "react";
+import type { GateResult } from "../../../../../domain/entities/flow-config.types";
+
+declare const __DEV__: boolean;
+
+export interface GateCallbacks {
+  /** Called when auth is required - should show auth modal */
+  readonly onAuthRequired?: () => void;
+  /** Called when credits are exhausted - should show paywall */
+  readonly onCreditsExhausted?: () => void;
+  /** Called when gate passes - auto advance to next step */
+  readonly onGatePassed?: () => void;
+}
+
+export interface AuthGateState {
+  readonly isAuthenticated: boolean;
+  readonly isAnonymous: boolean;
+  readonly userId: string | null;
+}
+
+export interface CreditGateState {
+  readonly creditBalance: number;
+  readonly requiredCredits: number;
+}
+
+export interface UseGateStepProps {
+  readonly gateType: "auth" | "credit";
+  readonly authState?: AuthGateState;
+  readonly creditState?: CreditGateState;
+  readonly callbacks: GateCallbacks;
+  readonly allowAnonymous?: boolean;
+}
+
+export interface UseGateStepReturn {
+  readonly gateResult: GateResult;
+  readonly checkGate: () => GateResult;
+}
+
+/**
+ * Hook to manage gate step logic
+ * Automatically triggers callbacks and advances when conditions are met
+ */
+export function useGateStep(props: UseGateStepProps): UseGateStepReturn {
+  const { gateType, authState, creditState, callbacks, allowAnonymous = false } = props;
+
+  const hasChecked = useRef(false);
+
+  const checkAuthGate = useCallback((): GateResult => {
+    if (!authState) return "pending";
+
+    const { isAuthenticated, isAnonymous, userId } = authState;
+
+    // Allow anonymous if configured
+    if (allowAnonymous && userId) {
+      return "passed";
+    }
+
+    // Must be authenticated and not anonymous
+    if (isAuthenticated && !isAnonymous && userId) {
+      return "passed";
+    }
+
+    return "blocked";
+  }, [authState, allowAnonymous]);
+
+  const checkCreditGate = useCallback((): GateResult => {
+    if (!creditState) return "pending";
+
+    const { creditBalance, requiredCredits } = creditState;
+
+    if (creditBalance >= requiredCredits) {
+      return "passed";
+    }
+
+    return "blocked";
+  }, [creditState]);
+
+  const checkGate = useCallback((): GateResult => {
+    if (gateType === "auth") {
+      return checkAuthGate();
+    }
+    return checkCreditGate();
+  }, [gateType, checkAuthGate, checkCreditGate]);
+
+  // Auto-check and trigger callbacks on mount
+  useEffect(() => {
+    if (hasChecked.current) return;
+
+    const result = checkGate();
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log(`[useGateStep] ${gateType} gate check:`, result);
+    }
+
+    if (result === "passed") {
+      hasChecked.current = true;
+      callbacks.onGatePassed?.();
+    } else if (result === "blocked") {
+      hasChecked.current = true;
+      if (gateType === "auth") {
+        callbacks.onAuthRequired?.();
+      } else {
+        callbacks.onCreditsExhausted?.();
+      }
+    }
+  }, [gateType, checkGate, callbacks]);
+
+  // Re-check when auth/credit state changes
+  useEffect(() => {
+    if (!hasChecked.current) return;
+
+    const result = checkGate();
+
+    if (result === "passed") {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log(`[useGateStep] ${gateType} gate now passed, advancing...`);
+      }
+      callbacks.onGatePassed?.();
+    }
+  }, [authState, creditState, gateType, checkGate, callbacks]);
+
+  return {
+    gateResult: checkGate(),
+    checkGate,
+  };
+}
+
+export default useGateStep;