insert-affiliate-react-native-sdk 1.10.0 → 1.11.2

package/.claude/settings.local.json

@@ -4,8 +4,14 @@
       "WebFetch(domain:github.com)",
       "Bash(npm run build:*)",
       "Bash(npm install:*)",
-      "Bash(npm view:*)"
+      "Bash(npm view:*)",
+      "Bash(find:*)",
+      "Bash(adb logcat:*)",
+      "Bash(adb shell:*)",
+      "Bash(adb shell am start:*)",
+      "Bash(git checkout:*)",
+      "Bash(git pull:*)"
     ],
     "deny": []
   }
-}
+}

package/dist/DeepLinkIapProvider.js

@@ -88,43 +88,63 @@ const DeepLinkIapProvider = ({ children, }) => {
     const [OfferCode, setOfferCode] = (0, react_1.useState)(null);
     const [affiliateAttributionActiveTime, setAffiliateAttributionActiveTime] = (0, react_1.useState)(null);
     const insertAffiliateIdentifierChangeCallbackRef = (0, react_1.useRef)(null);
+    const isInitializingRef = (0, react_1.useRef)(false);
+    // Refs for values that need to be current inside callbacks (to avoid stale closures)
+    const companyCodeRef = (0, react_1.useRef)(null);
+    const verboseLoggingRef = (0, react_1.useRef)(false);
+    // Refs for implementation functions (ref callback pattern for stable + fresh)
+    const initializeImplRef = (0, react_1.useRef)(null);
+    const setShortCodeImplRef = (0, react_1.useRef)(null);
+    const getAffiliateDetailsImplRef = (0, react_1.useRef)(null);
+    const returnInsertAffiliateIdentifierImplRef = (0, react_1.useRef)(null);
+    const isAffiliateAttributionValidImplRef = (0, react_1.useRef)(null);
+    const getAffiliateStoredDateImplRef = (0, react_1.useRef)(null);
+    const storeExpectedStoreTransactionImplRef = (0, react_1.useRef)(null);
+    const returnUserAccountTokenAndStoreExpectedTransactionImplRef = (0, react_1.useRef)(null);
+    const validatePurchaseWithIapticAPIImplRef = (0, react_1.useRef)(null);
+    const trackEventImplRef = (0, react_1.useRef)(null);
+    const setInsertAffiliateIdentifierImplRef = (0, react_1.useRef)(null);
+    const handleInsertLinksImplRef = (0, react_1.useRef)(null);
     // MARK: Initialize the SDK
-    const initialize = (companyCode_1, ...args_1) => __awaiter(void 0, [companyCode_1, ...args_1], void 0, function* (companyCode, verboseLogging = false, insertLinksEnabled = false, insertLinksClipboardEnabled = false, affiliateAttributionActiveTime) {
-        setVerboseLogging(verboseLogging);
-        setInsertLinksEnabled(insertLinksEnabled);
-        setInsertLinksClipboardEnabled(insertLinksClipboardEnabled);
-        if (affiliateAttributionActiveTime !== undefined) {
-            setAffiliateAttributionActiveTime(affiliateAttributionActiveTime);
+    const initializeImpl = (companyCodeParam_1, ...args_1) => __awaiter(void 0, [companyCodeParam_1, ...args_1], void 0, function* (companyCodeParam, verboseLoggingParam = false, insertLinksEnabledParam = false, insertLinksClipboardEnabledParam = false, affiliateAttributionActiveTimeParam) {
+        // Prevent multiple concurrent initialization attempts
+        if (isInitialized || isInitializingRef.current) {
+            return;
         }
-        if (verboseLogging) {
+        isInitializingRef.current = true;
+        setVerboseLogging(verboseLoggingParam);
+        verboseLoggingRef.current = verboseLoggingParam;
+        setInsertLinksEnabled(insertLinksEnabledParam);
+        setInsertLinksClipboardEnabled(insertLinksClipboardEnabledParam);
+        if (affiliateAttributionActiveTimeParam !== undefined) {
+            setAffiliateAttributionActiveTime(affiliateAttributionActiveTimeParam);
+        }
+        if (verboseLoggingParam) {
             console.log('[Insert Affiliate] [VERBOSE] Starting SDK initialization...');
-            console.log('[Insert Affiliate] [VERBOSE] Company code provided:', companyCode ? 'Yes' : 'No');
+            console.log('[Insert Affiliate] [VERBOSE] Company code provided:', companyCodeParam ? 'Yes' : 'No');
             console.log('[Insert Affiliate] [VERBOSE] Verbose logging enabled');
         }
-        if (isInitialized) {
-            console.error('[Insert Affiliate] SDK is already initialized.');
-            return;
-        }
-        if (companyCode && companyCode.trim() !== '') {
-            setCompanyCode(companyCode);
-            yield saveValueInAsync(ASYNC_KEYS.COMPANY_CODE, companyCode);
+        if (companyCodeParam && companyCodeParam.trim() !== '') {
+            setCompanyCode(companyCodeParam);
+            companyCodeRef.current = companyCodeParam;
+            yield saveValueInAsync(ASYNC_KEYS.COMPANY_CODE, companyCodeParam);
             setIsInitialized(true);
-            console.log(`[Insert Affiliate] SDK initialized with company code: ${companyCode}`);
-            if (verboseLogging) {
+            console.log(`[Insert Affiliate] SDK initialized with company code: ${companyCodeParam}`);
+            if (verboseLoggingParam) {
                 console.log('[Insert Affiliate] [VERBOSE] Company code saved to AsyncStorage');
                 console.log('[Insert Affiliate] [VERBOSE] SDK marked as initialized');
             }
             // Report SDK initialization for onboarding verification (fire and forget)
-            reportSdkInitIfNeeded(companyCode, verboseLogging);
+            reportSdkInitIfNeeded(companyCodeParam, verboseLoggingParam);
         }
         else {
             console.warn('[Insert Affiliate] SDK initialized without a company code.');
             setIsInitialized(true);
-            if (verboseLogging) {
+            if (verboseLoggingParam) {
                 console.log('[Insert Affiliate] [VERBOSE] No company code provided, SDK initialized in limited mode');
             }
         }
-        if (insertLinksEnabled && react_native_1.Platform.OS === 'ios') {
+        if (insertLinksEnabledParam && react_native_1.Platform.OS === 'ios') {
             try {
                 const enhancedSystemInfo = yield getEnhancedSystemInfo();
                 yield sendSystemInfoToBackend(enhancedSystemInfo);
@@ -155,6 +175,7 @@ const DeepLinkIapProvider = ({ children, }) => {
                 }
                 if (companyCodeFromStorage) {
                     setCompanyCode(companyCodeFromStorage);
+                    companyCodeRef.current = companyCodeFromStorage;
                     verboseLog('Company code restored from storage');
                 }
                 if (storedOfferCode) {
@@ -288,12 +309,6 @@ const DeepLinkIapProvider = ({ children, }) => {
         setIsInitialized(false);
         console.log('[Insert Affiliate] SDK has been reset.');
     };
-    // MARK: Callback Management
-    // Sets a callback that will be triggered whenever storeInsertAffiliateIdentifier is called
-    // The callback receives the current affiliate identifier (returnInsertAffiliateIdentifier result)
-    const setInsertAffiliateIdentifierChangeCallbackHandler = (callback) => {
-        insertAffiliateIdentifierChangeCallbackRef.current = callback;
-    };
     // MARK: Deep Link Handling
     // Helper function to parse URLs in React Native compatible way
     const parseURL = (url) => {
@@ -479,7 +494,7 @@ const DeepLinkIapProvider = ({ children, }) => {
         }
     });
     // Handles Insert Links deep linking - equivalent to iOS handleInsertLinks
-    const handleInsertLinks = (url) => __awaiter(void 0, void 0, void 0, function* () {
+    const handleInsertLinksImpl = (url) => __awaiter(void 0, void 0, void 0, function* () {
         try {
             console.log(`[Insert Affiliate] Attempting to handle URL: ${url}`);
             if (!url || typeof url !== 'string') {
@@ -582,14 +597,47 @@ const DeepLinkIapProvider = ({ children, }) => {
             return null;
         }
     };
+    // Parse shortcode from query parameter (new format: scheme://insert-affiliate?code=SHORTCODE)
+    const parseShortCodeFromQuery = (url) => {
+        try {
+            const queryIndex = url.indexOf('?');
+            if (queryIndex !== -1) {
+                const queryString = url.substring(queryIndex + 1);
+                const params = queryString.split('&');
+                for (const param of params) {
+                    const [key, value] = param.split('=');
+                    if (key === 'code' && value) {
+                        return decodeURIComponent(value);
+                    }
+                }
+            }
+            return null;
+        }
+        catch (error) {
+            verboseLog(`Error parsing short code from query: ${error}`);
+            return null;
+        }
+    };
     const parseShortCodeFromURLString = (url) => {
         try {
-            // For custom schemes like ia-companycode://shortcode, everything after :// is the short code
+            // First try to extract from query parameter (new format: scheme://insert-affiliate?code=SHORTCODE)
+            const queryCode = parseShortCodeFromQuery(url);
+            if (queryCode) {
+                console.log(`[Insert Affiliate] Found short code in query parameter: ${queryCode}`);
+                return queryCode;
+            }
+            // Fall back to path format (legacy: scheme://SHORTCODE)
             const match = url.match(/^[^:]+:\/\/(.+)$/);
             if (match) {
-                const shortCode = match[1];
+                let shortCode = match[1];
                 // Remove leading slash if present
-                return shortCode.startsWith('/') ? shortCode.substring(1) : shortCode;
+                shortCode = shortCode.startsWith('/') ? shortCode.substring(1) : shortCode;
+                // If the path is 'insert-affiliate' (from new format without code param), return null
+                if (shortCode === 'insert-affiliate' || shortCode.startsWith('insert-affiliate?')) {
+                    return null;
+                }
+                console.log(`[Insert Affiliate] Found short code in URL path (legacy format): ${shortCode}`);
+                return shortCode;
             }
             return null;
         }
@@ -609,26 +657,27 @@ 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
+    // Helper function to get company code from ref or storage (uses ref to avoid stale closures)
     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'}`);
+        let activeCompanyCode = companyCodeRef.current;
+        verboseLog(`Company code in ref: ${activeCompanyCode || 'empty'}`);
         if (!activeCompanyCode || (activeCompanyCode.trim() === '' && activeCompanyCode !== null)) {
-            verboseLog('Company code not in state, checking AsyncStorage...');
+            verboseLog('Company code not in ref, checking AsyncStorage...');
             activeCompanyCode = yield getValueFromAsync(ASYNC_KEYS.COMPANY_CODE);
             verboseLog(`Company code in AsyncStorage: ${activeCompanyCode || 'empty'}`);
             if (activeCompanyCode) {
-                // Update state for future use
+                // Update ref and state for future use
+                companyCodeRef.current = activeCompanyCode;
                 setCompanyCode(activeCompanyCode);
-                verboseLog('Updated React state with company code from storage');
+                verboseLog('Updated ref and React state with company code from storage');
             }
         }
         return activeCompanyCode;
     });
-    // Helper function for verbose logging
+    // Helper function for verbose logging (uses ref to avoid stale closures)
     const verboseLog = (message) => {
-        if (verboseLogging) {
+        if (verboseLoggingRef.current) {
             console.log(`[Insert Affiliate] [VERBOSE] ${message}`);
         }
     };
@@ -1156,7 +1205,7 @@ const DeepLinkIapProvider = ({ children, }) => {
             return false;
         }
     });
-    const getAffiliateDetails = (affiliateCode) => __awaiter(void 0, void 0, void 0, function* () {
+    const getAffiliateDetailsImpl = (affiliateCode) => __awaiter(void 0, void 0, void 0, function* () {
         try {
             const activeCompanyCode = yield getActiveCompanyCode();
             if (!activeCompanyCode) {
@@ -1195,27 +1244,25 @@ const DeepLinkIapProvider = ({ children, }) => {
             return null;
         }
     });
-    function setShortCode(shortCode) {
-        return __awaiter(this, void 0, void 0, function* () {
-            console.log('[Insert Affiliate] Setting short code.');
-            yield generateThenSetUserID();
-            // Validate it is a short code
-            const capitalisedShortCode = shortCode.toUpperCase();
-            isShortCode(capitalisedShortCode);
-            // Check if the affiliate exists before storing
-            const exists = yield checkAffiliateExists(capitalisedShortCode);
-            if (exists) {
-                // If affiliate exists, set the Insert Affiliate Identifier
-                yield storeInsertAffiliateIdentifier({ link: capitalisedShortCode, source: 'short_code_manual' });
-                console.log(`[Insert Affiliate] Short code ${capitalisedShortCode} validated and stored successfully.`);
-                return true;
-            }
-            else {
-                console.warn(`[Insert Affiliate] Short code ${capitalisedShortCode} does not exist. Not storing.`);
-                return false;
-            }
-        });
-    }
+    const setShortCodeImpl = (shortCode) => __awaiter(void 0, void 0, void 0, function* () {
+        console.log('[Insert Affiliate] Setting short code.');
+        yield generateThenSetUserID();
+        // Validate it is a short code
+        const capitalisedShortCode = shortCode.toUpperCase();
+        isShortCode(capitalisedShortCode);
+        // Check if the affiliate exists before storing
+        const exists = yield checkAffiliateExists(capitalisedShortCode);
+        if (exists) {
+            // If affiliate exists, set the Insert Affiliate Identifier
+            yield storeInsertAffiliateIdentifier({ link: capitalisedShortCode, source: 'short_code_manual' });
+            console.log(`[Insert Affiliate] Short code ${capitalisedShortCode} validated and stored successfully.`);
+            return true;
+        }
+        else {
+            console.warn(`[Insert Affiliate] Short code ${capitalisedShortCode} does not exist. Not storing.`);
+            return false;
+        }
+    });
     function getOrCreateUserAccountToken() {
         return __awaiter(this, void 0, void 0, function* () {
             let userAccountToken = yield getValueFromAsync(ASYNC_KEYS.USER_ACCOUNT_TOKEN);
@@ -1227,9 +1274,9 @@ const DeepLinkIapProvider = ({ children, }) => {
         });
     }
     ;
-    const returnUserAccountTokenAndStoreExpectedTransaction = () => __awaiter(void 0, void 0, void 0, function* () {
+    const returnUserAccountTokenAndStoreExpectedTransactionImpl = () => __awaiter(void 0, void 0, void 0, function* () {
         try {
-            const shortCode = yield returnInsertAffiliateIdentifier();
+            const shortCode = yield returnInsertAffiliateIdentifierImpl();
             if (!shortCode) {
                 console.log('[Insert Affiliate] No affiliate stored - not saving expected transaction.');
                 return null;
@@ -1241,7 +1288,7 @@ const DeepLinkIapProvider = ({ children, }) => {
                 return null;
             }
             else {
-                yield storeExpectedStoreTransaction(userAccountToken);
+                yield storeExpectedStoreTransactionImpl(userAccountToken);
                 return userAccountToken;
             }
         }
@@ -1261,12 +1308,12 @@ const DeepLinkIapProvider = ({ children, }) => {
         ;
     });
     // MARK: Return Insert Affiliate Identifier
-    const returnInsertAffiliateIdentifier = (...args_1) => __awaiter(void 0, [...args_1], void 0, function* (ignoreTimeout = false) {
+    const returnInsertAffiliateIdentifierImpl = (...args_1) => __awaiter(void 0, [...args_1], void 0, function* (ignoreTimeout = false) {
         try {
             verboseLog(`Getting insert affiliate identifier (ignoreTimeout: ${ignoreTimeout})...`);
             // If timeout is enabled and we're not ignoring it, check validity first
             if (!ignoreTimeout && affiliateAttributionActiveTime) {
-                const isValid = yield isAffiliateAttributionValid();
+                const isValid = yield isAffiliateAttributionValidImpl();
                 if (!isValid) {
                     verboseLog('Attribution has expired, returning null');
                     return null;
@@ -1306,14 +1353,14 @@ const DeepLinkIapProvider = ({ children, }) => {
     });
     // MARK: Attribution Timeout Functions
     // Check if the current affiliate attribution is still valid based on timeout
-    const isAffiliateAttributionValid = () => __awaiter(void 0, void 0, void 0, function* () {
+    const isAffiliateAttributionValidImpl = () => __awaiter(void 0, void 0, void 0, function* () {
         try {
             // If no timeout is set, attribution is always valid
             if (!affiliateAttributionActiveTime) {
                 verboseLog('No attribution timeout set, attribution is valid');
                 return true;
             }
-            const storedDate = yield getAffiliateStoredDate();
+            const storedDate = yield getAffiliateStoredDateImpl();
             if (!storedDate) {
                 verboseLog('No stored date found, attribution is invalid');
                 return false;
@@ -1330,7 +1377,7 @@ const DeepLinkIapProvider = ({ children, }) => {
         }
     });
     // Get the date when the affiliate identifier was stored
-    const getAffiliateStoredDate = () => __awaiter(void 0, void 0, void 0, function* () {
+    const getAffiliateStoredDateImpl = () => __awaiter(void 0, void 0, void 0, function* () {
         try {
             const storedDateString = yield getValueFromAsync(ASYNC_KEYS.AFFILIATE_STORED_DATE);
             if (!storedDateString) {
@@ -1347,84 +1394,81 @@ const DeepLinkIapProvider = ({ children, }) => {
         }
     });
     // MARK: Insert Affiliate Identifier
-    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.');
-                    verboseLog('Referring link is empty or invalid, storing as-is');
-                    yield storeInsertAffiliateIdentifier({ link: referringLink, source: 'referring_link' });
-                    return `${referringLink}-${customerID}`;
-                }
-                // 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.');
-                    verboseLog('Link is already a short code, storing directly');
-                    yield storeInsertAffiliateIdentifier({ link: referringLink, source: 'referring_link' });
-                    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.');
-                    verboseLog('Failed to encode link, storing original');
-                    yield storeInsertAffiliateIdentifier({ link: referringLink, source: 'referring_link' });
-                    return `${referringLink}-${customerID}`;
-                }
-                // Create the request URL
-                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, source: 'referring_link' });
-                    verboseLog('Short link stored successfully');
-                    return `${shortLink}-${customerID}`;
-                }
-                else {
-                    console.warn('[Insert Affiliate] Unexpected response format.');
-                    verboseLog(`Unexpected API response. Status: ${response.status}, Data: ${JSON.stringify(response.data)}`);
-                    verboseLog('Storing original link as fallback');
-                    yield storeInsertAffiliateIdentifier({ link: referringLink, source: 'referring_link' });
-                    return `${referringLink}-${customerID}`;
-                }
+    const setInsertAffiliateIdentifierImpl = (referringLink) => __awaiter(void 0, 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.');
+                verboseLog('Referring link is empty or invalid, storing as-is');
+                yield storeInsertAffiliateIdentifier({ link: referringLink, source: 'referring_link' });
+                return `${referringLink}-${customerID}`;
+            }
+            // 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;
             }
-            catch (error) {
-                console.error('[Insert Affiliate] Error:', error);
-                verboseLog(`Error in setInsertAffiliateIdentifier: ${error}`);
+            // 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.');
+                verboseLog('Link is already a short code, storing directly');
+                yield storeInsertAffiliateIdentifier({ link: referringLink, source: 'referring_link' });
+                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.');
+                verboseLog('Failed to encode link, storing original');
+                yield storeInsertAffiliateIdentifier({ link: referringLink, source: 'referring_link' });
+                return `${referringLink}-${customerID}`;
+            }
+            // Create the request URL
+            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, source: 'referring_link' });
+                verboseLog('Short link stored successfully');
+                return `${shortLink}-${customerID}`;
             }
-        });
-    }
-    ;
+            else {
+                console.warn('[Insert Affiliate] Unexpected response format.');
+                verboseLog(`Unexpected API response. Status: ${response.status}, Data: ${JSON.stringify(response.data)}`);
+                verboseLog('Storing original link as fallback');
+                yield storeInsertAffiliateIdentifier({ link: referringLink, source: 'referring_link' });
+                return `${referringLink}-${customerID}`;
+            }
+        }
+        catch (error) {
+            console.error('[Insert Affiliate] Error:', error);
+            verboseLog(`Error in setInsertAffiliateIdentifier: ${error}`);
+        }
+    });
     function storeInsertAffiliateIdentifier(_a) {
         return __awaiter(this, arguments, void 0, function* ({ link, source }) {
             console.log(`[Insert Affiliate] Storing affiliate identifier: ${link} (source: ${source})`);
@@ -1448,18 +1492,18 @@ const DeepLinkIapProvider = ({ children, }) => {
             yield retrieveAndStoreOfferCode(link);
             // Trigger callback with the current affiliate identifier
             if (insertAffiliateIdentifierChangeCallbackRef.current) {
-                const currentIdentifier = yield returnInsertAffiliateIdentifier();
+                const currentIdentifier = yield returnInsertAffiliateIdentifierImpl();
                 verboseLog(`Triggering callback with identifier: ${currentIdentifier}`);
                 insertAffiliateIdentifierChangeCallbackRef.current(currentIdentifier);
             }
             // Report this new affiliate association to the backend (fire and forget)
-            const fullIdentifier = yield returnInsertAffiliateIdentifier();
+            const fullIdentifier = yield returnInsertAffiliateIdentifierImpl();
             if (fullIdentifier) {
                 reportAffiliateAssociationIfNeeded(fullIdentifier, source);
             }
         });
     }
-    const validatePurchaseWithIapticAPI = (jsonIapPurchase, iapticAppId, iapticAppName, iapticPublicKey) => __awaiter(void 0, void 0, void 0, function* () {
+    const validatePurchaseWithIapticAPIImpl = (jsonIapPurchase, iapticAppId, iapticAppName, iapticPublicKey) => __awaiter(void 0, void 0, void 0, function* () {
         var _a;
         try {
             // Check for E_IAP_NOT_AVAILABLE error in development environment
@@ -1498,7 +1542,7 @@ const DeepLinkIapProvider = ({ children, }) => {
                 };
             }
             const requestBody = Object.assign(Object.assign({}, baseRequestBody), { transaction });
-            let insertAffiliateIdentifier = yield returnInsertAffiliateIdentifier();
+            let insertAffiliateIdentifier = yield returnInsertAffiliateIdentifierImpl();
             if (insertAffiliateIdentifier) {
                 requestBody.additionalData = {
                     applicationUsername: `${insertAffiliateIdentifier}`,
@@ -1545,7 +1589,7 @@ const DeepLinkIapProvider = ({ children, }) => {
             return false;
         }
     });
-    const storeExpectedStoreTransaction = (purchaseToken) => __awaiter(void 0, void 0, void 0, function* () {
+    const storeExpectedStoreTransactionImpl = (purchaseToken) => __awaiter(void 0, void 0, void 0, function* () {
         verboseLog(`Storing expected store transaction with token: ${purchaseToken}`);
         const activeCompanyCode = yield getActiveCompanyCode();
         if (!activeCompanyCode) {
@@ -1553,7 +1597,7 @@ const DeepLinkIapProvider = ({ children, }) => {
             verboseLog("Cannot store transaction: no company code available");
             return;
         }
-        const shortCode = yield returnInsertAffiliateIdentifier();
+        const shortCode = yield returnInsertAffiliateIdentifierImpl();
         if (!shortCode) {
             console.error("[Insert Affiliate] No affiliate identifier found. Please set one before tracking events.");
             verboseLog("Cannot store transaction: no affiliate identifier available");
@@ -1594,7 +1638,7 @@ const DeepLinkIapProvider = ({ children, }) => {
         }
     });
     // MARK: Track Event
-    const trackEvent = (eventName) => __awaiter(void 0, void 0, void 0, function* () {
+    const trackEventImpl = (eventName) => __awaiter(void 0, void 0, void 0, function* () {
         try {
             verboseLog(`Tracking event: ${eventName}`);
             const activeCompanyCode = yield getActiveCompanyCode();
@@ -1715,6 +1759,75 @@ const DeepLinkIapProvider = ({ children, }) => {
         // Remove special characters, keep only alphanumeric
         return removeSpecialCharacters(offerCode);
     };
+    // ============================================================================
+    // REF CALLBACK PATTERN: Update refs on every render for fresh closures
+    // ============================================================================
+    initializeImplRef.current = initializeImpl;
+    setShortCodeImplRef.current = setShortCodeImpl;
+    getAffiliateDetailsImplRef.current = getAffiliateDetailsImpl;
+    returnInsertAffiliateIdentifierImplRef.current = returnInsertAffiliateIdentifierImpl;
+    isAffiliateAttributionValidImplRef.current = isAffiliateAttributionValidImpl;
+    getAffiliateStoredDateImplRef.current = getAffiliateStoredDateImpl;
+    storeExpectedStoreTransactionImplRef.current = storeExpectedStoreTransactionImpl;
+    returnUserAccountTokenAndStoreExpectedTransactionImplRef.current = returnUserAccountTokenAndStoreExpectedTransactionImpl;
+    validatePurchaseWithIapticAPIImplRef.current = validatePurchaseWithIapticAPIImpl;
+    trackEventImplRef.current = trackEventImpl;
+    setInsertAffiliateIdentifierImplRef.current = setInsertAffiliateIdentifierImpl;
+    handleInsertLinksImplRef.current = handleInsertLinksImpl;
+    // ============================================================================
+    // STABLE WRAPPERS: useCallback with [] deps that delegate to refs
+    // These provide stable function references that always call current implementations
+    // ============================================================================
+    const initialize = (0, react_1.useCallback)((code, verboseLogging, insertLinksEnabled, insertLinksClipboardEnabled, affiliateAttributionActiveTime) => __awaiter(void 0, void 0, void 0, function* () {
+        return initializeImplRef.current(code, verboseLogging, insertLinksEnabled, insertLinksClipboardEnabled, affiliateAttributionActiveTime);
+    }), []);
+    const setShortCode = (0, react_1.useCallback)((shortCode) => __awaiter(void 0, void 0, void 0, function* () {
+        return setShortCodeImplRef.current(shortCode);
+    }), []);
+    const getAffiliateDetails = (0, react_1.useCallback)((affiliateCode) => __awaiter(void 0, void 0, void 0, function* () {
+        return getAffiliateDetailsImplRef.current(affiliateCode);
+    }), []);
+    const returnInsertAffiliateIdentifier = (0, react_1.useCallback)((ignoreTimeout) => __awaiter(void 0, void 0, void 0, function* () {
+        return returnInsertAffiliateIdentifierImplRef.current(ignoreTimeout);
+    }), []);
+    const isAffiliateAttributionValid = (0, react_1.useCallback)(() => __awaiter(void 0, void 0, void 0, function* () {
+        return isAffiliateAttributionValidImplRef.current();
+    }), []);
+    const getAffiliateStoredDate = (0, react_1.useCallback)(() => __awaiter(void 0, void 0, void 0, function* () {
+        return getAffiliateStoredDateImplRef.current();
+    }), []);
+    const storeExpectedStoreTransaction = (0, react_1.useCallback)((purchaseToken) => __awaiter(void 0, void 0, void 0, function* () {
+        return storeExpectedStoreTransactionImplRef.current(purchaseToken);
+    }), []);
+    const returnUserAccountTokenAndStoreExpectedTransaction = (0, react_1.useCallback)(() => __awaiter(void 0, void 0, void 0, function* () {
+        return returnUserAccountTokenAndStoreExpectedTransactionImplRef.current();
+    }), []);
+    const validatePurchaseWithIapticAPI = (0, react_1.useCallback)((jsonIapPurchase, iapticAppId, iapticAppName, iapticPublicKey) => __awaiter(void 0, void 0, void 0, function* () {
+        return validatePurchaseWithIapticAPIImplRef.current(jsonIapPurchase, iapticAppId, iapticAppName, iapticPublicKey);
+    }), []);
+    const trackEvent = (0, react_1.useCallback)((eventName) => __awaiter(void 0, void 0, void 0, function* () {
+        return trackEventImplRef.current(eventName);
+    }), []);
+    const setInsertAffiliateIdentifier = (0, react_1.useCallback)((referringLink) => __awaiter(void 0, void 0, void 0, function* () {
+        return setInsertAffiliateIdentifierImplRef.current(referringLink);
+    }), []);
+    const setInsertAffiliateIdentifierChangeCallbackHandler = (0, react_1.useCallback)((callback) => {
+        insertAffiliateIdentifierChangeCallbackRef.current = callback;
+        // If callback is being set, immediately call it with the current identifier value
+        // This ensures callbacks registered after initialization still receive the current state (including null if expired/not set)
+        if (callback) {
+            returnInsertAffiliateIdentifierImpl().then(identifier => {
+                // Verify callback is still the same (wasn't replaced during async operation)
+                if (insertAffiliateIdentifierChangeCallbackRef.current === callback) {
+                    verboseLog(`Calling callback immediately with current identifier: ${identifier}`);
+                    callback(identifier);
+                }
+            });
+        }
+    }, []);
+    const handleInsertLinks = (0, react_1.useCallback)((url) => __awaiter(void 0, void 0, void 0, function* () {
+        return handleInsertLinksImplRef.current(url);
+    }), []);
     return (react_1.default.createElement(exports.DeepLinkIapContext.Provider, { value: {
             referrerLink,
             userId,