@stackedapp/utils 1.17.2 → 1.17.4

package/dist/conditions.js

@@ -16,6 +16,7 @@ const calculatePercent = (amount, goal, isMet) => {
     }
     return isMet ? 100 : 0;
 };
+const formatList = (items) => items.length === 2 ? items.join(' and ') : `${items.slice(0, -1).join(', ')}, and ${items.at(-1)}`;
 const calculateDynamicConditionPercent = (dynamicObj, cond) => {
     if (!dynamicObj)
         return 0;
@@ -451,7 +452,7 @@ additionalData, }) => {
         }
     }
     // Validate link count conditions
-    if (conditions?.links && 'entityLinks' in playerSnap) {
+    if (conditions?.links) {
         for (const [linkType, constraint] of Object.entries(conditions.links)) {
             // linkType should always exist. and be default is none was specified
             const linkCount = playerSnap.entityLinks?.filter((link) => (link.kind || exports.DEFAULT_ENTITY_KIND) === linkType).length || 0;
@@ -553,19 +554,30 @@ additionalData, }) => {
                 return { isValid: false, isComplete: false, percentCompleted: 0 };
         }
     }
-    if (conditions?.identifiers?.platforms?.length && 'identifiers' in playerSnap) {
+    if (conditions?.identifiers?.platforms?.length) {
         const playerPlatforms = new Set(playerSnap.identifiers?.map((i) => i.platform.toLowerCase()) || []);
         const isAndBehaviour = conditions.identifiers.behaviour === 'AND';
         const platformsToCheck = conditions.identifiers.platforms;
         let isMet;
         let displayText;
+        const platformsMap = {
+            sms: 'SMS',
+            email: 'Email',
+            apple: 'Apple',
+            google: 'Google',
+            tiktok: 'TikTok',
+        };
+        const metAndPlatforms = platformsToCheck.filter((platform) => playerPlatforms.has(platform.toLowerCase()));
         if (isAndBehaviour) {
-            isMet = platformsToCheck.every((platform) => playerPlatforms.has(platform.toLowerCase()));
-            displayText = `Link all: ${platformsToCheck.join(', ')}`;
+            isMet = metAndPlatforms.length === platformsToCheck.length;
+            displayText =
+                platformsToCheck.length > 1
+                    ? `Link your ${formatList(platformsToCheck.map((p) => platformsMap[p.toLowerCase()] ?? p))} accounts`
+                    : `Link your ${platformsMap[platformsToCheck[0].toLowerCase()] ?? platformsToCheck[0]} account`;
         }
         else {
             isMet = platformsToCheck.some((platform) => playerPlatforms.has(platform.toLowerCase()));
-            displayText = `Link any: ${platformsToCheck.join(', ')}`;
+            displayText = `Link any of your ${formatList(platformsToCheck.map((p) => platformsMap[p.toLowerCase()] ?? p))} accounts`;
         }
         if (addDetails) {
             conditionData.push({
@@ -573,7 +585,11 @@ additionalData, }) => {
                 kind: 'identifiers',
                 trackerAmount: isMet ? 1 : 0,
                 trackerGoal: 1,
-                percentCompleted: isMet ? 100 : 0, // Binary
+                percentCompleted: isAndBehaviour
+                    ? calculatePercent(metAndPlatforms.length, platformsToCheck.length, isMet)
+                    : isMet
+                        ? 100
+                        : 0,
                 text: displayText,
             });
             if (!isMet)
@@ -1155,24 +1171,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.4",
   "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"
   }