hypixel-api-reborn 11.3.4 → 12.0.0-0

package/dist/src/Errors.js

@@ -0,0 +1,28 @@
+/* eslint-disable max-len */
+class Errors {
+    INVALID_API_KEY = '[Hypixel-API-Reborn] Invalid API Key! For help join our Discord Server https://discord.gg/NSEBNMM';
+    NO_API_KEY = '[Hypixel-API-Reborn] No API Key specified! For help join our Discord Server https://discord.gg/NSEBNMM';
+    ERROR_CODE_CAUSE = '[Hypixel-API-Reborn] Code: {code} - {cause}! For help join our Discord Server https://discord.gg/NSEBNMM';
+    ERROR_STATUSTEXT = '[Hypixel-API-Reborn] {statustext}! For help join our Discord Server https://discord.gg/NSEBNMM';
+    NO_NICKNAME_UUID = '[Hypixel-API-Reborn] No nickname or uuid specified.';
+    NO_UUID = '[Hypixel-API-Reborn] No uuid specified.';
+    UUID_NICKNAME_MUST_BE_A_STRING = '[Hypixel-API-Reborn] Nickname or uuid must be a string.';
+    MALFORMED_UUID = '[Hypixel-API-Reborn] Malformed UUID!';
+    PLAYER_HAS_NEVER_LOGGED = '[Hypixel-API-Reborn] Player has never logged into Hypixel.';
+    NO_GUILD_QUERY = '[Hypixel-API-Reborn] No guild search query specified.';
+    INVALID_GUILD_ID = '[Hypixel-API-Reborn] Specified Guild ID is invalid.';
+    INVALID_GUILD_SEARCH_PARAMETER = "[Hypixel-API-Reborn] getGuild() searchParameter must be 'id'; 'guild' or 'player'.";
+    SOMETHING_WENT_WRONG = '[Hypixel-API-Reborn] Something went wrong. {cause}';
+    GUILD_DOES_NOT_EXIST = '[Hypixel-API-Reborn] Guild does not exist.';
+    PAGE_INDEX_ERROR = '[Hypixel-API-Reborn] Invalid page index. Must be an integer, an array of 2 integers, or a keyword. For help join our Discord Server https://discord.gg/NSEBNMM';
+    INVALID_OPTION_VALUE = '[Hypixel-API-Reborn] Invalid option value! For help join our Discord Server https://discord.gg/NSEBNMM';
+    UPDATER_REQUEST_NOT_OK = '[Hypixel-API-Reborn] Something went wrong while checking for updates.';
+    MULTIPLE_INSTANCES = '[Hypixel-API-Reborn] Multiple instances of hypixel-api-reborn are found so we merged them for you. Please refrain from spawning multiple instances in the future. For more information, join our Discord Server https://discord.gg/NSEBNMM.';
+    UNEXPECTED_ERROR = "[Hypixel-API-Reborn] The data provided to hypixel API is malformed and thus not recognized by hypixel, but this shouldn't be your fault. Please report this error in our Discord Server https://discord.gg/NSEBNMM or GitHub. ";
+    RATE_LIMIT_EXCEEDED = "[Hypixel-API-Reborn] The rate limitations on your API Key has been exceeded. There might be an outage (Check Hypixel's status page), or you simply did too many requests in a short time. Hint: Enable rate limit options! They can help you avoid this error! For help join our Discord Server https://discord.gg/NSEBNMM";
+    NO_SKYBLOCK_PROFILES = '[Hypixel-API-Reborn] The player has no skyblock profiles.';
+    BAD_AUCTION_FILTER = '[Hypixel-API-Reborn] Unexpected filter for Client#getSkyblockAuction. Expected one of "PLAYER", "AUCTION", "PROFILE", but got something else.';
+    NOT_IMPLEMENTED = '[Hypixel-API-Reborn] Endpoint execute method is not implemented yet! Please report this https://discord.gg/NSEBNMM';
+    RATE_LIMIT_INIT_ERROR = '[hypixel-api-reborn] An error happened whilst initializing rate limit. We strongly recommend restarting the code as this can lead to desynchronization.';
+}
+export default Errors;

package/dist/src/Private/CacheHandler.js

@@ -0,0 +1,31 @@
+import NodeCache from 'node-cache';
+class CacheHandler {
+    client;
+    constructor(client) {
+        this.client = client;
+        this.cache = new NodeCache({
+            stdTTL: this.client.options.cacheTime,
+            maxKeys: this.client.options.cacheMaxKeys,
+            checkperiod: this.client.options.cacheCheckPeriod
+        });
+    }
+    set(key, value) {
+        return this.cache.set(key, value);
+    }
+    has(key) {
+        return this.cache.has(key);
+    }
+    get(key) {
+        return this.cache.get(key);
+    }
+    keys() {
+        return this.cache.keys();
+    }
+    size() {
+        return this.cache.keys().length;
+    }
+    clear() {
+        this.cache.flushAll();
+    }
+}
+export default CacheHandler;

package/dist/src/Private/CacheHandler.test.js

@@ -0,0 +1,37 @@
+import Client from '../Client';
+import { expect, expectTypeOf, test } from 'vitest';
+test('CacheHandler', () => {
+    const client = new Client(process.env.HYPIXEL_KEY ?? '');
+    expect(client).toBeDefined();
+    expectTypeOf(client).toEqualTypeOf();
+    expect(client.cacheHandler).toBeDefined();
+    expectTypeOf(client.cacheHandler).toEqualTypeOf();
+    expect(client.cacheHandler.cache).toBeDefined();
+    expectTypeOf(client.cacheHandler.cache).toEqualTypeOf();
+    expect(client.cacheHandler.set).toBeDefined();
+    expectTypeOf(client.cacheHandler.set).toBeFunction();
+    expect(() => client.cacheHandler.set('test', 'value')).not.toThrow();
+    expect(client.cacheHandler.get).toBeDefined();
+    expectTypeOf(client.cacheHandler.get).toBeFunction();
+    expect(() => client.cacheHandler.has('test')).not.toThrow();
+    expect(client.cacheHandler.has('test')).toBe(true);
+    expect(client.cacheHandler.get).toBeDefined();
+    expectTypeOf(client.cacheHandler.get).toBeFunction();
+    expect(() => client.cacheHandler.get('test')).not.toThrow();
+    expect(client.cacheHandler.get('test')).toBe('value');
+    expect(client.cacheHandler.keys).toBeDefined();
+    expectTypeOf(client.cacheHandler.keys).toBeFunction();
+    expect(() => client.cacheHandler.keys()).not.toThrow();
+    expect(client.cacheHandler.keys()).toEqual(['test']);
+    expectTypeOf(client.cacheHandler.keys()).toEqualTypeOf();
+    expect(client.cacheHandler.size).toBeDefined();
+    expectTypeOf(client.cacheHandler.size).toBeFunction();
+    expect(() => client.cacheHandler.size()).not.toThrow();
+    expect(client.cacheHandler.size()).toBe(1);
+    expectTypeOf(client.cacheHandler.size()).toEqualTypeOf();
+    expect(client.cacheHandler.clear).toBeDefined();
+    expectTypeOf(client.cacheHandler.clear).toBeFunction();
+    expect(() => client.cacheHandler.clear()).not.toThrow();
+    expect(client.cacheHandler.size()).toBe(0);
+    client.destroy();
+});

package/dist/src/Private/Endpoint.js

@@ -0,0 +1,10 @@
+class Endpoint {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    execute(...args) {
+        throw new Error(this.client.errors.NOT_IMPLEMENTED);
+    }
+}
+export default Endpoint;

package/dist/src/Private/Endpoint.test.js

@@ -0,0 +1,17 @@
+import Client from '../Client';
+import Endpoint from './Endpoint';
+import { expect, expectTypeOf, test } from 'vitest';
+test('Endpoint', () => {
+    const client = new Client(process.env.HYPIXEL_KEY ?? '');
+    expect(client).toBeDefined();
+    expectTypeOf(client).toEqualTypeOf();
+    const endpoint = new Endpoint(client);
+    expect(endpoint).toBeDefined();
+    expectTypeOf(endpoint).toEqualTypeOf();
+    expect(endpoint.client).toBeDefined();
+    expectTypeOf(endpoint.client).toEqualTypeOf();
+    expect(endpoint.execute).toBeDefined();
+    expectTypeOf(endpoint.execute).toBeFunction();
+    expect(() => endpoint.execute()).toThrowError(client.errors.NOT_IMPLEMENTED);
+    client.destroy();
+});

package/dist/src/Private/RateLimit.js

@@ -0,0 +1,30 @@
+class RateLimit {
+    client;
+    constructor(client) {
+        this.client = client;
+        this.requests = 0;
+        this.limit = 0;
+        this.initialized = false;
+        this.interval = setInterval(() => this.reset(), 300000);
+    }
+    async sync() {
+        const { headers } = await this.client.requests.request('/boosters', { raw: true });
+        if (headers?.['ratelimit-limit'] === undefined || headers?.['ratelimit-remaining'] === undefined) {
+            throw new Error(this.client.errors.RATE_LIMIT_INIT_ERROR);
+        }
+        this.requests = headers['ratelimit-limit'] - headers['ratelimit-remaining'];
+        this.limit = Number(headers['ratelimit-limit']);
+    }
+    reset() {
+        if (false === this.initialized)
+            return;
+        this.requests = 0;
+    }
+    async initialize() {
+        if (this.initialized)
+            return;
+        await this.sync();
+        this.initialized = true;
+    }
+}
+export default RateLimit;

package/dist/src/Private/RateLimit.test.js

@@ -0,0 +1,73 @@
+import Client from '../Client';
+import axios from 'axios';
+import { expect, expectTypeOf, test, vi } from 'vitest';
+test('RateLimit (None)', () => {
+    const client = new Client(process.env.HYPIXEL_KEY ?? '', { rateLimit: 'NONE' });
+    expect(client).toBeDefined();
+    expectTypeOf(client).toEqualTypeOf();
+    expect(client.rateLimit).toBeDefined();
+    expectTypeOf(client.rateLimit).toEqualTypeOf();
+    expect(client.rateLimit.requests).toBe(0);
+    expectTypeOf(client.rateLimit.requests).toEqualTypeOf();
+    expect(client.rateLimit.limit).toBe(0);
+    expectTypeOf(client.rateLimit.limit).toEqualTypeOf();
+    expect(client.rateLimit.initialized).toBe(false);
+    expectTypeOf(client.rateLimit.initialized).toEqualTypeOf();
+    expect(client.rateLimit.sync).toBeDefined();
+    expectTypeOf(client.rateLimit.sync).toBeFunction();
+    expect(() => client.rateLimit.sync()).not.toThrow();
+    expect(client.rateLimit.reset).toBeDefined();
+    expectTypeOf(client.rateLimit.reset).toBeFunction();
+    expect(() => client.rateLimit.reset()).not.toThrow();
+    expect(client.rateLimit.initialize).toBeDefined();
+    expectTypeOf(client.rateLimit.initialize).toBeFunction();
+    expect(() => client.rateLimit.initialize()).not.toThrow();
+    client.destroy();
+});
+test('RateLimit (Auto)', async () => {
+    const client = new Client(process.env.HYPIXEL_KEY ?? '', { rateLimit: 'NONE' });
+    expect(client).toBeDefined();
+    expectTypeOf(client).toEqualTypeOf();
+    expect(client.rateLimit).toBeDefined();
+    expectTypeOf(client.rateLimit).toEqualTypeOf();
+    await client.rateLimit.initialize();
+    expect(client.rateLimit.requests).greaterThan(0);
+    expectTypeOf(client.rateLimit.requests).toEqualTypeOf();
+    expect(client.rateLimit.limit).toBe(300);
+    expectTypeOf(client.rateLimit.limit).toEqualTypeOf();
+    expect(client.rateLimit.initialized).toBe(true);
+    expectTypeOf(client.rateLimit.initialized).toEqualTypeOf();
+    expect(client.rateLimit.sync).toBeDefined();
+    expectTypeOf(client.rateLimit.sync).toBeFunction();
+    expect(() => client.rateLimit.sync()).not.toThrow();
+    expect(client.rateLimit.reset).toBeDefined();
+    expectTypeOf(client.rateLimit.reset).toBeFunction();
+    expect(() => client.rateLimit.reset()).not.toThrow();
+    expect(client.rateLimit.initialize).toBeDefined();
+    expectTypeOf(client.rateLimit.initialize).toBeFunction();
+    expect(() => client.rateLimit.initialize()).not.toThrow();
+    client.destroy();
+});
+test('Ratelimit (Sync)', async () => {
+    const client = new Client(process.env.HYPIXEL_KEY ?? '');
+    client.updater.currentVersion = '1.0.0';
+    vi.spyOn(axios, 'get').mockResolvedValue({
+        status: 200,
+        data: { success: true },
+        headers: { 'ratelimit-limit': 30, 'ratelimit-remaining': 27 }
+    });
+    expect(() => client.rateLimit.sync()).not.toThrowError();
+    await client.rateLimit.sync();
+    expect(client.rateLimit.requests).toBe(3);
+    expect(client.rateLimit.limit).toBe(30);
+    vi.restoreAllMocks();
+    client.destroy();
+});
+test('Ratelimit (Bad Sync Data)', () => {
+    const client = new Client(process.env.HYPIXEL_KEY ?? '');
+    client.updater.currentVersion = '1.0.0';
+    vi.spyOn(axios, 'get').mockResolvedValue({ status: 200, data: { success: true }, headers: { hello: 100 } });
+    expect(() => client.rateLimit.sync()).rejects.toThrowError(client.errors.RATE_LIMIT_INIT_ERROR);
+    vi.restoreAllMocks();
+    client.destroy();
+});

package/dist/src/Private/Requests.js

@@ -0,0 +1,106 @@
+const BASE_URL = 'http://localhost:3000/hypixel';
+import axios from 'axios';
+import isUUID from '../utils/isUUID';
+class RequestData {
+    data;
+    headers;
+    statusCode;
+    options;
+    requestTimestamp;
+    requestAt;
+    requestUrl;
+    cached;
+    constructor(data, headers, info) {
+        this.data = data;
+        this.headers = headers;
+        this.statusCode = info.status;
+        this.options = info.options;
+        this.requestTimestamp = info.timestamp || Date.now();
+        this.requestAt = new Date(this.requestTimestamp);
+        this.requestUrl = info.url;
+        this.cached = info.cached;
+    }
+}
+class Requests {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async request(endpoint, options) {
+        options = { raw: options?.raw ?? false, noCache: options?.noCache ?? false };
+        if (this.client.cacheHandler.has(endpoint)) {
+            const data = this.client.cacheHandler.get(endpoint);
+            return new RequestData(data.data, data.headers, {
+                status: 200,
+                options,
+                url: endpoint,
+                cached: true,
+                timestamp: data.timestamp
+            });
+        }
+        const res = await axios.get(BASE_URL + endpoint, { headers: { 'API-Key': this.client.key } });
+        if (500 <= res.status && 528 > res.status) {
+            throw new Error(this.client.errors.ERROR_STATUSTEXT.replace(/{statustext}/, `Server Error : ${res.status} ${res.statusText}`));
+        }
+        const parsedRes = await res.data;
+        if (400 === res.status) {
+            throw new Error(this.client.errors.ERROR_CODE_CAUSE.replace(/{code}/, '400 Bad Request').replace(/{cause}/, parsedRes.cause || ''));
+        }
+        if (403 === res.status)
+            throw new Error(this.client.errors.INVALID_API_KEY);
+        if (422 === res.status)
+            throw new Error(this.client.errors.UNEXPECTED_ERROR);
+        if (429 === res.status)
+            throw new Error(this.client.errors.RATE_LIMIT_EXCEEDED);
+        if (200 !== res.status) {
+            throw new Error(this.client.errors.ERROR_STATUSTEXT.replace(/{statustext}/, res.statusText));
+        }
+        if (!parsedRes.success && !endpoint.startsWith('/housing')) {
+            throw new Error(this.client.errors.SOMETHING_WENT_WRONG.replace(/{cause}/, res.statusText));
+        }
+        this.client.rateLimit.requests++;
+        const requestData = new RequestData(parsedRes, res.headers, {
+            status: res.status,
+            options,
+            url: endpoint,
+            cached: false
+        });
+        if (options.noCache)
+            return requestData;
+        if (this.client.options.cache && !options.raw) {
+            this.client.cacheHandler.set(endpoint, requestData);
+        }
+        return requestData;
+    }
+    async toUUID(input) {
+        if (!input)
+            throw new Error(this.client.errors.NO_NICKNAME_UUID);
+        if ('string' !== typeof input)
+            throw new Error(this.client.errors.UUID_NICKNAME_MUST_BE_A_STRING);
+        if (isUUID(input))
+            return input.replace(/-/g, '');
+        const url = `http://localhost:3000/uuid/${input}`;
+        if (this.client.cacheHandler.has(url)) {
+            return this.client.cacheHandler.get(url);
+        }
+        const res = await axios.get(url);
+        if (500 <= res.status && 528 > res.status) {
+            throw new Error(this.client.errors.ERROR_STATUSTEXT.replace(/{statustext}/, `Server Error : ${res.status} ${res.statusText}`));
+        }
+        const parsedRes = await res.data;
+        if (400 === res.status) {
+            throw new Error(this.client.errors.ERROR_CODE_CAUSE.replace(/{code}/, '400 Bad Request').replace(/{cause}/, parsedRes.cause || ''));
+        }
+        if (200 !== res.status) {
+            throw new Error(this.client.errors.ERROR_STATUSTEXT.replace(/{statustext}/, res.statusText));
+        }
+        if ('string' !== typeof parsedRes.id || 'string' !== typeof parsedRes.name) {
+            throw new Error(this.client.errors.MALFORMED_UUID);
+        }
+        if (this.client.options.cache) {
+            this.client.cacheHandler.set(url, parsedRes.id);
+        }
+        return parsedRes.id;
+    }
+}
+export default Requests;

package/dist/src/Private/Requests.test.js

@@ -0,0 +1,48 @@
+import Client from '../Client';
+import axios from 'axios';
+import { expect, expectTypeOf, test, vi } from 'vitest';
+test('Requests', async () => {
+    const client = new Client(process.env.HYPIXEL_KEY ?? '');
+    expect(client).toBeDefined();
+    expectTypeOf(client).toEqualTypeOf();
+    expect(client.requests).toBeDefined();
+    expectTypeOf(client.requests).toEqualTypeOf();
+    expect(client.requests.toUUID).toBeDefined();
+    expectTypeOf(client.requests.toUUID).toBeFunction();
+    const data = await client.requests.toUUID('pixelic');
+    expect(data).toBe('14727faefbdc4aff848cd2713eb9939e');
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-expect-error
+    expect(() => client.requests.toUUID()).rejects.toThrowError(client.errors.NO_NICKNAME_UUID);
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-expect-error
+    expect(() => client.requests.toUUID(-1)).rejects.toThrowError(client.errors.UUID_NICKNAME_MUST_BE_A_STRING);
+    client.destroy();
+});
+test('Requests (Invalid API Key)', () => {
+    const client = new Client(process.env.HYPIXEL_KEY ?? '');
+    expect(client.requests.request).toBeDefined();
+    expectTypeOf(client.requests.request).toBeFunction();
+    vi.spyOn(axios, 'get').mockResolvedValue({ status: 403, data: {} });
+    expect(() => client.requests.request('/boosters')).rejects.toThrowError(client.errors.INVALID_API_KEY);
+    vi.restoreAllMocks();
+    client.destroy();
+});
+test('Requests (Unprocessable Entity)', () => {
+    const client = new Client(process.env.HYPIXEL_KEY ?? '');
+    expect(client.requests.request).toBeDefined();
+    expectTypeOf(client.requests.request).toBeFunction();
+    vi.spyOn(axios, 'get').mockResolvedValue({ status: 422, data: {} });
+    expect(() => client.requests.request('/boosters')).rejects.toThrowError(client.errors.UNEXPECTED_ERROR);
+    vi.restoreAllMocks();
+    client.destroy();
+});
+test('Requests (Rate Limited)', () => {
+    const client = new Client(process.env.HYPIXEL_KEY ?? '');
+    expect(client.requests.request).toBeDefined();
+    expectTypeOf(client.requests.request).toBeFunction();
+    vi.spyOn(axios, 'get').mockResolvedValue({ status: 429, data: {} });
+    expect(() => client.requests.request('/boosters')).rejects.toThrowError(client.errors.RATE_LIMIT_EXCEEDED);
+    vi.restoreAllMocks();
+    client.destroy();
+});

package/dist/src/Private/Updater.js

@@ -0,0 +1,41 @@
+import axios from 'axios';
+import { version } from '../../package.json';
+class Updater {
+    client;
+    currentVersion;
+    latestVersion;
+    constructor(client) {
+        this.client = client;
+        this.currentVersion = version;
+        this.latestVersion = '0.0.0';
+    }
+    async checkForUpdates() {
+        this.latestVersion = await this.getLatestVersion();
+        const compare = this.compareVersions(this.currentVersion, this.latestVersion);
+        if (compare) {
+            console.log(`New version of hypixel-api-reborn is available! Current version: ${this.currentVersion}, Latest version: ${this.latestVersion}`);
+        }
+    }
+    async getLatestVersion() {
+        const request = await axios.get('http://localhost:3000/npm/hypixel-api-reborn');
+        if (200 !== request.status)
+            throw new Error(this.client.errors.UPDATER_REQUEST_NOT_OK);
+        return request.data['dist-tags'].latest;
+    }
+    compareVersions(a, b) {
+        const pa = a.split('.');
+        const pb = b.split('.');
+        for (let i = 0; 3 > i; i++) {
+            const na = Number(pa[i]);
+            const nb = Number(pb[i]);
+            if (isNaN(na) || isNaN(nb))
+                return false;
+            if (na > nb)
+                return false;
+            if (nb > na)
+                return true;
+        }
+        return false;
+    }
+}
+export default Updater;

package/dist/src/Private/Updater.test.js

@@ -0,0 +1,52 @@
+import Client from '../Client';
+import axios from 'axios';
+import { expect, expectTypeOf, test, vi } from 'vitest';
+import { version } from '../../package.json';
+test('Updater', () => {
+    const client = new Client(process.env.HYPIXEL_KEY ?? '');
+    expect(client).toBeDefined();
+    expectTypeOf(client).toEqualTypeOf();
+    expect(client.updater).toBeDefined();
+    expectTypeOf(client.updater).toEqualTypeOf();
+    expect(client.updater.currentVersion).toBe(version);
+    expect(client.updater.latestVersion).toBe('0.0.0');
+    expect(client.updater.checkForUpdates).toBeDefined();
+    expectTypeOf(client.updater.checkForUpdates).toBeFunction();
+    expect(() => client.updater.checkForUpdates()).not.toThrow();
+    expect(client.updater.getLatestVersion).toBeDefined();
+    expectTypeOf(client.updater.getLatestVersion).toBeFunction();
+    expect(() => client.updater.getLatestVersion()).not.toThrow();
+    expect(client.updater.compareVersions).toBeDefined();
+    expectTypeOf(client.updater.compareVersions).toBeFunction();
+    expect(() => client.updater.compareVersions('1.0.0', '1.0.0')).not.toThrow();
+    expect(client.updater.compareVersions('1.0.0', '1.0.0')).toBe(false);
+    expect(client.updater.compareVersions('1.0.0', '1.0.1')).toBe(true);
+    expect(client.updater.compareVersions('1.0.1', '1.0.0')).toBe(false);
+    expect(client.updater.compareVersions('meow', '1.0.0')).toBe(false);
+    client.destroy();
+});
+test('Updater (get latest version)', async () => {
+    const client = new Client(process.env.HYPIXEL_KEY ?? '');
+    vi.spyOn(axios, 'get').mockResolvedValue({ status: 200, data: { 'dist-tags': { latest: '1.0.0' } } });
+    const data = await client.updater.getLatestVersion();
+    expect(data).toBe('1.0.0');
+    vi.restoreAllMocks();
+    client.destroy();
+});
+test('Updater (get latest version error)', () => {
+    const client = new Client(process.env.HYPIXEL_KEY ?? '');
+    vi.spyOn(axios, 'get').mockResolvedValue({ status: 404, data: { 'dist-tags': { latest: '1.0.0' } } });
+    expect(() => client.updater.getLatestVersion()).rejects.toThrowError(client.errors.UPDATER_REQUEST_NOT_OK);
+    vi.restoreAllMocks();
+    client.destroy();
+});
+test('Updater (check version)', async () => {
+    const client = new Client(process.env.HYPIXEL_KEY ?? '');
+    const consoleLogSpy = vi.spyOn(console, 'log');
+    client.updater.currentVersion = '1.0.0';
+    vi.spyOn(axios, 'get').mockResolvedValue({ status: 200, data: { 'dist-tags': { latest: version } } });
+    await client.updater.checkForUpdates();
+    expect(consoleLogSpy).toHaveBeenCalledWith(`New version of hypixel-api-reborn is available! Current version: 1.0.0, Latest version: ${version}`);
+    vi.restoreAllMocks();
+    client.destroy();
+});

package/dist/src/index.js

@@ -0,0 +1,34 @@
+/* v8 ignore next 200 */
+export * from './Client';
+export * from './Errors';
+export * from './Private/CacheHandler';
+export * from './Private/Updater';
+export * from './Private/Endpoint';
+export * from './Private/Requests';
+export * from './API/getAchievements';
+export * from './API/getActiveHouses';
+export * from './API/getBoosters';
+export * from './API/getChallenges';
+export * from './API/getGameCounts';
+export * from './API/getGuild';
+export * from './API/getGuildAchievements';
+export * from './API/getHouse';
+export * from './API/getLeaderboards';
+export * from './API/getPlayer';
+export * from './API/getPlayerHouses';
+export * from './API/getQuests';
+export * from './API/getRecentGames';
+export * from './API/getSkyblockAuction';
+export * from './API/getSkyblockAuctions';
+export * from './API/getSkyblockAuctionsByPlayer';
+export * from './API/getSkyblockBazaar';
+export * from './API/getSkyblockBingo';
+export * from './API/getSkyblockFireSales';
+export * from './API/getSkyblockGarden';
+export * from './API/getSkyblockGovernment';
+export * from './API/getSkyblockMember';
+export * from './API/getSkyblockMuseum';
+export * from './API/getSkyblockNews';
+export * from './API/getSkyblockProfiles';
+export * from './API/getStatus';
+export * from './API/getWatchdogStats';

package/dist/src/structures/Boosters/Booster.js

@@ -0,0 +1,38 @@
+import Game from '../Game';
+export function parseType(data) {
+    if (true === data.stacked)
+        return 'STACKED';
+    if (!data.stacked)
+        return 'QUEUED';
+    return 'ACTIVE';
+}
+class Booster {
+    purchaser;
+    amount;
+    originalLength;
+    remaining;
+    activatedTimestamp;
+    activated;
+    game;
+    isActive;
+    type;
+    stackers;
+    expired;
+    constructor(data) {
+        this.purchaser = data.purchaserUuid;
+        this.amount = data.amount;
+        this.originalLength = data.originalLength;
+        this.remaining = data.length;
+        this.activatedTimestamp = data.dateActivated;
+        this.activated = new Date(data.dateActivated);
+        this.game = new Game(data.gameType);
+        this.isActive = Array.isArray(data.stacked);
+        this.type = parseType(data);
+        this.stackers = Array.isArray(data.stacked) ? Array.from(data.stacked) : [];
+        this.expired = 0 > data.length;
+    }
+    toString() {
+        return `${this.purchaser}'s booster in ${this.game}`;
+    }
+}
+export default Booster;

package/dist/src/structures/Boosters/Booster.test.js

@@ -0,0 +1,7 @@
+import { expect, test } from 'vitest';
+import { parseType } from './Booster';
+test('Booster (parseType)', () => {
+    expect(parseType({ stacked: true })).toBe('STACKED');
+    expect(parseType({ stacked: false })).toBe('QUEUED');
+    expect(parseType({ stacked: 'meow' })).toBe('ACTIVE');
+});

package/dist/src/structures/Color.js

@@ -0,0 +1,73 @@
+const ColorStrings = {
+    BLACK: 'Black',
+    DARK_BLUE: 'Dark Blue',
+    DARK_GREEN: 'Dark Green',
+    DARK_AQUA: 'Dark Aqua',
+    DARK_RED: 'Dark Red',
+    DARK_PURPLE: 'Dark Purple',
+    GOLD: 'Gold',
+    GRAY: 'Gray',
+    DARK_GRAY: 'Dark Gray',
+    BLUE: 'Blue',
+    GREEN: 'Green',
+    AQUA: 'Aqua',
+    RED: 'Red',
+    LIGHT_PURPLE: 'Light Purple',
+    YELLOW: 'Yellow',
+    WHITE: 'White'
+};
+const ColorHexs = {
+    BLACK: '#000000',
+    DARK_BLUE: '#0000AA',
+    DARK_GREEN: '#008000',
+    DARK_AQUA: '#00AAAA',
+    DARK_RED: '#AA0000',
+    DARK_PURPLE: '#AA00AA',
+    GOLD: '#FFAA00',
+    GRAY: '#AAAAAA',
+    DARK_GRAY: '#555555',
+    BLUE: '#5555FF',
+    GREEN: '#3CE63C',
+    AQUA: '#3CE6E6',
+    RED: '#FF5555',
+    LIGHT_PURPLE: '#FF55FF',
+    YELLOW: '#FFFF55',
+    WHITE: '#FFFFFF'
+};
+const InGameCodes = {
+    BLACK: '§0',
+    DARK_BLUE: '§1',
+    DARK_GREEN: '§2',
+    DARK_AQUA: '§3',
+    DARK_RED: '§4',
+    DARK_PURPLE: '§5',
+    GOLD: '§6',
+    GRAY: '§7',
+    DARK_GRAY: '§8',
+    BLUE: '§9',
+    GREEN: '§a',
+    AQUA: '§b',
+    RED: '§c',
+    LIGHT_PURPLE: '§d',
+    YELLOW: '§e',
+    WHITE: '§f'
+};
+class Color {
+    color;
+    constructor(color) {
+        this.color = color;
+    }
+    toString() {
+        return ColorStrings[this.color];
+    }
+    toHex() {
+        return ColorHexs[this.color];
+    }
+    toCode() {
+        return this.color;
+    }
+    toInGameCode() {
+        return InGameCodes[this.color];
+    }
+}
+export default Color;

package/dist/src/structures/Color.test.js

@@ -0,0 +1,23 @@
+import Color from './Color';
+import { expect, expectTypeOf, test } from 'vitest';
+test('Color', () => {
+    const data = new Color('BLACK');
+    expect(data).toBeDefined();
+    expect(data).toBeInstanceOf(Color);
+    expectTypeOf(data).toEqualTypeOf();
+    expect(data.color).toBeDefined();
+    expectTypeOf(data.color).toEqualTypeOf();
+    expect(data.color).toBe('BLACK');
+    expect(data.toString()).toBeDefined();
+    expectTypeOf(data.toString()).toEqualTypeOf();
+    expect(data.toString()).toBe('Black');
+    expect(data.toHex()).toBeDefined();
+    expectTypeOf(data.toHex()).toEqualTypeOf();
+    expect(data.toHex()).toBe('#000000');
+    expect(data.toCode()).toBeDefined();
+    expectTypeOf(data.toCode()).toEqualTypeOf();
+    expect(data.toCode()).toBe('BLACK');
+    expect(data.toInGameCode()).toBeDefined();
+    expectTypeOf(data.toInGameCode()).toEqualTypeOf();
+    expect(data.toInGameCode()).toBe('§0');
+});