waitless-api 0.1.0

package/dist/ads/AdPlayer.d.ts

@@ -0,0 +1,62 @@
+export interface AdConfig {
+    adTagUrl: string;
+    maxDuration?: number;
+    onAdStarted?: () => void;
+    onAdComplete?: () => void;
+    onAdError?: (error: any) => void;
+    onAdSkipped?: () => void;
+}
+declare global {
+    interface Window {
+        google?: {
+            ima: {
+                AdDisplayContainer: new (container: HTMLElement, videoElement: HTMLVideoElement) => any;
+                AdsLoader: new (adDisplayContainer: any) => any;
+                AdsManagerLoadedEvent: {
+                    Type: {
+                        ADS_MANAGER_LOADED: string;
+                    };
+                };
+                AdErrorEvent: {
+                    Type: {
+                        AD_ERROR: string;
+                    };
+                };
+                AdsRequest: new () => any;
+                AdsRenderingSettings: new () => any;
+                AdEvent: {
+                    Type: {
+                        CONTENT_PAUSE_REQUESTED: string;
+                        CONTENT_RESUME_REQUESTED: string;
+                        ALL_ADS_COMPLETED: string;
+                        SKIPPED: string;
+                    };
+                };
+                ViewMode: {
+                    NORMAL: number;
+                };
+            };
+        };
+    }
+}
+export declare class AdPlayer {
+    private container;
+    private adDisplayContainer;
+    private adsLoader;
+    private adsManager;
+    private videoElement;
+    private adContainer;
+    private loadingOverlay;
+    private adBadge;
+    constructor(container: HTMLElement);
+    private setupElements;
+    private showLoadingOverlay;
+    private removeLoadingOverlay;
+    private showErrorOverlay;
+    playAd(config: AdConfig): Promise<void>;
+    private loadIMAScript;
+    private initializeAd;
+    private onAdsManagerLoaded;
+    private cleanup;
+    destroy(): void;
+}

package/dist/core.d.ts

@@ -0,0 +1,132 @@
+export type GameType = 'tetris' | 'snake' | 'breakout';
+export type ThemeType = 'default' | 'cyberpunk' | 'minimal' | 'corporate';
+/** Ad config shape from dashboard/backend (used by showAd and overrides) */
+export interface WaitlessConfig {
+    strategy?: {
+        preset?: string;
+        behavior?: string;
+    };
+    frequency?: {
+        minInterval?: number;
+        maxAdsPerSession?: number;
+        maxAdsPerHour?: number;
+    };
+    duration?: {
+        shortThreshold?: number;
+        longThreshold?: number;
+        adMaxDuration?: number;
+        enableGames?: boolean;
+    };
+    batch?: {
+        enabled?: boolean;
+        showAdOnce?: boolean;
+    };
+    fallback?: {
+        type?: string;
+        showMessage?: boolean;
+    };
+    analytics?: {
+        trackEvents?: boolean;
+        enableABTesting?: boolean;
+    };
+}
+export interface GameOptions {
+    game?: GameType;
+    theme?: ThemeType;
+    message?: string;
+    container?: HTMLElement | string;
+    width?: number;
+    height?: number;
+    onStart?: () => void;
+    onScore?: (score: number) => void;
+    onEnd?: () => void;
+    showAds?: boolean;
+    adTagUrl?: string;
+    adDuration?: number;
+    adPlacement?: 'pre-game' | 'post-game' | 'both';
+}
+export declare class WaitlessAPI {
+    private apiKey;
+    private baseUrl;
+    private apiBaseUrl;
+    private defaultAdTagUrl;
+    private sessionId;
+    private container;
+    private gameInstance;
+    private isPlaying;
+    private lastBackendConfig;
+    private config;
+    private configLoaded;
+    private configPromise;
+    private batchIdsSeen;
+    private lastAdTime;
+    private adsThisSession;
+    private adsThisHour;
+    private lastHourStart;
+    /**
+     * Initialize the WaitlessAPI SDK
+     * @param apiKey Your WaitlessAPI key
+     * @param baseUrlOrOptions Base URL string or options object with apiBaseUrl (defaults to production)
+     */
+    constructor(apiKey: string, baseUrlOrOptions?: string | {
+        apiBaseUrl?: string;
+    });
+    private getDefaultConfig;
+    private getCachedConfig;
+    private cacheConfig;
+    private loadConfig;
+    /** Wait for config to be loaded (e.g. before using showAd). */
+    private ensureConfigLoaded;
+    /** Clear cache and reload config from API. */
+    refreshConfig(): Promise<void>;
+    /** Return current config (for debugging). */
+    getConfig(): WaitlessConfig | null;
+    /**
+     * Run processing with a minimal fallback UI (spinner/message). No ad or game.
+     */
+    private showProcessing;
+    private shouldShowAd;
+    private recordAdShown;
+    /**
+     * Config-driven entry point: show ad and/or game based on dashboard config, then run processing.
+     */
+    showAd<T>(processingFn: () => Promise<T>, options?: {
+        estimatedDuration?: number;
+        batchId?: string;
+        message?: string;
+        overrideConfig?: Partial<WaitlessConfig>;
+    }): Promise<T>;
+    /**
+     * Show a game while executing a long-running function
+     * @param processingFn The function to execute while showing the game
+     * @param options Game configuration options
+     * @returns Promise with the result of the processing function
+     */
+    showGame<T>(processingFn: () => Promise<T>, options?: GameOptions): Promise<T>;
+    /**
+     * Create a new game session with the API
+     * @param options Game options
+     * @returns Session id and config (null for demo/offline)
+     */
+    private createSession;
+    /**
+     * Initialize the game UI container
+     * @param options Game options
+     * @returns container and overlay (overlay is non-null when we created the full-screen div)
+     */
+    private initializeGameUI;
+    /**
+     * Start the game
+     * @param options Game options
+     * @returns The game instance
+     */
+    private startGame;
+    private playAdInContainer;
+    private trackAdEvent;
+    private cleanup;
+    /**
+     * End the game and send session complete (overlay removal is done in cleanup)
+     */
+    private endGame;
+    private completeSession;
+}

package/dist/games/base.d.ts

@@ -0,0 +1,54 @@
+import { ThemeType } from '../core';
+export interface GameConfig {
+    container: HTMLElement;
+    theme?: ThemeType;
+    onScore?: (score: number) => void;
+    /** Backend/sync: dimensions and speed */
+    width?: number;
+    height?: number;
+    speed?: number;
+    /** Game-specific (Tetris: blockSize, scoring; Snake: gridSize, foodValue; Breakout: paddleWidth, brickRows, ballSpeed) */
+    [key: string]: any;
+}
+/**
+ * Base game class with common functionality
+ */
+export declare abstract class BaseGame {
+    protected container: HTMLElement;
+    protected theme: ThemeType;
+    protected isRunning: boolean;
+    protected score: number;
+    protected onScoreCallback?: (score: number) => void;
+    constructor(config: GameConfig);
+    /**
+     * Start the game
+     */
+    abstract start(): void;
+    /**
+     * Pause the game
+     */
+    abstract pause(): void;
+    /**
+     * Resume the game
+     */
+    abstract resume(): void;
+    /**
+     * Destroy the game and clean up
+     */
+    abstract destroy(): void;
+    /**
+     * Update the score and trigger callback
+     * @param points Points to add to the score
+     */
+    protected updateScore(points: number): void;
+    /**
+     * Get the current score
+     * @returns Current score
+     */
+    getScore(): number;
+    /**
+     * Check if the game is currently running
+     * @returns Whether the game is running
+     */
+    isActive(): boolean;
+}

package/dist/games/breakout.d.ts

@@ -0,0 +1,45 @@
+import { BaseGame, GameConfig } from './base';
+/**
+ * Breakout game implementation
+ */
+export default class BreakoutGame extends BaseGame {
+    private canvas;
+    private ctx;
+    private paddle;
+    private ball;
+    private bricks;
+    private animationFrame;
+    private lastTime;
+    private ballLaunched;
+    private lives;
+    private level;
+    private highScore;
+    private paused;
+    private readonly width;
+    private readonly height;
+    private readonly paddleWidth;
+    private readonly paddleHeight;
+    private readonly ballRadius;
+    private readonly brickRows;
+    private readonly brickColumns;
+    private baseBallSpeed;
+    private brickPadding;
+    private brickOffsetTop;
+    constructor(config: GameConfig);
+    private getColors;
+    start(): void;
+    pause(): void;
+    resume(): void;
+    destroy(): void;
+    private update;
+    private initBricks;
+    private resetGame;
+    private launchBall;
+    private updateGameState;
+    private draw;
+    private handleMouseMove;
+    private handleTouchMove;
+    private handleClick;
+    private handleKeyDown;
+    private setupControls;
+}

package/dist/games/index.d.ts

@@ -0,0 +1,11 @@
+import { GameType } from '../core';
+import { GameConfig } from './base';
+export { GameConfig } from './base';
+export { BaseGame } from './base';
+/**
+ * Load a game instance
+ * @param gameType Type of game to load
+ * @param config Game configuration
+ * @returns Game instance
+ */
+export declare function loadGame(gameType: GameType, config: GameConfig): any;

package/dist/games/snake.d.ts

@@ -0,0 +1,40 @@
+import { BaseGame, GameConfig } from './base';
+/**
+ * Snake game implementation
+ */
+export default class SnakeGame extends BaseGame {
+    private canvas;
+    private ctx;
+    private snake;
+    private food;
+    private direction;
+    private nextDirection;
+    private animationFrame;
+    private lastTime;
+    private moveInterval;
+    private moveCounter;
+    private highScore;
+    private gridSize;
+    private cellSize;
+    private gridWidth;
+    private gridHeight;
+    private foodValue;
+    private touchStartX;
+    private touchStartY;
+    constructor(config: GameConfig);
+    private getColors;
+    start(): void;
+    pause(): void;
+    resume(): void;
+    destroy(): void;
+    private update;
+    private draw;
+    private resetGame;
+    private spawnFood;
+    private moveSnake;
+    private gameOver;
+    private handleKeyDown;
+    private handleTouchStart;
+    private handleTouchEnd;
+    private setupControls;
+}

package/dist/games/tetris.d.ts

@@ -0,0 +1,94 @@
+import { BaseGame, GameConfig } from './base';
+/**
+ * Tetris game implementation
+ */
+export default class TetrisGame extends BaseGame {
+    private canvas;
+    private ctx;
+    private grid;
+    private currentPiece;
+    private nextPiece;
+    private animationFrame;
+    private lastTime;
+    private dropInterval;
+    private dropCounter;
+    private cols;
+    private rows;
+    private blockSize;
+    private scoring;
+    private readonly shapes;
+    private readonly colors;
+    constructor(config: GameConfig);
+    /**
+     * Start the game
+     */
+    start(): void;
+    /**
+     * Pause the game
+     */
+    pause(): void;
+    /**
+     * Resume the game
+     */
+    resume(): void;
+    /**
+     * Destroy the game and clean up
+     */
+    destroy(): void;
+    /**
+     * Main game update loop
+     */
+    private update;
+    /**
+     * Draw the game state
+     */
+    private draw;
+    /**
+     * Draw the game grid
+     */
+    private drawGrid;
+    /**
+     * Draw a tetromino piece
+     */
+    private drawPiece;
+    /**
+     * Reset the game grid
+     */
+    private resetGrid;
+    /**
+     * Create a new tetromino piece
+     */
+    private createPiece;
+    /**
+     * Move the current piece down
+     */
+    private dropPiece;
+    /**
+     * Check if the current piece collides with the grid or boundaries
+     */
+    private checkCollision;
+    /**
+     * Merge the current piece with the grid
+     */
+    private mergePiece;
+    /**
+     * Check for completed lines and remove them
+     */
+    private checkLines;
+    /**
+     * Move the current piece left or right
+     */
+    private movePiece;
+    /**
+     * Rotate the current piece
+     */
+    private rotatePiece;
+    /**
+     * Handle keyboard input
+     */
+    private handleKeyDown;
+    /**
+     * Set up control event listeners
+     */
+    private setupControls;
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import { WaitlessAPI, GameOptions, GameType, ThemeType, WaitlessConfig } from './core';
+export { WaitlessAPI, GameOptions, GameType, ThemeType, WaitlessConfig };
+export { AdPlayer, AdConfig } from './ads/AdPlayer';
+export default WaitlessAPI;