hypixel-api-reborn 11.3.4 → 12.0.0-0

package/src/structures/SkyBlock/Static/Bingo.ts

@@ -0,0 +1,50 @@
+function parsePosition(position: number): [number, number] {
+  const x = (position % 5) + 1;
+  const y = Math.floor(position / 5) + 1;
+  return [x, y];
+}
+
+class Bingo {
+  name: string;
+  id: string;
+  row: number | null;
+  column: number | null;
+  rawLore: string;
+  lore: string;
+  tiers: number[];
+  tierStep: number | null;
+  requiredAmount: number | null;
+  type: 'ONE_TIME' | 'ONE_TIER' | 'TIERED';
+  constructor(data: Record<string, any>, position: number = 0) {
+    this.name = data.name;
+    this.id = data.id;
+    const [row, column] = parsePosition(position);
+    this.row = row;
+    this.column = column;
+    this.rawLore = data.lore;
+    this.lore = data.lore?.replace?.(/§([1-9]|[a-l])|§/gm, '') || [];
+    this.tiers = Array.isArray(data.tiers) ? data.tiers.map((x) => parseInt(x, 10) || 0) : [];
+    this.tierStep = this.getTierStep();
+    this.requiredAmount = parseInt(data.requiredAmount, 10) ?? null;
+    this.type = this.tiers ? 'TIERED' : this.requiredAmount ? 'ONE_TIER' : 'ONE_TIME';
+  }
+
+  toString(): string {
+    return this.id;
+  }
+
+  private getTierStep(): number | null {
+    if ('TIERED' !== this.type) return null;
+    // No step possible
+    if (2 > this.tiers.length) return null;
+    const hypotheticStep = this.tiers[1] - this.tiers[0];
+    // Check if every 2 elements have the same step
+    const isConstant = this.tiers.slice(1).every((el, index) => {
+      return hypotheticStep === this.tiers[index - 1] - el;
+    });
+    if (!isConstant) return null;
+    return hypotheticStep;
+  }
+}
+
+export default Bingo;

package/src/structures/SkyBlock/Static/BingoData.ts

@@ -0,0 +1,21 @@
+import Bingo from './Bingo';
+
+class BingoData {
+  lastUpdatedTimestamp: number;
+  lastUpdatedAt: Date | null;
+  id: number | null;
+  goals: Bingo[] | null;
+  constructor(data: Record<string, any>) {
+    this.lastUpdatedTimestamp = parseInt(data.lastUpdated, 10);
+    this.lastUpdatedAt = new Date(this.lastUpdatedTimestamp);
+    this.id = parseInt(data.id, 10) || null;
+    this.goals = Array.isArray(data.goals) ? data.goals.map((goal, index) => new Bingo(goal, index)) : null;
+  }
+
+  getGoal(column: number, row: number): Bingo | undefined {
+    if (!this.goals || 1 > this.goals.length) return;
+    return this.goals.find((goal) => goal.row === row && goal.column === column);
+  }
+}
+
+export default BingoData;

package/src/structures/SkyBlock/Static/Candidate.ts

@@ -0,0 +1,22 @@
+import Perk from './Perk';
+
+class Candidate {
+  name: string;
+  keyBenefit: string;
+  perks: Perk[];
+  isMayor: boolean;
+  votesReceived: number;
+  constructor(data: Record<string, any>, isMayor: boolean = false) {
+    this.name = data.name;
+    this.keyBenefit = data.key;
+    this.perks = data.perks.map((x: any) => new Perk(x));
+    this.isMayor = isMayor || false;
+    this.votesReceived = parseInt(data.votes, 10);
+  }
+
+  toString(): string {
+    return this.name;
+  }
+}
+
+export default Candidate;

package/src/structures/SkyBlock/Static/FireSale.ts

@@ -0,0 +1,24 @@
+class FireSale {
+  itemId: string | null;
+  startTimestamp: number;
+  startAt: Date;
+  endTimestamp: number;
+  endAt: Date;
+  amount: number;
+  price: number;
+  constructor(data: Record<string, any>) {
+    this.itemId = data.item_id || null;
+    this.startTimestamp = parseInt(data.start, 10);
+    this.startAt = new Date(this.startTimestamp);
+    this.endTimestamp = parseInt(data.end, 10);
+    this.endAt = new Date(this.endTimestamp);
+    this.amount = data.amount || 0;
+    this.price = data.price || 0;
+  }
+
+  toString(): string | null {
+    return this.itemId;
+  }
+}
+
+export default FireSale;

package/src/structures/SkyBlock/Static/Government.ts

@@ -0,0 +1,42 @@
+import Candidate from './Candidate';
+
+class GovernmentData {
+  lastUpdatedTimestamp: number;
+  lastUpdatedAt: Date;
+  lastElectionResults: Map<string, Candidate>;
+  mayor: Candidate | undefined;
+  runningYear: number;
+  currentElectionResults: Map<string, Candidate> | null;
+  currentElectionFor: number | null;
+  constructor(data: Record<string, any>) {
+    this.lastUpdatedTimestamp = parseInt(data.lastUpdated, 10);
+    this.lastUpdatedAt = new Date(this.lastUpdatedTimestamp);
+    const lastElectionResults = data.mayor.election.candidates.map(
+      (x: any) => new Candidate(x, x.name === data.mayor.name)
+    );
+    this.lastElectionResults = new Map(
+      lastElectionResults
+        .sort((a: any, b: any) => a.votesReceived - b.votesReceived)
+        .reverse()
+        .map((x: any) => [x.name, x])
+    );
+    this.mayor = this.lastElectionResults.get(data.mayor.name);
+    this.runningYear = parseInt(data.mayor.election.year, 10) || 0;
+    const thisElection = data.current?.candidates.map((x: any) => new Candidate(x, x.name === data.mayor.name)) || null;
+    this.currentElectionResults = thisElection
+      ? new Map(
+          thisElection
+            .sort((a: any, b: any) => a.votesReceived - b.votesReceived)
+            .reverse()
+            .map((x: any) => [x.name, x])
+        )
+      : null;
+    this.currentElectionFor = parseInt(data.current?.year, 10) || null;
+  }
+
+  toString(): string {
+    return this.mayor?.name || '';
+  }
+}
+
+export default GovernmentData;

package/src/structures/SkyBlock/Static/Perk.ts

@@ -0,0 +1,10 @@
+class Perk {
+  name: string;
+  description: string;
+  constructor(data: Record<string, any>) {
+    this.name = data.name;
+    this.description = data.description;
+  }
+}
+
+export default Perk;

package/src/structures/Static/Achievement.ts

@@ -0,0 +1,49 @@
+import AchievementTier from './AchievementTier';
+
+function collectAll(data: AchievementTier | null) {
+  if (null === data) {
+    return { totalPoints: 0, totalAmount: 0 };
+  }
+  const mTier = data.maxTier;
+  let totalPoints = 0;
+  let totalAmount = 0;
+  for (let i = 1; i <= mTier; i++) {
+    totalPoints += data.getTier(i).pointsRewarded;
+    totalAmount += data.getTier(i).amountRequired;
+  }
+  return { totalPoints, totalAmount };
+}
+
+class Achievement {
+  name: string;
+  codeName: string;
+  description: string;
+  type: 'ONE_TIME' | 'TIERED';
+  rarity: Record<'local' | 'localPercentage' | 'global' | 'globalPercentage', number> | null;
+  tierInformation: AchievementTier | null;
+  points: number;
+  totalAmountRequired: number | null;
+  constructor(achievementName: string, data: Record<string, any>) {
+    this.name = data.name.trim();
+    this.codeName = achievementName;
+    this.description = data.description.trim();
+    this.type = data.tiers ? 'TIERED' : 'ONE_TIME';
+    this.rarity = {
+      local: parseFloat(data.gamePercentUnlocked) || 0,
+      localPercentage: parseFloat(data.gamePercentUnlocked) * 100 || 0,
+      global: data.globalPercentUnlocked,
+      globalPercentage: parseFloat(data.globalPercentUnlocked) * 100 || 0
+    };
+    this.tierInformation = 'TIERED' === this.type ? new AchievementTier(data.tiers) : null;
+    const { totalPoints = 0, totalAmount = 0 }: { totalPoints: number; totalAmount: number } =
+      'TIERED' === this.type ? collectAll(this.tierInformation) : { totalPoints: 0, totalAmount: 0 };
+    this.points = 'ONE_TIME' === this.type ? parseInt(data.points, 10) : totalPoints;
+    this.totalAmountRequired = 'TIERED' === this.type ? totalAmount : null;
+  }
+
+  toString(): string {
+    return this.codeName;
+  }
+}
+
+export default Achievement;

package/src/structures/Static/AchievementTier.ts

@@ -0,0 +1,18 @@
+class AchievementTier {
+  maxTier: number;
+  tierInfo: any;
+  constructor(data: Record<string, any>) {
+    this.maxTier = data.length;
+    this.tierInfo = data.sort(
+      ({ tier: tierA }: { tier: number }, { tier: tierB }: { tier: number }) => Number(tierA) - Number(tierB)
+    );
+  }
+
+  getTier(tier: number): Record<'pointsRewarded' | 'amountRequired', number> {
+    const index = tier - 1;
+    const info = this.tierInfo[index];
+    return { pointsRewarded: parseInt(info.points, 10) || 0, amountRequired: parseInt(info.amount, 10) || 0 };
+  }
+}
+
+export default AchievementTier;

package/src/structures/Static/Achievements.ts

@@ -0,0 +1,20 @@
+import GameAchievements from './GameAchievements';
+import { StaticGameNames } from '../../typings';
+
+class Achievements {
+  lastUpdatedTimestamp: number;
+  lastUpdatedAt: Date | null;
+  achievementsPerGame: Record<StaticGameNames, GameAchievements>;
+  constructor(data: Record<string, any>) {
+    this.lastUpdatedTimestamp = parseInt(data.lastUpdated, 10);
+    this.lastUpdatedAt = new Date(this.lastUpdatedTimestamp);
+    this.achievementsPerGame = Object.fromEntries(
+      Object.entries(data.achievements).map(([game, data]) => [
+        game,
+        new GameAchievements(game as StaticGameNames, data as Record<string, any>)
+      ])
+    ) as Record<StaticGameNames, GameAchievements>;
+  }
+}
+
+export default Achievements;

package/src/structures/Static/Challenges.ts

@@ -0,0 +1,20 @@
+import GameChallenges from './GameChallenges';
+import { StaticGameNames } from '../../typings';
+
+class Challenges {
+  lastUpdatedTimestamp: number;
+  lastUpdatedAt: Date | null;
+  challengesPerGame: Record<StaticGameNames, GameChallenges>;
+  constructor(data: Record<string, any>) {
+    this.lastUpdatedTimestamp = parseInt(data.lastUpdated, 10);
+    this.lastUpdatedAt = new Date(this.lastUpdatedTimestamp);
+    this.challengesPerGame = Object.fromEntries(
+      Object.entries(data.challenges).map(([game, data]) => [
+        game,
+        new GameChallenges(game as StaticGameNames, data as Record<string, any>)
+      ])
+    ) as Record<StaticGameNames, GameChallenges>;
+  }
+}
+
+export default Challenges;

package/src/structures/Static/GameAchievements.ts

@@ -0,0 +1,19 @@
+import Achievement from './Achievement';
+import { StaticGameNames } from '../../typings';
+
+class GameAchievements {
+  category: StaticGameNames;
+  totalPoints: number;
+  totalLegacyPoints: number;
+  achievements: Achievement[];
+  constructor(name: StaticGameNames, data: Record<string, any>) {
+    this.category = name;
+    this.totalPoints = parseInt(data.total_points, 10) || 0;
+    this.totalLegacyPoints = parseInt(data.total_legacy_points, 10) || 0;
+    this.achievements = Object.entries({ ...(data.one_time || {}), ...(data.tiered || {}) }).map(
+      ([name, data]) => new Achievement(name, data as Record<string, any>)
+    );
+  }
+}
+
+export default GameAchievements;

package/src/structures/Static/GameChallenges.ts

@@ -0,0 +1,28 @@
+import { StaticGameNames } from '../../typings';
+
+export interface ChallengeData {
+  id: string;
+  name: string;
+  reward: number;
+  rewardType: string;
+}
+
+class GameChallenges {
+  category: StaticGameNames;
+  challenges: Map<string, ChallengeData>;
+  constructor(name: StaticGameNames, data: Record<string, any>) {
+    this.category = name;
+    this.challenges = new Map();
+    data.forEach((challenge: any) => {
+      const content = {
+        id: challenge.id,
+        name: challenge.name,
+        reward: parseInt(challenge.rewards[0].amount, 10) || 0,
+        rewardType: challenge.rewards[0].type
+      };
+      this.challenges.set(challenge.id, content);
+    });
+  }
+}
+
+export default GameChallenges;

package/src/structures/Static/GameQuests.ts

@@ -0,0 +1,13 @@
+import Quest from './Quest';
+import { StaticGameNames } from '../../typings';
+
+class GameQuests {
+  game: StaticGameNames;
+  quests: Quest[];
+  constructor(name: StaticGameNames, data: Record<string, any>) {
+    this.game = name;
+    this.quests = (data || []).map((x: any) => new Quest(x));
+  }
+}
+
+export default GameQuests;

package/src/structures/Static/GuildAchievements.ts

@@ -0,0 +1,19 @@
+import Achievement from './Achievement';
+
+class GuildAchievements {
+  lastUpdatedTimestamp: number;
+  lastUpdatedAt: Date | null;
+  achievements: Record<string, Achievement>;
+  constructor(data: Record<string, any>) {
+    this.lastUpdatedTimestamp = parseInt(data.lastUpdated, 10);
+    this.lastUpdatedAt = new Date(this.lastUpdatedTimestamp);
+    this.achievements = Object.fromEntries(
+      Object.entries({ ...(data.tiered || {}), ...(data.one_time || {}) }).map(([name, value]) => [
+        name,
+        new Achievement(name, value as Record<string, any>)
+      ])
+    );
+  }
+}
+
+export default GuildAchievements;

package/src/structures/Static/Quest.ts

@@ -0,0 +1,37 @@
+export interface QuestObjective {
+  id: string;
+  type: 'Integer' | 'Boolean';
+  amountNeeded: number;
+}
+
+export interface QuestReward {
+  type: string;
+  amount: number;
+}
+
+class Quest {
+  questName: string;
+  questID: string;
+  description: string;
+  type: 'DAILY' | 'WEEKLY';
+  objectives: QuestObjective[];
+  rewards: QuestReward[];
+  constructor(data: Record<string, any>) {
+    this.questName = data.name.trim();
+    this.questID = data.id;
+    this.description = data.description.trim();
+    this.type = 'DailyResetQuestRequirement' === data.requirements?.[0].type ? 'DAILY' : 'WEEKLY';
+    this.objectives = data.objectives.map((objective: any) => ({
+      id: objective.id,
+      type: 'IntegerObjective' === objective.type ? 'Integer' : 'Boolean',
+      amountNeeded: parseInt(objective.integer || '1', 10)
+    }));
+    this.rewards = data.rewards || [];
+  }
+
+  toString(): string {
+    return this.questName;
+  }
+}
+
+export default Quest;

package/src/structures/Static/Quests.ts

@@ -0,0 +1,20 @@
+import GameQuests from './GameQuests';
+import { StaticGameNames } from '../../typings';
+
+class Quests {
+  lastUpdatedTimestamp: number;
+  lastUpdatedAt: Date | null;
+  questsPerGame: Record<StaticGameNames, GameQuests>;
+  constructor(data: Record<string, any>) {
+    this.lastUpdatedTimestamp = parseInt(data.lastUpdated, 10);
+    this.lastUpdatedAt = new Date(this.lastUpdatedTimestamp);
+    this.questsPerGame = Object.fromEntries(
+      Object.entries(data.quests).map(([game, data]) => [
+        game,
+        new GameQuests(game as StaticGameNames, data as Record<string, any>)
+      ])
+    ) as Record<StaticGameNames, GameQuests>;
+  }
+}
+
+export default Quests;

package/src/structures/Status.ts

@@ -0,0 +1,20 @@
+import Game from './Game';
+
+class Status {
+  online: boolean;
+  game: Game | null;
+  mode: string | null;
+  map: string | null;
+  constructor(data: Record<string, any>) {
+    this.online = data.online;
+    this.game = data.gameType ? new Game(data.gameType) : null;
+    this.mode = data.mode ?? null;
+    this.map = data.map ?? null;
+  }
+
+  toString(): 'Online' | 'Offline' {
+    return this.online ? 'Online' : 'Offline';
+  }
+}
+
+export default Status;

package/src/structures/Watchdog/Stats.ts

@@ -0,0 +1,16 @@
+class WatchdogStats {
+  byWatchdogTotal: number;
+  byWatchdogLastMinute: number;
+  byWatchdogRollingDay: number;
+  byStaffTotal: number;
+  byStaffRollingDay: number;
+  constructor(data: Record<string, any>) {
+    this.byWatchdogTotal = data.watchdog_total;
+    this.byWatchdogLastMinute = data.watchdog_lastMinute;
+    this.byWatchdogRollingDay = data.watchdog_rollingDaily;
+    this.byStaffTotal = data.staff_total;
+    this.byStaffRollingDay = data.staff_rollingDaily;
+  }
+}
+
+export default WatchdogStats;

package/src/typings/index.d.ts

@@ -0,0 +1,24 @@
+export type StaticGameNames =
+  | 'arcade'
+  | 'arena'
+  | 'bedwars'
+  | 'hungergames'
+  | 'buildbattle'
+  | 'truecombat'
+  | 'duels'
+  | 'mcgo'
+  | 'murdermystery'
+  | 'paintball'
+  | 'quake'
+  | 'skyclash'
+  | 'skywars'
+  | 'supersmash'
+  | 'speeduhc'
+  | 'gingerbread'
+  | 'tntgames'
+  | 'uhc'
+  | 'vampirez'
+  | 'walls3'
+  | 'walls'
+  | 'battleground'
+  | 'woolgames';