hive-bedrock-api 3.0.0-alpha.23 → 3.0.0-alpha.25

package/lib/helpers/fetchEndpoint.d.ts

@@ -0,0 +1,3 @@
+import { APIResponse } from "../types/types";
+import { Routes } from "hive-bedrock-data";
+export default function fetchEndpoint<T extends string>(endpoint: T, init?: RequestInit): Promise<APIResponse<Routes<T>>>;

package/lib/helpers/fetchEndpoint.js

@@ -0,0 +1,88 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = fetchEndpoint;
+var hive_bedrock_data_1 = require("hive-bedrock-data");
+function fetchEndpoint(endpoint, init) {
+    return __awaiter(this, void 0, void 0, function () {
+        var time_start, request, time_end, duration, response, err_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 3, , 4]);
+                    time_start = performance.now();
+                    return [4 /*yield*/, fetch(hive_bedrock_data_1.API_BASE_ENDPOINT + endpoint, init)];
+                case 1:
+                    request = _a.sent();
+                    time_end = performance.now();
+                    duration = Math.round(time_end - time_start);
+                    if (!request.ok)
+                        return [2 /*return*/, {
+                                status: request.status,
+                                data: null,
+                                error: {
+                                    code: request.status,
+                                    message: request.statusText,
+                                },
+                                duration: duration,
+                            }];
+                    return [4 /*yield*/, request.json()];
+                case 2:
+                    response = _a.sent();
+                    return [2 /*return*/, {
+                            status: request.status,
+                            headers: request.headers,
+                            data: response,
+                            error: null,
+                            duration: duration,
+                        }];
+                case 3:
+                    err_1 = _a.sent();
+                    return [2 /*return*/, {
+                            status: 500,
+                            data: null,
+                            error: {
+                                code: 500,
+                                message: "Failed to fetch endpoint data.",
+                            },
+                        }];
+                case 4: return [2 /*return*/];
+            }
+        });
+    });
+}

package/lib/helpers/isGame.d.ts

@@ -0,0 +1,2 @@
+import { Game } from "hive-bedrock-data";
+export default function isGame(game_id: Game): boolean;

package/lib/helpers/isGame.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = isGame;
+var hive_bedrock_data_1 = require("hive-bedrock-data");
+function isGame(game_id) {
+    return Object.values(hive_bedrock_data_1.Game).includes(game_id);
+}

package/lib/helpers/toPoint.d.ts

@@ -0,0 +1 @@
+export default function toPoint(num: number, point: number): number;

package/lib/helpers/toPoint.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = toPoint;
+function toPoint(num, point) {
+    if (isNaN(num))
+        return 0;
+    if (num === Infinity)
+        return 0;
+    return Math.round(num * (10 ^ point)) / (10 ^ point);
+}

package/lib/index.d.ts

@@ -0,0 +1,106 @@
+import { Game, Timeframe } from "hive-bedrock-data";
+import { MethodResponse } from "./utils";
+import { ProcessedPlayerResponse } from "./processors/player";
+import { ProcessedGlobalStatisticsResponse } from "./processors/global_statistics";
+import { ProcessedMapResponse } from "./processors/map";
+import { ProcessedGameMetadata } from "./processors/meta";
+import { ProcessedPlayerSearchResponse } from "./processors/player_search";
+import { AvailableLeaderboardResponse, ProcessedAllGamesResponse, ProcessedGame, ProcessedMonthlyGamesResponse } from "./processors/game";
+interface Options {
+    resolveDynamicTitles?: boolean;
+    useModernLeaderboardSource?: boolean;
+    apiBaseEndpoint?: string;
+    requestInit?: RequestInit;
+}
+export default class HiveAPI {
+    options: Options;
+    constructor(options?: Options);
+    private _fetchAPI;
+    /**
+     * `/game/all/main/{identifier}` Gets information about a player
+     * @param identifier Username or UUID of the player
+     * @returns The player information
+     */
+    getPlayer(identifier: string): Promise<MethodResponse<ProcessedPlayerResponse>>;
+    /**
+     * `/player/search/{prefix}` Gets a list of players that match the prefix
+     * @param prefix The prefix to search for (must be at least 4 characters long)
+     * @returns A list of players that match the prefix
+     */
+    getPlayerSearch(prefix: string): Promise<MethodResponse<ProcessedPlayerSearchResponse>>;
+    /**
+     * Gets statistics for a player
+     * @param identifier Username or UUID of the player
+     * @param timeframe The timeframe to get the statistics for
+     * @param options Additional options including specific game, month, and year
+     * @returns The player statistics
+     */
+    getStatistics(identifier: string, timeframe: Timeframe.AllTime): Promise<MethodResponse<ProcessedAllGamesResponse>>;
+    getStatistics<G extends Game>(identifier: string, timeframe: Timeframe.AllTime, options: {
+        game: G;
+    }): Promise<MethodResponse<ProcessedGame<Timeframe.AllTime, false>[G]>>;
+    getStatistics(identifier: string, timeframe: Timeframe.Monthly, options?: {
+        month?: number;
+        year?: number;
+    }): Promise<MethodResponse<ProcessedMonthlyGamesResponse>>;
+    getStatistics<G extends Game>(identifier: string, timeframe: Timeframe.Monthly, options: {
+        game: G;
+        month?: number;
+        year?: number;
+    }): Promise<MethodResponse<ProcessedGame<Timeframe.Monthly, false>[G]>>;
+    getStatistics<G extends Game>(identifier: string, timeframe: Timeframe.Seasonal, options?: {
+        game: G;
+        season?: number;
+    }): Promise<MethodResponse<ProcessedMonthlyGamesResponse>>;
+    private _getStatisticsAllTime;
+    private _getStatisticsMonthly;
+    private _getStatisticsSeasonal;
+    getAvailableMonthlyLeaderboards<G extends Game>(game: G): Promise<MethodResponse<AvailableLeaderboardResponse>>;
+    /**
+     * `/game/season/player/{game}/{player}/{season}` Gets seasonal statistics for a player
+     * @param identifier Username or UUID of the player
+     * @param game The game to get the statistics for
+     * @param season The season to get the statistics for
+     * @returns The player's seasonal statistics
+     */
+    getSeasonalStatistics<G extends Game>(identifier: string, game: G, season?: number): Promise<MethodResponse<ProcessedMonthlyGamesResponse["statistics"][G] | null>>;
+    /**
+     * `/game/all/{game}` Gets statistics for a game
+     * @param timeframe The timeframe to get the statistics for
+     * @param game The game to get the statistics for
+     * @param options Additional options including specific month and year
+     */
+    getLeaderboard<G extends Game>(timeframe: Timeframe.AllTime, game: G): Promise<MethodResponse<ProcessedGame<Timeframe.AllTime, true>[G][] | null>>;
+    getLeaderboard<G extends Game>(timeframe: Timeframe.Monthly, game: G): Promise<MethodResponse<ProcessedGame<Timeframe.Monthly, true>[G][] | null>>;
+    getLeaderboard<G extends Game>(timeframe: Timeframe.Monthly, game: G, options: {
+        month?: number;
+        year?: number;
+    }): Promise<MethodResponse<ProcessedGame<Timeframe.Monthly, true>[G][] | null>>;
+    private _getLeaderboardAllTime;
+    private _getLeaderboardMonthly;
+    /**
+     * `/game/season/{game}/{season}` Gets seasonal statistics for a game
+     * @param game The game to get the statistics for
+     * @param season The season to get the statistics for
+     * @returns The seasonal statistics for the game
+     */
+    getSeasonalLeaderboard<G extends Game>(game: G, season?: number): Promise<MethodResponse<ProcessedGame<Timeframe.Monthly, true>[G][]>>;
+    /**
+     * `/global/statistics` Gets global statistics
+     * @returns The global statistics
+     */
+    getGlobalStatistics(): Promise<MethodResponse<ProcessedGlobalStatisticsResponse>>;
+    /**
+     * `/game/map/{game}` Gets information about the maps in a game
+     * @param game The game to get the maps for (fails for games without maps)
+     * @returns A list of maps in the game
+     */
+    getGameMaps(game: Game): Promise<MethodResponse<ProcessedMapResponse>>;
+    /**
+     * `/game/meta/{game}` Gets metadata about a game
+     * @param game The game to get the metadata for
+     * @returns The metadata for the game
+     */
+    getGameMetadata(game: Game): Promise<MethodResponse<ProcessedGameMetadata>>;
+}
+export {};

package/lib/index.js

@@ -0,0 +1,424 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var hive_bedrock_data_1 = require("hive-bedrock-data");
+var player_1 = __importDefault(require("./processors/player"));
+var player_search_1 = __importDefault(require("./processors/player_search"));
+var game_1 = __importDefault(require("./processors/game"));
+var HiveAPI = /** @class */ (function () {
+    function HiveAPI(options) {
+        if (options === void 0) { options = {}; }
+        var _a;
+        this.options = options;
+        this.options = options;
+        this.options.apiBaseEndpoint = (_a = this.options.apiBaseEndpoint) !== null && _a !== void 0 ? _a : hive_bedrock_data_1.API_BASE_ENDPOINT;
+    }
+    HiveAPI.prototype._fetchAPI = function (endpoint) {
+        return __awaiter(this, void 0, void 0, function () {
+            var url, start, request, meta, response, err_1;
+            var _a, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        url = this.options.apiBaseEndpoint + endpoint;
+                        _c.label = 1;
+                    case 1:
+                        _c.trys.push([1, 4, , 5]);
+                        start = performance.now();
+                        return [4 /*yield*/, fetch(url, __assign(__assign({}, this.options.requestInit), { headers: __assign({ "X-Hive-Resolve-Stat-Track": ((_a = this.options.resolveDynamicTitles) !== null && _a !== void 0 ? _a : true).toString(), "X-Hive-Leaderboard-Source": this.options.useModernLeaderboardSource ? "modern" : "legacy" }, (_b = this.options.requestInit) === null || _b === void 0 ? void 0 : _b.headers) }))];
+                    case 2:
+                        request = _c.sent();
+                        if (!request.ok)
+                            return [2 /*return*/, { data: null, error: { status: request.status } }];
+                        meta = {
+                            duration: Math.ceil(performance.now() - start),
+                            ratelimit: {
+                                limit: Number(request.headers.get("X-Ratelimit-Limit")),
+                                remaining: Number(request.headers.get("X-Ratelimit-Remaining")),
+                                reset: Number(request.headers.get("X-Ratelimit-Reset")),
+                            },
+                            retryAfter: Number(request.headers.get("Retry-After")),
+                        };
+                        return [4 /*yield*/, request.json()];
+                    case 3:
+                        response = _c.sent();
+                        return [2 /*return*/, { data: response, error: null, meta: meta }];
+                    case 4:
+                        err_1 = _c.sent();
+                        return [2 /*return*/, { data: null, error: { status: 500, message: err_1.message } }];
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * `/game/all/main/{identifier}` Gets information about a player
+     * @param identifier Username or UUID of the player
+     * @returns The player information
+     */
+    HiveAPI.prototype.getPlayer = function (identifier) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, response, error, meta, data;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this._fetchAPI("/game/all/main/".concat(identifier))];
+                    case 1:
+                        _a = _b.sent(), response = _a.data, error = _a.error, meta = _a.meta;
+                        if (error)
+                            return [2 /*return*/, { data: null, error: error, meta: meta }];
+                        data = (0, player_1.default)(response);
+                        if (!data)
+                            return [2 /*return*/, { data: null, error: { status: 500, message: "Failed to process player data" }, meta: meta }];
+                        return [2 /*return*/, { data: data, error: null, meta: meta }];
+                }
+            });
+        });
+    };
+    /**
+     * `/player/search/{prefix}` Gets a list of players that match the prefix
+     * @param prefix The prefix to search for (must be at least 4 characters long)
+     * @returns A list of players that match the prefix
+     */
+    HiveAPI.prototype.getPlayerSearch = function (prefix) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, response, error, meta, data;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this._fetchAPI("/player/search/".concat(prefix))];
+                    case 1:
+                        _a = _b.sent(), response = _a.data, error = _a.error, meta = _a.meta;
+                        if (error)
+                            return [2 /*return*/, { data: null, error: error, meta: meta }];
+                        data = (0, player_search_1.default)(response);
+                        if (!data)
+                            return [2 /*return*/, { data: null, error: { status: 500, message: "Failed to process player search data" }, meta: meta }];
+                        return [2 /*return*/, { data: data, error: null, meta: meta }];
+                }
+            });
+        });
+    };
+    HiveAPI.prototype.getStatistics = function (identifier, timeframe, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                if (timeframe === hive_bedrock_data_1.Timeframe.AllTime) {
+                    if (options === null || options === void 0 ? void 0 : options.game)
+                        return [2 /*return*/, this._getStatisticsAllTime(identifier, options.game)];
+                    return [2 /*return*/, this._getStatisticsAllTime(identifier)];
+                }
+                else if (timeframe === hive_bedrock_data_1.Timeframe.Seasonal) {
+                    if (!(options === null || options === void 0 ? void 0 : options.game))
+                        throw new Error("Game must be specified for seasonal statistics");
+                    return [2 /*return*/, this._getStatisticsSeasonal(identifier, options === null || options === void 0 ? void 0 : options.game, (options === null || options === void 0 ? void 0 : options.season) || 1)];
+                }
+                if (options === null || options === void 0 ? void 0 : options.game)
+                    return [2 /*return*/, this._getStatisticsMonthly(identifier, options.game, options.month, options.year)];
+                return [2 /*return*/, this._getStatisticsMonthly(identifier, undefined, options === null || options === void 0 ? void 0 : options.month, options === null || options === void 0 ? void 0 : options.year)];
+            });
+        });
+    };
+    HiveAPI.prototype._getStatisticsAllTime = function (identifier, game) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, response, error, meta, data;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this._fetchAPI("/game/all/".concat(game !== null && game !== void 0 ? game : "all", "/").concat(identifier))];
+                    case 1:
+                        _a = _b.sent(), response = _a.data, error = _a.error, meta = _a.meta;
+                        if (error)
+                            return [2 /*return*/, { data: null, error: error, meta: meta }];
+                        if (game)
+                            return [2 /*return*/, { data: (0, game_1.default)(game, hive_bedrock_data_1.Timeframe.AllTime, false, response), error: null, meta: meta }];
+                        data = Object.fromEntries(Object.entries(response).map(function (_a) {
+                            var _b;
+                            var _c = __read(_a, 2), id = _c[0], res = _c[1];
+                            return [id, id === "main" ? null : (_b = (0, game_1.default)(id, hive_bedrock_data_1.Timeframe.AllTime, false, res)) !== null && _b !== void 0 ? _b : null];
+                        }));
+                        delete data.main;
+                        return [2 /*return*/, {
+                                data: {
+                                    player: (0, player_1.default)(response),
+                                    statistics: data,
+                                },
+                                error: null,
+                                meta: meta,
+                            }];
+                }
+            });
+        });
+    };
+    HiveAPI.prototype._getStatisticsMonthly = function (identifier, game, month, year) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, response, error, meta, data;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this._fetchAPI("/game/monthly/player/".concat(game !== null && game !== void 0 ? game : "all", "/").concat(identifier, "/").concat(year !== null && year !== void 0 ? year : new Date().getFullYear(), "/").concat(month !== null && month !== void 0 ? month : new Date().getMonth() + 1))];
+                    case 1:
+                        _a = _b.sent(), response = _a.data, error = _a.error, meta = _a.meta;
+                        if (error)
+                            return [2 /*return*/, { data: null, error: error, meta: meta }];
+                        if (game)
+                            return [2 /*return*/, { data: (0, game_1.default)(game, hive_bedrock_data_1.Timeframe.Monthly, false, response), error: null, meta: meta }];
+                        data = Object.fromEntries(Object.entries(response).map(function (_a) {
+                            var _b;
+                            var _c = __read(_a, 2), id = _c[0], res = _c[1];
+                            return [id, id === "main" ? null : (_b = (0, game_1.default)(id, hive_bedrock_data_1.Timeframe.Monthly, false, res)) !== null && _b !== void 0 ? _b : null];
+                        }));
+                        delete data.main;
+                        return [2 /*return*/, {
+                                data: {
+                                    statistics: data,
+                                },
+                                error: null,
+                                meta: meta,
+                            }];
+                }
+            });
+        });
+    };
+    HiveAPI.prototype._getStatisticsSeasonal = function (identifier, game, season) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, response, error, meta;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this._fetchAPI("/game/season/player/".concat(game, "/").concat(identifier, "/").concat(season !== null && season !== void 0 ? season : 1))];
+                    case 1:
+                        _a = _b.sent(), response = _a.data, error = _a.error, meta = _a.meta;
+                        if (error)
+                            return [2 /*return*/, { data: null, error: error, meta: meta }];
+                        return [2 /*return*/, { data: (0, game_1.default)(game, hive_bedrock_data_1.Timeframe.Seasonal, false, response), error: null, meta: meta }];
+                }
+            });
+        });
+    };
+    HiveAPI.prototype.getAvailableMonthlyLeaderboards = function (game) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, response, error, meta;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this._fetchAPI("/game/monthly/".concat(game, "/available"))];
+                    case 1:
+                        _a = _b.sent(), response = _a.data, error = _a.error, meta = _a.meta;
+                        if (error)
+                            return [2 /*return*/, { data: null, error: error, meta: meta }];
+                        return [2 /*return*/, { data: response, error: null, meta: meta }];
+                }
+            });
+        });
+    };
+    /**
+     * `/game/season/player/{game}/{player}/{season}` Gets seasonal statistics for a player
+     * @param identifier Username or UUID of the player
+     * @param game The game to get the statistics for
+     * @param season The season to get the statistics for
+     * @returns The player's seasonal statistics
+     */
+    HiveAPI.prototype.getSeasonalStatistics = function (identifier_1, game_2) {
+        return __awaiter(this, arguments, void 0, function (identifier, game, season) {
+            var _a, response, error, meta, data;
+            if (season === void 0) { season = 1; }
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this._fetchAPI("/game/season/player/".concat(game, "/").concat(identifier, "/").concat(season))];
+                    case 1:
+                        _a = _b.sent(), response = _a.data, error = _a.error, meta = _a.meta;
+                        if (error)
+                            return [2 /*return*/, { data: null, error: error, meta: meta }];
+                        data = (0, game_1.default)(game, hive_bedrock_data_1.Timeframe.Monthly, true, response);
+                        return [2 /*return*/, { data: data, error: null, meta: meta }];
+                }
+            });
+        });
+    };
+    HiveAPI.prototype.getLeaderboard = function (timeframe, game, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                if (timeframe === hive_bedrock_data_1.Timeframe.Monthly)
+                    return [2 /*return*/, this._getLeaderboardMonthly(game, (options === null || options === void 0 ? void 0 : options.month) || new Date().getMonth() + 1, (options === null || options === void 0 ? void 0 : options.year) || new Date().getFullYear())];
+                return [2 /*return*/, this._getLeaderboardAllTime(game)];
+            });
+        });
+    };
+    // /game/all/{game}
+    HiveAPI.prototype._getLeaderboardAllTime = function (game) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, response, error, meta, data;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this._fetchAPI("/game/all/".concat(game))];
+                    case 1:
+                        _a = _b.sent(), response = _a.data, error = _a.error, meta = _a.meta;
+                        if (error)
+                            return [2 /*return*/, { data: null, error: error, meta: meta }];
+                        data = response.map(function (res) { return (0, game_1.default)(game, hive_bedrock_data_1.Timeframe.AllTime, true, res); });
+                        return [2 /*return*/, { data: data, error: null, meta: meta }];
+                }
+            });
+        });
+    };
+    // /game/monthly/{game}/{year}/{month}
+    HiveAPI.prototype._getLeaderboardMonthly = function (game, month, year) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, response, error, meta, data;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this._fetchAPI("/game/monthly/".concat(game, "/").concat(year, "/").concat(month))];
+                    case 1:
+                        _a = _b.sent(), response = _a.data, error = _a.error, meta = _a.meta;
+                        if (error)
+                            return [2 /*return*/, { data: null, error: error, meta: meta }];
+                        data = response.map(function (res) { return (0, game_1.default)(game, hive_bedrock_data_1.Timeframe.Monthly, true, res); });
+                        return [2 /*return*/, { data: data, error: null, meta: meta }];
+                }
+            });
+        });
+    };
+    /**
+     * `/game/season/{game}/{season}` Gets seasonal statistics for a game
+     * @param game The game to get the statistics for
+     * @param season The season to get the statistics for
+     * @returns The seasonal statistics for the game
+     */
+    HiveAPI.prototype.getSeasonalLeaderboard = function (game_2) {
+        return __awaiter(this, arguments, void 0, function (game, season) {
+            var _a, response, error, meta, data;
+            if (season === void 0) { season = 1; }
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this._fetchAPI("/game/season/".concat(game, "/").concat(season !== null && season !== void 0 ? season : 1))];
+                    case 1:
+                        _a = _b.sent(), response = _a.data, error = _a.error, meta = _a.meta;
+                        if (error)
+                            return [2 /*return*/, { data: null, error: error, meta: meta }];
+                        data = response.map(function (res) { return (0, game_1.default)(game, hive_bedrock_data_1.Timeframe.Monthly, true, res); });
+                        return [2 /*return*/, { data: data, error: null, meta: meta }];
+                }
+            });
+        });
+    };
+    /**
+     * `/global/statistics` Gets global statistics
+     * @returns The global statistics
+     */
+    HiveAPI.prototype.getGlobalStatistics = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, response, error, meta;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this._fetchAPI("/global/statistics")];
+                    case 1:
+                        _a = _b.sent(), response = _a.data, error = _a.error, meta = _a.meta;
+                        if (error)
+                            return [2 /*return*/, { data: null, error: error, meta: meta }];
+                        return [2 /*return*/, { data: response, error: null, meta: meta }];
+                }
+            });
+        });
+    };
+    /**
+     * `/game/map/{game}` Gets information about the maps in a game
+     * @param game The game to get the maps for (fails for games without maps)
+     * @returns A list of maps in the game
+     */
+    HiveAPI.prototype.getGameMaps = function (game) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, response, error, meta;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this._fetchAPI("/game/map/".concat(game))];
+                    case 1:
+                        _a = _b.sent(), response = _a.data, error = _a.error, meta = _a.meta;
+                        if (error)
+                            return [2 /*return*/, { data: null, error: error, meta: meta }];
+                        return [2 /*return*/, { data: response, error: null, meta: meta }];
+                }
+            });
+        });
+    };
+    /**
+     * `/game/meta/{game}` Gets metadata about a game
+     * @param game The game to get the metadata for
+     * @returns The metadata for the game
+     */
+    HiveAPI.prototype.getGameMetadata = function (game) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, response, error, meta;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this._fetchAPI("/game/meta/".concat(game))];
+                    case 1:
+                        _a = _b.sent(), response = _a.data, error = _a.error, meta = _a.meta;
+                        if (error)
+                            return [2 /*return*/, { data: null, error: error, meta: meta }];
+                        return [2 /*return*/, { data: response, error: null, meta: meta }];
+                }
+            });
+        });
+    };
+    return HiveAPI;
+}());
+exports.default = HiveAPI;

package/lib/methods/getAllTimeLeaderboard.d.ts

@@ -0,0 +1,4 @@
+import { Game } from "hive-bedrock-data";
+import { APIResponse, Options } from "../types/types";
+import { AllTimeProcessedLeaderboard } from "../types/output";
+export default function getAllTimeLeaderboard<G extends Game>(game_id: G, options?: Partial<Options>): Promise<APIResponse<AllTimeProcessedLeaderboard<G>>>;