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

package/dist/index.js

@@ -1921,6 +1921,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 +1939,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 +1962,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 +1985,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 +2008,7 @@ const meetsCompletionConditions = ({ completionConditions, completionTrackers, p
             }
             else {
                 if (isDisqualify)
-                    return { isValid: false };
+                    return { isValid: false, availableClaimsNow: 0 };
             }
         }
         if (conditions?.login) {
@@ -2008,7 +2025,7 @@ const meetsCompletionConditions = ({ completionConditions, completionTrackers, p
             }
             else {
                 if (!isMet)
-                    return { isValid: false };
+                    return { isValid: false, availableClaimsNow: 0 };
             }
         }
         if (conditions?.loginStreak) {
@@ -2028,7 +2045,7 @@ const meetsCompletionConditions = ({ completionConditions, completionTrackers, p
             }
             else {
                 if (isDisqualify)
-                    return { isValid: false };
+                    return { isValid: false, availableClaimsNow: 0 };
             }
         }
         if (conditions?.social) {
@@ -2050,6 +2067,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 +2149,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 +2173,7 @@ const meetsCompletionConditions = ({ completionConditions, completionTrackers, p
             }
             else {
                 if (isDisqualify)
-                    return { isValid: false };
+                    return { isValid: false, availableClaimsNow: 0 };
             }
         }
         if (conditions?.dynamicTracker?.conditions?.length) {
@@ -2151,6 +2183,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 +2201,7 @@ const meetsCompletionConditions = ({ completionConditions, completionTrackers, p
             }
             else {
                 if (!dynamicResult)
-                    return { isValid: false };
+                    return { isValid: false, availableClaimsNow: 0 };
             }
         }
         const r = meetsBaseConditions({
@@ -2173,9 +2212,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 +2388,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 +2420,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 +2620,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;