@kotori-bot/core 1.1.0

package/lib/base/command.d.ts

@@ -0,0 +1,20 @@
+import { CommandAccess, type CommandAction, type CommandConfig, type CommandData } from '../types';
+export declare class Command {
+    private static parseOption;
+    private static parseArgs;
+    static readonly dataList: CommandData[];
+    static parse(input: string): void;
+    private template;
+    constructor(template: string, config?: CommandConfig);
+    readonly data: CommandData;
+    private requiredParamMatch;
+    private optionalParamMatch;
+    private parseTemplate;
+    alias(alias: string | string[]): this;
+    scope(scope: CommandConfig['scope']): this;
+    access(access: CommandAccess): this;
+    option(name: string, template: string): this;
+    action(callback: CommandAction): this;
+    help(text: string): this;
+}
+export default Command;

package/lib/base/command.js

@@ -0,0 +1,217 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Command = void 0;
+const tools_1 = require("@kotori-bot/tools");
+const errror_1 = require("../utils/errror");
+const commandExtra_1 = __importDefault(require("../utils/commandExtra"));
+function parseTemplateParam(content) {
+    const { '0': root, '1': defaultValue } = content.split('=');
+    const { '0': argName, '1': argType } = root.split(':');
+    let handleDefault = defaultValue || undefined;
+    let handleArg = 'string';
+    if (argType === 'number') {
+        handleArg = argType;
+        if (handleDefault !== undefined)
+            handleDefault = parseInt(handleDefault, 10);
+    }
+    return {
+        name: argName || 'content',
+        type: handleArg,
+        default: handleDefault,
+    };
+}
+function error(type, data) {
+    return new errror_1.CommandError(undefined, new commandExtra_1.default({ type, ...data }));
+}
+class Command {
+    static parseOption(expectedOptions, input) {
+        const realityOptions = {};
+        let cmd = input;
+        [...`${cmd} `.matchAll(/\s-([a-z]+)(=(\w+)|)\s?\b/g)].forEach(el => {
+            cmd = cmd.replace(el[0], '');
+            const key = el[1];
+            let val = el[3] || undefined;
+            expectedOptions.forEach(option => {
+                if (option.realname !== key)
+                    return;
+                if (val !== undefined && val !== '') {
+                    if (option.type === 'number' && typeof val !== 'number') {
+                        val = parseInt(val, 10);
+                        if (Number.isNaN(val)) {
+                            throw error('option_error', {
+                                expected: 'number',
+                                reality: 'string,',
+                                target: option.realname,
+                            });
+                        }
+                    }
+                }
+                val = option.default || '';
+                realityOptions[option.name] = val;
+            });
+        });
+        return [realityOptions, cmd];
+    }
+    static parseArgs(expectedArgs, inputHandel) {
+        const realityArgs = [];
+        let current = '';
+        let inBackslash = false;
+        let inQuote = false;
+        `${inputHandel} `.split('').forEach(char => {
+            if (inBackslash) {
+                inBackslash = false;
+                current += char;
+            }
+            else if (char === ' ' && !inQuote) {
+                if (!current)
+                    return;
+                const arg = expectedArgs[realityArgs.length];
+                if (!arg) {
+                    throw error('arg_many', { expected: expectedArgs.length, reality: realityArgs.length + 1 });
+                }
+                let val = current.trim();
+                if (arg.type === 'number' && typeof val !== 'number') {
+                    val = parseInt(current, 10);
+                    if (Number.isNaN(val)) {
+                        throw error('arg_error', { expected: 'number', reality: 'string', target: arg.name });
+                    }
+                }
+                realityArgs.push(val);
+                current = '';
+            }
+            else if (char === '"' || char === "'") {
+                // dont fix it for big and small quote
+                inQuote = !inQuote;
+            }
+            else if (char === '\\') {
+                inBackslash = true;
+            }
+            else {
+                current += char;
+            }
+        });
+        if (!inQuote && !inBackslash)
+            return realityArgs;
+        throw error('syntax', { index: inputHandel.lastIndexOf(inQuote ? '"' : '\\'), char: inQuote ? '"' : '\\' });
+    }
+    static dataList = [];
+    static parse(input) {
+        this.dataList.forEach(command => {
+            if (!command.action)
+                return;
+            const cmd = input
+                .replace(/(\s+)/g, ' ')
+                .replace(/("\s?")|('\s?')/g, '')
+                .trim();
+            if (!`${input} `.startsWith(`${command.root} `)) {
+                const alias = command.alias.filter(el => `${input} `.startsWith(`${el} `));
+                if (alias.length <= 0)
+                    return;
+                // cmd = (input.split(alias[0])[1] ?? '').trim();
+            }
+            const tempArray = this.parseOption(command.options, cmd);
+            const realityOptions = tempArray[0];
+            const realityArgs = this.parseArgs(command.args, (0, tools_1.stringRightSplit)(tempArray[1], cmd.split(' ')[0]));
+            const expectedLength = command.args.filter(el => !el.optional).length;
+            if (expectedLength > realityArgs.length) {
+                throw error('arg_few', { expected: expectedLength, reality: realityArgs.length });
+            }
+            if (command.args.length > realityArgs.length) {
+                let index = realityArgs.length;
+                while (index < command.args.length) {
+                    const arg = command.args[index];
+                    if (arg.default === undefined)
+                        break;
+                    realityArgs.push(arg.default);
+                    index += 1;
+                }
+            }
+            throw error('parsed', { action: command.action, args: realityArgs, options: realityOptions });
+        });
+        throw error('unknown', { input });
+    }
+    template;
+    constructor(template, config) {
+        this.template = template;
+        this.data = Object.assign(this.data, config);
+        Command.dataList.push(this.data);
+        this.parseTemplate();
+    }
+    data = {
+        root: '',
+        alias: [],
+        scope: 'all',
+        access: 0 /* CommandAccess.MEMBER */,
+        args: [],
+        options: [],
+    };
+    requiredParamMatch = /<(.*?)>/g;
+    optionalParamMatch = /\[(.*?)]/g;
+    parseTemplate() {
+        const { '0': root, '1': description } = this.template
+            .trim()
+            .replace(/\s{2,}/g, ' ')
+            .split(' - ');
+        this.data.description = description;
+        const requiredIndex = root.indexOf(' <');
+        const optionalIndex = root.indexOf(' [');
+        let requiredStr = '';
+        let optionalStr = '';
+        if (requiredIndex > 0) {
+            this.data.root = root.substring(0, requiredIndex);
+            requiredStr = root.substring(requiredIndex);
+            const newOptionalIndex = requiredStr.indexOf(' [');
+            if (newOptionalIndex > 0) {
+                optionalStr = requiredStr.substring(newOptionalIndex);
+                requiredStr = requiredStr.substring(0, newOptionalIndex);
+            }
+        }
+        else if (optionalIndex > 0) {
+            this.data.root = root.substring(0, optionalIndex);
+            optionalStr = root.substring(optionalIndex);
+        }
+        else {
+            this.data.root = root;
+        }
+        [...requiredStr.matchAll(this.requiredParamMatch)].forEach(content => {
+            this.data.args.push({ optional: false, rest: false, ...parseTemplateParam(content[1]) });
+        });
+        [...optionalStr.matchAll(this.optionalParamMatch)].forEach(content => {
+            this.data.args.push({ optional: true, rest: false, ...parseTemplateParam(content[1]) });
+        });
+    }
+    alias(alias) {
+        if (typeof alias === 'string')
+            this.data.alias.push(alias);
+        else
+            this.data.alias.push(...alias);
+        return this;
+    }
+    scope(scope) {
+        this.data.scope = scope;
+        return this;
+    }
+    access(access) {
+        this.data.access = access;
+        return this;
+    }
+    option(name, template) {
+        const { '0': root, '1': description } = template.trim().split(' ');
+        const handleData = parseTemplateParam(root);
+        this.data.options.push({ realname: handleData.name, description, ...handleData, name });
+        return this;
+    }
+    action(callback) {
+        this.data.action = callback;
+        return this;
+    }
+    help(text) {
+        this.data.help = text;
+        return this;
+    }
+}
+exports.Command = Command;
+exports.default = Command;

package/lib/base/core.d.ts

@@ -0,0 +1,30 @@
+import { obj } from '@kotori-bot/tools';
+import { Parser } from 'tsukiko';
+import { type AdapterConstructor, type BaseDir, type GlobalConfig, type GlobalOptions, type KotoriConfig, type PackageInfo } from '../types';
+import type Api from '../components/api';
+export declare const defaultConfig: {
+    baseDir: {
+        root: string;
+        modules: string;
+    };
+    config: {
+        global: {
+            lang: "ja_JP" | "en_US" | "zh_TW" | "zh_CN";
+            'command-prefix': string;
+        };
+        adapter: {};
+    };
+    options: {
+        env: string;
+    };
+};
+export declare class Core {
+    protected readonly adapterStack: obj<[AdapterConstructor, Parser<unknown>?]>;
+    protected readonly botStack: obj<Api[]>;
+    readonly baseDir: BaseDir;
+    readonly config: GlobalConfig;
+    readonly options: GlobalOptions;
+    readonly package: PackageInfo;
+    constructor(config?: KotoriConfig);
+}
+export default Core;

package/lib/base/core.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Core = exports.defaultConfig = void 0;
+const tools_1 = require("@kotori-bot/tools");
+const path_1 = __importDefault(require("path"));
+const types_1 = require("../types");
+const errror_1 = require("../utils/errror");
+const consts_1 = require("../consts");
+exports.defaultConfig = {
+    baseDir: {
+        root: path_1.default.resolve(consts_1.DEFAULT_ROOT_DIR),
+        modules: path_1.default.resolve(consts_1.DEFAULT_MODULES_DIR),
+    },
+    config: {
+        global: {
+            lang: consts_1.DEFAULT_LANG,
+            'command-prefix': consts_1.DEFAULT_COMMAND_PREFIX,
+        },
+        adapter: {},
+    },
+    options: {
+        env: consts_1.DEFAULT_ENV,
+    },
+};
+class Core {
+    adapterStack = {};
+    botStack = {};
+    baseDir;
+    config;
+    options;
+    package;
+    constructor(config) {
+        const info = (0, tools_1.loadConfig)(path_1.default.join(__dirname, '../../package.json'));
+        if (!info || Object.values(info).length === 0)
+            throw new errror_1.CoreError('Cannot find kotori-bot package.json');
+        const result = types_1.packageInfoSchema.parseSafe(info);
+        if (!result.value)
+            throw new errror_1.CoreError(`File package.json format error: ${result.error.message}`);
+        this.package = result.data;
+        const handle = types_1.kotoriConfigSchema.parseSafe(config);
+        if (!handle.value)
+            throw new errror_1.CoreError('Unexpected error in parsing config (basedir,kotori,options)');
+        this.baseDir = handle.data.baseDir;
+        this.config = handle.data.config;
+        this.options = handle.data.options;
+    }
+}
+exports.Core = Core;
+exports.default = Core;

package/lib/base/events.d.ts

@@ -0,0 +1,13 @@
+import type { EventType, EventCallback } from '../types';
+import Core from './core';
+type EventBeforeKeys<T> = T extends `before_${infer U}` ? U : never;
+export declare class Events extends Core {
+    private eventStack;
+    emit<T extends keyof EventType>(type: T, data: Omit<EventType[T], 'type'>): void;
+    on<T extends keyof EventType>(type: T, callback: EventCallback<T>): void;
+    before<T extends EventBeforeKeys<keyof EventType>>(type: T, callback: EventCallback<`before_${T}`>): void;
+    once<T extends keyof EventType>(type: T, callback: EventCallback<T>): void;
+    off<T extends keyof EventType>(type: T, callback: EventCallback<T>): void;
+    offAll<T extends keyof EventType>(type: T): void;
+}
+export default Events;

package/lib/base/events.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Events = void 0;
+const core_1 = __importDefault(require("./core"));
+class Events extends core_1.default {
+    eventStack = [];
+    emit(type, data) {
+        const session = Object.assign(data, { type });
+        this.eventStack.filter(el => el.type === type).forEach(el => el.callback(session));
+    }
+    on(type, callback) {
+        // if (this.eventStack.filter(el => el.callback === callback && el.type === type).length > 0) return false;
+        this.eventStack.push({ type, callback: callback });
+    }
+    before(type, callback) {
+        this.on(`before_${type}`, callback);
+    }
+    once(type, callback) {
+        const removeSelf = data => {
+            const handleArr = this.eventStack.filter(el => el.type !== type && el.callback !== removeSelf);
+            this.eventStack = handleArr;
+            callback(data);
+        };
+        this.on(type, removeSelf);
+    }
+    off(type, callback) {
+        const handleArr = this.eventStack.filter(el => el.callback !== callback && el.type !== type);
+        // if (this.eventStack.length === handleArr.length) return false;
+        this.eventStack = handleArr;
+    }
+    offAll(type) {
+        const handleArr = this.eventStack.filter(el => el.type !== type);
+        // if (this.eventStack.length === handleArr.length) return false;
+        this.eventStack = handleArr;
+    }
+}
+exports.Events = Events;
+exports.default = Events;

package/lib/base/filter.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/base/filter.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/base/internal.d.ts

@@ -0,0 +1,34 @@
+import Message from './message';
+export declare class Internal extends Message {
+    private getModules;
+    private setModules;
+    private getAdapters;
+    private setAdapters;
+    private getBots;
+    private setBots;
+    private getCommands;
+    private setCommands;
+    private getCommandData;
+    private setCommandData;
+    private getMidwares;
+    private setMidwares;
+    private getRegexps;
+    private setRegexps;
+    get internal(): {
+        getModules: () => import("..").ModuleData[];
+        setModules: (key: number, value: import("..").ModuleData) => void;
+        getAdapters: () => import("@kotori-bot/tools").obj<[import("..").AdapterConstructor, (import("tsukiko").Parser<unknown> | undefined)?]>;
+        setAdapters: (key: string, value: [import("..").AdapterConstructor, (import("tsukiko").Parser<unknown> | undefined)?]) => void;
+        getBots: () => import("@kotori-bot/tools").obj<import("..").Api[]>;
+        setBots: (key: string, value: import("..").Api[]) => void;
+        getCommands: () => import("..").CommandStack[];
+        setCommands: (key: number, value: import("..").CommandStack) => void;
+        getCommandData: () => import("..").CommandData[];
+        setCommandData: (key: number, value: import("..").CommandData) => void;
+        getMidwares: () => import("..").MidwareStack[];
+        setMidwares: (key: number, value: import("..").MidwareStack) => void;
+        getRegexps: () => import("..").RegexpStack[];
+        setRegexps: (key: number, value: import("..").RegexpStack) => void;
+    };
+}
+export default Internal;

package/lib/base/internal.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Internal = void 0;
+const tools_1 = require("@kotori-bot/tools");
+const message_1 = __importDefault(require("./message"));
+const command_1 = __importDefault(require("./command"));
+class Internal extends message_1.default {
+    getModules() {
+        return this.moduleStack;
+    }
+    setModules(key, value) {
+        this.moduleStack[key] = value;
+    }
+    getAdapters() {
+        return this.adapterStack;
+    }
+    setAdapters(key, value) {
+        this.adapterStack[key] = value;
+    }
+    getBots() {
+        return this.botStack;
+    }
+    setBots(key, value) {
+        this.botStack[key] = value;
+    }
+    getCommands() {
+        return this.commandStack;
+    }
+    setCommands(key, value) {
+        this.commandStack[key] = value;
+    }
+    getCommandData() {
+        (0, tools_1.none)(this);
+        return command_1.default.dataList;
+    }
+    setCommandData(key, value) {
+        (0, tools_1.none)(this);
+        command_1.default.dataList[key] = value;
+    }
+    getMidwares() {
+        return this.midwareStack;
+    }
+    setMidwares(key, value) {
+        this.midwareStack[key] = value;
+    }
+    getRegexps() {
+        return this.regexpStack;
+    }
+    setRegexps(key, value) {
+        this.regexpStack[key] = value;
+    }
+    get internal() {
+        const getModules = () => this.getModules();
+        const setModules = (key, value) => this.setModules(key, value);
+        const getAdapters = () => this.getAdapters();
+        const setAdapters = (key, value) => this.setAdapters(key, value);
+        const getBots = () => this.getBots();
+        const setBots = (key, value) => this.setBots(key, value);
+        const getCommands = () => this.getCommands();
+        const setCommands = (key, value) => this.setCommands(key, value);
+        const getCommandData = () => this.getCommandData();
+        const setCommandData = (key, value) => this.setCommandData(key, value);
+        const getMidwares = () => this.getMidwares();
+        const setMidwares = (key, value) => this.setMidwares(key, value);
+        const getRegexps = () => this.getRegexps();
+        const setRegexps = (key, value) => this.setRegexps(key, value);
+        return {
+            getModules,
+            setModules,
+            getAdapters,
+            setAdapters,
+            getBots,
+            setBots,
+            getCommands,
+            setCommands,
+            getCommandData,
+            setCommandData,
+            getMidwares,
+            setMidwares,
+            getRegexps,
+            setRegexps,
+        };
+    }
+}
+exports.Internal = Internal;
+exports.default = Internal;

package/lib/base/message.d.ts

@@ -0,0 +1,18 @@
+import { CommandConfig, MessageRaw, MessageScope, MidwareStack, CommandStack, RegexpStack, MidwareCallback, RegexpCallback } from '../types';
+import Modules from './modules';
+import Command from './command';
+export declare class Message extends Modules {
+    protected readonly midwareStack: MidwareStack[];
+    protected readonly commandStack: CommandStack[];
+    protected readonly regexpStack: RegexpStack[];
+    private handleMessageEvent;
+    private handleMidwaresEvent;
+    private handleUnloadModuleEvent;
+    protected registeMessageEvent(): void;
+    midware(callback: MidwareCallback, priority?: number): boolean;
+    command(template: string, config?: CommandConfig): Command;
+    regexp(match: RegExp, callback: RegexpCallback): boolean;
+    boardcast(type: MessageScope, message: MessageRaw): void;
+    notify(message: MessageRaw): void;
+}
+export default Message;