hypixel-api-reborn 9.0.3 → 11.0.0

package/src/utils/SkyblockUtils.js

@@ -1,164 +1,208 @@
-/* eslint-disable camelcase */
-const constants = require('./Constants');
-module.exports = {
-  async decode (base64) {
-    const nbt = require('prismarine-nbt');
-    const parseNbt = (require('util')).promisify(nbt.parse);
-    const buffer = Buffer.from(base64, 'base64');
-    let data = await parseNbt(buffer);
-    data = nbt.simplify(data);
-    const newdata = [];
-    for (let i = 0; i < data.i.length; i++) {
-      newdata.push(data.i[i]);
-    }
-    return newdata;
-  },
-  getLevelByXp (xp, type, levelCap) {
-    let xpTable;
-    switch (type) {
-      case 'runecrafting':
-        xpTable = constants.runecrafting_xp;
-        break;
-      case 'dungeons':
-        xpTable = constants.dungeon_xp;
-        break;
-      default:
-        xpTable = constants.leveling_xp;
-    }
-    let maxLevel = Math.max(...Object.keys(xpTable));
-    if (constants.skills_cap[type] > maxLevel) {
-      xpTable = Object.assign(constants.xp_past_50, xpTable);
-      maxLevel = typeof levelCap === 'number' ?
-        maxLevel + levelCap :
-        Math.max(...Object.keys(xpTable));
-    }
-    if (isNaN(xp)) {
-      return {
-        xp: 0,
-        level: 0,
-        maxLevel,
-        xpCurrent: 0,
-        xpForNext: xpTable[1],
-        progress: 0
-      };
-    }
-    let xpTotal = 0;
-    let level = 0;
-    let xpForNext = 0;
-    for (let x = 1; x <= maxLevel; x++) {
-      xpTotal += xpTable[x];
-      if (xpTotal > xp) {
-        xpTotal -= xpTable[x];
-        break;
-      } else {
-        level = x;
-      }
-    }
-    const xpCurrent = Math.floor(xp - xpTotal);
-    if (level < maxLevel) xpForNext = Math.ceil(xpTable[level + 1]);
-    const progress = Math.floor((Math.max(0, Math.min(xpCurrent / xpForNext, 1))) * 100);
-    return {
-      xp,
-      level,
-      maxLevel,
-      xpCurrent,
-      xpForNext,
-      progress
-    };
-  },
-  getLevelByAchievement (achievementLevel, type) {
-    let xpTable = constants.leveling_xp;
-    let maxLevel = Math.max(...Object.keys(xpTable));
-    if (constants.skills_cap[type] > maxLevel && type in constants.skills_achievements) {
-      xpTable = Object.assign(constants.xp_past_50, xpTable);
-      maxLevel = Math.max(...Object.keys(xpTable));
-    }
-    if (isNaN(achievementLevel)) {
-      return {
-        xp: 0,
-        level: 0,
-        maxLevel,
-        xpCurrent: 0,
-        xpForNext: xpTable[1],
-        progress: 0
-      };
-    }
-    let xpTotal = 0;
-    let xpForNext = 0;
-    for (let x = 1; x <= achievementLevel; x++) {
-      xpTotal += xpTable[x];
-    }
-    if (achievementLevel < maxLevel) xpForNext = Math.ceil(xpTable[achievementLevel + 1]);
-    return {
-      xp: xpTotal,
-      level: achievementLevel,
-      maxLevel,
-      xpCurrent: 0,
-      xpForNext,
-      progress: 0
-    };
-  },
-  getSlayerLevel (slayer) {
-    if (!slayer) {
-      return {
-        xp: 0,
-        tier1: 0,
-        tier2: 0,
-        tier3: 0,
-        tier4: 0,
-        tier5: 0,
-        level: 0
-      };
-    }
-    const { claimed_levels } = slayer;
-    let level = 0;
-    for (const level_name in claimed_levels) {
-      if (Object.prototype.hasOwnProperty.call(claimed_levels, level_name)) {
-        const _level = parseInt(level_name.split('_').pop(), 10);
-        if (_level > level) {
-          level = _level;
-        }
-      }
-    }
-    return {
-      xp: slayer.xp || 0,
-      tier1: slayer.boss_kills_tier_0 || 0,
-      tier2: slayer.boss_kills_tier_1 || 0,
-      tier3: slayer.boss_kills_tier_2 || 0,
-      tier4: slayer.boss_kills_tier_3 || 0,
-      tier5: slayer.boss_kills_tier_4 || 0,
-      level
-    };
-  },
-  getSlayerLevelByXp (xp) {
-    const { slayer_xp } = constants;
-    const maxLevel = Math.max(...Object.keys(slayer_xp));
-    let level = 0;
-    for (let x = 1; x <= maxLevel && slayer_xp[x] <= xp; x++) {
-      level = x;
-    }
-    return level;
-  },
-  getBonusStat (level, skill, max, incremention) {
-    const skill_stats = constants.bonus_stats[skill];
-    const steps = Object.keys(skill_stats).sort((a, b) => Number(a) - Number(b)).map((a) => Number(a));
-    const bonus = Object.assign({}, constants.stat_template);
-    for (let x = steps[0]; x <= max; x += incremention) {
-      if (level < x) {
-        break;
-      }
-      const skill_step = steps.slice().reverse().find((a) => a <= x);
-      const skill_bonus = skill_stats[skill_step];
-      for (const skill in skill_bonus) {
-        if (Object.prototype.hasOwnProperty.call(skill_bonus, skill)) {
-          bonus[skill] += skill_bonus[skill];
-        }
-      }
-    }
-    return bonus;
-  },
-  getEffectiveHealth (health, defense) {
-    if (defense <= 0) return health;
-    return Math.round(health * (1 + defense / 100));
-  }
-};
+/* eslint-disable camelcase */
+const constants = require('./Constants');
+module.exports = {
+  async decode(base64, isBuffer = false) {
+    const nbt = require('prismarine-nbt');
+    const parseNbt = require('util').promisify(nbt.parse);
+    const buffer = isBuffer ? base64 : Buffer.from(base64, 'base64');
+    let data = await parseNbt(buffer);
+    data = nbt.simplify(data);
+    const newdata = [];
+    for (let i = 0; i < data.i.length; i++) {
+      newdata.push(data.i[i]);
+    }
+    return newdata;
+  },
+  getLevelByXp(xp, type, levelCap) {
+    let xpTable;
+    switch (type) {
+      case 'runecrafting':
+        xpTable = constants.runecrafting_xp;
+        break;
+      case 'dungeons':
+        xpTable = constants.dungeon_xp;
+        break;
+      case 'hotm':
+        xpTable = constants.hotm_xp;
+        break;
+      default:
+        xpTable = constants.leveling_xp;
+    }
+    let maxLevel = Math.max(...Object.keys(xpTable));
+    if ((constants.skills_cap[type] ?? maxLevel) > maxLevel) {
+      xpTable = Object.assign(constants.xp_past_50, xpTable);
+      maxLevel = typeof levelCap === 'number' ? maxLevel + levelCap : Math.max(...Object.keys(xpTable));
+    }
+    if (isNaN(xp)) {
+      return {
+        xp: 0,
+        level: 0,
+        maxLevel,
+        xpCurrent: 0,
+        xpForNext: xpTable[1],
+        progress: 0
+      };
+    }
+    let xpTotal = 0;
+    let level = 0;
+    let xpForNext = 0;
+    for (let x = 1; x <= maxLevel; x++) {
+      if (!xpTable[x]) continue;
+      xpTotal += xpTable[x];
+      if (xpTotal > xp) {
+        xpTotal -= xpTable[x];
+        break;
+      } else {
+        level = x;
+      }
+    }
+    const xpCurrent = Math.floor(xp - xpTotal);
+    if (level < maxLevel) xpForNext = Math.ceil(xpTable[level + 1]);
+    const progress = Math.floor(Math.max(0, Math.min(xpCurrent / xpForNext, 1)) * 100 * 10) / 10;
+
+    return {
+      xp,
+      level,
+      maxLevel,
+      xpCurrent,
+      xpForNext,
+      progress
+    };
+  },
+  getLevelByAchievement(achievementLevel, type) {
+    let xpTable = constants.leveling_xp;
+    let maxLevel = Math.max(...Object.keys(xpTable));
+    if (constants.skills_cap[type] > maxLevel && type in constants.skills_achievements) {
+      xpTable = Object.assign(constants.xp_past_50, xpTable);
+      maxLevel = Math.max(...Object.keys(xpTable));
+    }
+    if (isNaN(achievementLevel)) {
+      return {
+        xp: 0,
+        level: 0,
+        maxLevel,
+        xpCurrent: 0,
+        xpForNext: xpTable[1],
+        progress: 0
+      };
+    }
+    let xpTotal = 0;
+    let xpForNext = 0;
+    for (let x = 1; x <= achievementLevel; x++) {
+      xpTotal += xpTable[x];
+    }
+    if (achievementLevel < maxLevel) xpForNext = Math.ceil(xpTable[achievementLevel + 1]);
+    return {
+      xp: xpTotal,
+      level: achievementLevel,
+      maxLevel,
+      xpCurrent: 0,
+      xpForNext,
+      progress: 0
+    };
+  },
+  getSlayerLevel(slayer) {
+    if (!slayer) {
+      return {
+        xp: 0,
+        tier1: 0,
+        tier2: 0,
+        tier3: 0,
+        tier4: 0,
+        tier5: 0,
+        level: 0
+      };
+    }
+    const { claimed_levels } = slayer;
+    let level = 0;
+    for (const level_name in claimed_levels) {
+      if (Object.prototype.hasOwnProperty.call(claimed_levels, level_name)) {
+        const _level = parseInt(level_name.replace('_special', '').split('_').pop(), 10);
+        if (_level > level) {
+          level = _level;
+        }
+      }
+    }
+    return {
+      xp: slayer.xp || 0,
+      tier1: slayer.boss_kills_tier_0 || 0,
+      tier2: slayer.boss_kills_tier_1 || 0,
+      tier3: slayer.boss_kills_tier_2 || 0,
+      tier4: slayer.boss_kills_tier_3 || 0,
+      tier5: slayer.boss_kills_tier_4 || 0,
+      level
+    };
+  },
+  getSlayerLevelByXp(xp) {
+    const { slayer_xp } = constants;
+    const maxLevel = Math.max(...Object.keys(slayer_xp));
+    let level = 0;
+    for (let x = 1; x <= maxLevel && slayer_xp[x] <= xp; x++) {
+      level = x;
+    }
+    return level;
+  },
+  getBonusStat(level, skill, max, incremention) {
+    const skill_stats = constants.bonus_stats[skill];
+    const steps = Object.keys(skill_stats)
+      .sort((a, b) => Number(a) - Number(b))
+      .map((a) => Number(a));
+    const bonus = Object.assign({}, constants.stat_template);
+    for (let x = steps[0]; x <= max; x += incremention) {
+      if (level < x) {
+        break;
+      }
+      const skill_step = steps
+        .slice()
+        .reverse()
+        .find((a) => a <= x);
+      const skill_bonus = skill_stats[skill_step];
+      for (const skill in skill_bonus) {
+        if (Object.prototype.hasOwnProperty.call(skill_bonus, skill)) {
+          bonus[skill] += skill_bonus[skill];
+        }
+      }
+    }
+    return bonus;
+  },
+  getEffectiveHealth(health, defense) {
+    if (defense <= 0) return health;
+    return Math.round(health * (1 + defense / 100));
+  },
+  getMemberStats(obj) {
+    return Object.keys(obj).reduce(
+      (result, currentKey) => {
+        const key = currentKey.replace(/_[a-z]/gi, (match) => match[1].toUpperCase());
+
+        if (currentKey.startsWith('kills') || currentKey.startsWith('deaths')) {
+          const category = currentKey.startsWith('kills') ? 'kills' : 'deaths';
+          const subKey = key === category ? 'total' : key;
+
+          result[category][
+            subKey.replace(category, (sub, _, key) => {
+              return key[sub.length].toLowerCase() + key.slice(sub.length + 1);
+            })
+          ] = obj[currentKey];
+        } else {
+          result[key] = obj[currentKey];
+        }
+
+        return result;
+      },
+      { kills: {}, deaths: {} }
+    );
+  },
+  getTrophyFishRank(level) {
+    if (level === 1) {
+      return 'Bronze';
+    } else if (level === 2) {
+      return 'Silver';
+    } else if (level === 3) {
+      return 'Gold';
+    } else if (level === 4) {
+      return 'Diamond';
+    } else {
+      return 'Bronze';
+    }
+  }
+};

package/src/utils/arrayTools.js

@@ -1,4 +1,4 @@
-module.exports = {
-  isStrArray: (input) => Array.isArray(input) || typeof input === 'string',
-  strToArray: (input) => [input].flat()
-};
+module.exports = {
+  isStrArray: (input) => Array.isArray(input) || typeof input === 'string',
+  strToArray: (input) => [input].flat()
+};

package/src/utils/divide.js

@@ -1,5 +1,5 @@
-module.exports = (a=0, b=1) => {
-  const out = +((a || 0) / (b || 0)).toFixed(2) || 0;
-  if (isFinite(out)) return out;
-  return a;
-};
+module.exports = (a = 0, b = 1) => {
+  const out = +((a || 0) / (b || 0)).toFixed(2) || 0;
+  if (isFinite(out)) return out;
+  return a;
+};

package/src/utils/guildExp.js

@@ -1,67 +1,57 @@
-const dateRegExp = /(\d{4})-(\d{2})-(\d{2})/;
-/**
- * Parses exp history
- * @param {object} historyData History data from the API
- * @returns {ExpHistory[]} Array of ExpHistory
- */
-function parseHistory(historyData) {
-  return Object.entries(historyData).map((x, index) => ({
-    day: x[0],
-    date: parseDate(x[0].match(dateRegExp).slice(1).map((x) => parseInt(x, 10))) || undefined,
-    exp: x[1] || 0,
-    totalExp: Object.values(historyData).slice(0, index + 1).reduce((pV, cV) => pV + cV, 0)
-  }));
-}
-
-/**
- * Parses date
- * Because hypixel's oscillation precises that exp resets at 5 am UTC, the hour is set accordingly
- * @param {number[]} date Date from regexp
- * @returns {Date} Parsed Date
- */
-function parseDate(date) {
-  date[1] -= 1;
-  return new Date(Math.round(new Date(new Date().setUTCFullYear(...date)).setUTCHours(5, 0, 0) / 1000) * 1000);
-}
-
-/**
- * Converts guild exp to guild level ( possible rewrite )
- * @param {number} exp Experience
- * @return {number}
- */
-function getGuildLevel(exp) {
-  if (exp < 100000) {
-    return 0;
-  } else if (exp < 250000) {
-    return 1;
-  } else if (exp < 500000) {
-    return 2;
-  } else if (exp < 1000000) {
-    return 3;
-  } else if (exp < 1750000) {
-    return 4;
-  } else if (exp < 2750000) {
-    return 5;
-  } else if (exp < 4000000) {
-    return 6;
-  } else if (exp < 5500000) {
-    return 7;
-  } else if (exp < 7500000) {
-    return 8;
-  } else if (exp >= 7500000) {
-    if (exp < 15000000) {
-      return Math.floor((exp - 7500000) / 2500000) + 9;
-    } else {
-      return Math.floor((exp - 15000000) / 3000000) + 12;
-    }
-  }
-}
-
-/**
- * @typedef {object} ExpHistory
- * @property {string} day String Date ( unparsed )
- * @property {Date} date Parsed Date
- * @property {number} exp Experience of the day
- * @property {number} totalExp Experience earned from day 0 to this day
- */
-module.exports = {parseHistory, getGuildLevel};
+const dateRegExp = /(\d{4})-(\d{2})-(\d{2})/;
+// eslint-disable-next-line require-jsdoc
+function parseHistory(historyData) {
+  return Object.entries(historyData).map((x, index) => ({
+    day: x[0],
+    date:
+      parseDate(
+        x[0]
+          .match(dateRegExp)
+          .slice(1)
+          .map((x) => parseInt(x, 10))
+      ) || undefined,
+    exp: x[1] || 0,
+    totalExp: Object.values(historyData)
+      .slice(0, index + 1)
+      .reduce((pV, cV) => pV + cV, 0)
+  }));
+}
+
+// eslint-disable-next-line require-jsdoc
+function parseDate(date) {
+  date[1] -= 1;
+  return new Date(Math.round(new Date(new Date().setUTCFullYear(...date)).setUTCHours(5, 0, 0) / 1000) * 1000);
+}
+
+// eslint-disable-next-line require-jsdoc
+function getGuildLevel(exp) {
+  const EXP_NEEDED = [100000, 150000, 250000, 500000, 750000, 1000000, 1250000, 1500000, 2000000, 2500000, 2500000, 2500000, 2500000, 2500000, 3000000];
+
+  let level = 0;
+
+  for (let i = 0; i <= 1000; i += 1) {
+    let need = 0;
+    if (i >= EXP_NEEDED.length) {
+      need = EXP_NEEDED[EXP_NEEDED.length - 1];
+    } else {
+      need = EXP_NEEDED[i];
+    }
+
+    if (exp - need < 0) {
+      return Math.round((level + exp / need) * 100) / 100;
+    }
+    level += 1;
+    exp -= need;
+  }
+
+  return 1000;
+}
+
+/**
+ * @typedef {object} ExpHistory
+ * @property {string} day String Date ( unparsed )
+ * @property {Date} date Parsed Date
+ * @property {number} exp Experience of the day
+ * @property {number} totalExp Experience earned from day 0 to this day
+ */
+module.exports = { parseHistory, getGuildLevel };

package/src/utils/index.js

@@ -1,9 +1,13 @@
-/* eslint-disable no-extend-native */
-const fs = require('fs');
-// eslint-disable-next-line no-path-concat
-const curDir = __dirname + '/';
-module.exports = Array.from(fs.readdirSync(curDir, { withFileTypes: true }))
-  .filter((x) => x.name !== 'index.js')
-  .map((x) => x.isDirectory() ? Array.from(fs.readdirSync(curDir + x.name)).map((y) => ([y.split('.')[0], x.name + '/' + y])) : [[x.name.split('.')[0], x.name]])
-  .flat(1)
-  .reduce((pV, cV) => Object.assign(pV, { [cV[0]]: require(curDir + cV[1]) }), {});
+module.exports = {
+  arrayTool: require('./arrayTools'),
+  Constants: require('./Constants'),
+  divide: require('./divide'),
+  isGuildID: require('./isGuildID'),
+  isUUID: require('./isUUID'),
+  oscillation: require('./oscillation'),
+  removeSnakeCase: require('./removeSnakeCase'),
+  SkyblockUtils: require('./SkyblockUtils'),
+  toIGN: require('./toIGN'),
+  toUuid: require('./toUuid'),
+  varInt: require('./varInt')
+};

package/src/utils/isGuildID.js

@@ -1,3 +1,3 @@
-module.exports = (id) => {
-  return id.length === 24;
-};
+module.exports = (id) => {
+  return id.length === 24;
+};

package/src/utils/isUUID.js

@@ -1,5 +1,5 @@
-module.exports = (uuid) => {
-  const regexp = /^[0-9a-f]{32}$/i;
-  uuid = uuid.replace(/-/g, '');
-  return regexp.test(uuid);
-};
+module.exports = (uuid) => {
+  const regexp = /^[0-9a-f]{32}$/i;
+  uuid = uuid.replace(/-/g, '');
+  return regexp.test(uuid);
+};

package/src/utils/oscillation.js

@@ -1,23 +1,15 @@
-// See https://github.com/HypixelDev/PublicAPI/blob/db26b5fd3b7bb29da14e40e6d211143ec44a4519/Documentation/misc/Oscillation.md
-// Month oscillation started in December 2014, so every month that is pair ( odd in js!! ) is month A
-// Weekly oscillation started... just refer to the code in the docs
-/**
- * Checks if month is A or B
- * @param {number|Date} [date] Timestamp or date, defaults to now
- * @return {'a'|'b'}
- */
-function monthAB (date = Date.now()) {
-  return new Date(date).getMonth() % 2 ? 'a' : 'b';
-}
-
-const weeklyOscillationStart = 1417237200000;
-/**
- * Checks if week is A or B
- * @param {number|Date} [date] Timestamp or date, defaults to now
- * @return {'a'|'b'}
- */
-function weekAB (date = Date.now()) {
-  return (Math.abs(new Date(date).getTime() - weeklyOscillationStart) / 604800000) % 2 ? 'a' : 'b';
-}
-
-module.exports = { monthAB, weekAB };
+// See https://github.com/HypixelDev/PublicAPI/blob/db26b5fd3b7bb29da14e40e6d211143ec44a4519/Documentation/misc/Oscillation.md
+// Month oscillation started in December 2014, so every month that is pair ( odd in js!! ) is month A
+// Weekly oscillation started... just refer to the code in the docs
+// eslint-disable-next-line require-jsdoc
+function monthAB(date = Date.now()) {
+  return new Date(date).getMonth() % 2 ? 'a' : 'b';
+}
+
+const weeklyOscillationStart = 1417237200000;
+// eslint-disable-next-line require-jsdoc
+function weekAB(date = Date.now()) {
+  return (Math.abs(new Date(date).getTime() - weeklyOscillationStart) / 604800000) % 2 ? 'a' : 'b';
+}
+
+module.exports = { monthAB, weekAB };