rampkit-expo-dev 0.0.91 → 0.0.92

package/build/EventManager.d.ts

@@ -15,6 +15,9 @@ declare class EventManager {
     private currentVariantId;
     private currentPaywallId;
     private currentPlacement;
+    private currentTargetId;
+    private currentTargetName;
+    private currentBucket;
     private onboardingStartTime;
     private currentOnboardingId;
     private onboardingCompletedForSession;
@@ -40,6 +43,19 @@ declare class EventManager {
      * Set current paywall context
      */
     setCurrentPaywall(paywallId: string | null, placement?: string | null): void;
+    /**
+     * Set targeting context (called after target evaluation)
+     * This persists for all subsequent events
+     */
+    setTargetingContext(targetId: string, targetName: string, onboardingId: string, bucket: number): void;
+    /**
+     * Get current targeting info (for user profile updates)
+     */
+    getTargetingInfo(): {
+        targetId: string | null;
+        targetName: string | null;
+        bucket: number | null;
+    };
     /**
      * Start onboarding tracking
      */
@@ -68,6 +84,11 @@ declare class EventManager {
      * Track app session started
      */
     trackAppSessionStarted(isFirstLaunch: boolean, launchCount: number): void;
+    /**
+     * Track target matched event
+     * Called when targeting evaluation completes and a target is selected
+     */
+    trackTargetMatched(targetId: string, targetName: string, onboardingId: string, bucket: number): void;
     /**
      * Track onboarding started
      */

package/build/EventManager.js

@@ -31,6 +31,10 @@ class EventManager {
         this.currentVariantId = null;
         this.currentPaywallId = null;
         this.currentPlacement = null;
+        // Targeting tracking (persists for all events after target match)
+        this.currentTargetId = null;
+        this.currentTargetName = null;
+        this.currentBucket = null;
         // Onboarding tracking
         this.onboardingStartTime = null;
         this.currentOnboardingId = null;
@@ -96,6 +100,28 @@ class EventManager {
             this.currentPlacement = placement;
         }
     }
+    /**
+     * Set targeting context (called after target evaluation)
+     * This persists for all subsequent events
+     */
+    setTargetingContext(targetId, targetName, onboardingId, bucket) {
+        this.currentTargetId = targetId;
+        this.currentTargetName = targetName;
+        this.currentOnboardingId = onboardingId;
+        this.currentBucket = bucket;
+        this.currentFlowId = onboardingId;
+        Logger_1.Logger.verbose("EventManager: Targeting context set", { targetId, targetName, bucket });
+    }
+    /**
+     * Get current targeting info (for user profile updates)
+     */
+    getTargetingInfo() {
+        return {
+            targetId: this.currentTargetId,
+            targetName: this.currentTargetName,
+            bucket: this.currentBucket,
+        };
+    }
     /**
      * Start onboarding tracking
      */
@@ -147,6 +173,16 @@ class EventManager {
             regionCode: (_h = (_g = contextOverrides === null || contextOverrides === void 0 ? void 0 : contextOverrides.regionCode) !== null && _g !== void 0 ? _g : this.baseContext.regionCode) !== null && _h !== void 0 ? _h : null,
             placement: (_j = contextOverrides === null || contextOverrides === void 0 ? void 0 : contextOverrides.placement) !== null && _j !== void 0 ? _j : this.currentPlacement,
         };
+        // Include targeting info in all events if available
+        const enrichedProperties = {
+            ...properties,
+        };
+        if (this.currentTargetId) {
+            enrichedProperties.targetId = this.currentTargetId;
+        }
+        if (this.currentBucket !== null) {
+            enrichedProperties.bucket = this.currentBucket;
+        }
         const event = {
             appId: this.appId,
             appUserId: this.appUserId,
@@ -156,7 +192,7 @@ class EventManager {
             occurredAt,
             device: this.device,
             context,
-            properties,
+            properties: enrichedProperties,
         };
         // Fire and forget - don't await
         this.sendEvent(event);
@@ -205,6 +241,21 @@ class EventManager {
     trackAppSessionStarted(isFirstLaunch, launchCount) {
         this.track("app_session_started", { isFirstLaunch, launchCount });
     }
+    /**
+     * Track target matched event
+     * Called when targeting evaluation completes and a target is selected
+     */
+    trackTargetMatched(targetId, targetName, onboardingId, bucket) {
+        // Set targeting context for all future events
+        this.setTargetingContext(targetId, targetName, onboardingId, bucket);
+        // Track the target_matched event
+        this.track("target_matched", {
+            targetId,
+            targetName,
+            onboardingId,
+            bucket,
+        });
+    }
     /**
      * Track onboarding started
      */
@@ -326,6 +377,9 @@ class EventManager {
         this.currentVariantId = null;
         this.currentPaywallId = null;
         this.currentPlacement = null;
+        this.currentTargetId = null;
+        this.currentTargetName = null;
+        this.currentBucket = null;
         this.onboardingStartTime = null;
         this.currentOnboardingId = null;
         this.onboardingCompletedForSession = false;

package/build/RampKit.d.ts

@@ -3,6 +3,7 @@
  * Main SDK class for RampKit Expo integration
  */
 import { DeviceInfo, RampKitConfig, EventContext } from "./types";
+import { TargetEvaluationResult } from "./TargetingEngine";
 export declare class RampKitCore {
     private static _instance;
     private config;
@@ -15,6 +16,8 @@ export declare class RampKitCore {
     private initialized;
     /** Custom App User ID provided by the developer (alias for their user system) */
     private appUserID;
+    /** Result of target evaluation (for analytics/debugging) */
+    private targetingResult;
     static get instance(): RampKitCore;
     /**
      * Configure the RampKit SDK
@@ -57,6 +60,10 @@ export declare class RampKitCore {
      * Get the device info
      */
     getDeviceInfo(): DeviceInfo | null;
+    /**
+     * Get the targeting result (which target matched and which onboarding was selected)
+     */
+    getTargetingResult(): TargetEvaluationResult | null;
     /**
      * Check if SDK is initialized
      */

package/build/RampKit.js

@@ -10,6 +10,8 @@ const userId_1 = require("./userId");
 const DeviceInfoCollector_1 = require("./DeviceInfoCollector");
 const EventManager_1 = require("./EventManager");
 const RampKitNative_1 = require("./RampKitNative");
+const TargetingContext_1 = require("./TargetingContext");
+const TargetingEngine_1 = require("./TargetingEngine");
 const constants_1 = require("./constants");
 const OnboardingResponseStorage_1 = require("./OnboardingResponseStorage");
 const Logger_1 = require("./Logger");
@@ -23,6 +25,8 @@ class RampKitCore {
         this.initialized = false;
         /** Custom App User ID provided by the developer (alias for their user system) */
         this.appUserID = null;
+        /** Result of target evaluation (for analytics/debugging) */
+        this.targetingResult = null;
     }
     static get instance() {
         if (!this._instance)
@@ -87,21 +91,44 @@ class RampKitCore {
                 Logger_1.Logger.warn("Failed to resolve user id:", e2);
             }
         }
-        // Load onboarding data
+        // Load onboarding data with targeting
         Logger_1.Logger.verbose("Loading onboarding data...");
         try {
             const manifestUrl = `${constants_1.MANIFEST_BASE_URL}/${config.appId}/manifest.json`;
             Logger_1.Logger.verbose("Fetching manifest from", manifestUrl);
             const manifestResponse = await globalThis.fetch(manifestUrl);
             const manifest = await manifestResponse.json();
-            if (!manifest.onboardings || manifest.onboardings.length === 0) {
-                throw new Error("No onboardings found in manifest");
+            // Build targeting context from device info
+            const targetingContext = (0, TargetingContext_1.buildTargetingContext)(this.deviceInfo);
+            Logger_1.Logger.verbose("Targeting context built:", JSON.stringify(targetingContext, null, 2));
+            // Evaluate targets to find matching onboarding
+            if (!manifest.targets || manifest.targets.length === 0) {
+                throw new Error("No targets found in manifest");
             }
-            // Use the first onboarding
-            const firstOnboarding = manifest.onboardings[0];
-            Logger_1.Logger.verbose("Using onboarding:", firstOnboarding.name);
-            // Fetch the actual onboarding data
-            const onboardingResponse = await globalThis.fetch(firstOnboarding.url);
+            const result = (0, TargetingEngine_1.evaluateTargets)(manifest.targets, targetingContext, this.userId || "anonymous");
+            if (!result) {
+                throw new Error("No matching target found in manifest");
+            }
+            this.targetingResult = result;
+            Logger_1.Logger.verbose("Target matched:", `"${result.targetName}" -> onboarding ${result.onboarding.id} (bucket ${result.bucket})`);
+            // Track target_matched event (also sets targeting context for all future events)
+            EventManager_1.eventManager.trackTargetMatched(result.targetId, result.targetName, result.onboarding.id, result.bucket);
+            // Update deviceInfo with targeting data
+            if (this.deviceInfo) {
+                this.deviceInfo = {
+                    ...this.deviceInfo,
+                    matchedTargetId: result.targetId,
+                    matchedTargetName: result.targetName,
+                    matchedOnboardingId: result.onboarding.id,
+                    abTestBucket: result.bucket,
+                };
+                // Sync updated targeting info to backend
+                this.sendUserDataToBackend(this.deviceInfo).catch((e) => {
+                    Logger_1.Logger.warn("Failed to sync targeting info to backend:", e);
+                });
+            }
+            // Fetch the selected onboarding data
+            const onboardingResponse = await globalThis.fetch(result.onboarding.url);
             const json = await onboardingResponse.json();
             this.onboardingData = json;
             Logger_1.Logger.verbose("Onboarding loaded, id:", json === null || json === void 0 ? void 0 : json.onboardingId);
@@ -109,6 +136,7 @@ class RampKitCore {
         catch (error) {
             Logger_1.Logger.verbose("Onboarding load failed:", error);
             this.onboardingData = null;
+            this.targetingResult = null;
         }
         // Log SDK configured (always shown - single summary line)
         Logger_1.Logger.info(`Configured - appId: ${config.appId}, userId: ${this.userId || "pending"}`);
@@ -219,6 +247,12 @@ class RampKitCore {
     getDeviceInfo() {
         return this.deviceInfo;
     }
+    /**
+     * Get the targeting result (which target matched and which onboarding was selected)
+     */
+    getTargetingResult() {
+        return this.targetingResult;
+    }
     /**
      * Check if SDK is initialized
      */
@@ -387,6 +421,7 @@ class RampKitCore {
         this.userId = null;
         this.deviceInfo = null;
         this.onboardingData = null;
+        this.targetingResult = null;
         this.initialized = false;
         this.appUserID = null;
         // Clear stored onboarding variables

package/build/TargetingContext.d.ts

@@ -0,0 +1,10 @@
+/**
+ * RampKit Targeting Context
+ * Builds targeting context from DeviceInfo for rule evaluation
+ */
+import { DeviceInfo, TargetingContext } from "./types";
+/**
+ * Build targeting context from DeviceInfo
+ * Maps SDK device info to the attribute structure used by targeting rules
+ */
+export declare function buildTargetingContext(deviceInfo: DeviceInfo | null): TargetingContext;

package/build/TargetingContext.js

@@ -0,0 +1,100 @@
+"use strict";
+/**
+ * RampKit Targeting Context
+ * Builds targeting context from DeviceInfo for rule evaluation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTargetingContext = buildTargetingContext;
+/**
+ * Calculate days since install from install date string
+ */
+function calculateDaysSinceInstall(installDateString) {
+    try {
+        const installDate = new Date(installDateString);
+        const now = new Date();
+        const diffMs = now.getTime() - installDate.getTime();
+        const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24));
+        return Math.max(0, diffDays);
+    }
+    catch (_a) {
+        return 0;
+    }
+}
+/**
+ * Build targeting context from DeviceInfo
+ * Maps SDK device info to the attribute structure used by targeting rules
+ */
+function buildTargetingContext(deviceInfo) {
+    var _a, _b;
+    if (!deviceInfo) {
+        // Return default context with null values for optional fields
+        return {
+            user: {
+                isNewUser: true,
+                daysSinceInstall: 0,
+                subscriptionStatus: null,
+                hasAppleSearchAdsAttribution: false,
+            },
+            device: {
+                platform: "iOS",
+                model: "unknown",
+                osVersion: "0",
+                interfaceStyle: "light",
+                country: "US",
+                language: "en",
+                locale: "en_US",
+                currencyCode: "USD",
+            },
+            app: {
+                version: "1.0.0",
+                buildNumber: "1",
+                sdkVersion: "1.0.0",
+            },
+            asa: {
+                keyword: null,
+                campaignId: null,
+            },
+            cpp: {
+                pageId: null,
+            },
+        };
+    }
+    // Extract country from regionCode or locale
+    const country = deviceInfo.regionCode ||
+        ((_a = deviceInfo.deviceLocale) === null || _a === void 0 ? void 0 : _a.split("_")[1]) ||
+        "US";
+    // Extract language from deviceLanguageCode or locale
+    const language = deviceInfo.deviceLanguageCode ||
+        ((_b = deviceInfo.deviceLocale) === null || _b === void 0 ? void 0 : _b.split("_")[0]) ||
+        "en";
+    return {
+        user: {
+            isNewUser: deviceInfo.isFirstLaunch,
+            daysSinceInstall: calculateDaysSinceInstall(deviceInfo.installDate),
+            subscriptionStatus: null, // Not yet collected - will be null
+            hasAppleSearchAdsAttribution: deviceInfo.isAppleSearchAdsAttribution,
+        },
+        device: {
+            platform: deviceInfo.platform,
+            model: deviceInfo.deviceModel,
+            osVersion: deviceInfo.platformVersion,
+            interfaceStyle: deviceInfo.interfaceStyle,
+            country,
+            language,
+            locale: deviceInfo.deviceLocale,
+            currencyCode: deviceInfo.deviceCurrencyCode || "USD",
+        },
+        app: {
+            version: deviceInfo.appVersion || "1.0.0",
+            buildNumber: deviceInfo.buildNumber || "1",
+            sdkVersion: deviceInfo.sdkVersion,
+        },
+        asa: {
+            keyword: null, // Not yet collected
+            campaignId: null, // Not yet collected
+        },
+        cpp: {
+            pageId: null, // Not yet collected
+        },
+    };
+}

package/build/TargetingEngine.d.ts

@@ -0,0 +1,37 @@
+/**
+ * RampKit Targeting Engine
+ * Evaluates targeting rules and handles A/B allocation
+ */
+import { ManifestTarget, TargetRules, TargetRule, TargetOnboarding, TargetingContext } from "./types";
+/**
+ * Result of target evaluation including metadata for logging/analytics
+ */
+export interface TargetEvaluationResult {
+    onboarding: TargetOnboarding;
+    targetId: string;
+    targetName: string;
+    bucket: number;
+}
+/**
+ * Evaluate all targets and return the selected onboarding
+ * Targets are evaluated in priority order (0 = highest priority)
+ * Falls back to lowest priority target if none match
+ */
+export declare function evaluateTargets(targets: ManifestTarget[], context: TargetingContext, userId: string): TargetEvaluationResult | null;
+/**
+ * Evaluate a set of rules against the context
+ * Empty rules = matches all users
+ */
+export declare function evaluateRules(rules: TargetRules, context: TargetingContext): boolean;
+/**
+ * Evaluate a single rule against the context
+ */
+export declare function evaluateRule(rule: TargetRule, context: TargetingContext): boolean;
+/**
+ * Select an onboarding based on allocation percentages
+ * Uses deterministic hashing for consistent A/B assignment
+ */
+export declare function selectOnboardingByAllocation(onboardings: TargetOnboarding[], userId: string): {
+    onboarding: TargetOnboarding;
+    bucket: number;
+};

package/build/TargetingEngine.js

@@ -0,0 +1,162 @@
+"use strict";
+/**
+ * RampKit Targeting Engine
+ * Evaluates targeting rules and handles A/B allocation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateTargets = evaluateTargets;
+exports.evaluateRules = evaluateRules;
+exports.evaluateRule = evaluateRule;
+exports.selectOnboardingByAllocation = selectOnboardingByAllocation;
+const Logger_1 = require("./Logger");
+/**
+ * Evaluate all targets and return the selected onboarding
+ * Targets are evaluated in priority order (0 = highest priority)
+ * Falls back to lowest priority target if none match
+ */
+function evaluateTargets(targets, context, userId) {
+    if (!targets || targets.length === 0) {
+        Logger_1.Logger.verbose("TargetingEngine", "No targets in manifest");
+        return null;
+    }
+    // Sort by priority ascending (0 = highest priority, evaluated first)
+    const sorted = [...targets].sort((a, b) => a.priority - b.priority);
+    Logger_1.Logger.verbose("TargetingEngine", `Evaluating ${sorted.length} targets for user ${userId.substring(0, 8)}...`);
+    for (const target of sorted) {
+        const matches = evaluateRules(target.rules, context);
+        Logger_1.Logger.verbose("TargetingEngine", `Target "${target.name}" (priority ${target.priority}): ${matches ? "MATCHED" : "no match"}`);
+        if (matches) {
+            const { onboarding, bucket } = selectOnboardingByAllocation(target.onboardings, userId);
+            Logger_1.Logger.verbose("TargetingEngine", `Selected onboarding ${onboarding.id} (bucket ${bucket}, allocation ${onboarding.allocation}%)`);
+            return {
+                onboarding,
+                targetId: target.id,
+                targetName: target.name,
+                bucket,
+            };
+        }
+    }
+    // Fallback: use the lowest priority target (last in sorted array)
+    const fallbackTarget = sorted[sorted.length - 1];
+    Logger_1.Logger.verbose("TargetingEngine", `No targets matched, using fallback target "${fallbackTarget.name}"`);
+    const { onboarding, bucket } = selectOnboardingByAllocation(fallbackTarget.onboardings, userId);
+    return {
+        onboarding,
+        targetId: fallbackTarget.id,
+        targetName: fallbackTarget.name,
+        bucket,
+    };
+}
+/**
+ * Evaluate a set of rules against the context
+ * Empty rules = matches all users
+ */
+function evaluateRules(rules, context) {
+    // Empty rules array = match all users
+    if (!rules.rules || rules.rules.length === 0) {
+        return true;
+    }
+    if (rules.match === "all") {
+        // AND logic - all rules must match
+        return rules.rules.every((rule) => evaluateRule(rule, context));
+    }
+    else {
+        // OR logic - at least one rule must match
+        return rules.rules.some((rule) => evaluateRule(rule, context));
+    }
+}
+/**
+ * Evaluate a single rule against the context
+ */
+function evaluateRule(rule, context) {
+    // Parse attribute path (e.g., "device.country" -> ["device", "country"])
+    const parts = rule.attribute.split(".");
+    if (parts.length !== 2) {
+        Logger_1.Logger.verbose("TargetingEngine", `Invalid attribute format: ${rule.attribute}`);
+        return false;
+    }
+    const [category, attr] = parts;
+    // Get the actual value from context
+    const categoryObj = context[category];
+    if (!categoryObj || typeof categoryObj !== "object") {
+        Logger_1.Logger.verbose("TargetingEngine", `Unknown category: ${category}`);
+        return false;
+    }
+    const actualValue = categoryObj[attr];
+    // Handle null/undefined - rule doesn't match
+    if (actualValue === null || actualValue === undefined) {
+        Logger_1.Logger.verbose("TargetingEngine", `Attribute ${rule.attribute} is null/undefined, rule does not match`);
+        return false;
+    }
+    // Apply operator
+    const result = applyOperator(rule.operator, actualValue, rule.value);
+    Logger_1.Logger.verbose("TargetingEngine", `Rule: ${rule.attribute} ${rule.operator} "${rule.value}" => actual: "${actualValue}" => ${result}`);
+    return result;
+}
+/**
+ * Apply an operator to compare actual value with expected value
+ */
+function applyOperator(operator, actualValue, expectedValue) {
+    switch (operator) {
+        // Text operators
+        case "equals":
+            return String(actualValue) === expectedValue;
+        case "not_equals":
+            return String(actualValue) !== expectedValue;
+        case "contains":
+            return String(actualValue).toLowerCase().includes(expectedValue.toLowerCase());
+        case "starts_with":
+            return String(actualValue).toLowerCase().startsWith(expectedValue.toLowerCase());
+        // Number operators
+        case "greater_than":
+            return Number(actualValue) > Number(expectedValue);
+        case "less_than":
+            return Number(actualValue) < Number(expectedValue);
+        // Boolean operators
+        case "is_true":
+            return actualValue === true;
+        case "is_false":
+            return actualValue === false;
+        default:
+            Logger_1.Logger.verbose("TargetingEngine", `Unknown operator: ${operator}`);
+            return false;
+    }
+}
+/**
+ * Select an onboarding based on allocation percentages
+ * Uses deterministic hashing for consistent A/B assignment
+ */
+function selectOnboardingByAllocation(onboardings, userId) {
+    if (onboardings.length === 0) {
+        throw new Error("No onboardings in target");
+    }
+    // Single onboarding - no allocation needed
+    if (onboardings.length === 1) {
+        return { onboarding: onboardings[0], bucket: 0 };
+    }
+    // Generate deterministic bucket (0-99) from userId
+    const bucket = hashUserIdToBucket(userId);
+    // Find which allocation bucket the user falls into
+    let cumulative = 0;
+    for (const onboarding of onboardings) {
+        cumulative += onboarding.allocation;
+        if (bucket < cumulative) {
+            return { onboarding, bucket };
+        }
+    }
+    // Fallback to last onboarding (handles rounding errors or allocation < 100)
+    return { onboarding: onboardings[onboardings.length - 1], bucket };
+}
+/**
+ * Hash userId to a bucket 0-99 using djb2 algorithm
+ * This is deterministic - same userId always gets same bucket
+ */
+function hashUserIdToBucket(userId) {
+    let hash = 5381;
+    for (let i = 0; i < userId.length; i++) {
+        const char = userId.charCodeAt(i);
+        hash = ((hash << 5) + hash) + char; // hash * 33 + char
+        hash = hash & hash; // Convert to 32-bit integer
+    }
+    return Math.abs(hash % 100);
+}

package/build/index.d.ts

@@ -11,6 +11,9 @@ export { default as RampKitNative } from "./RampKitNative";
 export type { NativeDeviceInfo, NativeLaunchData } from "./RampKitNative";
 export { Haptics, StoreReview, Notifications, TransactionObserver, isNativeModuleAvailable } from "./RampKitNative";
 export type { ImpactStyle, NotificationType, NotificationOptions, NotificationPermissionResult, TransactionObserverResult, SentEventResult, TrackedTransactionDetail, EntitlementCheckResult } from "./RampKitNative";
-export type { DeviceInfo, RampKitEvent, EventDevice, EventContext, RampKitConfig, RampKitEventName, RampKitContext, RampKitDeviceContext, RampKitUserContext, NavigationData, ScreenPosition, AppSessionStartedProperties, OnboardingStartedProperties, OnboardingCompletedProperties, OnboardingAbandonedProperties, OptionSelectedProperties, NotificationsResponseProperties, PaywallShownProperties, PurchaseStartedProperties, PurchaseCompletedProperties, PurchaseFailedProperties, PurchaseRestoredProperties, } from "./types";
+export type { DeviceInfo, RampKitEvent, EventDevice, EventContext, RampKitConfig, RampKitEventName, RampKitContext, RampKitDeviceContext, RampKitUserContext, NavigationData, ScreenPosition, Manifest, ManifestTarget, TargetRules, TargetRule, TargetOnboarding, ManifestOnboarding, TargetingContext, AppSessionStartedProperties, OnboardingStartedProperties, OnboardingCompletedProperties, OnboardingAbandonedProperties, OptionSelectedProperties, NotificationsResponseProperties, PaywallShownProperties, PurchaseStartedProperties, PurchaseCompletedProperties, PurchaseFailedProperties, PurchaseRestoredProperties, } from "./types";
+export { buildTargetingContext } from "./TargetingContext";
+export { evaluateTargets, evaluateRules, evaluateRule } from "./TargetingEngine";
+export type { TargetEvaluationResult } from "./TargetingEngine";
 export { SDK_VERSION, CAPABILITIES } from "./constants";
 export { setVerboseLogging } from "./Logger";

package/build/index.js

@@ -7,7 +7,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.setVerboseLogging = exports.CAPABILITIES = exports.SDK_VERSION = exports.isNativeModuleAvailable = exports.TransactionObserver = exports.Notifications = exports.StoreReview = exports.Haptics = exports.RampKitNative = exports.buildRampKitContext = exports.getSessionStartTime = exports.getSessionDurationSeconds = exports.collectDeviceInfo = exports.eventManager = exports.getRampKitUserId = exports.RampKit = void 0;
+exports.setVerboseLogging = exports.CAPABILITIES = exports.SDK_VERSION = exports.evaluateRule = exports.evaluateRules = exports.evaluateTargets = exports.buildTargetingContext = exports.isNativeModuleAvailable = exports.TransactionObserver = exports.Notifications = exports.StoreReview = exports.Haptics = exports.RampKitNative = exports.buildRampKitContext = exports.getSessionStartTime = exports.getSessionDurationSeconds = exports.collectDeviceInfo = exports.eventManager = exports.getRampKitUserId = exports.RampKit = void 0;
 const RampKit_1 = require("./RampKit");
 // Main SDK singleton instance
 exports.RampKit = RampKit_1.RampKitCore.instance;
@@ -33,6 +33,13 @@ Object.defineProperty(exports, "StoreReview", { enumerable: true, get: function
 Object.defineProperty(exports, "Notifications", { enumerable: true, get: function () { return RampKitNative_2.Notifications; } });
 Object.defineProperty(exports, "TransactionObserver", { enumerable: true, get: function () { return RampKitNative_2.TransactionObserver; } });
 Object.defineProperty(exports, "isNativeModuleAvailable", { enumerable: true, get: function () { return RampKitNative_2.isNativeModuleAvailable; } });
+// Export targeting utilities
+var TargetingContext_1 = require("./TargetingContext");
+Object.defineProperty(exports, "buildTargetingContext", { enumerable: true, get: function () { return TargetingContext_1.buildTargetingContext; } });
+var TargetingEngine_1 = require("./TargetingEngine");
+Object.defineProperty(exports, "evaluateTargets", { enumerable: true, get: function () { return TargetingEngine_1.evaluateTargets; } });
+Object.defineProperty(exports, "evaluateRules", { enumerable: true, get: function () { return TargetingEngine_1.evaluateRules; } });
+Object.defineProperty(exports, "evaluateRule", { enumerable: true, get: function () { return TargetingEngine_1.evaluateRule; } });
 // Export constants
 var constants_1 = require("./constants");
 Object.defineProperty(exports, "SDK_VERSION", { enumerable: true, get: function () { return constants_1.SDK_VERSION; } });

package/build/types.d.ts

@@ -1,6 +1,95 @@
 /**
  * RampKit SDK Types
  */
+/**
+ * Root manifest structure fetched from CDN
+ */
+export interface Manifest {
+    appId: string;
+    appName: string;
+    updatedAt: string;
+    targets: ManifestTarget[];
+    onboardings: ManifestOnboarding[];
+}
+/**
+ * A target defines rules for matching users and which onboardings to show
+ */
+export interface ManifestTarget {
+    id: string;
+    name: string;
+    priority: number;
+    rules: TargetRules;
+    onboardings: TargetOnboarding[];
+}
+/**
+ * Rule matching configuration
+ */
+export interface TargetRules {
+    /** "all" = AND logic (all rules must match), "any" = OR logic (at least one must match) */
+    match: "all" | "any";
+    rules: TargetRule[];
+}
+/**
+ * Individual targeting rule
+ */
+export interface TargetRule {
+    id: string;
+    attribute: string;
+    operator: string;
+    value: string;
+}
+/**
+ * Onboarding reference within a target (includes A/B allocation)
+ */
+export interface TargetOnboarding {
+    id: string;
+    allocation: number;
+    url: string;
+}
+/**
+ * Top-level onboarding reference in manifest (metadata only)
+ */
+export interface ManifestOnboarding {
+    id: string;
+    name: string;
+    status: string;
+    version: number;
+    rules: Record<string, unknown>;
+    url: string;
+}
+/**
+ * Context used for evaluating targeting rules
+ */
+export interface TargetingContext {
+    user: {
+        isNewUser: boolean;
+        daysSinceInstall: number;
+        subscriptionStatus: string | null;
+        hasAppleSearchAdsAttribution: boolean;
+    };
+    device: {
+        platform: string;
+        model: string;
+        osVersion: string;
+        interfaceStyle: string;
+        country: string;
+        language: string;
+        locale: string;
+        currencyCode: string;
+    };
+    app: {
+        version: string;
+        buildNumber: string;
+        sdkVersion: string;
+    };
+    asa: {
+        keyword: string | null;
+        campaignId: string | null;
+    };
+    cpp: {
+        pageId: string | null;
+    };
+}
 export interface DeviceInfo {
     appUserId: string;
     /**
@@ -48,6 +137,14 @@ export interface DeviceInfo {
     capabilities: string[];
     connectionType: string | null;
     collectedAt: string;
+    /** The ID of the matched target */
+    matchedTargetId?: string | null;
+    /** The name of the matched target */
+    matchedTargetName?: string | null;
+    /** The ID of the selected onboarding */
+    matchedOnboardingId?: string | null;
+    /** The A/B test bucket (0-99) for deterministic allocation */
+    abTestBucket?: number | null;
 }
 export interface EventDevice {
     platform: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rampkit-expo-dev",
-  "version": "0.0.91",
+  "version": "0.0.92",
   "description": "The Expo SDK for RampKit. Build, test, and personalize app onboardings with instant updates.",
   "main": "build/index.js",
   "types": "build/index.d.ts",