@kotori-bot/core 1.5.1 → 1.6.0

package/README.md

@@ -1,16 +1,22 @@
 # @kotori-bot/core
 
-- Context
+It's Kotori Bot's core library, and it only used ecmascript standard (less than es2021), so you can use it in any environment that supports ecmascript standard (Such as node.js, browser, web worker, quick.js and more...).
+
+## Features
+
 - Symbols
-- Service
-- Modules
 - Core
 - Config
 - Message
+- Command
+- Session
+- Messages
+- Decorators
 - Adapter
 - Api
 - Elements
-- Cache
+- i18n (from `@kotori-bot/i18n`)
+- http (from `@kotori-bot/tools`)
 
 ## Reference
 

package/lib/app/config.d.ts

@@ -0,0 +1,32 @@
+import type { CoreConfig } from '../types';
+/** Meta information. */
+interface MetaInfo {
+    /** Program name */
+    name: string;
+    /** Program core version */
+    coreVersion: string;
+    /** Program loader version if exists */
+    loaderVersion?: string;
+    /** Program version if exists */
+    version?: string;
+    /** Program description */
+    description: string;
+    /** Program entry file */
+    main: string;
+    /**
+     *  Program license
+     *
+     *  @constant
+     */
+    license: 'GPL-3.0';
+    /** Program author */
+    author: string;
+}
+export declare class Config {
+    readonly config: CoreConfig;
+    readonly meta: MetaInfo;
+    constructor(config?: Omit<Partial<CoreConfig>, 'global'> & {
+        global?: Partial<CoreConfig['global']>;
+    });
+}
+export default Config;

package/lib/app/config.js

@@ -0,0 +1,65 @@
+
+/**
+ * @Package @kotori-bot/core
+ * @Version 1.6.0-rc.1
+ * @Author Arimura Sena <me@hotaru.icu>
+ * @Copyright 2024 Hotaru. All rights reserved.
+ * @License GPL-3.0
+ * @Link https://github.com/kotorijs/kotori
+ * @Date 2024/8/9 17:33:05
+ */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var config_exports = {};
+__export(config_exports, {
+  Config: () => Config,
+  default: () => config_default
+});
+module.exports = __toCommonJS(config_exports);
+var import_global = require("../global");
+class Config {
+  config;
+  meta;
+  constructor(config = {}) {
+    this.config = { ...import_global.DEFAULT_CORE_CONFIG, ...config };
+    this.config.global = { ...import_global.DEFAULT_CORE_CONFIG.global, ...this.config.global };
+    const pkg = typeof require === "function" ? require("../../package.json") : {
+      name: "@kotori-bot/core",
+      version: "BROWSER",
+      description: "",
+      author: "Arimura Sena <me@hotaru.icu>",
+      main: "lib/index.js"
+    };
+    this.meta = {
+      name: pkg.name,
+      description: pkg.description,
+      main: pkg.main,
+      license: "GPL-3.0",
+      author: pkg.author,
+      coreVersion: pkg.version
+    };
+    globalThis.kotori = this.meta;
+  }
+}
+var config_default = Config;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Config
+});

package/lib/app/core.d.ts

@@ -0,0 +1,138 @@
+import { Http } from '@kotori-bot/tools';
+import I18n from '@kotori-bot/i18n';
+import type { Parser } from 'tsukiko';
+import Context from 'fluoro';
+import Config from './config';
+import Message from './message';
+import type { AdapterClass } from '../types';
+import { Cache, type Api } from '../components';
+import { Symbols } from '../global';
+declare module 'fluoro' {
+    interface Context {
+        /**
+         * Adapter constructors list.
+         *
+         * @readonly
+         */
+        readonly [Symbols.adapter]: Core[typeof Symbols.adapter];
+        /**
+         * Bot instances list.
+         *
+         * @readonly
+         */
+        readonly [Symbols.bot]: Core[typeof Symbols.bot];
+        /**
+         * Core config.
+         *
+         * @readonly
+         */
+        readonly config: Config['config'];
+        /**
+         * Meta information.
+         *
+         * @readonly
+         */
+        readonly meta: Config['meta'];
+        /**
+         * Registered middlewares list.
+         *
+         * @readonly
+         */
+        readonly [Symbols.midware]: Message[typeof Symbols.midware];
+        /**
+         * Registered commands list.
+         *
+         * @readonly
+         */
+        readonly [Symbols.command]: Message[typeof Symbols.command];
+        /**
+         * Registered regexps list.
+         *
+         * @readonly
+         */
+        readonly [Symbols.regexp]: Message[typeof Symbols.regexp];
+        /**
+         * Registered scheduled tasks list.
+         *
+         * @readonly
+         */
+        readonly [Symbols.task]: Message[typeof Symbols.task];
+        /**
+         * Registered session filters list.
+         *
+         * @readonly
+         */
+        readonly [Symbols.filter]: Message[typeof Symbols.filter];
+        /**
+         * Session promises in progress list.
+         *
+         * @readonly
+         */
+        readonly [Symbols.promise]: Message[typeof Symbols.promise];
+        /**
+         * Register a message handled middleware.
+         *
+         * @param callback - Middleware callback
+         * @param priority - Middleware priority, default is 100
+         * @returns dispose function
+         */
+        midware: Message['midware'];
+        /**
+         * Register a command.
+         *
+         * @param template - Command template
+         * @param config - Command config, optional
+         * @returns Command instance
+         */
+        command: Message['command'];
+        /**
+         * Register a regexp.
+         *
+         * @param match - Regexp to match
+         * @param callback - Regexp callback
+         * @returns dispose function
+         */
+        regexp: Message['regexp'];
+        /**
+         * Register a scheduled task.
+         *
+         * @param options - Task options
+         * @param callback - Task callback
+         * @returns dispose function
+         */
+        task: Message['task'];
+        /**
+         * Register a session filter.
+         *
+         * @param option - Filter option
+         * @returns new context
+         */
+        filter: Message['filter'];
+        /**
+         * Send a notified message to the master of first bot instance at config.
+         *
+         * @experimental
+         */
+        notify: Message['notify'];
+        /**
+         * Send a message to all sessions on all bots.
+         *
+         * @experimental
+         */
+        boardcast: Message['boardcast'];
+        /** Http request methods */
+        http: Http;
+        /** International methods */
+        i18n: I18n;
+        /** Cache service */
+        cache: Cache;
+    }
+}
+export declare class Core extends Context {
+    readonly [Symbols.adapter]: Map<string, [AdapterClass, Parser<unknown>?]>;
+    readonly [Symbols.bot]: Map<string, Set<Api>>;
+    constructor(config?: ConstructorParameters<typeof Config>[0]);
+    start(): void;
+    stop(): void;
+}
+export default Core;

package/lib/{components → app}/core.js

@@ -1,12 +1,12 @@
 
 /**
  * @Package @kotori-bot/core
- * @Version 1.5.0
- * @Author Hotaru <biyuehuya@gmail.com>
+ * @Version 1.6.0-rc.1
+ * @Author Arimura Sena <me@hotaru.icu>
  * @Copyright 2024 Hotaru. All rights reserved.
  * @License GPL-3.0
  * @Link https://github.com/kotorijs/kotori
- * @Date 2024/6/7 11:22:22
+ * @Date 2024/8/9 17:33:05
  */
 
 "use strict";
@@ -45,25 +45,39 @@ __export(core_exports, {
 module.exports = __toCommonJS(core_exports);
 var import_tools = require("@kotori-bot/tools");
 var import_i18n = __toESM(require("@kotori-bot/i18n"));
-var import_fluoro = require("fluoro");
+var import_fluoro = __toESM(require("fluoro"));
 var import_config = __toESM(require("./config"));
 var import_message = __toESM(require("./message"));
-var import_service = require("../service");
+var import_components = require("../components");
 var import_global = require("../global");
-class Core extends import_fluoro.Context {
+class Core extends import_fluoro.default {
   [import_global.Symbols.adapter] = /* @__PURE__ */ new Map();
   [import_global.Symbols.bot] = /* @__PURE__ */ new Map();
   constructor(config) {
     super();
     this.provide("config", new import_config.default(config));
-    this.mixin("config", ["config", "pkg"]);
+    this.mixin("config", ["config", "meta"]);
     this.provide("message", new import_message.default(this));
-    this.mixin("message", ["midware", "command", "regexp", "notify", "task"]);
-    this.provide("http", new import_tools.Http({ validateStatus: () => true }));
+    this.mixin("message", [
+      "midware",
+      "command",
+      "regexp",
+      "notify",
+      "boardcast",
+      "task",
+      "filter",
+      import_global.Symbols.command,
+      import_global.Symbols.midware,
+      import_global.Symbols.task,
+      import_global.Symbols.filter,
+      import_global.Symbols.promise,
+      import_global.Symbols.regexp
+    ]);
+    this.provide("http", new import_tools.Http());
     this.inject("http");
     this.provide("i18n", new import_i18n.default({ lang: this.config.global.lang }));
     this.inject("i18n");
-    this.service("cache", new import_service.Cache(this.extends()));
+    this.service("cache", new import_components.Cache(this.extends("cache")));
   }
 }
 var core_default = Core;

package/lib/app/index.d.ts

@@ -0,0 +1 @@
+export * from './core';

package/lib/{service → app}/index.js

@@ -1,12 +1,12 @@
 
 /**
  * @Package @kotori-bot/core
- * @Version 1.5.0
- * @Author Hotaru <biyuehuya@gmail.com>
+ * @Version 1.6.0-rc.1
+ * @Author Arimura Sena <me@hotaru.icu>
  * @Copyright 2024 Hotaru. All rights reserved.
  * @License GPL-3.0
  * @Link https://github.com/kotorijs/kotori
- * @Date 2024/6/7 11:22:22
+ * @Date 2024/8/9 17:33:05
  */
 
 "use strict";
@@ -24,16 +24,10 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var service_exports = {};
-module.exports = __toCommonJS(service_exports);
-__reExport(service_exports, require("./adapter"), module.exports);
-__reExport(service_exports, require("./api"), module.exports);
-__reExport(service_exports, require("./elements"), module.exports);
-__reExport(service_exports, require("./cache"), module.exports);
+var app_exports = {};
+module.exports = __toCommonJS(app_exports);
+__reExport(app_exports, require("./core"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ...require("./adapter"),
-  ...require("./api"),
-  ...require("./elements"),
-  ...require("./cache")
+  ...require("./core")
 });

package/lib/{components → app}/message.d.ts

@@ -1,7 +1,7 @@
-import { type Context } from 'fluoro';
+import type { Context } from 'fluoro';
 import { CronJob } from 'cron';
-import { type CommandConfig, type MidwareCallback, type RegexpCallback, MessageQuick, TaskCallback } from '../types';
-import { Command } from '../utils/command';
+import { type CommandConfig, type MidwareCallback, type RegexpCallback, type TaskCallback, type FilterOption, type TaskOptions } from '../types';
+import { Filter, Command, type SessionMsg } from '../components';
 import { Symbols } from '../global';
 interface MidwareData {
     callback: MidwareCallback;
@@ -15,19 +15,20 @@ export declare class Message {
     readonly [Symbols.midware]: Set<MidwareData>;
     readonly [Symbols.command]: Set<Command>;
     readonly [Symbols.regexp]: Set<RegexpData>;
+    readonly [Symbols.task]: Set<CronJob>;
+    readonly [Symbols.filter]: Map<string, Filter>;
+    readonly [Symbols.promise]: Map<string, ((value: SessionMsg['message']) => void)[]>;
     private handleMidware;
     private handleRegexp;
     private handleCommand;
     private readonly ctx;
     constructor(ctx: Context);
     midware(callback: MidwareCallback, priority?: number): () => boolean;
-    command<T extends string>(template: T, config?: CommandConfig): Command<T, {}>;
+    command<T extends string>(template: T, config?: CommandConfig): Command<T, {}, "all">;
     regexp(match: RegExp, callback: RegexpCallback): () => boolean;
-    notify(message: MessageQuick): void;
-    task(options: string | {
-        cron: string;
-        start?: boolean;
-        timeZone?: string;
-    }, callback: TaskCallback): CronJob<null, null>;
+    boardcast(): void;
+    notify(): void;
+    task(options: TaskOptions, callback: TaskCallback): () => boolean;
+    filter(option: FilterOption): Context;
 }
 export default Message;

package/lib/app/message.js

@@ -0,0 +1,253 @@
+
+/**
+ * @Package @kotori-bot/core
+ * @Version 1.6.0-rc.1
+ * @Author Arimura Sena <me@hotaru.icu>
+ * @Copyright 2024 Hotaru. All rights reserved.
+ * @License GPL-3.0
+ * @Link https://github.com/kotorijs/kotori
+ * @Date 2024/8/9 17:33:05
+ */
+
+"use strict";
+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 __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);
+var message_exports = {};
+__export(message_exports, {
+  Message: () => Message,
+  default: () => message_default
+});
+module.exports = __toCommonJS(message_exports);
+var import_cron = require("cron");
+var import_types = require("../types");
+var import_internal = require("../utils/internal");
+var import_components = require("../components");
+var import_error = require("../utils/error");
+var import_global = require("../global");
+var import_node_crypto = require("node:crypto");
+var import_utils = __toESM(require("../decorators/utils"));
+class Message {
+  [import_global.Symbols.midware] = /* @__PURE__ */ new Set();
+  [import_global.Symbols.command] = /* @__PURE__ */ new Set();
+  [import_global.Symbols.regexp] = /* @__PURE__ */ new Set();
+  [import_global.Symbols.task] = /* @__PURE__ */ new Set();
+  [import_global.Symbols.filter] = /* @__PURE__ */ new Map();
+  [import_global.Symbols.promise] = /* @__PURE__ */ new Map();
+  handleMidware(session) {
+    const { api } = session;
+    api.adapter.status.receivedMsg += 1;
+    const setup = Array.from(this[import_global.Symbols.midware].values()).sort((first, last) => first.priority - last.priority).map(({ callback }) => callback).reverse().reduce(
+      (first, last) => {
+        const next = () => {
+          first(() => {
+          }, session);
+        };
+        return () => {
+          last(next, session);
+        };
+      },
+      (_, session2) => {
+        this.handleCommand(session2);
+        this.handleRegexp(session2);
+      }
+    );
+    setup(() => {
+    }, session);
+  }
+  async handleRegexp(session) {
+    for (const data of this[import_global.Symbols.regexp]) {
+      const result = session.message.match(data.match);
+      if (!result) continue;
+      const cancel = (0, import_internal.cancelFactory)();
+      this.ctx.emit("before_regexp", {
+        session,
+        regexp: data.match,
+        raw: session.message.toString(),
+        cancel: cancel.get()
+      });
+      if (cancel.value) continue;
+      session.quick(data.callback(result, session));
+      this.ctx.emit("regexp", { result, session, regexp: data.match, raw: session.message.toString() });
+    }
+  }
+  async handleCommand(session) {
+    const prefix = session.api.adapter.config.commandPrefix ?? this.ctx.config.global.commandPrefix;
+    for (const cmd of this[import_global.Symbols.command]) {
+      for (const shortcut of cmd.meta.shortcut) {
+        if (!session.message.startsWith(shortcut)) continue;
+        session.message = session.message.replace(shortcut, `${prefix}${cmd.meta.root}`);
+      }
+    }
+    if (!session.message.startsWith(prefix)) return;
+    const raw = session.message.slice(prefix.length);
+    if (!raw) return;
+    let matched;
+    for (const cmd of this[import_global.Symbols.command]) {
+      if (matched || !cmd.meta.action) continue;
+      const result2 = import_components.Command.run(raw, cmd.meta);
+      if (result2 instanceof import_error.CommandError && result2.value.type === "unknown") continue;
+      matched = cmd;
+      const cancel = (0, import_internal.cancelFactory)();
+      this.ctx.emit("before_command", { command: cmd, result: result2, raw, session, cancel: cancel.get() });
+      if (cancel.value) continue;
+      if (result2 instanceof import_error.CommandError) continue;
+      try {
+        const executed = await cmd.meta.action({ args: result2.args, options: result2.options }, session);
+        if (executed instanceof import_error.CommandError) {
+          this.ctx.emit("command", { command: cmd, result: executed, raw, session });
+          continue;
+        }
+        if (executed !== void 0) session.quick(executed);
+        this.ctx.emit("command", {
+          command: cmd,
+          result: executed instanceof import_error.CommandError ? result2 : executed,
+          raw,
+          session
+        });
+      } catch (error) {
+        this.ctx.emit("command", { command: matched, result: new import_error.CommandError({ type: "error", error }), raw, session });
+      }
+    }
+    if (matched) return;
+    const result = new import_error.CommandError({ type: "unknown", input: raw });
+    this.ctx.emit("command", { command: new import_components.Command(""), result, raw, session });
+  }
+  ctx;
+  constructor(ctx) {
+    this.ctx = ctx;
+    this.ctx.on("ready", () => {
+      for (const bots of this.ctx[import_global.Symbols.bot].values()) {
+        for (const bot of bots) {
+          for (const key of ["sendPrivateMsg", "sendGroupMsg", "sendChannelMsg"]) {
+            ;
+            bot[key] = new Proxy(bot[key], {
+              apply: (target, thisArg, argArray) => {
+                const [message, id1, id2] = argArray;
+                const cancel = (0, import_internal.cancelFactory)();
+                this.ctx.emit("before_send", {
+                  api: bot,
+                  message,
+                  cancel: cancel.get(),
+                  target: key === "sendPrivateMsg" ? { type: import_types.MessageScope.PRIVATE, userId: id1 } : key === "sendGroupMsg" ? { type: import_types.MessageScope.GROUP, groupId: id1 } : { type: import_types.MessageScope.CHANNEL, guildId: id1, channelId: id2 }
+                });
+                if (cancel.value) return;
+                Reflect.apply(target, thisArg, argArray);
+              }
+            });
+          }
+        }
+      }
+    });
+    this.ctx.on("on_message", (session) => this.handleMidware(session));
+    this.ctx.on("before_send", (data) => {
+      const { api } = data;
+      api.adapter.status.sentMsg += 1;
+      api.adapter.status.lastMsgTime = /* @__PURE__ */ new Date();
+    });
+    const test = (identity, session) => {
+      for (const [key, filter] of this[import_global.Symbols.filter].entries()) {
+        if (identity.toString().includes(key)) return filter.test(session);
+      }
+      return true;
+    };
+    this.ctx.on("before_command", (data) => {
+      const { identity } = (0, import_internal.getCommandMeta)(data.command) ?? {};
+      if (identity && !test(identity, data.session)) {
+        data.cancel();
+        const result = new import_error.CommandError({ type: "unknown", input: data.raw });
+        this.ctx.emit("command", { command: new import_components.Command(""), result, raw: data.raw, session: data.session });
+      }
+    });
+    this.ctx.on("before_regexp", (data) => {
+      const { callback } = Array.from(this[import_global.Symbols.regexp]).find(({ match }) => match === data.regexp) ?? {};
+      if (!callback) return;
+      const { identity } = (0, import_internal.getRegExpMeta)(callback) ?? {};
+      if (identity && !test(identity, data.session)) data.cancel();
+    });
+    this.midware((next, session) => {
+      const resolves = this[import_global.Symbols.promise].get(session.id);
+      if (resolves) {
+        for (const resolve of resolves) resolve(session.message);
+        return;
+      }
+      next();
+    }, 10);
+    import_utils.default.setup(this.ctx);
+  }
+  midware(callback, priority = 100) {
+    (0, import_internal.setMidwareMeta)(callback, { identity: this.ctx.identity, priority });
+    const data = { callback, priority };
+    this[import_global.Symbols.midware].add(data);
+    return () => this[import_global.Symbols.midware].delete(data);
+  }
+  command(template, config) {
+    const command = new import_components.Command(template, config);
+    this[import_global.Symbols.command].add(command);
+    (0, import_internal.setCommandMeta)(command, { identity: this.ctx.identity, ...command.meta });
+    return command;
+  }
+  regexp(match, callback) {
+    (0, import_internal.setRegExpMeta)(callback, { identity: this.ctx.identity, match });
+    const data = { match, callback };
+    this[import_global.Symbols.regexp].add(data);
+    return () => this[import_global.Symbols.regexp].delete(data);
+  }
+  boardcast() {
+  }
+  notify() {
+    const mainAdapterIdentity = Object.keys(this.ctx.config.adapter)[0];
+    for (const apis of this.ctx[import_global.Symbols.bot].values()) {
+      for (const api of apis) {
+        if (api.adapter.identity !== mainAdapterIdentity) continue;
+      }
+    }
+  }
+  task(options, callback) {
+    const [baseOption, extraOptions] = typeof options === "string" ? [options, {}] : [options.cron, options];
+    const task = new import_cron.CronJob(
+      baseOption,
+      () => callback(this.ctx),
+      null,
+      extraOptions.start ?? true,
+      extraOptions.timeZone
+    );
+    (0, import_internal.setTaskMeta)(task, { identity: this.ctx.identity, task, options });
+    this[import_global.Symbols.task].add(task);
+    return () => this[import_global.Symbols.task].delete(task);
+  }
+  filter(option) {
+    const filterId = (0, import_node_crypto.randomUUID)().slice(0, 12).replaceAll("-", "");
+    this[import_global.Symbols.filter].set(filterId, new import_components.Filter(option));
+    return this.ctx.extends(void 0, `${this.ctx.identity?.toString()}_${filterId}`);
+  }
+}
+var message_default = Message;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Message
+});