rampkit-expo-dev 0.0.89 → 0.0.91

package/build/DeviceInfoCollector.js

@@ -15,6 +15,7 @@ exports.buildRampKitContext = buildRampKitContext;
 const react_native_1 = require("react-native");
 const RampKitNative_1 = __importDefault(require("./RampKitNative"));
 const constants_1 = require("./constants");
+const Logger_1 = require("./Logger");
 // Session-level data (regenerated each app launch)
 let sessionId = null;
 let sessionStartTime = null;
@@ -103,11 +104,11 @@ async function collectDeviceInfo() {
             // Timestamp
             collectedAt: nativeInfo.collectedAt,
         };
-        console.log("[RampKit] DeviceInfo: Collected from native module");
+        Logger_1.Logger.verbose("Device info collected");
         return deviceInfo;
     }
     catch (error) {
-        console.warn("[RampKit] DeviceInfo: Failed to collect from native module", error);
+        Logger_1.Logger.warn("Failed to collect device info from native module:", error);
         // Return minimal fallback
         return getFallbackDeviceInfo();
     }

package/build/EventManager.js

@@ -6,6 +6,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EventManager = exports.eventManager = void 0;
 const constants_1 = require("./constants");
+const Logger_1 = require("./Logger");
 /**
  * Generate a UUID v4 using Math.random
  * This is sufficient for event IDs - no crypto dependency needed
@@ -63,7 +64,7 @@ class EventManager {
             regionCode: deviceInfo.regionCode,
         };
         this.initialized = true;
-        console.log("[RampKit] EventManager: Initialized");
+        Logger_1.Logger.verbose("EventManager initialized");
     }
     /**
      * Check if the event manager is initialized
@@ -132,7 +133,7 @@ class EventManager {
     async track(eventName, properties = {}, contextOverrides) {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j;
         if (!this.initialized || !this.appId || !this.appUserId || !this.sessionId || !this.device) {
-            console.warn("[RampKit] EventManager: Not initialized, skipping event:", eventName);
+            Logger_1.Logger.warn("EventManager: Not initialized, skipping event:", eventName);
             return;
         }
         const eventId = generateEventId();
@@ -185,14 +186,14 @@ class EventManager {
                 catch (_a) {
                     // Ignore if we can't read the body
                 }
-                console.warn(`[RampKit] EventManager: Failed to send event: ${event.eventName}`, `\n  Status: ${response.status} ${response.statusText}`, `\n  URL: ${url}`, `\n  AppId: ${event.appId}`, `\n  UserId: ${event.appUserId}`, errorDetails ? `\n  Error: ${errorDetails}` : "");
+                Logger_1.Logger.warn(`Failed to send event ${event.eventName}: ${response.status}${errorDetails}`);
             }
             else {
-                console.log("[RampKit] EventManager: Event sent:", event.eventName);
+                Logger_1.Logger.verbose("Event sent:", event.eventName);
             }
         }
         catch (error) {
-            console.warn(`[RampKit] EventManager: Network error sending event: ${event.eventName}`, `\n  Error: ${error instanceof Error ? error.message : String(error)}`);
+            Logger_1.Logger.warn(`Network error sending event ${event.eventName}: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
     // ============================================================================
@@ -217,7 +218,7 @@ class EventManager {
     trackOnboardingAbandoned(reason, lastScreenName, onboardingId) {
         // Skip if onboarding was already completed this session
         if (this.onboardingCompletedForSession) {
-            console.log("[RampKit] EventManager: onboarding_abandoned skipped (already completed)");
+            Logger_1.Logger.verbose("onboarding_abandoned skipped (already completed)");
             return;
         }
         const timeSpentSeconds = this.getOnboardingDurationSeconds();
@@ -246,7 +247,7 @@ class EventManager {
      */
     trackOnboardingCompleted(trigger, completedSteps, totalSteps, onboardingId) {
         const timeToCompleteSeconds = this.getOnboardingDurationSeconds();
-        console.log(`[RampKit] EventManager: 📊 onboarding_completed`, `\n  trigger: ${trigger}`, `\n  onboardingId: ${onboardingId || this.currentOnboardingId}`, `\n  timeToCompleteSeconds: ${timeToCompleteSeconds}`);
+        Logger_1.Logger.verbose(`onboarding_completed: trigger=${trigger}, time=${timeToCompleteSeconds}s`);
         this.track("onboarding_completed", {
             onboardingId: onboardingId || this.currentOnboardingId,
             timeToCompleteSeconds,
@@ -284,7 +285,7 @@ class EventManager {
     trackPurchaseStarted(properties) {
         // Context (paywallId, placement) is automatically included from current state
         // which was set when trackPaywallShown was called
-        console.log(`[RampKit] EventManager: 🛒 purchase_started`, `\n  productId: ${properties.productId}`, properties.amount ? `\n  amount: ${properties.amount} ${properties.currency || ""}` : "");
+        Logger_1.Logger.verbose(`purchase_started: ${properties.productId}`);
         this.track("purchase_started", properties);
     }
     /**
@@ -294,21 +295,21 @@ class EventManager {
      */
     trackPurchaseCompleted(properties) {
         // Context is automatically included from current state (paywallId, placement, etc.)
-        console.log(`[RampKit] EventManager: ✅ purchase_completed`, `\n  productId: ${properties.productId}`, `\n  transactionId: ${properties.transactionId}`, `\n  originalTransactionId: ${properties.originalTransactionId}`, properties.isTrial ? `\n  isTrial: true` : "", properties.environment ? `\n  environment: ${properties.environment}` : "");
+        Logger_1.Logger.verbose(`purchase_completed: ${properties.productId}`);
         this.track("purchase_completed", properties);
     }
     /**
      * Track purchase failed
      */
     trackPurchaseFailed(productId, errorCode, errorMessage) {
-        console.log(`[RampKit] EventManager: ❌ purchase_failed`, `\n  productId: ${productId}`, `\n  errorCode: ${errorCode}`, `\n  errorMessage: ${errorMessage}`);
+        Logger_1.Logger.verbose(`purchase_failed: ${productId} (${errorCode})`);
         this.track("purchase_failed", { productId, errorCode, errorMessage });
     }
     /**
      * Track purchase restored
      */
     trackPurchaseRestored(properties) {
-        console.log(`[RampKit] EventManager: 🔄 purchase_restored`, `\n  productId: ${properties.productId}`, properties.transactionId ? `\n  transactionId: ${properties.transactionId}` : "", properties.originalTransactionId ? `\n  originalTransactionId: ${properties.originalTransactionId}` : "");
+        Logger_1.Logger.verbose(`purchase_restored: ${properties.productId}`);
         this.track("purchase_restored", properties);
     }
     /**

package/build/Logger.d.ts

@@ -0,0 +1,45 @@
+/**
+ * RampKit Logger
+ * Centralized logging with verbose mode support
+ *
+ * Like RevenueCat, the SDK logs minimal information by default.
+ * Enable verbose logging during development to see detailed logs.
+ */
+/**
+ * Set verbose logging mode
+ * When enabled, additional debug information will be logged
+ */
+export declare function setVerboseLogging(enabled: boolean): void;
+/**
+ * Check if verbose logging is enabled
+ */
+export declare function isVerboseLogging(): boolean;
+/**
+ * RampKit Logger
+ * - info(): Always logged - important SDK status messages
+ * - verbose(): Only logged when verboseLogging is enabled
+ * - warn(): Always logged - warnings that don't break functionality
+ * - error(): Always logged - errors that affect functionality
+ */
+export declare const Logger: {
+    /**
+     * Log important status messages (always shown)
+     * Use sparingly - only for SDK lifecycle events
+     */
+    info(message: string, ...args: any[]): void;
+    /**
+     * Log detailed debug information (only when verbose mode enabled)
+     * Use for step-by-step progress, variable values, etc.
+     */
+    verbose(message: string, ...args: any[]): void;
+    /**
+     * Log warnings (always shown)
+     * Use for recoverable issues, deprecations, or unexpected states
+     */
+    warn(message: string, ...args: any[]): void;
+    /**
+     * Log errors (always shown)
+     * Use for failures that affect SDK functionality
+     */
+    error(message: string, ...args: any[]): void;
+};

package/build/Logger.js

@@ -0,0 +1,65 @@
+"use strict";
+/**
+ * RampKit Logger
+ * Centralized logging with verbose mode support
+ *
+ * Like RevenueCat, the SDK logs minimal information by default.
+ * Enable verbose logging during development to see detailed logs.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+exports.setVerboseLogging = setVerboseLogging;
+exports.isVerboseLogging = isVerboseLogging;
+let verboseLogging = false;
+/**
+ * Set verbose logging mode
+ * When enabled, additional debug information will be logged
+ */
+function setVerboseLogging(enabled) {
+    verboseLogging = enabled;
+}
+/**
+ * Check if verbose logging is enabled
+ */
+function isVerboseLogging() {
+    return verboseLogging;
+}
+/**
+ * RampKit Logger
+ * - info(): Always logged - important SDK status messages
+ * - verbose(): Only logged when verboseLogging is enabled
+ * - warn(): Always logged - warnings that don't break functionality
+ * - error(): Always logged - errors that affect functionality
+ */
+exports.Logger = {
+    /**
+     * Log important status messages (always shown)
+     * Use sparingly - only for SDK lifecycle events
+     */
+    info(message, ...args) {
+        console.log(`[RampKit] ${message}`, ...args);
+    },
+    /**
+     * Log detailed debug information (only when verbose mode enabled)
+     * Use for step-by-step progress, variable values, etc.
+     */
+    verbose(message, ...args) {
+        if (verboseLogging) {
+            console.log(`[RampKit] ${message}`, ...args);
+        }
+    },
+    /**
+     * Log warnings (always shown)
+     * Use for recoverable issues, deprecations, or unexpected states
+     */
+    warn(message, ...args) {
+        console.warn(`[RampKit] ${message}`, ...args);
+    },
+    /**
+     * Log errors (always shown)
+     * Use for failures that affect SDK functionality
+     */
+    error(message, ...args) {
+        console.error(`[RampKit] ${message}`, ...args);
+    },
+};

package/build/OnboardingResponseStorage.d.ts

@@ -1,42 +1,25 @@
 /**
  * OnboardingResponseStorage
- * Manages persistent storage of onboarding state variables
+ * Manages persistent storage of onboarding variables
  */
 /**
- * Represents the stored onboarding state
- */
-export interface OnboardingState {
-    /** The state variables as key-value pairs */
-    variables: Record<string, any>;
-    /** ISO 8601 timestamp when the state was last updated */
-    updatedAt: string;
-}
-/**
- * Manages persistent storage of onboarding state variables
+ * Manages persistent storage of onboarding variables
  */
 export declare const OnboardingResponseStorage: {
     /**
-     * Initialize the state with initial values from onboarding config
-     * This should be called when onboarding starts
-     */
-    initializeState(initialVariables: Record<string, any>): Promise<void>;
-    /**
-     * Update state with new variable values (merges with existing)
+     * Initialize with initial values from onboarding config
      */
-    updateState(newVariables: Record<string, any>): Promise<void>;
+    initializeVariables(initialVariables: Record<string, any>): Promise<void>;
     /**
-     * Retrieve the stored state
-     * @returns OnboardingState object with variables and timestamp
+     * Update variables (merges with existing)
      */
-    retrieveState(): Promise<OnboardingState>;
+    updateVariables(newVariables: Record<string, any>): Promise<void>;
     /**
-     * Retrieve just the variables (convenience method)
-     * @returns Record of variable name to value
+     * Get stored variables
      */
-    retrieveVariables(): Promise<Record<string, any>>;
+    getVariables(): Promise<Record<string, any>>;
     /**
-     * Clear all stored state
+     * Clear all stored variables
      */
-    clearState(): Promise<void>;
-    clearResponses(): Promise<void>;
+    clearVariables(): Promise<void>;
 };

package/build/OnboardingResponseStorage.js

@@ -1,98 +1,69 @@
 "use strict";
 /**
  * OnboardingResponseStorage
- * Manages persistent storage of onboarding state variables
+ * Manages persistent storage of onboarding variables
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OnboardingResponseStorage = void 0;
 const RampKitNative_1 = require("./RampKitNative");
 const constants_1 = require("./constants");
+const Logger_1 = require("./Logger");
 /**
- * Manages persistent storage of onboarding state variables
+ * Manages persistent storage of onboarding variables
  */
 exports.OnboardingResponseStorage = {
     /**
-     * Initialize the state with initial values from onboarding config
-     * This should be called when onboarding starts
+     * Initialize with initial values from onboarding config
      */
-    async initializeState(initialVariables) {
+    async initializeVariables(initialVariables) {
         try {
-            const state = {
-                variables: { ...initialVariables },
-                updatedAt: new Date().toISOString(),
-            };
-            await (0, RampKitNative_1.setStoredValue)(constants_1.STORAGE_KEYS.ONBOARDING_RESPONSES, JSON.stringify(state));
-            if (__DEV__) {
-                console.log("[RampKit] Initialized onboarding state:", initialVariables);
-            }
+            await (0, RampKitNative_1.setStoredValue)(constants_1.STORAGE_KEYS.ONBOARDING_RESPONSES, JSON.stringify(initialVariables));
+            Logger_1.Logger.verbose("Initialized onboarding variables");
         }
         catch (error) {
-            console.warn("[RampKit] Failed to initialize onboarding state:", error);
+            Logger_1.Logger.warn("Failed to initialize onboarding variables:", error);
         }
     },
     /**
-     * Update state with new variable values (merges with existing)
+     * Update variables (merges with existing)
      */
-    async updateState(newVariables) {
+    async updateVariables(newVariables) {
         try {
-            const currentState = await this.retrieveState();
-            const updatedState = {
-                variables: {
-                    ...currentState.variables,
-                    ...newVariables,
-                },
-                updatedAt: new Date().toISOString(),
-            };
-            await (0, RampKitNative_1.setStoredValue)(constants_1.STORAGE_KEYS.ONBOARDING_RESPONSES, JSON.stringify(updatedState));
-            if (__DEV__) {
-                console.log("[RampKit] Updated onboarding state:", newVariables);
-            }
+            const current = await this.getVariables();
+            const merged = { ...current, ...newVariables };
+            await (0, RampKitNative_1.setStoredValue)(constants_1.STORAGE_KEYS.ONBOARDING_RESPONSES, JSON.stringify(merged));
+            Logger_1.Logger.verbose("Updated onboarding variables");
         }
         catch (error) {
-            console.warn("[RampKit] Failed to update onboarding state:", error);
+            Logger_1.Logger.warn("Failed to update onboarding variables:", error);
         }
     },
     /**
-     * Retrieve the stored state
-     * @returns OnboardingState object with variables and timestamp
+     * Get stored variables
      */
-    async retrieveState() {
+    async getVariables() {
         try {
             const jsonString = await (0, RampKitNative_1.getStoredValue)(constants_1.STORAGE_KEYS.ONBOARDING_RESPONSES);
             if (!jsonString) {
-                return { variables: {}, updatedAt: "" };
+                return {};
             }
             return JSON.parse(jsonString);
         }
         catch (error) {
-            console.warn("[RampKit] Failed to retrieve onboarding state:", error);
-            return { variables: {}, updatedAt: "" };
+            Logger_1.Logger.warn("Failed to retrieve onboarding variables:", error);
+            return {};
         }
     },
     /**
-     * Retrieve just the variables (convenience method)
-     * @returns Record of variable name to value
+     * Clear all stored variables
      */
-    async retrieveVariables() {
-        const state = await this.retrieveState();
-        return state.variables;
-    },
-    /**
-     * Clear all stored state
-     */
-    async clearState() {
+    async clearVariables() {
         try {
             await (0, RampKitNative_1.setStoredValue)(constants_1.STORAGE_KEYS.ONBOARDING_RESPONSES, "");
-            if (__DEV__) {
-                console.log("[RampKit] Cleared onboarding state");
-            }
+            Logger_1.Logger.verbose("Cleared onboarding variables");
         }
         catch (error) {
-            console.warn("[RampKit] Failed to clear onboarding state:", error);
+            Logger_1.Logger.warn("Failed to clear onboarding variables:", error);
         }
     },
-    // Legacy aliases for backwards compatibility
-    async clearResponses() {
-        return this.clearState();
-    },
 };

package/build/RampKit.d.ts

@@ -3,7 +3,6 @@
  * Main SDK class for RampKit Expo integration
  */
 import { DeviceInfo, RampKitConfig, EventContext } from "./types";
-import { OnboardingState } from "./OnboardingResponseStorage";
 export declare class RampKitCore {
     private static _instance;
     private config;
@@ -63,19 +62,13 @@ export declare class RampKitCore {
      */
     isInitialized(): boolean;
     /**
-     * Get all stored onboarding state variables
-     * @returns Promise resolving to OnboardingState with variables and timestamp
+     * Get all user answers from onboarding
      */
-    getOnboardingState(): Promise<OnboardingState>;
+    getAnswers(): Promise<Record<string, any>>;
     /**
-     * Get just the onboarding variables (convenience method)
-     * @returns Promise resolving to Record of variable name to value
+     * Get a single answer by key
      */
-    getOnboardingVariables(): Promise<Record<string, any>>;
-    /**
-     * @deprecated Use getOnboardingState() or getOnboardingVariables() instead
-     */
-    getOnboardingResponses(): Promise<Record<string, any>>;
+    getAnswer(key: string): Promise<any>;
     /**
      * Show the onboarding overlay
      */