hypixel-api-reborn 11.3.4 → 12.0.0-0

package/dist/src/structures/SkyBlock/Static/FireSale.js

@@ -0,0 +1,22 @@
+class FireSale {
+    itemId;
+    startTimestamp;
+    startAt;
+    endTimestamp;
+    endAt;
+    amount;
+    price;
+    constructor(data) {
+        this.itemId = data.item_id;
+        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;
+        this.price = data.price;
+    }
+    toString() {
+        return this.itemId;
+    }
+}
+export default FireSale;

package/dist/src/structures/SkyBlock/Static/Government.js

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

package/dist/src/structures/SkyBlock/Static/Perk.js

@@ -0,0 +1,9 @@
+class Perk {
+    name;
+    description;
+    constructor(data) {
+        this.name = data.name;
+        this.description = data.description;
+    }
+}
+export default Perk;

package/dist/src/structures/Static/Achievement.js

@@ -0,0 +1,44 @@
+import AchievementTier from './AchievementTier';
+function collectAll(data) {
+    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;
+    codeName;
+    description;
+    type;
+    rarity;
+    tierInformation;
+    points;
+    totalAmountRequired;
+    constructor(achievementName, data) {
+        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 } = '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() {
+        return this.codeName;
+    }
+}
+export default Achievement;

package/dist/src/structures/Static/AchievementTier.js

@@ -0,0 +1,14 @@
+class AchievementTier {
+    maxTier;
+    tierInfo;
+    constructor(data) {
+        this.maxTier = data.length;
+        this.tierInfo = data.sort(({ tier: tierA }, { tier: tierB }) => Number(tierA) - Number(tierB));
+    }
+    getTier(tier) {
+        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/dist/src/structures/Static/Achievements.js

@@ -0,0 +1,15 @@
+import GameAchievements from './GameAchievements';
+class Achievements {
+    lastUpdatedTimestamp;
+    lastUpdatedAt;
+    achievementsPerGame;
+    constructor(data) {
+        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, data)
+        ]));
+    }
+}
+export default Achievements;

package/dist/src/structures/Static/Challenges.js

@@ -0,0 +1,15 @@
+import GameChallenges from './GameChallenges';
+class Challenges {
+    lastUpdatedTimestamp;
+    lastUpdatedAt;
+    challengesPerGame;
+    constructor(data) {
+        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, data)
+        ]));
+    }
+}
+export default Challenges;

package/dist/src/structures/Static/GameAchievements.js

@@ -0,0 +1,14 @@
+import Achievement from './Achievement';
+class GameAchievements {
+    category;
+    totalPoints;
+    totalLegacyPoints;
+    achievements;
+    constructor(name, data) {
+        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));
+    }
+}
+export default GameAchievements;

package/dist/src/structures/Static/GameChallenges.js

@@ -0,0 +1,18 @@
+class GameChallenges {
+    category;
+    challenges;
+    constructor(name, data) {
+        this.category = name;
+        this.challenges = new Map();
+        data.forEach((challenge) => {
+            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/dist/src/structures/Static/GameQuests.js

@@ -0,0 +1,10 @@
+import Quest from './Quest';
+class GameQuests {
+    game;
+    quests;
+    constructor(name, data) {
+        this.game = name;
+        this.quests = data.map((x) => new Quest(x));
+    }
+}
+export default GameQuests;

package/dist/src/structures/Static/GuildAchievements.js

@@ -0,0 +1,15 @@
+import Achievement from './Achievement';
+class GuildAchievements {
+    lastUpdatedTimestamp;
+    lastUpdatedAt;
+    achievements;
+    constructor(data) {
+        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)
+        ]));
+    }
+}
+export default GuildAchievements;

package/dist/src/structures/Static/Quest.js

@@ -0,0 +1,24 @@
+class Quest {
+    questName;
+    questID;
+    description;
+    type;
+    objectives;
+    rewards;
+    constructor(data) {
+        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) => ({
+            id: objective.id,
+            type: 'IntegerObjective' === objective.type ? 'Integer' : 'Boolean',
+            amountNeeded: parseInt(objective.integer || '1', 10)
+        }));
+        this.rewards = data.rewards || [];
+    }
+    toString() {
+        return this.questName;
+    }
+}
+export default Quest;

package/dist/src/structures/Static/Quests.js

@@ -0,0 +1,15 @@
+import GameQuests from './GameQuests';
+class Quests {
+    lastUpdatedTimestamp;
+    lastUpdatedAt;
+    questsPerGame;
+    constructor(data) {
+        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, data)
+        ]));
+    }
+}
+export default Quests;

package/dist/src/structures/Status.js

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

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

@@ -0,0 +1,18 @@
+import Status from './Status';
+import { expect, expectTypeOf, test } from 'vitest';
+test('Status', () => {
+    const data = new Status({ stats: 'meow' });
+    expect(data).toBeDefined();
+    expect(data).toBeInstanceOf(Status);
+    expectTypeOf(data).toEqualTypeOf();
+    expect(data.online).toBeDefined();
+    expectTypeOf(data.online).toEqualTypeOf();
+    expect(data.game).toBeDefined();
+    expectTypeOf(data.game).toEqualTypeOf();
+    expect(data.mode).toBeDefined();
+    expectTypeOf(data.mode).toEqualTypeOf();
+    expect(data.map).toBeDefined();
+    expectTypeOf(data.map).toEqualTypeOf();
+    expect(data.toString()).toBeDefined();
+    expectTypeOf(data.toString()).toEqualTypeOf();
+});

package/dist/src/structures/WatchdogStats.js

@@ -0,0 +1,15 @@
+class WatchdogStats {
+    byWatchdogTotal;
+    byWatchdogLastMinute;
+    byWatchdogRollingDay;
+    byStaffTotal;
+    byStaffRollingDay;
+    constructor(data) {
+        this.byWatchdogTotal = data?.watchdog_total || 0;
+        this.byWatchdogLastMinute = data?.watchdog_lastMinute || 0;
+        this.byWatchdogRollingDay = data?.watchdog_rollingDaily || 0;
+        this.byStaffTotal = data?.staff_total || 0;
+        this.byStaffRollingDay = data?.staff_rollingDaily || 0;
+    }
+}
+export default WatchdogStats;

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

@@ -0,0 +1,23 @@
+import WatchdogStats from './WatchdogStats';
+import { expect, expectTypeOf, test } from 'vitest';
+test('WatchdogStats', () => {
+    const data = new WatchdogStats({ stats: 'meow' });
+    expect(data).toBeDefined();
+    expect(data).toBeInstanceOf(WatchdogStats);
+    expectTypeOf(data).toEqualTypeOf();
+    expect(data.byWatchdogTotal).toBeDefined();
+    expect(data.byWatchdogTotal).greaterThanOrEqual(0);
+    expectTypeOf(data.byWatchdogTotal).toEqualTypeOf();
+    expect(data.byWatchdogLastMinute).toBeDefined();
+    expect(data.byWatchdogLastMinute).greaterThanOrEqual(0);
+    expectTypeOf(data.byWatchdogLastMinute).toEqualTypeOf();
+    expect(data.byWatchdogRollingDay).toBeDefined();
+    expect(data.byWatchdogRollingDay).greaterThanOrEqual(0);
+    expectTypeOf(data.byWatchdogRollingDay).toEqualTypeOf();
+    expect(data.byStaffTotal).toBeDefined();
+    expect(data.byStaffTotal).greaterThanOrEqual(0);
+    expectTypeOf(data.byStaffTotal).toEqualTypeOf();
+    expect(data.byStaffRollingDay).toBeDefined();
+    expect(data.byStaffRollingDay).greaterThanOrEqual(0);
+    expectTypeOf(data.byStaffRollingDay).toEqualTypeOf();
+});