@kotori-bot/core 1.5.1 → 1.6.0

package/lib/types/message.d.ts

@@ -1,241 +1,176 @@
-import Tsu, { TsuError } from 'tsukiko';
-import type I18n from '@kotori-bot/i18n';
-import type { Context, EventsList } from 'fluoro';
-import type CommandError from '../utils/commandError';
-import type { Api, Elements } from '../service';
-import { Command } from '../utils/command';
+import type { Context } from 'fluoro';
+import type { CommandError } from '../utils/error';
+import type { Api, Command, MessageList, MessageSingle, SessionMsg } from '../components';
+import type { CommandAction, CommandArgType } from './command';
 declare module 'fluoro' {
     interface EventsMapping {
-        midwares(data: EventDataMidwares): void;
-        before_parse(data: EventDataBeforeParse): void;
-        parse(data: EventDataParse): void;
         before_command(data: EventDataBeforeCommand): void;
+        /**
+         * Event after command running.
+         *
+         * @param data - Event data
+         */
         command(data: EventDataCommand): void;
+        /**
+         * Event before regexp.
+         *
+         * @param data - Event data
+         */
+        before_regexp(data: EventDataBeforeRegexp): void;
+        /**
+         * Event after regexp.
+         *
+         * @param data - Event data
+         */
         regexp(data: EventDataRegexp): void;
+        /**
+         * Event before message send.
+         *
+         * @param data - Event data
+         */
         before_send(data: EventDataBeforeSend): void;
+        /**
+         * Event after message send.
+         *
+         * @param data - Event data
+         */
         send(data: EventDataSend): void;
-        on_message(session: EventDataPrivateMsg | EventDataGroupMsg): void;
-        on_recall(session: EventDataPrivateRecall | EventDataGroupRecall): void;
-        on_request(session: EventDataPrivateRequest | EventDataGroupRequest): void;
-        on_private_add(session: EventDataPrivateAdd): void;
-        on_group_increase(session: EventDataGroupIncrease): void;
-        on_group_decrease(session: EventDataGroupDecrease): void;
-        on_group_admin(session: EventDataGroupAdmin): void;
-        on_group_ban(session: EventDataGroupBan): void;
     }
 }
-export declare const enum CommandAccess {
+/** User access */
+export declare enum UserAccess {
+    /** Normal member */
     MEMBER = 0,
+    /** Manager (group owner and group mangers) */
     MANGER = 1,
+    /** Admin (master of bot instance) */
     ADMIN = 2
 }
-export type ArgsOrigin = CommandArgType[];
-export type OptsOrigin = Record<string, CommandArgType>;
-export type CommandAction<Args = ArgsOrigin, Opts = OptsOrigin> = (data: {
-    args: Args;
-    options: Opts;
-}, session: SessionData) => MessageQuick;
-export type CommandArgType = string | number | boolean;
-export declare const commandArgTypeSignSchema: import("tsukiko").UnionParser<[import("tsukiko").UnionParser<[import("tsukiko").LiteralParser<"string">, import("tsukiko").LiteralParser<"number">]>, import("tsukiko").LiteralParser<"boolean">]>;
-export type CommandArgTypeSign = Tsu.infer<typeof commandArgTypeSignSchema>;
-export interface CommandConfig {
-    alias?: string[];
-    scope?: MessageScope | 'all';
-    access?: CommandAccess;
-    help?: string;
-    action?: CommandAction;
-}
-interface CommandParseResult {
-    option_error: {
-        expected: CommandArgTypeSign;
-        reality: CommandArgTypeSign;
-        target: string;
+/** Message scope (session type) */
+export declare enum MessageScope {
+    /** Private message */
+    PRIVATE = 0,
+    /** Group message */
+    GROUP = 1,
+    /** Channel message */
+    CHANNEL = 2
+}
+export interface MessageMapping {
+    text: {
+        text: string;
     };
-    arg_error: {
-        expected: CommandArgTypeSign;
-        reality: CommandArgTypeSign;
-        index: number;
+    mention: {
+        userId: string;
     };
-    arg_many: {
-        expected: number;
-        reality: number;
+    mentionAll: {};
+    image: {
+        content: string;
     };
-    arg_few: CommandParseResult['arg_many'];
-    syntax: {
-        index: number;
-        char: string;
+    voice: {
+        content: string;
     };
-    unknown: {
-        input: string;
+    audio: {
+        content: string;
     };
-}
-export interface CommandResult extends CommandParseResult {
-    error: {
-        error: unknown;
+    video: {
+        content: string;
     };
-    data_error: {
-        target: string | number;
+    file: {
+        content: string;
     };
-    res_error: {
-        error: TsuError;
+    location: {
+        latitude: number;
+        longitude: number;
+        title: string;
+        content: string;
     };
-    num_error: null;
-    no_access_manger: null;
-    no_access_admin: null;
-    disable: null;
-    exists: {
-        target: string;
+    reply: {
+        messageId: string;
     };
-    no_exists: CommandResult['exists'];
 }
-type CommandResultNoArgs = 'num_error' | 'no_access_manger' | 'no_access_admin' | 'disable';
-export type CommandResultExtra = {
-    [K in keyof CommandResult]: {
-        type: K;
-    } & (K extends CommandResultNoArgs ? object : CommandResult[K]);
-};
-export type SessionData = EventsList['on_message'];
-export declare enum MessageScope {
-    PRIVATE = 0,
-    GROUP = 1
-}
-export type MessageRaw = string;
-export type MessageQuickReal = [string, (CommandArgType | undefined)[] | Record<string, CommandArgType | undefined>] | MessageRaw | CommandError | void;
+export type Message<T extends keyof MessageMapping = keyof MessageMapping> = MessageSingle<T | 'text'> | MessageList<T | 'text'> | string;
+export type MessageQuickReal = [string, (Message | CommandArgType | undefined)[] | Record<string, CommandArgType | undefined>] | Message | void;
 export type MessageQuick = MessageQuickReal | Promise<MessageQuickReal>;
-export type MidwareCallback = (next: () => void, session: SessionData) => MessageQuick;
-export type RegexpCallback = (match: RegExpMatchArray, session: SessionData) => MessageQuick;
+export type MidwareCallback = (next: () => void | Promise<void>, session: SessionMsg) => MessageQuick;
+export type RegexpCallback = (match: RegExpMatchArray, session: SessionMsg) => MessageQuick;
 export type TaskCallback = (ctx: Context) => void;
-export type EventApiType = {
-    [K in keyof EventsList]: EventsList[K] extends EventDataApiBase ? EventsList[K] : never;
+export type TaskOptions = string | {
+    cron: string;
+    start?: boolean;
+    timeZone?: string;
 };
-export declare const eventDataTargetIdSchema: import("tsukiko").UnionParser<[import("tsukiko").NumberParser, import("tsukiko").StringParser]>;
-export type EventDataTargetId = Tsu.infer<typeof eventDataTargetIdSchema>;
-interface EventDataMidwares {
-    isPass: boolean;
-    session: SessionData;
-}
-interface EventDataBeforeParse {
-    session: SessionData;
-    raw: string;
-}
-interface EventDataParse {
-    session: SessionData;
+/** Event data before command running */
+interface EventDataBeforeCommand {
+    /** Session instance */
+    session: SessionMsg;
+    /** Target command instance */
     command: Command;
+    /** Raw text message */
     raw: string;
+    /** Parsed result, command error or command data (args and options) */
     result: CommandError | Parameters<CommandAction>[0];
+    /** Cancel the command running */
     cancel(): void;
 }
-interface EventDataBeforeCommand {
-    session: SessionData;
-    raw: string;
-    cancel(): void;
-}
+/** Event data after command running */
 interface EventDataCommand {
-    session: SessionData;
+    /** Session instance */
+    session: SessionMsg;
+    /** Raw text message */
     raw: string;
+    /** Target command instance */
     command: Command;
-    result: EventDataParse['result'] | MessageQuick;
+    /** Command running result, running error or back message */
+    result: EventDataBeforeCommand['result'] | MessageQuick;
+}
+/** Event data before regexp running */
+interface EventDataBeforeRegexp {
+    /** Session instance */
+    session: SessionMsg;
+    /** Raw text message */
+    raw: string;
+    /** Target regexp instance */
+    regexp: RegExp;
+    /** Cancel the regexp running */
+    cancel(): void;
 }
+/** Event data after regexp running */
 interface EventDataRegexp {
-    session: SessionData;
+    /** Session instance */
+    session: SessionMsg;
+    /** Raw text message */
     raw: string;
+    /** Target regexp instance */
     regexp: RegExp;
+    /** Match result */
     result: RegExpMatchArray;
 }
+/** Event data before message sending */
 interface EventDataBeforeSend {
+    /** Api instance  */
     api: Api;
-    message: MessageRaw;
-    messageType: MessageScope;
-    targetId: EventDataTargetId;
+    /** Message to send */
+    message: Message;
+    /** Target user or group or channel */
+    target: {
+        type: MessageScope.PRIVATE;
+        userId: string;
+    } | {
+        type: MessageScope.GROUP;
+        groupId: string;
+    } | {
+        type: MessageScope.CHANNEL;
+        channelId: string;
+        guildId: string;
+    };
+    /** Cancel the message sending */
     cancel(): void;
 }
+/** Event data after message sending */
 interface EventDataSend {
+    /** Api instance  */
     api: Api;
-    messageId: EventDataTargetId;
-}
-interface SessionDataSender {
-    nickname: string;
-    sex: 'male' | 'female' | 'unknown';
-    age: number;
-}
-export interface EventDataApiBase {
-    type?: MessageScope;
-    api: Api;
-    el: Elements;
-    userId: EventDataTargetId;
-    groupId?: EventDataTargetId;
-    operatorId?: EventDataTargetId;
-    i18n: I18n;
-    send(message: MessageRaw): void;
-    format(template: string, data: Record<string, CommandArgType | undefined> | (CommandArgType | undefined)[]): string;
-    quick(message: MessageQuick): void;
-    prompt(message?: MessageRaw): Promise<MessageRaw>;
-    confirm(options?: {
-        message: MessageRaw;
-        sure: MessageRaw;
-    }): Promise<boolean>;
-    error<T extends Exclude<keyof CommandResult, CommandResultNoArgs>>(type: T, data: CommandResult[T] extends object ? CommandResult[T] : never): CommandError;
-    error<T extends CommandResultNoArgs>(type: T): CommandError;
-    extra?: unknown;
-}
-interface EventDataPrivateMsg extends EventDataApiBase {
-    type: MessageScope.PRIVATE;
-    messageId: EventDataTargetId;
-    message: MessageRaw;
-    sender: SessionDataSender;
-}
-interface EventDataGroupMsg extends EventDataApiBase {
-    type: MessageScope.GROUP;
-    messageId: EventDataTargetId;
-    message: MessageRaw;
-    sender: SessionDataSender & {
-        level: string;
-        role: 'owner' | 'admin' | 'member';
-        title: string;
-    };
-    groupId: EventDataTargetId;
-}
-interface EventDataPrivateRecall extends EventDataApiBase {
-    type: MessageScope.PRIVATE;
-    messageId: EventDataTargetId;
-}
-interface EventDataGroupRecall extends EventDataApiBase {
-    messageId: EventDataTargetId;
-    operatorId: EventDataTargetId;
-    groupId: EventDataTargetId;
-}
-interface EventDataPrivateRequest extends EventDataApiBase {
-    type: MessageScope.PRIVATE;
-    userId: EventDataTargetId;
-}
-interface EventDataGroupRequest extends EventDataApiBase {
-    type: MessageScope.GROUP;
-    userId: EventDataTargetId;
-    operatorId: EventDataTargetId;
-    groupId: EventDataTargetId;
-}
-interface EventDataPrivateAdd extends EventDataApiBase {
-    userId: EventDataTargetId;
-}
-interface EventDataGroupIncrease extends EventDataApiBase {
-    userId: EventDataTargetId;
-    operatorId: EventDataTargetId;
-    groupId: EventDataTargetId;
-}
-interface EventDataGroupDecrease extends EventDataApiBase {
-    userId: EventDataTargetId;
-    operatorId: EventDataTargetId;
-    groupId: EventDataTargetId;
-}
-interface EventDataGroupAdmin extends EventDataApiBase {
-    userId: EventDataTargetId;
-    operation: 'set' | 'unset';
-    groupId: EventDataTargetId;
-}
-interface EventDataGroupBan extends EventDataApiBase {
-    userId: EventDataTargetId | 0;
-    operatorId: EventDataTargetId;
-    time: number | -1;
-    groupId: EventDataTargetId;
+    /** Message id */
+    messageId: string;
 }
 export {};

package/lib/types/message.js

@@ -1,20 +1,18 @@
 
 /**
  * @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";
-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)
@@ -28,44 +26,27 @@ var __copyProps = (to, from, except, desc) => {
   }
   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, {
-  CommandAccess: () => CommandAccess,
   MessageScope: () => MessageScope,
-  commandArgTypeSignSchema: () => commandArgTypeSignSchema,
-  eventDataTargetIdSchema: () => eventDataTargetIdSchema
+  UserAccess: () => UserAccess
 });
 module.exports = __toCommonJS(message_exports);
-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 || {});
-const 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 UserAccess = /* @__PURE__ */ ((UserAccess2) => {
+  UserAccess2[UserAccess2["MEMBER"] = 0] = "MEMBER";
+  UserAccess2[UserAccess2["MANGER"] = 1] = "MANGER";
+  UserAccess2[UserAccess2["ADMIN"] = 2] = "ADMIN";
+  return UserAccess2;
+})(UserAccess || {});
 var MessageScope = /* @__PURE__ */ ((MessageScope2) => {
   MessageScope2[MessageScope2["PRIVATE"] = 0] = "PRIVATE";
   MessageScope2[MessageScope2["GROUP"] = 1] = "GROUP";
+  MessageScope2[MessageScope2["CHANNEL"] = 2] = "CHANNEL";
   return MessageScope2;
 })(MessageScope || {});
-const eventDataTargetIdSchema = import_tsukiko.default.Union([import_tsukiko.default.Number(), import_tsukiko.default.String()]);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  CommandAccess,
   MessageScope,
-  commandArgTypeSignSchema,
-  eventDataTargetIdSchema
+  UserAccess
 });