@stackedapp/utils 1.17.2 → 1.17.3

package/dist/conditions.js

@@ -1155,24 +1155,101 @@ const meetsCompletionConditions = ({ completionConditions, completionTrackers, p
         // Evaluate contractInteractions completion trackers
         if (conditions?.contractInteractions) {
             for (const [conditionId, condition] of Object.entries(conditions.contractInteractions)) {
-                const baseAmount = condition.minAmount || 0;
-                const trackerGoal = baseAmount * claimMultiplier;
-                const trackerAmount = completionTrackers?.contractInteractions?.[conditionId] || 0;
-                const isDisqualify = trackerAmount < trackerGoal;
-                if (shouldScale && baseAmount > 0) {
-                    updateMax(Math.floor(trackerAmount / baseAmount));
+                // Tracker now stores { amount: number, count: number }
+                // Default to { amount: 0, count: 0 } if missing
+                const rawTracker = completionTrackers?.contractInteractions?.[conditionId];
+                const trackerData = rawTracker || { amount: 0, count: 0 };
+                const trackerAmount = trackerData.amount || 0;
+                const trackerCount = trackerData.count || 0;
+                // Goals
+                const minAmount = condition.minAmount ? condition.minAmount * claimMultiplier : 0;
+                const maxAmount = condition.maxAmount ? condition.maxAmount * claimMultiplier : undefined;
+                const minCount = condition.minCount ? condition.minCount * claimMultiplier : 0;
+                const maxCount = condition.maxCount ? condition.maxCount * claimMultiplier : undefined;
+                let isDisqualify = false;
+                // Check Amounts
+                if (shouldScale) {
+                    // If we have scaling (claimMultiplier), we handle max claims calculation differently
+                    // For now, assume standard validation
+                }
+                if (minAmount > 0 && trackerAmount < minAmount)
+                    isDisqualify = true;
+                if (maxAmount !== undefined && trackerAmount > maxAmount)
+                    isDisqualify = true;
+                // Check Counts
+                if (minCount > 0 && trackerCount < minCount)
+                    isDisqualify = true;
+                if (maxCount !== undefined && trackerCount > maxCount)
+                    isDisqualify = true;
+                if (shouldScale) {
+                    // Update max claims based on whatever allows the FEWEST claims
+                    // e.g. if I have enough Amount for 3 claims but enough Count for 1 claim, I can only make 1 claim.
+                    const possibleClaimsByAmount = condition.minAmount
+                        ? Math.floor(trackerAmount / condition.minAmount)
+                        : Number.MAX_SAFE_INTEGER;
+                    const possibleClaimsByCount = condition.minCount
+                        ? Math.floor(trackerCount / condition.minCount)
+                        : Number.MAX_SAFE_INTEGER;
+                    const possibleClaims = Math.min(possibleClaimsByAmount, possibleClaimsByCount);
+                    // Only update if we have at least ANY requirement (Amount or Count)
+                    // If both minAmount and minCount are 0/undefined, this logic might be weird, but usually one is set.
+                    if (condition.minAmount || condition.minCount) {
+                        updateMax(possibleClaims);
+                    }
                 }
                 if (addDetails) {
+                    // Determine primary metric for progress display 
+                    // If minAmount is set, use amount. Else use count.
+                    let current = trackerAmount;
+                    let goal = minAmount;
+                    let percent = 0;
+                    // If both are set, display percent based on the average of the two
+                    const hasMin = minAmount > 0 || minCount > 0;
+                    const hasMax = (maxAmount !== undefined && maxAmount > 0) || (maxCount !== undefined && maxCount > 0);
+                    if (!hasMin && hasMax) {
+                        // If only max is set: > 0 progress = 100%, else 0%
+                        const maxAmountSet = maxAmount !== undefined && maxAmount > 0;
+                        const maxCountSet = maxCount !== undefined && maxCount > 0;
+                        let pcts = [];
+                        if (maxAmountSet) {
+                            pcts.push(trackerAmount > 0 ? 100 : 0);
+                        }
+                        if (maxCountSet) {
+                            pcts.push(trackerCount > 0 ? 100 : 0);
+                        }
+                        if (pcts.length > 0) {
+                            percent = pcts.reduce((a, b) => a + b, 0) / pcts.length;
+                        }
+                        else {
+                            percent = 0;
+                        }
+                    }
+                    else if (minAmount > 0 && minCount > 0) {
+                        const pctAmount = calculatePercent(trackerAmount, minAmount, true); // clamp to 100
+                        const pctCount = calculatePercent(trackerCount, minCount, true);
+                        percent = (pctAmount + pctCount) / 2;
+                    }
+                    else if (minCount > 0) {
+                        current = trackerCount;
+                        goal = minCount;
+                        percent = calculatePercent(current, goal, !isDisqualify);
+                    }
+                    else {
+                        percent = calculatePercent(trackerAmount, minAmount || 0, !isDisqualify);
+                    }
                     const displayText = (0, template_1.renderTemplate)(condition.template, {
-                        current: trackerAmount,
-                        amount: trackerGoal,
+                        currentAmount: trackerAmount || 0,
+                        currentCount: trackerCount || 0,
+                        minAmount: minAmount || 0,
+                        maxAmount: maxAmount || 0,
+                        minCount: minCount || 0,
+                        maxCount: maxCount || 0,
                     });
                     conditionData.push({
                         isMet: !isDisqualify,
                         kind: 'contractInteractions',
                         trackerAmount,
-                        trackerGoal,
-                        percentCompleted: calculatePercent(trackerAmount, trackerGoal, !isDisqualify),
+                        percentCompleted: percent,
                         text: displayText,
                     });
                     if (isDisqualify)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stackedapp/utils",
-  "version": "1.17.2",
+  "version": "1.17.3",
   "description": "Public utilities for Stacked platform SDK",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -23,8 +23,8 @@
   "license": "ISC",
   "devDependencies": {
     "@semantic-release/commit-analyzer": "^13.0.1",
-    "@semantic-release/gitlab": "^13.2.9",
-    "@semantic-release/npm": "^13.1.3",
+    "@semantic-release/gitlab": "^13.3.0",
+    "@semantic-release/npm": "^13.1.4",
     "@semantic-release/release-notes-generator": "^14.1.0",
     "conventional-changelog-conventionalcommits": "^9.1.0"
   }