gametime-api-client 1.0.0

package/README.md

@@ -0,0 +1,102 @@
+# Gametime API Client
+
+A typed JavaScript client for the [Gametime API](https://gametimeapi.onrender.com) – live sports data, player analysis, and predictions for NBA & Soccer.
+
+## Install
+
+```bash
+npm install gametime-api-client
+```
+
+## Usage
+
+### Quick start
+
+```js
+import { gametime } from 'gametime-api-client';
+
+// Live soccer games
+const games = await gametime.live.games('soccer');
+console.log(games[0]); // { sportEventId, homeTeam, awayTeam, score, ... }
+
+// One-line soccer analysis (auto-picks game + focus player)
+const analysis = await gametime.live.soccerAnalysis({
+  sportEventId: games[0].sportEventId,
+});
+console.log(analysis.prediction.projectedFinal); // { goals, assists, shots, touches }
+```
+
+### Custom base URL
+
+```js
+import { createClient } from 'gametime-api-client';
+
+const api = createClient({ baseUrl: 'https://gametimeapi.onrender.com' });
+
+const nbaGames = await api.live.games('nba');
+const nbaAnalysis = await api.live.nbaAnalysis({
+  sportEventId: nbaGames[0].sportEventId,
+  focusPlayerId: 'some-player-id',
+});
+```
+
+### Full flow (soccer)
+
+```js
+import { createClient } from 'gametime-api-client';
+
+const api = createClient();
+
+// 1. Get live games
+const games = await api.live.games('soccer');
+
+// 2. Optional: list players for a game
+const players = await api.live.players(games[0].sportEventId, 'soccer');
+
+// 3. Get prediction analysis (focus player optional; API can auto-pick)
+const analysis = await api.live.soccerAnalysis({
+  sportEventId: games[0].sportEventId,
+  focusPlayerId: players[0]?.playerId, // optional
+});
+
+console.log(analysis.live.currentTotals);   // goals, assists, shots, touches
+console.log(analysis.prediction.projectedFinal);
+```
+
+### Error handling
+
+```js
+import { gametime, ApiError } from 'gametime-api-client';
+
+try {
+  const games = await gametime.live.games('soccer');
+} catch (err) {
+  if (err instanceof ApiError) {
+    console.error(err.message, err.status, err.code);
+  }
+  throw err;
+}
+```
+
+## API reference
+
+| Method | Description |
+|--------|-------------|
+| `live.games(sport)` | `'soccer' \| 'nba'` – list in-progress live games |
+| `live.players(sportEventId, sport)` | List players for a game |
+| `live.soccerAnalysis({ sportEventId, focusPlayerId? })` | Soccer prediction analysis |
+| `live.nbaAnalysis({ sportEventId, focusPlayerId?, verbosity? })` | NBA prediction analysis |
+| `live.createSession({ sport, sportEventId, focusPlayerId? })` | Create live WebSocket session |
+
+## Types
+
+The client is written in TypeScript and ships with `.d.ts` definitions. Import types for better IDE support:
+
+```ts
+import type { LiveGame, SoccerAnalysis, NbaAnalysis } from 'gametime-api-client';
+```
+
+## Links
+
+- **Hosted API**: https://gametimeapi.onrender.com
+- **API docs**: See main project README

package/dist/index.d.ts

@@ -0,0 +1,133 @@
+/**
+ * Gametime API JavaScript Client
+ * Live sports data, player analysis, and predictions for NBA & Soccer.
+ *
+ * @example
+ * ```js
+ * import { createClient } from 'gametime-api-client';
+ * const api = createClient({ baseUrl: 'https://gametimeapi.onrender.com' });
+ * const games = await api.live.games('soccer');
+ * const analysis = await api.live.soccerAnalysis({ sportEventId: games[0].sportEventId });
+ * ```
+ */
+export interface ClientOptions {
+    /** API base URL. Default: https://gametimeapi.onrender.com */
+    baseUrl?: string;
+}
+declare class ApiError extends Error {
+    code?: string | undefined;
+    status?: number | undefined;
+    details?: unknown | undefined;
+    constructor(message: string, code?: string | undefined, status?: number | undefined, details?: unknown | undefined);
+}
+/** Live games and analysis */
+export interface LiveApi {
+    /** Fetch in-progress live games for a sport */
+    games(sport: "soccer" | "nba"): Promise<LiveGame[]>;
+    /** Fetch players for a specific game */
+    players(sportEventId: string, sport: "soccer" | "nba"): Promise<LivePlayer[]>;
+    /** Soccer player prediction analysis (auto-picks focus player if not provided) */
+    soccerAnalysis(params: {
+        sportEventId: string;
+        focusPlayerId?: string;
+        focusPlayerName?: string;
+    }): Promise<SoccerAnalysis>;
+    /** NBA player prediction analysis */
+    nbaAnalysis(params: {
+        sportEventId: string;
+        focusPlayerId?: string;
+        focusPlayerName?: string;
+        verbosity?: "short" | "medium" | "high";
+    }): Promise<NbaAnalysis>;
+    /** Create a live session for WebSocket streaming */
+    createSession(params: {
+        sport: "soccer" | "nba";
+        sportEventId: string;
+        focusPlayerId?: string;
+        focusPlayerName?: string;
+    }): Promise<{
+        id: string;
+    }>;
+}
+export interface LiveGame {
+    sportEventId: string;
+    scheduled?: string;
+    status?: string;
+    homeTeam?: string;
+    awayTeam?: string;
+    score?: string | null;
+    competition?: string | null;
+    analysis?: Record<string, unknown>;
+}
+export interface LivePlayer {
+    playerId: string;
+    name?: string | null;
+    teamId?: string | null;
+    teamName?: string | null;
+    touches?: number;
+    isActive?: boolean;
+}
+export interface SoccerAnalysis {
+    sport: "soccer";
+    sportEventId: string;
+    player: {
+        playerId: string;
+        name: string;
+        teamId?: string | null;
+    };
+    live: {
+        elapsedMinutes: number;
+        currentTotals: {
+            goals: number;
+            assists: number;
+            shots: number;
+            touches: number;
+        };
+    };
+    historical: {
+        averages: Record<string, number>;
+    };
+    prediction: {
+        projectedFinal: Record<string, number>;
+        blendedPrediction: Record<string, number>;
+        confidence: string;
+    };
+    matchEnded: boolean;
+    narration?: Record<string, unknown>;
+}
+export interface NbaAnalysis {
+    sport: "nba";
+    sportEventId: string;
+    player: {
+        playerId: string;
+        name: string;
+        teamId?: string | null;
+    };
+    live: {
+        elapsedSeconds: number;
+        currentTotals: {
+            pts: number;
+            ast: number;
+            reb: number;
+            threePm: number;
+        };
+    };
+    historical: {
+        averages: Record<string, number>;
+    };
+    prediction: {
+        projectedFinal: Record<string, number>;
+        blendedPrediction: Record<string, number>;
+        confidence: string;
+    };
+    narration?: Record<string, unknown>;
+}
+/** Create a Gametime API client */
+export declare function createClient(options?: ClientOptions): {
+    live: LiveApi;
+};
+/** Pre-built client using default hosted API URL */
+export declare const gametime: {
+    live: LiveApi;
+};
+export { ApiError };

package/dist/index.js

@@ -0,0 +1,70 @@
+/**
+ * Gametime API JavaScript Client
+ * Live sports data, player analysis, and predictions for NBA & Soccer.
+ *
+ * @example
+ * ```js
+ * import { createClient } from 'gametime-api-client';
+ * const api = createClient({ baseUrl: 'https://gametimeapi.onrender.com' });
+ * const games = await api.live.games('soccer');
+ * const analysis = await api.live.soccerAnalysis({ sportEventId: games[0].sportEventId });
+ * ```
+ */
+const DEFAULT_BASE = "https://gametimeapi.onrender.com";
+class ApiError extends Error {
+    constructor(message, code, status, details) {
+        super(message);
+        this.code = code;
+        this.status = status;
+        this.details = details;
+        this.name = "GametimeApiError";
+    }
+}
+async function request(baseUrl, path, init) {
+    const url = `${baseUrl.replace(/\/$/, "")}${path}`;
+    const res = await fetch(url, {
+        ...init,
+        headers: { "Content-Type": "application/json", ...init?.headers },
+    });
+    const body = await res.json().catch(() => ({}));
+    if (!res.ok) {
+        const err = body?.error ?? body;
+        throw new ApiError(err?.message ?? body?.message ?? res.statusText, err?.code, res.status, err?.details);
+    }
+    return body;
+}
+function get(baseUrl, path) {
+    return request(baseUrl, path, { method: "GET" });
+}
+function post(baseUrl, path, body) {
+    return request(baseUrl, path, {
+        method: "POST",
+        body: JSON.stringify(body),
+    });
+}
+/** Create a Gametime API client */
+export function createClient(options = {}) {
+    const baseUrl = options.baseUrl ?? DEFAULT_BASE;
+    const live = {
+        games(sport) {
+            return get(baseUrl, `/v1/live/games?sport=${sport}`);
+        },
+        players(sportEventId, sport) {
+            const path = `/v1/live/games/${encodeURIComponent(sportEventId)}/players?sport=${sport}`;
+            return get(baseUrl, path);
+        },
+        async soccerAnalysis(params) {
+            return post(baseUrl, "/v1/live/soccer/analysis", params);
+        },
+        async nbaAnalysis(params) {
+            return post(baseUrl, "/v1/live/nba/analysis", params);
+        },
+        async createSession(params) {
+            return post(baseUrl, "/v1/live/sessions", params);
+        },
+    };
+    return { live };
+}
+/** Pre-built client using default hosted API URL */
+export const gametime = createClient();
+export { ApiError };

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "gametime-api-client",
+  "version": "1.0.0",
+  "description": "JavaScript client for Gametime API - live sports data, player analysis, and predictions",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": ["gametime", "sports", "api", "nba", "soccer", "live", "prediction"],
+  "author": "",
+  "license": "MIT",
+  "devDependencies": {
+    "typescript": "^5.9.2"
+  }
+}