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

package/dist/offerwall-sdk.umd.js

@@ -1925,6 +1925,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 +1943,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 +1966,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 +1989,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 +2012,7 @@
                 }
                 else {
                     if (isDisqualify)
-                        return { isValid: false };
+                        return { isValid: false, availableClaimsNow: 0 };
                 }
             }
             if (conditions?.login) {
@@ -2012,7 +2029,7 @@
                 }
                 else {
                     if (!isMet)
-                        return { isValid: false };
+                        return { isValid: false, availableClaimsNow: 0 };
                 }
             }
             if (conditions?.loginStreak) {
@@ -2032,7 +2049,7 @@
                 }
                 else {
                     if (isDisqualify)
-                        return { isValid: false };
+                        return { isValid: false, availableClaimsNow: 0 };
                 }
             }
             if (conditions?.social) {
@@ -2054,6 +2071,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 +2153,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 +2177,7 @@
                 }
                 else {
                     if (isDisqualify)
-                        return { isValid: false };
+                        return { isValid: false, availableClaimsNow: 0 };
                 }
             }
             if (conditions?.dynamicTracker?.conditions?.length) {
@@ -2155,6 +2187,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 +2205,7 @@
                 }
                 else {
                     if (!dynamicResult)
-                        return { isValid: false };
+                        return { isValid: false, availableClaimsNow: 0 };
                 }
             }
             const r = meetsBaseConditions({
@@ -2177,9 +2216,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 +2392,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 +2424,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 +2624,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;