@stackedapp/utils 1.23.2 → 1.23.4

package/dist/conditions/helpers.d.ts

@@ -0,0 +1,11 @@
+import { IDynamicCondition, IDynamicGroup, StackedBaseUserExtra } from '@stackedapp/types';
+export declare const calculatePercent: (amount: number | undefined, goal: number | undefined, isMet: boolean) => number;
+export declare const formatList: (items: string[]) => string;
+export declare const calculateDynamicConditionPercent: (dynamicObj: Record<string, string | number | boolean> | undefined, cond: IDynamicCondition) => number;
+export declare const calculateDynamicGroupPercent: (dynamicObj: Record<string, string | number | boolean> | undefined, group: IDynamicGroup | undefined) => number;
+export declare function evaluateDynamicCondition(dynamicObj: Record<string, string | number | boolean>, cond: IDynamicCondition, claimMultiplier?: number): boolean;
+export declare function meetsDynamicConditions(dynamicObj: Record<string, string | number | boolean> | undefined | null, dynamicGroup: IDynamicGroup, claimMultiplier?: number): boolean;
+export declare function getMaxClaimsForDynamicCondition(dynamicObj: Record<string, string | number | boolean>, cond: IDynamicCondition): number;
+export declare function getMaxClaimsForDynamicGroup(dynamicObj: Record<string, string | number | boolean>, dynamicGroup: IDynamicGroup, currentClaimCount?: number): number;
+export declare function aggregateTokenBalances(data?: StackedBaseUserExtra): Record<string, number>;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/conditions/helpers.js

@@ -0,0 +1,256 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateDynamicGroupPercent = exports.calculateDynamicConditionPercent = exports.formatList = exports.calculatePercent = void 0;
+exports.evaluateDynamicCondition = evaluateDynamicCondition;
+exports.meetsDynamicConditions = meetsDynamicConditions;
+exports.getMaxClaimsForDynamicCondition = getMaxClaimsForDynamicCondition;
+exports.getMaxClaimsForDynamicGroup = getMaxClaimsForDynamicGroup;
+exports.aggregateTokenBalances = aggregateTokenBalances;
+const calculatePercent = (amount, goal, isMet) => {
+    if (goal && goal > 0 && amount !== undefined) {
+        return Math.min(100, (amount / goal) * 100);
+    }
+    return isMet ? 100 : 0;
+};
+exports.calculatePercent = calculatePercent;
+const formatList = (items) => items.length === 2 ? items.join(' and ') : `${items.slice(0, -1).join(', ')}, and ${items.at(-1)}`;
+exports.formatList = formatList;
+const calculateDynamicConditionPercent = (dynamicObj, cond) => {
+    if (!dynamicObj)
+        return 0;
+    if (cond.operator === 'is_truthy')
+        return dynamicObj[cond.key] ? 100 : 0;
+    if (cond.operator === 'is_falsy')
+        return !dynamicObj[cond.key] ? 100 : 0;
+    if (cond.operator === 'is_defined')
+        return dynamicObj[cond.key] != null ? 100 : 0;
+    const val = dynamicObj[cond.key];
+    if (typeof val !== 'number')
+        return 0;
+    const compareTo = typeof cond.compareTo === 'number' ? cond.compareTo : 0;
+    switch (cond.operator) {
+        case '>=':
+        case '>':
+            return compareTo > 0 ? Math.min(100, (val / compareTo) * 100) : val >= compareTo ? 100 : 0;
+        case '==':
+            return val === compareTo ? 100 : 0;
+        case '!=':
+            return val !== compareTo ? 100 : 0;
+        case '<=':
+        case '<':
+            return val <= compareTo ? 100 : 0;
+        default:
+            return 0;
+    }
+};
+exports.calculateDynamicConditionPercent = calculateDynamicConditionPercent;
+const calculateDynamicGroupPercent = (dynamicObj, group) => {
+    if (!group?.conditions?.length)
+        return 100;
+    const percentages = group.conditions.map((c) => (0, exports.calculateDynamicConditionPercent)(dynamicObj, c));
+    if (!group.links?.length) {
+        return percentages.reduce((sum, p) => sum + p, 0) / percentages.length;
+    }
+    let result = percentages[0];
+    for (let i = 0; i < group.links.length; i++) {
+        const nextPct = percentages[i + 1];
+        switch (group.links[i]) {
+            case 'AND':
+                result = (result + nextPct) / 2;
+                break;
+            case 'OR':
+                result = Math.max(result, nextPct);
+                break;
+            case 'AND NOT':
+                result = (result + (100 - nextPct)) / 2;
+                break;
+        }
+    }
+    return result;
+};
+exports.calculateDynamicGroupPercent = calculateDynamicGroupPercent;
+function evaluateDynamicCondition(dynamicObj, cond, claimMultiplier = 1) {
+    if (!dynamicObj)
+        return false;
+    const val = dynamicObj[cond.key];
+    if (cond.operator === 'is_truthy')
+        return !!val;
+    if (cond.operator === 'is_falsy')
+        return !val;
+    if (cond.operator === 'is_defined')
+        return val != null;
+    if (val == undefined)
+        return false;
+    const isNumber = typeof val === 'number';
+    const isBoolean = typeof val === 'boolean';
+    if (isBoolean) {
+        switch (cond.operator) {
+            case '==':
+                return val === Boolean(cond.compareTo);
+            case '!=':
+                return val !== Boolean(cond.compareTo);
+            default:
+                return false;
+        }
+    }
+    const compareTo = isNumber ? Number(cond.compareTo) : String(cond.compareTo);
+    if (isNumber && typeof compareTo === 'number') {
+        const skipMultiplier = cond.operator === '==' || cond.operator === '!=';
+        const scaledCompareTo = skipMultiplier ? compareTo : compareTo * claimMultiplier;
+        switch (cond.operator) {
+            case '==':
+                return val === scaledCompareTo;
+            case '!=':
+                return val !== scaledCompareTo;
+            case '>':
+                return val > scaledCompareTo;
+            case '>=':
+                return val >= scaledCompareTo;
+            case '<':
+                return val < scaledCompareTo;
+            case '<=':
+                return val <= scaledCompareTo;
+        }
+    }
+    else if (!isNumber && typeof compareTo === 'string') {
+        switch (cond.operator) {
+            case '==':
+                return val === compareTo;
+            case '!=':
+                return val !== compareTo;
+            case 'has':
+                return val.includes(compareTo);
+            case 'not_has':
+                return !val.includes(compareTo);
+        }
+    }
+    return false;
+}
+function meetsDynamicConditions(dynamicObj, dynamicGroup, claimMultiplier = 1) {
+    const { conditions, links } = dynamicGroup;
+    if (!conditions || conditions.length === 0)
+        return true;
+    if (!dynamicObj)
+        return false;
+    if (!links || links.length === 0) {
+        return conditions.every((cond) => evaluateDynamicCondition(dynamicObj, cond, claimMultiplier));
+    }
+    let result = evaluateDynamicCondition(dynamicObj, conditions[0], claimMultiplier);
+    for (let i = 0; i < links.length; i++) {
+        const nextCond = evaluateDynamicCondition(dynamicObj, conditions[i + 1], claimMultiplier);
+        const link = links[i];
+        if (link === 'AND') {
+            result = result && nextCond;
+        }
+        else if (link === 'OR') {
+            result = result || nextCond;
+        }
+        else if (link === 'AND NOT') {
+            result = result && !nextCond;
+        }
+    }
+    return result;
+}
+function getMaxClaimsForDynamicCondition(dynamicObj, cond) {
+    if (!dynamicObj)
+        return 0;
+    if (cond.operator === 'is_truthy')
+        return dynamicObj[cond.key] ? Infinity : 0;
+    if (cond.operator === 'is_falsy')
+        return !dynamicObj[cond.key] ? Infinity : 0;
+    if (cond.operator === 'is_defined')
+        return dynamicObj[cond.key] != null ? Infinity : 0;
+    const val = dynamicObj[cond.key];
+    if (val === undefined)
+        return 0;
+    if (typeof val === 'number') {
+        const base = Number(cond.compareTo);
+        if (isNaN(base)) {
+            return evaluateDynamicCondition(dynamicObj, cond, 1) ? Infinity : 0;
+        }
+        switch (cond.operator) {
+            case '>=':
+                if (base === 0)
+                    return val >= 0 ? Infinity : 0;
+                if (base < 0)
+                    return val >= base ? Infinity : 0;
+                return Math.max(0, Math.floor(val / base));
+            case '>':
+                if (base === 0)
+                    return val > 0 ? Infinity : 0;
+                if (base < 0)
+                    return val > base ? Infinity : 0;
+                if (val <= 0)
+                    return 0;
+                return Math.max(0, Math.ceil(val / base) - 1);
+            case '==':
+                return val === base ? Infinity : 0;
+            case '!=':
+                return val !== base ? Infinity : 0;
+            case '<=':
+                if (base === 0)
+                    return val <= 0 ? Infinity : 0;
+                if (base > 0)
+                    return evaluateDynamicCondition(dynamicObj, cond, 1) ? Infinity : 0;
+                if (val >= 0)
+                    return 0;
+                return Math.max(0, Math.floor(val / base));
+            case '<':
+                if (base === 0)
+                    return val < 0 ? Infinity : 0;
+                if (base > 0)
+                    return evaluateDynamicCondition(dynamicObj, cond, 1) ? Infinity : 0;
+                if (val >= 0)
+                    return 0;
+                return Math.max(0, Math.ceil(val / base) - 1);
+        }
+    }
+    return evaluateDynamicCondition(dynamicObj, cond, 1) ? Infinity : 0;
+}
+function getMaxClaimsForDynamicGroup(dynamicObj, dynamicGroup, currentClaimCount = 0) {
+    const { conditions, links } = dynamicGroup;
+    if (!conditions || conditions.length === 0)
+        return Infinity;
+    if (!links || links.length === 0 || links.every((l) => l === 'AND')) {
+        let minClaims = Infinity;
+        for (const cond of conditions) {
+            const max = getMaxClaimsForDynamicCondition(dynamicObj, cond);
+            if (max === 0)
+                return 0;
+            minClaims = Math.min(minClaims, max);
+        }
+        return minClaims;
+    }
+    if (links.every((l) => l === 'OR')) {
+        let maxClaims = 0;
+        for (const cond of conditions) {
+            const max = getMaxClaimsForDynamicCondition(dynamicObj, cond);
+            if (max === Infinity)
+                return Infinity;
+            maxClaims = Math.max(maxClaims, max);
+        }
+        return maxClaims;
+    }
+    const maxIterations = 100;
+    for (let n = currentClaimCount + 1; n <= currentClaimCount + maxIterations; n++) {
+        if (!meetsDynamicConditions(dynamicObj, dynamicGroup, n)) {
+            return n - 1;
+        }
+    }
+    return currentClaimCount + maxIterations;
+}
+function aggregateTokenBalances(data) {
+    const aggregatedBalances = {};
+    for (const { balances } of data?.cryptoWallets || []) {
+        if (!balances)
+            continue;
+        for (const [key, balance] of Object.entries(balances)) {
+            if (!aggregatedBalances[key]) {
+                aggregatedBalances[key] = 0;
+            }
+            aggregatedBalances[key] += balance;
+        }
+    }
+    return aggregatedBalances;
+}
+//# sourceMappingURL=helpers.js.map

package/dist/conditions/index.d.ts

@@ -0,0 +1,97 @@
+import { ICompletionCondition, ISurfacingCondition, ICompletionTrackers, IClaimableTrackers, StackedOffer, StackedSnapshot, StackedBaseUserExtra, StackedOfferTrackers, IClaimableCondition, ConditionDetail } from '@stackedapp/types';
+export { meetsDynamicConditions, getMaxClaimsForDynamicCondition, getMaxClaimsForDynamicGroup } from './helpers';
+export declare const meetsBaseConditions: ({ conditions, playerSnap, addDetails, playerOffer, additionalData, }: {
+    conditions: ISurfacingCondition[] | ICompletionCondition[];
+    playerSnap: StackedSnapshot;
+    addDetails?: boolean;
+    playerOffer?: {
+        createdAt?: Date | number;
+        claimedCount?: number;
+        trackers?: Record<string, any>;
+    };
+    additionalData?: StackedBaseUserExtra;
+}) => {
+    isValid: boolean;
+    isComplete: boolean;
+    percentCompleted: number;
+    conditionData?: undefined;
+} | {
+    isValid: boolean;
+    isComplete: boolean;
+    percentCompleted: number;
+    conditionData: ConditionDetail[] | undefined;
+};
+export declare const hasCompletionConditions: (conditions: ICompletionCondition[] | undefined | null) => boolean;
+export declare const meetsLinkedEntityOffersCondition: ({ linkedEntityOffers, matchingLinks, linkedPOfferMap, }: {
+    linkedEntityOffers: {
+        kind?: string;
+        offer_id?: string;
+        offerId?: 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;
+    conditionData: ConditionDetail[];
+    availableClaimsNow: number;
+} | {
+    isValid: boolean;
+    isComplete: boolean;
+    percentCompleted: number;
+    availableClaimsNow: number;
+    conditionData?: undefined;
+};
+export declare const meetsCompletionConditions: ({ completionConditions, completionTrackers, playerSnap, playerOffer, addDetails, maxClaimCount, additionalData, }: {
+    completionConditions: ICompletionCondition[];
+    completionTrackers?: ICompletionTrackers;
+    playerSnap: StackedSnapshot;
+    playerOffer: {
+        createdAt?: Date | number;
+        trackers?: StackedOfferTrackers;
+    };
+    addDetails?: boolean;
+    maxClaimCount?: number;
+    additionalData?: StackedBaseUserExtra;
+}) => {
+    isValid: boolean;
+    isComplete: boolean;
+    percentCompleted: number;
+    conditionData: ConditionDetail[];
+    availableClaimsNow: number;
+} | {
+    isValid: boolean;
+    isComplete: boolean;
+    percentCompleted: number;
+    availableClaimsNow: number;
+    conditionData?: undefined;
+};
+export declare const meetsCompletionConditionsBeforeExpiry: ({ completionConditions, completionTrackers, playerSnap, playerOffer, maxClaimCount, }: {
+    completionConditions: ICompletionCondition[];
+    completionTrackers?: ICompletionTrackers;
+    playerSnap: StackedSnapshot;
+    playerOffer: {
+        createdAt?: Date | number;
+        claimedCount?: number;
+        trackers?: Record<string, any>;
+        expiresAt?: Date | number | string;
+    };
+    maxClaimCount?: number;
+}) => boolean;
+export declare function meetsClaimableConditions({ claimableConditions, playerOfferTrackers, claimableTrackers, }: {
+    claimableConditions?: IClaimableCondition[];
+    playerOfferTrackers?: StackedOfferTrackers;
+    claimableTrackers?: IClaimableTrackers;
+}): {
+    isValid: boolean;
+};
+//# sourceMappingURL=index.d.ts.map