koishi-plugin-apple-rank 0.0.1

package/lib/index.d.ts

@@ -0,0 +1,10 @@
+import { Context, Schema } from 'koishi';
+export declare const name = "apple-rank";
+export interface Config {
+    country: string;
+    limit: 10 | 25 | 50 | 100 | 200;
+    cacheTtl: number;
+    aliases: Record<string, string>;
+}
+export declare const Config: Schema<Config>;
+export declare function apply(ctx: Context, config: Config): void;

package/lib/index.js

@@ -0,0 +1,249 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Config: () => Config,
+  apply: () => apply,
+  name: () => name
+});
+module.exports = __toCommonJS(src_exports);
+var import_koishi = require("koishi");
+var name = "apple-rank";
+var Config = import_koishi.Schema.object({
+  country: import_koishi.Schema.string().default("cn").description("App Store 国家/地区代码"),
+  limit: import_koishi.Schema.union([10, 25, 50, 100, 200]).default(100).description("榜单拉取数量"),
+  cacheTtl: import_koishi.Schema.number().min(60).default(600).description("榜单缓存时间，单位秒"),
+  aliases: import_koishi.Schema.dict(String).default({
+    王者荣耀: "989673964",
+    和平精英: "1321803705",
+    星铁: "1523037824",
+    崩铁: "1523037824",
+    崩坏星穹铁道: "1523037824",
+    鸣潮: "6450693428",
+    异环: "6514281568",
+    终末地: "6753859465",
+    明日方舟终末地: "6753859465",
+    "明日方舟：终末地": "6753859465"
+  }).description("游戏别名到 App Store appId 的映射")
+});
+var feedLabels = {
+  topgrossingapplications: "畅销榜",
+  topfreeapplications: "免费榜",
+  toppaidapplications: "付费榜"
+};
+function toArray(value) {
+  if (!value) return [];
+  return Array.isArray(value) ? value : [value];
+}
+__name(toArray, "toArray");
+function getEntryUrl(entry) {
+  const links = toArray(entry.link);
+  return links.find((link) => link.attributes?.href)?.attributes?.href;
+}
+__name(getEntryUrl, "getEntryUrl");
+function normalizeEntry(entry, index) {
+  return {
+    rank: index + 1,
+    appId: entry.id.attributes["im:id"],
+    name: entry["im:name"].label,
+    artist: entry["im:artist"].label,
+    category: entry.category?.attributes?.label,
+    bundleId: entry.id.attributes["im:bundleId"],
+    price: entry["im:price"]?.label,
+    url: getEntryUrl(entry),
+    icon: entry["im:image"]?.at(-1)?.label
+  };
+}
+__name(normalizeEntry, "normalizeEntry");
+function formatRankItem(item) {
+  const category = item.category ? ` / ${item.category}` : "";
+  return `${item.rank}. ${item.name}${category}`;
+}
+__name(formatRankItem, "formatRankItem");
+function formatRankItemWithIcon(item) {
+  const text = formatRankItem(item);
+  return item.icon ? `${import_koishi.h.image(item.icon)}${text}` : text;
+}
+__name(formatRankItemWithIcon, "formatRankItemWithIcon");
+function formatUpdatedAt(updated) {
+  if (!updated) return "更新时间：未知";
+  const date = new Date(updated);
+  if (Number.isNaN(date.valueOf())) return `更新时间：${updated}`;
+  return `更新时间：${date.toLocaleString("zh-CN", { timeZone: "Asia/Shanghai", hour12: false })}`;
+}
+__name(formatUpdatedAt, "formatUpdatedAt");
+function parseFeedType(type = "grossing") {
+  if (["grossing", "畅销", "畅销榜", "流水"].includes(type)) return "topgrossingapplications";
+  if (["free", "免费", "免费榜"].includes(type)) return "topfreeapplications";
+  if (["paid", "付费", "付费榜"].includes(type)) return "toppaidapplications";
+}
+__name(parseFeedType, "parseFeedType");
+function parseJson(source) {
+  if (typeof source === "string") return JSON.parse(source);
+  return source;
+}
+__name(parseJson, "parseJson");
+function apply(ctx, config) {
+  let cachedAt = 0;
+  let cachedFeed = "";
+  let cachedRankFeed = { ranks: [], actualLimit: 0 };
+  const recentReplies = /* @__PURE__ */ new Map();
+  async function fetchRanks(feedType = "topgrossingapplications") {
+    const now = Date.now();
+    if (cachedFeed === feedType && cachedRankFeed.ranks.length && now - cachedAt < config.cacheTtl * 1e3) {
+      return cachedRankFeed;
+    }
+    const url = `https://itunes.apple.com/${config.country}/rss/${feedType}/limit=${config.limit}/json`;
+    const response = parseJson(await ctx.http.get(url));
+    if (!response?.feed) {
+      throw new Error("Apple 榜单接口未返回 feed 数据");
+    }
+    const ranks = toArray(response.feed.entry).map(normalizeEntry);
+    cachedAt = now;
+    cachedFeed = feedType;
+    cachedRankFeed = { ranks, updated: response.feed.updated?.label, actualLimit: ranks.length };
+    return cachedRankFeed;
+  }
+  __name(fetchRanks, "fetchRanks");
+  function shouldReplyOnce(key) {
+    const now = Date.now();
+    const last = recentReplies.get(key);
+    if (last && now - last < 1500) return false;
+    recentReplies.set(key, now);
+    if (recentReplies.size > 100) {
+      for (const [storedKey, storedAt] of recentReplies) {
+        if (now - storedAt > 10 * 60 * 1e3) recentReplies.delete(storedKey);
+      }
+    }
+    return true;
+  }
+  __name(shouldReplyOnce, "shouldReplyOnce");
+  async function searchApp(keyword) {
+    const url = "https://itunes.apple.com/search";
+    const response = parseJson(await ctx.http.get(url, {
+      params: {
+        term: keyword,
+        country: config.country,
+        entity: "software",
+        limit: 5
+      }
+    }));
+    return response.results;
+  }
+  __name(searchApp, "searchApp");
+  async function resolveApp(keyword) {
+    const appId = config.aliases[keyword] || (/^\d+$/.test(keyword) ? keyword : void 0);
+    if (appId) return appId;
+    const results = await searchApp(keyword);
+    return results.find((result) => result.primaryGenreName === "Games")?.trackId.toString() || results[0]?.trackId.toString();
+  }
+  __name(resolveApp, "resolveApp");
+  async function findRank(keyword, feedType = "topgrossingapplications") {
+    const appId = await resolveApp(keyword);
+    if (!appId) return { appId: void 0, item: void 0 };
+    const feed = await fetchRanks(feedType);
+    return {
+      appId,
+      item: feed.ranks.find((item) => item.appId === appId),
+      updated: feed.updated,
+      actualLimit: feed.actualLimit
+    };
+  }
+  __name(findRank, "findRank");
+  ctx.command("ios榜 [type:string]", "查看中国区 App Store 榜单").option("limit", "-l <limit:number> 显示数量", { fallback: 10 }).action(async ({ options, session }, type) => {
+    if (session && !shouldReplyOnce(`${session.sid}:ios榜:${type || "grossing"}:${options.limit || 10}`)) return;
+    const feedType = parseFeedType(type);
+    if (!feedType) return "榜单类型可用：畅销 / 免费 / 付费";
+    const limit = Math.max(options.limit || 10, 1);
+    const feed = await fetchRanks(feedType);
+    const actualLimit = feed.actualLimit || feed.ranks.length;
+    const lines = feed.ranks.slice(0, Math.min(limit, actualLimit)).map(formatRankItemWithIcon);
+    return [`App Store ${config.country.toUpperCase()} ${feedLabels[feedType]} Top ${actualLimit}`, formatUpdatedAt(feed.updated), ...lines].join("\n");
+  });
+  ctx.command("ios排名 <game:text>", "查询游戏在 iOS 畅销榜的排名").option("type", "-t <type:string> 榜单类型：畅销/免费/付费", { fallback: "畅销" }).action(async ({ options, session }, game) => {
+    if (session && !shouldReplyOnce(`${session.sid}:ios排名:${options.type}:${game}`)) return;
+    if (!game) return "请输入游戏名，例如：ios排名 王者荣耀";
+    const feedType = parseFeedType(options.type);
+    if (!feedType) return "榜单类型可用：畅销 / 免费 / 付费";
+    const { appId, item, updated, actualLimit } = await findRank(game, feedType);
+    if (!appId) return `没找到「${game}」对应的 App Store 应用`;
+    if (!item) {
+      return `「${game}」未进入 App Store ${config.country.toUpperCase()} ${feedLabels[feedType]} Top ${actualLimit}
+${formatUpdatedAt(updated)}
+口径：Apple 公开榜单，只代表 iOS 排名，不代表全平台流水`;
+    }
+    return [
+      item.icon ? import_koishi.h.image(item.icon) : "",
+      `${item.name} iOS ${feedLabels[feedType]}排名：第 ${item.rank} 名`,
+      formatUpdatedAt(updated),
+      `开发者：${item.artist}`,
+      `分类：${item.category || "未知"}`,
+      "口径：Apple 公开榜单，只代表 iOS 排名，不代表全平台流水"
+    ].filter(Boolean).join("\n");
+  });
+  ctx.command("ios对比 <games:text>", "对比多个游戏的 iOS 畅销榜排名").action(async ({ session }, games) => {
+    if (session && !shouldReplyOnce(`${session.sid}:ios对比:${games}`)) return;
+    const names = games?.split(/\s+/).filter(Boolean) || [];
+    if (names.length < 2) return "请输入至少两个游戏名，例如：ios对比 王者荣耀 原神";
+    const feed = await fetchRanks();
+    const actualLimit = feed.actualLimit || feed.ranks.length;
+    const appIds = await Promise.all(names.map(resolveApp));
+    const results = names.map((game, index) => {
+      const appId = appIds[index];
+      if (!appId) return `${game}：未找到应用`;
+      const item = feed.ranks.find((item2) => item2.appId === appId);
+      if (!item) return `${game}：未进入畅销榜 Top ${actualLimit}`;
+      return [
+        item.icon ? import_koishi.h.image(item.icon) : "",
+        `${item.name}：第 ${item.rank} 名`
+      ].filter(Boolean).join("\n");
+    });
+    return [
+      `App Store ${config.country.toUpperCase()} 畅销榜对比`,
+      formatUpdatedAt(feed.updated),
+      ...results,
+      "口径：Apple 公开榜单，只代表 iOS 排名，不代表全平台流水"
+    ].join("\n");
+  });
+  ctx.command("ios搜索 <keyword:text>", "搜索 App Store 应用").action(async ({ session }, keyword) => {
+    if (session && !shouldReplyOnce(`${session.sid}:ios搜索:${keyword}`)) return;
+    if (!keyword) return "请输入关键词，例如：ios搜索 王者荣耀";
+    const results = await searchApp(keyword);
+    if (!results.length) return `没搜到「${keyword}」`;
+    return results.map((result, index) => {
+      const genres = result.genres?.join(" / ") || result.primaryGenreName;
+      const icon = result.artworkUrl100 ? `${import_koishi.h.image(result.artworkUrl100)}` : "";
+      return [
+        icon,
+        `${index + 1}. ${result.trackName} (${result.trackId})`,
+        `开发者：${result.artistName}`,
+        `分类：${genres}`
+      ].filter(Boolean).join("\n");
+    }).join("\n\n");
+  });
+}
+__name(apply, "apply");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Config,
+  apply,
+  name
+});

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "koishi-plugin-apple-rank",
+  "description": "给二游痴看流水用的,数据来自苹果的rss",
+  "version": "0.0.1",
+  "main": "lib/index.js",
+  "typings": "lib/index.d.ts",
+  "files": [
+    "lib",
+    "dist"
+  ],
+  "license": "MIT",
+  "keywords": [
+    "chatbot",
+    "koishi",
+    "plugin"
+  ],
+  "peerDependencies": {
+    "koishi": "^4.18.7"
+  }
+}

package/readme.md

@@ -0,0 +1,5 @@
+# koishi-plugin-apple-rank
+
+[![npm](https://img.shields.io/npm/v/koishi-plugin-apple-rank?style=flat-square)](https://www.npmjs.com/package/koishi-plugin-apple-rank)
+
+给二游痴看流水用的