insert-affiliate-react-native-sdk 1.5.0 → 1.6.0

package/.claude/settings.local.json

@@ -0,0 +1,8 @@
+{
+  "permissions": {
+    "allow": [
+      "WebFetch(domain:github.com)"
+    ],
+    "deny": []
+  }
+}

package/dist/DeepLinkIapProvider.d.ts

@@ -8,6 +8,7 @@ type CustomPurchase = {
 type T_DEEPLINK_IAP_CONTEXT = {
     referrerLink: string;
     userId: string;
+    iOSOfferCode: string | null;
     returnInsertAffiliateIdentifier: () => Promise<string | null>;
     validatePurchaseWithIapticAPI: (jsonIapPurchase: CustomPurchase, iapticAppId: string, iapticAppName: string, iapticPublicKey: string) => Promise<boolean>;
     returnUserAccountTokenAndStoreExpectedTransaction: () => Promise<string | null>;
@@ -15,7 +16,7 @@ type T_DEEPLINK_IAP_CONTEXT = {
     trackEvent: (eventName: string) => Promise<void>;
     setShortCode: (shortCode: string) => Promise<void>;
     setInsertAffiliateIdentifier: (referringLink: string) => Promise<void | string>;
-    initialize: (code: string | null) => Promise<void>;
+    initialize: (code: string | null, verboseLogging?: boolean) => Promise<void>;
     isInitialized: boolean;
 };
 export declare const DeepLinkIapContext: React.Context<T_DEEPLINK_IAP_CONTEXT>;

package/dist/DeepLinkIapProvider.js

@@ -46,11 +46,13 @@ const ASYNC_KEYS = {
     USER_ID: '@app_user_id',
     COMPANY_CODE: '@app_company_code',
     USER_ACCOUNT_TOKEN: '@app_user_account_token',
+    IOS_OFFER_CODE: '@app_ios_offer_code',
 };
 // STARTING CONTEXT IMPLEMENTATION
 exports.DeepLinkIapContext = (0, react_1.createContext)({
     referrerLink: '',
     userId: '',
+    iOSOfferCode: null,
     returnInsertAffiliateIdentifier: () => __awaiter(void 0, void 0, void 0, function* () { return ''; }),
     validatePurchaseWithIapticAPI: (jsonIapPurchase, iapticAppId, iapticAppName, iapticPublicKey) => __awaiter(void 0, void 0, void 0, function* () { return false; }),
     returnUserAccountTokenAndStoreExpectedTransaction: () => __awaiter(void 0, void 0, void 0, function* () { return ''; }),
@@ -58,7 +60,7 @@ exports.DeepLinkIapContext = (0, react_1.createContext)({
     trackEvent: (eventName) => __awaiter(void 0, void 0, void 0, function* () { }),
     setShortCode: (shortCode) => __awaiter(void 0, void 0, void 0, function* () { }),
     setInsertAffiliateIdentifier: (referringLink) => __awaiter(void 0, void 0, void 0, function* () { }),
-    initialize: (code) => __awaiter(void 0, void 0, void 0, function* () { }),
+    initialize: (code, verboseLogging) => __awaiter(void 0, void 0, void 0, function* () { }),
     isInitialized: false,
 });
 const DeepLinkIapProvider = ({ children, }) => {
@@ -66,8 +68,16 @@ const DeepLinkIapProvider = ({ children, }) => {
     const [userId, setUserId] = (0, react_1.useState)('');
     const [companyCode, setCompanyCode] = (0, react_1.useState)(null);
     const [isInitialized, setIsInitialized] = (0, react_1.useState)(false);
+    const [verboseLogging, setVerboseLogging] = (0, react_1.useState)(false);
+    const [iOSOfferCode, setIOSOfferCode] = (0, react_1.useState)(null);
     // MARK: Initialize the SDK
-    const initialize = (companyCode) => __awaiter(void 0, void 0, void 0, function* () {
+    const initialize = (companyCode_1, ...args_1) => __awaiter(void 0, [companyCode_1, ...args_1], void 0, function* (companyCode, verboseLogging = false) {
+        setVerboseLogging(verboseLogging);
+        if (verboseLogging) {
+            console.log('[Insert Affiliate] [VERBOSE] Starting SDK initialization...');
+            console.log('[Insert Affiliate] [VERBOSE] Company code provided:', companyCode ? 'Yes' : 'No');
+            console.log('[Insert Affiliate] [VERBOSE] Verbose logging enabled');
+        }
         if (isInitialized) {
             console.error('[Insert Affiliate] SDK is already initialized.');
             return;
@@ -77,10 +87,17 @@ const DeepLinkIapProvider = ({ children, }) => {
             yield saveValueInAsync(ASYNC_KEYS.COMPANY_CODE, companyCode);
             setIsInitialized(true);
             console.log(`[Insert Affiliate] SDK initialized with company code: ${companyCode}`);
+            if (verboseLogging) {
+                console.log('[Insert Affiliate] [VERBOSE] Company code saved to AsyncStorage');
+                console.log('[Insert Affiliate] [VERBOSE] SDK marked as initialized');
+            }
         }
         else {
             console.warn('[Insert Affiliate] SDK initialized without a company code.');
             setIsInitialized(true);
+            if (verboseLogging) {
+                console.log('[Insert Affiliate] [VERBOSE] No company code provided, SDK initialized in limited mode');
+            }
         }
     });
     // EFFECT TO FETCH USER ID AND REF LINK
@@ -88,28 +105,49 @@ const DeepLinkIapProvider = ({ children, }) => {
     (0, react_1.useEffect)(() => {
         const fetchAsyncEssentials = () => __awaiter(void 0, void 0, void 0, function* () {
             try {
+                verboseLog('Loading stored data from AsyncStorage...');
                 const uId = yield getValueFromAsync(ASYNC_KEYS.USER_ID);
                 const refLink = yield getValueFromAsync(ASYNC_KEYS.REFERRER_LINK);
+                const companyCodeFromStorage = yield getValueFromAsync(ASYNC_KEYS.COMPANY_CODE);
+                const storedIOSOfferCode = yield getValueFromAsync(ASYNC_KEYS.IOS_OFFER_CODE);
+                verboseLog(`User ID found: ${uId ? 'Yes' : 'No'}`);
+                verboseLog(`Referrer link found: ${refLink ? 'Yes' : 'No'}`);
+                verboseLog(`Company code found: ${companyCodeFromStorage ? 'Yes' : 'No'}`);
+                verboseLog(`iOS Offer Code found: ${storedIOSOfferCode ? 'Yes' : 'No'}`);
                 if (uId && refLink) {
                     setUserId(uId);
                     setReferrerLink(refLink);
+                    verboseLog('User ID and referrer link restored from storage');
+                }
+                if (companyCodeFromStorage) {
+                    setCompanyCode(companyCodeFromStorage);
+                    verboseLog('Company code restored from storage');
+                }
+                if (storedIOSOfferCode) {
+                    setIOSOfferCode(storedIOSOfferCode);
+                    verboseLog('iOS Offer Code restored from storage');
                 }
             }
             catch (error) {
                 errorLog(`ERROR ~ fetchAsyncEssentials: ${error}`);
+                verboseLog(`Error loading from AsyncStorage: ${error}`);
             }
         });
         fetchAsyncEssentials();
     }, []);
     function generateThenSetUserID() {
         return __awaiter(this, void 0, void 0, function* () {
+            verboseLog('Getting or generating user ID...');
             let userId = yield getValueFromAsync(ASYNC_KEYS.USER_ID);
             if (!userId) {
+                verboseLog('No existing user ID found, generating new one...');
                 userId = generateUserID();
                 setUserId(userId);
                 yield saveValueInAsync(ASYNC_KEYS.USER_ID, userId);
+                verboseLog(`Generated and saved new user ID: ${userId}`);
             }
             else {
+                verboseLog(`Found existing user ID: ${userId}`);
                 setUserId(userId);
             }
             return userId;
@@ -140,6 +178,29 @@ const DeepLinkIapProvider = ({ children, }) => {
     const clearAsyncStorage = () => __awaiter(void 0, void 0, void 0, function* () {
         yield async_storage_1.default.clear();
     });
+    // Helper function to get company code from state or storage
+    const getActiveCompanyCode = () => __awaiter(void 0, void 0, void 0, function* () {
+        verboseLog('Getting active company code...');
+        let activeCompanyCode = companyCode;
+        verboseLog(`Company code in React state: ${activeCompanyCode || 'empty'}`);
+        if (!activeCompanyCode || (activeCompanyCode.trim() === '' && activeCompanyCode !== null)) {
+            verboseLog('Company code not in state, checking AsyncStorage...');
+            activeCompanyCode = yield getValueFromAsync(ASYNC_KEYS.COMPANY_CODE);
+            verboseLog(`Company code in AsyncStorage: ${activeCompanyCode || 'empty'}`);
+            if (activeCompanyCode) {
+                // Update state for future use
+                setCompanyCode(activeCompanyCode);
+                verboseLog('Updated React state with company code from storage');
+            }
+        }
+        return activeCompanyCode;
+    });
+    // Helper function for verbose logging
+    const verboseLog = (message) => {
+        if (verboseLogging) {
+            console.log(`[Insert Affiliate] [VERBOSE] ${message}`);
+        }
+    };
     // Helper function to log errors
     const errorLog = (message, type) => {
         switch (type) {
@@ -156,9 +217,9 @@ const DeepLinkIapProvider = ({ children, }) => {
     };
     // MARK: Short Codes
     const isShortCode = (referringLink) => {
-        // Short codes are less than 10 characters
-        const isValidCharacters = /^[a-zA-Z0-9]+$/.test(referringLink);
-        return isValidCharacters && referringLink.length < 25 && referringLink.length > 3;
+        // Short codes are 3-25 characters and can include underscores
+        const isValidCharacters = /^[a-zA-Z0-9_]+$/.test(referringLink);
+        return isValidCharacters && referringLink.length >= 3 && referringLink.length <= 25;
     };
     function setShortCode(shortCode) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -207,12 +268,32 @@ const DeepLinkIapProvider = ({ children, }) => {
         ;
     });
     // MARK: Return Insert Affiliate Identifier
+    // Instead of just reading React state
     const returnInsertAffiliateIdentifier = () => __awaiter(void 0, void 0, void 0, function* () {
         try {
-            return `${referrerLink}-${userId}`;
+            verboseLog('Getting insert affiliate identifier...');
+            verboseLog(`React state - referrerLink: ${referrerLink || 'empty'}, userId: ${userId || 'empty'}`);
+            // Try React state first
+            if (referrerLink && userId) {
+                const identifier = `${referrerLink}-${userId}`;
+                verboseLog(`Found identifier in React state: ${identifier}`);
+                return identifier;
+            }
+            verboseLog('React state empty, checking AsyncStorage...');
+            // Fallback to async storage if React state is empty
+            const storedLink = yield getValueFromAsync(ASYNC_KEYS.REFERRER_LINK);
+            const storedUserId = yield getValueFromAsync(ASYNC_KEYS.USER_ID);
+            verboseLog(`AsyncStorage - storedLink: ${storedLink || 'empty'}, storedUserId: ${storedUserId || 'empty'}`);
+            if (storedLink && storedUserId) {
+                const identifier = `${storedLink}-${storedUserId}`;
+                verboseLog(`Found identifier in AsyncStorage: ${identifier}`);
+                return identifier;
+            }
+            verboseLog('No affiliate identifier found in state or storage');
+            return null;
         }
         catch (error) {
-            errorLog(`ERROR ~ returnInsertAffiliateIdentifier: ${error}`);
+            verboseLog(`Error getting affiliate identifier: ${error}`);
             return null;
         }
     });
@@ -220,64 +301,77 @@ const DeepLinkIapProvider = ({ children, }) => {
     function setInsertAffiliateIdentifier(referringLink) {
         return __awaiter(this, void 0, void 0, function* () {
             console.log('[Insert Affiliate] Setting affiliate identifier.');
+            verboseLog(`Input referringLink: ${referringLink}`);
             try {
+                verboseLog('Generating or retrieving user ID...');
                 const customerID = yield generateThenSetUserID();
                 console.log('[Insert Affiliate] Completed generateThenSetUserID within setInsertAffiliateIdentifier.');
+                verboseLog(`Customer ID: ${customerID}`);
                 if (!referringLink) {
                     console.warn('[Insert Affiliate] Referring link is invalid.');
-                    let heldReferrerLinkBeforeAsyncStateUpdate = referrerLink;
+                    verboseLog('Referring link is empty or invalid, storing as-is');
                     yield storeInsertAffiliateIdentifier({ link: referringLink });
-                    return `${heldReferrerLinkBeforeAsyncStateUpdate}-${customerID}`;
+                    return `${referringLink}-${customerID}`;
                 }
-                if (!companyCode || (companyCode.trim() === '' && companyCode !== null)) {
-                    let companyCodeFromStorage = yield getValueFromAsync(ASYNC_KEYS.COMPANY_CODE);
-                    if (companyCodeFromStorage !== null) {
-                        setCompanyCode(companyCodeFromStorage);
-                    }
-                    else {
-                        console.error('[Insert Affiliate] Company code is not set. Please initialize the SDK with a valid company code.');
-                        return;
-                    }
+                // Get company code from state or storage
+                verboseLog('Getting company code...');
+                const activeCompanyCode = yield getActiveCompanyCode();
+                verboseLog(`Active company code: ${activeCompanyCode || 'Not found'}`);
+                if (!activeCompanyCode) {
+                    console.error('[Insert Affiliate] Company code is not set. Please initialize the SDK with a valid company code.');
+                    verboseLog('Company code missing, cannot proceed with API call');
+                    return;
                 }
                 // Check if referring link is already a short code, if so save it and stop here.
+                verboseLog('Checking if referring link is already a short code...');
                 if (isShortCode(referringLink)) {
                     console.log('[Insert Affiliate] Referring link is already a short code.');
-                    let heldReferrerLinkBeforeAsyncStateUpdate = referrerLink;
+                    verboseLog('Link is already a short code, storing directly');
                     yield storeInsertAffiliateIdentifier({ link: referringLink });
-                    return `${heldReferrerLinkBeforeAsyncStateUpdate}-${customerID}`;
+                    return `${referringLink}-${customerID}`;
                 }
+                verboseLog('Link is not a short code, will convert via API');
                 // If the code is not already a short code, encode it raedy to send to our endpoint to return the short code. Save it before making the call in case something goes wrong
                 // Encode the referring link
+                verboseLog('Encoding referring link for API call...');
                 const encodedAffiliateLink = encodeURIComponent(referringLink);
                 if (!encodedAffiliateLink) {
                     console.error('[Insert Affiliate] Failed to encode affiliate link.');
-                    let heldReferrerLinkBeforeAsyncStateUpdate = referrerLink;
+                    verboseLog('Failed to encode link, storing original');
                     yield storeInsertAffiliateIdentifier({ link: referringLink });
-                    return `${heldReferrerLinkBeforeAsyncStateUpdate}-${customerID}`;
+                    return `${referringLink}-${customerID}`;
                 }
                 // Create the request URL
-                const urlString = `https://api.insertaffiliate.com/V1/convert-deep-link-to-short-link?companyId=${companyCode}&deepLinkUrl=${encodedAffiliateLink}`;
+                const urlString = `https://api.insertaffiliate.com/V1/convert-deep-link-to-short-link?companyId=${activeCompanyCode}&deepLinkUrl=${encodedAffiliateLink}`;
                 console.log('[Insert Affiliate] urlString .', urlString);
+                verboseLog('Making API request to convert deep link to short code...');
                 const response = yield axios_1.default.get(urlString, {
                     headers: {
                         'Content-Type': 'application/json',
                     },
                 });
+                verboseLog(`API response status: ${response.status}`);
                 // Call to the backend for the short code and save the resolse in valid
                 if (response.status === 200 && response.data.shortLink) {
                     const shortLink = response.data.shortLink;
                     console.log('[Insert Affiliate] Short link received:', shortLink);
+                    verboseLog(`Successfully converted to short link: ${shortLink}`);
+                    verboseLog('Storing short link to AsyncStorage...');
+                    yield storeInsertAffiliateIdentifier({ link: shortLink });
+                    verboseLog('Short link stored successfully');
                     return `${shortLink}-${customerID}`;
                 }
                 else {
                     console.warn('[Insert Affiliate] Unexpected response format.');
-                    let heldReferrerLinkBeforeAsyncStateUpdate = referrerLink;
+                    verboseLog(`Unexpected API response. Status: ${response.status}, Data: ${JSON.stringify(response.data)}`);
+                    verboseLog('Storing original link as fallback');
                     yield storeInsertAffiliateIdentifier({ link: referringLink });
-                    return `${heldReferrerLinkBeforeAsyncStateUpdate}-${customerID}`;
+                    return `${referringLink}-${customerID}`;
                 }
             }
             catch (error) {
                 console.error('[Insert Affiliate] Error:', error);
+                verboseLog(`Error in setInsertAffiliateIdentifier: ${error}`);
             }
         });
     }
@@ -285,8 +379,14 @@ const DeepLinkIapProvider = ({ children, }) => {
     function storeInsertAffiliateIdentifier(_a) {
         return __awaiter(this, arguments, void 0, function* ({ link }) {
             console.log(`[Insert Affiliate] Storing affiliate identifier: ${link}`);
+            verboseLog(`Updating React state with referrer link: ${link}`);
             setReferrerLink(link);
+            verboseLog(`Saving referrer link to AsyncStorage...`);
             yield saveValueInAsync(ASYNC_KEYS.REFERRER_LINK, link);
+            verboseLog(`Referrer link saved to AsyncStorage successfully`);
+            // Automatically fetch and store offer code for any affiliate identifier
+            verboseLog('Attempting to fetch offer code for stored affiliate identifier...');
+            yield retrieveAndStoreOfferCode(link);
         });
     }
     const validatePurchaseWithIapticAPI = (jsonIapPurchase, iapticAppId, iapticAppName, iapticPublicKey) => __awaiter(void 0, void 0, void 0, function* () {
@@ -350,23 +450,29 @@ const DeepLinkIapProvider = ({ children, }) => {
         }
     });
     const storeExpectedStoreTransaction = (purchaseToken) => __awaiter(void 0, void 0, void 0, function* () {
-        if (!companyCode || (companyCode.trim() === '' && companyCode !== null)) {
+        verboseLog(`Storing expected store transaction with token: ${purchaseToken}`);
+        const activeCompanyCode = yield getActiveCompanyCode();
+        if (!activeCompanyCode) {
             console.error("[Insert Affiliate] Company code is not set. Please initialize the SDK with a valid company code.");
+            verboseLog("Cannot store transaction: no company code available");
             return;
         }
         const shortCode = yield returnInsertAffiliateIdentifier();
         if (!shortCode) {
             console.error("[Insert Affiliate] No affiliate identifier found. Please set one before tracking events.");
+            verboseLog("Cannot store transaction: no affiliate identifier available");
             return;
         }
+        verboseLog(`Company code: ${activeCompanyCode}, Short code: ${shortCode}`);
         // Build JSON payload
         const payload = {
             UUID: purchaseToken,
-            companyCode,
+            companyCode: activeCompanyCode,
             shortCode,
             storedDate: new Date().toISOString(), // ISO8601 format
         };
         console.log("[Insert Affiliate] Storing expected transaction: ", payload);
+        verboseLog("Making API call to store expected transaction...");
         try {
             const response = yield fetch("https://api.insertaffiliate.com/v1/api/app-store-webhook/create-expected-transaction", {
                 method: "POST",
@@ -375,53 +481,139 @@ const DeepLinkIapProvider = ({ children, }) => {
                 },
                 body: JSON.stringify(payload),
             });
+            verboseLog(`API response status: ${response.status}`);
             if (response.ok) {
                 console.info("[Insert Affiliate] Expected transaction stored successfully.");
+                verboseLog("Expected transaction stored successfully on server");
             }
             else {
                 const errorText = yield response.text();
                 console.error(`[Insert Affiliate] Failed to store expected transaction with status code: ${response.status}. Response: ${errorText}`);
+                verboseLog(`API error response: ${errorText}`);
             }
         }
         catch (error) {
             console.error(`[Insert Affiliate] Error storing expected transaction: ${error}`);
+            verboseLog(`Network error storing transaction: ${error}`);
         }
     });
     // MARK: Track Event
     const trackEvent = (eventName) => __awaiter(void 0, void 0, void 0, function* () {
         try {
-            if (!companyCode || (companyCode.trim() === '' && companyCode !== null)) {
+            verboseLog(`Tracking event: ${eventName}`);
+            const activeCompanyCode = yield getActiveCompanyCode();
+            if (!activeCompanyCode) {
                 console.error("[Insert Affiliate] Company code is not set. Please initialize the SDK with a valid company code.");
+                verboseLog("Cannot track event: no company code available");
                 return Promise.resolve();
             }
-            console.log("track event called with - companyCode: ", companyCode);
+            console.log("track event called with - companyCode: ", activeCompanyCode);
             if (!referrerLink || !userId) {
                 console.warn('[Insert Affiliate] No affiliate identifier found. Please set one before tracking events.');
+                verboseLog("Cannot track event: no affiliate identifier available");
                 return Promise.resolve();
             }
+            const deepLinkParam = `${referrerLink}-${userId}`;
+            verboseLog(`Deep link param: ${deepLinkParam}`);
             const payload = {
                 eventName,
-                deepLinkParam: `${referrerLink}-${userId}`,
-                companyId: companyCode,
+                deepLinkParam: deepLinkParam,
+                companyId: activeCompanyCode,
             };
+            verboseLog(`Track event payload: ${JSON.stringify(payload)}`);
+            verboseLog("Making API call to track event...");
             const response = yield axios_1.default.post('https://api.insertaffiliate.com/v1/trackEvent', payload, {
                 headers: { 'Content-Type': 'application/json' },
             });
+            verboseLog(`Track event API response status: ${response.status}`);
             if (response.status === 200) {
                 console.log('[Insert Affiliate] Event tracked successfully');
+                verboseLog("Event tracked successfully on server");
             }
             else {
                 console.error(`[Insert Affiliate] Failed to track event with status code: ${response.status}`);
+                verboseLog(`Track event API error: status ${response.status}, response: ${JSON.stringify(response.data)}`);
             }
         }
         catch (error) {
             console.error('[Insert Affiliate] Error tracking event:', error);
+            verboseLog(`Network error tracking event: ${error}`);
             return Promise.reject(error);
         }
     });
+    const fetchOfferCode = (affiliateLink) => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            const activeCompanyCode = yield getActiveCompanyCode();
+            if (!activeCompanyCode) {
+                verboseLog('Cannot fetch offer code: no company code available');
+                return null;
+            }
+            const encodedAffiliateLink = encodeURIComponent(affiliateLink);
+            const url = `https://api.insertaffiliate.com/v1/affiliateReturnOfferCode/${activeCompanyCode}/${encodedAffiliateLink}`;
+            verboseLog(`Fetching offer code from: ${url}`);
+            const response = yield axios_1.default.get(url);
+            if (response.status === 200) {
+                const offerCode = response.data;
+                // Check for specific error strings from API
+                if (typeof offerCode === 'string' && (offerCode.includes("errorofferCodeNotFound") ||
+                    offerCode.includes("errorAffiliateoffercodenotfoundinanycompany") ||
+                    offerCode.includes("errorAffiliateoffercodenotfoundinanycompanyAffiliatelinkwas") ||
+                    offerCode.includes("Routenotfound"))) {
+                    console.warn(`[Insert Affiliate] Offer code not found or invalid: ${offerCode}`);
+                    verboseLog(`Offer code not found or invalid: ${offerCode}`);
+                    return null;
+                }
+                const cleanedOfferCode = cleanOfferCode(offerCode);
+                verboseLog(`Successfully fetched and cleaned offer code: ${cleanedOfferCode}`);
+                return cleanedOfferCode;
+            }
+            else {
+                console.error(`[Insert Affiliate] Failed to fetch offer code. Status code: ${response.status}, Response: ${JSON.stringify(response.data)}`);
+                verboseLog(`Failed to fetch offer code. Status code: ${response.status}, Response: ${JSON.stringify(response.data)}`);
+                return null;
+            }
+        }
+        catch (error) {
+            console.error('[Insert Affiliate] Error fetching offer code:', error);
+            verboseLog(`Error fetching offer code: ${error}`);
+            return null;
+        }
+    });
+    const retrieveAndStoreOfferCode = (affiliateLink) => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            verboseLog(`Attempting to retrieve and store offer code for: ${affiliateLink}`);
+            const offerCode = yield fetchOfferCode(affiliateLink);
+            if (offerCode && offerCode.length > 0) {
+                // Store in both AsyncStorage and state
+                yield saveValueInAsync(ASYNC_KEYS.IOS_OFFER_CODE, offerCode);
+                setIOSOfferCode(offerCode);
+                verboseLog(`Successfully stored offer code: ${offerCode}`);
+                console.log('[Insert Affiliate] Offer code retrieved and stored successfully');
+            }
+            else {
+                verboseLog('No valid offer code found to store');
+                // Clear stored offer code if none found
+                yield saveValueInAsync(ASYNC_KEYS.IOS_OFFER_CODE, '');
+                setIOSOfferCode(null);
+            }
+        }
+        catch (error) {
+            console.error('[Insert Affiliate] Error retrieving and storing offer code:', error);
+            verboseLog(`Error in retrieveAndStoreOfferCode: ${error}`);
+        }
+    });
+    const removeSpecialCharacters = (offerCode) => {
+        // Remove special characters, keep only alphanumeric and underscores
+        return offerCode.replace(/[^a-zA-Z0-9_]/g, '');
+    };
+    const cleanOfferCode = (offerCode) => {
+        // Remove special characters, keep only alphanumeric
+        return removeSpecialCharacters(offerCode);
+    };
     return (react_1.default.createElement(exports.DeepLinkIapContext.Provider, { value: {
             referrerLink,
             userId,
+            iOSOfferCode,
             setShortCode,
             returnInsertAffiliateIdentifier,
             storeExpectedStoreTransaction,

package/dist/useDeepLinkIapProvider.d.ts

@@ -10,7 +10,8 @@ declare const useDeepLinkIapProvider: () => {
     trackEvent: (eventName: string) => Promise<void>;
     setShortCode: (shortCode: string) => Promise<void>;
     setInsertAffiliateIdentifier: (referringLink: string) => Promise<void | string>;
-    initialize: (code: string | null) => Promise<void>;
+    initialize: (code: string | null, verboseLogging?: boolean) => Promise<void>;
     isInitialized: boolean;
+    iOSOfferCode: string | null;
 };
 export default useDeepLinkIapProvider;

package/dist/useDeepLinkIapProvider.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const react_1 = require("react");
 const DeepLinkIapProvider_1 = require("./DeepLinkIapProvider");
 const useDeepLinkIapProvider = () => {
-    const { referrerLink, userId, validatePurchaseWithIapticAPI, storeExpectedStoreTransaction, returnUserAccountTokenAndStoreExpectedTransaction, returnInsertAffiliateIdentifier, trackEvent, setShortCode, setInsertAffiliateIdentifier, initialize, isInitialized } = (0, react_1.useContext)(DeepLinkIapProvider_1.DeepLinkIapContext);
+    const { referrerLink, userId, validatePurchaseWithIapticAPI, storeExpectedStoreTransaction, returnUserAccountTokenAndStoreExpectedTransaction, returnInsertAffiliateIdentifier, trackEvent, setShortCode, setInsertAffiliateIdentifier, initialize, isInitialized, iOSOfferCode, } = (0, react_1.useContext)(DeepLinkIapProvider_1.DeepLinkIapContext);
     return {
         referrerLink,
         userId,
@@ -15,7 +15,8 @@ const useDeepLinkIapProvider = () => {
         setShortCode,
         setInsertAffiliateIdentifier,
         initialize,
-        isInitialized
+        isInitialized,
+        iOSOfferCode,
     };
 };
 exports.default = useDeepLinkIapProvider;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "insert-affiliate-react-native-sdk",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "description": "A package for connecting with the Insert Affiliate Platform to add app based affiliate marketing.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",