insert-affiliate-js-sdk 1.0.2 → 1.1.0

package/dist/index.d.ts

@@ -1,13 +1,44 @@
 interface IapticIOSReceipt {
     transactionReceipt: string;
 }
+interface AffiliateDetails {
+    affiliateName: string;
+    affiliateShortCode: string;
+    deeplinkUrl: string;
+}
+type InsertAffiliateIdentifierChangeCallback = (identifier: string | null) => void;
 declare class InsertAffiliate {
     private static isInitialized;
     private static companyCode;
-    static initialize(code: string | null): Promise<void>;
-    static returnInsertAffiliateIdentifier(): Promise<string | null>;
+    private static verboseLogging;
+    private static insertAffiliateIdentifierChangeCallback;
+    private static affiliateAttributionActiveTime;
+    private static offerCode;
+    private static verboseLog;
+    static initialize(code: string | null, verboseLogging?: boolean, affiliateAttributionActiveTime?: number): Promise<void>;
+    private static checkForInsertAffiliateParam;
+    static returnInsertAffiliateIdentifier(ignoreTimeout?: boolean): Promise<string | null>;
     static setInsertAffiliateIdentifier(referringLink: string): Promise<string | null>;
-    static setShortCode(shortCode: string): Promise<void>;
+    /**
+     * Validates and sets a short code for affiliate tracking
+     * Validates the short code against the API before storing
+     * @param shortCode The short code to validate and set
+     * @returns true if the code exists and was successfully validated and stored, false otherwise
+     */
+    static setShortCode(shortCode: string): Promise<boolean>;
+    static setInsertAffiliateIdentifierChangeCallback(callback: InsertAffiliateIdentifierChangeCallback | null): void;
+    static isAffiliateAttributionValid(): Promise<boolean>;
+    static getAffiliateStoredDate(): Promise<string | null>;
+    /**
+     * Retrieve detailed information about an affiliate by their short code or deep link
+     * This method queries the API and does not store or set the affiliate identifier
+     * @param affiliateCode The short code or deep link to look up
+     * @returns AffiliateDetails if found, null otherwise
+     */
+    static getAffiliateDetails(affiliateCode: string): Promise<AffiliateDetails | null>;
+    static returnCompanyId(): Promise<string | null>;
+    static getOfferCode(): Promise<string | null>;
+    private static fetchAndStoreOfferCode;
     static trackEvent(eventName: string): Promise<void>;
     static returnUserAccountTokenAndStoreExpectedTransaction(): Promise<string | null>;
     static storeExpectedStoreTransaction(userAccountToken: string): Promise<void>;
@@ -19,4 +50,4 @@ declare class InsertAffiliate {
     private static fetchShortLink;
 }
 
-export { InsertAffiliate };
+export { type AffiliateDetails, InsertAffiliate, type InsertAffiliateIdentifierChangeCallback };

package/dist/index.js

@@ -75,78 +75,339 @@ if (!String.prototype.hasOwnProperty("hashCode")) {
 
 // src/sdk/InsertAffiliate.ts
 var InsertAffiliate = class {
-  static async initialize(code) {
+  static verboseLog(message) {
+    if (this.verboseLogging) {
+      console.log(`[Insert Affiliate] [VERBOSE] ${message}`);
+    }
+  }
+  static async initialize(code, verboseLogging = false, affiliateAttributionActiveTime) {
+    this.verboseLogging = verboseLogging;
+    if (verboseLogging) {
+      this.verboseLog("Starting SDK initialization...");
+      this.verboseLog(`Company code provided: ${code ? "Yes" : "No"}`);
+      this.verboseLog("Verbose logging enabled");
+    }
     if (this.isInitialized) {
-      console.warn("[Insert Affiliate] SDK already initialized.");
+      this.verboseLog("SDK already initialized, skipping");
       return;
     }
     this.companyCode = code;
     await saveValue("companyCode", code || "");
+    if (affiliateAttributionActiveTime !== void 0) {
+      this.affiliateAttributionActiveTime = affiliateAttributionActiveTime;
+      await saveValue("affiliateAttributionActiveTime", affiliateAttributionActiveTime.toString());
+      this.verboseLog(`Attribution timeout set to: ${affiliateAttributionActiveTime}ms`);
+    }
     this.isInitialized = true;
-    console.log(`[Insert Affiliate] SDK initialized ${code ? `with company code: ${code}` : "without a company code."}`);
+    this.verboseLog(`SDK initialized ${code ? `with company code: ${code}` : "without a company code."}`);
+    this.verboseLog("Company code saved to storage");
+    this.verboseLog("SDK marked as initialized");
+    await this.checkForInsertAffiliateParam();
+  }
+  static async checkForInsertAffiliateParam() {
+    this.verboseLog("Checking for insertAffiliate URL parameter...");
+    try {
+      if (typeof window === "undefined" || !window.location) {
+        this.verboseLog("Not in browser environment, skipping URL parameter check");
+        return;
+      }
+      this.verboseLog(`Current URL: ${window.location.href}`);
+      const urlParams = new URLSearchParams(window.location.search);
+      const insertAffiliateParam = urlParams.get("insertAffiliate");
+      if (insertAffiliateParam) {
+        this.verboseLog(`Found insertAffiliate URL parameter: ${insertAffiliateParam}`);
+        await this.setShortCode(insertAffiliateParam);
+        this.verboseLog("Successfully processed insertAffiliate URL parameter");
+      } else {
+        this.verboseLog("No insertAffiliate URL parameter found");
+      }
+    } catch (error) {
+      this.verboseLog(`Error checking for insertAffiliate URL parameter: ${error}`);
+    }
   }
-  static async returnInsertAffiliateIdentifier() {
+  static async returnInsertAffiliateIdentifier(ignoreTimeout = false) {
+    this.verboseLog("Getting insert affiliate identifier...");
     const userId = await this.getOrCreateUserID();
     const referrerLink = await getValue("referrerLink");
-    if (!referrerLink) return null;
-    return `${referrerLink}-${userId}`;
+    this.verboseLog(`User ID: ${userId || "empty"}, Referrer link: ${referrerLink || "empty"}`);
+    if (!referrerLink) {
+      this.verboseLog("No referrer link found, returning null");
+      return null;
+    }
+    if (!ignoreTimeout) {
+      const isValid = await this.isAffiliateAttributionValid();
+      if (!isValid) {
+        this.verboseLog("Attribution has expired, returning null");
+        return null;
+      }
+    } else {
+      this.verboseLog("Ignoring attribution timeout");
+    }
+    const identifier = `${referrerLink}-${userId}`;
+    this.verboseLog(`Returning affiliate identifier: ${identifier}`);
+    return identifier;
   }
   static async setInsertAffiliateIdentifier(referringLink) {
+    this.verboseLog(`Setting affiliate identifier. Input referringLink: ${referringLink}`);
     const userId = await this.getOrCreateUserID();
-    const shortCode = /^[a-zA-Z0-9]{3,25}$/.test(referringLink) ? referringLink : await this.fetchShortLink(referringLink);
-    if (!shortCode) return null;
+    this.verboseLog(`User ID: ${userId}`);
+    const isShortCode = /^[a-zA-Z0-9]{3,25}$/.test(referringLink);
+    this.verboseLog(`Is short code: ${isShortCode}`);
+    const shortCode = isShortCode ? referringLink : await this.fetchShortLink(referringLink);
+    if (!shortCode) {
+      this.verboseLog("No short code found or generated, returning null");
+      return null;
+    }
+    const existingShortCode = await getValue("referrerLink");
+    if (existingShortCode === shortCode) {
+      this.verboseLog(`Short code ${shortCode} is already set, not updating attribution date`);
+      const identifier2 = `${shortCode}-${userId}`;
+      this.verboseLog(`Returning existing identifier: ${identifier2}`);
+      return identifier2;
+    }
+    this.verboseLog(`Saving short code to storage: ${shortCode}`);
     await saveValue("referrerLink", shortCode);
-    return `${shortCode}-${userId}`;
+    const storedDate = (/* @__PURE__ */ new Date()).toISOString();
+    await saveValue("affiliateStoredDate", storedDate);
+    this.verboseLog(`Short code saved successfully with stored date: ${storedDate}`);
+    const identifier = `${shortCode}-${userId}`;
+    this.verboseLog(`Returning identifier: ${identifier}`);
+    await this.fetchAndStoreOfferCode(shortCode);
+    if (this.insertAffiliateIdentifierChangeCallback) {
+      this.verboseLog(`Triggering callback with identifier: ${identifier}`);
+      this.insertAffiliateIdentifierChangeCallback(identifier);
+    }
+    return identifier;
   }
+  /**
+   * Validates and sets a short code for affiliate tracking
+   * Validates the short code against the API before storing
+   * @param shortCode The short code to validate and set
+   * @returns true if the code exists and was successfully validated and stored, false otherwise
+   */
   static async setShortCode(shortCode) {
+    this.verboseLog(`Setting short code. Input: ${shortCode}`);
     const valid = /^[a-zA-Z0-9]{3,25}$/.test(shortCode);
+    this.verboseLog(`Short code validation: ${valid ? "Valid" : "Invalid"}`);
     if (!valid) {
-      console.warn("[Insert Affiliate] Invalid short code.");
-      return;
+      this.verboseLog("Invalid short code format, aborting");
+      return false;
     }
+    const affiliateDetails = await this.getAffiliateDetails(shortCode);
+    if (!affiliateDetails) {
+      this.verboseLog(`Short code '${shortCode}' does not exist or validation failed`);
+      console.error(`[Insert Affiliate] Error: Short code '${shortCode}' does not exist or validation failed.`);
+      return false;
+    }
+    this.verboseLog(`Short code validated successfully for affiliate: ${affiliateDetails.affiliateName}`);
+    console.log(`[Insert Affiliate] Short code validated successfully for affiliate: ${affiliateDetails.affiliateName}`);
+    this.verboseLog("Calling setInsertAffiliateIdentifier with short code");
     await this.setInsertAffiliateIdentifier(shortCode);
+    return true;
+  }
+  static setInsertAffiliateIdentifierChangeCallback(callback) {
+    this.verboseLog(`Setting affiliate identifier change callback: ${callback ? "callback provided" : "callback cleared"}`);
+    this.insertAffiliateIdentifierChangeCallback = callback;
+  }
+  static async isAffiliateAttributionValid() {
+    this.verboseLog("Checking if affiliate attribution is valid...");
+    const storedDateStr = await getValue("affiliateStoredDate");
+    if (!storedDateStr) {
+      this.verboseLog("No stored date found, attribution invalid");
+      return false;
+    }
+    let timeoutMs = this.affiliateAttributionActiveTime;
+    if (timeoutMs === null) {
+      const storedTimeout = await getValue("affiliateAttributionActiveTime");
+      timeoutMs = storedTimeout ? parseInt(storedTimeout, 10) : null;
+    }
+    if (timeoutMs === null) {
+      this.verboseLog("No attribution timeout configured, attribution is valid");
+      return true;
+    }
+    const storedDate = new Date(storedDateStr);
+    const currentDate = /* @__PURE__ */ new Date();
+    const elapsedMs = currentDate.getTime() - storedDate.getTime();
+    const isValid = elapsedMs <= timeoutMs;
+    this.verboseLog(`Attribution stored: ${storedDateStr}, elapsed: ${elapsedMs}ms, timeout: ${timeoutMs}ms, valid: ${isValid}`);
+    return isValid;
+  }
+  static async getAffiliateStoredDate() {
+    this.verboseLog("Getting affiliate stored date...");
+    const storedDate = await getValue("affiliateStoredDate");
+    this.verboseLog(`Stored date: ${storedDate || "none"}`);
+    return storedDate;
+  }
+  /**
+   * Retrieve detailed information about an affiliate by their short code or deep link
+   * This method queries the API and does not store or set the affiliate identifier
+   * @param affiliateCode The short code or deep link to look up
+   * @returns AffiliateDetails if found, null otherwise
+   */
+  static async getAffiliateDetails(affiliateCode) {
+    this.verboseLog(`Getting affiliate details for: ${affiliateCode}`);
+    const companyCode = this.companyCode || await getValue("companyCode");
+    if (!companyCode) {
+      this.verboseLog("Cannot get affiliate details: no company code available");
+      return null;
+    }
+    const cleanCode = affiliateCode.includes("-") ? affiliateCode.split("-")[0] : affiliateCode;
+    this.verboseLog(`Clean code: ${cleanCode}`);
+    try {
+      const url = "https://api.insertaffiliate.com/V1/checkAffiliateExists";
+      const payload = {
+        companyId: companyCode,
+        affiliateCode: cleanCode
+      };
+      this.verboseLog(`Making API call to: ${url}`);
+      this.verboseLog(`Payload: ${JSON.stringify(payload)}`);
+      const response = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(payload)
+      });
+      this.verboseLog(`API response status: ${response.status}`);
+      if (!response.ok) {
+        this.verboseLog(`Failed to get affiliate details, status: ${response.status}`);
+        return null;
+      }
+      const data = await response.json();
+      this.verboseLog(`API response data: ${JSON.stringify(data)}`);
+      if (data.exists && data.affiliate) {
+        const details = {
+          affiliateName: data.affiliate.affiliateName,
+          affiliateShortCode: data.affiliate.affiliateShortCode,
+          deeplinkUrl: data.affiliate.deeplinkurl
+        };
+        this.verboseLog(`Successfully retrieved affiliate details for: ${details.affiliateName}`);
+        return details;
+      }
+      this.verboseLog("Affiliate does not exist");
+      return null;
+    } catch (error) {
+      this.verboseLog(`Error fetching affiliate details: ${error}`);
+      return null;
+    }
+  }
+  static async returnCompanyId() {
+    this.verboseLog("Getting company ID...");
+    const companyCode = this.companyCode || await getValue("companyCode");
+    this.verboseLog(`Company ID: ${companyCode || "none"}`);
+    return companyCode;
+  }
+  static async getOfferCode() {
+    this.verboseLog("Getting offer code...");
+    if (this.offerCode) {
+      this.verboseLog(`Returning cached offer code: ${this.offerCode}`);
+      return this.offerCode;
+    }
+    const storedOfferCode = await getValue("offerCode");
+    if (storedOfferCode) {
+      this.verboseLog(`Returning stored offer code: ${storedOfferCode}`);
+      this.offerCode = storedOfferCode;
+      return storedOfferCode;
+    }
+    this.verboseLog("No offer code found");
+    return null;
+  }
+  static async fetchAndStoreOfferCode(shortCode) {
+    this.verboseLog(`Fetching offer code for short code: ${shortCode}`);
+    try {
+      const companyCode = this.companyCode || await getValue("companyCode");
+      if (!companyCode) {
+        this.verboseLog("Cannot fetch offer code: no company code available");
+        return;
+      }
+      const encoded = encodeURIComponent(shortCode);
+      const url = `https://api.insertaffiliate.com/v1/affiliateReturnOfferCode/${companyCode}/${encoded}`;
+      this.verboseLog(`Making API call to: ${url}`);
+      const response = await fetch(url);
+      this.verboseLog(`API response status: ${response.status}`);
+      if (!response.ok) {
+        this.verboseLog(`Failed to fetch offer code, status: ${response.status}`);
+        return;
+      }
+      const offerCode = (await response.text()).replace(/[^a-zA-Z0-9]/g, "");
+      this.verboseLog(`Received offer code: ${offerCode}`);
+      const errorCodes = [
+        "errorofferCodeNotFound",
+        "errorAffiliateoffercodenotfoundinanycompany",
+        "errorAffiliateoffercodenotfoundinanycompanyAffiliatelinkwas",
+        "Routenotfound"
+      ];
+      if (errorCodes.includes(offerCode)) {
+        this.verboseLog("Offer code not found or invalid");
+        return;
+      }
+      this.offerCode = offerCode;
+      await saveValue("offerCode", offerCode);
+      this.verboseLog(`Offer code stored successfully: ${offerCode}`);
+    } catch (error) {
+      this.verboseLog(`Error fetching offer code: ${error}`);
+    }
   }
   static async trackEvent(eventName) {
+    this.verboseLog(`Tracking event: ${eventName}`);
     const id = await this.returnInsertAffiliateIdentifier();
     if (!id) {
-      console.warn("[Insert Affiliate] No affiliate identifier found.");
+      this.verboseLog("Cannot track event: no affiliate identifier available");
       return;
     }
     const companyCode = this.companyCode || await getValue("companyCode");
-    if (!companyCode) return;
+    this.verboseLog(`Company code: ${companyCode || "empty"}`);
+    if (!companyCode) {
+      this.verboseLog("Cannot track event: no company code available");
+      return;
+    }
+    const payload = {
+      eventName,
+      deepLinkParam: id,
+      companyId: companyCode
+    };
+    this.verboseLog(`Track event payload: ${JSON.stringify(payload)}`);
+    this.verboseLog("Making API call to track event...");
     try {
-      await fetch("https://api.insertaffiliate.com/v1/trackEvent", {
+      const response = await fetch("https://api.insertaffiliate.com/v1/trackEvent", {
         method: "POST",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(
-          {
-            eventName,
-            deepLinkParam: id,
-            companyId: companyCode
-          }
-        )
+        body: JSON.stringify(payload)
       });
-      console.log("[Insert Affiliate] Event tracked:", eventName);
+      this.verboseLog(`Track event API response status: ${response.status}`);
+      if (response.ok) {
+        this.verboseLog(`Event tracked successfully: ${eventName}`);
+      } else {
+        this.verboseLog(`Failed to track event with status code: ${response.status}`);
+      }
     } catch (err) {
-      console.error("[Insert Affiliate] Failed to track event:", err);
+      this.verboseLog(`Network error tracking event: ${err}`);
     }
   }
   static async returnUserAccountTokenAndStoreExpectedTransaction() {
+    this.verboseLog("Getting user account token and storing expected transaction...");
     const shortCode = await this.returnInsertAffiliateIdentifier();
-    if (!shortCode) return null;
+    if (!shortCode) {
+      this.verboseLog("No affiliate identifier found, not saving expected transaction");
+      return null;
+    }
     let token = await getValue("userAccountToken");
+    this.verboseLog(`Existing token: ${token || "none"}`);
     if (!token) {
+      this.verboseLog("Generating new user account token...");
       token = generateUUID();
       await saveValue("userAccountToken", token);
+      this.verboseLog(`Generated and saved new token: ${token}`);
     }
+    this.verboseLog(`User account token: ${token}`);
     await this.storeExpectedStoreTransaction(token);
     return token;
   }
   static async storeExpectedStoreTransaction(userAccountToken) {
+    this.verboseLog(`Storing expected store transaction with token: ${userAccountToken}`);
     const companyCode = this.companyCode || await getValue("companyCode");
     const shortCode = await this.returnInsertAffiliateIdentifier();
+    this.verboseLog(`Company code: ${companyCode || "empty"}, Short code: ${shortCode || "empty"}`);
     if (!companyCode || !shortCode) {
-      console.error("[Insert Affiliate] Missing company code or identifier.");
+      this.verboseLog("Cannot store transaction: missing company code or identifier");
       return;
     }
     const payload = {
@@ -155,36 +416,43 @@ var InsertAffiliate = class {
       shortCode,
       storedDate: (/* @__PURE__ */ new Date()).toISOString()
     };
+    this.verboseLog(`Payload: ${JSON.stringify(payload)}`);
+    this.verboseLog("Making API call to store expected transaction...");
     try {
       const res = await fetch("https://api.insertaffiliate.com/v1/api/app-store-webhook/create-expected-transaction", {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify(payload)
       });
+      this.verboseLog(`API response status: ${res.status}`);
       if (res.status === 200) {
-        console.log("[Insert Affiliate] Stored expected transaction");
+        this.verboseLog("Expected transaction stored successfully on server");
       } else {
-        console.warn("[Insert Affiliate] Failed storing transaction:", res.status);
+        this.verboseLog(`Failed to store transaction with status: ${res.status}`);
       }
     } catch (error) {
-      console.error("[Insert Affiliate] Error storing transaction:", error);
+      this.verboseLog(`Network error storing transaction: ${error}`);
     }
   }
   static async validatePurchaseWithIapticAPI(jsonIapPurchase, iapticAppId, iapticAppName, iapticPublicKey) {
     try {
+      this.verboseLog("Starting Iaptic purchase validation...");
       const isIOS = typeof window !== "undefined" && /iPad|iPhone|iPod/.test(navigator.userAgent);
+      this.verboseLog(`Platform detected: ${isIOS ? "iOS" : "Android"}`);
       const baseRequest = {
         id: iapticAppId,
         type: "application"
       };
       let transaction;
       if (isIOS) {
+        this.verboseLog("Creating iOS transaction payload");
         transaction = {
           id: iapticAppId,
           type: "ios-appstore",
           appStoreReceipt: jsonIapPurchase.transactionReceipt
         };
       } else {
+        this.verboseLog("Creating Android transaction payload");
         const receiptJson = JSON.parse(atob(jsonIapPurchase.transactionReceipt));
         transaction = {
           id: receiptJson.orderId,
@@ -195,10 +463,12 @@ var InsertAffiliate = class {
         };
       }
       const insertAffiliateIdentifier = await this.returnInsertAffiliateIdentifier();
+      this.verboseLog(`Affiliate identifier: ${insertAffiliateIdentifier || "none"}`);
       const payload = __spreadProps(__spreadValues({}, baseRequest), {
         transaction,
         additionalData: insertAffiliateIdentifier ? { applicationUsername: insertAffiliateIdentifier } : void 0
       });
+      this.verboseLog("Making API call to Iaptic validator...");
       const response = await fetch("https://validator.iaptic.com/v1/validate", {
         method: "POST",
         headers: {
@@ -207,17 +477,36 @@ var InsertAffiliate = class {
         },
         body: JSON.stringify(payload)
       });
-      return response.status === 200;
+      this.verboseLog(`Iaptic validation response status: ${response.status}`);
+      if (response.status === 200) {
+        this.verboseLog("Purchase validated successfully");
+        return true;
+      } else {
+        this.verboseLog(`Validation failed with status: ${response.status}`);
+        return false;
+      }
     } catch (error) {
-      console.error("[Insert Affiliate] Purchase validation failed:", error);
+      this.verboseLog(`Error during purchase validation: ${error}`);
       return false;
     }
   }
   static async fetchAndConditionallyOpenUrl(affiliateLink, offerCodeUrlId) {
+    this.verboseLog("Fetching offer code and opening URL...");
     const encoded = encodeURIComponent(affiliateLink);
+    this.verboseLog(`Encoded affiliate link: ${encoded}`);
     try {
-      const res = await fetch(`https://api.insertaffiliate.com/v1/affiliateReturnOfferCode/${encoded}`);
+      const companyCode = this.companyCode || await getValue("companyCode");
+      if (!companyCode) {
+        this.verboseLog("Cannot fetch offer code: no company code available");
+        return;
+      }
+      this.verboseLog("Making API call to fetch offer code...");
+      const url = `https://api.insertaffiliate.com/v1/affiliateReturnOfferCode/${companyCode}/${encoded}`;
+      this.verboseLog(`API URL: ${url}`);
+      const res = await fetch(url);
+      this.verboseLog(`API response status: ${res.status}`);
       const offerCode = (await res.text()).replace(/[^a-zA-Z0-9]/g, "");
+      this.verboseLog(`Received offer code: ${offerCode}`);
       const errorCodes = [
         "errorofferCodeNotFound",
         "errorAffiliateoffercodenotfoundinanycompany",
@@ -225,39 +514,60 @@ var InsertAffiliate = class {
         "Routenotfound"
       ];
       if (errorCodes.includes(offerCode)) {
-        console.warn("[Insert Affiliate] Offer Code Not Found");
+        this.verboseLog("Offer code not found or invalid");
         return;
       }
       const redeemUrl = `https://apps.apple.com/redeem?ctx=offercodes&id=${offerCodeUrlId}&code=${offerCode}`;
+      this.verboseLog(`Opening redeem URL: ${redeemUrl}`);
       window.open(redeemUrl, "_blank");
+      this.verboseLog("Redeem URL opened successfully");
     } catch (err) {
-      console.error("[Insert Affiliate] Error fetching/opening offer code:", err);
+      this.verboseLog(`Error fetching/opening offer code: ${err}`);
     }
   }
   static async getOrCreateUserID() {
+    this.verboseLog("Getting or creating user ID...");
     let id = await getValue("userId");
+    this.verboseLog(`Existing user ID: ${id || "none"}`);
     if (!id) {
+      this.verboseLog("Generating new user ID...");
       id = generateShortDeviceID();
       await saveValue("userId", id);
+      this.verboseLog(`Generated and saved new user ID: ${id}`);
     }
     return id;
   }
   static async fetchShortLink(link) {
     try {
+      this.verboseLog("Converting deep link to short link...");
       const encoded = encodeURIComponent(link);
       const companyCode = this.companyCode || await getValue("companyCode");
-      if (!companyCode) return null;
-      const res = await fetch(`https://api.insertaffiliate.com/V1/convert-deep-link-to-short-link?companyId=${companyCode}&deepLinkUrl=${encoded}`);
+      this.verboseLog(`Company code: ${companyCode || "empty"}`);
+      if (!companyCode) {
+        this.verboseLog("No company code available, cannot convert link");
+        return null;
+      }
+      const url = `https://api.insertaffiliate.com/V1/convert-deep-link-to-short-link?companyId=${companyCode}&deepLinkUrl=${encoded}`;
+      this.verboseLog(`Making API call to: ${url}`);
+      const res = await fetch(url);
+      this.verboseLog(`API response status: ${res.status}`);
       const data = await res.json();
-      return (data == null ? void 0 : data.shortLink) || null;
+      const shortLink = (data == null ? void 0 : data.shortLink) || null;
+      this.verboseLog(`Short link received: ${shortLink || "none"}`);
+      return shortLink;
     } catch (err) {
-      console.error("[Insert Affiliate] Failed to fetch short link:", (err == null ? void 0 : err.message) || err);
+      this.verboseLog(`Error fetching short link: ${(err == null ? void 0 : err.message) || err}`);
       return null;
     }
   }
 };
 InsertAffiliate.isInitialized = false;
 InsertAffiliate.companyCode = null;
+InsertAffiliate.verboseLogging = false;
+InsertAffiliate.insertAffiliateIdentifierChangeCallback = null;
+InsertAffiliate.affiliateAttributionActiveTime = null;
+// in milliseconds
+InsertAffiliate.offerCode = null;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   InsertAffiliate

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "insert-affiliate-js-sdk",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",