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

package/dist/offerwall-sdk.umd.js

@@ -634,25 +634,33 @@
     }
 
     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`);
         }
@@ -660,16 +668,23 @@
          * 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);
             }
@@ -678,26 +693,30 @@
         /**
          * 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' ||
@@ -708,14 +727,14 @@
         /**
          * 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
@@ -728,17 +747,29 @@
             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;
         }
     }
 
@@ -841,7 +872,9 @@
             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) {
@@ -897,6 +930,7 @@
         constructor(config) {
             this.isInitializing = false;
             this.pendingStackedToken = null;
+            this.selfId = null;
             this.config = {
                 autoConnect: config.autoConnect ?? false,
                 reconnect: config.reconnect ?? true,
@@ -909,7 +943,7 @@
             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);
@@ -950,6 +984,9 @@
         get assets() {
             return this.assetHelper;
         }
+        getSelfId() {
+            return this.selfId;
+        }
         /**
          * Initialize the offerwall client and connect
          */
@@ -1012,8 +1049,9 @@
             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();
             }
@@ -1021,8 +1059,8 @@
         /**
          * 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`);
             }
@@ -1037,7 +1075,7 @@
                 }
             }
             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, {
@@ -1093,7 +1131,7 @@
             });
             */
             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}`);
             });
         }
@@ -1123,23 +1161,27 @@
             }
             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');
             }
@@ -1148,9 +1190,10 @@
                 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');
@@ -1925,6 +1968,8 @@
             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;
@@ -1941,17 +1986,22 @@
                 }
                 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)
@@ -1959,17 +2009,22 @@
                 }
                 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)
@@ -1977,17 +2032,22 @@
                 }
                 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)
@@ -1995,7 +2055,7 @@
                 }
                 else {
                     if (isDisqualify)
-                        return { isValid: false };
+                        return { isValid: false, availableClaimsNow: 0 };
                 }
             }
             if (conditions?.login) {
@@ -2012,7 +2072,7 @@
                 }
                 else {
                     if (!isMet)
-                        return { isValid: false };
+                        return { isValid: false, availableClaimsNow: 0 };
                 }
             }
             if (conditions?.loginStreak) {
@@ -2032,7 +2092,7 @@
                 }
                 else {
                     if (isDisqualify)
-                        return { isValid: false };
+                        return { isValid: false, availableClaimsNow: 0 };
                 }
             }
             if (conditions?.social) {
@@ -2054,6 +2114,17 @@
                 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',
@@ -2125,14 +2196,18 @@
                 }
                 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,
@@ -2145,7 +2220,7 @@
                 }
                 else {
                     if (isDisqualify)
-                        return { isValid: false };
+                        return { isValid: false, availableClaimsNow: 0 };
                 }
             }
             if (conditions?.dynamicTracker?.conditions?.length) {
@@ -2155,6 +2230,13 @@
                     ...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,
@@ -2166,7 +2248,7 @@
                 }
                 else {
                     if (!dynamicResult)
-                        return { isValid: false };
+                        return { isValid: false, availableClaimsNow: 0 };
                 }
             }
             const r = meetsBaseConditions({
@@ -2177,9 +2259,18 @@
             });
             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.
@@ -2344,26 +2435,30 @@
             }
         }
         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':
@@ -2372,6 +2467,98 @@
         }
         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.
@@ -2480,6 +2667,8 @@
     exports.OfferwallClient = OfferwallClient;
     exports.PlayerOfferStatuses = PlayerOfferStatuses;
     exports.SSEConnection = SSEConnection;
+    exports.getMaxClaimsForDynamicCondition = getMaxClaimsForDynamicCondition;
+    exports.getMaxClaimsForDynamicGroup = getMaxClaimsForDynamicGroup;
     exports.hasConditions = hasConditions;
     exports.meetsBaseConditions = meetsBaseConditions;
     exports.meetsClaimableConditions = meetsClaimableConditions;