@pixels-online/pixels-client-js-sdk 1.0.2

package/dist/offerwall-sdk.umd.js

@@ -0,0 +1,1557 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+    typeof define === 'function' && define.amd ? define(['exports'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.OfferwallSDK = {}));
+})(this, (function (exports) { 'use strict';
+
+    class Logger {
+        constructor(config, prefix) {
+            this.config = config;
+            this.prefix = prefix;
+        }
+        log(...args) {
+            if (this.config.debug) {
+                console.log(`[${this.prefix}]`, ...args);
+            }
+        }
+        error(...args) {
+            console.error(`[${this.prefix}]`, ...args);
+        }
+        warn(...args) {
+            if (this.config.debug) {
+                console.warn(`[${this.prefix}]`, ...args);
+            }
+        }
+        info(...args) {
+            if (this.config.debug) {
+                console.info(`[${this.prefix}]`, ...args);
+            }
+        }
+        /**
+         * Create a child logger with an additional prefix
+         */
+        child(subPrefix) {
+            return new Logger(this.config, `${this.prefix}:${subPrefix}`);
+        }
+    }
+    /**
+     * Create a logger instance for a component
+     */
+    function createLogger(config, prefix) {
+        return new Logger(config, prefix);
+    }
+
+    class EventEmitter {
+        constructor(config) {
+            this.events = new Map();
+            this.logger = createLogger(config, 'EventEmitter');
+        }
+        on(event, handler) {
+            if (!this.events.has(event)) {
+                this.events.set(event, new Set());
+            }
+            this.events.get(event).add(handler);
+            this.logger.log(`Handler registered for event: ${event}`);
+        }
+        off(event, handler) {
+            const handlers = this.events.get(event);
+            if (handlers) {
+                handlers.delete(handler);
+                if (handlers.size === 0) {
+                    this.events.delete(event);
+                }
+            }
+            this.logger.log(`Handler removed for event: ${event}`);
+        }
+        emit(event, data) {
+            const handlers = this.events.get(event);
+            if (handlers) {
+                handlers.forEach(handler => {
+                    try {
+                        handler(data);
+                    }
+                    catch (error) {
+                        this.logger.error(`Error in handler for event ${event}:`, error);
+                    }
+                });
+            }
+            this.logger.log(`Event emitted: ${event}`, data);
+        }
+        once(event, handler) {
+            const wrappedHandler = (data) => {
+                handler(data);
+                this.off(event, wrappedHandler);
+            };
+            this.on(event, wrappedHandler);
+        }
+        removeAllListeners(event) {
+            if (event) {
+                this.events.delete(event);
+            }
+            else {
+                this.events.clear();
+            }
+            this.logger.log(`Listeners removed for: ${event || 'all events'}`);
+        }
+        listenerCount(event) {
+            const handlers = this.events.get(event);
+            return handlers ? handlers.size : 0;
+        }
+    }
+
+    exports.OfferEvent = void 0;
+    (function (OfferEvent) {
+        OfferEvent["CONNECTED"] = "connected";
+        OfferEvent["DISCONNECTED"] = "disconnected";
+        OfferEvent["CONNECTION_ERROR"] = "connection_error";
+        OfferEvent["CONNECTION_STATE_CHANGED"] = "connection_state_changed";
+        OfferEvent["OFFER_SURFACED"] = "offer_surfaced";
+        OfferEvent["OFFER_CLAIMED"] = "offer_claimed";
+        OfferEvent["ERROR"] = "error";
+        OfferEvent["REFRESH"] = "refresh";
+        /* placeholder events for future use
+        OFFER_ADDED = 'offer_added',
+        OFFER_UPDATED = 'offer_updated',
+        SNAPSHOT_UPDATED = 'snapshot_updated',
+        */
+    })(exports.OfferEvent || (exports.OfferEvent = {}));
+
+    /**
+     * Connection states for SSE connection
+     */
+    exports.ConnectionState = void 0;
+    (function (ConnectionState) {
+        ConnectionState["DISCONNECTED"] = "disconnected";
+        ConnectionState["CONNECTING"] = "connecting";
+        ConnectionState["CONNECTED"] = "connected";
+        ConnectionState["RECONNECTING"] = "reconnecting";
+        ConnectionState["ERROR"] = "error";
+    })(exports.ConnectionState || (exports.ConnectionState = {}));
+
+    /**
+     * Custom EventSource implementation that supports headers
+     * This is needed because the native EventSource API doesn't support custom headers
+     */
+    var ReadyState;
+    (function (ReadyState) {
+        ReadyState[ReadyState["CONNECTING"] = 0] = "CONNECTING";
+        ReadyState[ReadyState["OPEN"] = 1] = "OPEN";
+        ReadyState[ReadyState["CLOSED"] = 2] = "CLOSED";
+    })(ReadyState || (ReadyState = {}));
+    class CustomEventSource {
+        constructor(url, init) {
+            this.readyState = ReadyState.CONNECTING;
+            this.eventListeners = new Map();
+            this.onopen = null;
+            this.onerror = null;
+            this.onmessage = null;
+            this.reader = null;
+            this.decoder = new TextDecoder();
+            this.eventBuffer = '';
+            this.abortController = null;
+            this.lastEventId = '';
+            this.reconnectTime = 3000;
+            this.onRetryUpdate = null;
+            this.url = url;
+            this.headers = {
+                'Accept': 'text/event-stream',
+                'Cache-Control': 'no-cache',
+                ...(init?.headers || {})
+            };
+            this.connect();
+        }
+        async connect() {
+            try {
+                this.readyState = ReadyState.CONNECTING;
+                this.abortController = new AbortController();
+                const response = await fetch(this.url, {
+                    method: 'GET',
+                    headers: this.headers,
+                    credentials: 'same-origin',
+                    signal: this.abortController.signal,
+                });
+                if (!response.ok) {
+                    // Check for JWT errors
+                    if (response.status === 400 || response.status === 401) {
+                        try {
+                            const json = await response.json();
+                            if (json.message === 'jwt-expired' || json.message === 'jwt-invalid') {
+                                const error = new Error(json.message);
+                                error.isAuthError = true;
+                                throw error;
+                            }
+                        }
+                        catch (e) {
+                            // If not JSON or no message, throw original error
+                        }
+                    }
+                    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+                }
+                if (!response.body) {
+                    throw new Error('Response body is null');
+                }
+                this.readyState = ReadyState.OPEN;
+                // Dispatch open event
+                if (this.onopen) {
+                    this.onopen(new Event('open'));
+                }
+                this.reader = response.body.getReader();
+                await this.readStream();
+            }
+            catch (error) {
+                this.handleError(error);
+            }
+        }
+        async readStream() {
+            if (!this.reader)
+                return;
+            try {
+                while (true) {
+                    const { done, value } = await this.reader.read();
+                    if (done) {
+                        this.handleError(new Error('Stream ended'));
+                        break;
+                    }
+                    const chunk = this.decoder.decode(value, { stream: true });
+                    this.eventBuffer += chunk;
+                    this.processBuffer();
+                }
+            }
+            catch (error) {
+                this.handleError(error);
+            }
+        }
+        processBuffer() {
+            const lines = this.eventBuffer.split('\n');
+            this.eventBuffer = lines.pop() || '';
+            let eventType = 'message';
+            let eventData = '';
+            let eventId = '';
+            for (const line of lines) {
+                if (line === '') {
+                    // Empty line signals end of event
+                    if (eventData) {
+                        this.dispatchEvent(eventType, eventData.trim(), eventId);
+                        eventType = 'message';
+                        eventData = '';
+                        eventId = '';
+                    }
+                }
+                else if (line.startsWith(':')) {
+                    // Comment, ignore
+                    continue;
+                }
+                else if (line.startsWith('event:')) {
+                    eventType = line.slice(6).trim();
+                }
+                else if (line.startsWith('data:')) {
+                    eventData += line.slice(5).trim() + '\n';
+                }
+                else if (line.startsWith('id:')) {
+                    eventId = line.slice(3).trim();
+                    this.lastEventId = eventId;
+                }
+                else if (line.startsWith('retry:')) {
+                    const retry = parseInt(line.slice(6).trim(), 10);
+                    if (!isNaN(retry)) {
+                        this.reconnectTime = retry;
+                        // Notify SSEConnection about the server's suggested retry time
+                        if (this.onRetryUpdate) {
+                            this.onRetryUpdate(retry);
+                        }
+                    }
+                }
+            }
+        }
+        dispatchEvent(type, data, id) {
+            const event = new MessageEvent(type, {
+                data: data.endsWith('\n') ? data.slice(0, -1) : data,
+                lastEventId: id || this.lastEventId,
+                origin: new URL(this.url).origin,
+            });
+            // Dispatch to specific event listeners
+            const listeners = this.eventListeners.get(type);
+            if (listeners) {
+                listeners.forEach(listener => listener(event));
+            }
+            // Dispatch to general message handler for 'message' events
+            if (type === 'message' && this.onmessage) {
+                this.onmessage(event);
+            }
+        }
+        handleError(error) {
+            this.readyState = ReadyState.CLOSED;
+            if (this.reader) {
+                this.reader.cancel();
+                this.reader = null;
+            }
+            // Dispatch error event with details
+            if (this.onerror) {
+                const errorEvent = new Event('error');
+                errorEvent.detail = error;
+                errorEvent.message = error?.message;
+                this.onerror(errorEvent);
+            }
+            // Reconnection is handled by SSEConnection, not here
+        }
+        addEventListener(type, listener) {
+            if (!this.eventListeners.has(type)) {
+                this.eventListeners.set(type, new Set());
+            }
+            this.eventListeners.get(type).add(listener);
+        }
+        removeEventListener(type, listener) {
+            const listeners = this.eventListeners.get(type);
+            if (listeners) {
+                listeners.delete(listener);
+            }
+        }
+        close() {
+            this.readyState = ReadyState.CLOSED;
+            if (this.abortController) {
+                this.abortController.abort();
+                this.abortController = null;
+            }
+            if (this.reader) {
+                this.reader.cancel();
+                this.reader = null;
+            }
+            this.eventListeners.clear();
+            this.onopen = null;
+            this.onerror = null;
+            this.onmessage = null;
+        }
+        get CONNECTING() {
+            return ReadyState.CONNECTING;
+        }
+        get OPEN() {
+            return ReadyState.OPEN;
+        }
+        get CLOSED() {
+            return ReadyState.CLOSED;
+        }
+        getReadyState() {
+            return this.readyState;
+        }
+        getReconnectTime() {
+            return this.reconnectTime;
+        }
+    }
+
+    class SSEConnection {
+        constructor(config, eventEmitter, tokenManager) {
+            this.config = config;
+            this.eventEmitter = eventEmitter;
+            this.tokenManager = tokenManager;
+            this.eventSource = null;
+            this.reconnectAttempts = 0;
+            this.reconnectTimeout = null;
+            this.isConnecting = false;
+            this.connectionState = exports.ConnectionState.DISCONNECTED;
+            this.serverSuggestedRetryTime = null;
+            this.logger = createLogger(config, 'SSEConnection');
+        }
+        /**
+         * Get current connection state
+         */
+        getConnectionState() {
+            return this.connectionState;
+        }
+        /**
+         * Set connection state and emit change event
+         */
+        setConnectionState(newState, error) {
+            const previousState = this.connectionState;
+            if (previousState === newState)
+                return;
+            this.connectionState = newState;
+            this.eventEmitter.emit(exports.OfferEvent.CONNECTION_STATE_CHANGED, {
+                state: newState,
+                previousState,
+                error,
+                attempt: this.reconnectAttempts,
+                maxAttempts: this.config.maxReconnectAttempts
+            });
+        }
+        connect() {
+            return new Promise(async (resolve, reject) => {
+                if (this.eventSource) {
+                    this.logger.log('Already connected');
+                    resolve();
+                    return;
+                }
+                if (this.isConnecting) {
+                    this.logger.log('Connection already in progress');
+                    resolve();
+                    return;
+                }
+                this.isConnecting = true;
+                this.setConnectionState(exports.ConnectionState.CONNECTING);
+                this.logger.log('Connecting to SSE endpoint...');
+                try {
+                    // Create SSE URL
+                    const url = new URL(this.config.endpoint + '/sse/connect');
+                    const token = await this.tokenManager.getTokenForConnection();
+                    // Use CustomEventSource with Authorization Bearer header
+                    this.eventSource = new CustomEventSource(url.toString(), {
+                        headers: {
+                            'Authorization': `Bearer ${token}`,
+                        }
+                    });
+                    // Listen for server-suggested retry time updates
+                    this.eventSource.onRetryUpdate = (retryTime) => {
+                        this.serverSuggestedRetryTime = retryTime;
+                        this.logger.log(`Server suggested retry time: ${retryTime}ms`);
+                    };
+                    this.eventSource.onopen = () => {
+                        this.logger.log('SSE connection opened');
+                        this.isConnecting = false;
+                        this.reconnectAttempts = 0;
+                        this.setConnectionState(exports.ConnectionState.CONNECTED);
+                        this.eventEmitter.emit(exports.OfferEvent.CONNECTED, { timestamp: new Date() });
+                        resolve();
+                    };
+                    this.eventSource.onerror = (error) => {
+                        this.logger.log('SSE connection error', error);
+                        this.isConnecting = false;
+                        // Check if it's an auth error
+                        if (error?.detail?.isAuthError || error?.message === 'jwt-expired' || error?.message === 'jwt-invalid') {
+                            this.tokenManager.clearToken();
+                            this.setConnectionState(exports.ConnectionState.DISCONNECTED);
+                            // Try to reconnect with fresh token if reconnect is enabled
+                            if (this.config.reconnect && this.reconnectAttempts < (this.config.maxReconnectAttempts || 5)) {
+                                this.logger.log('JWT invalid/expired, attempting reconnect with fresh token');
+                                this.handleReconnect();
+                                resolve(); // Resolve instead of reject to allow reconnection
+                                return;
+                            }
+                            else {
+                                reject(new Error('JWT token invalid or expired'));
+                                return;
+                            }
+                        }
+                        const errorMsg = this.eventSource?.getReadyState() === ReadyState.CLOSED ?
+                            'Connection closed' : 'Connection error';
+                        const connectionError = new Error(errorMsg);
+                        this.setConnectionState(exports.ConnectionState.ERROR, connectionError);
+                        if (this.eventSource?.getReadyState() === ReadyState.CLOSED) {
+                            this.eventEmitter.emit(exports.OfferEvent.CONNECTION_ERROR, {
+                                error: connectionError,
+                                timestamp: new Date()
+                            });
+                            this.handleReconnect();
+                        }
+                        else {
+                            this.eventEmitter.emit(exports.OfferEvent.CONNECTION_ERROR, {
+                                error: connectionError,
+                                timestamp: new Date()
+                            });
+                            reject(connectionError);
+                        }
+                    };
+                    this.eventSource.addEventListener(exports.OfferEvent.OFFER_SURFACED, (event) => {
+                        this.handleMessage(exports.OfferEvent.OFFER_SURFACED, event.data);
+                    });
+                    /*this.eventSource.addEventListener(OfferEvent.INIT, (event) => {
+                      this.handleMessage(OfferEvent.INIT, event.data);
+                    });
+            
+                    this.eventSource.addEventListener(OfferEvent.OFFER_ADDED, (event) => {
+                      this.handleMessage(OfferEvent.OFFER_ADDED, event.data);
+                    });
+            
+            
+                    this.eventSource.addEventListener(OfferEvent.OFFER_UPDATED, (event) => {
+                      this.handleMessage(OfferEvent.OFFER_UPDATED, event.data);
+                    });
+            
+                    this.eventSource.addEventListener(OfferEvent.SNAPSHOT_UPDATED, (event) => {
+                      this.handleMessage(OfferEvent.SNAPSHOT_UPDATED, event.data);
+                    });
+                    */
+                }
+                catch (error) {
+                    this.isConnecting = false;
+                    this.logger.log('Failed to create EventSource', error);
+                    reject(error);
+                }
+            });
+        }
+        async handleMessage(type, data) {
+            try {
+                const parsed = JSON.parse(data);
+                this.logger.log(`Handling ${type} message:`, parsed);
+                switch (type) {
+                    /*
+                    case OfferEvent.INIT:
+                      if (!parsed.offers || !Array.isArray(parsed.offers))
+                        throw new Error('INIT message missing offers array');
+            
+                      if (!parsed.playerSnapshot)
+                        throw new Error('INIT message missing playerSnapshot');
+            
+                      this.eventEmitter.emit(OfferEvent.INIT, {
+                        offers: parsed.offers as IClientOffer[],
+                        playerSnapshot: parsed.playerSnapshot as IClientPlayerSnapshot
+                      });
+            
+                      break;
+                    case OfferEvent.OFFER_ADDED:
+                      if (!parsed.offer)
+                        throw new Error('OFFER_ADDED message missing offer');
+                      this.eventEmitter.emit(OfferEvent.OFFER_ADDED, {
+                        offer: parsed.offer as IClientOffer,
+                      });
+                      break;
+            
+                    case OfferEvent.OFFER_UPDATED:
+                      if (!parsed.offer)
+                        throw new Error('OFFER_UPDATED message missing offer');
+            
+                      this.eventEmitter.emit(OfferEvent.OFFER_UPDATED, {
+                        offer: parsed.offer as IClientOffer,
+                      });
+                      break;
+                    case OfferEvent.SNAPSHOT_UPDATED:
+                      if (!parsed.playerSnapshot)
+                        throw new Error('SNAPSHOT_UPDATED message missing playerSnapshot');
+                      this.eventEmitter.emit(OfferEvent.SNAPSHOT_UPDATED, {
+                        playerSnapshot: parsed.playerSnapshot as IClientPlayerSnapshot
+                      });
+                      break;
+                    case OfferEvent.OFFER_CLAIMED:
+                      if (!parsed.offerId)
+                        throw new Error('OFFER_CLAIMED message missing offerId');
+                      this.eventEmitter.emit(OfferEvent.OFFER_CLAIMED, {
+                        instanceId: parsed as string,
+                      });
+                      break;
+                      */
+                    case exports.OfferEvent.OFFER_SURFACED:
+                        if (!parsed.offer)
+                            throw new Error('OFFER_SURFACED message missing offer');
+                        let surface = true;
+                        if (this.config.hooks?.onOfferSurfaced) {
+                            surface = await this.config.hooks.onOfferSurfaced(parsed.offer);
+                        }
+                        if (surface) {
+                            this.logger.log('Offer surfaced hook returned true, popping notification for offer:', parsed.offer);
+                            this.eventEmitter.emit(exports.OfferEvent.OFFER_SURFACED, {
+                                offer: parsed.offer,
+                            });
+                        }
+                        break;
+                    default:
+                        this.logger.log('Unknown message type:', type);
+                }
+            }
+            catch (error) {
+                this.logger.log('Error parsing SSE message:', error);
+                this.eventEmitter.emit(exports.OfferEvent.ERROR, {
+                    error: error,
+                    context: 'sse_message_parse'
+                });
+            }
+        }
+        handleReconnect() {
+            if (!this.config.reconnect) {
+                this.disconnect();
+                return;
+            }
+            if (this.reconnectAttempts >= (this.config.maxReconnectAttempts || 5)) {
+                this.logger.log('Max reconnection attempts reached');
+                this.setConnectionState(exports.ConnectionState.DISCONNECTED);
+                this.disconnect();
+                this.eventEmitter.emit(exports.OfferEvent.DISCONNECTED, {
+                    reason: 'max_reconnect_attempts',
+                    timestamp: new Date()
+                });
+                return;
+            }
+            this.reconnectAttempts++;
+            // Use server-suggested retry time if available, otherwise use config delay with exponential backoff
+            const baseDelay = this.serverSuggestedRetryTime || this.config.reconnectDelay || 1000;
+            const backoffDelay = baseDelay * Math.pow(2, this.reconnectAttempts - 1);
+            this.setConnectionState(exports.ConnectionState.RECONNECTING);
+            this.logger.log(`Reconnecting in ${backoffDelay}ms (attempt ${this.reconnectAttempts}`);
+            this.reconnectTimeout = window.setTimeout(() => {
+                this.eventSource = null;
+                this.connect().catch((error) => {
+                    this.logger.log('Reconnection failed:', error);
+                });
+            }, backoffDelay);
+        }
+        disconnect() {
+            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;
+        }
+        isConnected() {
+            return this.eventSource?.getReadyState() === ReadyState.OPEN;
+        }
+    }
+
+    class OfferStore {
+        constructor(config) {
+            this.offers = new Map();
+            this.playerSnapshot = null;
+            this.logger = createLogger(config, 'OfferStore');
+        }
+        getSnapshot() {
+            return this.playerSnapshot;
+        }
+        setSnapshot(snapshot) {
+            this.playerSnapshot = snapshot;
+            this.logger.log('Updated player snapshot:', snapshot);
+        }
+        /**
+         * Set all offers (replaces existing)
+         */
+        setOffers(offers) {
+            this.offers.clear();
+            offers.forEach(offer => {
+                this.offers.set(offer.instanceId, offer);
+            });
+            this.logger.log(`Set ${offers.length} offers`);
+        }
+        /**
+         * Add or update a single offer
+         */
+        upsertOffer(offer) {
+            const previousOffer = this.offers.get(offer.instanceId);
+            this.offers.set(offer.instanceId, offer);
+            this.logger.log(`${previousOffer ? 'Updated' : 'Added'} offer:`, offer.instanceId);
+            return previousOffer;
+        }
+        /**
+         * Remove an offer
+         */
+        removeOffer(offerId) {
+            const removed = this.offers.delete(offerId);
+            if (removed) {
+                this.logger.log(`Removed offer:`, offerId);
+            }
+            return removed;
+        }
+        /**
+         * Get a single offer
+         */
+        getOffer(offerId) {
+            return this.offers.get(offerId);
+        }
+        /**
+         * Get all offers
+         */
+        getAllOffers() {
+            return Array.from(this.offers.values());
+        }
+        /**
+         * Get offers filtered by status
+         */
+        getOffersByStatus(status) {
+            return this.getAllOffers().filter(offer => offer.status === status);
+        }
+        /**
+         * Get active offers (not expired, not claimed)
+         */
+        getActiveOffers() {
+            return this.getAllOffers().filter(offer => {
+                if (!offer.status)
+                    return false; // Must have a status
+                return offer.status === 'surfaced' || offer.status === 'viewed' || offer.status === 'claimable';
+            });
+        }
+        /**
+         * Get claimable offers
+         */
+        getClaimableOffers() {
+            return this.getOffersByStatus('claimable');
+        }
+        /**
+         * Check if an offer has expired
+         */
+        isOfferExpired(offerId) {
+            const offer = this.getOffer(offerId);
+            if (!offer)
+                return true;
+            // Check status
+            if (offer.status === 'expired')
+                return true;
+            // Check expiry date
+            if (offer.expiresAt && new Date(offer.expiresAt) < new Date()) {
+                return true;
+            }
+            return false;
+        }
+        /**
+         * Clear all offers
+         */
+        clear() {
+            this.offers.clear();
+            this.logger.log('Cleared all offers');
+        }
+        /**
+         * Get offer count
+         */
+        get size() {
+            return this.offers.size;
+        }
+    }
+
+    /**
+     * Manages JWT tokens for the offerwall client
+     * Handles token storage, validation, and refresh logic
+     */
+    class TokenManager {
+        constructor(config) {
+            this.config = config;
+            this.currentToken = null;
+            this.logger = createLogger(config, 'TokenManager');
+        }
+        /**
+         * Get the current stored token
+         */
+        getCurrentToken() {
+            return this.currentToken;
+        }
+        /**
+         * Clear the stored token
+         */
+        clearToken() {
+            this.currentToken = null;
+        }
+        /**
+         * Get current token or fetch a new one if needed
+         */
+        async getTokenForConnection() {
+            if (!this.currentToken)
+                return this.fetchToken();
+            if (!this.validateToken(this.currentToken))
+                return this.fetchToken();
+            return this.currentToken;
+        }
+        async fetchToken() {
+            const token = await this.config.tokenProvider();
+            this.currentToken = token;
+            return token;
+        }
+        validateToken(token) {
+            try {
+                const { exp } = this.parseJWT(token);
+                const now = Date.now();
+                const expiryTime = exp * 1000;
+                var isValid = expiryTime > now + 60000; // valid if more than 1 minute left
+                return isValid;
+            }
+            catch (error) {
+                this.logger.log(`Failed to validate token: ${error}`);
+                return false;
+            }
+        }
+        parseJWT(token) {
+            try {
+                const parts = token.split(".");
+                if (parts.length !== 3)
+                    throw new Error("Invalid JWT format");
+                const payload = JSON.parse(atob(parts[1]));
+                // Validate required claims
+                if (!payload.sub || typeof payload.sub !== "string") {
+                    throw new Error("Invalid sub claim");
+                }
+                if (!payload.iss || typeof payload.iss !== "string") {
+                    throw new Error("Invalid iss claim");
+                }
+                if (!payload.exp || typeof payload.exp !== "number") {
+                    throw new Error("Invalid exp claim");
+                }
+                if (!payload.iat || typeof payload.iat !== "number") {
+                    throw new Error("Invalid iat claim");
+                }
+                // discard unknown claims
+                return {
+                    sub: payload.sub,
+                    iss: payload.iss,
+                    exp: payload.exp,
+                    iat: payload.iat,
+                };
+            }
+            catch (error) {
+                throw new Error(`Failed to parse JWT: ${error}`);
+            }
+        }
+    }
+
+    class AssetHelper {
+        constructor(config) {
+            this.config = config;
+        }
+        resolveReward(reward) {
+            // Determine the ID to translate based on reward kind
+            let id;
+            switch (reward.kind) {
+                case 'item':
+                    id = reward.itemId;
+                    break;
+                case 'coins':
+                    id = reward.currencyId;
+                    break;
+                case 'exp':
+                    id = reward.skillId;
+                    break;
+                case 'on_chain':
+                    id = reward.assetId;
+                    break;
+                case 'trust_points':
+                    id = 'trust_points';
+                    break;
+            }
+            // Fallback to reward's built-in name, we should add 5x popberry etc
+            const formattedName = reward.amount > 1 ? `${reward.amount}x ${reward.name}` : reward.name;
+            // Try to resolve asset content if ID exists and resolver is set
+            if (id && this.config.assetResolver) {
+                const content = this.config.assetResolver(reward, id);
+                if (content) {
+                    return {
+                        name: content.name || formattedName,
+                        image: content.image || this.config.fallbackRewardImage
+                    };
+                }
+            }
+            return {
+                name: formattedName,
+                image: this.config.fallbackRewardImage
+            };
+        }
+        resolveOfferRewards(offer) {
+            return offer.rewards.map(reward => ({
+                ...reward,
+                ...this.resolveReward(reward),
+            }));
+        }
+    }
+
+    class OfferwallClient {
+        constructor(config) {
+            this.isInitializing = false;
+            this.config = {
+                endpoint: config.endpoint || 'https://api.buildon.pixels.xyz',
+                autoConnect: config.autoConnect ?? false,
+                reconnect: config.reconnect ?? true,
+                reconnectDelay: config.reconnectDelay ?? 1000,
+                maxReconnectAttempts: config.maxReconnectAttempts ?? 5,
+                debug: config.debug ?? false,
+                ...config
+            };
+            this.hooks = this.config.hooks || {};
+            this.logger = createLogger(this.config, 'OfferwallClient');
+            this.eventEmitter = new EventEmitter(this.config);
+            this.offerStore = new OfferStore(this.config);
+            this.tokenManager = new TokenManager(this.config);
+            this.assetHelper = new AssetHelper(this.config);
+            this.sseConnection = new SSEConnection(this.config, this.eventEmitter, this.tokenManager);
+            this.setupInternalListeners();
+            if (this.config.autoConnect) {
+                this.initialize().catch(err => {
+                    this.logger.error('Auto-initialization failed:', err);
+                });
+            }
+        }
+        /**
+         * Get the offer store instance
+         */
+        get store() {
+            return this.offerStore;
+        }
+        /**
+         * Get the event emitter instance for event handling
+         */
+        get events() {
+            return this.eventEmitter;
+        }
+        /**
+         * Get asset helper for resolving offer/reward content
+         */
+        get assets() {
+            return this.assetHelper;
+        }
+        /**
+         * Initialize the offerwall client and connect
+         */
+        async initialize() {
+            try {
+                if (this.isInitializing) {
+                    this.logger.log('Initialization already in progress');
+                    return;
+                }
+                this.isInitializing = true;
+                await this.refreshOffersAndSnapshot();
+                await this.connect();
+                this.isInitializing = false;
+            }
+            catch (error) {
+                this.handleError(error, 'initialize');
+                throw error;
+            }
+        }
+        /**
+         * Connect to the offerwall SSE endpoint
+         */
+        async connect() {
+            if (this.sseConnection?.isConnected()) {
+                this.logger.log('Already connected');
+                return;
+            }
+            const token = await this.tokenManager.getTokenForConnection();
+            if (this.hooks.beforeConnect) {
+                await this.hooks.beforeConnect({ jwt: token, endpoint: this.config.endpoint });
+            }
+            try {
+                await this.sseConnection.connect();
+                if (this.hooks.afterConnect) {
+                    await this.hooks.afterConnect();
+                }
+            }
+            catch (error) {
+                this.handleError(error, 'connection');
+                throw error;
+            }
+        }
+        /**
+         * Disconnect from the offerwall
+         */
+        async disconnect() {
+            if (this.hooks.beforeDisconnect) {
+                await this.hooks.beforeDisconnect();
+            }
+            if (this.sseConnection) {
+                this.sseConnection.disconnect();
+            }
+            this.offerStore.clear();
+            this.tokenManager.clearToken();
+            if (this.hooks.afterDisconnect) {
+                await this.hooks.afterDisconnect();
+            }
+        }
+        /**
+         * Claim rewards for an offer
+         */
+        async claimReward(instanceId) {
+            const offer = this.offerStore.getOffer(instanceId);
+            if (!offer) {
+                throw new Error(`Offer ${instanceId} not found`);
+            }
+            if (offer.status !== 'claimable') {
+                throw new Error(`Offer ${instanceId} is not claimable (status: ${offer.status})`);
+            }
+            if (this.hooks.beforeOfferClaim) {
+                const canClaim = await this.hooks.beforeOfferClaim(offer);
+                if (!canClaim) {
+                    this.logger.log('Claim cancelled by beforeOfferClaim hook');
+                    return;
+                }
+            }
+            try {
+                const response = await this.claimOfferAPI(instanceId);
+                const updatedOffer = { ...offer, status: 'claimed', };
+                this.offerStore.upsertOffer(updatedOffer);
+                this.eventEmitter.emit(exports.OfferEvent.OFFER_CLAIMED, {
+                    instanceId,
+                });
+                if (this.hooks.afterOfferClaim) {
+                    await this.hooks.afterOfferClaim(updatedOffer, offer.rewards);
+                }
+                return response;
+            }
+            catch (error) {
+                this.handleError(error, 'claim');
+                throw error;
+            }
+        }
+        /**
+         * Check if connected
+         */
+        isConnected() {
+            return this.sseConnection?.isConnected() || false;
+        }
+        /**
+         * Get current connection state
+         */
+        getConnectionState() {
+            return this.sseConnection?.getConnectionState() || exports.ConnectionState.DISCONNECTED;
+        }
+        setupInternalListeners() {
+            /*
+            this.eventEmitter.on(OfferEvent.INIT, ({ offers, playerSnapshot }) => {
+              this.offerStore.setOffers(offers);
+              this.offerStore.setSnapshot(playerSnapshot);
+              this.logger.log(`Loaded ${offers.length} offers`);
+            });
+        
+            this.eventEmitter.on(OfferEvent.OFFER_ADDED, ({ offer }) => {
+              this.offerStore.upsertOffer(offer);
+              this.logger.log(`Added offer: ${offer.instanceId}`);
+            });
+        
+            this.eventEmitter.on(OfferEvent.OFFER_UPDATED, ({ offer }) => {
+              this.offerStore.upsertOffer(offer);
+              this.logger.log(`Updated offer: ${offer.instanceId}`);
+            });
+        
+            this.eventEmitter.on(OfferEvent.SNAPSHOT_UPDATED, ({ playerSnapshot }) => {
+              this.offerStore.setSnapshot(playerSnapshot);
+              this.logger.log(`Updated player snapshot`);
+            });
+        
+            this.eventEmitter.on(OfferEvent.ERROR, ({ error, context }) => {
+              this.handleError(error, context);
+            });
+            */
+            this.eventEmitter.on(exports.OfferEvent.OFFER_SURFACED, ({ offer }) => {
+                this.offerStore.upsertOffer(offer);
+                this.logger.log(`Surfaced offer: ${offer.instanceId}`);
+            });
+        }
+        /**
+         * Helper to POST to an endpoint with JWT and handle token expiry/retry logic
+         */
+        async postWithAuth(endpoint, body, retry = false) {
+            const token = await this.tokenManager.getTokenForConnection();
+            const response = await fetch(`${this.config.endpoint}${endpoint}`, {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${token}`,
+                    'Content-Type': 'application/json'
+                },
+                body: body ? JSON.stringify(body) : undefined,
+            });
+            if (!response.ok) {
+                if (response.status === 400) {
+                    const errorData = await response.json();
+                    if ((errorData.message === 'jwt-expired' || errorData.message === 'jwt-invalid') &&
+                        !retry) {
+                        this.tokenManager.clearToken();
+                        return this.postWithAuth(endpoint, body, true);
+                    }
+                }
+                throw new Error(`Failed to POST to ${endpoint}: ${response.statusText}`);
+            }
+            return response.json();
+        }
+        async claimOfferAPI(instanceId) {
+            return this.postWithAuth('/client/reward/claim', { instanceId, kind: 'offer' });
+        }
+        async refreshOffersAndSnapshot() {
+            try {
+                const { offers, snapshot } = await this.getOffersAndSnapshot();
+                this.offerStore.setOffers(offers);
+                this.offerStore.setSnapshot(snapshot);
+                this.eventEmitter.emit(exports.OfferEvent.REFRESH, { offers, playerSnapshot: snapshot });
+                this.logger.log('Refreshed offers and player snapshot');
+            }
+            catch (error) {
+                this.handleError(error, 'refreshOffersAndSnapshot');
+                throw error;
+            }
+        }
+        async getOffersAndSnapshot() {
+            const data = await this.postWithAuth('/client/player/campaigns', { viewingCampaigns: true });
+            if (!data.offers || !Array.isArray(data.offers)) {
+                throw new Error('No offers returned from offers endpoint');
+            }
+            if (!data.snapshot) {
+                throw new Error('No player snapshot returned from offers endpoint');
+            }
+            return data;
+        }
+        async getAuthLinkToken() {
+            const data = await this.postWithAuth('/auth/one_time_token/generate');
+            if (!data.token) {
+                throw new Error('No token returned from auth link endpoint');
+            }
+            return data.token;
+        }
+        handleError(error, context) {
+            this.logger.error(`Error in ${context}:`, error);
+            if (this.hooks.onError) {
+                this.hooks.onError(error, context);
+            }
+        }
+    }
+
+    const meetsBaseConditions = ({ conditions, playerSnap, addDetails, }) => {
+        const conditionData = [];
+        let isValid = true;
+        if (conditions?.minDaysInGame) {
+            const isDisqualify = (playerSnap.daysInGame || 0) < conditions.minDaysInGame;
+            if (addDetails) {
+                conditionData.push({
+                    isMet: !isDisqualify,
+                    kind: 'minDaysInGame',
+                    trackerAmount: playerSnap.daysInGame || 0,
+                    text: `More than ${conditions.minDaysInGame} Days in Game`,
+                });
+                if (isDisqualify)
+                    isValid = false;
+            }
+            else {
+                if (isDisqualify)
+                    return { isValid: false };
+            }
+        }
+        if (conditions?.minTrustScore) {
+            const isDisqualify = (playerSnap.trustScore || 0) < conditions.minTrustScore;
+            if (addDetails) {
+                conditionData.push({
+                    isMet: !isDisqualify,
+                    kind: 'minTrustScore',
+                    trackerAmount: playerSnap.trustScore || 0,
+                    text: `More than ${conditions.minTrustScore} Rep`,
+                });
+                if (isDisqualify)
+                    isValid = false;
+            }
+            else {
+                if (isDisqualify)
+                    return { isValid: false };
+            }
+        }
+        if (conditions?.maxTrustScore) {
+            const isDisqualify = (playerSnap.trustScore || 0) > conditions.maxTrustScore;
+            if (addDetails) {
+                conditionData.push({
+                    isMet: !isDisqualify,
+                    kind: 'maxTrustScore',
+                    trackerAmount: playerSnap.trustScore || 0,
+                    text: `Less than ${conditions.maxTrustScore} Rep`,
+                });
+                if (isDisqualify)
+                    isValid = false;
+            }
+            else {
+                if (isDisqualify)
+                    return { isValid: false };
+            }
+        }
+        for (const key in conditions?.achievements) {
+            const a = conditions.achievements[key];
+            const playerAchData = playerSnap.achievements?.[key];
+            if (!playerAchData) {
+                const isDisqualify = true;
+                if (addDetails) {
+                    conditionData.push({
+                        isMet: isDisqualify,
+                        kind: 'achievements',
+                        trackerAmount: 0,
+                        text: `Have the achievement ${a.name}`,
+                    });
+                    isValid = false;
+                }
+                else {
+                    return { isValid: false };
+                }
+            }
+            if (a.minCount) {
+                const isDisqualify = (playerAchData?.count || 1) < a.minCount;
+                if (addDetails) {
+                    conditionData.push({
+                        isMet: !isDisqualify,
+                        kind: 'achievements',
+                        trackerAmount: playerAchData?.count || 0,
+                        text: `Have the achievement ${a.name} more than ${a.minCount} times`,
+                    });
+                    if (isDisqualify)
+                        isValid = false;
+                    return { isValid: false };
+                }
+                else {
+                    if (isDisqualify)
+                        return { isValid: false };
+                }
+            }
+        }
+        for (const key in conditions?.currencies) {
+            const c = conditions.currencies[key];
+            const playerCurrencyData = playerSnap.currencies?.[key];
+            if (c.min) {
+                const isDisqualify = (playerCurrencyData?.balance || 0) < c.min;
+                if (addDetails) {
+                    conditionData.push({
+                        isMet: !isDisqualify,
+                        kind: 'currencies',
+                        trackerAmount: playerCurrencyData?.balance || 0,
+                        text: `Have more than ${c.min} ${c.name}`,
+                    });
+                    if (isDisqualify)
+                        isValid = false;
+                }
+                else {
+                    if (isDisqualify)
+                        return { isValid: false };
+                }
+            }
+            if (c.max) {
+                const isDisqualify = (playerCurrencyData?.balance || 0) > c.max;
+                if (addDetails) {
+                    conditionData.push({
+                        isMet: !isDisqualify,
+                        kind: 'currencies',
+                        trackerAmount: playerCurrencyData?.balance || 0,
+                        text: `Have less than ${c.max} ${c.name}`,
+                    });
+                    if (isDisqualify)
+                        isValid = false;
+                }
+                else {
+                    if (isDisqualify)
+                        return { isValid: false };
+                }
+            }
+            if (c.in) {
+                const isDisqualify = (playerCurrencyData?.in || 0) < c.in;
+                if (addDetails) {
+                    conditionData.push({
+                        isMet: !isDisqualify,
+                        kind: 'currencies',
+                        trackerAmount: playerCurrencyData?.in || 0,
+                        text: `Deposit at least ${c.in} ${c.name}`,
+                    });
+                    if (isDisqualify)
+                        isValid = false;
+                }
+                else {
+                    if (isDisqualify)
+                        return { isValid: false };
+                }
+            }
+            if (c.out) {
+                const isDisqualify = (playerCurrencyData?.out || 0) < c.out;
+                if (addDetails) {
+                    conditionData.push({
+                        isMet: !isDisqualify,
+                        kind: 'currencies',
+                        trackerAmount: playerCurrencyData?.out || 0,
+                        text: `Withdraw at least ${c.out} ${c.name}`,
+                    });
+                    if (isDisqualify)
+                        isValid = false;
+                }
+                else {
+                    if (isDisqualify)
+                        return { isValid: false };
+                }
+            }
+        }
+        for (const key in conditions?.levels) {
+            const l = conditions.levels[key];
+            const playerLevelData = playerSnap.levels?.[key];
+            if (l.min) {
+                const isDisqualify = (playerLevelData?.level || 0) < l.min;
+                if (addDetails) {
+                    conditionData.push({
+                        isMet: !isDisqualify,
+                        kind: 'levels',
+                        trackerAmount: playerLevelData?.level || 0,
+                        text: `Be above level ${l.min} ${l.name}`,
+                    });
+                    if (isDisqualify)
+                        isValid = false;
+                }
+                else {
+                    if (isDisqualify)
+                        return { isValid: false };
+                }
+            }
+            if (l.max) {
+                const isDisqualify = (playerLevelData?.level || 0) > l.max;
+                if (addDetails) {
+                    conditionData.push({
+                        isMet: !isDisqualify,
+                        kind: 'levels',
+                        trackerAmount: playerLevelData?.level || 0,
+                        text: `Be under level ${l.max} ${l.name}`,
+                    });
+                    if (isDisqualify)
+                        isValid = false;
+                }
+                else {
+                    if (isDisqualify)
+                        return { isValid: false };
+                }
+            }
+        }
+        if (conditions?.quests) {
+            for (const questId in conditions.quests) {
+                const quest = conditions.quests[questId];
+                const playerQuestData = playerSnap.quests?.[questId];
+                const isDisqualify = playerQuestData
+                    ? (playerQuestData?.completions || 0) < (quest.completions || 0)
+                    : false;
+                if (addDetails) {
+                    conditionData.push({
+                        isMet: !isDisqualify,
+                        kind: 'quests',
+                        trackerAmount: playerQuestData?.completions || 0,
+                        text: quest.completions === 1
+                            ? `Complete the quest ${quest.name}`
+                            : (quest.completions || 0) < 1
+                                ? `Start the quest ${quest.name}`
+                                : `Complete the quest ${quest.name} ${quest.completions} times`,
+                    });
+                    if (isDisqualify)
+                        isValid = false;
+                }
+                else {
+                    if (isDisqualify)
+                        return { isValid: false };
+                }
+            }
+        }
+        for (const key in conditions?.memberships) {
+            const m = conditions.memberships[key];
+            const playerMembershipsData = playerSnap.memberships?.[key];
+            if (m.minCount) {
+                const isDisqualify = (playerMembershipsData?.count || 0) < m.minCount;
+                if (addDetails) {
+                    conditionData.push({
+                        isMet: !isDisqualify,
+                        kind: 'memberships',
+                        trackerAmount: playerMembershipsData?.count || 0,
+                        text: m.minCount > 1
+                            ? `Have at least ${m.minCount} ${m.name} memberships`
+                            : `Have a ${m.name} membership`,
+                    });
+                    if (isDisqualify)
+                        isValid = false;
+                }
+                else {
+                    if (isDisqualify)
+                        return { isValid: false };
+                }
+            }
+            if (m.maxCount) {
+                const isDisqualify = (playerMembershipsData?.count || 0) > m.maxCount;
+                if (addDetails) {
+                    conditionData.push({
+                        isMet: !isDisqualify,
+                        kind: 'memberships',
+                        trackerAmount: playerMembershipsData?.count || 0,
+                        text: `Have less than ${m.maxCount} ${m.name} memberships`,
+                    });
+                    if (isDisqualify)
+                        isValid = false;
+                }
+                else {
+                    if (isDisqualify)
+                        return { isValid: false };
+                }
+            }
+            const timeOwned = (playerMembershipsData?.expiresAt || 0) - Date.now();
+            if (m.minMs) {
+                const isDisqualify = timeOwned < m.minMs;
+                if (addDetails) {
+                    conditionData.push({
+                        isMet: !isDisqualify,
+                        kind: 'memberships',
+                        trackerAmount: Number((timeOwned / (1000 * 60 * 60 * 24)).toFixed(1)),
+                        text: `Own ${m.name} membership for at least ${(m.minMs /
+                        (1000 * 60 * 60 * 24)).toFixed(1)} days`,
+                    });
+                    if (isDisqualify)
+                        isValid = false;
+                }
+                else {
+                    if (isDisqualify)
+                        return { isValid: false };
+                }
+            }
+            if (m.maxMs) {
+                const isDisqualify = timeOwned > m.maxMs;
+                if (addDetails) {
+                    conditionData.push({
+                        isMet: !isDisqualify,
+                        kind: 'memberships',
+                        trackerAmount: Number((timeOwned / (1000 * 60 * 60 * 24)).toFixed(1)),
+                        text: `Own ${m.name} membership for less than ${(m.maxMs /
+                        (1000 * 60 * 60 * 24)).toFixed(1)} days`,
+                    });
+                    if (isDisqualify)
+                        isValid = false;
+                }
+                else {
+                    if (isDisqualify)
+                        return { isValid: false };
+                }
+            }
+        }
+        for (const key in conditions?.stakedTokens) {
+            const s = conditions.stakedTokens[key];
+            const playerStakedData = playerSnap.stakedTokens?.[key];
+            if (s.min) {
+                const isDisqualify = (playerStakedData?.balance || 0) < s.min;
+                if (addDetails) {
+                    conditionData.push({
+                        isMet: !isDisqualify,
+                        kind: 'stakedTokens',
+                        trackerAmount: playerStakedData?.balance || 0,
+                        text: `Have at least ${s.min} ${s.name} staked`,
+                    });
+                    if (isDisqualify)
+                        isValid = false;
+                }
+                else {
+                    if (isDisqualify)
+                        return { isValid: false };
+                }
+            }
+        }
+        return { isValid, conditionData: addDetails ? conditionData : undefined };
+    };
+    const meetsCompletionConditions = ({ completionConditions, completionTrackers, playerSnap, addDetails = false, }) => {
+        if (completionConditions) {
+            const conditions = completionConditions;
+            const conditionData = [];
+            let isValid = true;
+            if (conditions.buyItem) {
+                const isDisqualify = (completionTrackers?.buyItem || 0) < (conditions.buyItem.amount || 1);
+                if (addDetails) {
+                    conditionData.push({
+                        isMet: !isDisqualify,
+                        kind: 'buyItem',
+                        trackerAmount: completionTrackers?.buyItem || 0,
+                        text: `Buy ${conditions.buyItem.amount || 1} ${conditions.buyItem.name}`,
+                    });
+                    if (isDisqualify)
+                        isValid = false;
+                }
+                else {
+                    if (isDisqualify)
+                        return { isValid: false };
+                }
+            }
+            if (conditions.spendCurrency) {
+                const isDisqualify = (completionTrackers?.spendCurrency || 0) < (conditions.spendCurrency.amount || 1);
+                if (addDetails) {
+                    conditionData.push({
+                        isMet: !isDisqualify,
+                        kind: 'spendCurrency',
+                        trackerAmount: completionTrackers?.spendCurrency || 0,
+                        text: `Spend ${conditions.spendCurrency.amount || 1} ${conditions.spendCurrency.name}`,
+                    });
+                    if (isDisqualify)
+                        isValid = false;
+                }
+                else {
+                    if (isDisqualify)
+                        return { isValid: false };
+                }
+            }
+            if (conditions.depositCurrency) {
+                const isDisqualify = (completionTrackers?.depositCurrency || 0) <
+                    (conditions.depositCurrency.amount || 1);
+                if (addDetails) {
+                    conditionData.push({
+                        isMet: !isDisqualify,
+                        kind: 'depositCurrency',
+                        trackerAmount: completionTrackers?.depositCurrency || 0,
+                        text: `Deposit ${conditions.depositCurrency.amount || 1} ${conditions.depositCurrency.name}`,
+                    });
+                }
+                else {
+                    if (isDisqualify)
+                        return { isValid: false };
+                }
+            }
+            if (conditions.login) {
+                const isMet = completionTrackers?.login || false;
+                if (addDetails) {
+                    conditionData.push({
+                        isMet,
+                        kind: 'login',
+                        trackerAmount: completionTrackers?.login ? 1 : 0,
+                        text: `Login to the game`,
+                    });
+                    isValid = isMet;
+                }
+                else {
+                    if (!isMet)
+                        return { isValid: false };
+                }
+            }
+            if (conditions.loginStreak) {
+                // player's login streak snapshot right now - their login streak when offer was surfaced = their login streak since the offer was surfaced
+                // if their login streak since the offer was surfaced is less than the required login streak, then they are not yet eligible for the offer
+                const streakSinceOffer = (playerSnap.loginStreak || 0) - (completionTrackers?.currentLoginStreak || 0);
+                const isDisqualify = streakSinceOffer + 1 < conditions.loginStreak;
+                if (addDetails) {
+                    conditionData.push({
+                        isMet: !isDisqualify,
+                        kind: 'loginStreak',
+                        trackerAmount: (playerSnap.loginStreak || 0) - (completionTrackers?.currentLoginStreak || 0),
+                        text: `Login streak of ${conditions.loginStreak || 0} days`,
+                    });
+                    if (isDisqualify)
+                        isValid = false;
+                }
+                else {
+                    if (isDisqualify)
+                        return { isValid: false };
+                }
+            }
+            const r = meetsBaseConditions({
+                conditions,
+                playerSnap,
+                addDetails: true,
+            });
+            isValid = r.isValid;
+            conditionData.push(...(r.conditionData || []));
+            return { isValid, conditionData };
+        }
+        return { isValid: true, conditionData: [] };
+    };
+
+    // Taken from buildon_server/src/commons/types/offer.ts and merged into a single interface
+    const PlayerOfferStatuses = [
+        'inQueue',
+        'surfaced',
+        'viewed',
+        'claimable',
+        'claimed',
+        'expired',
+    ];
+
+    // Taken from buildon_server/src/commons/types/reward.ts
+    // Use a const assertion for the array and infer the union type directly
+    const rewardKinds = [
+        'item',
+        'coins',
+        'exp',
+        'trust_points',
+        /** on-chain rewards require the builder to send funds to a custodial wallet that we use to send to player wallets*/
+        'on_chain',
+    ];
+
+    exports.AssetHelper = AssetHelper;
+    exports.EventEmitter = EventEmitter;
+    exports.OfferStore = OfferStore;
+    exports.OfferwallClient = OfferwallClient;
+    exports.PlayerOfferStatuses = PlayerOfferStatuses;
+    exports.SSEConnection = SSEConnection;
+    exports.meetsBaseConditions = meetsBaseConditions;
+    exports.meetsCompletionConditions = meetsCompletionConditions;
+    exports.rewardKinds = rewardKinds;
+
+}));
+//# sourceMappingURL=offerwall-sdk.umd.js.map