@pixels-online/pixels-client-js-sdk 1.17.0 → 1.19.0

package/dist/index.js

@@ -630,25 +630,33 @@ class SSEConnection {
 }
 
 class OfferStore {
-    constructor(config) {
+    constructor(config, client) {
+        this.client = client;
         this.offers = new Map();
-        this.player = null;
+        this.players = new Map();
         this.logger = createLogger(config, 'OfferStore');
     }
-    getPlayer() {
-        return this.player || null;
+    getPlayer(targetId = this.client.getSelfId()) {
+        if (!targetId)
+            return null;
+        return this.players.get(targetId) || null;
     }
     setPlayer(player) {
-        this.player = player;
+        this.players.set(player.snapshot.playerId, player);
         this.logger.log('Updated player:', player);
     }
     /**
      * Set all offers (replaces existing)
      */
-    setOffers(offers) {
-        this.offers.clear();
+    setOffers(offers, target) {
+        const targetPlayer = target || this.getPlayer();
+        if (!targetPlayer) {
+            this.logger.warn('No target player to set offers for');
+            return;
+        }
+        this.offers.set(targetPlayer.snapshot.playerId, new Map());
         offers.forEach((offer) => {
-            this.offers.set(offer.instanceId, offer);
+            this.offers.get(targetPlayer.snapshot.playerId).set(offer.instanceId, offer);
         });
         this.logger.log(`Set ${offers.length} offers`);
     }
@@ -656,16 +664,23 @@ class OfferStore {
      * Add or update a single offer
      */
     upsertOffer(offer) {
-        const previousOffer = this.offers.get(offer.instanceId);
-        this.offers.set(offer.instanceId, offer);
+        let playerOffers = this.offers.get(offer.playerId);
+        if (!playerOffers) {
+            playerOffers = new Map();
+            this.offers.set(offer.playerId, playerOffers);
+        }
+        const previousOffer = playerOffers.get(offer.instanceId);
+        playerOffers.set(offer.instanceId, offer);
         this.logger.log(`${previousOffer ? 'Updated' : 'Added'} offer:`, offer.instanceId);
         return previousOffer;
     }
     /**
      * Remove an offer
      */
-    removeOffer(offerId) {
-        const removed = this.offers.delete(offerId);
+    removeOffer(offerId, targetId = this.client.getSelfId()) {
+        if (!targetId)
+            return false;
+        const removed = this.offers.get(targetId)?.delete(offerId) || false;
         if (removed) {
             this.logger.log(`Removed offer:`, offerId);
         }
@@ -674,26 +689,30 @@ class OfferStore {
     /**
      * Get a single offer
      */
-    getOffer(offerId) {
-        return this.offers.get(offerId);
+    getOffer(offerId, targetId = this.client.getSelfId()) {
+        if (!targetId)
+            return undefined;
+        return this.offers.get(targetId)?.get(offerId);
     }
     /**
      * Get all offers
      */
-    getAllOffers() {
-        return Array.from(this.offers.values());
+    getAllOffers(targetId = this.client.getSelfId()) {
+        if (!targetId)
+            return [];
+        return Array.from(this.offers.get(targetId)?.values() || []);
     }
     /**
      * Get offers filtered by status
      */
-    getOffersByStatus(status) {
-        return this.getAllOffers().filter((offer) => offer.status === status);
+    getOffersByStatus(status, targetId = this.client.getSelfId()) {
+        return this.getAllOffers(targetId).filter((offer) => offer.status === status);
     }
     /**
      * Get active offers (not expired, not claimed)
      */
-    getActiveOffers() {
-        return this.getAllOffers().filter((offer) => {
+    getActiveOffers(targetId = this.client.getSelfId()) {
+        return this.getAllOffers(targetId).filter((offer) => {
             if (!offer.status)
                 return false; // Must have a status
             return (offer.status === 'surfaced' ||
@@ -704,14 +723,14 @@ class OfferStore {
     /**
      * Get claimable offers
      */
-    getClaimableOffers() {
-        return this.getOffersByStatus('claimable');
+    getClaimableOffers(targetId = this.client.getSelfId()) {
+        return this.getOffersByStatus('claimable', targetId);
     }
     /**
      * Check if an offer has expired
      */
-    isOfferExpired(offerId) {
-        const offer = this.getOffer(offerId);
+    isOfferExpired(offerId, targetId = this.client.getSelfId()) {
+        const offer = this.getOffer(offerId, targetId);
         if (!offer)
             return true;
         // Check status
@@ -724,17 +743,29 @@ class OfferStore {
         return false;
     }
     /**
-     * Clear all offers
+     * Clear all offers for a specific player
      */
-    clear() {
+    clear(targetId = this.client.getSelfId()) {
+        if (!targetId)
+            return;
+        this.offers.set(targetId, new Map());
+        this.logger.log('Cleared all offers for player:', targetId);
+    }
+    /**
+     * Clear all offers for all players
+     */
+    clearAll() {
         this.offers.clear();
-        this.logger.log('Cleared all offers');
+        this.logger.log('Cleared all offers for all players');
     }
     /**
-     * Get offer count
+     * Get offer count (for self player)
      */
     get size() {
-        return this.offers.size;
+        const selfId = this.client.getSelfId();
+        if (!selfId)
+            return 0;
+        return this.offers.get(selfId)?.size || 0;
     }
 }
 
@@ -837,7 +868,9 @@ class AssetHelper {
         return null;
     }
     setCurrencyAssetContents(currencies) {
-        this.currencies = currencies;
+        Object.keys(currencies).forEach((key) => {
+            this.currencies[key] = currencies[key];
+        });
     }
     resolveReward(reward) {
         if (reward.kind === 'loyalty_currency' && reward.rewardId) {
@@ -893,6 +926,7 @@ class OfferwallClient {
     constructor(config) {
         this.isInitializing = false;
         this.pendingStackedToken = null;
+        this.selfId = null;
         this.config = {
             autoConnect: config.autoConnect ?? false,
             reconnect: config.reconnect ?? true,
@@ -905,7 +939,7 @@ class OfferwallClient {
         this.hooks = this.config.hooks || {};
         this.logger = createLogger(this.config, 'OfferwallClient');
         this.eventEmitter = new EventEmitter(this.config);
-        this.offerStore = new OfferStore(this.config);
+        this.offerStore = new OfferStore(this.config, this);
         this.tokenManager = new TokenManager(this.config);
         this.assetHelper = new AssetHelper(this.config);
         this.sseConnection = new SSEConnection(this.config, this.eventEmitter, this.tokenManager);
@@ -946,6 +980,9 @@ class OfferwallClient {
     get assets() {
         return this.assetHelper;
     }
+    getSelfId() {
+        return this.selfId;
+    }
     /**
      * Initialize the offerwall client and connect
      */
@@ -1008,8 +1045,9 @@ class OfferwallClient {
         if (this.sseConnection) {
             this.sseConnection.disconnect();
         }
-        this.offerStore.clear();
+        this.offerStore.clearAll();
         this.tokenManager.clearToken();
+        this.selfId = null;
         if (this.hooks.afterDisconnect) {
             await this.hooks.afterDisconnect();
         }
@@ -1017,8 +1055,8 @@ class OfferwallClient {
     /**
      * Claim rewards for an offer
      */
-    async claimReward(instanceId) {
-        const offer = this.offerStore.getOffer(instanceId);
+    async claimReward(instanceId, targetId = this.getSelfId()) {
+        const offer = this.offerStore.getOffer(instanceId, targetId);
         if (!offer) {
             throw new Error(`Offer ${instanceId} not found`);
         }
@@ -1033,7 +1071,7 @@ class OfferwallClient {
             }
         }
         try {
-            const response = await this.claimOfferAPI(instanceId);
+            const response = await this.claimOfferAPI(instanceId, targetId);
             const updatedOffer = { ...offer, status: 'claimed' };
             this.offerStore.upsertOffer(updatedOffer);
             this.eventEmitter.emit(exports.OfferEvent.OFFER_CLAIMED, {
@@ -1089,7 +1127,7 @@ class OfferwallClient {
         });
         */
         this.eventEmitter.on(exports.OfferEvent.OFFER_SURFACED, ({ offer }) => {
-            this.offerStore.upsertOffer(offer);
+            this.offerStore.upsertOffer(offer); // should always be selfId
             this.logger.log(`Surfaced offer: ${offer.instanceId}`);
         });
     }
@@ -1119,23 +1157,27 @@ class OfferwallClient {
         }
         return response.json();
     }
-    async claimOfferAPI(instanceId) {
+    async claimOfferAPI(instanceId, targetId = null) {
         return this.postWithAuth('/v1/client/reward/claim', {
             instanceId,
             kind: 'offer',
+            targetId: targetId || undefined,
         });
     }
-    getPlayer() {
-        return this.offerStore.getPlayer();
+    getPlayer(targetId = this.getSelfId()) {
+        return this.offerStore.getPlayer(targetId);
     }
-    getOffers() {
-        return this.offerStore.getAllOffers();
+    getOffers(targetId = this.getSelfId()) {
+        return this.offerStore.getAllOffers(targetId);
     }
-    async refreshOffersAndPlayer() {
+    async refreshOffersAndPlayer(targetId = null) {
         try {
-            const { offers, player } = await this.getOffersAndPlayer();
-            this.offerStore.setOffers(offers);
+            const { offers, player } = await this.getOffersAndPlayer(targetId);
+            if (targetId == null) {
+                this.selfId = player.snapshot.playerId;
+            }
             this.offerStore.setPlayer(player);
+            this.offerStore.setOffers(offers, player);
             this.eventEmitter.emit(exports.OfferEvent.REFRESH, { offers, player: player });
             this.logger.log('Refreshed offers and player snapshot');
         }
@@ -1144,9 +1186,10 @@ class OfferwallClient {
             throw error;
         }
     }
-    async getOffersAndPlayer() {
+    async getOffersAndPlayer(targetId = null) {
         const data = await this.postWithAuth('/v1/client/player/campaigns', {
             viewingCampaigns: true,
+            targetId: targetId || undefined,
         });
         if (!data.offers || !Array.isArray(data.offers)) {
             throw new Error('No offers returned from offers endpoint');
@@ -1921,6 +1964,8 @@ const meetsCompletionConditions = ({ completionConditions, completionTrackers, p
         const claimMultiplier = shouldScale ? (playerOffer.claimedCount || 0) + 1 : 1;
         const conditionData = [];
         let isValid = true;
+        let maxTotalClaimsFromScaling = Infinity;
+        const updateMax = (limit) => (maxTotalClaimsFromScaling = Math.min(maxTotalClaimsFromScaling, limit));
         if (completionConditions?.context?.id) {
             const hasTrackedContext = completionTrackers?.context &&
                 completionConditions.context.id === completionTrackers.context;
@@ -1937,17 +1982,22 @@ const meetsCompletionConditions = ({ completionConditions, completionTrackers, p
             }
             else {
                 if (isDisqualify)
-                    return { isValid: false };
+                    return { isValid: false, availableClaimsNow: 0 };
             }
         }
         if (conditions?.buyItem) {
-            const scaledAmount = (conditions.buyItem.amount || 1) * claimMultiplier;
-            const isDisqualify = (completionTrackers?.buyItem || 0) < scaledAmount;
+            const baseAmount = conditions.buyItem.amount || 1;
+            const scaledAmount = baseAmount * claimMultiplier;
+            const trackerValue = completionTrackers?.buyItem || 0;
+            const isDisqualify = trackerValue < scaledAmount;
+            if (shouldScale && baseAmount > 0) {
+                updateMax(Math.floor(trackerValue / baseAmount));
+            }
             if (addDetails) {
                 conditionData.push({
                     isMet: !isDisqualify,
                     kind: 'buyItem',
-                    trackerAmount: completionTrackers?.buyItem || 0,
+                    trackerAmount: trackerValue,
                     text: `Buy ${scaledAmount} ${conditions.buyItem.name}`,
                 });
                 if (isDisqualify)
@@ -1955,17 +2005,22 @@ const meetsCompletionConditions = ({ completionConditions, completionTrackers, p
             }
             else {
                 if (isDisqualify)
-                    return { isValid: false };
+                    return { isValid: false, availableClaimsNow: 0 };
             }
         }
         if (conditions?.spendCurrency) {
-            const scaledAmount = (conditions.spendCurrency.amount || 1) * claimMultiplier;
-            const isDisqualify = (completionTrackers?.spendCurrency || 0) < scaledAmount;
+            const baseAmount = conditions.spendCurrency.amount || 1;
+            const scaledAmount = baseAmount * claimMultiplier;
+            const trackerValue = completionTrackers?.spendCurrency || 0;
+            const isDisqualify = trackerValue < scaledAmount;
+            if (shouldScale && baseAmount > 0) {
+                updateMax(Math.floor(trackerValue / baseAmount));
+            }
             if (addDetails) {
                 conditionData.push({
                     isMet: !isDisqualify,
                     kind: 'spendCurrency',
-                    trackerAmount: completionTrackers?.spendCurrency || 0,
+                    trackerAmount: trackerValue,
                     text: `Spend ${scaledAmount} ${conditions.spendCurrency.name}`,
                 });
                 if (isDisqualify)
@@ -1973,17 +2028,22 @@ const meetsCompletionConditions = ({ completionConditions, completionTrackers, p
             }
             else {
                 if (isDisqualify)
-                    return { isValid: false };
+                    return { isValid: false, availableClaimsNow: 0 };
             }
         }
         if (conditions?.depositCurrency) {
-            const scaledAmount = (conditions.depositCurrency.amount || 1) * claimMultiplier;
-            const isDisqualify = (completionTrackers?.depositCurrency || 0) < scaledAmount;
+            const baseAmount = conditions.depositCurrency.amount || 1;
+            const scaledAmount = baseAmount * claimMultiplier;
+            const trackerValue = completionTrackers?.depositCurrency || 0;
+            const isDisqualify = trackerValue < scaledAmount;
+            if (shouldScale && baseAmount > 0) {
+                updateMax(Math.floor(trackerValue / baseAmount));
+            }
             if (addDetails) {
                 conditionData.push({
                     isMet: !isDisqualify,
                     kind: 'depositCurrency',
-                    trackerAmount: completionTrackers?.depositCurrency || 0,
+                    trackerAmount: trackerValue,
                     text: `Deposit ${scaledAmount} ${conditions.depositCurrency.name}`,
                 });
                 if (isDisqualify)
@@ -1991,7 +2051,7 @@ const meetsCompletionConditions = ({ completionConditions, completionTrackers, p
             }
             else {
                 if (isDisqualify)
-                    return { isValid: false };
+                    return { isValid: false, availableClaimsNow: 0 };
             }
         }
         if (conditions?.login) {
@@ -2008,7 +2068,7 @@ const meetsCompletionConditions = ({ completionConditions, completionTrackers, p
             }
             else {
                 if (!isMet)
-                    return { isValid: false };
+                    return { isValid: false, availableClaimsNow: 0 };
             }
         }
         if (conditions?.loginStreak) {
@@ -2028,7 +2088,7 @@ const meetsCompletionConditions = ({ completionConditions, completionTrackers, p
             }
             else {
                 if (isDisqualify)
-                    return { isValid: false };
+                    return { isValid: false, availableClaimsNow: 0 };
             }
         }
         if (conditions?.social) {
@@ -2050,6 +2110,17 @@ const meetsCompletionConditions = ({ completionConditions, completionTrackers, p
             if (likes < minLikes || views < minViews || comments < minComments) {
                 isDisqualify = true;
             }
+            if (shouldScale && mode === 'accumulate' && hasContent) {
+                const baseLikes = cSocial?.minLikes || 0;
+                const baseViews = cSocial?.minViews || 0;
+                const baseComments = cSocial?.minComments || 0;
+                if (baseLikes > 0)
+                    updateMax(Math.floor(likes / baseLikes));
+                if (baseViews > 0)
+                    updateMax(Math.floor(views / baseViews));
+                if (baseComments > 0)
+                    updateMax(Math.floor(comments / baseComments));
+            }
             if (addDetails) {
                 const platformMap = {
                     tiktok: 'TikTok',
@@ -2121,14 +2192,18 @@ const meetsCompletionConditions = ({ completionConditions, completionTrackers, p
             }
             else {
                 if (isDisqualify)
-                    return { isValid: false };
+                    return { isValid: false, availableClaimsNow: 0 };
             }
         }
         // Linked completions - wait for N linked entities to complete
         if (conditions?.linkedCompletions?.min) {
+            const baseMin = conditions.linkedCompletions.min;
             const currentCount = completionTrackers?.linkedCompletions || 0;
-            const scaledMin = conditions.linkedCompletions.min * claimMultiplier;
+            const scaledMin = baseMin * claimMultiplier;
             const isDisqualify = currentCount < scaledMin;
+            if (shouldScale && baseMin > 0) {
+                updateMax(Math.floor(currentCount / baseMin));
+            }
             if (addDetails) {
                 conditionData.push({
                     isMet: !isDisqualify,
@@ -2141,7 +2216,7 @@ const meetsCompletionConditions = ({ completionConditions, completionTrackers, p
             }
             else {
                 if (isDisqualify)
-                    return { isValid: false };
+                    return { isValid: false, availableClaimsNow: 0 };
             }
         }
         if (conditions?.dynamicTracker?.conditions?.length) {
@@ -2151,6 +2226,13 @@ const meetsCompletionConditions = ({ completionConditions, completionTrackers, p
                 ...conditions.dynamicTracker,
                 conditions: resolvedConditions,
             }, claimMultiplier);
+            if (shouldScale) {
+                const dynamicMax = getMaxClaimsForDynamicGroup(completionTrackers?.dynamicTracker || {}, {
+                    ...conditions.dynamicTracker,
+                    conditions: resolvedConditions,
+                }, playerOffer.claimedCount || 0);
+                updateMax(dynamicMax);
+            }
             if (addDetails) {
                 conditionData.push({
                     isMet: dynamicResult,
@@ -2162,7 +2244,7 @@ const meetsCompletionConditions = ({ completionConditions, completionTrackers, p
             }
             else {
                 if (!dynamicResult)
-                    return { isValid: false };
+                    return { isValid: false, availableClaimsNow: 0 };
             }
         }
         const r = meetsBaseConditions({
@@ -2173,9 +2255,18 @@ const meetsCompletionConditions = ({ completionConditions, completionTrackers, p
         });
         isValid = isValid && r.isValid;
         conditionData.push(...(r.conditionData || []));
-        return { isValid, conditionData };
-    }
-    return { isValid: true, conditionData: [] };
+        if (maxClaimCount && maxClaimCount > 0) {
+            updateMax(maxClaimCount);
+        }
+        const claimedCount = playerOffer.claimedCount || 0;
+        let availableClaimsNow = !isValid
+            ? 0
+            : maxTotalClaimsFromScaling === Infinity
+                ? -1
+                : Math.max(0, maxTotalClaimsFromScaling - claimedCount);
+        return { isValid, conditionData, availableClaimsNow };
+    }
+    return { isValid: true, conditionData: [], availableClaimsNow: -1 };
 };
 /**
  * Checks if completion conditions were met before a specific expiry time.
@@ -2340,26 +2431,30 @@ function evaluateDynamicCondition(dynamicObj, cond, claimMultiplier = 1) {
         }
     }
     const compareTo = isNumber ? Number(cond.compareTo) : String(cond.compareTo);
-    switch (cond.operator) {
-        case '==':
-            return val === compareTo;
-        case '!=':
-            return val !== compareTo;
-    }
     if (isNumber && typeof compareTo === 'number') {
+        const skipMultiplier = cond.operator === '==' || cond.operator === '!=';
+        const scaledCompareTo = skipMultiplier ? compareTo : compareTo * claimMultiplier;
         switch (cond.operator) {
+            case '==':
+                return val === scaledCompareTo;
+            case '!=':
+                return val !== scaledCompareTo;
             case '>':
-                return val > compareTo * claimMultiplier;
+                return val > scaledCompareTo;
             case '>=':
-                return val >= compareTo * claimMultiplier;
+                return val >= scaledCompareTo;
             case '<':
-                return val < compareTo * claimMultiplier;
+                return val < scaledCompareTo;
             case '<=':
-                return val <= compareTo * claimMultiplier;
+                return val <= scaledCompareTo;
         }
     }
     else if (!isNumber && typeof compareTo === 'string') {
         switch (cond.operator) {
+            case '==':
+                return val === compareTo;
+            case '!=':
+                return val !== compareTo;
             case 'has':
                 return val.includes(compareTo);
             case 'not_has':
@@ -2368,6 +2463,98 @@ function evaluateDynamicCondition(dynamicObj, cond, claimMultiplier = 1) {
     }
     return false;
 }
+/**
+ * Calculates the maximum number of claims supported by a single dynamic condition.
+ */
+function getMaxClaimsForDynamicCondition(dynamicObj, cond) {
+    if (!dynamicObj)
+        return 0;
+    const val = dynamicObj[cond.key];
+    if (val === undefined)
+        return 0;
+    if (typeof val === 'number') {
+        const base = Number(cond.compareTo);
+        if (isNaN(base)) {
+            return evaluateDynamicCondition(dynamicObj, cond, 1) ? Infinity : 0;
+        }
+        switch (cond.operator) {
+            case '>=':
+                if (base === 0)
+                    return val >= 0 ? Infinity : 0;
+                if (base < 0)
+                    return val >= base ? Infinity : 0;
+                return Math.max(0, Math.floor(val / base));
+            case '>':
+                if (base === 0)
+                    return val > 0 ? Infinity : 0;
+                if (base < 0)
+                    return val > base ? Infinity : 0;
+                if (val <= 0)
+                    return 0;
+                return Math.max(0, Math.ceil(val / base) - 1);
+            case '==':
+                return val === base ? Infinity : 0;
+            case '!=':
+                return val !== base ? Infinity : 0;
+            case '<=':
+                if (base === 0)
+                    return val <= 0 ? Infinity : 0;
+                if (base > 0)
+                    return evaluateDynamicCondition(dynamicObj, cond, 1) ? Infinity : 0;
+                if (val >= 0)
+                    return 0;
+                return Math.max(0, Math.floor(val / base));
+            case '<':
+                if (base === 0)
+                    return val < 0 ? Infinity : 0;
+                if (base > 0)
+                    return evaluateDynamicCondition(dynamicObj, cond, 1) ? Infinity : 0;
+                if (val >= 0)
+                    return 0;
+                return Math.max(0, Math.ceil(val / base) - 1);
+        }
+    }
+    // we don't scale the rest, they are always true or always false
+    return evaluateDynamicCondition(dynamicObj, cond, 1) ? Infinity : 0;
+}
+/**
+ * Calculates the maximum number of claims supported by a group of dynamic conditions.
+ */
+function getMaxClaimsForDynamicGroup(dynamicObj, dynamicGroup, currentClaimCount = 0) {
+    const { conditions, links } = dynamicGroup;
+    if (!conditions || conditions.length === 0)
+        return Infinity;
+    // AND only
+    if (!links || links.length === 0 || links.every((l) => l === 'AND')) {
+        let minClaims = Infinity;
+        for (const cond of conditions) {
+            const max = getMaxClaimsForDynamicCondition(dynamicObj, cond);
+            if (max === 0)
+                return 0;
+            minClaims = Math.min(minClaims, max);
+        }
+        return minClaims;
+    }
+    // OR only
+    if (links.every((l) => l === 'OR')) {
+        let maxClaims = 0;
+        for (const cond of conditions) {
+            const max = getMaxClaimsForDynamicCondition(dynamicObj, cond);
+            if (max === Infinity)
+                return Infinity;
+            maxClaims = Math.max(maxClaims, max);
+        }
+        return maxClaims;
+    }
+    // mixed:
+    const maxIterations = 100;
+    for (let n = currentClaimCount + 1; n <= currentClaimCount + maxIterations; n++) {
+        if (!meetsDynamicConditions(dynamicObj, dynamicGroup, n)) {
+            return n - 1;
+        }
+    }
+    return currentClaimCount + maxIterations;
+}
 /**
  * Evaluates a group of dynamic conditions with logical links (AND, OR, AND NOT).
  * @param dynamicObj - The player's dynamic object with any key and string or number value.
@@ -2476,6 +2663,8 @@ exports.OfferStore = OfferStore;
 exports.OfferwallClient = OfferwallClient;
 exports.PlayerOfferStatuses = PlayerOfferStatuses;
 exports.SSEConnection = SSEConnection;
+exports.getMaxClaimsForDynamicCondition = getMaxClaimsForDynamicCondition;
+exports.getMaxClaimsForDynamicGroup = getMaxClaimsForDynamicGroup;
 exports.hasConditions = hasConditions;
 exports.meetsBaseConditions = meetsBaseConditions;
 exports.meetsClaimableConditions = meetsClaimableConditions;