@ekmanss/5eplay 20260716.0.0

package/dist/http.js

@@ -0,0 +1,75 @@
+import { FiveEPlayError } from './errors.js';
+export async function fetchJson(context, url, options) {
+    const startedAt = performance.now();
+    let response;
+    try {
+        response = await context.fetch(url, {
+            method: options.method ?? 'GET',
+            signal: context.signal,
+            headers: options.body === undefined ? undefined : { 'content-type': 'application/json' },
+            body: options.body === undefined ? undefined : JSON.stringify(options.body),
+        });
+    }
+    catch (error) {
+        if (context.signal.aborted)
+            throw context.signal.reason;
+        throw new FiveEPlayError('5EPlay request failed', {
+            code: 'HTTP_ERROR',
+            operation: context.operation,
+            stage: options.stage,
+            retryable: true,
+            matchId: context.matchId,
+            cause: error,
+        });
+    }
+    const body = await response.text();
+    context.diagnostics.push({
+        kind: options.kind,
+        status: response.status,
+        durationMs: Math.round((performance.now() - startedAt) * 100) / 100,
+        bytes: new TextEncoder().encode(body).byteLength,
+        ...(options.mapNumber === undefined ? {} : { mapNumber: options.mapNumber }),
+        ...(options.tab === undefined ? {} : { tab: options.tab }),
+        ...(options.page === undefined ? {} : { page: options.page }),
+    });
+    if (response.status === 404) {
+        throw new FiveEPlayError('5EPlay match was not found', {
+            code: 'MATCH_NOT_FOUND', operation: context.operation, stage: options.stage,
+            retryable: false, matchId: context.matchId, details: { status: response.status },
+        });
+    }
+    if (!response.ok) {
+        throw new FiveEPlayError(`5EPlay request returned HTTP ${response.status}`, {
+            code: 'HTTP_ERROR', operation: context.operation, stage: options.stage,
+            retryable: response.status === 429 || response.status >= 500,
+            matchId: context.matchId, details: { status: response.status },
+        });
+    }
+    try {
+        return JSON.parse(body);
+    }
+    catch (error) {
+        throw new FiveEPlayError('5EPlay returned invalid JSON', {
+            code: 'INVALID_RESPONSE', operation: context.operation, stage: options.stage,
+            retryable: true, matchId: context.matchId, cause: error,
+        });
+    }
+}
+export function responseData(value, context) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+        throw new FiveEPlayError('5EPlay response envelope is invalid', {
+            code: 'INVALID_RESPONSE', retryable: true, ...context,
+        });
+    }
+    const envelope = value;
+    if (envelope.success !== true || !('data' in envelope)) {
+        throw new FiveEPlayError('5EPlay response reported failure', {
+            code: 'INVALID_RESPONSE', retryable: true, ...context,
+            details: {
+                errcode: typeof envelope.errcode === 'number' ? envelope.errcode : null,
+                message: typeof envelope.message === 'string' ? envelope.message : null,
+            },
+        });
+    }
+    return envelope.data;
+}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { getFiveEPlayMatch } from './client.js';
+export { FiveEPlayError } from './errors.js';
+export { matchIdentityFromInput } from './input.js';
+export { getFiveEPlayLiveMatches } from './live_matches.js';
+export { renderFiveEPlayMatchMarkdown } from './markdown.js';
+export { createFiveEPlayMatchSession } from './session.js';
+export { fiveEPlayMarkdownOutputPath, writeFiveEPlayMatchMarkdown, } from './write_markdown.js';
+export type { FiveEPlayMarkdownOptions } from './markdown.js';
+export type { WriteFiveEPlayMatchMarkdownOptions, WriteFiveEPlayMatchMarkdownResult, } from './write_markdown.js';
+export type { CreateFiveEPlayMatchSessionOptions, FiveEPlayAnalysisMap, FiveEPlayAnalysisPlayer, FiveEPlayBombEvent, FiveEPlayClientOptions, FiveEPlayCommunityCard, FiveEPlayCommunityRatings, FiveEPlayCommunityScore, FiveEPlayDiagnosticWarning, FiveEPlayErrorCode, FiveEPlayHalfScore, FiveEPlayJson, FiveEPlayJsonObject, FiveEPlayLiveMatch, FiveEPlayLiveMatchMap, FiveEPlayLiveMatchesData, FiveEPlayLiveMatchesDiagnostics, FiveEPlayLiveMatchTeam, FiveEPlayKillEvent, FiveEPlayLogEvent, FiveEPlayLogPlayer, FiveEPlayMap, FiveEPlayMapStatus, FiveEPlayMatch, FiveEPlayMatchDiagnostics, FiveEPlayMatchIdentity, FiveEPlayMatchSession, FiveEPlayMatchStatus, FiveEPlayOperation, FiveEPlayPlayerDuel, FiveEPlayPlayerEquipment, FiveEPlayPlayerMetrics, FiveEPlayPlayerStats, FiveEPlayPrematchAnalysis, FiveEPlayProgressEvent, FiveEPlayRealtimeUpdate, FiveEPlayRequestDiagnostic, FiveEPlayRequestOptions, FiveEPlayRoundEnd, FiveEPlayRoundStart, FiveEPlaySide, FiveEPlayStage, FiveEPlayTeam, FiveEPlayTeamMapState, FiveEPlayTeamPlayerStats, FiveEPlayTournament, FiveEPlayVetoEntry, FiveEPlayWebSocketFactory, FiveEPlayWebSocketLike, GetFiveEPlayMatchOptions, GetFiveEPlayMatchResult, GetFiveEPlayLiveMatchesOptions, GetFiveEPlayLiveMatchesResult, } from './types.js';

package/dist/index.js

@@ -0,0 +1,7 @@
+export { getFiveEPlayMatch } from './client.js';
+export { FiveEPlayError } from './errors.js';
+export { matchIdentityFromInput } from './input.js';
+export { getFiveEPlayLiveMatches } from './live_matches.js';
+export { renderFiveEPlayMatchMarkdown } from './markdown.js';
+export { createFiveEPlayMatchSession } from './session.js';
+export { fiveEPlayMarkdownOutputPath, writeFiveEPlayMatchMarkdown, } from './write_markdown.js';

package/dist/input.d.ts

@@ -0,0 +1,3 @@
+import type { FiveEPlayMatchIdentity } from './types.js';
+export declare function matchIdentityFromInput(input: string): FiveEPlayMatchIdentity | null;
+export declare function requireMatchIdentity(input: string): FiveEPlayMatchIdentity;

package/dist/input.js

@@ -0,0 +1,45 @@
+import { FiveEPlayError } from './errors.js';
+const ID_PATTERN = /^csgo_mc_(\d+)$/;
+export function matchIdentityFromInput(input) {
+    if (typeof input !== 'string' || !input.trim())
+        return null;
+    const value = input.trim();
+    const direct = value.match(ID_PATTERN);
+    if (direct) {
+        const numericId = Number(direct[1]);
+        if (!Number.isSafeInteger(numericId) || numericId <= 0)
+            return null;
+        return {
+            id: value,
+            numericId,
+            url: `https://event.5eplay.com/csgo/matches/${value}`,
+        };
+    }
+    try {
+        const url = new URL(value);
+        if (url.protocol !== 'https:' || url.hostname !== 'event.5eplay.com')
+            return null;
+        const pathMatch = url.pathname.match(/^\/csgo\/matches\/(csgo_mc_(\d+))\/?$/);
+        if (!pathMatch)
+            return null;
+        const numericId = Number(pathMatch[2]);
+        if (!Number.isSafeInteger(numericId) || numericId <= 0)
+            return null;
+        const id = pathMatch[1];
+        return { id, numericId, url: `https://event.5eplay.com/csgo/matches/${id}` };
+    }
+    catch {
+        return null;
+    }
+}
+export function requireMatchIdentity(input) {
+    const identity = matchIdentityFromInput(input);
+    if (identity)
+        return identity;
+    throw new FiveEPlayError('match must be a csgo_mc_<id> identifier or canonical https://event.5eplay.com/csgo/matches/csgo_mc_<id> URL', {
+        code: 'INVALID_INPUT',
+        operation: 'match-detail',
+        stage: 'validating-input',
+        retryable: false,
+    });
+}

package/dist/live_matches.d.ts

@@ -0,0 +1,2 @@
+import type { GetFiveEPlayLiveMatchesOptions, GetFiveEPlayLiveMatchesResult } from './types.js';
+export declare function getFiveEPlayLiveMatches(options?: GetFiveEPlayLiveMatchesOptions): Promise<GetFiveEPlayLiveMatchesResult>;

package/dist/live_matches.js

@@ -0,0 +1,209 @@
+import { asFiveEPlayError, FiveEPlayError } from './errors.js';
+import { fetchJson, responseData } from './http.js';
+import { matchIdentityFromInput } from './input.js';
+import { integer, record, records, text } from './value.js';
+const LIST_PAGE = 'https://event.5eplay.com/csgo/matches';
+const LIST_API = 'https://app.5eplay.com/api/tournament/session_list';
+const PAGE_SIZE = 20;
+function emit(options, stage, message) {
+    options.onProgress?.({
+        operation: 'live-matches',
+        stage,
+        message,
+        timestamp: new Date().toISOString(),
+    });
+}
+function requestLifetime(options) {
+    const controller = new AbortController();
+    const timeoutMs = options.timeoutMs ?? 5_000;
+    const timeout = setTimeout(() => {
+        controller.abort(new FiveEPlayError(`5EPlay live-list request timed out after ${timeoutMs}ms`, {
+            code: 'TIMEOUT', operation: 'live-matches', stage: 'fetching-live-matches', retryable: true,
+        }));
+    }, timeoutMs);
+    const abort = () => controller.abort(options.signal?.reason);
+    if (options.signal?.aborted)
+        abort();
+    else
+        options.signal?.addEventListener('abort', abort, { once: true });
+    return {
+        signal: controller.signal,
+        dispose: () => {
+            clearTimeout(timeout);
+            options.signal?.removeEventListener('abort', abort);
+        },
+    };
+}
+function isLive(value) {
+    const state = record(value.state);
+    return state.status === '1' || state.status === 1
+        || records(state.bout_states).some((map) => map.status === '1' || map.status === 1);
+}
+function mapStatus(value) {
+    if (value === '1' || value === 1)
+        return 'live';
+    if (value === '2' || value === 2)
+        return 'completed';
+    if (value === '0' || value === 0 || value === '-1' || value === -1)
+        return 'upcoming';
+    return 'unknown';
+}
+function liveTeam(value, seriesScore, fallbackId) {
+    const source = record(value);
+    return {
+        id: text(source.id) ?? fallbackId,
+        name: text(source.disp_name)?.trim() ?? '',
+        country: text(source.country),
+        rank: integer(source.rank),
+        valveRank: integer(record(source.v_rank).rank),
+        seriesScore: integer(seriesScore),
+    };
+}
+function liveMap(value, matchId, teams) {
+    const source = record(value);
+    const number = integer(source.bout_num);
+    const name = text(source.map_name)?.trim();
+    if (number === null || !name)
+        return null;
+    return {
+        id: `${matchId}_${number}`,
+        number,
+        name,
+        status: mapStatus(source.status),
+        winnerTeamId: source.result === 't1' ? teams[0]?.id ?? null
+            : source.result === 't2' ? teams[1]?.id ?? null : null,
+        teams: [
+            { teamId: teams[0]?.id ?? 't1', score: integer(source.t1_score) },
+            { teamId: teams[1]?.id ?? 't2', score: integer(source.t2_score) },
+        ],
+    };
+}
+function liveMatch(value) {
+    const source = record(value);
+    if (!isLive(source))
+        return null;
+    const matchInfo = record(source.mc_info);
+    const state = record(source.state);
+    const identity = matchIdentityFromInput(text(matchInfo.id) ?? '');
+    if (!identity)
+        return null;
+    const teams = [
+        liveTeam(matchInfo.t1_info, state.t1_score, 't1'),
+        liveTeam(matchInfo.t2_info, state.t2_score, 't2'),
+    ];
+    const maps = records(state.bout_states).flatMap((map) => {
+        const transformed = liveMap(map, identity.id, teams);
+        return transformed ? [transformed] : [];
+    }).sort((left, right) => left.number - right.number);
+    const tournament = record(source.tt_info);
+    return {
+        id: identity.id,
+        numericId: identity.numericId,
+        url: identity.url,
+        status: 'live',
+        bestOf: integer(matchInfo.format),
+        scheduledAtUnixSeconds: integer(matchInfo.plan_ts),
+        stage: text(matchInfo.tt_stage),
+        stageDescription: text(matchInfo.tt_stage_desc),
+        tournament: {
+            id: text(tournament.id),
+            name: text(tournament.disp_name)?.trim() ?? '',
+            grade: text(tournament.grade),
+            gradeLabel: text(tournament.grade_label),
+        },
+        teams,
+        maps,
+        currentMap: maps.find((map) => map.status === 'live') ?? null,
+    };
+}
+export async function getFiveEPlayLiveMatches(options = {}) {
+    const startedAt = new Date().toISOString();
+    const started = performance.now();
+    const lifetime = requestLifetime(options);
+    const requests = [];
+    const context = {
+        operation: 'live-matches',
+        signal: lifetime.signal,
+        fetch: options.fetch ?? globalThis.fetch,
+        diagnostics: requests,
+    };
+    if (typeof context.fetch !== 'function') {
+        lifetime.dispose();
+        throw new FiveEPlayError('global fetch is unavailable', {
+            code: 'INTERNAL_ERROR', operation: 'live-matches', stage: 'fetching-live-matches',
+            retryable: false,
+        });
+    }
+    emit(options, 'fetching-live-matches', 'Fetching currently live 5EPlay CS2 matches');
+    try {
+        const matches = [];
+        const seen = new Set();
+        for (let page = 1;; page += 1) {
+            const query = new URLSearchParams({
+                game_status: '1',
+                game_type: '1',
+                grades: '',
+                page: String(page),
+                limit: String(PAGE_SIZE),
+            });
+            const response = await fetchJson(context, `${LIST_API}?${query}`, {
+                kind: 'live-list', stage: 'fetching-live-matches', page,
+            });
+            const data = record(responseData(response, {
+                operation: 'live-matches', stage: 'fetching-live-matches',
+            }));
+            if (!Array.isArray(data.matches)) {
+                throw new FiveEPlayError('5EPlay live-list response did not contain a match array', {
+                    code: 'INVALID_RESPONSE', operation: 'live-matches', stage: 'fetching-live-matches',
+                    retryable: true,
+                });
+            }
+            const pageMatches = records(data.matches);
+            let newLiveMatches = 0;
+            for (const source of pageMatches) {
+                const transformed = liveMatch(source);
+                if (!transformed || seen.has(transformed.id))
+                    continue;
+                seen.add(transformed.id);
+                matches.push(transformed);
+                newLiveMatches += 1;
+            }
+            const pageIsEntirelyLive = pageMatches.length === PAGE_SIZE
+                && pageMatches.every(isLive);
+            if (!pageIsEntirelyLive || newLiveMatches === 0)
+                break;
+        }
+        const completedAt = new Date().toISOString();
+        const result = {
+            data: {
+                schemaVersion: '1.0.0',
+                capturedAt: completedAt,
+                source: { provider: '5eplay', url: LIST_PAGE },
+                hasLiveMatches: matches.length > 0,
+                matches,
+            },
+            diagnostics: {
+                schemaVersion: '1.0.0',
+                operation: 'live-matches',
+                startedAt,
+                completedAt,
+                durationMs: Math.round((performance.now() - started) * 100) / 100,
+                requests,
+            },
+        };
+        emit(options, 'completed', `Found ${matches.length} live 5EPlay CS2 matches`);
+        return result;
+    }
+    catch (error) {
+        if (lifetime.signal.aborted && lifetime.signal.reason instanceof Error) {
+            throw lifetime.signal.reason;
+        }
+        throw asFiveEPlayError(error, {
+            code: 'INTERNAL_ERROR', operation: 'live-matches', stage: 'fetching-live-matches',
+            retryable: false,
+        });
+    }
+    finally {
+        lifetime.dispose();
+    }
+}

package/dist/log.d.ts

@@ -0,0 +1,4 @@
+import type { FiveEPlayLogEvent } from './types.js';
+export declare function transformLogRecord(value: unknown): FiveEPlayLogEvent;
+export declare function compareUpdateVersions(left: string, right: string): number;
+export declare function mergeLogEvents(existing: FiveEPlayLogEvent[], additions: FiveEPlayLogEvent[]): FiveEPlayLogEvent[];

package/dist/log.js

@@ -0,0 +1,153 @@
+import { flag, integer, json, record, side, text } from './value.js';
+function player(value, nameKeys, idKey, sideKey) {
+    const name = nameKeys.map((key) => text(value[key])).find(Boolean) ?? '';
+    return {
+        id: idKey ? text(value[idKey]) : null,
+        name,
+        side: sideKey ? side(value[sideKey]) : null,
+    };
+}
+function populated(value) {
+    return Object.values(value).some((item) => item !== '' && item !== null && item !== undefined && item !== false && item !== 0);
+}
+function kindFor(parsed) {
+    if (populated(record(parsed.round_start)))
+        return 'round-start';
+    if (populated(record(parsed.round_end)))
+        return 'round-end';
+    if (populated(record(parsed.player_join)))
+        return 'player-joined';
+    if (populated(record(parsed.player_quit)))
+        return 'player-left';
+    if (populated(record(parsed.kill)))
+        return 'kill';
+    if (populated(record(parsed.bomb_planted)))
+        return 'bomb-planted';
+    if (populated(record(parsed.bomb_defused)))
+        return 'bomb-defused';
+    if (populated(record(parsed.suicide)))
+        return 'suicide';
+    if (populated(record(parsed.match_started)))
+        return 'match-started';
+    if (parsed.restart !== undefined)
+        return 'restart';
+    return 'unknown';
+}
+function killEvent(parsed) {
+    const kill = record(parsed.kill);
+    if (!populated(kill))
+        return null;
+    const assist = record(parsed.assist);
+    const assister = populated(assist)
+        ? player(assist, ['assister_nick', 'assister_name'], undefined, 'assister_side')
+        : null;
+    const flasherName = text(kill.flasher_nick);
+    return {
+        eventId: text(kill.event_id),
+        killer: player(kill, ['killer_nick', 'killer_name'], 'killer_id', 'killer_side'),
+        victim: player(kill, ['victim_nick', 'victim_name'], 'victim_id', 'victim_side'),
+        assister,
+        flasher: flasherName
+            ? { id: null, name: flasherName, side: side(kill.flasher_side) }
+            : null,
+        weapon: text(kill.weapon),
+        weaponLogoUrl: text(kill.weapon_logo),
+        headshot: flag(kill.head_shot) === true,
+        wallbang: flag(kill.penetrated) === true,
+        throughSmoke: flag(kill.through_smoke) === true,
+        noScope: flag(kill.no_scope) === true,
+        killerBlind: flag(kill.killer_blind) === true,
+        killerPosition: { x: integer(kill.killer_x), y: integer(kill.killer_y) },
+        victimPosition: { x: integer(kill.victim_x), y: integer(kill.victim_y) },
+    };
+}
+function bombEvent(parsed) {
+    const bomb = record(parsed.bomb_planted);
+    if (!populated(bomb))
+        return null;
+    return {
+        player: player(bomb, ['player_nick', 'player_name']),
+        site: text(bomb.bomb_site),
+        ctPlayers: integer(bomb.ct_players),
+        tPlayers: integer(bomb.t_players),
+    };
+}
+function parseLogInfo(value) {
+    if (value !== null && typeof value === 'object' && !Array.isArray(value))
+        return record(value);
+    if (typeof value !== 'string' || !value)
+        return {};
+    try {
+        return record(JSON.parse(value));
+    }
+    catch {
+        return {};
+    }
+}
+export function transformLogRecord(value) {
+    const row = record(value);
+    const parsed = parseLogInfo(row.log_info);
+    const roundStart = record(parsed.round_start);
+    const roundEnd = record(parsed.round_end);
+    const joined = record(parsed.player_join);
+    const left = record(parsed.player_quit);
+    const suicide = record(parsed.suicide);
+    const defused = record(parsed.bomb_defused);
+    const winner = side(roundEnd.winner);
+    const restart = parsed.restart === undefined ? null : json(parsed.restart);
+    return {
+        updateVersion: text(row.update_version) ?? text(parsed.update_version) ?? '',
+        matchId: text(row.match_id) ?? '',
+        tournamentId: text(row.tt_id),
+        mapId: text(row.bout_id),
+        mapNumber: integer(row.bout_num),
+        map: text(row.map_name),
+        type: integer(parsed.type),
+        kind: kindFor(parsed),
+        roundStart: populated(roundStart) ? {
+            round: integer(roundStart.round_num),
+            map: text(roundStart.map),
+            mapNumber: integer(roundStart.bout_num),
+        } : null,
+        roundEnd: populated(roundEnd) ? {
+            ctScore: integer(roundEnd.ct_score),
+            tScore: integer(roundEnd.t_score),
+            winnerSide: winner,
+            reason: text(roundEnd.win_type),
+            reasonCode: integer(roundEnd.win_type_app),
+        } : null,
+        playerJoined: populated(joined)
+            ? player(joined, ['player_nick', 'player_name'])
+            : null,
+        playerLeft: populated(left)
+            ? player(left, ['player_nick', 'player_name'], undefined, 'player_side')
+            : null,
+        kill: killEvent(parsed),
+        suicide: populated(suicide) ? {
+            player: player(suicide, ['player_nick', 'player_name'], undefined, 'side'),
+            weapon: text(suicide.weapon),
+            weaponLogoUrl: text(suicide.weapon_logo),
+        } : null,
+        bombPlanted: bombEvent(parsed),
+        bombDefused: populated(defused)
+            ? player(defused, ['player_nick', 'player_name'])
+            : null,
+        restart: restart,
+    };
+}
+export function compareUpdateVersions(left, right) {
+    if (/^\d+$/.test(left) && /^\d+$/.test(right)) {
+        const a = BigInt(left);
+        const b = BigInt(right);
+        return a < b ? -1 : a > b ? 1 : 0;
+    }
+    return left.localeCompare(right);
+}
+export function mergeLogEvents(existing, additions) {
+    const byVersion = new Map();
+    for (const event of [...existing, ...additions]) {
+        const key = event.updateVersion || JSON.stringify(event);
+        byVersion.set(key, event);
+    }
+    return [...byVersion.values()].sort((leftEvent, rightEvent) => compareUpdateVersions(leftEvent.updateVersion, rightEvent.updateVersion));
+}

package/dist/markdown.d.ts

@@ -0,0 +1,5 @@
+import type { GetFiveEPlayMatchResult } from './types.js';
+export interface FiveEPlayMarkdownOptions {
+    includeDiagnostics?: boolean;
+}
+export declare function renderFiveEPlayMatchMarkdown(result: GetFiveEPlayMatchResult, options?: FiveEPlayMarkdownOptions): string;