@pixels-online/pixels-client-js-sdk 1.13.0 → 1.15.0

package/dist/offerwall-sdk.umd.js

@@ -605,22 +605,28 @@
             }, backoffDelay);
         }
         disconnect() {
-            if (this.reconnectTimeout) {
-                clearTimeout(this.reconnectTimeout);
-                this.reconnectTimeout = null;
+            try {
+                if (this.reconnectTimeout) {
+                    clearTimeout(this.reconnectTimeout);
+                    this.reconnectTimeout = null;
+                }
+                if (this.eventSource) {
+                    this.logger.log('Closing SSE connection');
+                    this.eventSource.close();
+                    this.eventSource = null;
+                    this.setConnectionState(exports.ConnectionState.DISCONNECTED);
+                    this.eventEmitter.emit(exports.OfferEvent.DISCONNECTED, {
+                        reason: 'manual',
+                        timestamp: new Date(),
+                    });
+                }
+                this.isConnecting = false;
+                this.reconnectAttempts = 0;
             }
-            if (this.eventSource) {
-                this.logger.log('Closing SSE connection');
-                this.eventSource.close();
-                this.eventSource = null;
-                this.setConnectionState(exports.ConnectionState.DISCONNECTED);
-                this.eventEmitter.emit(exports.OfferEvent.DISCONNECTED, {
-                    reason: 'manual',
-                    timestamp: new Date(),
-                });
+            catch (error) {
+                // should be safe to ignore, likely mid-stream error during disconnect
+                this.logger.log('Error during disconnect:', error);
             }
-            this.isConnecting = false;
-            this.reconnectAttempts = 0;
         }
         isConnected() {
             return this.eventSource?.getReadyState() === ReadyState.OPEN;
@@ -1169,6 +1175,19 @@
         }
     }
 
+    const keyPattern = /\{([a-zA-Z_][a-zA-Z0-9_]*)\}/g;
+    // renders template by replacing {keyName} with values from dynamic
+    function renderTemplate(template, dynamic) {
+        if (!template)
+            return '';
+        return template.replace(keyPattern, (match, key) => {
+            if (dynamic && dynamic[key] !== undefined) {
+                return String(dynamic[key]);
+            }
+            return '{?}'; // indicate missing key
+        });
+    }
+
     const meetsBaseConditions = ({ conditions, playerSnap, addDetails, }) => {
         const conditionData = [];
         let isValid = true;
@@ -1494,6 +1513,92 @@
                 }
             }
         }
+        // Validate link count conditions
+        if (conditions?.links) {
+            for (const [linkType, constraint] of Object.entries(conditions.links)) {
+                const linkCount = playerSnap.entityLinks?.filter((link) => link.kind === linkType).length || 0;
+                if (constraint.min !== undefined) {
+                    const isDisqualify = linkCount < constraint.min;
+                    if (addDetails) {
+                        conditionData.push({
+                            isMet: !isDisqualify,
+                            kind: 'links',
+                            trackerAmount: linkCount,
+                            text: `At least ${constraint.min} ${linkType} link(s)`,
+                        });
+                        if (isDisqualify)
+                            isValid = false;
+                    }
+                    else {
+                        if (isDisqualify)
+                            return { isValid: false };
+                    }
+                }
+                if (constraint.max !== undefined) {
+                    const isDisqualify = linkCount > constraint.max;
+                    if (addDetails) {
+                        conditionData.push({
+                            isMet: !isDisqualify,
+                            kind: 'links',
+                            trackerAmount: linkCount,
+                            text: `At most ${constraint.max} ${linkType} link(s)`,
+                        });
+                        if (isDisqualify)
+                            isValid = false;
+                    }
+                    else {
+                        if (isDisqualify)
+                            return { isValid: false };
+                    }
+                }
+            }
+        }
+        // Evaluate dynamic conditions
+        if (conditions?.dynamic?.conditions?.length) {
+            const dynamicResult = meetsDynamicConditions(playerSnap.dynamic || {}, conditions.dynamic);
+            if (addDetails) {
+                conditionData.push({
+                    isMet: dynamicResult,
+                    kind: 'dynamic',
+                    text: renderTemplate(conditions.dynamic.template, playerSnap.dynamic) ||
+                        'Dynamic conditions',
+                });
+                if (!dynamicResult)
+                    isValid = false;
+            }
+            else {
+                if (!dynamicResult)
+                    return { isValid: false };
+            }
+        }
+        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;
+            if (isAndBehaviour) {
+                isMet = platformsToCheck.every((platform) => playerPlatforms.has(platform.toLowerCase()));
+                displayText = `Link all: ${platformsToCheck.join(', ')}`;
+            }
+            else {
+                isMet = platformsToCheck.some((platform) => playerPlatforms.has(platform.toLowerCase()));
+                displayText = `Link any: ${platformsToCheck.join(', ')}`;
+            }
+            if (addDetails) {
+                conditionData.push({
+                    isMet,
+                    kind: 'identifiers',
+                    text: displayText,
+                });
+                if (!isMet)
+                    isValid = false;
+            }
+            else {
+                if (!isMet)
+                    return { isValid: false };
+            }
+        }
         return { isValid, conditionData: addDetails ? conditionData : undefined };
     };
     const meetsSurfacingConditions = ({ surfacingConditions, playerSnap, context, playerOffers, }) => {
@@ -1502,6 +1607,13 @@
             // context is not in the list of surfacing contexts, so we don't want to surface this offer
             return { isValid: false };
         }
+        if (surfacingConditions?.targetEntityTypes?.length) {
+            const playerTarget = playerSnap.target || 'default';
+            // check if entity type is allowed
+            if (!surfacingConditions.targetEntityTypes.includes(playerTarget)) {
+                return { isValid: false };
+            }
+        }
         const conditions = surfacingConditions;
         if (conditions?.andTags?.length) {
             // check if player has all of the tags
@@ -1540,12 +1652,6 @@
             (!playerSnap.dateSignedUp || playerSnap.dateSignedUp > conditions.maxDateSignedUp)) {
             return { isValid: false };
         }
-        // Check dynamic conditions if present
-        if (conditions.dynamic?.conditions?.length) {
-            if (!meetsDynamicConditions(playerSnap.dynamic || {}, conditions.dynamic)) {
-                return { isValid: false };
-            }
-        }
         const completedOfferIds = new Set();
         for (const pOffer of playerOffers?.values() || []) {
             if (pOffer.status === 'claimed' || pOffer.status === 'claimable') {
@@ -1581,6 +1687,10 @@
             return true;
         if (conditions.minDaysInGame)
             return true;
+        if (conditions.dynamic?.conditions?.length)
+            return true;
+        if (conditions.identifiers?.platforms?.length)
+            return true;
         const surCond = conditions;
         if (surCond.contexts?.length)
             return true;
@@ -1600,6 +1710,12 @@
             return true;
         if (surCond.completedOffers?.length)
             return true;
+        if (surCond.programmatic)
+            return true;
+        if (surCond.targetEntityTypes?.length)
+            return true;
+        if (surCond.links && Object.keys(surCond.links).length > 0)
+            return true;
         const compCond = conditions;
         if (compCond.context)
             return true;
@@ -1615,6 +1731,8 @@
             return true;
         if (compCond.loginStreak)
             return true;
+        if (compCond.linkedCompletions)
+            return true;
         return false;
     };
     const meetsCompletionConditions = ({ completionConditions, completionTrackers, playerSnap, addDetails = false, }) => {
@@ -1728,51 +1846,107 @@
                 }
             }
             if (conditions?.social) {
-                const hasAttachedContent = !!completionTrackers?.social?.videoId;
                 const tSocial = completionTrackers?.social;
                 const cSocial = completionConditions.social;
-                let isDisqualify = !hasAttachedContent;
-                if (cSocial?.minLikes && tSocial && (tSocial.likes || 0) < cSocial.minLikes) {
-                    isDisqualify = true;
-                }
-                if (cSocial?.minViews && tSocial && (tSocial.views || 0) < cSocial.minViews) {
-                    isDisqualify = true;
-                }
-                if (cSocial?.minComments && tSocial && (tSocial.comments || 0) < cSocial.minComments) {
+                const mode = cSocial?.mode || 'attach';
+                const hasContent = Boolean(mode === 'accumulate'
+                    ? tSocial?.mode === 'accumulate'
+                    : tSocial && tSocial.mode !== 'accumulate' && !!tSocial.videoId);
+                const minLikes = cSocial?.minLikes || 0;
+                const minViews = cSocial?.minViews || 0;
+                const minComments = cSocial?.minComments || 0;
+                const likes = tSocial?.likes || 0;
+                const views = tSocial?.views || 0;
+                const comments = tSocial?.comments || 0;
+                let isDisqualify = !hasContent;
+                if (likes < minLikes || views < minViews || comments < minComments) {
                     isDisqualify = true;
                 }
                 if (addDetails) {
-                    // Build detailed text about requirements
                     const platformMap = {
-                        'tiktok': 'TikTok',
-                        'instagram': 'Instagram',
-                        'youtube': 'YouTube',
+                        tiktok: 'TikTok',
+                        instagram: 'Instagram',
+                        youtube: 'YouTube',
                     };
-                    const platformText = conditions.social.platforms.map(platform => platformMap[platform]).join(' | ');
-                    let displayText = `Attach a ${platformText} post`;
-                    if (hasAttachedContent && tSocial) {
-                        let socialTexts = [];
-                        if (cSocial?.minLikes ?? 0 > 0) {
-                            socialTexts.push(`${cSocial.minLikes} Likes (${tSocial.likes}/${cSocial.minLikes})`);
-                        }
-                        if (cSocial?.minViews ?? 0 > 0) {
-                            socialTexts.push(`${cSocial.minViews} Views (${tSocial.views}/${cSocial.minViews})`);
-                        }
-                        if (cSocial?.minComments ?? 0 > 0) {
-                            socialTexts.push(`${cSocial.minComments} Comments (${tSocial.comments}/${cSocial.minComments})`);
-                        }
-                        displayText = `Reach:\n${socialTexts.join('\n')}`;
+                    const platformText = conditions.social.platforms
+                        .map((platform) => platformMap[platform])
+                        .join(' | ');
+                    const requiredWords = cSocial?.requiredWords ?? [];
+                    if (mode === 'accumulate') {
+                        const matchCount = (tSocial?.mode === 'accumulate' && tSocial.matchCount) || 0;
+                        conditionData.push({
+                            isMet: hasContent,
+                            kind: 'social',
+                            trackerAmount: matchCount,
+                            text: hasContent
+                                ? `Found ${matchCount} matching ${platformText} post${matchCount !== 1 ? 's' : ''}`
+                                : requiredWords.length > 0
+                                    ? `Post ${platformText} content with ${requiredWords.map((w) => `"${w}"`).join(', ')}`
+                                    : `Post ${platformText} content`,
+                        });
+                    }
+                    else {
+                        const title = (tSocial && tSocial.mode !== 'accumulate' && tSocial.title) || undefined;
+                        conditionData.push({
+                            isMet: hasContent,
+                            kind: 'social',
+                            trackerAmount: 0,
+                            text: !hasContent
+                                ? requiredWords.length > 0
+                                    ? `Attach a ${platformText} post with ${requiredWords.map((w) => `"${w}"`).join(', ')} in the title`
+                                    : `Attach a ${platformText} post`
+                                : `Attached: ${title}`,
+                        });
                     }
-                    const trackerAmount = (cSocial?.minViews ?? 0) > 0 && (tSocial?.likes ?? 0) < (cSocial.minLikes ?? 0)
-                        ? (tSocial?.likes ?? 0)
-                        : (cSocial?.minComments ?? 0) > 0 && (tSocial?.comments ?? 0) < (cSocial.minComments ?? 0)
-                            ? (tSocial?.comments ?? 0)
-                            : (tSocial?.views ?? 0);
+                    if (minLikes > 0) {
+                        conditionData.push({
+                            isMet: hasContent && likes >= minLikes,
+                            kind: 'social',
+                            trackerAmount: likes,
+                            text: mode === 'accumulate'
+                                ? `Combined ${minLikes} Likes`
+                                : `Reach ${minLikes} Likes`,
+                        });
+                    }
+                    if (minViews > 0) {
+                        conditionData.push({
+                            isMet: hasContent && views >= minViews,
+                            kind: 'social',
+                            trackerAmount: views,
+                            text: mode === 'accumulate'
+                                ? `Combined ${minViews} Views`
+                                : `Reach ${minViews} Views`,
+                        });
+                    }
+                    if (minComments > 0) {
+                        conditionData.push({
+                            isMet: hasContent && comments >= minComments,
+                            kind: 'social',
+                            trackerAmount: comments,
+                            text: mode === 'accumulate'
+                                ? `Combined ${minComments} Comments`
+                                : `Reach ${minComments} Comments`,
+                        });
+                    }
+                    if (isDisqualify)
+                        isValid = false;
+                }
+                else {
+                    if (isDisqualify)
+                        return { isValid: false };
+                }
+            }
+            // Linked completions - wait for N linked entities to complete
+            if (conditions?.linkedCompletions?.min) {
+                const currentCount = completionTrackers?.linkedCompletions || 0;
+                const requiredCount = conditions.linkedCompletions.min;
+                const isDisqualify = currentCount < requiredCount;
+                if (addDetails) {
                     conditionData.push({
-                        isMet: hasAttachedContent,
-                        kind: 'social',
-                        trackerAmount,
-                        text: displayText,
+                        isMet: !isDisqualify,
+                        kind: 'linkedCompletions',
+                        trackerAmount: currentCount,
+                        text: `Wait for ${requiredCount} linked ${requiredCount === 1 ? 'entity' : 'entities'} to complete`,
                     });
                     if (isDisqualify)
                         isValid = false;
@@ -1793,6 +1967,136 @@
         }
         return { isValid: true, conditionData: [] };
     };
+    /**
+     * Checks if completion conditions were met before a specific expiry time.
+     * Returns true if all relevant condition fields were updated before expiryTime.
+     *
+     * @param completionConditions - The completion conditions to check
+     * @param completionTrackers - The completion trackers (for buyItem, spendCurrency, etc.)
+     * @param playerSnap - The player snapshot with field timestamps
+     * @param expiryTime - The expiry timestamp in milliseconds
+     * @returns true if all conditions were met before expiry, false otherwise
+     */
+    const meetsCompletionConditionsBeforeExpiry = ({ completionConditions, completionTrackers, playerSnap, expiryTime, }) => {
+        if (!completionConditions)
+            return false;
+        // Check if there are actually any conditions to evaluate
+        if (!hasConditions(completionConditions))
+            return false;
+        // First check if conditions are actually met
+        const conditionsMet = meetsCompletionConditions({
+            completionConditions,
+            completionTrackers,
+            playerSnap,
+        });
+        if (!conditionsMet.isValid)
+            return false;
+        const lastSnapshotUpdate = new Date(playerSnap.snapshotLastUpdated).getTime();
+        /**
+         * Checks if a field was updated after the expiry time.
+         * Returns true if updated AFTER or AT expiry (violates grace period).
+         * Returns false if updated BEFORE expiry (allows grace period).
+         */
+        function wasUpdatedAfterExpiry(data) {
+            let lastUpdated;
+            if (typeof data === 'object' && data !== null && !(data instanceof Date)) {
+                // Object with optional lastUpdated field
+                lastUpdated = data.lastUpdated
+                    ? new Date(data.lastUpdated).getTime()
+                    : lastSnapshotUpdate;
+            }
+            else if (data instanceof Date) {
+                lastUpdated = data.getTime();
+            }
+            else if (typeof data === 'string' || typeof data === 'number') {
+                lastUpdated = new Date(data).getTime();
+            }
+            else {
+                // No data provided, use snapshot timestamp
+                lastUpdated = lastSnapshotUpdate;
+            }
+            return lastUpdated >= expiryTime;
+        }
+        if (completionConditions.currencies) {
+            for (const currencyId in completionConditions.currencies) {
+                const currency = playerSnap.currencies?.[currencyId];
+                if (!currency)
+                    continue;
+                if (wasUpdatedAfterExpiry(currency))
+                    return false;
+            }
+        }
+        if (completionConditions.levels) {
+            for (const skillId in completionConditions.levels) {
+                const level = playerSnap.levels?.[skillId];
+                if (!level)
+                    continue;
+                if (wasUpdatedAfterExpiry(level))
+                    return false;
+            }
+        }
+        if (completionConditions.quests) {
+            for (const questId in completionConditions.quests) {
+                const quest = playerSnap.quests?.[questId];
+                if (!quest)
+                    continue;
+                if (wasUpdatedAfterExpiry(quest))
+                    return false;
+            }
+        }
+        if (completionConditions.memberships) {
+            for (const membershipId in completionConditions.memberships) {
+                const membership = playerSnap.memberships?.[membershipId];
+                if (!membership)
+                    continue;
+                if (wasUpdatedAfterExpiry(membership))
+                    return false;
+            }
+        }
+        if (completionConditions.achievements) {
+            for (const achievementId in completionConditions.achievements) {
+                const achievement = playerSnap.achievements?.[achievementId];
+                if (!achievement)
+                    continue;
+                if (wasUpdatedAfterExpiry(achievement))
+                    return false;
+            }
+        }
+        if (completionConditions.stakedTokens) {
+            for (const tokenId in completionConditions.stakedTokens) {
+                const stakedToken = playerSnap.stakedTokens?.[tokenId];
+                if (!stakedToken)
+                    continue;
+                const lastStakeTime = new Date(stakedToken.lastStake ?? 0).getTime();
+                const lastUnstakeTime = new Date(stakedToken.lastUnstake ?? 0).getTime();
+                const lastUpdated = Math.max(lastStakeTime, lastUnstakeTime);
+                if (lastUpdated >= expiryTime)
+                    return false;
+            }
+        }
+        if (completionConditions.minTrustScore !== undefined ||
+            completionConditions.maxTrustScore !== undefined) {
+            if (wasUpdatedAfterExpiry(playerSnap.trustLastUpdated))
+                return false;
+        }
+        if (completionConditions.minDaysInGame !== undefined) {
+            if (wasUpdatedAfterExpiry(playerSnap.daysInGameLastUpdated))
+                return false;
+        }
+        if (completionConditions.login || completionConditions.loginStreak) {
+            if (wasUpdatedAfterExpiry())
+                return false;
+        }
+        if (completionConditions.social) {
+            // Check if social content was attached/validated after expiry
+            if (completionTrackers?.social?.lastChecked) {
+                if (wasUpdatedAfterExpiry(completionTrackers.social.lastChecked))
+                    return false;
+            }
+        }
+        // All conditions were met before expiry
+        return true;
+    };
     /**
      * Checks if a dynamic object meets a set of dynamic field conditions.
      * @param dynamicObj - The object with any key and string or number value.
@@ -1871,8 +2175,9 @@
         return result;
     }
 
+    const offerListenerEvents = ['claim_offer'];
     const PlayerOfferStatuses = [
-        'inQueue',
+        // 'inQueue', // fuck this shit. just don't surface offers if their offer plate is full.
         'surfaced',
         'viewed',
         'claimable',
@@ -1887,12 +2192,26 @@
         'exp',
         'trust_points',
         'loyalty_currency', // loyalty currency that the player can exchange for rewards like on-chain via withdraw, etc.
+        'discount', // handled by the external dev, using the rewardId to identify what it is for in their system
         /** on-chain rewards require the builder to send funds to a custodial wallet that we use to send to player wallets*/
     ];
     const rewardSchema = {
         _id: false,
         kind: { type: String, enum: rewardKinds },
-        rewardId: String,
+        rewardId: {
+            type: String,
+            validate: {
+                validator: function (value) {
+                    // Require rewardId for item, coins, loyalty_currency, exp, and discount kinds
+                    const requiresRewardId = ['item', 'coins', 'loyalty_currency', 'exp', 'discount'].includes(this.kind);
+                    if (requiresRewardId) {
+                        return !!value;
+                    }
+                    return true;
+                },
+                message: 'rewardId is required for reward kinds: item, coins, loyalty_currency, exp, and discount',
+            },
+        },
         skillId: String,
         currencyId: String, // could be a loyalty currency
         itemId: String,
@@ -1910,8 +2229,10 @@
     exports.hasConditions = hasConditions;
     exports.meetsBaseConditions = meetsBaseConditions;
     exports.meetsCompletionConditions = meetsCompletionConditions;
+    exports.meetsCompletionConditionsBeforeExpiry = meetsCompletionConditionsBeforeExpiry;
     exports.meetsDynamicConditions = meetsDynamicConditions;
     exports.meetsSurfacingConditions = meetsSurfacingConditions;
+    exports.offerListenerEvents = offerListenerEvents;
     exports.rewardKinds = rewardKinds;
     exports.rewardSchema = rewardSchema;