hypixel-api-reborn 11.3.4 → 12.0.0-0

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "hypixel-api-reborn",
-  "version": "11.3.4",
+  "version": "12.0.0-0",
   "description": "Feature-rich Hypixel API wrapper for Node.js",
-  "main": "./src/index.js",
-  "types": "./typings/index.d.ts",
+  "main": "dist/index.js",
+  "types": "dist/src/typings/index.d.ts",
   "keywords": [
     "minecraft",
     "client",
@@ -16,41 +16,48 @@
     "url": "https://github.com/Hypixel-API-Reborn/hypixel-api-reborn/issues"
   },
   "scripts": {
-    "lint": "npx eslint src/",
-    "lint:fix": "npx eslint src/ --fix",
-    "tests": "npx mocha tests --exit --recursive",
-    "docgen": " npx docgen -s src/ --custom docs/index.yml -o ./master.json",
-    "prettier": "npx prettier --write src/ typings/",
-    "prettier:check": "npx prettier --check src/ typings/"
+    "lint:check": "npx eslint src/",
+    "lint": "npx eslint src/ --fix",
+    "prettier:check": "npx prettier --check src/",
+    "prettier": "npx prettier --write src/",
+    "build": "npx tsc",
+    "test": "npx vitest run",
+    "test:coverage": "npx vitest --ui --coverage"
   },
   "engines": {
-    "node": ">=18.18.0"
+    "node": ">=20.17.0"
   },
-  "author": "StavZ",
+  "type": "module",
+  "packageManager": "pnpm@9.7.1",
+  "author": "Kathund",
   "dependencies": {
+    "axios": "^1.7.7",
+    "farming-weight": "^0.4.13",
     "node-cache": "^5.1.2",
-    "node-fetch": "^3.3.2",
     "prismarine-nbt": "^2.5.0",
     "rss-parser": "^3.13.0",
-    "skyhelper-networth": "^1.23.0"
+    "skyhelper-networth": "^1.24.0"
   },
   "license": "MIT",
-  "readme": "https://hypixel.stavzdev.me/",
+  "readme": "https://github.com/Hypixel-API-Reborn/hypixel-api-reborn?tab=readme-ov-file#hypixel-api--reborn",
   "repository": {
-    "url": "https://github.com/Hypixel-API-Reborn/hypixel-api-reborn"
+    "url": "git+https://github.com/Hypixel-API-Reborn/hypixel-api-reborn.git"
   },
-  "publisher": "StavZ",
+  "publisher": "Kathund",
   "devDependencies": {
-    "@discordjs/docgen": "github:discordjs/docgen",
-    "@types/node": "^22.1.0",
-    "chai": "^4.3.4",
-    "eslint": "^9.8.0",
-    "eslint-plugin-jsdoc": "^49.0.0",
+    "@eslint/js": "^9.9.1",
+    "@j4cobi/eslint-plugin-sort-imports": "^1.0.2",
+    "@types/eslint": "^9.6.1",
+    "@types/node": "^20.16.3",
+    "@vitest/coverage-v8": "^2.0.5",
+    "@vitest/ui": "^2.0.5",
+    "dotenv": "^16.4.5",
+    "eslint": "^9.9.1",
+    "eslint-config-prettier": "^9.1.0",
     "globals": "^15.9.0",
-    "mocha": "^10.4.0",
-    "node-env-run": "^4.0.2",
-    "path": "^0.12.7",
     "prettier": "^3.3.3",
-    "typescript": "^5.5.4"
+    "typescript": "^5.5.4",
+    "typescript-eslint": "^8.3.0",
+    "vitest": "^2.0.5"
   }
 }

package/renovate.json

@@ -0,0 +1,21 @@
+{
+  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+  "extends": ["config:recommended"],
+  "labels": ["dependencies"],
+  "timezone": "UTC",
+  "assignees": ["kathund"],
+  "reviewers": ["kathund"],
+  "schedule": "before 5am every weekday",
+  "ignoreDeps": ["pnpm", "node"],
+  "npm": {
+    "rangeStrategy": "bump",
+    "packageRules": [
+      {
+        "matchUpdateTypes": ["minor", "patch"],
+        "matchCurrentVersion": "!/^0/",
+        "automerge": true,
+        "commitMessagePrefix": "chore(deps):"
+      }
+    ]
+  }
+}

package/src/API/API.d.ts

@@ -0,0 +1,16 @@
+import { RequestOptions } from '../Private/Requests';
+
+export interface PlayerRequestOptions extends RequestOptions {
+  guild?: boolean;
+  houses?: boolean;
+  recentGames?: boolean;
+}
+
+export interface AuctionRequestOptions extends RequestOptions {
+  includeItemBytes?: boolean;
+}
+
+export interface SkyblockRequestOptions extends RequestOptions {
+  garden?: boolean;
+  museum?: boolean;
+}

package/src/API/getAchievements.test.ts

@@ -0,0 +1,81 @@
+import Achievement from '../structures/Static/Achievement';
+import AchievementTier from '../structures/Static/AchievementTier';
+import Achievements from '../structures/Static/Achievements';
+import Client from '../Client';
+import GameAchievements from '../structures/Static/GameAchievements';
+import { StaticGameNames } from '../typings';
+import { expect, expectTypeOf, test } from 'vitest';
+
+test('getAchievements (raw)', async () => {
+  const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false });
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-expect-error
+  const data = await client.getAchievements({ raw: true });
+  expect(data).toBeDefined();
+  expectTypeOf(data).toEqualTypeOf<object>();
+  client.destroy();
+});
+
+test('getAchievements', async () => {
+  const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false });
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-expect-error
+  const data = await client.getAchievements();
+  expect(data).toBeDefined();
+  expect(data).toBeInstanceOf(Achievements);
+  expectTypeOf(data).toEqualTypeOf<Achievements>();
+  expect(data.lastUpdatedTimestamp).toBeDefined();
+  expectTypeOf(data.lastUpdatedTimestamp).toEqualTypeOf<number>();
+  expect(data.lastUpdatedTimestamp).toBeGreaterThan(0);
+  expect(data.lastUpdatedAt).toBeDefined();
+  expectTypeOf(data.lastUpdatedAt).toEqualTypeOf<Date>();
+  expect(data.achievementsPerGame).toBeDefined();
+  expectTypeOf(data.achievementsPerGame).toEqualTypeOf<Record<StaticGameNames, GameAchievements>>();
+  Object.keys(data.achievementsPerGame).forEach((game) => {
+    expect(data.achievementsPerGame[game]).toBeDefined();
+    expect(data.achievementsPerGame[game]).toBeInstanceOf(GameAchievements);
+    expectTypeOf(data.achievementsPerGame[game]).toEqualTypeOf<GameAchievements>();
+    expect(data.achievementsPerGame[game].category).toBeDefined();
+    expect(data.achievementsPerGame[game].category).toBe(game);
+    expectTypeOf(data.achievementsPerGame[game].totalPoints).toEqualTypeOf<string>();
+    expect(data.achievementsPerGame[game].totalPoints).toBeDefined();
+    expect(data.achievementsPerGame[game].totalPoints).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.achievementsPerGame[game].totalPoints).toEqualTypeOf<number>();
+    expect(data.achievementsPerGame[game].totalLegacyPoints).toBeDefined();
+    expect(data.achievementsPerGame[game].totalLegacyPoints).toBeGreaterThanOrEqual(0);
+    expect(data.achievementsPerGame[game].totalLegacyPoints).toBeDefined();
+    expectTypeOf(data.achievementsPerGame[game].totalLegacyPoints).toEqualTypeOf<number>();
+    expect(data.achievementsPerGame[game].achievements).toBeDefined();
+    expectTypeOf(data.achievementsPerGame[game].achievements).toEqualTypeOf<Achievement[]>();
+    data.achievementsPerGame[game].achievements.forEach((gameAchievement: Achievement) => {
+      expect(gameAchievement).toBeDefined();
+      expect(gameAchievement).toBeInstanceOf(Achievement);
+      expectTypeOf(gameAchievement).toEqualTypeOf<Achievement>();
+      expect(gameAchievement.name).toBeDefined();
+      expectTypeOf(gameAchievement.name).toEqualTypeOf<string>();
+      expect(gameAchievement.codeName).toBeDefined();
+      expectTypeOf(gameAchievement.codeName).toEqualTypeOf<string>();
+      expect(gameAchievement.description).toBeDefined();
+      expectTypeOf(gameAchievement.description).toEqualTypeOf<string>();
+      expect(gameAchievement.type).toBeDefined();
+      expectTypeOf(gameAchievement.type).toEqualTypeOf<'ONE_TIME' | 'TIERED'>();
+      expect(['ONE_TIME', 'TIERED']).toContain(gameAchievement.type);
+      expect(gameAchievement.rarity).toBeDefined();
+      expectTypeOf(gameAchievement.rarity).toEqualTypeOf<Record<
+        'local' | 'localPercentage' | 'global' | 'globalPercentage',
+        number
+      > | null>();
+      expect(gameAchievement.tierInformation).toBeDefined();
+      expectTypeOf(gameAchievement.tierInformation).toEqualTypeOf<AchievementTier | null>();
+      expect(gameAchievement.points).toBeDefined();
+      expectTypeOf(gameAchievement.points).toEqualTypeOf<number>();
+      if ('TIERED' === gameAchievement.type) {
+        expect(gameAchievement.totalAmountRequired).toBeDefined();
+        expectTypeOf(gameAchievement.totalAmountRequired).toEqualTypeOf<number | null>();
+      }
+      expect(gameAchievement.toString()).toBeDefined();
+      expectTypeOf(gameAchievement.toString()).toEqualTypeOf<string>();
+    });
+  });
+  client.destroy();
+});

package/src/API/getAchievements.ts

@@ -0,0 +1,20 @@
+import Achievements from '../structures/Static/Achievements';
+import Client from '../Client';
+import Endpoint from '../Private/Endpoint';
+import { RequestOptions } from '../Private/Requests';
+
+class getAchievements extends Endpoint {
+  readonly client: Client;
+  constructor(client: Client) {
+    super(client);
+    this.client = client;
+  }
+
+  async execute(options?: RequestOptions): Promise<Achievements> {
+    const res = await this.client.requests.request('/resources/achievements', options);
+    if (res.options.raw) return res.data;
+    return new Achievements(res.data);
+  }
+}
+
+export default getAchievements;

package/src/API/getActiveHouses.test.ts

@@ -0,0 +1,45 @@
+import Client from '../Client';
+import House from '../structures/House';
+import { expect, expectTypeOf, test } from 'vitest';
+
+test('getActiveHouses (raw)', async () => {
+  const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false });
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-expect-error
+  const data = await client.getActiveHouses({ raw: true });
+  expect(data).toBeDefined();
+  expectTypeOf(data).toEqualTypeOf<object>();
+  client.destroy();
+});
+
+test('getActiveHouses', async () => {
+  const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false });
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-expect-error
+  const data = await client.getActiveHouses();
+  expect(data).toBeDefined();
+  expectTypeOf(data).toEqualTypeOf<House[]>();
+  data.forEach((house: House) => {
+    expect(house).toBeDefined();
+    expect(house).toBeInstanceOf(House);
+    expectTypeOf(house).toEqualTypeOf<House>();
+    expect(house.name).toBeDefined();
+    expectTypeOf(house.name).toEqualTypeOf<string>();
+    expect(house.uuid).toBeDefined();
+    expectTypeOf(house.uuid).toEqualTypeOf<string>();
+    expect(house.owner).toBeDefined();
+    expectTypeOf(house.owner).toEqualTypeOf<string>();
+    expect(house.createdAtTimestamp).toBeDefined();
+    expectTypeOf(house.createdAtTimestamp).toEqualTypeOf<number>();
+    expect(house.createdAt).toBeDefined();
+    expectTypeOf(house.createdAt).toEqualTypeOf<Date>();
+    expect(house.players).toBeDefined();
+    expectTypeOf(house.players).toEqualTypeOf<number>();
+    expect(house.cookies).toBeDefined();
+    expectTypeOf(house.cookies).toEqualTypeOf<number>();
+    expect(house.toString()).toBeDefined();
+    expectTypeOf(house.toString()).toEqualTypeOf<string>();
+    expect(house.toString()).toBe(house.name);
+  });
+  client.destroy();
+});

package/src/API/getActiveHouses.ts

@@ -0,0 +1,20 @@
+import Client from '../Client';
+import Endpoint from '../Private/Endpoint';
+import House from '../structures/House';
+import { RequestOptions } from '../Private/Requests';
+
+class getActiveHouses extends Endpoint {
+  readonly client: Client;
+  constructor(client: Client) {
+    super(client);
+    this.client = client;
+  }
+
+  async execute(options?: RequestOptions): Promise<House[]> {
+    const res = await this.client.requests.request('/housing/active', options);
+    if (res.options.raw) return res.data;
+    return res.data.map((b: any) => new House(b));
+  }
+}
+
+export default getActiveHouses;

package/src/API/getBoosters.test.ts

@@ -0,0 +1,53 @@
+import Booster from '../structures/Boosters/Booster';
+import Client from '../Client';
+import Game from '../structures/Game';
+import { expect, expectTypeOf, test } from 'vitest';
+
+test('getBoosters (raw)', async () => {
+  const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false });
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-expect-error
+  const data = await client.getBoosters({ raw: true });
+  expect(data).toBeDefined();
+  expectTypeOf(data).toEqualTypeOf<object>();
+  client.destroy();
+});
+
+test('getBoosters', async () => {
+  const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false });
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-expect-error
+  const data = await client.getBoosters();
+  expect(data).toBeDefined();
+  expectTypeOf(data).toEqualTypeOf<Booster[]>();
+  data.forEach((booster: Booster) => {
+    expect(booster).toBeDefined();
+    expect(booster).toBeInstanceOf(Booster);
+    expectTypeOf(booster).toEqualTypeOf<Booster>();
+    expect(booster.purchaser).toBeDefined();
+    expectTypeOf(booster.purchaser).toEqualTypeOf<string>();
+    expect(booster.amount).toBeDefined();
+    expectTypeOf(booster.amount).toEqualTypeOf<number>();
+    expect(booster.originalLength).toBeDefined();
+    expectTypeOf(booster.originalLength).toEqualTypeOf<number>();
+    expect(booster.remaining).toBeDefined();
+    expectTypeOf(booster.remaining).toEqualTypeOf<number>();
+    expect(booster.activatedTimestamp).toBeDefined();
+    expectTypeOf(booster.activatedTimestamp).toEqualTypeOf<number>();
+    expect(booster.activated).toBeDefined();
+    expectTypeOf(booster.activated).toEqualTypeOf<Date>();
+    expect(booster.game).toBeDefined();
+    expectTypeOf(booster.game).toEqualTypeOf<Game | null>();
+    expect(booster.isActive).toBeDefined();
+    expectTypeOf(booster.isActive).toEqualTypeOf<boolean>();
+    expect(booster.type).toBeDefined();
+    expectTypeOf(booster.type).toEqualTypeOf<'STACKED' | 'QUEUED' | 'ACTIVE'>();
+    expect(booster.stackers).toBeDefined();
+    expectTypeOf(booster.stackers).toEqualTypeOf<string[]>();
+    expect(booster.expired).toBeDefined();
+    expectTypeOf(booster.expired).toEqualTypeOf<boolean>();
+    expect(booster.toString()).toBeDefined();
+    expectTypeOf(booster.toString()).toEqualTypeOf<string>();
+  });
+  client.destroy();
+});

package/src/API/getBoosters.ts

@@ -0,0 +1,20 @@
+import Booster from '../structures/Boosters/Booster';
+import Client from '../Client';
+import Endpoint from '../Private/Endpoint';
+import { RequestOptions } from '../Private/Requests';
+
+class getBoosters extends Endpoint {
+  readonly client: Client;
+  constructor(client: Client) {
+    super(client);
+    this.client = client;
+  }
+
+  async execute(options?: RequestOptions): Promise<Booster[]> {
+    const res = await this.client.requests.request('/boosters', options);
+    if (res.options.raw) return res.data;
+    return res.data.boosters.map((b: any) => new Booster(b)).reverse();
+  }
+}
+
+export default getBoosters;

package/src/API/getChallenges.test.ts

@@ -0,0 +1,54 @@
+import Challenges from '../structures/Static/Challenges';
+import Client from '../Client';
+import GameChallenges, { ChallengeData } from '../structures/Static/GameChallenges';
+import { StaticGameNames } from '../typings';
+import { expect, expectTypeOf, test } from 'vitest';
+
+test('getChallenges (raw)', async () => {
+  const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false });
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-expect-error
+  const data = await client.getChallenges({ raw: true });
+  expect(data).toBeDefined();
+  expectTypeOf(data).toEqualTypeOf<object>();
+  client.destroy();
+});
+
+test('getChallenges', async () => {
+  const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false });
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-expect-error
+  const data = await client.getChallenges();
+  expect(data).toBeDefined();
+  expect(data).toBeInstanceOf(Challenges);
+  expectTypeOf(data).toEqualTypeOf<Challenges>();
+  expect(data.lastUpdatedTimestamp).toBeDefined();
+  expect(data.lastUpdatedTimestamp).toBeGreaterThan(0);
+  expectTypeOf(data.lastUpdatedTimestamp).toEqualTypeOf<number>();
+  expect(data.lastUpdatedAt).toBeDefined();
+  expectTypeOf(data.lastUpdatedAt).toEqualTypeOf<Date>();
+  expect(data.challengesPerGame).toBeDefined();
+  expectTypeOf(data.challengesPerGame).toEqualTypeOf<Record<StaticGameNames, GameChallenges>>();
+  Object.keys(data.challengesPerGame).forEach((game) => {
+    expect(data.challengesPerGame[game]).toBeDefined();
+    expect(data.challengesPerGame[game]).toBeInstanceOf(GameChallenges);
+    expectTypeOf(data.challengesPerGame[game]).toEqualTypeOf<GameChallenges>();
+    expect(data.challengesPerGame[game].category).toBeDefined();
+    expect(data.challengesPerGame[game].category).toEqual(game);
+    expect(data.challengesPerGame[game].challenges).toBeDefined();
+    expectTypeOf(data.challengesPerGame[game].challenges).toEqualTypeOf<Map<string, ChallengeData>>();
+    data.challengesPerGame[game].challenges.forEach((challenge: ChallengeData) => {
+      expect(challenge).toBeDefined();
+      expectTypeOf(challenge).toEqualTypeOf<ChallengeData>();
+      expect(challenge.id).toBeDefined();
+      expectTypeOf(challenge.id).toEqualTypeOf<string>();
+      expect(challenge.name).toBeDefined();
+      expectTypeOf(challenge.name).toEqualTypeOf<string>();
+      expect(challenge.reward).toBeDefined();
+      expectTypeOf(challenge.reward).toEqualTypeOf<number>();
+      expect(challenge.rewardType).toBeDefined();
+      expectTypeOf(challenge.rewardType).toEqualTypeOf<string>();
+    });
+  });
+  client.destroy();
+});

package/src/API/getChallenges.ts

@@ -0,0 +1,19 @@
+import Challenges from '../structures/Static/Challenges';
+import Client from '../Client';
+import Endpoint from '../Private/Endpoint';
+import { RequestOptions } from '../Private/Requests';
+
+class getChallenges extends Endpoint {
+  readonly client: Client;
+  constructor(client: Client) {
+    super(client);
+    this.client = client;
+  }
+
+  async execute(options?: RequestOptions): Promise<Challenges> {
+    const res = await this.client.requests.request('/resources/challenges', options);
+    if (res.options.raw) return res.data;
+    return new Challenges(res.data);
+  }
+}
+export default getChallenges;

package/src/API/getGameCounts.test.ts

@@ -0,0 +1,28 @@
+import Client from '../Client';
+import GameCounts from '../structures/GameCounts';
+import { expect, expectTypeOf, test } from 'vitest';
+
+test('getGameCounts (raw)', async () => {
+  const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false });
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-expect-error
+  const data = await client.getGameCounts({ raw: true });
+  expect(data).toBeDefined();
+  expectTypeOf(data).toEqualTypeOf<object>();
+  client.destroy();
+});
+
+test('getGameCounts', async () => {
+  const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false });
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-expect-error
+  const data = await client.getGameCounts();
+  expect(data).toBeDefined();
+  expect(data).toBeInstanceOf(GameCounts);
+  expectTypeOf(data).toEqualTypeOf<GameCounts>();
+  expect(data.playerCount).toBeDefined();
+  expectTypeOf(data.playerCount).toEqualTypeOf<number>();
+  expect(data.toString()).toBeDefined();
+  expectTypeOf(data.toString()).toEqualTypeOf<number>();
+  client.destroy();
+});

package/src/API/getGameCounts.ts

@@ -0,0 +1,20 @@
+import Client from '../Client';
+import Endpoint from '../Private/Endpoint';
+import GameCounts from '../structures/GameCounts';
+import { RequestOptions } from '../Private/Requests';
+
+class getGameCounts extends Endpoint {
+  readonly client: Client;
+  constructor(client: Client) {
+    super(client);
+    this.client = client;
+  }
+
+  async execute(options?: RequestOptions): Promise<GameCounts> {
+    const res = await this.client.requests.request('/counts', options);
+    if (res.options.raw) return res.data;
+    return new GameCounts(res.data);
+  }
+}
+
+export default getGameCounts;