insert-affiliate-react-native-sdk 1.9.0 → 1.11.1

package/dist/DeepLinkIapProvider.js

@@ -54,6 +54,8 @@ const ASYNC_KEYS = {
     USER_ACCOUNT_TOKEN: '@app_user_account_token',
     IOS_OFFER_CODE: '@app_ios_offer_code',
     AFFILIATE_STORED_DATE: '@app_affiliate_stored_date',
+    SDK_INIT_REPORTED: '@app_sdk_init_reported',
+    REPORTED_AFFILIATE_ASSOCIATIONS: '@app_reported_affiliate_associations',
 };
 // STARTING CONTEXT IMPLEMENTATION
 exports.DeepLinkIapContext = (0, react_1.createContext)({
@@ -86,41 +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(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);
@@ -151,6 +175,7 @@ const DeepLinkIapProvider = ({ children, }) => {
                 }
                 if (companyCodeFromStorage) {
                     setCompanyCode(companyCodeFromStorage);
+                    companyCodeRef.current = companyCodeFromStorage;
                     verboseLog('Company code restored from storage');
                 }
                 if (storedOfferCode) {
@@ -284,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) => {
@@ -330,12 +349,24 @@ const DeepLinkIapProvider = ({ children, }) => {
                 verboseLog('Invalid URL provided to handleInsertLinkAndroid');
                 return false;
             }
-            // Parse the URL to extract query parameters
-            const urlObj = new URL(url);
-            const insertAffiliate = urlObj.searchParams.get('insertAffiliate');
+            // Parse the URL to extract query parameters (React Native compatible)
+            // URLSearchParams is not available in React Native, so parse manually
+            let insertAffiliate = null;
+            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 === 'insertAffiliate' && value) {
+                        insertAffiliate = decodeURIComponent(value);
+                        break;
+                    }
+                }
+            }
             if (insertAffiliate && insertAffiliate.length > 0) {
                 verboseLog(`Found insertAffiliate parameter: ${insertAffiliate}`);
-                yield storeInsertAffiliateIdentifier({ link: insertAffiliate });
+                yield storeInsertAffiliateIdentifier({ link: insertAffiliate, source: 'deep_link_android' });
                 return true;
             }
             else {
@@ -449,7 +480,7 @@ const DeepLinkIapProvider = ({ children, }) => {
             // If we have insertAffiliate parameter, use it as the affiliate identifier
             if (insertAffiliate && insertAffiliate.length > 0) {
                 verboseLog(`Found insertAffiliate parameter, setting as affiliate identifier: ${insertAffiliate}`);
-                yield storeInsertAffiliateIdentifier({ link: insertAffiliate });
+                yield storeInsertAffiliateIdentifier({ link: insertAffiliate, source: 'install_referrer' });
                 return true;
             }
             else {
@@ -463,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') {
@@ -513,7 +544,7 @@ const DeepLinkIapProvider = ({ children, }) => {
                 console.log(`[Insert Affiliate] Warning: URL company code (${companyCode}) doesn't match initialized company code (${activeCompanyCode})`);
             }
             // If URL scheme is used, we can straight away store the short code as the referring link
-            yield storeInsertAffiliateIdentifier({ link: shortCode });
+            yield storeInsertAffiliateIdentifier({ link: shortCode, source: 'deep_link_ios' });
             // Collect and send enhanced system info to backend
             try {
                 const enhancedSystemInfo = yield getEnhancedSystemInfo();
@@ -566,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;
         }
@@ -593,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}`);
         }
     };
@@ -630,6 +695,87 @@ const DeepLinkIapProvider = ({ children, }) => {
                 break;
         }
     };
+    // Reports a new affiliate association to the backend for tracking.
+    // Only reports each unique affiliateIdentifier once to prevent duplicates.
+    const reportAffiliateAssociationIfNeeded = (affiliateIdentifier, source) => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            const activeCompanyCode = yield getActiveCompanyCode();
+            if (!activeCompanyCode) {
+                verboseLog('Cannot report affiliate association: no company code available');
+                return;
+            }
+            // Get the set of already-reported affiliate identifiers
+            const reportedAssociationsJson = yield async_storage_1.default.getItem(ASYNC_KEYS.REPORTED_AFFILIATE_ASSOCIATIONS);
+            const reportedAssociations = reportedAssociationsJson ? JSON.parse(reportedAssociationsJson) : [];
+            // Check if this affiliate identifier has already been reported
+            if (reportedAssociations.includes(affiliateIdentifier)) {
+                verboseLog(`Affiliate association already reported for: ${affiliateIdentifier}, skipping`);
+                return;
+            }
+            verboseLog(`Reporting new affiliate association: ${affiliateIdentifier} (source: ${source})`);
+            const response = yield fetch('https://api.insertaffiliate.com/V1/onboarding/affiliate-associated', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    companyId: activeCompanyCode,
+                    affiliateIdentifier: affiliateIdentifier,
+                    source: source,
+                    timestamp: new Date().toISOString(),
+                }),
+            });
+            if (response.ok) {
+                // Add to reported set and persist
+                reportedAssociations.push(affiliateIdentifier);
+                yield async_storage_1.default.setItem(ASYNC_KEYS.REPORTED_AFFILIATE_ASSOCIATIONS, JSON.stringify(reportedAssociations));
+                verboseLog(`Affiliate association reported successfully for: ${affiliateIdentifier}`);
+            }
+            else {
+                verboseLog(`Affiliate association report failed with status: ${response.status}`);
+            }
+        }
+        catch (error) {
+            // Silently fail - this is non-critical telemetry
+            verboseLog(`Affiliate association report error: ${error}`);
+        }
+    });
+    // Reports SDK initialization to the backend for onboarding verification.
+    // Only reports once per install to minimize server load.
+    const reportSdkInitIfNeeded = (companyCode, verboseLogging) => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            // Only report once per install
+            const alreadyReported = yield async_storage_1.default.getItem(ASYNC_KEYS.SDK_INIT_REPORTED);
+            if (alreadyReported === 'true') {
+                return;
+            }
+            if (verboseLogging) {
+                console.log('[Insert Affiliate] Reporting SDK initialization for onboarding verification...');
+            }
+            const response = yield fetch('https://api.insertaffiliate.com/V1/onboarding/sdk-init', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({ companyId: companyCode }),
+            });
+            if (response.ok) {
+                yield async_storage_1.default.setItem(ASYNC_KEYS.SDK_INIT_REPORTED, 'true');
+                if (verboseLogging) {
+                    console.log('[Insert Affiliate] SDK initialization reported successfully');
+                }
+            }
+            else if (verboseLogging) {
+                console.log(`[Insert Affiliate] SDK initialization report failed with status: ${response.status}`);
+            }
+        }
+        catch (error) {
+            // Silently fail - this is non-critical telemetry
+            if (verboseLogging) {
+                console.log(`[Insert Affiliate] SDK initialization report error: ${error}`);
+            }
+        }
+    });
     // MARK: - Deep Linking Utilities
     // Retrieves and validates clipboard content for UUID format
     const getClipboardUUID = () => __awaiter(void 0, void 0, void 0, function* () {
@@ -995,7 +1141,7 @@ const DeepLinkIapProvider = ({ children, }) => {
                 if (matchFound && response.data.matched_affiliate_shortCode && response.data.matched_affiliate_shortCode.length > 0) {
                     const matchedShortCode = response.data.matched_affiliate_shortCode;
                     verboseLog(`Storing Matched short code from backend: ${matchedShortCode}`);
-                    yield storeInsertAffiliateIdentifier({ link: matchedShortCode });
+                    yield storeInsertAffiliateIdentifier({ link: matchedShortCode, source: 'clipboard_match' });
                 }
             }
             // Check for a successful response
@@ -1059,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) {
@@ -1098,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 });
-                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);
@@ -1130,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;
@@ -1144,7 +1288,7 @@ const DeepLinkIapProvider = ({ children, }) => {
                 return null;
             }
             else {
-                yield storeExpectedStoreTransaction(userAccountToken);
+                yield storeExpectedStoreTransactionImpl(userAccountToken);
                 return userAccountToken;
             }
         }
@@ -1164,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;
@@ -1209,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;
@@ -1233,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) {
@@ -1250,87 +1394,84 @@ 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 });
-                    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 });
-                    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 });
-                    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 });
-                    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 });
-                    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 }) {
-            console.log(`[Insert Affiliate] Storing affiliate identifier: ${link}`);
+        return __awaiter(this, arguments, void 0, function* ({ link, source }) {
+            console.log(`[Insert Affiliate] Storing affiliate identifier: ${link} (source: ${source})`);
             // Check if we're trying to store the same link (prevent duplicate storage)
             const existingLink = yield getValueFromAsync(ASYNC_KEYS.REFERRER_LINK);
             if (existingLink === link) {
@@ -1351,13 +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 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
@@ -1396,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}`,
@@ -1443,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) {
@@ -1451,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");
@@ -1492,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();
@@ -1613,6 +1759,64 @@ 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;
+    }, []);
+    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,