@stackedapp/utils 1.23.2 → 1.23.3

package/dist/conditions/index.js

@@ -0,0 +1,338 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.meetsCompletionConditionsBeforeExpiry = exports.meetsCompletionConditions = exports.offerMeetsCompletionConditions = exports.meetsLinkedEntityOffersCondition = exports.hasCompletionConditions = exports.meetsBaseConditions = exports.getMaxClaimsForDynamicGroup = exports.getMaxClaimsForDynamicCondition = exports.meetsDynamicConditions = void 0;
+exports.meetsClaimableConditions = meetsClaimableConditions;
+const handlers_1 = require("./handlers");
+var helpers_1 = require("./helpers");
+Object.defineProperty(exports, "meetsDynamicConditions", { enumerable: true, get: function () { return helpers_1.meetsDynamicConditions; } });
+Object.defineProperty(exports, "getMaxClaimsForDynamicCondition", { enumerable: true, get: function () { return helpers_1.getMaxClaimsForDynamicCondition; } });
+Object.defineProperty(exports, "getMaxClaimsForDynamicGroup", { enumerable: true, get: function () { return helpers_1.getMaxClaimsForDynamicGroup; } });
+function evaluateBaseCondition(cond, ctx) {
+    switch (cond.kind) {
+        case 'daysInGame': return (0, handlers_1.evaluateDaysInGame)(cond, ctx);
+        case 'trustScore': return (0, handlers_1.evaluateTrustScore)(cond, ctx);
+        case 'level': return (0, handlers_1.evaluateLevel)(cond, ctx);
+        case 'currency': return (0, handlers_1.evaluateCurrency)(cond, ctx);
+        case 'stakedTokens': return (0, handlers_1.evaluateStakedTokens)(cond, ctx);
+        case 'loginStreak': return (0, handlers_1.evaluateLoginStreak)(cond, ctx);
+        case 'achievement': return (0, handlers_1.evaluateAchievement)(cond, ctx);
+        case 'membership': return (0, handlers_1.evaluateMembership)(cond, ctx);
+        case 'quest': return (0, handlers_1.evaluateQuest)(cond, ctx);
+        case 'entityLink': return (0, handlers_1.evaluateEntityLink)(cond, ctx);
+        case 'dynamic': return (0, handlers_1.evaluateDynamic)(cond, ctx);
+        case 'identifiers': return (0, handlers_1.evaluateIdentifiers)(cond, ctx);
+        case 'tokenBalance': return (0, handlers_1.evaluateTokenBalance)(cond, ctx);
+        case 'stackedAccount': return (0, handlers_1.evaluateStackedAccount)(cond, ctx);
+        case 'userSettings': return (0, handlers_1.evaluateUserSettings)(cond, ctx);
+        default: {
+            const _ = cond;
+            return undefined;
+        } // trick to refuse to compile if we don't handle a new condition kind
+    }
+}
+function evaluateCompletionOnlyCondition(cond, ctx) {
+    switch (cond.kind) {
+        case 'completionContext': return (0, handlers_1.evaluateCompletionContext)(cond, ctx);
+        case 'buyItem': return (0, handlers_1.evaluateBuyItem)(cond, ctx);
+        case 'spendCurrency': return (0, handlers_1.evaluateSpendCurrency)(cond, ctx);
+        case 'depositCurrency': return (0, handlers_1.evaluateDepositCurrency)(cond, ctx);
+        case 'login': return (0, handlers_1.evaluateLogin)(cond, ctx);
+        case 'social': return (0, handlers_1.evaluateSocial)(cond, ctx);
+        case 'linkedCompletions': return (0, handlers_1.evaluateLinkedCompletions)(cond, ctx);
+        case 'dynamicTracker': return (0, handlers_1.evaluateDynamicTracker)(cond, ctx);
+        case 'contractInteraction': return (0, handlers_1.evaluateContractInteraction)(cond, ctx);
+        // base kinds handled by evaluateBaseCondition
+        case 'level':
+        case 'currency':
+        case 'stakedTokens':
+        case 'trustScore':
+        case 'daysInGame':
+        case 'loginStreak':
+        case 'achievement':
+        case 'membership':
+        case 'quest':
+        case 'entityLink':
+        case 'dynamic':
+        case 'identifiers':
+        case 'tokenBalance':
+        case 'stackedAccount':
+        case 'userSettings':
+        case 'nested':
+            return undefined;
+        default: {
+            const _ = cond;
+            return undefined;
+        } // trick to refuse to compile if we don't handle a new condition kind
+    }
+}
+const meetsBaseConditions = ({ conditions, playerSnap, addDetails, playerOffer, additionalData, }) => {
+    const conditionData = [];
+    let isValid = true;
+    const ctx = {
+        snap: playerSnap,
+        additionalData,
+        offerTrackers: playerOffer?.trackers,
+        claimMultiplier: 1,
+        shouldScale: false,
+    };
+    for (const cond of conditions) {
+        if (cond.kind === 'nested')
+            continue; // handled separately if needed
+        const result = evaluateBaseCondition(cond, ctx);
+        if (!result)
+            continue; // not a base kind, skip
+        if (addDetails) {
+            conditionData.push(...result.details);
+            if (!result.isMet)
+                isValid = false;
+        }
+        else {
+            if (!result.isMet)
+                return { isValid: false, isComplete: false, percentCompleted: 0 };
+        }
+    }
+    const percentCompleted = conditionData.length > 0
+        ? conditionData.reduce((sum, c) => sum + c.percentCompleted, 0) / conditionData.length
+        : isValid ? 100 : 0;
+    return {
+        isValid,
+        isComplete: isValid,
+        percentCompleted,
+        conditionData: addDetails ? conditionData : undefined,
+    };
+};
+exports.meetsBaseConditions = meetsBaseConditions;
+const hasCompletionConditions = (conditions) => {
+    return !!conditions && conditions.length > 0;
+};
+exports.hasCompletionConditions = hasCompletionConditions;
+const meetsLinkedEntityOffersCondition = ({ linkedEntityOffers, matchingLinks, linkedPOfferMap, }) => {
+    if (!linkedPOfferMap)
+        return { isValid: false };
+    const linkedPlayerOffer_ids = [];
+    const targetOfferId = linkedEntityOffers.offerId || linkedEntityOffers.offer_id;
+    for (const link of matchingLinks) {
+        const key = `${link.playerId}:${targetOfferId}`;
+        const po = linkedPOfferMap.get(key);
+        if (po) {
+            linkedPlayerOffer_ids.push(po.instanceId.toString());
+        }
+    }
+    if (linkedPlayerOffer_ids.length > 0) {
+        return { isValid: true, linkedPlayerOffer_ids };
+    }
+    return { isValid: false };
+};
+exports.meetsLinkedEntityOffersCondition = meetsLinkedEntityOffersCondition;
+const offerMeetsCompletionConditions = (offer, snapshot, additionalData) => {
+    return (0, exports.meetsCompletionConditions)({
+        completionConditions: offer.completionConditions || [],
+        completionTrackers: offer.completionTrackers,
+        playerSnap: snapshot,
+        playerOffer: offer,
+        addDetails: true,
+        maxClaimCount: offer.maxClaimCount,
+        additionalData,
+    });
+};
+exports.offerMeetsCompletionConditions = offerMeetsCompletionConditions;
+const meetsCompletionConditions = ({ completionConditions, completionTrackers, playerSnap, playerOffer, addDetails = false, maxClaimCount, additionalData, }) => {
+    if (!completionConditions?.length) {
+        return { isValid: true, isComplete: true, percentCompleted: 100, conditionData: [], availableClaimsNow: -1 };
+    }
+    const shouldScale = maxClaimCount === -1 || (maxClaimCount != null && maxClaimCount > 1);
+    const claimMultiplier = shouldScale ? (playerOffer.trackers?.claimedCount || 0) + 1 : 1;
+    const conditionData = [];
+    let isValid = true;
+    let maxTotalClaimsFromScaling = Infinity;
+    const updateMax = (limit) => { maxTotalClaimsFromScaling = Math.min(maxTotalClaimsFromScaling, limit); };
+    const ctx = {
+        snap: playerSnap,
+        additionalData,
+        offerTrackers: playerOffer?.trackers,
+        completionTrackers,
+        claimMultiplier,
+        shouldScale,
+        offerCreatedAt: playerOffer?.createdAt,
+    };
+    for (const cond of completionConditions) {
+        if (cond.kind === 'nested')
+            continue; // TODO: handle nested
+        // Try completion-only handler first, then base handler
+        let result = evaluateCompletionOnlyCondition(cond, ctx);
+        if (!result)
+            result = evaluateBaseCondition(cond, ctx);
+        if (!result)
+            continue; // unknown kind
+        if (result.maxClaims !== undefined)
+            updateMax(result.maxClaims);
+        if (addDetails) {
+            conditionData.push(...result.details);
+            if (!result.isMet)
+                isValid = false;
+        }
+        else {
+            if (!result.isMet)
+                return { isValid: false, isComplete: false, percentCompleted: 0, availableClaimsNow: 0 };
+        }
+    }
+    if (maxClaimCount && maxClaimCount > 0)
+        updateMax(maxClaimCount);
+    const claimedCount = playerOffer?.trackers?.claimedCount || 0;
+    const availableClaimsNow = !isValid
+        ? 0
+        : maxTotalClaimsFromScaling === Infinity
+            ? -1
+            : Math.max(0, maxTotalClaimsFromScaling - claimedCount);
+    const percentCompleted = conditionData.length > 0
+        ? conditionData.reduce((sum, c) => sum + c.percentCompleted, 0) / conditionData.length
+        : isValid ? 100 : 0;
+    return {
+        isValid,
+        isComplete: isValid,
+        percentCompleted,
+        conditionData,
+        availableClaimsNow,
+    };
+};
+exports.meetsCompletionConditions = meetsCompletionConditions;
+const meetsCompletionConditionsBeforeExpiry = ({ completionConditions, completionTrackers, playerSnap, playerOffer, maxClaimCount, }) => {
+    if (!completionConditions)
+        return false;
+    if (!(0, exports.hasCompletionConditions)(completionConditions))
+        return false;
+    const conditionsMet = (0, exports.meetsCompletionConditions)({
+        completionConditions,
+        completionTrackers,
+        playerOffer,
+        playerSnap,
+        maxClaimCount,
+    });
+    if (!conditionsMet.isValid)
+        return false;
+    if (!playerOffer.expiresAt)
+        return true;
+    const expiryTime = new Date(playerOffer.expiresAt).getTime();
+    const lastSnapshotUpdate = new Date(playerSnap.snapshotLastUpdated ?? new Date()).getTime();
+    function wasUpdatedAfterExpiry(data) {
+        let lastUpdated;
+        if (typeof data === 'object' && data !== null && !(data instanceof Date)) {
+            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 {
+            lastUpdated = lastSnapshotUpdate;
+        }
+        return lastUpdated >= expiryTime;
+    }
+    for (const cond of completionConditions) {
+        switch (cond.kind) {
+            case 'currency':
+                if (playerSnap.currencies?.[cond.id] && wasUpdatedAfterExpiry(playerSnap.currencies[cond.id]))
+                    return false;
+                break;
+            case 'level':
+                if (playerSnap.levels?.[cond.id] && wasUpdatedAfterExpiry(playerSnap.levels[cond.id]))
+                    return false;
+                break;
+            case 'quest':
+                if (playerSnap.quests?.[cond.id] && wasUpdatedAfterExpiry(playerSnap.quests[cond.id]))
+                    return false;
+                break;
+            case 'membership':
+                if (playerSnap.memberships?.[cond.id] && wasUpdatedAfterExpiry(playerSnap.memberships[cond.id]))
+                    return false;
+                break;
+            case 'achievement':
+                if (playerSnap.achievements?.[cond.id] && wasUpdatedAfterExpiry(playerSnap.achievements[cond.id]))
+                    return false;
+                break;
+            case 'stakedTokens': {
+                const stakedToken = playerSnap.stakedTokens?.[cond.id];
+                if (stakedToken) {
+                    const lastStakeTime = new Date(stakedToken.lastStake ?? 0).getTime();
+                    const lastUnstakeTime = new Date(stakedToken.lastUnstake ?? 0).getTime();
+                    if (Math.max(lastStakeTime, lastUnstakeTime) >= expiryTime)
+                        return false;
+                }
+                break;
+            }
+            case 'trustScore':
+                if (wasUpdatedAfterExpiry(playerSnap.trustLastUpdated))
+                    return false;
+                break;
+            case 'daysInGame':
+                if (cond.min != null && wasUpdatedAfterExpiry(playerSnap.daysInGameLastUpdated))
+                    return false;
+                break;
+            case 'login':
+            case 'loginStreak':
+                if (wasUpdatedAfterExpiry())
+                    return false;
+                break;
+            case 'dynamic':
+                if (cond.conditions?.length && wasUpdatedAfterExpiry())
+                    return false;
+                break;
+            case 'identifiers':
+                if (cond.platforms?.length && wasUpdatedAfterExpiry())
+                    return false;
+                break;
+            case 'social':
+                if (completionTrackers?.social?.lastChecked) {
+                    if (wasUpdatedAfterExpiry(completionTrackers.social.lastChecked))
+                        return false;
+                }
+                break;
+            case 'buyItem':
+            case 'spendCurrency':
+            case 'depositCurrency':
+            case 'completionContext':
+            case 'linkedCompletions':
+            case 'contractInteraction':
+                if (completionTrackers?.lastUpdated != null && wasUpdatedAfterExpiry(completionTrackers.lastUpdated)) {
+                    return false;
+                }
+                break;
+            case 'dynamicTracker':
+                if (completionTrackers?.lastUpdated != null) {
+                    for (const dc of cond.conditions) {
+                        const perKeyTs = completionTrackers.dynamicTracker?.[dc.key]?.lastUpdated;
+                        if (wasUpdatedAfterExpiry(perKeyTs ?? completionTrackers.lastUpdated))
+                            return false;
+                    }
+                }
+                break;
+        }
+    }
+    return true;
+};
+exports.meetsCompletionConditionsBeforeExpiry = meetsCompletionConditionsBeforeExpiry;
+function meetsClaimableConditions({ claimableConditions, playerOfferTrackers, claimableTrackers, }) {
+    if (!claimableConditions?.length)
+        return { isValid: true };
+    for (const cond of claimableConditions) {
+        switch (cond.kind) {
+            case 'siblingCompletions': {
+                if (!cond.count)
+                    break;
+                const siblingCount = playerOfferTrackers?.siblingPlayerOffer_ids?.length ?? 0;
+                let completedCount = claimableTrackers?.siblingCompletions ?? 0;
+                if (completedCount === -1)
+                    completedCount = siblingCount;
+                if (siblingCount > 0 && completedCount < siblingCount) {
+                    return { isValid: false };
+                }
+                break;
+            }
+            // default: { const _: never = cond; break; } // trick to refuse to compile if we don't handle a new condition kind (when more cases)
+        }
+    }
+    return { isValid: true };
+}
+//# sourceMappingURL=index.js.map

package/dist/dynamic.d.ts

@@ -1,3 +1,3 @@
-import { StackedCompletionDynamicTracker } from '@stackedapp/types';
-export declare const dynamicTrackerToPrimitive: (dynaTrack: Record<string, StackedCompletionDynamicTracker>) => Record<string, string | number | boolean>;
+import { ICompletionDynamicTracker } from '@stackedapp/types';
+export declare const dynamicTrackerToPrimitive: (dynaTrack: Record<string, ICompletionDynamicTracker>) => Record<string, string | number | boolean>;
 //# sourceMappingURL=dynamic.d.ts.map

package/dist/template.d.ts

@@ -1,4 +1,4 @@
-import { StackedDynamicCondition } from '@stackedapp/types';
+import { IDynamicCondition } from '@stackedapp/types';
 export declare function extractTemplateKeys(template: string | undefined): Set<string>;
 /**
  * This replaces {keyName} keys from the template with corresponding values from the dynamic object.
@@ -12,7 +12,7 @@ export declare function renderTemplate(template: string | undefined, dynamic: Re
  */
 export declare function replaceDynamicConditionKey(key: string, trackers: Record<string, any> | undefined): string;
 /** this replaces all of the dynamic conditions.keys by calling replaceDynamicConditionKey */
-export declare function replaceDynamicConditionKeys(conditions: Array<StackedDynamicCondition>, trackers: Record<string, any> | undefined): {
+export declare function replaceDynamicConditionKeys(conditions: Array<IDynamicCondition>, trackers: Record<string, any> | undefined): {
     key: string;
     compareTo: string | number | boolean;
     operator: "==" | "!=" | ">" | ">=" | "<" | "<=" | "has" | "not_has" | "is_truthy" | "is_falsy" | "is_defined";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stackedapp/utils",
-  "version": "1.23.2",
+  "version": "1.23.3",
   "description": "Public utilities for Stacked platform SDK",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/dist/conditions.d.ts

@@ -1,130 +0,0 @@
-import { StackedCompletionConditions, StackedOffer, StackedSnapshot, StackedBaseUserExtra, StackedBaseConditions, StackedClaimableConditions, StackedClaimableTrackers, StackedCompletionTrackers, StackedDynamicCondition, StackedDynamicGroup, StackedOfferTrackers, ConditionDetail } from '@stackedapp/types';
-export declare const DEFAULT_ENTITY_KIND = "_default";
-export declare const meetsBaseConditions: ({ conditions, playerSnap, addDetails, playerOffer, additionalData, }: {
-    conditions: StackedBaseConditions;
-    playerSnap: StackedSnapshot;
-    addDetails?: boolean;
-    playerOffer?: {
-        createdAt?: Date | number;
-        claimedCount?: number;
-        trackers?: Record<string, any>;
-    };
-    additionalData?: StackedBaseUserExtra;
-}) => {
-    isValid: boolean;
-    isComplete: boolean;
-    percentCompleted: number;
-    conditionData?: undefined;
-} | {
-    /** @deprecated Use isComplete instead */
-    isValid: boolean;
-    isComplete: boolean;
-    percentCompleted: number;
-    conditionData: ConditionDetail[] | undefined;
-};
-export declare const hasCompletionConditions: (conditions: StackedCompletionConditions) => boolean;
-export declare const meetsLinkedEntityOffersCondition: ({ linkedEntityOffers, matchingLinks, linkedPOfferMap, }: {
-    linkedEntityOffers: {
-        kind?: string;
-        offer_id?: string;
-        link?: boolean;
-    };
-    matchingLinks: Array<{
-        playerId: string;
-        kind?: string;
-    }>;
-    linkedPOfferMap: Map<string, StackedOffer>;
-}) => {
-    isValid: boolean;
-    linkedPlayerOffer_ids?: string[];
-};
-export declare const offerMeetsCompletionConditions: (offer: StackedOffer, snapshot: StackedSnapshot, additionalData?: StackedBaseUserExtra) => {
-    isValid: boolean;
-    isComplete: boolean;
-    percentCompleted: number;
-    availableClaimsNow: number;
-    conditionData?: undefined;
-} | {
-    /** @deprecated Use isComplete instead */
-    isValid: boolean;
-    isComplete: boolean;
-    percentCompleted: number;
-    conditionData: ConditionDetail[];
-    availableClaimsNow: number;
-};
-export declare const meetsCompletionConditions: ({ completionConditions, completionTrackers, playerSnap, playerOffer, addDetails, maxClaimCount, additionalData, }: {
-    completionConditions: StackedCompletionConditions;
-    completionTrackers?: StackedCompletionTrackers;
-    playerSnap: StackedSnapshot;
-    playerOffer: {
-        createdAt?: Date | number;
-        trackers?: StackedOfferTrackers;
-    };
-    addDetails?: boolean;
-    maxClaimCount?: number;
-    additionalData?: StackedBaseUserExtra;
-}) => {
-    isValid: boolean;
-    isComplete: boolean;
-    percentCompleted: number;
-    availableClaimsNow: number;
-    conditionData?: undefined;
-} | {
-    /** @deprecated Use isComplete instead */
-    isValid: boolean;
-    isComplete: boolean;
-    percentCompleted: number;
-    conditionData: ConditionDetail[];
-    availableClaimsNow: number;
-};
-/**
- * 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
- * @returns true if all conditions were met before expiry, false otherwise
- */
-export declare const meetsCompletionConditionsBeforeExpiry: ({ completionConditions, completionTrackers, playerSnap, playerOffer, maxClaimCount, }: {
-    completionConditions: StackedCompletionConditions;
-    completionTrackers?: StackedCompletionTrackers;
-    playerSnap: StackedSnapshot;
-    playerOffer: {
-        createdAt?: Date | number;
-        claimedCount?: number;
-        trackers?: Record<string, any>;
-        expiresAt?: Date | number | string;
-    };
-    maxClaimCount?: number;
-}) => boolean;
-/**
- * Calculates the maximum number of claims supported by a single dynamic condition.
- */
-export declare function getMaxClaimsForDynamicCondition(dynamicObj: Record<string, string | number | boolean>, cond: StackedDynamicCondition): number;
-/**
- * Calculates the maximum number of claims supported by a group of dynamic conditions.
- */
-export declare function getMaxClaimsForDynamicGroup(dynamicObj: Record<string, string | number | boolean>, dynamicGroup: StackedDynamicGroup, currentClaimCount?: number): number;
-/**
- * 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.
- * @param dynamicGroup - The group of conditions and links to check.
- * @param claimMultiplier - Multiplier to scale conditions (used for numeric comparisons).
- * @returns true if the group evaluates to true, false otherwise.
- */
-export declare function meetsDynamicConditions(dynamicObj: Record<string, string | number | boolean> | undefined | null, dynamicGroup: StackedDynamicGroup, claimMultiplier?: number): boolean;
-/**
- * Checks if a PlayerOffer meets its claimable conditions (completed -> claimable transition).
- * @param claimableConditions - The offer's claimableConditions (from IOffer)
- * @param claimableTrackers - The player offer's claimableTrackers
- */
-export declare function meetsClaimableConditions({ claimableConditions, playerOfferTrackers, claimableTrackers, }: {
-    claimableConditions?: StackedClaimableConditions;
-    playerOfferTrackers?: StackedOfferTrackers;
-    claimableTrackers?: StackedClaimableTrackers;
-}): {
-    isValid: boolean;
-};
-export declare function aggregateTokenBalances(data?: StackedBaseUserExtra): Record<string, number>;
-//# sourceMappingURL=conditions.d.ts.map