@sjtdev/koishi-plugin-dota2tracker 2.2.3 → 2.3.1

package/lib/index.js

@@ -259,7 +259,8 @@ var require_en_US_constants = __commonJS({
             "136": "Marci",
             "137": "Primal Beast",
             "138": "Muerta",
-            "145": "Kez"
+            "145": "Kez",
+            "155": "Largo"
           },
           behavior: {
             "Unit Target": "Unit Target",
@@ -571,7 +572,8 @@ var require_zh_CN_constants = __commonJS({
             "136": "玛西",
             "137": "獸",
             "138": "琼英碧灵",
-            "145": "凯"
+            "145": "凯",
+            "155": "朗戈"
           },
           behavior: {
             "Unit Target": "单位目标",
@@ -833,7 +835,6 @@ var import_path5 = __toESM(require("path"));
 
 // src/app/common/i18n.ts
 var import_koishi = require("koishi");
-var dotaconstants = __toESM(require("dotaconstants"));
 
 // src/app/common/utils.ts
 var import_luxon = require("luxon");
@@ -925,14 +926,9 @@ var LanguageTags = {
   "zh-CN": { graphqlTag: "S_CHINESE", valveTag: "schinese" }
 };
 var I18NService = class extends import_koishi.Service {
-  static {
-    __name(this, "I18NService");
-  }
-  constantLocales = {};
-  i18n;
-  globalLanguageTag;
-  constructor(ctx) {
+  constructor(ctx, dotaconstants) {
     super(ctx, "dota2tracker.i18n", true);
+    this.dotaconstants = dotaconstants;
     this.config = ctx.config;
     this.i18n = this.ctx.i18n;
     for (const supportLanguageTag of Object.keys(LanguageTags)) {
@@ -943,6 +939,12 @@ var I18NService = class extends import_koishi.Service {
     }
     this.globalLanguageTag = this.i18n.fallback(Object.values(this.i18n.locales).map((locale) => Object.keys(locale).at(0))).find((locale) => Object.keys(LanguageTags).includes(locale));
   }
+  static {
+    __name(this, "I18NService");
+  }
+  constantLocales = {};
+  i18n;
+  globalLanguageTag;
   getGraphqlLanguageTag(languageTag) {
     return LanguageTags[languageTag].graphqlTag;
   }
@@ -1048,7 +1050,7 @@ var I18NService = class extends import_koishi.Service {
    */
   _buildNicknameMap(languageTag) {
     this.logger.debug(`Building nickname map for ${languageTag}...`);
-    const heroIds = Object.keys(dotaconstants.heroes).map(Number);
+    const heroIds = Object.keys(this.dotaconstants.heroes).map(Number);
     const nicknameMap = /* @__PURE__ */ new Map();
     for (const heroId of heroIds) {
       const allNames = this._getAllHeroNames(heroId, languageTag);
@@ -1063,7 +1065,7 @@ var I18NService = class extends import_koishi.Service {
     const inputStr = String(input).toLowerCase();
     if (/^\d+$/.test(inputStr)) {
       const heroId = Number(inputStr);
-      if (dotaconstants.heroes[heroId]) {
+      if (this.dotaconstants.heroes[heroId]) {
         return heroId;
       }
     }
@@ -1089,7 +1091,6 @@ var I18NService = class extends import_koishi.Service {
 
 // src/app/core/hero.service.ts
 var import_koishi2 = require("koishi");
-var dotaconstants2 = __toESM(require("dotaconstants"));
 var import_luxon2 = require("luxon");
 
 // src/app/common/constants.ts
@@ -1098,12 +1099,13 @@ var RANK_BRACKETS = ["UNCALIBRATED", "HERALD", "GUARDIAN", "CRUSADER", "ARCHON",
 
 // src/app/core/hero.service.ts
 var HeroService = class _HeroService extends import_koishi2.Service {
+  constructor(ctx, dotaconstants) {
+    super(ctx, "dota2tracker.hero", true);
+    this.dotaconstants = dotaconstants;
+  }
   static {
     __name(this, "HeroService");
   }
-  constructor(ctx) {
-    super(ctx, "dota2tracker.hero", true);
-  }
   async getWeeklyHeroMeta(rank) {
     const MINIMUM_PICK_RATE = 0.02;
     const RECOMMENDATION_COUNT = 3;
@@ -1138,7 +1140,7 @@ var HeroService = class _HeroService extends import_koishi2.Service {
     return weeklyHeroMeta;
   }
   async getHeroDetails(input, languageTag, isRandom = false) {
-    const heroId = this.ctx.dota2tracker.i18n.findHeroIdInLocale(isRandom ? import_koishi2.Random.pick(Object.keys(dotaconstants2.heroes)) : input);
+    const heroId = this.ctx.dota2tracker.i18n.findHeroIdInLocale(isRandom ? import_koishi2.Random.pick(Object.keys(this.dotaconstants.heroes)) : input);
     if (!heroId) return;
     return _HeroService.formatHeroDetails(await this.ctx.dota2tracker.valveAPI.queryHeroDetailsFromValve(heroId, languageTag));
   }
@@ -1298,7 +1300,7 @@ var ItemService = class _ItemService extends import_koishi3.Service {
   }
   static getFormattedItemListData(rawItems) {
     const processItemName = /* @__PURE__ */ __name((name2) => name2.replace(/^item_/i, "").replace(/^recipe_/i, "recipe_"), "processItemName");
-    const [recipes, items3] = rawItems.reduce(
+    const [recipes, items] = rawItems.reduce(
       (acc, item) => {
         const processed = {
           ...item,
@@ -1312,14 +1314,14 @@ var ItemService = class _ItemService extends import_koishi3.Service {
       [[], []]
     );
     const itemMap = /* @__PURE__ */ new Map();
-    items3.concat(recipes).forEach(
+    items.concat(recipes).forEach(
       (item) => itemMap.set(item.id, {
         id: item.id,
         name: item.name,
         name_loc: item.name_loc
       })
     );
-    const processedItems = items3.map((baseItem) => {
+    const processedItems = items.map((baseItem) => {
       const recipe = recipes.find((r) => r.name === `recipe_${baseItem.name.replace("item_", "")}`);
       return {
         ...baseItem,
@@ -1352,19 +1354,19 @@ var ItemService = class _ItemService extends import_koishi3.Service {
       }))
     }));
   }
-  searchItems(items3, keyword, languageTag, config) {
+  searchItems(items, keyword, languageTag, config) {
     if (!keyword) return [];
     const alias = this.ctx.dota2tracker.i18n.getConstantLocale(languageTag).dota2tracker.items_alias?.[keyword] ?? config.customItemAlias.filter((cia) => cia.alias == keyword).map((cia) => cia.keyword);
-    const exactMatch = items3.filter(
+    const exactMatch = items.filter(
       (item) => alias?.some((a) => item.name_loc.trim().toLowerCase() == a.toLowerCase()) || item.name_loc.trim().toLowerCase() === keyword.trim().toLowerCase() || Number.isInteger(Number(keyword)) && item.id === Number(keyword)
     );
     if (exactMatch.length) return exactMatch;
-    return this.fuzzySearchItems(alias.length ? alias : [keyword], items3);
+    return this.fuzzySearchItems(alias.length ? alias : [keyword], items);
   }
-  fuzzySearchItems(keywords, items3) {
+  fuzzySearchItems(keywords, items) {
     const resultMap = /* @__PURE__ */ new Map();
     if (!keywords.length) return [];
-    for (const item of items3) {
+    for (const item of items) {
       const cleanName = item.name_loc.toLowerCase().replace(/[^\p{L}\p{N}]/gu, "").trim();
       let matchAllKeywords = true;
       for (const keyword of keywords) {
@@ -1391,7 +1393,6 @@ var ItemService = class _ItemService extends import_koishi3.Service {
 
 // src/app/core/match.service.ts
 var import_koishi4 = require("koishi");
-var dotaconstants3 = __toESM(require("dotaconstants"));
 
 // src/app/common/error.ts
 var import_util = require("util");
@@ -1520,9 +1521,10 @@ __name(handleError, "handleError");
 
 // src/app/core/match.service.ts
 var MatchService = class _MatchService extends import_koishi4.Service {
-  constructor(ctx, pluginVersion2) {
+  constructor(ctx, pluginVersion, dotaconstants) {
     super(ctx, "dota2tracker.match", true);
-    this.pluginVersion = pluginVersion2;
+    this.pluginVersion = pluginVersion;
+    this.dotaconstants = dotaconstants;
   }
   static {
     __name(this, "MatchService");
@@ -1627,7 +1629,7 @@ var MatchService = class _MatchService extends import_koishi4.Service {
       }
       const facetData = await _MatchService.constantsInjectFacetData(constantsQuery, matchQuery, languageTag, this.ctx.dota2tracker.hero);
       this.ctx.dota2tracker.cache.setFacetConstantsCache(languageTag, constantsQuery);
-      const match = _MatchService.extendMatchData(matchQuery, facetData);
+      const match = _MatchService.extendMatchData(matchQuery, facetData, this.dotaconstants);
       return match;
     } catch (error) {
       this.ctx.dota2tracker.cache.deleteFacetConstantsCache(languageTag);
@@ -1652,7 +1654,7 @@ var MatchService = class _MatchService extends import_koishi4.Service {
     return facetData;
   }
   // 对比赛数据进行补充以供生成模板函数使用
-  static extendMatchData(matchQuery, facetData) {
+  static extendMatchData(matchQuery, facetData, dotaconstants) {
     const match = matchQuery.match;
     const matchParsed = _MatchService.isMatchParsed(matchQuery);
     ["radiant", "dire"].forEach((team) => {
@@ -1772,9 +1774,9 @@ var MatchService = class _MatchService extends import_koishi4.Service {
             }
             purchaseTimesMap[item.itemId].push(item.time);
           } else {
-            const itemName = dotaconstants3.item_ids[item.itemId];
+            const itemName = dotaconstants.item_ids[item.itemId];
             if (itemName) {
-              const itemDetails = dotaconstants3.items[itemName];
+              const itemDetails = dotaconstants.items[itemName];
               if (itemDetails && itemDetails.cost) {
                 player.utilityScore += itemDetails.cost;
               }
@@ -1787,7 +1789,7 @@ var MatchService = class _MatchService extends import_koishi4.Service {
       for (let itemId in supportItemsCount) {
         if (supportItemsCount[itemId] === 0) continue;
         player.supportItemsCount.push({
-          name: dotaconstants3.item_ids[itemId],
+          name: dotaconstants.item_ids[itemId],
           count: supportItemsCount[itemId]
         });
       }
@@ -1795,13 +1797,13 @@ var MatchService = class _MatchService extends import_koishi4.Service {
       player.items = [];
       for (let i = 0; i <= 5; i++) {
         const itemId = player[`item${i}Id`];
-        const itemObject = createItemObject(itemId, purchaseTimesMap, purchaseTimeIndices);
+        const itemObject = createItemObject(itemId, purchaseTimesMap, purchaseTimeIndices, dotaconstants);
         player.items.push(itemObject);
       }
       player.backpacks = [];
       for (let i = 0; i <= 2; i++) {
         const itemId = player[`backpack${i}Id`];
-        const itemObject = createItemObject(itemId, purchaseTimesMap, purchaseTimeIndices);
+        const itemObject = createItemObject(itemId, purchaseTimesMap, purchaseTimeIndices, dotaconstants);
         player.backpacks.push(itemObject);
       }
       if (player.additionalUnit) {
@@ -1809,12 +1811,12 @@ var MatchService = class _MatchService extends import_koishi4.Service {
         player.unitBackpacks = [];
         for (let i = 0; i <= 5; i++) {
           const itemId = player.additionalUnit[`item${i}Id`];
-          const itemObject = createItemObject(itemId, purchaseTimesMap, purchaseTimeIndices);
+          const itemObject = createItemObject(itemId, purchaseTimesMap, purchaseTimeIndices, dotaconstants);
           player.unitItems.push(itemObject);
         }
         for (let i = 0; i <= 2; i++) {
           const itemId = player.additionalUnit[`backpack${i}Id`];
-          const itemObject = createItemObject(itemId, purchaseTimesMap, purchaseTimeIndices);
+          const itemObject = createItemObject(itemId, purchaseTimesMap, purchaseTimeIndices, dotaconstants);
           player.unitBackpacks.push(itemObject);
         }
       }
@@ -1893,15 +1895,15 @@ var MatchService = class _MatchService extends import_koishi4.Service {
     return matchQuery?.match?.parsedDateTime && matchQuery?.match?.players.filter((player) => player?.stats?.heroDamageReport?.dealtTotal).length > 0;
   }
 };
-function createItemObject(itemId, purchaseTimesMap, purchaseTimeIndices) {
+function createItemObject(itemId, purchaseTimesMap, purchaseTimeIndices, dotaconstants) {
   if (itemId === void 0 || itemId === null) {
     return null;
   }
-  if (dotaconstants3.item_ids[itemId]) {
+  if (dotaconstants.item_ids[itemId]) {
     const currentIndex = purchaseTimeIndices.get(itemId) || 0;
     const seconds = purchaseTimesMap[itemId]?.[currentIndex];
     purchaseTimeIndices.set(itemId, currentIndex + 1);
-    const name2 = dotaconstants3.item_ids[itemId];
+    const name2 = dotaconstants.item_ids[itemId];
     const prefix = "recipe_";
     const isRecipe = name2.startsWith(prefix);
     const cleanName = isRecipe ? name2.substring(prefix.length) : name2;
@@ -1919,16 +1921,16 @@ __name(createItemObject, "createItemObject");
 
 // src/app/core/player.service.ts
 var import_koishi5 = require("koishi");
-var dotaconstants4 = __toESM(require("dotaconstants"));
 var import_luxon3 = require("luxon");
 var PlayerService = class _PlayerService extends import_koishi5.Service {
-  static {
-    __name(this, "PlayerService");
-  }
-  constructor(ctx) {
+  constructor(ctx, dotaconstants) {
     super(ctx, "dota2tracker.player", true);
+    this.dotaconstants = dotaconstants;
     this.config = ctx.config;
   }
+  static {
+    __name(this, "PlayerService");
+  }
   async getHeroRecommendation(steamId, player) {
     const RECENT_IMP_WEIGHT = 0.1;
     const LIFETIME_WIN_LOG_WEIGHT = 5;
@@ -2027,12 +2029,12 @@ var PlayerService = class _PlayerService extends import_koishi5.Service {
       const lastMatchQuery = await this.ctx.dota2tracker.stratzAPI.queryPlayersLastMatchRankInfo({
         steamAccountIds: [steamId]
       });
-      if (lastMatchQuery.players[0].steamAccount.isAnonymous) return { matchId: 0, isAnonymous: true };
+      if (lastMatchQuery.players[0].steamAccount.isAnonymous) return { id: 0, isAnonymous: true };
       lastMatchId = lastMatchQuery.players[0].matches[0]?.id;
     } catch (error) {
       this.logger.error(error);
     }
-    return { matchId: lastMatchId };
+    return { id: lastMatchId };
   }
   async getFormattedPlayerData(steamId, heroId, languageTag) {
     const playerQuery = await this.ctx.dota2tracker.stratzAPI.queryPlayerInfoWith25Matches({
@@ -2049,12 +2051,15 @@ var PlayerService = class _PlayerService extends import_koishi5.Service {
         dotaPlus: null
       }
     };
-    const player = _PlayerService.extendPlayerData({
-      playerQuery,
-      playerExtraQuery,
-      genHero: heroId ? { heroId, name: this.ctx.dota2tracker.i18n.getConstantLocale(languageTag).dota2tracker.template.hero_names[heroId] } : null,
-      estimateRank: this.config.playerRankEstimate
-    });
+    const player = _PlayerService.extendPlayerData(
+      {
+        playerQuery,
+        playerExtraQuery,
+        genHero: heroId ? { heroId, name: this.ctx.dota2tracker.i18n.getConstantLocale(languageTag).dota2tracker.template.hero_names[heroId] } : null,
+        estimateRank: this.config.playerRankEstimate
+      },
+      this.dotaconstants
+    );
     return player;
   }
   async validateSteamId(steamId) {
@@ -2076,14 +2081,14 @@ var PlayerService = class _PlayerService extends import_koishi5.Service {
       };
     }
   }
-  static extendPlayerData(param) {
+  static extendPlayerData(param, dotaconstants) {
     const { playerQuery, playerExtraQuery, genHero, estimateRank } = param;
     const player = playerQuery.player;
     const playerExtra = playerExtraQuery?.player;
     if (player.steamAccount.isAnonymous) {
       for (let index = 0; index < 25; index++) {
         const random = new import_koishi5.Random(() => enhancedSimpleHashToSeed(`${player.steamAccount.id}-${index}`));
-        const heroId = random.pick(Object.keys(dotaconstants4.heroes));
+        const heroId = random.pick(Object.keys(dotaconstants.heroes));
         player.matches.push({
           id: 1e9 + index,
           gameMode: "UNKNOWN",
@@ -2100,7 +2105,7 @@ var PlayerService = class _PlayerService extends import_koishi5.Service {
               kills: random.int(0, 20),
               deaths: random.int(0, 20),
               assists: random.int(0, 20),
-              hero: { id: heroId, shortName: dotaconstants4.heroes[heroId].name.match(/^npc_dota_hero_(.+)$/)[1] }
+              hero: { id: heroId, shortName: dotaconstants.heroes[heroId].name.match(/^npc_dota_hero_(.+)$/)[1] }
             }
           ]
         });
@@ -2258,8 +2263,8 @@ var CacheService = class extends import_koishi6.Service {
   async getMatchCache(matchId) {
     return this.ctx.cache.get("dt_previous_query_results", String(matchId));
   }
-  setMatchCache(matchId, matchQuery, pluginVersion2) {
-    this.ctx.cache.set("dt_previous_query_results", String(matchQuery.match.id), { data: matchQuery, pluginVersion: pluginVersion2 }, DAYS_30);
+  setMatchCache(matchId, matchQuery, pluginVersion) {
+    this.ctx.cache.set("dt_previous_query_results", String(matchQuery.match.id), { data: matchQuery, pluginVersion }, DAYS_30);
   }
   markMatchAsSended(matchId) {
     this.ctx.cache.set("dt_sended_match_id", String(matchId), void 0, DAYS_30);
@@ -2388,14 +2393,6 @@ var import_path = __toESM(require("path"));
 var import_axios2 = __toESM(require("axios"));
 var import_https_proxy_agent = require("https-proxy-agent");
 var StratzAPI = class extends import_koishi8.Service {
-  constructor(ctx, pluginDir3) {
-    super(ctx, "dota2tracker.stratz-api", true);
-    this.pluginDir = pluginDir3;
-    this.config = ctx.config;
-    this.queue = new MiniQueue(ctx, { interval: 200 });
-    this.http = import_axios2.default.create({ timeout: 1e4, signal: this.abortController.signal });
-    ctx.on("dispose", () => this.dispose());
-  }
   static {
     __name(this, "StratzAPI");
   }
@@ -2403,12 +2400,21 @@ var StratzAPI = class extends import_koishi8.Service {
   queue;
   http;
   abortController = new AbortController();
+  graphqlQueriesDir;
+  constructor(ctx, currentDir) {
+    super(ctx, "dota2tracker.stratz-api", true);
+    this.config = ctx.config;
+    this.graphqlQueriesDir = import_path.default.join(currentDir, "queries");
+    this.queue = new MiniQueue(ctx, { interval: 200 });
+    this.http = import_axios2.default.create({ timeout: 15e3, signal: this.abortController.signal });
+    ctx.on("dispose", () => this.dispose());
+  }
   dispose() {
     this.queue.dispose();
     this.abortController.abort();
   }
   async queryGetWeeklyMetaByPosition({ bracketIds }) {
-    return this.query("GetWeeklyMetaByPosition", { bracketIds }, (data) => !!data.heroStats);
+    return this.query("GetWeeklyMetaByPosition", { bracketIds }, (data) => !!data?.heroStats);
   }
   async queryPlayerPerformanceForHeroRecommendation({ steamAccountId, recentDateTime }) {
     return this.query(
@@ -2417,7 +2423,7 @@ var StratzAPI = class extends import_koishi8.Service {
         steamAccountId,
         recentDateTime
       },
-      (data) => !!data.player
+      (data) => !!data?.player
     );
   }
   async queryPlayersMatchesForDaily(steamAccountIds, seconds) {
@@ -2427,11 +2433,11 @@ var StratzAPI = class extends import_koishi8.Service {
         steamAccountIds,
         seconds
       },
-      (data) => !!data.players
+      (data) => !!data?.players
     );
   }
   async queryVerifyingPlayer(steamAccountId) {
-    return this.query("VerifyingPlayer", { steamAccountId }, (data) => !!data.player);
+    return this.query("VerifyingPlayer", { steamAccountId }, (data) => !!data?.player);
   }
   async queryPlayerExtraInfo({ steamAccountId, matchCount, heroIds }) {
     return this.query(
@@ -2441,11 +2447,11 @@ var StratzAPI = class extends import_koishi8.Service {
         matchCount,
         heroIds
       },
-      (data) => !!data.player
+      (data) => !!data?.player
     );
   }
   async queryPlayersInfoWith10MatchesForGuild({ steamAccountIds }) {
-    return this.query("PlayersInfoWith10MatchesForGuild", { steamAccountIds }, (data) => !!data.players);
+    return this.query("PlayersInfoWith10MatchesForGuild", { steamAccountIds }, (data) => !!data?.players);
   }
   async queryPlayerInfoWith25Matches({ steamAccountId, heroIds }) {
     return this.query(
@@ -2454,17 +2460,17 @@ var StratzAPI = class extends import_koishi8.Service {
         steamAccountId,
         heroIds
       },
-      (data) => !!data.player
+      (data) => !!data?.player
     );
   }
   async queryPlayersLastMatchRankInfo({ steamAccountIds }) {
-    return this.query("PlayersLastmatchRankinfo", { steamAccountIds }, (data) => !!data.players);
+    return this.query("PlayersLastmatchRankinfo", { steamAccountIds }, (data) => !!data?.players);
   }
   async queryConstants(languageTag) {
-    return this.query("Constants", { language: this.ctx.dota2tracker.i18n.getGraphqlLanguageTag(languageTag) }, (data) => !!data.constants);
+    return this.query("Constants", { language: this.ctx.dota2tracker.i18n.getGraphqlLanguageTag(languageTag) }, (data) => !!data?.constants);
   }
   async queryMatchInfo(matchId) {
-    return this.query("MatchInfo", { matchId }, (data) => !!data.match);
+    return this.query("MatchInfo", { matchId }, (data) => !!data?.match);
   }
   async requestParseMatch(matchId) {
     const response = await this.query("RequestMatchDataAnalysis", {
@@ -2525,7 +2531,7 @@ var StratzAPI = class extends import_koishi8.Service {
     });
   }
   loadGraphqlFile(queryName) {
-    return import_fs.default.readFileSync(import_path.default.join(this.pluginDir, "queries", `${queryName}.graphql`), { encoding: "utf-8" }).replace(/[\r\n]+/g, " ");
+    return import_fs.default.readFileSync(import_path.default.join(this.graphqlQueriesDir, `${queryName}.graphql`), { encoding: "utf-8" }).replace(/[\r\n]+/g, " ");
   }
 };
 var MiniQueue = class {
@@ -2592,7 +2598,7 @@ var ValveAPI = class extends import_koishi9.Service {
   constructor(ctx) {
     super(ctx, "dota2tracker.valve-api", true);
     this.config = ctx.config;
-    this.http = import_axios3.default.create({ timeout: 1e4, signal: this.abortController.signal, baseURL: this.baseURL });
+    this.http = import_axios3.default.create({ timeout: 15e3, signal: this.abortController.signal, baseURL: this.baseURL });
     ctx.on("dispose", () => this.dispose());
   }
   dispose() {
@@ -2643,7 +2649,6 @@ var import_koishi10 = require("koishi");
 var import_ejs = __toESM(require("ejs"));
 var import_fs2 = __toESM(require("fs"));
 var import_path2 = __toESM(require("path"));
-var dotaconstants5 = __toESM(require("dotaconstants"));
 
 // src/app/common/types.ts
 var ImageType = /* @__PURE__ */ ((ImageType2) => {
@@ -2666,14 +2671,16 @@ var ImageFormat = /* @__PURE__ */ ((ImageFormat2) => {
 // src/app/presentation/image.renderer.ts
 var import_luxon5 = require("luxon");
 var ImageRenderer = class extends import_koishi10.Service {
-  constructor(ctx, pluginDir3) {
+  constructor(ctx, currentDir, dotaconstants) {
     super(ctx, "dota2tracker.image", true);
-    this.pluginDir = pluginDir3;
+    this.dotaconstants = dotaconstants;
     this.config = ctx.config;
+    this.templateDir = import_path2.default.join(currentDir, "templates");
   }
   static {
     __name(this, "ImageRenderer");
   }
+  templateDir;
   async renderToImageByFile(data, templateName, type, languageTag) {
     const html = await this.generateHTML(data, { source: "FILE", templateName, type }, languageTag);
     return this.ctx.puppeteer.render(html);
@@ -2690,7 +2697,7 @@ var ImageRenderer = class extends import_koishi10.Service {
       data,
       ImageType,
       ImageFormat,
-      dotaconstants: dotaconstants5,
+      dotaconstants: this.dotaconstants,
       DateTime: import_luxon5.DateTime,
       $t: /* @__PURE__ */ __name((key, params) => this.ctx.dota2tracker.i18n.$t(languageTag, key, params), "$t"),
       languageTag,
@@ -2701,7 +2708,7 @@ var ImageRenderer = class extends import_koishi10.Service {
     try {
       let html;
       if (template.source === "FILE") {
-        const templatePath = import_path2.default.join(this.pluginDir, "template", template.type, `${template.templateName}.ejs`);
+        const templatePath = import_path2.default.join(this.templateDir, template.type, `${template.templateName}.ejs`);
         html = await import_ejs.default.renderFile(templatePath, templateData, {
           strict: false
         });
@@ -2711,7 +2718,7 @@ var ImageRenderer = class extends import_koishi10.Service {
           async: true
         });
       }
-      if (process.env.NODE_ENV === "development") import_fs2.default.writeFileSync(import_path2.default.join(this.pluginDir, "temp.html"), html);
+      if (process.env.NODE_ENV === "development") import_fs2.default.writeFileSync(import_path2.default.resolve(process.cwd(), "temp.html"), html);
       return html;
     } catch (error) {
       this.logger.error(error);
@@ -2721,8 +2728,8 @@ var ImageRenderer = class extends import_koishi10.Service {
   getImageUrl(image, type = "local" /* Local */, format = "png" /* png */) {
     if (type === "local" /* Local */) {
       try {
-        if (format === "svg" /* svg */) return import_fs2.default.readFileSync(import_path2.default.join(this.pluginDir, "template", "images", `${image}.svg`));
-        const imageData = import_fs2.default.readFileSync(import_path2.default.join(this.pluginDir, "template", "images", `${image}.${format}`));
+        if (format === "svg" /* svg */) return import_fs2.default.readFileSync(import_path2.default.join(this.templateDir, "images", `${image}.svg`));
+        const imageData = import_fs2.default.readFileSync(import_path2.default.join(this.templateDir, "images", `${image}.${format}`));
         const base64Data = imageData.toString("base64");
         return `data:image/png;base64,${base64Data}`;
       } catch (error) {
@@ -3456,20 +3463,25 @@ __name(resolvePlayerAndHandleErrors, "resolvePlayerAndHandleErrors");
 // src/app/commands/hero-of-the-day.command.ts
 var import_luxon10 = require("luxon");
 function registerHeroOfTheDayCommand(ctx) {
-  ctx.command("dota2tracker.hero-of-the-day <input_data>").alias("今日英雄").option("days", "-d <value:number>").action(async ({ session, options }, input_data) => {
-    const steamId = await resolvePlayerAndHandleErrors(ctx, session, input_data);
-    if (steamId === null) return;
-    const days = clamp(options.days, 1, 180, 30);
-    const result = await ctx.dota2tracker.stratzAPI.queryPlayerPerformanceForHeroRecommendation({
-      steamAccountId: steamId,
-      recentDateTime: import_luxon10.DateTime.now().minus({ days }).toUnixInteger()
-    });
-    const recommendationPromise = ctx.dota2tracker.player.getHeroRecommendation(steamId, result.player);
-    const metaPromise = ctx.dota2tracker.hero.getWeeklyHeroMeta(PlayerService.estimateWeightedRank(result.player));
-    const [recommendation, weeklyHeroMeta] = await Promise.all([recommendationPromise, metaPromise]);
-    const languageTag = await ctx.dota2tracker.i18n.getLanguageTag({ session });
-    const message = ctx.dota2tracker.messageBuilder.buildHeroOfTheDayMessage(languageTag, recommendation, weeklyHeroMeta);
-    return message;
+  const name2 = "hero-of-the-day";
+  ctx.command(`dota2tracker.${name2} <input_data>`).alias("今日英雄").option("days", "-d <value:number>").action(async ({ session, options }, input_data) => {
+    try {
+      const steamId = await resolvePlayerAndHandleErrors(ctx, session, input_data);
+      if (steamId === null) return;
+      const days = clamp(options.days, 1, 180, 30);
+      const result = await ctx.dota2tracker.stratzAPI.queryPlayerPerformanceForHeroRecommendation({
+        steamAccountId: steamId,
+        recentDateTime: import_luxon10.DateTime.now().minus({ days }).toUnixInteger()
+      });
+      const recommendationPromise = ctx.dota2tracker.player.getHeroRecommendation(steamId, result.player);
+      const metaPromise = ctx.dota2tracker.hero.getWeeklyHeroMeta(PlayerService.estimateWeightedRank(result.player));
+      const [recommendation, weeklyHeroMeta] = await Promise.all([recommendationPromise, metaPromise]);
+      const languageTag = await ctx.dota2tracker.i18n.getLanguageTag({ session });
+      const message = ctx.dota2tracker.messageBuilder.buildHeroOfTheDayMessage(languageTag, recommendation, weeklyHeroMeta);
+      return message;
+    } catch (error) {
+      handleError(error, ctx.logger(name2), ctx.dota2tracker.i18n, ctx.config);
+    }
   });
 }
 __name(registerHeroOfTheDayCommand, "registerHeroOfTheDayCommand");
@@ -3477,14 +3489,19 @@ __name(registerHeroOfTheDayCommand, "registerHeroOfTheDayCommand");
 // src/app/commands/query-hero.command.ts
 function registerQueryHeroCommand(ctx) {
   ctx.command("dota2tracker.query-hero <input_data>").option("random", "-r").alias("查询英雄").action(async ({ session, options }, input_data) => {
-    if (input_data) {
-      await session.send(session.text(".querying_hero"));
-      const languageTag = await ctx.dota2tracker.i18n.getLanguageTag({ session });
-      const heroData = await ctx.dota2tracker.hero.getHeroDetails(input_data, languageTag, options.random);
-      if (!heroData) return session.text(".not_found");
-      const image = await ctx.dota2tracker.image.renderToImageByFile(heroData, ctx.config.template_hero, "hero" /* Hero */, languageTag);
-      const message = ctx.dota2tracker.messageBuilder.buildHeroMessage(heroData);
-      await session.send(message + image);
+    const name2 = "query-hero";
+    try {
+      if (input_data || options.random) {
+        await session.send(session.text(".querying_hero"));
+        const languageTag = await ctx.dota2tracker.i18n.getLanguageTag({ session });
+        const heroData = await ctx.dota2tracker.hero.getHeroDetails(input_data, languageTag, options.random);
+        if (!heroData) return session.text(".not_found");
+        const image = await ctx.dota2tracker.image.renderToImageByFile(heroData, ctx.config.template_hero, "hero" /* Hero */, languageTag);
+        const message = ctx.dota2tracker.messageBuilder.buildHeroMessage(heroData);
+        await session.send(message + image);
+      }
+    } catch (error) {
+      handleError(error, ctx.logger(name2), ctx.dota2tracker.i18n, ctx.config);
     }
   });
 }
@@ -3540,25 +3557,40 @@ __name(registerQueryItemCommand, "registerQueryItemCommand");
 // src/app/commands/query-match.command.ts
 function registerQueryMatchCommand(ctx) {
   ctx.command("dota2tracker.query-match <match_id>").alias("查询比赛").option("parse", "-p").option("template", "-t <value:string>").action(async ({ session, options }, match_id) => {
-    if (!match_id) return session.text(".empty_input");
-    if (!/^\d{1,11}$/.test(match_id)) return session.text(".match_id_invalid");
-    await session.send(session.text(".querying_match"));
-    return await handleQueryMatchCommand(ctx, ctx.config, session, options, match_id);
+    const name2 = "query-match";
+    try {
+      if (!match_id) return session.text(".empty_input");
+      if (!/^\d{1,11}$/.test(match_id)) return session.text(".match_id_invalid");
+      await session.send(session.text(".querying_match"));
+      return await handleQueryMatchCommand(ctx, ctx.config, session, options, match_id);
+    } catch (error) {
+      handleError(error, ctx.logger(name2), ctx.dota2tracker.i18n, ctx.config);
+    }
   });
   ctx.command("dota2tracker.query-recent-match [input_data]").alias("查询最近比赛").option("parse", "-p").option("template", "-t <value:string>").action(async ({ session, options }, input_data) => {
-    const steamId = await resolvePlayerAndHandleErrors(ctx, session, input_data);
-    if (steamId === null) return;
-    session.send(session.text(".querying_match"));
-    const lastMatchId = await ctx.dota2tracker.player.getLastMatchId(Number(steamId));
-    if (!lastMatchId?.matchId) return session.text(".query_failed");
-    if (lastMatchId.isAnonymous) return session.text(".is_anonymous");
-    return await handleQueryMatchCommand(ctx, ctx.config, session, options, lastMatchId.matchId);
+    const name2 = "query-recent-match";
+    try {
+      const steamId = await resolvePlayerAndHandleErrors(ctx, session, input_data);
+      if (steamId === null) return;
+      session.send(session.text(".querying_match"));
+      let lastMatch;
+      try {
+        lastMatch = await ctx.dota2tracker.player.getLastMatchId(Number(steamId));
+      } catch (error) {
+        handleError(error, ctx.logger(name2), ctx.dota2tracker.i18n, ctx.config);
+      }
+      if (!lastMatch?.id) return session.text(".query_failed");
+      if (lastMatch.isAnonymous) return session.text(".is_anonymous");
+      return await handleQueryMatchCommand(ctx, ctx.config, session, options, lastMatch.id);
+    } catch (error) {
+      handleError(error, ctx.logger(name2), ctx.dota2tracker.i18n, ctx.config);
+    }
   });
 }
 __name(registerQueryMatchCommand, "registerQueryMatchCommand");
 async function handleQueryMatchCommand(ctx, config, session, options, matchId) {
   const languageTag = await ctx.dota2tracker.i18n.getLanguageTag({ session });
-  const result = await ctx.dota2tracker.match.getMatchResult({ matchId: Number(matchId), requestParse: options.parse });
+  const result = await ctx.dota2tracker.match.getMatchResult({ matchId: Number(matchId), waitForParse: options.parse, allowFallback: config.enableOpenDotaFallback });
   if (result.status === "PENDING") {
     const subscriber = ctx.dota2tracker.parsePolling.createSubscriberByCommand(session, languageTag, { templateName: options?.template });
     ctx.dota2tracker.parsePolling.add(result.matchId, [subscriber]);
@@ -3569,7 +3601,6 @@ async function handleQueryMatchCommand(ctx, config, session, options, matchId) {
     const formattedMatchData = await ctx.dota2tracker.match.generateMatchData(result.matchData, languageTag);
     const message = ctx.dota2tracker.messageBuilder.buildMatchMessage(languageTag, formattedMatchData, []);
     const image = await ctx.dota2tracker.image.renderToImageByFile(formattedMatchData, options.template || config.template_match, "match" /* Match */, languageTag);
-    await ctx.dota2tracker.image.renderToImageByFile(formattedMatchData, options.template || config.template_match, "match" /* Match */, languageTag);
     return message + image;
   }
 }
@@ -3590,18 +3621,23 @@ __name(registerQueryMembersCommand, "registerQueryMembersCommand");
 // src/app/commands/query-player.command.ts
 function registerQueryPlayerCommand(ctx) {
   ctx.command("dota2tracker.query-player <input_data>").option("hero", "-o <value:string>").alias("查询玩家").action(async ({ session, options }, input_data) => {
-    if (session.guild || !session.guild && input_data) {
-      const steamId = await resolvePlayerAndHandleErrors(ctx, session, input_data);
-      if (steamId === null) return;
-      session.send(session.text(".querying_player"));
-      const heroId = ctx.dota2tracker.i18n.findHeroIdInLocale(options.hero);
-      const languageTag = await ctx.dota2tracker.i18n.getLanguageTag({ session });
-      const formattedPlayerData = await ctx.dota2tracker.player.getFormattedPlayerData(steamId, heroId, languageTag);
-      const image = await ctx.dota2tracker.image.renderToImageByFile(formattedPlayerData, ctx.config.template_player, "player" /* Player */, languageTag);
-      const message = ctx.dota2tracker.messageBuilder.buildPlayerMessage(steamId);
-      return message + image;
-    } else {
-      return session.text("commands.dota2tracker.common.messages.user_not_in_group");
+    const name2 = "query-player";
+    try {
+      if (session.guild || !session.guild && input_data) {
+        const steamId = await resolvePlayerAndHandleErrors(ctx, session, input_data);
+        if (steamId === null) return;
+        session.send(session.text(".querying_player"));
+        const heroId = ctx.dota2tracker.i18n.findHeroIdInLocale(options.hero);
+        const languageTag = await ctx.dota2tracker.i18n.getLanguageTag({ session });
+        const formattedPlayerData = await ctx.dota2tracker.player.getFormattedPlayerData(steamId, heroId, languageTag);
+        const image = await ctx.dota2tracker.image.renderToImageByFile(formattedPlayerData, ctx.config.template_player, "player" /* Player */, languageTag);
+        const message = ctx.dota2tracker.messageBuilder.buildPlayerMessage(steamId);
+        return message + image;
+      } else {
+        return session.text("commands.dota2tracker.common.messages.user_not_in_group");
+      }
+    } catch (error) {
+      handleError(error, ctx.logger(name2), ctx.dota2tracker.i18n, ctx.config);
     }
   });
 }
@@ -3686,7 +3722,7 @@ var OpenDotaAPI = class extends import_koishi15.Service {
   constructor(ctx) {
     super(ctx, "dota2tracker.opendota-api", true);
     this.config = ctx.config;
-    this.http = import_axios4.default.create({ timeout: 1e4, signal: this.abortController.signal, baseURL: this.BASE_URL });
+    this.http = import_axios4.default.create({ timeout: 15e3, signal: this.abortController.signal, baseURL: this.BASE_URL });
     ctx.on("dispose", () => this.dispose());
   }
   dispose() {
@@ -3736,14 +3772,14 @@ var OpenDotaAPI = class extends import_koishi15.Service {
 
 // src/app/core/opendota.adapter.ts
 var import_koishi16 = require("koishi");
-var dotaconstants6 = __toESM(require("dotaconstants"));
 var OpenDotaAdapter = class extends import_koishi16.Service {
+  constructor(ctx, dotaconstants) {
+    super(ctx, "dota2tracker.opendota-adapter", true);
+    this.dotaconstants = dotaconstants;
+  }
   static {
     __name(this, "OpenDotaAdapter");
   }
-  constructor(ctx) {
-    super(ctx, "dota2tracker.opendota-adapter", true);
-  }
   transform(_match) {
     determinePlayerPositions(_match);
     const players = [];
@@ -3791,9 +3827,9 @@ var OpenDotaAdapter = class extends import_koishi16.Service {
         steamAccount: { name: _player.personaname, seasonRank: _player.rank_tier, seasonLeaderboardRank: null },
         hero: {
           id: _player.hero_id,
-          name: dotaconstants6.heroes[_player.hero_id].name,
-          shortName: dotaconstants6.heroes[_player.hero_id].name.match(/^npc_dota_hero_(.+)$/)[1],
-          facets: [...dotaconstants6.hero_abilities[dotaconstants6.heroes[_player.hero_id].name].facets.map((f) => ({ id: -1, name: f.name }))]
+          name: this.dotaconstants.heroes[_player.hero_id].name,
+          shortName: this.dotaconstants.heroes[_player.hero_id].name.match(/^npc_dota_hero_(.+)$/)[1],
+          facets: [...this.dotaconstants.hero_abilities[this.dotaconstants.heroes[_player.hero_id].name].facets.map((f) => ({ id: -1, name: f.name }))]
         },
         dotaPlus: null,
         stats: {
@@ -3824,7 +3860,7 @@ var OpenDotaAdapter = class extends import_koishi16.Service {
               disableCount: 0
             }
           },
-          itemPurchases: _player.purchase_log.map((p) => ({ time: p.time, itemId: dotaconstants6.items[p.key].id }))
+          itemPurchases: _player.purchase_log.map((p) => ({ time: p.time, itemId: this.dotaconstants.items[p.key].id }))
         },
         additionalUnit: null
       };
@@ -3853,8 +3889,8 @@ var OpenDotaAdapter = class extends import_koishi16.Service {
     const match = {
       id: _match.match_id,
       didRadiantWin: _match.radiant_win,
-      lobbyType: convertLobbyType(_match.lobby_type),
-      gameMode: convertGameMode(_match.game_mode),
+      lobbyType: convertLobbyType(_match.lobby_type, this.dotaconstants),
+      gameMode: convertGameMode(_match.game_mode, this.dotaconstants),
       regionId: _match.region,
       parsedDateTime: _match.start_time + _match.duration,
       startDateTime: _match.start_time,
@@ -3939,7 +3975,7 @@ function convertPosition(openDotaPosition) {
   }
 }
 __name(convertPosition, "convertPosition");
-function convertLobbyType(openDotaLobbyType) {
+function convertLobbyType(openDotaLobbyType, dotaconstants) {
   const map = {
     lobby_type_normal: "UNRANKED" /* Unranked */,
     lobby_type_practice: "PRACTICE" /* Practice */,
@@ -3956,11 +3992,11 @@ function convertLobbyType(openDotaLobbyType) {
     lobby_type_new_player: "COOP_VS_BOTS" /* CoopVsBots */,
     lobby_type_featured: "EVENT" /* Event */
   };
-  return map[dotaconstants6.lobby_type[openDotaLobbyType].name] || "EVENT" /* Event */;
+  return map[dotaconstants.lobby_type[openDotaLobbyType].name] || "EVENT" /* Event */;
 }
 __name(convertLobbyType, "convertLobbyType");
-function convertGameMode(openDotaGameModeId) {
-  const gameModeName = dotaconstants6.game_mode[openDotaGameModeId]?.name;
+function convertGameMode(openDotaGameModeId, dotaconstants) {
+  const gameModeName = dotaconstants.game_mode[openDotaGameModeId]?.name;
   switch (gameModeName) {
     case "game_mode_all_pick":
       return "ALL_PICK" /* AllPick */;
@@ -4178,7 +4214,7 @@ var globRequire_locales_schema_yml = __glob({
 });
 
 // src/config.ts
-var pluginDir = import_path4.default.resolve(__dirname, "..");
+var templateDir = import_path4.default.join(__dirname, "templates");
 var allI18nConfigs = Object.fromEntries(Object.keys(LanguageTags).map((lang) => [lang, globRequire_locales_schema_yml(`./locales/${lang}.schema.yml`)._config]));
 var Config = import_koishi17.Schema.intersect([
   import_koishi17.Schema.intersect([
@@ -4249,9 +4285,9 @@ var Config = import_koishi17.Schema.intersect([
     ]).i18n(getI18n("report"))
   ]),
   import_koishi17.Schema.object({
-    template_match: import_koishi17.Schema.union([...readDirectoryFilesSync(import_path4.default.join(pluginDir, "template", "match"))]).default("match_1"),
-    template_player: import_koishi17.Schema.union([...readDirectoryFilesSync(import_path4.default.join(pluginDir, "template", "player"))]).default("player_1"),
-    template_hero: import_koishi17.Schema.union([...readDirectoryFilesSync(import_path4.default.join(pluginDir, "template", "hero"))]).default("hero_1"),
+    template_match: import_koishi17.Schema.union([...readDirectoryFilesSync(import_path4.default.join(templateDir, "match"))]).default("match_1"),
+    template_player: import_koishi17.Schema.union([...readDirectoryFilesSync(import_path4.default.join(templateDir, "player"))]).default("player_1"),
+    template_hero: import_koishi17.Schema.union([...readDirectoryFilesSync(import_path4.default.join(templateDir, "hero"))]).default("hero_1"),
     playerRankEstimate: import_koishi17.Schema.boolean().default(true),
     templateFonts: import_koishi17.Schema.array(String).default([]).role("table")
   }).i18n(getI18n("template"))
@@ -4285,16 +4321,18 @@ var inject = {
   required: ["database", "puppeteer", "cache"],
   optional: ["cron", "console"]
 };
-var pluginDir2 = import_path5.default.resolve(__dirname, "..");
-var pluginVersion = require(import_path5.default.join(pluginDir2, "package.json")).version;
 async function apply(ctx, config) {
+  const lib = await import("dotaconstants");
+  const dotaconstants = lib.default || lib;
   const logger = ctx.logger("dota2tracker");
+  const currentDir = import_path5.default.resolve(__dirname);
+  const pluginVersion = require(import_path5.default.join(currentDir, "..", "package.json")).version;
   ctx.dota2tracker = {};
-  ctx.dota2tracker.i18n = new I18NService(ctx);
-  ctx.dota2tracker.image = new ImageRenderer(ctx, pluginDir2);
+  ctx.dota2tracker.i18n = new I18NService(ctx, dotaconstants);
+  ctx.dota2tracker.image = new ImageRenderer(ctx, currentDir, dotaconstants);
   ctx.dota2tracker.messageBuilder = new MessageBuilder(ctx);
-  ctx.dota2tracker.match = new MatchService(ctx, pluginVersion);
-  ctx.dota2tracker.player = new PlayerService(ctx);
+  ctx.dota2tracker.match = new MatchService(ctx, pluginVersion, dotaconstants);
+  ctx.dota2tracker.player = new PlayerService(ctx, dotaconstants);
   if (ctx.cron) {
     ctx.dota2tracker.matchWatcher = new MatchWatcherTask(ctx);
     ctx.dota2tracker.parsePolling = new ParsePollingTask(ctx);
@@ -4306,15 +4344,15 @@ async function apply(ctx, config) {
   } else {
     logger.info(ctx.dota2tracker.i18n.gt("dota2tracker.logger.cron_not_enabled"));
   }
-  ctx.dota2tracker.hero = new HeroService(ctx);
+  ctx.dota2tracker.hero = new HeroService(ctx, dotaconstants);
   ctx.dota2tracker.item = new ItemService(ctx);
   ctx.dota2tracker.cache = new CacheService(ctx);
   ctx.dota2tracker.database = new DatabaseService(ctx);
   ctx.dota2tracker.valveAPI = new ValveAPI(ctx);
-  ctx.dota2tracker.stratzAPI = new StratzAPI(ctx, pluginDir2);
+  ctx.dota2tracker.stratzAPI = new StratzAPI(ctx, currentDir);
   if (config.enableOpenDotaFallback) {
     ctx.dota2tracker.opendotaAPI = new OpenDotaAPI(ctx);
-    ctx.dota2tracker.opendotaAdapter = new OpenDotaAdapter(ctx);
+    ctx.dota2tracker.opendotaAdapter = new OpenDotaAdapter(ctx, dotaconstants);
   }
   ctx.dota2tracker = ctx.dota2tracker;
   usage = await ctx.dota2tracker.i18n.generateUsage();
@@ -4327,7 +4365,7 @@ async function apply(ctx, config) {
   registerQueryHeroCommand(ctx);
   registerQueryItemCommand(ctx);
   registerHeroOfTheDayCommand(ctx);
-  if (config.enableConsole) registerConsolePage(ctx);
+  if (ctx.console && config.enableConsole) registerConsolePage(ctx);
 }
 __name(apply, "apply");
 // Annotate the CommonJS export names for ESM import in node: