hive-bedrock-api 1.0.10 → 2.0.0

package/lib/types/output.d.ts

@@ -0,0 +1,67 @@
+import { Game, Leaderboards, Statistics, Timeframe } from "hive-bedrock-data";
+type Processor = (stats: any) => void;
+export type GameProcessors = {
+    [key in Game]: Processor[];
+};
+interface AllTimeAdditions {
+    level: number;
+}
+interface PvPAdditions {
+    kdr: number;
+}
+interface CommonStatistics {
+    id: Game;
+    played: number;
+    victories: number;
+    losses: number;
+    win_percentage: number;
+}
+type BaseStatistics<G extends Game, T extends Timeframe> = Statistics<G, T> & CommonStatistics & (T extends Timeframe.AllTime ? AllTimeAdditions : unknown);
+export type StatisticsResponse<G extends Game, T extends Timeframe> = AllStatistics<T>[G];
+export interface AllStatistics<T extends Timeframe> {
+    [Game.BlockDrop]: BaseStatistics<Game.BlockDrop, T>;
+    [Game.BlockParty]: BaseStatistics<Game.BlockParty, T>;
+    [Game.CaptureTheFlag]: BaseStatistics<Game.CaptureTheFlag, T> & PvPAdditions;
+    [Game.DeathRun]: BaseStatistics<Game.DeathRun, T>;
+    [Game.Gravity]: BaseStatistics<Game.Gravity, T>;
+    [Game.GroundWars]: BaseStatistics<Game.GroundWars, T> & PvPAdditions;
+    [Game.HideAndSeek]: BaseStatistics<Game.HideAndSeek, T>;
+    [Game.JustBuild]: BaseStatistics<Game.JustBuild, T> & {
+        total_ratings: number;
+    };
+    [Game.MurderMystery]: BaseStatistics<Game.MurderMystery, T>;
+    [Game.Skywars]: BaseStatistics<Game.Skywars, T> & PvPAdditions;
+    [Game.SurvivalGames]: BaseStatistics<Game.SurvivalGames, T> & PvPAdditions;
+    [Game.TheBridge]: BaseStatistics<Game.TheBridge, T> & PvPAdditions;
+    [Game.TreasureWars]: BaseStatistics<Game.TreasureWars, T> & PvPAdditions;
+}
+interface CommonLeaderboard {
+    id: Game;
+    played: number;
+    victories: number;
+    losses: number;
+    win_percentage: number;
+}
+type BaseLeaderboard<G extends Game, T extends Timeframe> = Leaderboards<G, T> & CommonLeaderboard & (T extends Timeframe.AllTime ? AllTimeAdditions : unknown);
+export type LeaderboardResponse<G extends Game, T extends Timeframe> = AllLeaderboards<T>[G];
+export interface AllLeaderboards<T extends Timeframe> {
+    [Game.BlockDrop]: BaseLeaderboard<Game.BlockDrop, T>[];
+    [Game.BlockParty]: BaseLeaderboard<Game.BlockParty, T>[];
+    [Game.CaptureTheFlag]: BaseLeaderboard<Game.CaptureTheFlag, T>[];
+    [Game.DeathRun]: BaseLeaderboard<Game.DeathRun, T>[];
+    [Game.Gravity]: BaseLeaderboard<Game.Gravity, T>[];
+    [Game.GroundWars]: BaseLeaderboard<Game.GroundWars, T>[];
+    [Game.HideAndSeek]: BaseLeaderboard<Game.HideAndSeek, T>[];
+    [Game.JustBuild]: (BaseLeaderboard<Game.JustBuild, T> & {
+        total_ratings: number;
+    })[];
+    [Game.MurderMystery]: BaseLeaderboard<Game.MurderMystery, T>[];
+    [Game.Skywars]: BaseLeaderboard<Game.Skywars, T>[];
+    [Game.SurvivalGames]: BaseLeaderboard<Game.SurvivalGames, T>[];
+    [Game.TheBridge]: BaseLeaderboard<Game.TheBridge, T>[];
+    [Game.TreasureWars]: BaseLeaderboard<Game.TreasureWars, T>[];
+}
+export type AllGameStatistics<T extends Timeframe> = {
+    [key in Game]: BaseStatistics<key, T> | null;
+};
+export {};

package/lib/types/{GAMES.js → output.js}

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var GAME_INFO_1 = require("./GAME_INFO");
+var hive_bedrock_data_1 = require("hive-bedrock-data");

package/lib/types/types.d.ts

@@ -0,0 +1,21 @@
+interface APIResponse_Base {
+    duration?: number;
+    status: number;
+}
+interface APIResponse_Error {
+    code: number;
+    message: string;
+}
+export interface APIResponse_Success<T> extends APIResponse_Base {
+    error: null;
+    data: T;
+}
+export interface APIResponse_Failure extends APIResponse_Base {
+    error: APIResponse_Error;
+    data: null;
+}
+export type APIResponse<T> = APIResponse_Success<T> | APIResponse_Failure;
+export interface Options {
+    init: RequestInit;
+}
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "hive-bedrock-api",
-    "version": "1.0.10",
+    "version": "2.0.0",
     "description": "An API wrapper for the Hive Minecraft Bedrock Edition server.",
     "main": "lib/index.js",
     "types": "lib/index.d.ts",
@@ -10,19 +10,18 @@
     },
     "license": "MIT",
     "author": "Cubeedge Studios",
-    "dependencies": {},
+    "dependencies": {
+        "hive-bedrock-data": "^1.1.7"
+    },
     "scripts": {
-        "build": "tsc",
-        "test": "jest"
+        "prepack": "yarn build",
+        "prepare": "npm run build",
+        "build": "tsc"
     },
     "files": [
         "lib/**/*"
     ],
     "devDependencies": {
-        "@types/jest": "^29.5.2",
-        "jest": "^29.5.0",
-        "jest-extended": "^4.0.0",
-        "ts-jest": "^29.1.0",
         "ts-node": "^10.9.1",
         "typescript": "^5.1.3"
     }

package/lib/format/gameFormat.d.ts

@@ -1,30 +0,0 @@
-import { GAME } from "../types/GAME_INFO";
-interface SingleGameFormat {
-    [key: string]: any;
-}
-interface GameFormat {
-    [key: string]: SingleGameFormat | null;
-}
-export declare const formats: {
-    main: (player: SingleGameFormat) => SingleGameFormat;
-    default: (gameType: GAME, game: SingleGameFormat | null) => {
-        id: GAME;
-    } | null;
-    drop: (game: SingleGameFormat | null) => SingleGameFormat | null;
-    party: (game: SingleGameFormat | null) => SingleGameFormat | null;
-    ctf: (game: SingleGameFormat | null) => SingleGameFormat | null;
-    dr: (game: SingleGameFormat | null) => SingleGameFormat | null;
-    ground: (game: SingleGameFormat | null) => SingleGameFormat | null;
-    hide: (game: SingleGameFormat | null) => SingleGameFormat | null;
-    build: (game: SingleGameFormat | null) => SingleGameFormat | null;
-    murder: (game: SingleGameFormat | null) => SingleGameFormat | null;
-    sky: (game: SingleGameFormat | null) => SingleGameFormat | null;
-    sg: (game: SingleGameFormat | null) => SingleGameFormat | null;
-    wars: (game: SingleGameFormat | null) => SingleGameFormat | null;
-    grav: (game: SingleGameFormat | null) => SingleGameFormat | null;
-    bridge: (game: SingleGameFormat | null) => SingleGameFormat | null;
-};
-export declare function gameFormatArray(gameType: GAME, games: SingleGameFormat[]): (SingleGameFormat | null)[];
-export default function gameFormat(games: GameFormat, returnAsSingle: true): SingleGameFormat | null;
-export default function gameFormat(games: GameFormat): GameFormat | null;
-export {};

package/lib/format/gameFormat.js

@@ -1,164 +0,0 @@
-"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 __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 };
-};
-var _a;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.gameFormatArray = exports.formats = void 0;
-var calculateLevel_1 = __importDefault(require("../methods/calculateLevel"));
-var GAME_INFO_1 = require("../types/GAME_INFO");
-exports.formats = (_a = {
-        main: function (player) {
-            return player;
-        },
-        default: function (gameType, game) {
-            var _a, _b, _c, _d;
-            if (!game)
-                return null;
-            if ("index" in game && game.index == 2147483646)
-                return null;
-            if (!("index" in game)) {
-                if ("xp" in game) {
-                    game.level = (0, calculateLevel_1.default)(game.xp, gameType);
-                }
-                else
-                    return null;
-            }
-            if ("played" in game && "victories" in game) {
-                game.losses = ((_a = game.played) !== null && _a !== void 0 ? _a : 0) - ((_b = game.victories) !== null && _b !== void 0 ? _b : 0);
-                game.win_percentage = game.victories / game.played;
-                if (isNaN(game.win_percentage))
-                    game.win_percentage = 0;
-            }
-            if ("kills" in game && "deaths" in game)
-                game.kdr = parseFloat((((_c = game.kills) !== null && _c !== void 0 ? _c : 0) / ((_d = game.deaths) !== null && _d !== void 0 ? _d : 0)).toFixed(2));
-            return __assign({ id: gameType }, game);
-        }
-    },
-    _a[GAME_INFO_1.GAME.BlockDrop] = function (game) {
-        return game;
-    },
-    _a[GAME_INFO_1.GAME.BlockParty] = function (game) {
-        return game;
-    },
-    _a[GAME_INFO_1.GAME.CaptureTheFlag] = function (game) {
-        return game;
-    },
-    _a[GAME_INFO_1.GAME.DeathRun] = function (game) {
-        return game;
-    },
-    _a[GAME_INFO_1.GAME.GroundWars] = function (game) {
-        return game;
-    },
-    _a[GAME_INFO_1.GAME.HideAndSeek] = function (game) {
-        if (!game)
-            return null;
-        if ("hider_kills" in game && "deaths" in game)
-            game.kdr = parseFloat((game.hider_kills / game.deaths).toFixed(2));
-        return game;
-    },
-    _a[GAME_INFO_1.GAME.JustBuild] = function (game) {
-        return game;
-    },
-    _a[GAME_INFO_1.GAME.MurderMystery] = function (game) {
-        if (!game)
-            return null;
-        if ("murders" in game && "deaths" in game)
-            game.kdr = parseFloat((game.murders / game.deaths).toFixed(2));
-        return game;
-    },
-    _a[GAME_INFO_1.GAME.Skywars] = function (game) {
-        return game;
-    },
-    _a[GAME_INFO_1.GAME.SurvivalGames] = function (game) {
-        return game;
-    },
-    _a[GAME_INFO_1.GAME.TreasureWars] = function (game) {
-        return game;
-    },
-    _a[GAME_INFO_1.GAME.Gravity] = function (game) {
-        return game;
-    },
-    _a[GAME_INFO_1.GAME.TheBridge] = function (game) {
-        var _a, _b;
-        if (!game)
-            return null;
-        if ("m_solo_deaths" in game) {
-            game.deaths = game.m_solo_deaths;
-            delete game.m_solo_deaths;
-        }
-        if ("m_solo_goals" in game) {
-            game.goals = game.m_solo_goals;
-            delete game.m_solo_goals;
-        }
-        if ("m_solo_kills" in game) {
-            game.kills = game.m_solo_kills;
-            delete game.m_solo_kills;
-        }
-        if ("m_solo_played" in game) {
-            game.played = game.m_solo_played;
-            delete game.m_solo_played;
-        }
-        if ("m_solo_victories" in game) {
-            game.victories = game.m_solo_victories;
-            delete game.m_solo_victories;
-        }
-        if ("played" in game && "victories" in game) {
-            game.losses = (_b = (_a = game.played) !== null && _a !== void 0 ? _a : 0 - game.victories) !== null && _b !== void 0 ? _b : 0;
-            game.win_percentage = game.victories / game.played;
-            if (isNaN(game.win_percentage))
-                game.win_percentage = 0;
-        }
-        return game;
-    },
-    _a);
-function gameFormatArray(gameType, games) {
-    return games.map(function (game) {
-        var _a;
-        return gameFormat((_a = {},
-            _a[gameType] = game,
-            _a), true);
-    });
-}
-exports.gameFormatArray = gameFormatArray;
-function gameFormat(games, returnAsSingle) {
-    var formatted = Object.fromEntries(Object.entries(games).map(function (_a) {
-        var _b = __read(_a, 2), key = _b[0], data = _b[1];
-        if (!data)
-            return [key, null];
-        var defaultFormat = exports.formats.default(key, data);
-        if (!defaultFormat)
-            return [key, null];
-        var gameFormat = exports.formats[key](defaultFormat);
-        return [key, gameFormat];
-    }));
-    return returnAsSingle ? Object.values(formatted)[0] : formatted;
-}
-exports.default = gameFormat;

package/lib/methods/calculateLevel.d.ts

@@ -1,2 +0,0 @@
-import { GAME } from "../types/GAME_INFO";
-export default function calculateLevel(xp: number, game: GAME): number;

package/lib/methods/calculateLevel.js

@@ -1,45 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var GAME_INFO_1 = require("../types/GAME_INFO");
-function calculateLevel(xp, game) {
-    if (game === GAME_INFO_1.GAME.TheBridge) {
-        var lastXp = 0;
-        var currentXp = 300;
-        var increment = 300;
-        var additionalIncrement = 300;
-        var i = 2;
-        while (true) {
-            if (xp === currentXp)
-                return i;
-            else if (xp < currentXp)
-                return i + (xp - lastXp) / (currentXp - lastXp) - 1;
-            additionalIncrement = Math.floor(additionalIncrement * 1.08);
-            increment += additionalIncrement;
-            lastXp = currentXp;
-            currentXp += increment;
-            i++;
-        }
-    }
-    var gameInfo = GAME_INFO_1.GAME_INFO[game];
-    var INCREMENT = gameInfo.increment / 2;
-    var INCREMENT_CAP = gameInfo.incrementCap;
-    var level = (INCREMENT + Math.sqrt(INCREMENT * (INCREMENT + 4 * xp))) /
-        (2 * INCREMENT);
-    if (!INCREMENT_CAP || level <= INCREMENT_CAP)
-        return boundLevel(level, gameInfo.maxLevel);
-    level =
-        INCREMENT_CAP +
-            (xp -
-                (INCREMENT * Math.pow(INCREMENT_CAP - 1, 2) +
-                    (INCREMENT_CAP - 1) * INCREMENT)) /
-                ((INCREMENT_CAP - 1) * INCREMENT * 2);
-    return boundLevel(level, gameInfo.maxLevel);
-}
-exports.default = calculateLevel;
-function boundLevel(level, maxLevel) {
-    if (level < 0)
-        return 0;
-    if (level > maxLevel)
-        return maxLevel;
-    return parseFloat(level.toFixed(2));
-}

package/lib/methods/fetchData.d.ts

@@ -1,25 +0,0 @@
-import { API_BASE_GAME_ALL, API_BASE_GAME_MONTHLY, API_GAME_STATS, API_GLOBAL_STATISTICS, API_MAP, API_METADATA, API_REQUEST_ALL, API_REQUEST_LB } from "../types/API";
-import { GAME_LB_ALLTIME_ENDPOINT, GAME_LB_MONTHLY_ENDPOINT, GAME_LB_SPECIFIC_MONTHLY_ENDPOINT, GAME_MAPS_ENDPOINT, GAME_METADATA_ENDPOINT, GLOBAL_STATISTICS_ENDPOINT, PLAYER_ALLTIME_ENDPOINT, PLAYER_LB_SPECIFIC_MONTHLY_ENDPOINT, PLAYER_MONTHLY_ENDPOINT } from "../types/ENDPOINTS";
-import { USER_MAIN } from "../types/GAMES";
-import { GAME } from "../types/GAME_INFO";
-import { MethodResponse } from "../types/METHODS";
-export interface FetchOptions {
-    headers: {
-        [key: string]: string;
-    };
-}
-export declare const API_ROOT = "https://api.playhive.com/v0";
-export default function fetchData(endpoint: PLAYER_ALLTIME_ENDPOINT<"all", string>, options?: FetchOptions): Promise<MethodResponse<API_REQUEST_ALL>>;
-export default function fetchData(endpoint: PLAYER_ALLTIME_ENDPOINT<"main", string>, options?: FetchOptions): Promise<MethodResponse<{
-    main: USER_MAIN;
-}>>;
-export default function fetchData<G extends GAME>(endpoint: PLAYER_ALLTIME_ENDPOINT<G, string>, options?: FetchOptions): Promise<MethodResponse<API_GAME_STATS<API_BASE_GAME_ALL>[G]>>;
-export default function fetchData(endpoint: PLAYER_MONTHLY_ENDPOINT<"all", string>, options?: FetchOptions): Promise<MethodResponse<API_GAME_STATS<API_BASE_GAME_MONTHLY>>>;
-export default function fetchData<G extends GAME>(endpoint: PLAYER_MONTHLY_ENDPOINT<G, string>, options?: FetchOptions): Promise<MethodResponse<API_GAME_STATS<API_BASE_GAME_MONTHLY>[G]>>;
-export default function fetchData<G extends GAME>(endpoint: GAME_LB_ALLTIME_ENDPOINT<G>, options?: FetchOptions): Promise<MethodResponse<API_REQUEST_LB<G>>>;
-export default function fetchData<G extends GAME>(endpoint: GAME_LB_MONTHLY_ENDPOINT<G>, options?: FetchOptions): Promise<MethodResponse<API_REQUEST_LB<G>>>;
-export default function fetchData<G extends GAME>(endpoint: PLAYER_LB_SPECIFIC_MONTHLY_ENDPOINT<G, string, number, number, number, number>, options?: FetchOptions): Promise<MethodResponse<API_REQUEST_LB<G>>>;
-export default function fetchData<G extends GAME>(endpoint: GAME_LB_SPECIFIC_MONTHLY_ENDPOINT<G, number, number, number, number>, options?: FetchOptions): Promise<MethodResponse<API_REQUEST_LB<G>>>;
-export default function fetchData(endpoint: GLOBAL_STATISTICS_ENDPOINT, options?: FetchOptions): Promise<MethodResponse<API_GLOBAL_STATISTICS>>;
-export default function fetchData<G extends GAME>(endpoint: GAME_MAPS_ENDPOINT<G>, options?: FetchOptions): Promise<MethodResponse<API_MAP[]>>;
-export default function fetchData<G extends GAME>(endpoint: GAME_METADATA_ENDPOINT<G>, options?: FetchOptions): Promise<MethodResponse<API_METADATA>>;

package/lib/methods/getAllTimeStats.d.ts

@@ -1,13 +0,0 @@
-import { Options } from "../types/API";
-import { BASE_GAME_ALL, GAME_STATS, GAME_STATS_ALL, REQUEST_ALL, USER_MAIN } from "../types/GAMES";
-import { GAME } from "../types/GAME_INFO";
-import { MethodResponse } from "../types/METHODS";
-export default function getAllTimeStats(playerIdentifier: string, options?: Options): Promise<MethodResponse<Omit<REQUEST_ALL, "main">> & {
-    player: USER_MAIN;
-}>;
-export default function getAllTimeStats<G extends GAME>(playerIdentifier: string, game: G, options?: Options): Promise<MethodResponse<GAME_STATS<BASE_GAME_ALL>[G]>>;
-export default function getAllTimeStats<G extends GAME>(playerIdentifier: string, game: G[], options?: Options): Promise<MethodResponse<{
-    [M in G]: GAME_STATS_ALL<M>;
-}> & {
-    player: USER_MAIN;
-}>;

package/lib/methods/getAllTimeStats.js

@@ -1,186 +0,0 @@
-"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 __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-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;
-    return g = { next: verb(0), "throw": verb(1), "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 gameFormat_1 = __importStar(require("../format/gameFormat"));
-var GAME_INFO_1 = require("../types/GAME_INFO");
-var fetchData_1 = __importDefault(require("./fetchData"));
-function getAllTimeStats(playerIdentifier, game, options) {
-    return __awaiter(this, void 0, void 0, function () {
-        var _a, data, error, gameData, filteredGamesEntries, filteredGames, err_1, _b, data, error, gameData, err_2, _c, data, error, gameData, FILTER_GAMES_1, filteredGamesEntries, filteredGames, err_3;
-        var _d;
-        return __generator(this, function (_e) {
-            switch (_e.label) {
-                case 0:
-                    if (typeof game === "object" && !(game instanceof Array)) {
-                        options = game;
-                        game = undefined;
-                    }
-                    if (!!game) return [3 /*break*/, 4];
-                    _e.label = 1;
-                case 1:
-                    _e.trys.push([1, 3, , 4]);
-                    return [4 /*yield*/, (0, fetchData_1.default)("/game/all/all/".concat(playerIdentifier), options === null || options === void 0 ? void 0 : options.fetch)];
-                case 2:
-                    _a = _e.sent(), data = _a.data, error = _a.error;
-                    if (error || !data)
-                        return [2 /*return*/, {
-                                data: null,
-                                error: __assign({ message: "Failed to fetch data." }, error),
-                            }];
-                    gameData = (0, gameFormat_1.default)(data);
-                    filteredGamesEntries = Object.entries(gameData).filter(function (_a) {
-                        var _b = __read(_a, 1), key = _b[0];
-                        return Object.values(GAME_INFO_1.GAME).includes(key);
-                    });
-                    filteredGames = Object.fromEntries(filteredGamesEntries);
-                    return [2 /*return*/, {
-                            data: filteredGames,
-                            error: null,
-                            player: gameFormat_1.formats.main(data.main),
-                        }];
-                case 3:
-                    err_1 = _e.sent();
-                    console.error(err_1);
-                    return [2 /*return*/, { data: null, error: { message: "Failed to fetch data." } }];
-                case 4:
-                    if (!(typeof game === "string")) return [3 /*break*/, 8];
-                    _e.label = 5;
-                case 5:
-                    _e.trys.push([5, 7, , 8]);
-                    return [4 /*yield*/, (0, fetchData_1.default)("/game/all/".concat(game, "/").concat(playerIdentifier), options === null || options === void 0 ? void 0 : options.fetch)];
-                case 6:
-                    _b = _e.sent(), data = _b.data, error = _b.error;
-                    if (error || !data)
-                        return [2 /*return*/, {
-                                data: null,
-                                error: __assign({ message: "Failed to fetch data." }, error),
-                            }];
-                    gameData = (0, gameFormat_1.default)((_d = {}, _d[game] = data, _d));
-                    return [2 /*return*/, { data: gameData[game], error: null }];
-                case 7:
-                    err_2 = _e.sent();
-                    console.error(err_2);
-                    return [2 /*return*/, { data: null, error: { message: "Failed to fetch data." } }];
-                case 8:
-                    if (!Array.isArray(game)) return [3 /*break*/, 12];
-                    _e.label = 9;
-                case 9:
-                    _e.trys.push([9, 11, , 12]);
-                    return [4 /*yield*/, (0, fetchData_1.default)("/game/all/all/".concat(playerIdentifier), options === null || options === void 0 ? void 0 : options.fetch)];
-                case 10:
-                    _c = _e.sent(), data = _c.data, error = _c.error;
-                    if (error || !data)
-                        return [2 /*return*/, {
-                                data: null,
-                                error: __assign({ message: "Failed to fetch data." }, error),
-                            }];
-                    gameData = (0, gameFormat_1.default)(data);
-                    FILTER_GAMES_1 = game;
-                    filteredGamesEntries = Object.entries(gameData).filter(function (_a) {
-                        var _b = __read(_a, 1), key = _b[0];
-                        return FILTER_GAMES_1.includes(key);
-                    });
-                    filteredGames = Object.fromEntries(filteredGamesEntries);
-                    return [2 /*return*/, {
-                            data: filteredGames,
-                            error: null,
-                            player: gameFormat_1.formats.main(data.main),
-                        }];
-                case 11:
-                    err_3 = _e.sent();
-                    console.error(err_3);
-                    return [2 /*return*/, { data: null, error: { message: "Failed to fetch data." } }];
-                case 12: return [2 /*return*/, { data: null, error: { message: "Failed to detect game type." } }];
-            }
-        });
-    });
-}
-exports.default = getAllTimeStats;

package/lib/methods/getGameMetadata.d.ts

@@ -1,4 +0,0 @@
-import { API_METADATA, Options } from "../types/API";
-import { GAME } from "../types/GAME_INFO";
-import { MethodResponse } from "../types/METHODS";
-export default function getGameMetadata(game: GAME, options?: Options): Promise<MethodResponse<API_METADATA>>;

package/lib/methods/getMonthlyStats.d.ts

@@ -1,15 +0,0 @@
-import { Options } from "../types/API";
-import { BASE_GAME_MONTHLY, GAME_STATS, GAME_STATS_ALL, REQUEST_MONTHLY } from "../types/GAMES";
-import { GAME } from "../types/GAME_INFO";
-import { MethodResponse } from "../types/METHODS";
-interface OptionsType extends Options {
-    year?: number;
-    month?: number;
-    date?: Date;
-}
-export default function getMonthlyStats(playerIdentifier: string, options?: Options): Promise<MethodResponse<Omit<REQUEST_MONTHLY, "main">>>;
-export default function getMonthlyStats<G extends GAME>(playerIdentifier: string, game: G, options?: OptionsType): Promise<MethodResponse<GAME_STATS<BASE_GAME_MONTHLY>[G]>>;
-export default function getMonthlyStats<G extends GAME>(playerIdentifier: string, game: G[], options?: Options): Promise<MethodResponse<{
-    [M in G]: GAME_STATS_ALL<M>;
-}>>;
-export {};