@kotori-bot/core 1.4.1 → 1.5.0

package/lib/utils/factory.js

@@ -1,45 +1,855 @@
+
+/**
+ * @Package @kotori-bot/core
+ * @Version 1.4.2-beta.1
+ * @Author Hotaru <biyuehuya@gmail.com>
+ * @Copyright 2024 Hotaru. All rights reserved.
+ * @License GPL-3.0
+ * @Link https://github.com/kotorijs/kotori
+ * @Date 2024/6/6 21:03:53
+ */
+
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatFactory = exports.cancelFactory = exports.disposeFactory = void 0;
-const __1 = require("..");
-function disposeFactory(ctx, dispose) {
-    ctx.once('dispose_module', (data) => {
-        if ((typeof data.instance === 'object' ? data.instance.name : data.instance) !== ctx.identity) {
-            disposeFactory(ctx, dispose);
-            return;
-        }
-        dispose();
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], 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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/factory.ts
+var factory_exports = {};
+__export(factory_exports, {
+  cancelFactory: () => cancelFactory,
+  confirmFactory: () => confirmFactory,
+  disposeFactory: () => disposeFactory,
+  formatFactory: () => formatFactory,
+  promptFactory: () => promptFactory,
+  quickFactory: () => quickFactory,
+  sendMessageFactory: () => sendMessageFactory
+});
+module.exports = __toCommonJS(factory_exports);
+var import_tools8 = require("@kotori-bot/tools");
+
+// src/types/message.ts
+var import_tsukiko = __toESM(require("tsukiko"));
+var CommandAccess = /* @__PURE__ */ ((CommandAccess2) => {
+  CommandAccess2[CommandAccess2["MEMBER"] = 0] = "MEMBER";
+  CommandAccess2[CommandAccess2["MANGER"] = 1] = "MANGER";
+  CommandAccess2[CommandAccess2["ADMIN"] = 2] = "ADMIN";
+  return CommandAccess2;
+})(CommandAccess || {});
+var commandArgTypeSignSchema = import_tsukiko.default.Union([
+  import_tsukiko.default.Union([import_tsukiko.default.Literal("string"), import_tsukiko.default.Literal("number")]),
+  import_tsukiko.default.Literal("boolean")
+]);
+var MessageScope = /* @__PURE__ */ ((MessageScope2) => {
+  MessageScope2[MessageScope2["PRIVATE"] = 0] = "PRIVATE";
+  MessageScope2[MessageScope2["GROUP"] = 1] = "GROUP";
+  return MessageScope2;
+})(MessageScope || {});
+var eventDataTargetIdSchema = import_tsukiko.default.Union([import_tsukiko.default.Number(), import_tsukiko.default.String()]);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ADAPTER_PREFIX: () => ADAPTER_PREFIX,
+  Adapter: () => Adapter,
+  Api: () => Api,
+  CUSTOM_PREFIX: () => CUSTOM_PREFIX,
+  Cache: () => Cache,
+  Command: () => Command,
+  CommandAccess: () => CommandAccess,
+  CommandError: () => CommandError,
+  Container: () => Container,
+  Core: () => Core,
+  DATABASE_PREFIX: () => DATABASE_PREFIX,
+  DEFAULT_CORE_CONFIG: () => DEFAULT_CORE_CONFIG,
+  DEFAULT_PORT: () => DEFAULT_PORT,
+  DevError: () => DevError,
+  Elements: () => Elements,
+  KotoriError: () => KotoriError,
+  MessageScope: () => MessageScope,
+  ModuleError: () => ModuleError,
+  OFFICIAL_MODULES_SCOPE: () => OFFICIAL_MODULES_SCOPE,
+  PLUGIN_PREFIX: () => PLUGIN_PREFIX,
+  Symbols: () => Symbols,
+  cancelFactory: () => cancelFactory,
+  commandArgTypeSignSchema: () => commandArgTypeSignSchema,
+  confirmFactory: () => confirmFactory,
+  disposeFactory: () => disposeFactory,
+  eventDataTargetIdSchema: () => eventDataTargetIdSchema,
+  formatFactory: () => formatFactory,
+  promptFactory: () => promptFactory,
+  quickFactory: () => quickFactory,
+  sendMessageFactory: () => sendMessageFactory
+});
+__reExport(src_exports, require("fluoro"));
+
+// src/components/core.ts
+var import_tools6 = require("@kotori-bot/tools");
+var import_i18n2 = __toESM(require("@kotori-bot/i18n"));
+var import_fluoro2 = require("fluoro");
+
+// src/components/config.ts
+var import_tsukiko2 = __toESM(require("tsukiko"));
+var import_node_path = require("path");
+var import_tools = require("@kotori-bot/tools");
+
+// src/global/constants.ts
+var import_i18n = require("@kotori-bot/i18n");
+var OFFICIAL_MODULES_SCOPE = "@kotori-bot/";
+var PLUGIN_PREFIX = "kotori-plugin-";
+var DATABASE_PREFIX = `${PLUGIN_PREFIX}database-`;
+var ADAPTER_PREFIX = `${PLUGIN_PREFIX}adapter-`;
+var CUSTOM_PREFIX = `${PLUGIN_PREFIX}custom-`;
+var DEFAULT_PORT = 720;
+var DEFAULT_CORE_CONFIG = {
+  global: {
+    lang: import_i18n.DEFAULT_LANG,
+    "command-prefix": "/",
+    port: DEFAULT_PORT
+  },
+  adapter: {},
+  plugin: {}
+};
+
+// src/global/symbols.ts
+var Symbols = class {
+  static adapter = Symbol.for("kotori.core.adapter");
+  static bot = Symbol.for("kotori.core.bot");
+  static midware = Symbol.for("kotori.core.midware");
+  static command = Symbol.for("kotori.core.command");
+  static regexp = Symbol.for("kotori.core.regexp");
+  static modules = Symbol.for("kotori.loader.module");
+  static job = Symbol.for("kotori.loader.job");
+};
+
+// src/components/config.ts
+var packageInfoSchema = import_tsukiko2.default.Object({
+  name: import_tsukiko2.default.String(),
+  version: import_tsukiko2.default.String(),
+  description: import_tsukiko2.default.String(),
+  main: import_tsukiko2.default.String(),
+  license: import_tsukiko2.default.Literal("GPL-3.0"),
+  author: import_tsukiko2.default.String()
+});
+var Config = class {
+  config;
+  pkg;
+  constructor(config = DEFAULT_CORE_CONFIG) {
+    this.config = config;
+    const info = (0, import_tools.loadConfig)((0, import_node_path.resolve)(__dirname, "../../package.json"));
+    if (!info || Object.values(info).length === 0) {
+      process.stderr.write(`Cannot find kotori-bot package.json
+`);
+      process.exit();
+    }
+    const result = packageInfoSchema.parseSafe(info);
+    if (!result.value) {
+      process.stderr.write(`File package.json format error: ${result.error.message}
+`);
+      process.exit();
+    }
+    this.pkg = result.data;
+  }
+};
+var config_default = Config;
+
+// src/components/message.ts
+var import_tools3 = require("@kotori-bot/tools");
+var import_cron = require("cron");
+
+// src/utils/command.ts
+var import_tools2 = require("@kotori-bot/tools");
+var import_minimist = __toESM(require("minimist"));
+
+// src/utils/error.ts
+var KotoriError = class _KotoriError extends Error {
+  constructor(message, extra, type = "UnknownError") {
+    super(message);
+    this.name = type;
+    this.extra = extra;
+  }
+  extra;
+  name;
+  extend() {
+    const { message: fatherMessage, name: fatherType, extra: fatherExtra } = this;
+    return new Proxy(_KotoriError, {
+      construct(Class, params) {
+        const args = params;
+        args[0] = `${fatherMessage} ${args[0]}`;
+        args[1] = args[1] ?? fatherExtra;
+        args[2] = args[2] ?? fatherType;
+        return new Class(...args);
+      }
     });
+  }
+};
+var ModuleError = new KotoriError(void 0, void 0, "ModuleError").extend();
+var DevError = new KotoriError(void 0, void 0, "DevError").extend();
+
+// src/utils/commandError.ts
+var CommandError = class extends KotoriError {
+  value;
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+};
+var commandError_default = CommandError;
+
+// src/utils/command.ts
+var requiredParamMatch = /<(\.\.\.)?(.*?)(:(.*?))?(=(.*?))?>/;
+var optionalParamMatch = /\[(\.\.\.)?(.*?)(:(.*?))?(=(.*?))?\]/;
+var defaultType = "string";
+function handleDefaultValue(value, type) {
+  if (type === "boolean") return value !== "false" && !!value;
+  if (type === "number") {
+    if (typeof value === "number") return value;
+    if (value === true) return 1;
+    if (value === false) return 0;
+    const float = parseFloat(value);
+    const int = parseInt(value, 10);
+    return float === int ? int : float;
+  }
+  return value.toString();
 }
-exports.disposeFactory = disposeFactory;
-function cancelFactory() {
+var Command = class {
+  static run(input, data) {
+    let starts = "";
+    [data.root, ...data.alias].forEach((el) => {
+      if (starts) return;
+      if (input.startsWith(`${el} `) || input === el) starts = el;
+    });
+    if (!starts) return new CommandError({ type: "unknown", input });
+    const opts = {
+      string: [],
+      boolean: [],
+      alias: {}
+    };
+    data.options.forEach((option) => {
+      if (option.type === "string") {
+        opts.string.push(option.realname);
+      } else if (option.type === "boolean") {
+        opts.boolean.push(option.realname);
+      }
+      opts.alias[option.realname] = option.name;
+    });
+    const arr = (0, import_tools2.parseArgs)(input.slice(starts.length).trim());
+    if (!Array.isArray(arr)) return new CommandError({ type: "syntax", ...arr });
+    const result = (0, import_minimist.default)(arr, opts);
+    const args = result._;
+    const count = {
+      expected: data.args.filter((el) => !el.optional).length,
+      reality: args.length
+    };
+    if (count.reality < count.expected) return new CommandError({ type: "arg_few", ...count });
+    count.expected = data.args.length;
+    if ((data.args.length <= 0 || !data.args[data.args.length - 1].rest) && count.reality > count.expected)
+      return new CommandError({ type: "arg_many", ...count });
+    let error2;
+    data.args.forEach((val, index) => {
+      if (error2 || index > 0 && !args[index - 1]) return;
+      if (!args[index] && val.default) {
+        args[index] = val.default;
+        return;
+      }
+      if (val.rest || !args[index]) return;
+      args[index] = handleDefaultValue(args[index], val.type);
+      if (!Number.isNaN(args[index])) return;
+      error2 = new CommandError({ type: "arg_error", expected: "number", reality: "string", index });
+    });
+    if (error2) return error2;
+    const options = {};
+    data.options.forEach((val) => {
+      if (!(val.realname in result)) return;
+      options[val.realname] = Array.isArray(result[val.realname]) ? result[val.realname][0] : result[val.realname];
+      options[val.realname] = handleDefaultValue(options[val.realname], val.type);
+      if (Number.isNaN(options[val.realname]))
+        error2 = new CommandError({ type: "option_error", expected: "number", reality: "string", target: val.realname });
+    });
+    if (error2) return error2;
     return {
-        get() {
-            return () => this.fn();
-        },
-        fn() {
-            this.value = true;
-        },
-        value: false
+      args: data.args.length > 0 && data.args[data.args.length - 1].rest ? args : args.slice(0, data.args.length),
+      options
     };
-}
-exports.cancelFactory = cancelFactory;
-function formatFactory(i18n) {
-    return (template, data) => {
-        const params = data;
-        if (Array.isArray(params)) {
-            let str = i18n.locale(template);
-            params.forEach((value, index) => {
-                str = str.replaceAll(`{${index}}`, i18n.locale(typeof value === 'string' ? value : String(value)));
-            });
-            return str;
+  }
+  template;
+  meta = {
+    root: "",
+    alias: [],
+    scope: "all",
+    access: 0 /* MEMBER */,
+    args: [],
+    options: []
+  };
+  constructor(template, config) {
+    this.template = template;
+    this.meta = Object.assign(this.meta, config);
+    this.parse();
+  }
+  parse() {
+    const [str, description] = this.template.trim().split(" - ");
+    this.meta.description = description;
+    const requiredIndex = str.indexOf(" <");
+    const optionalIndex = str.indexOf(" [");
+    if (requiredIndex === -1 && optionalIndex === -1) {
+      this.meta.root = str.trim();
+      return;
+    }
+    if (requiredIndex !== -1 && (optionalIndex === -1 || requiredIndex < optionalIndex)) {
+      this.meta.root = str.substring(0, requiredIndex).trim();
+    } else {
+      this.meta.root = str.substring(0, optionalIndex).trim();
+    }
+    const args = (0, import_minimist.default)(str.split(" "))._;
+    args.forEach((arg) => {
+      const current = this.meta.args[this.meta.args.length - 1];
+      if (current && current.rest) return;
+      let result = optionalParamMatch.exec(arg);
+      if (result) {
+        if (!result[2]) return;
+        const type = commandArgTypeSignSchema.parseSafe(result[4]).value ? result[4] : defaultType;
+        this.meta.args.push({
+          name: result[2],
+          type,
+          rest: !!result[1],
+          optional: true,
+          default: result[6] ? handleDefaultValue(result[6], type) : void 0
+        });
+      }
+      result = requiredParamMatch.exec(arg);
+      if (!result || !result[2]) return;
+      if (!result[6] && current && current.optional) return;
+      this.meta.args.push({
+        name: result[2],
+        type: commandArgTypeSignSchema.parseSafe(result[4]).value ? result[4] : defaultType,
+        rest: !!result[1],
+        optional: false
+      });
+    });
+  }
+  alias(alias) {
+    if (typeof alias === "string") this.meta.alias.push(alias);
+    else this.meta.alias.push(...alias);
+    return this;
+  }
+  scope(scope) {
+    this.meta.scope = scope;
+    return this;
+  }
+  access(access) {
+    this.meta.access = access;
+    return this;
+  }
+  option(name, template) {
+    const [str, description] = template.trim().split(" ");
+    const [realname, type] = str.split(":");
+    this.meta.options.push({
+      realname,
+      description,
+      type: commandArgTypeSignSchema.parseSafe(type).value ? type : defaultType,
+      name: name.charAt(0)
+    });
+    return this;
+  }
+  action(callback) {
+    this.meta.action = callback;
+    return this;
+  }
+  help(text) {
+    this.meta.help = text;
+    return this;
+  }
+};
+
+// src/components/message.ts
+var Message = class {
+  [Symbols.midware] = /* @__PURE__ */ new Set();
+  [Symbols.command] = /* @__PURE__ */ new Set();
+  [Symbols.regexp] = /* @__PURE__ */ new Set();
+  handleMidware(session) {
+    const { api } = session;
+    let isPass = true;
+    let midwares = [];
+    api.adapter.status.receivedMsg += 1;
+    this[Symbols.midware].forEach((val) => midwares.push(val));
+    midwares = midwares.sort((first, second) => first.priority - second.priority);
+    let lastMidwareNum = -1;
+    while (midwares.length > 0) {
+      if (lastMidwareNum === midwares.length) {
+        isPass = false;
+        break;
+      }
+      lastMidwareNum = midwares.length;
+      session.quick(midwares[0].callback(() => midwares.shift(), session));
+    }
+    this.ctx.emit("midwares", { isPass, session });
+  }
+  async handleRegexp(data) {
+    const { session } = data;
+    if (!data.isPass) return;
+    this[Symbols.regexp].forEach((data2) => {
+      const result = session.message.match(data2.match);
+      if (!result) return;
+      session.quick(data2.callback(result, session));
+      this.ctx.emit("regexp", { result, session, regexp: data2.match, raw: session.message });
+    });
+  }
+  handleCommand(data) {
+    const { session } = data;
+    const prefix = session.api.adapter.config["command-prefix"] ?? this.ctx.config.global["command-prefix"];
+    if (!session.message.startsWith(prefix)) return;
+    const params = {
+      session,
+      raw: (0, import_tools3.stringRightSplit)(session.message, prefix)
+    };
+    this.ctx.emit("before_parse", params);
+    const cancel = cancelFactory();
+    this.ctx.emit("before_command", { cancel: cancel.get(), ...params });
+    if (cancel.value) return;
+    let matched;
+    this[Symbols.command].forEach(async (cmd) => {
+      if (matched || !cmd.meta.action) return;
+      const result = Command.run(params.raw, cmd.meta);
+      if (result instanceof commandError_default && result.value.type === "unknown") return;
+      matched = cmd;
+      this.ctx.emit("parse", { command: cmd, result, ...params, cancel: cancel.get() });
+      if (cancel.value || result instanceof commandError_default) return;
+      try {
+        const executed = await cmd.meta.action({ args: result.args, options: result.options }, session);
+        if (executed instanceof commandError_default) {
+          this.ctx.emit("command", { command: cmd, result: executed, ...params });
+          return;
         }
-        Object.keys(params).forEach((key) => {
-            if (typeof params[key] !== 'string')
-                params[key] = String(params[key]);
-            params[key] = i18n.locale(params[key]);
+        if (executed !== void 0) session.quick(executed);
+        this.ctx.emit("command", {
+          command: cmd,
+          result: executed instanceof commandError_default ? result : executed,
+          ...params
         });
-        return (0, __1.stringTemp)(i18n.locale(template), params);
+      } catch (error2) {
+        this.ctx.emit("command", {
+          command: matched,
+          result: new commandError_default({ type: "error", error: error2 }),
+          ...params
+        });
+      }
+    });
+    if (matched) return;
+    this.ctx.emit("parse", {
+      command: new Command(""),
+      result: new commandError_default({ type: "unknown", input: params.raw }),
+      ...params,
+      cancel: cancel.get()
+    });
+  }
+  ctx;
+  constructor(ctx) {
+    this.ctx = ctx;
+    this.ctx.on("on_message", (session) => this.handleMidware(session));
+    this.ctx.on("midwares", (data) => this.handleCommand(data));
+    this.ctx.on("midwares", (data) => this.handleRegexp(data));
+    this.ctx.on("before_send", (data) => {
+      const { api } = data;
+      api.adapter.status.sentMsg += 1;
+    });
+  }
+  midware(callback, priority = 100) {
+    const data = { callback, priority };
+    this[Symbols.midware].add(data);
+    const dispose = () => this[Symbols.midware].delete(data);
+    disposeFactory(this.ctx, dispose);
+    return dispose;
+  }
+  command(template, config) {
+    const command = new Command(template, config);
+    this[Symbols.command].add(command);
+    const dispose = () => this[Symbols.command].delete(command);
+    disposeFactory(this.ctx, dispose);
+    return command;
+  }
+  regexp(match, callback) {
+    const data = { match, callback };
+    this[Symbols.regexp].add(data);
+    const dispose = () => this[Symbols.regexp].delete(data);
+    disposeFactory(this.ctx, dispose);
+    return dispose;
+  }
+  // boardcast(type: MessageScope, message: MessageRaw) {
+  //   const send =
+  //     type === 'private'
+  //       ? (api: Api) => api.send_on_message(message, 1)
+  //       : (api: Api) => api.send_on_message(message, 1);
+  //   /* this need support of database... */
+  //   Object.values(this.botStack).forEach((apis) => {
+  //     apis.forEach((api) => send(api));
+  //   });
+  // }
+  notify(message) {
+    const mainAdapterIdentity = Object.keys(this.ctx.config.adapter)[0];
+    this.ctx[Symbols.bot].forEach(
+      (apis) => apis.forEach((api) => {
+        if (api.adapter.identity !== mainAdapterIdentity) return;
+        quickFactory(
+          sendMessageFactory(api.adapter, "on_message", { userId: api.adapter.config.master }),
+          this.ctx.i18n.extends(api.adapter.config.lang)
+        )(message);
+      })
+    );
+  }
+  task(options, callback) {
+    const [cron, extraOptions] = typeof options === "string" ? [options, {}] : [options.cron, options];
+    return new import_cron.CronJob(cron, () => callback(this.ctx), null, extraOptions.start ?? true, extraOptions.timeZone);
+  }
+};
+var message_default = Message;
+
+// src/service/elements.ts
+var import_tools4 = require("@kotori-bot/tools");
+var Elements = class _Elements {
+  default(...args) {
+    (0, import_tools4.none)(this, args);
+    return "";
+  }
+  at(target, ...extra) {
+    return this.default(target, extra);
+  }
+  image(url, ...extra) {
+    return this.default(url, extra);
+  }
+  voice(url, ...extra) {
+    return this.default(url, extra);
+  }
+  video(url, ...extra) {
+    return this.default(url, extra);
+  }
+  face(id, ...extra) {
+    return this.default(id, extra);
+  }
+  file(data, ...extra) {
+    return this.default(data, extra);
+  }
+  supports() {
+    const supports = [];
+    const keys = ["at", "image", "voice", "video", "face", "file"];
+    keys.forEach((key) => {
+      if (this[key] !== new _Elements()[key]) supports.push(key);
+    });
+    return supports;
+  }
+};
+var elements_default = Elements;
+
+// src/service/adapter.ts
+function setProxy(api, ctx) {
+  const proxy = Object.create(api);
+  proxy.sendPrivateMsg = new Proxy(api.sendPrivateMsg, {
+    apply(_, __, argArray) {
+      const [message, targetId] = argArray;
+      const cancel = cancelFactory();
+      ctx.emit("before_send", { api, message, messageType: 0 /* PRIVATE */, targetId, cancel: cancel.get() });
+      if (cancel.value) return;
+      api.sendPrivateMsg(message, targetId, argArray[2]);
+    }
+  });
+  proxy.sendGroupMsg = new Proxy(api.sendGroupMsg, {
+    apply(_, __, argArray) {
+      const [message, targetId] = argArray;
+      const cancel = cancelFactory();
+      ctx.emit("before_send", { api, message, messageType: 0 /* PRIVATE */, targetId, cancel: cancel.get() });
+      if (cancel.value) return;
+      api.sendGroupMsg(message, targetId, argArray[2]);
+    }
+  });
+  return proxy;
+}
+function error(type, data) {
+  return new commandError_default(Object.assign(data ?? {}, { type }));
+}
+var Adapter = class {
+  constructor(ctx, config, identity, Api2, el = new elements_default()) {
+    this.ctx = ctx;
+    this.config = config;
+    this.identity = identity;
+    this.platform = config.extends;
+    this.api = setProxy(new Api2(this), this.ctx);
+    this.elements = el;
+    if (!this.ctx[Symbols.bot].get(this.platform)) this.ctx[Symbols.bot].set(this.platform, /* @__PURE__ */ new Set());
+    this.ctx[Symbols.bot].get(this.platform).add(this.api);
+  }
+  online() {
+    if (this.status.value !== "offline") return;
+    this.status.value = "online";
+    this.ctx.emit("status", { adapter: this, status: "online" });
+  }
+  offline() {
+    if (this.status.value !== "online") return;
+    this.status.value = "offline";
+    this.status.offlineTimes += 1;
+    this.ctx.emit("status", { adapter: this, status: "offline" });
+  }
+  session(type, data) {
+    const i18n = this.ctx.i18n.extends(this.config.lang);
+    const send = sendMessageFactory(this, type, data);
+    const format = formatFactory(i18n);
+    const quick = quickFactory(send, i18n);
+    const prompt = promptFactory(quick, this, data);
+    const confirm = confirmFactory(quick, this, data);
+    const { api, elements: el } = this;
+    this.ctx.emit(
+      type,
+      ...[{ ...data, api, el, send, i18n, format, quick, prompt, confirm, error }]
+    );
+  }
+  ctx;
+  config;
+  identity;
+  platform;
+  api;
+  elements;
+  status = {
+    value: "offline",
+    createTime: /* @__PURE__ */ new Date(),
+    lastMsgTime: null,
+    receivedMsg: 0,
+    sentMsg: 0,
+    offlineTimes: 0
+  };
+  selfId = -1;
+};
+
+// src/service/api.ts
+var import_tools5 = require("@kotori-bot/tools");
+var Api = class {
+  adapter;
+  constructor(adapter) {
+    this.adapter = adapter;
+  }
+  sendPrivateMsg(message, userId, ...extra) {
+    (0, import_tools5.none)(this, message, userId, extra);
+  }
+  sendGroupMsg(message, groupId, ...extra) {
+    (0, import_tools5.none)(this, message, groupId, extra, extra);
+  }
+  deleteMsg(messageId, ...extra) {
+    (0, import_tools5.none)(this, messageId, extra);
+  }
+  setGroupName(groupId, groupName, ...extra) {
+    (0, import_tools5.none)(this, groupId, groupName, extra);
+  }
+  setGroupAvatar(groupId, image, ...extra) {
+    (0, import_tools5.none)(this, groupId, image, extra);
+  }
+  setGroupAdmin(groupId, userId, enable, ...extra) {
+    (0, import_tools5.none)(this, groupId, userId, enable, extra);
+  }
+  setGroupCard(groupId, userId, card, ...extra) {
+    (0, import_tools5.none)(this, groupId, userId, card, extra);
+  }
+  setGroupBan(groupId, userId, time, ...extra) {
+    (0, import_tools5.none)(this, groupId, userId, time, extra);
+  }
+  sendGroupNotice(groupId, content, image, ...extra) {
+    (0, import_tools5.none)(this, groupId, content, image, extra);
+  }
+  setGroupKick(groupId, userId, ...extra) {
+    (0, import_tools5.none)(this, groupId, userId, extra);
+  }
+  setGroupLeave(groupId, ...extra) {
+    (0, import_tools5.none)(this, groupId, groupId, extra);
+  }
+};
+
+// src/service/cache.ts
+var import_fluoro = require("fluoro");
+var Cache = class extends import_fluoro.Service {
+  cache;
+  constructor(ctx) {
+    super(ctx, {}, "cache");
+  }
+  start() {
+    if (this.cache) return;
+    this.cache = /* @__PURE__ */ new Map();
+  }
+  stop() {
+    this.cache?.forEach((el) => el.clear());
+    this.cache?.clear();
+    delete this.cache;
+  }
+  getContainer() {
+    const key = this.ctx.identity ?? "root";
+    if (!this.cache.has(key)) this.cache.set(key, /* @__PURE__ */ new Map());
+    return this.cache.get(key);
+  }
+  get(prop) {
+    return this.getContainer().get(prop);
+  }
+  set(prop, value) {
+    this.getContainer().set(prop, value);
+  }
+};
+
+// src/components/core.ts
+var Core = class extends import_fluoro2.Context {
+  [Symbols.adapter] = /* @__PURE__ */ new Map();
+  [Symbols.bot] = /* @__PURE__ */ new Map();
+  constructor(config) {
+    super();
+    this.provide("config", new config_default(config));
+    this.mixin("config", ["config", "pkg"]);
+    this.provide("message", new message_default(this));
+    this.mixin("message", ["midware", "command", "regexp", "notify", "task"]);
+    this.provide("http", new import_tools6.Http({ validateStatus: () => true }));
+    this.inject("http");
+    this.provide("i18n", new import_i18n2.default({ lang: this.config.global.lang }));
+    this.inject("i18n");
+    this.service("cache", new Cache(this.extends()));
+  }
+};
+
+// src/utils/container.ts
+var import_tools7 = require("@kotori-bot/tools");
+var Container = class _Container {
+  constructor() {
+    (0, import_tools7.none)();
+  }
+  static instance = {};
+  static setInstance(ctx) {
+    this.instance = ctx;
+  }
+  static getInstance() {
+    return this.instance;
+  }
+  static getMixin() {
+    return Object.assign(
+      _Container.getInstance()
+      /* , Context */
+    );
+  }
+};
+
+// src/index.ts
+__reExport(src_exports, require("@kotori-bot/tools"));
+__reExport(src_exports, require("@kotori-bot/i18n"));
+__reExport(src_exports, require("tsukiko"));
+
+// src/utils/factory.ts
+function disposeFactory(ctx, dispose) {
+  ctx.once("dispose_module", (data) => {
+    if ((typeof data.instance === "object" ? data.instance.name : data.instance) !== ctx.identity) {
+      disposeFactory(ctx, dispose);
+      return;
+    }
+    dispose();
+  });
+}
+function cancelFactory() {
+  return {
+    get() {
+      return () => this.fn();
+    },
+    fn() {
+      this.value = true;
+    },
+    value: false
+  };
+}
+function formatFactory(i18n) {
+  return (template, data) => {
+    const params = data;
+    if (Array.isArray(params)) {
+      let str = i18n.locale(template);
+      params.forEach((value, index) => {
+        str = str.replaceAll(`{${index}}`, i18n.locale(typeof value === "string" ? value : String(value)));
+      });
+      return str;
+    }
+    Object.keys(params).forEach((key) => {
+      if (typeof params[key] !== "string") params[key] = String(params[key]);
+      params[key] = i18n.locale(params[key]);
+    });
+    return (0, import_tools8.stringTemp)(i18n.locale(template), params);
+  };
+}
+function sendMessageFactory(adapter, type, data) {
+  if ((data.type === 1 /* GROUP */ || type.includes("group")) && "groupId" in data) {
+    return (message) => {
+      adapter.api.sendGroupMsg(message, data.groupId, data.extra);
+    };
+  }
+  return (message) => {
+    adapter.api.sendPrivateMsg(message, data.userId, data.extra);
+  };
+}
+function quickFactory(send, i18n) {
+  return async (message) => {
+    const msg = await message;
+    if (!msg || msg instanceof CommandError) return;
+    if (typeof msg === "string") {
+      send(i18n.locale(msg));
+      return;
+    }
+    send(formatFactory(i18n)(...msg));
+  };
+}
+function isSameSender(adapter, data, session) {
+  return session.api.adapter.identity === adapter.identity && session.api.adapter.platform === adapter.platform && session.type === data.type && session.groupId === data.groupId && session.userId === data.userId && "messageId" in data && session.messageId !== data.messageId;
+}
+function promptFactory(quick, adapter, data) {
+  return (message) => new Promise((resolve2) => {
+    const handle = (session) => {
+      if (isSameSender(adapter, data, session)) {
+        resolve2(session.message);
+        return;
+      }
+      adapter.ctx.once("on_message", handle);
+    };
+    quick(message ?? "corei18n.template.prompt").then(() => adapter.ctx.once("on_message", handle));
+  });
+}
+function confirmFactory(quick, adapter, data) {
+  return (options) => new Promise((resolve2) => {
+    const handle = (session) => {
+      if (isSameSender(adapter, data, session)) {
+        resolve2(session.message === (options?.sure ?? "corei18n.template.confirm.sure"));
+        return;
+      }
+      adapter.ctx.once("on_message", handle);
     };
+    quick(options?.message ?? "corei18n.template.confirm").then(() => adapter.ctx.once("on_message", handle));
+  });
 }
-exports.formatFactory = formatFactory;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cancelFactory,
+  confirmFactory,
+  disposeFactory,
+  formatFactory,
+  promptFactory,
+  quickFactory,
+  sendMessageFactory
+});