kodenique-game-sdk 1.0.0

package/dist/lib/pusher.js

@@ -0,0 +1,137 @@
+/**
+ * Pusher integration for real-time game updates
+ * Alternative to WebSocket for easier setup
+ *
+ * Note: Install pusher-js to use this: npm install pusher-js
+ */
+export class GamePusherClient {
+    constructor(config) {
+        this.config = config;
+        this.pusher = null;
+        this.channels = new Map();
+    }
+    /**
+     * Initialize Pusher connection
+     */
+    async connect() {
+        if (this.pusher) {
+            console.log("[GamePusher] Already connected");
+            return;
+        }
+        console.log("[GamePusher] Connecting to Pusher...");
+        // Dynamic import to make pusher-js optional
+        try {
+            // @ts-ignore - dynamic import
+            const PusherModule = await import("pusher-js");
+            const PusherConstructor = PusherModule.default || PusherModule;
+            this.pusher = new PusherConstructor(this.config.key, {
+                cluster: this.config.cluster,
+                authEndpoint: this.config.authEndpoint,
+            });
+        }
+        catch (error) {
+            console.error("[GamePusher] Pusher not installed. Install with: npm install pusher-js");
+            return;
+        }
+        this.pusher.connection.bind("connected", () => {
+            console.log("[GamePusher] Connected to Pusher");
+        });
+        this.pusher.connection.bind("disconnected", () => {
+            console.log("[GamePusher] Disconnected from Pusher");
+        });
+        this.pusher.connection.bind("error", (error) => {
+            console.error("[GamePusher] Connection error:", error);
+        });
+    }
+    /**
+     * Subscribe to a game channel
+     */
+    subscribeToGame(gameId, callbacks) {
+        if (!this.pusher) {
+            console.error("[GamePusher] Not connected. Call connect() first.");
+            return;
+        }
+        const channelName = `game.${gameId}`;
+        if (this.channels.has(channelName)) {
+            console.log("[GamePusher] Already subscribed to:", channelName);
+            return;
+        }
+        console.log("[GamePusher] Subscribing to channel:", channelName);
+        const channel = this.pusher.subscribe(channelName);
+        // Listen for game update events
+        if (callbacks.onGameUpdate) {
+            channel.bind("game-update", callbacks.onGameUpdate);
+        }
+        // Listen for score update events
+        if (callbacks.onScoreUpdate) {
+            channel.bind("score-update", callbacks.onScoreUpdate);
+        }
+        // Listen for status update events
+        if (callbacks.onStatusUpdate) {
+            channel.bind("status-update", callbacks.onStatusUpdate);
+        }
+        // Listen for game ended events
+        if (callbacks.onGameEnded) {
+            channel.bind("game-ended", callbacks.onGameEnded);
+        }
+        this.channels.set(channelName, channel);
+    }
+    /**
+     * Unsubscribe from a game channel
+     */
+    unsubscribeFromGame(gameId) {
+        const channelName = `game.${gameId}`;
+        if (!this.channels.has(channelName)) {
+            console.log("[GamePusher] Not subscribed to:", channelName);
+            return;
+        }
+        console.log("[GamePusher] Unsubscribing from channel:", channelName);
+        if (this.pusher) {
+            this.pusher.unsubscribe(channelName);
+        }
+        this.channels.delete(channelName);
+    }
+    /**
+     * Disconnect from Pusher
+     */
+    disconnect() {
+        if (!this.pusher)
+            return;
+        console.log("[GamePusher] Disconnecting from Pusher");
+        // Unsubscribe from all channels
+        this.channels.forEach((_, channelName) => {
+            var _a;
+            (_a = this.pusher) === null || _a === void 0 ? void 0 : _a.unsubscribe(channelName);
+        });
+        this.channels.clear();
+        this.pusher.disconnect();
+        this.pusher = null;
+    }
+    /**
+     * Check if connected
+     */
+    isConnected() {
+        var _a;
+        return ((_a = this.pusher) === null || _a === void 0 ? void 0 : _a.connection.state) === "connected";
+    }
+}
+// Singleton instance
+let pusherClient = null;
+/**
+ * Initialize the global Pusher client
+ */
+export function initializePusher(config) {
+    if (pusherClient) {
+        console.warn("[GamePusher] Already initialized");
+        return pusherClient;
+    }
+    pusherClient = new GamePusherClient(config);
+    pusherClient.connect();
+    return pusherClient;
+}
+/**
+ * Get the global Pusher client
+ */
+export function getPusherClient() {
+    return pusherClient;
+}

package/dist/types.d.ts

@@ -0,0 +1,87 @@
+export interface Team {
+    id: string;
+    game_id: string;
+    team_name: string;
+    team_color: string;
+    logo_url: string;
+    current_score: number;
+    created_at: string;
+    updated_at: string;
+}
+export interface Round {
+    id: string;
+    game_id: string;
+    round_number: number;
+    status: 'active' | 'open' | 'closed' | 'finished' | 'cancelled';
+    red_team_score: number;
+    blue_team_score: number;
+    result: 'red_win' | 'blue_win' | 'draw' | null;
+    winner_team_id: string | null;
+    started_at: string;
+    ended_at: string | null;
+    metadata: any;
+    created_at: string;
+    updated_at: string;
+    winnerTeam: {
+        id: string;
+        team_name: string;
+        team_color: string;
+    } | null;
+}
+export interface Creator {
+    id: string;
+    username: string;
+    email: string;
+}
+export interface Game {
+    id: string;
+    game_name: string;
+    description: string;
+    status: 'active' | 'live' | 'paused' | 'finished' | 'cancelled';
+    scheduled_start: string;
+    started_at: string | null;
+    ended_at: string | null;
+    metadata: Record<string, any> | null;
+    display_stream_url: string;
+    stream_name?: string;
+    stream_server?: string;
+    created_at: string;
+    updated_at: string;
+    teams: Team[];
+    rounds: Round[];
+    creator: Creator;
+}
+export interface GamesApiResponse {
+    data: Game[];
+}
+export interface GameProviderProps {
+    access_token: string;
+    api_url?: string;
+    children: React.ReactNode;
+    socketToken?: string;
+    environment?: 'development' | 'staging' | 'production';
+    websocketUrl?: string;
+}
+export interface GameContextType {
+    access_token: string;
+    api_url: string;
+    subscribeToGame: (gameId: string) => void;
+    unsubscribeFromGame: (gameId: string) => void;
+    getGame: (gameId: string) => Game | undefined;
+    updateGame: (game: Game) => void;
+    isConnected: boolean;
+    subscribedGameIds: string[];
+    activeGames: Game[];
+}
+export interface UseGamesOptions {
+    access_token?: string;
+    api_url?: string;
+}
+export interface UseGamesReturn {
+    games: Game[];
+    fetchGames: () => Promise<Game[]>;
+    getGameById: (gameId: string) => Game | undefined;
+    loading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/useGames.d.ts

@@ -0,0 +1,2 @@
+import { UseGamesOptions, UseGamesReturn } from "./types";
+export declare const useGames: (options?: UseGamesOptions) => UseGamesReturn;

package/dist/useGames.js

@@ -0,0 +1,73 @@
+import { useState, useCallback } from "react";
+import { useGameContext } from "./GameContext";
+export const useGames = (options) => {
+    const [games, setGames] = useState([]);
+    const [loading, setLoading] = useState(false);
+    const [error, setError] = useState(null);
+    // Try to get context, but allow options to override
+    let contextConfig;
+    try {
+        contextConfig = useGameContext();
+    }
+    catch (e) {
+        // No context available, use options
+        contextConfig = null;
+    }
+    const access_token = (options === null || options === void 0 ? void 0 : options.access_token) || (contextConfig === null || contextConfig === void 0 ? void 0 : contextConfig.access_token);
+    const api_url = (options === null || options === void 0 ? void 0 : options.api_url) ||
+        (contextConfig === null || contextConfig === void 0 ? void 0 : contextConfig.api_url) ||
+        "http://localhost:5001/v1/external/games";
+    if (!access_token) {
+        throw new Error("access_token is required. Provide it via useGames options or GameProvider.");
+    }
+    // Fetch all games that the access token has permission to view
+    const fetchGames = useCallback(async () => {
+        setLoading(true);
+        setError(null);
+        // Debug logging
+        console.log("[useGames] Fetching from:", api_url);
+        console.log("[useGames] Access token:", access_token ? "Present" : "Missing");
+        try {
+            const response = await fetch(api_url, {
+                method: "GET",
+                headers: {
+                    Authorization: `Bearer ${access_token}`,
+                    "Content-Type": "application/json",
+                },
+            });
+            if (!response.ok) {
+                if (response.status === 401) {
+                    throw new Error("Unauthorized - Invalid or expired access token");
+                }
+                throw new Error(`Failed to fetch games: ${response.statusText}`);
+            }
+            const result = await response.json();
+            setGames(result.data);
+            return result.data;
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error("Unknown error occurred");
+            setError(error);
+            throw error;
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [access_token, api_url]);
+    // Helper function to get a specific game by ID from the cached games
+    const getGameById = useCallback((gameId) => {
+        return games.find((game) => game.id === gameId);
+    }, [games]);
+    // Refetch function for manual refresh
+    const refetch = useCallback(async () => {
+        await fetchGames();
+    }, [fetchGames]);
+    return {
+        games,
+        fetchGames,
+        getGameById,
+        loading,
+        error,
+        refetch,
+    };
+};

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "kodenique-game-sdk",
+  "version": "1.0.0",
+  "description": "React SDK for real-time game streaming with WebSocket updates and WebRTC video player",
+  "main": "dist/index.js",
+  "module": "dist/index.esm.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.esm.js",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "test": "jest",
+    "prepublishOnly": "npm run build",
+    "clean": "rm -rf dist"
+  },
+  "keywords": [
+    "react",
+    "game",
+    "sdk",
+    "websocket",
+    "webrtc",
+    "streaming",
+    "real-time",
+    "video-player",
+    "socketcluster",
+    "whep",
+    "live-streaming"
+  ],
+  "author": "Kodenique",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kodenique/game-sdk.git"
+  },
+  "bugs": {
+    "url": "https://github.com/kodenique/game-sdk/issues"
+  },
+  "homepage": "https://github.com/kodenique/game-sdk#readme",
+  "peerDependencies": {
+    "react": "^16.8.0 || ^17.0.0 || ^18.0.0",
+    "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.0.10",
+    "@types/react": "^18.0.0",
+    "@types/react-dom": "^18.0.0",
+    "typescript": "^5.0.0"
+  },
+  "dependencies": {
+    "@types/pako": "^2.0.4",
+    "axios": "^1.7.9",
+    "pako": "^2.1.0",
+    "socketcluster-wrapper-client": "^1.1.8"
+  }
+}