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

package/dist/index.js

@@ -601,22 +601,28 @@ class SSEConnection {
         }, 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;
@@ -1165,6 +1171,19 @@ class OfferwallClient {
     }
 }
 
+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;
@@ -1490,6 +1509,92 @@ const meetsBaseConditions = ({ conditions, playerSnap, addDetails, }) => {
             }
         }
     }
+    // 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, }) => {
@@ -1498,6 +1603,13 @@ const meetsSurfacingConditions = ({ surfacingConditions, playerSnap, context, pl
         // 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
@@ -1536,12 +1648,6 @@ const meetsSurfacingConditions = ({ surfacingConditions, playerSnap, context, pl
         (!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') {
@@ -1577,6 +1683,10 @@ const hasConditions = (conditions) => {
         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;
@@ -1596,6 +1706,12 @@ const hasConditions = (conditions) => {
         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;
@@ -1611,6 +1727,8 @@ const hasConditions = (conditions) => {
         return true;
     if (compCond.loginStreak)
         return true;
+    if (compCond.linkedCompletions)
+        return true;
     return false;
 };
 const meetsCompletionConditions = ({ completionConditions, completionTrackers, playerSnap, addDetails = false, }) => {
@@ -1724,51 +1842,107 @@ const meetsCompletionConditions = ({ completionConditions, completionTrackers, p
             }
         }
         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;
@@ -1789,6 +1963,136 @@ const meetsCompletionConditions = ({ completionConditions, completionTrackers, p
     }
     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.
@@ -1867,8 +2171,9 @@ function meetsDynamicConditions(dynamicObj, dynamicGroup) {
     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',
@@ -1883,12 +2188,26 @@ const rewardKinds = [
     '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,
@@ -1906,8 +2225,10 @@ exports.SSEConnection = SSEConnection;
 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;
 //# sourceMappingURL=index.js.map