karin-plugin-mys-core 1.0.1 → 1.0.3

package/lib/chunk-HNODD2IL.js

@@ -0,0 +1,179 @@
+import {
+  Render,
+  UserInfo
+} from "./chunk-RWBRS7SA.js";
+import {
+  MysGame
+} from "./chunk-3BIQN6QA.js";
+
+// src/apps/UIDManage.ts
+import karin, { handler, segment } from "node-karin";
+var BindUID = karin.command(
+  /^#?(.*?)绑定uid(?:\s*(.+))?$/i,
+  async (e, next) => {
+    const msgMatch = e.msg.match(/^#?(?<prefix>.*?)绑定uid(?:\s*(?<uid>.+))?$/i)?.groups;
+    const Game = MysGame.match(msgMatch.prefix?.trim() || "");
+    if (!Game) return next();
+    const uid = msgMatch.uid?.trim();
+    if (!uid) {
+      e.reply("\u8BF7\u63D0\u4F9B\u8981\u7ED1\u5B9A\u7684\u6E38\u620FUID\uFF01", { at: true });
+      return true;
+    }
+    const userInfo = await Game.UserInfo.create(e.userId);
+    const bindUids = userInfo.bind_uids;
+    if (!(uid in bindUids)) {
+      bindUids[uid] = { perm: 0 /* BIND */, ltuid: "" };
+    }
+    await userInfo.saveUserInfo({
+      [Game.game + "-main"]: uid,
+      [Game.game + "-uids"]: bindUids
+    });
+    await handler.call(`MYS.${Game.game}.ShowUID`, { e });
+    return true;
+  }
+);
+var getMainUid = (uid, mainUid, bindUids) => {
+  if (mainUid !== uid) return mainUid;
+  const filterUids = Object.entries(bindUids).filter((value) => value[1].perm !== 4 /* DEL */);
+  if (filterUids.length > 0) return filterUids[0][0];
+  return "";
+};
+var UnbindUID = karin.command(
+  /^#?(.*?)(删除|解绑)uid(?:\s*(.+))?$/i,
+  async (e, next) => {
+    const msgMatch = e.msg.match(/^#?(?<prefix>.*?)(删除|解绑)uid(?:\s*(?<idx>.+))?$/i)?.groups;
+    const Game = MysGame.match(msgMatch.prefix?.trim() || "");
+    if (!Game) return next();
+    const uid = msgMatch.idx?.trim();
+    const idx = +uid.split(".")[0];
+    if (isNaN(idx)) {
+      e.reply("\u8BF7\u6B63\u786E\u63D0\u4F9B\u8981\u89E3\u7ED1\u7684\u6E38\u620FUID\u6216\u5E8F\u53F7\uFF01", { at: true });
+      return true;
+    }
+    const userInfo = await Game.UserInfo.create(e.userId);
+    const bindUids = userInfo.bind_uids;
+    let delUid = uid;
+    if (idx <= 1e4) {
+      const filterUids = Object.entries(bindUids).filter((value) => value[1].perm !== 4 /* DEL */);
+      if (idx > filterUids.length || idx <= 0) {
+        e.reply("UID\u5E8F\u53F7\u4E0D\u5B58\u5728\uFF0C\u8BF7\u68C0\u67E5\u540E\u91CD\u65B0\u8F93\u5165\uFF01", { at: true });
+        return "break";
+      }
+      delUid = filterUids[idx - 1][0];
+    }
+    if (delUid in bindUids) {
+      if (bindUids[delUid].perm === 0 /* BIND */) {
+        delete bindUids[delUid];
+      } else {
+        bindUids[delUid].perm = 4 /* DEL */;
+      }
+    } else {
+      e.reply("UID\u672A\u7ED1\u5B9A\uFF0C\u8BF7\u68C0\u67E5\u540E\u91CD\u65B0\u8F93\u5165\uFF01", { at: true });
+      return "break";
+    }
+    const mainUid = getMainUid(delUid, userInfo.main_uid, bindUids);
+    await userInfo.saveUserInfo({
+      [Game.game + "-main"]: mainUid,
+      [Game.game + "-uids"]: bindUids
+    });
+    await handler.call(`MYS.${Game.game}.ShowUID`, { e });
+    return true;
+  }
+);
+var ShowBindAccountCmdFunc = async (e) => {
+  const userInfo = await UserInfo.create(e.userId, true);
+  const renderData = {
+    User: {
+      userId: e.userId,
+      avatar: e.contact.name,
+      nickname: await e.bot.getAvatarUrl(e.userId, 100)
+    },
+    AccountList: []
+  };
+  const ltuidInfoList = userInfo.LtuidInfoList;
+  if (ltuidInfoList.length > 0) {
+    for (const ltuidInfo of ltuidInfoList) {
+      const data = {
+        ltuid: ltuidInfo.ltuid,
+        permission: 0 /* BIND */,
+        bindUids: []
+      };
+      if (ltuidInfo.cookie) {
+        data.permission += 1 /* CK */;
+      }
+      if (ltuidInfo.stoken) {
+        data.permission += 2 /* ST */;
+      }
+      await MysGame.forEachGame(async (Game) => {
+        const gameUserInfo = await Game.UserInfo.create(e.userId);
+        data.bindUids.push({
+          gameName: Game.name,
+          uids: Object.entries(gameUserInfo.bind_uids).filter(([, info]) => info.ltuid === ltuidInfo.ltuid).map(([uid, info]) => ({
+            uid,
+            perm: info.perm
+          }))
+        });
+      });
+      renderData.AccountList.push(data);
+    }
+  }
+  const image = await Render.template("ShowBindAccount", renderData);
+  image && e.reply(segment.image(image), { at: true });
+  return true;
+};
+var ShowBindAccount = karin.command(
+  /^#?(米游社|mys)账号(列表)?$/i,
+  ShowBindAccountCmdFunc
+);
+var UnbindAccount = karin.command(
+  /^#?(删除|解绑)(米游社|mys)账号(?:\s*(.+))?$/i,
+  async (e) => {
+    const msgMatch = e.msg.match(/^#?(删除|解绑)(米游社|mys)账号(?:\s*(?<idx>.+))?$/i)?.groups;
+    const uid = msgMatch.idx?.trim();
+    const idx = +uid.split(".")[0];
+    if (isNaN(idx)) {
+      e.reply("\u8BF7\u6B63\u786E\u63D0\u4F9B\u8981\u89E3\u7ED1\u7684\u7C73\u6E38\u793EUID\u6216\u5E8F\u53F7\uFF01", { at: true });
+      return true;
+    }
+    const userInfo = await UserInfo.create(e.userId, true);
+    let ltuidInfo;
+    const ltuidInfoList = userInfo.LtuidInfoList;
+    if (idx < 1e4) {
+      if (idx > ltuidInfoList.length || idx <= 0) {
+        e.reply("\u7C73\u6E38\u793EUID\u5E8F\u53F7\u4E0D\u5B58\u5728\uFF0C\u8BF7\u68C0\u67E5\u540E\u91CD\u65B0\u8F93\u5165\uFF01", { at: true });
+        return true;
+      }
+      ltuidInfo = ltuidInfoList[idx - 1];
+    } else {
+      ltuidInfo = ltuidInfoList.find((info) => info.ltuid === uid);
+      if (!ltuidInfo) {
+        e.reply("\u7C73\u6E38\u793EUID\u672A\u7ED1\u5B9A\uFF0C\u8BF7\u68C0\u67E5\u540E\u91CD\u65B0\u8F93\u5165\uFF01", { at: true });
+        return true;
+      }
+    }
+    const ltuid = ltuidInfo.ltuid;
+    await ltuidInfo.destroy();
+    await userInfo.saveUserInfo({
+      ltuids: userInfo.ltuids.remove(ltuid),
+      stuids: userInfo.stuids.remove(ltuid)
+    });
+    await MysGame.forEachGame(async (Game) => {
+      const gameUserInfo = await Game.UserInfo.create(e.userId);
+      const bindUids = gameUserInfo.bind_uids;
+      for (const uid2 in bindUids) {
+        if (bindUids[uid2].ltuid === ltuid) {
+          bindUids[uid2].perm = 0 /* BIND */;
+        }
+      }
+    });
+    return await ShowBindAccountCmdFunc(e);
+  }
+);
+
+export {
+  BindUID,
+  UnbindUID,
+  ShowBindAccountCmdFunc,
+  ShowBindAccount,
+  UnbindAccount
+};

package/lib/chunk-HVYNK5BN.js

@@ -0,0 +1,45 @@
+// src/exports/utils/render.ts
+import karin, { config } from "node-karin";
+import path from "path";
+var RenderTemplate = class {
+  #renderCfg;
+  constructor(cfg) {
+    this.#renderCfg = cfg;
+  }
+  /** @description 渲染Html路径为：resources/template/${template}/index.html */
+  async template(template, rendeDdata, options = {}) {
+    const img = await karin.render({
+      name: `${this.#renderCfg.name}/${template}`,
+      data: {
+        ...rendeDdata,
+        plugin: {
+          ...options.plugin || {},
+          template,
+          name: this.#renderCfg.name,
+          version: this.#renderCfg.version,
+          resources: {
+            default: path.join(this.#renderCfg.pluginDir, "resources").replace(/\\/g, "/"),
+            download: this.#renderCfg.ResourcesDir.replace(/\\/g, "/")
+          },
+          defaultLayout: path.join(this.#renderCfg.pluginDir, "resources/template/layout/default.html")
+        },
+        karin: {
+          version: config.pkg().version
+        }
+      },
+      type: options.type || "jpeg",
+      omitBackground: options.type === "png",
+      selector: "container",
+      file: path.join(this.#renderCfg.pluginDir, `resources/template/${template}/index.html`),
+      setViewport: {
+        deviceScaleFactor: 2
+      }
+    });
+    if (!img) return null;
+    return "base64://" + img;
+  }
+};
+
+export {
+  RenderTemplate
+};

package/lib/chunk-I7XZONDN.js

@@ -0,0 +1,13 @@
+// src/exports/database/types/tables/mysUserInfo.ts
+var UidPermission = /* @__PURE__ */ ((UidPermission2) => {
+  UidPermission2[UidPermission2["BIND"] = 0] = "BIND";
+  UidPermission2[UidPermission2["CK"] = 1] = "CK";
+  UidPermission2[UidPermission2["ST"] = 2] = "ST";
+  UidPermission2[UidPermission2["CS"] = 3] = "CS";
+  UidPermission2[UidPermission2["DEL"] = 4] = "DEL";
+  return UidPermission2;
+})(UidPermission || {});
+
+export {
+  UidPermission
+};

package/lib/chunk-IVZICDGW.js

@@ -0,0 +1,19 @@
+// src/exports/mys/types/user/userInfo.ts
+var RegisterGameBase = class {
+  game;
+  columnKey;
+  /** @description 游戏名称 */
+  name;
+  /** @description 指令前缀匹配 */
+  prefix;
+  constructor(game, name, prefix) {
+    this.game = game;
+    this.columnKey = `${game}-uids`;
+    this.name = name;
+    this.prefix = prefix;
+  }
+};
+
+export {
+  RegisterGameBase
+};

package/lib/chunk-JKZ5NRPX.js

@@ -0,0 +1,130 @@
+import {
+  EnhancedArray
+} from "./chunk-6PIXUPZ6.js";
+
+// src/exports/config/config.ts
+import { existsSync, logger, requireFileSync, watch, writeJsonSync } from "node-karin";
+import lodash from "node-karin/lodash";
+var Config = class {
+  #cfgName;
+  /**
+   * @description 配置缓存
+   */
+  #ConfigCache = null;
+  /**
+   * @description 默认配置
+   */
+  #DefaultConfig;
+  #DefineConfig;
+  /**
+   * @description 配置保存路径
+   */
+  #ConfigPath;
+  /**
+   * @param name 插件名称:配置名称
+   */
+  constructor(name, ConfigPath, DefaultConfig, DefineConfig) {
+    this.#cfgName = name;
+    this.#ConfigPath = ConfigPath;
+    this.#DefaultConfig = DefaultConfig;
+    this.#DefineConfig = DefineConfig;
+    !existsSync(ConfigPath) && writeJsonSync(ConfigPath, DefaultConfig);
+    this.loadConfig();
+  }
+  loadConfig() {
+    const config = requireFileSync(this.#ConfigPath);
+    const mergedConfig = this.mergeWithDefaults(config, this.#DefaultConfig, this.#DefineConfig);
+    this.#ConfigCache = mergedConfig;
+    return mergedConfig;
+  }
+  mergeWithDefaults(userConfig, defaultConfig, IgnoreConfig) {
+    const filterUserConfig = (user, defaults, Ignore) => {
+      if (Array.isArray(user) && Array.isArray(defaults)) {
+        if (Ignore?.defaultConfigItem) {
+          const filtered = [];
+          const required = Ignore.defaultConfigItem.required;
+          user.forEach((value, key) => {
+            if (required && lodash.isPlainObject(value)) {
+              const hasAllRequired = required.every((requiredKey) => requiredKey in value && value[requiredKey] !== void 0 && value[requiredKey] !== null && value[requiredKey] !== "");
+              if (!hasAllRequired) return;
+            }
+            filtered[key] = filterUserConfig(value, Ignore.defaultConfigItem.defaultConfig, Ignore.defaultConfigItem.defaultConfig);
+          });
+          return filtered;
+        }
+        return user;
+      } else if (lodash.isPlainObject(user) && lodash.isPlainObject(defaults)) {
+        const filtered = {};
+        const mergedValue = lodash.merge({}, defaults, user);
+        if (Ignore?.defaultConfig) {
+          lodash.forEach(user, (value, key) => {
+            const mergedValue2 = lodash.merge(Array.isArray(value) ? [] : {}, Ignore.defaultConfig, value);
+            filtered[key] = filterUserConfig(mergedValue2, Ignore.defaultConfig, Array.isArray(value) ? Ignore : Ignore[key]);
+          });
+        }
+        lodash.forEach(defaults, (value, key) => {
+          filtered[key] = filterUserConfig(mergedValue[key], value, Ignore?.[key]);
+        });
+        return filtered;
+      }
+      return user;
+    };
+    const filteredUserConfig = filterUserConfig(userConfig, defaultConfig, IgnoreConfig);
+    const result = lodash.merge({}, defaultConfig, filteredUserConfig);
+    if (!lodash.isEqual(result, userConfig)) {
+      try {
+        writeJsonSync(this.#ConfigPath, result);
+      } catch (err) {
+        logger.error(err);
+      }
+    }
+    return result;
+  }
+  /**
+   * @description 获取配置路径对应的默认配置
+   */
+  getDef(path) {
+    const defConfig = JSON.parse(JSON.stringify(this.#DefaultConfig));
+    return lodash.get(defConfig, path);
+  }
+  get(path, isArray = false, def) {
+    const conf = JSON.parse(JSON.stringify(this.#ConfigCache));
+    const result = path ? lodash.get(conf, path, def) : conf;
+    if (isArray) {
+      if (!Array.isArray(result)) {
+        logger.error(`\u914D\u7F6E\u8DEF\u5F84 ${path} \u4E0D\u662F\u6570\u7EC4\u7C7B\u578B`);
+        return new EnhancedArray(this, [], path);
+      }
+      return new EnhancedArray(this, result, path);
+    }
+    return result;
+  }
+  /**
+   * @param save 是否立即保存
+   */
+  set(path, value, save) {
+    lodash.set(this.#ConfigCache, path, value);
+    save && this.save();
+  }
+  /**
+   * @description 立即保存配置
+   */
+  save() {
+    try {
+      logger.debug(`[${this.#cfgName}] \u4FDD\u5B58\u914D\u7F6E`, this.#ConfigCache);
+      writeJsonSync(this.#ConfigPath, this.#ConfigCache);
+    } catch (err) {
+      logger.error(err);
+    }
+  }
+  watch() {
+    watch(this.#ConfigPath, () => {
+      this.loadConfig();
+    });
+    return this;
+  }
+};
+
+export {
+  Config
+};

package/lib/chunk-JVJQKRJ4.js

@@ -0,0 +1,89 @@
+// src/exports/database/types/dbs/base.ts
+import { logger } from "node-karin";
+import lodash from "node-karin/lodash";
+var Dialect = /* @__PURE__ */ ((Dialect2) => {
+  Dialect2["Sqlite"] = "sqlite";
+  Dialect2["MySQL"] = "mysql";
+  Dialect2["MariaDB"] = "mariadb";
+  Dialect2["PostgreSQL"] = "postgres";
+  Dialect2["MSSQL"] = "mssql";
+  Dialect2["Oracle"] = "oracle";
+  Dialect2["DB2"] = "db2";
+  Dialect2["Snowflake"] = "snowflake";
+  return Dialect2;
+})(Dialect || {});
+var DatabaseType = /* @__PURE__ */ ((DatabaseType2) => {
+  DatabaseType2["File"] = "file";
+  DatabaseType2["Dir"] = "dir";
+  DatabaseType2["Db"] = "db";
+  return DatabaseType2;
+})(DatabaseType || {});
+var DatabaseArray = class _DatabaseArray extends Array {
+  constructor(items) {
+    super();
+    Object.setPrototypeOf(this, _DatabaseArray.prototype);
+    if (Array.isArray(items)) {
+      this.push(...items);
+    }
+  }
+  /**
+  * @param element - string | number
+  * @returns
+  */
+  has(element) {
+    return new Set(this).has(element);
+  }
+  /**
+   * @param isEqual 是否不添加重复元素
+   */
+  add(element, isEqual) {
+    if (isEqual) {
+      const existingSet = new Set(this.map((item) => JSON.stringify(item)));
+      if (existingSet.has(JSON.stringify(element))) return this;
+    }
+    this.push(element);
+    return this;
+  }
+  /**
+   * @param isEqual 是否不添加重复元素
+   */
+  addSome(elements, isEqual) {
+    if (isEqual) {
+      const existingSet = new Set(this.map((item) => JSON.stringify(item)));
+      elements = elements.filter((element) => !existingSet.has(JSON.stringify(element)));
+      if (elements.length === 0) return this;
+    }
+    this.push(...elements);
+    return this;
+  }
+  /**
+   * @param isIndex predicate是否为索引
+   */
+  remove(predicate, isIndex = false) {
+    let newArr = [];
+    if (isIndex && lodash.isNumber(predicate)) {
+      if (predicate < 0 || predicate >= this.length) {
+        logger.error(`DatabaseArray\u7D22\u5F15 ${predicate} \u8D85\u51FA\u8303\u56F4`);
+        return this;
+      }
+      newArr = [...this.slice(0, predicate), ...this.slice(predicate + 1)];
+    } else if (lodash.isFunction(predicate)) {
+      newArr = this.filter((item) => !predicate(item));
+    } else {
+      newArr = lodash.without(this, predicate);
+    }
+    this.length = 0;
+    this.push(...newArr);
+    return this;
+  }
+  clear() {
+    this.length = 0;
+    return this;
+  }
+};
+
+export {
+  Dialect,
+  DatabaseType,
+  DatabaseArray
+};

package/lib/chunk-KN5SHBVI.js

@@ -0,0 +1,30 @@
+import {
+  Table
+} from "./chunk-5NA7ZPDS.js";
+import {
+  Database
+} from "./chunk-G547WVGV.js";
+import {
+  dir
+} from "./chunk-SHLPPEAY.js";
+
+// src/exports/database/tables/mysAccountInfo.ts
+var MysAccountInfoTable = new Table(
+  dir.DataDir,
+  "mys_account_info_data",
+  "db" /* Db */
+);
+var MysAccountInfoDB = await MysAccountInfoTable.init(
+  {
+    ltuid: Database.PkColumn("STRING"),
+    type: Database.Column("STRING", "mihoyo" /* cn */),
+    cookie: Database.Column("TEXT", ""),
+    stoken: Database.Column("STRING", ""),
+    deviceMd5: Database.Column("STRING", "")
+  }
+);
+
+export {
+  MysAccountInfoTable,
+  MysAccountInfoDB
+};

package/lib/chunk-LG34FPBI.js

@@ -0,0 +1,50 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/exports/utils/common.ts
+var common_exports = {};
+__export(common_exports, {
+  ObjToStr: () => ObjToStr,
+  StrToObj: () => StrToObj,
+  getDeviceGuid: () => getDeviceGuid,
+  randomString: () => randomString
+});
+import lodash from "node-karin/lodash";
+var randomString = (length, type) => {
+  let str = "0123456789";
+  if (type === "Lower" || type === "All") {
+    str += "abcdefghijklmnopqrstuvwxyz";
+  }
+  if (type === "Upper" || type === "All") {
+    str += "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+  }
+  return lodash.sampleSize(str, length).join("");
+};
+var getDeviceGuid = () => {
+  function S4() {
+    return ((1 + Math.random()) * 65536 | 0).toString(16).substring(1);
+  }
+  return S4() + S4() + "-" + S4() + "-" + S4() + "-" + S4() + "-" + S4() + S4() + S4();
+};
+var StrToObj = (Str, sep) => {
+  const strObj = {};
+  Str.split(sep).forEach((item) => {
+    const [key, value] = item.split("=");
+    if (key) {
+      strObj[key] = value || "";
+    }
+  });
+  return strObj;
+};
+var ObjToStr = (obj, sep) => {
+  return Object.entries(obj).filter(([k, v]) => v).map(([k, v]) => `${k}=${v}`).join(sep) + sep;
+};
+
+export {
+  randomString,
+  getDeviceGuid,
+  StrToObj,
+  ObjToStr,
+  common_exports
+};