@kotori-bot/core 1.2.0 → 1.3.0

package/README.md

@@ -1,5 +1,17 @@
 # @kotori-bot/core
 
+- Context
+- Symbols
+- Service
+- Modules
+- Core
+- Config
+- Message
+- Adapter
+- Api
+- Elements
+- Cache
+
 ## Reference
 
 - [Kotori Docs](https://kotori.js.org/)

package/lib/components/core.d.ts

@@ -1,28 +1,26 @@
-import { Events, Http } from '@kotori-bot/tools';
+import { Http } from '@kotori-bot/tools';
 import I18n from '@kotori-bot/i18n';
 import type { Parser } from 'tsukiko';
 import { Context, Symbols } from '../context';
 import Config from './config';
 import Message from './message';
-import Modules from './modules';
-import type { AdapterClass, EventsMapping } from '../types';
-import type { Api } from '../service';
+import type { AdapterClass } from '../types';
+import { Cache, type Api } from '../service';
 declare module '../context' {
-    interface Context extends Events<EventsMapping> {
+    interface Context {
         readonly [Symbols.adapter]: Core[typeof Symbols.adapter];
         readonly [Symbols.bot]: Core[typeof Symbols.bot];
         readonly config: Config['config'];
         readonly pkg: Config['pkg'];
-        use(modules: Parameters<Modules['use']>[0], config?: Parameters<Modules['use']>[1]): Promise<void>;
-        dispose(modules: Parameters<Modules['dispose']>[0]): void;
         readonly [Symbols.midware]: Message[typeof Symbols.midware];
         readonly [Symbols.command]: Message[typeof Symbols.command];
         readonly [Symbols.regexp]: Message[typeof Symbols.regexp];
-        midware(callback: Parameters<Message['midware']>[0], priority?: Parameters<Message['midware']>[1]): () => void;
-        command(template: Parameters<Message['command']>[0], config?: Parameters<Message['command']>[1]): ReturnType<Message['command']>;
-        regexp(match: Parameters<Message['regexp']>[0], callback: Parameters<Message['regexp']>[1]): () => void;
+        midware: Message['midware'];
+        command: Message['command'];
+        regexp: Message['regexp'];
         http: Http;
         i18n: I18n;
+        cache: Cache;
     }
 }
 export declare class Core extends Context {

package/lib/components/core.js

@@ -9,7 +9,7 @@ const i18n_1 = __importDefault(require("@kotori-bot/i18n"));
 const context_1 = require("../context");
 const config_1 = __importDefault(require("./config"));
 const message_1 = __importDefault(require("./message"));
-const modules_1 = __importDefault(require("./modules"));
+const service_1 = require("../service");
 class Core extends context_1.Context {
     [context_1.Symbols.adapter] = new Map();
     [context_1.Symbols.bot] = new Map();
@@ -17,17 +17,13 @@ class Core extends context_1.Context {
         super();
         this.provide('config', new config_1.default(config));
         this.mixin('config', ['config', 'pkg']);
-        this.provide('events', new tools_1.Events());
-        this.mixin('events', ['emit', 'on', 'once', 'off', 'offAll']);
-        this.provide('modules', new modules_1.default(this));
-        this.mixin('modules', ['use', 'dispose']);
         this.provide('message', new message_1.default(this));
         this.mixin('message', ['midware', 'command', 'regexp']);
         this.provide('http', new tools_1.Http({ validateStatus: () => true }));
         this.inject('http');
         this.provide('i18n', new i18n_1.default({ lang: this.config.global.lang }));
         this.inject('i18n');
-        this.inject('i18n');
+        this.service('cache', new service_1.Cache(this.extends()));
     }
 }
 exports.Core = Core;

package/lib/components/message.d.ts

@@ -1,4 +1,4 @@
-import { Context, Symbols } from '../context';
+import { type Context, Symbols } from '../context';
 import { type CommandConfig, type MidwareCallback, type RegexpCallback } from '../types';
 import { Command } from '../utils/command';
 interface MidwareData {

package/lib/components/message.js

@@ -9,17 +9,6 @@ const context_1 = require("../context");
 const factory_1 = require("../utils/factory");
 const command_1 = require("../utils/command");
 const commandError_1 = __importDefault(require("../utils/commandError"));
-function objectTempFactory(i18n) {
-    return (obj) => {
-        const result = obj;
-        Object.keys(result).forEach((key) => {
-            if (!result[key] || typeof result[key] !== 'string')
-                return;
-            result[key] = i18n.locale(result[key]);
-        });
-        return result;
-    };
-}
 class Message {
     [context_1.Symbols.midware] = new Set();
     [context_1.Symbols.command] = new Set();
@@ -60,57 +49,51 @@ class Message {
             return;
         const params = {
             session,
-            command: (0, tools_1.stringRightSplit)(session.message, prefix)
+            raw: (0, tools_1.stringRightSplit)(session.message, prefix)
         };
         this.ctx.emit('before_parse', params);
         const cancel = (0, factory_1.cancelFactory)();
-        const cmdParams = {
-            scope: session.type,
-            access: session.userId === session.api.adapter.config.master ? 2 /* CommandAccess.ADMIN */ : 0 /* CommandAccess.MEMBER */
-        };
-        this.ctx.emit('before_command', { cancel: cancel.get(), ...params, ...cmdParams });
+        this.ctx.emit('before_command', { cancel: cancel.get(), ...params });
         if (cancel.value)
             return;
-        let matched = false;
+        let matched;
         this[context_1.Symbols.command].forEach(async (cmd) => {
             if (matched || !cmd.meta.action)
                 return;
-            const result = command_1.Command.run(params.command, cmd.meta);
+            const result = command_1.Command.run(params.raw, cmd.meta);
             if (result instanceof commandError_1.default && result.value.type === 'unknown')
                 return;
-            matched = true;
-            this.ctx.emit('parse', { result, ...params, cancel: cancel.get() });
+            matched = cmd;
+            this.ctx.emit('parse', { command: cmd, result, ...params, cancel: cancel.get() });
             if (cancel.value || result instanceof commandError_1.default)
                 return;
             try {
                 const executed = await cmd.meta.action({ args: result.args, options: result.options }, session);
                 if (executed instanceof commandError_1.default) {
-                    this.ctx.emit('command', { result, ...params, ...cmdParams });
+                    this.ctx.emit('command', { command: cmd, result: executed, ...params });
                     return;
                 }
-                if (executed !== undefined) {
-                    session.send(Array.isArray(executed)
-                        ? (0, tools_1.stringTemp)(session.i18n.locale(executed[0]), objectTempFactory(session.i18n)(executed[1]))
-                        : session.i18n.locale(executed));
-                }
+                if (executed !== undefined)
+                    session.quick(executed);
                 this.ctx.emit('command', {
+                    command: cmd,
                     result: executed instanceof commandError_1.default ? result : executed,
-                    ...params,
-                    ...cmdParams
+                    ...params
                 });
             }
             catch (error) {
                 this.ctx.emit('command', {
+                    command: matched,
                     result: new commandError_1.default({ type: 'error', error }),
-                    ...params,
-                    ...cmdParams
+                    ...params
                 });
             }
         });
         if (matched)
             return;
         this.ctx.emit('parse', {
-            result: new commandError_1.default({ type: 'unknown', input: params.command }),
+            command: new command_1.Command(''),
+            result: new commandError_1.default({ type: 'unknown', input: params.raw }),
             ...params,
             cancel: cancel.get()
         });
@@ -118,7 +101,7 @@ class Message {
     ctx;
     constructor(ctx) {
         this.ctx = ctx;
-        this.ctx.on('on_message', (data) => this.handleMidware(data));
+        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) => {

package/lib/components/modules.js

@@ -35,22 +35,31 @@ function checkConfig(schema, config) {
 class Modules {
     handleExports(identity, ctx, exports, config) {
         /* before handle */
-        const { lang, config: schema, default: defaults, main, Main } = exports.default;
+        const { lang, inject, config: schema, default: defaults, main, Main } = exports.default;
         if (lang)
             this.ctx.i18n.use(Array.isArray(lang) ? (0, path_1.resolve)(...lang) : (0, path_1.resolve)(lang));
         /* handle */
+        /* service */
         if (isServiceConsructor(defaults)) {
-            /* adapter */
+            return undefined;
+        }
+        /* adapter */
+        if (isAdapterClass(defaults)) {
             const adapterName = identity.split(consts_1.ADAPTER_PREFIX)[1];
-            // const databaseName = moduleName.split(DATABASE_PREFIX)[1];
-            if (adapterName && isAdapterClass(defaults)) {
+            if (adapterName)
                 this.ctx[context_1.Symbols.adapter].set(adapterName, [defaults, schema]);
-            } /* else if (databaseName && isDatabaseClass(default)) {
-              service and database
-            } */
             return undefined;
         }
         /* plugin */
+        if (inject && Array.isArray(inject)) {
+            inject.forEach((identity) => {
+                ctx[context_1.Symbols.container].forEach((service, name) => {
+                    if (!(service instanceof service_1.Service) || service.identity !== identity)
+                        return;
+                    ctx.inject(name);
+                });
+            });
+        }
         const moduleConfig = checkConfig(schema, config);
         if (moduleConfig instanceof tsukiko_1.TsuError)
             return new errror_1.ModuleError(`Config format of module ${identity} is error: ${moduleConfig.message}`);

package/lib/consts.d.ts

@@ -3,10 +3,12 @@ export declare const PLUGIN_PREFIX = "kotori-plugin-";
 export declare const DATABASE_PREFIX = "kotori-plugin-database-";
 export declare const ADAPTER_PREFIX = "kotori-plugin-adapter-";
 export declare const CUSTOM_PREFIX = "kotori-plugin-custom-";
+export declare const DEFAULT_PORT = 720;
 export declare const DEFAULT_CORE_CONFIG: {
     global: {
         lang: "en_US" | "en_GB" | "en_AU" | "zh_CN" | "zh_HK" | "zh_TW" | "zh_SG" | "es_ES" | "es_MX" | "ar_EG" | "ar_AE" | "ru_RU" | "fr_FR" | "fr_CA" | "de_DE" | "de_CH" | "it_IT" | "it_CH" | "hi_IN" | "pt_BR" | "pt_PT" | "tr_TR" | "ja_JP" | "id_ID" | "uk_UA" | "vi_VN" | "th_TH" | "sv_SE" | "nb_NO" | "da_DK" | "fi_FI" | "he_IL" | "sk_SK" | "bg_BG" | "lt_LT" | "sl_SI" | "sr_RS" | "mk_MK" | "sq_AL" | "et_EE" | "mt_MT";
         'command-prefix': string;
+        port: number;
     };
     adapter: {};
     plugin: {};

package/lib/consts.js

@@ -1,16 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_CORE_CONFIG = exports.CUSTOM_PREFIX = exports.ADAPTER_PREFIX = exports.DATABASE_PREFIX = exports.PLUGIN_PREFIX = exports.OFFICIAL_MODULES_SCOPE = void 0;
+exports.DEFAULT_CORE_CONFIG = exports.DEFAULT_PORT = exports.CUSTOM_PREFIX = exports.ADAPTER_PREFIX = exports.DATABASE_PREFIX = exports.PLUGIN_PREFIX = exports.OFFICIAL_MODULES_SCOPE = void 0;
 const i18n_1 = require("@kotori-bot/i18n");
 exports.OFFICIAL_MODULES_SCOPE = '@kotori-bot/';
 exports.PLUGIN_PREFIX = 'kotori-plugin-';
 exports.DATABASE_PREFIX = `${exports.PLUGIN_PREFIX}database-`;
 exports.ADAPTER_PREFIX = `${exports.PLUGIN_PREFIX}adapter-`;
 exports.CUSTOM_PREFIX = `${exports.PLUGIN_PREFIX}custom-`;
+exports.DEFAULT_PORT = 720;
 exports.DEFAULT_CORE_CONFIG = {
     global: {
         lang: i18n_1.DEFAULT_LANG,
-        'command-prefix': '/'
+        'command-prefix': '/',
+        port: exports.DEFAULT_PORT
     },
     adapter: {},
     plugin: {}

package/lib/context/context.d.ts

@@ -1,4 +1,5 @@
 import Symbols from './symbols';
+import './events';
 interface obj {
     [propName: string | number | symbol]: any;
 }
@@ -25,10 +26,10 @@ export declare class Context implements ContextImpl {
     readonly [Symbols.table]: Map<string, string[]>;
     root: Context;
     constructor(root?: Context);
-    get(prop: string): obj | undefined;
+    get<T = obj | undefined>(prop: string): T;
     inject<T extends Keys>(prop: T): void;
     provide<T extends obj>(prop: string, value: T): void;
     mixin<K extends Keys>(prop: string, keys: K[]): void;
-    extends<T extends obj = {}>(meta?: T, identity?: string): Context;
+    extends<T extends obj = object>(meta?: T, identity?: string): Context;
 }
 export default Context;

package/lib/context/context.js

@@ -4,13 +4,37 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Context = void 0;
+/*
+ * @Author: Hotaru biyuehuya@gmail.com
+ * @Blog: https://hotaru.icu
+ * @Date: 2024-02-07 13:44:38
+ * @LastEditors: Hotaru biyuehuya@gmail.com
+ * @LastEditTime: 2024-02-21 10:38:39
+ */
+const tools_1 = require("@kotori-bot/tools");
 const symbols_1 = __importDefault(require("./symbols"));
+const modules_1 = __importDefault(require("./modules"));
+const handler = (value, ctx) => {
+    if (!value || typeof value !== 'object' || !(value.ctx instanceof Context))
+        return value;
+    return new Proxy(value, {
+        get(target, prop, receiver) {
+            if (prop === 'ctx')
+                return ctx;
+            return Reflect.get(target, prop, receiver);
+        }
+    });
+};
 class Context {
     [symbols_1.default.container] = new Map();
     [symbols_1.default.table] = new Map();
     root;
     constructor(root) {
         this.root = root || this;
+        this.provide('events', root ? root.get('events') : new tools_1.Events());
+        this.mixin('events', ['emit', 'on', 'once', 'off', 'offAll']);
+        this.provide('modules', new modules_1.default(this));
+        this.mixin('modules', ['load', 'unload', 'service']);
     }
     get(prop) {
         return this[symbols_1.default.container].get(prop);
@@ -35,8 +59,9 @@ class Context {
             if (this[key] || !instance[key])
                 return;
             this[key] = instance[key];
-            if (typeof this[key] === 'function')
-                this[key] = this[key].bind(instance);
+            if (typeof this[key] === 'function') {
+                this[key] = this[key]?.bind(instance);
+            }
         });
     }
     extends(meta, identity) {
@@ -46,31 +71,23 @@ class Context {
             if (typeof this[key] === 'function')
                 delete metaHandle[key];
         });
-        const handler = (value, ctx) => {
-            if (!value || typeof value !== 'object' || !value.ctx)
-                return value;
-            return new Proxy(value, {
-                get(target, prop, receiver) {
-                    if (prop === 'ctx')
-                        return ctx;
-                    return Reflect.get(target, prop, receiver);
-                }
-            });
-        };
         /* set proxy */
         const ctx = new Proxy(new Context(this.root), {
             get: (target, prop) => {
                 if (prop === 'identity')
                     return identity ?? this.identity ?? 'sub';
                 if (target[prop])
-                    return target[prop];
+                    return handler(target[prop], ctx);
                 let value;
                 this[symbols_1.default.table].forEach((keys, key) => {
                     if (value || (typeof prop === 'string' && !keys.includes(prop)))
                         return;
-                    value = ctx[symbols_1.default.container].get(key)[prop];
+                    const instance = ctx[symbols_1.default.container].get(key);
+                    if (!instance)
+                        return;
+                    value = instance[prop];
                     if (typeof value === 'function')
-                        value = value.bind(ctx[symbols_1.default.container].get(key));
+                        value = value.bind(instance);
                 });
                 if (value !== undefined)
                     return value;

package/lib/context/events.d.ts

@@ -0,0 +1,18 @@
+import { Events } from '@kotori-bot/tools';
+declare module './context' {
+    interface Context {
+        emit: Events<EventsMapping>['emit'];
+        parallel: Events<EventsMapping>['parallel'];
+        on: Events<EventsMapping>['on'];
+        once: Events<EventsMapping>['once'];
+        off: Events<EventsMapping>['off'];
+        offAll: Events<EventsMapping>['offAll'];
+    }
+}
+export type EventsList = {
+    [K in keyof EventsMapping]: Parameters<EventsMapping[K]>[1] extends never | undefined | null ? Parameters<EventsMapping[K]>[0] : [...Parameters<EventsMapping[K]>];
+};
+export interface EventsMapping {
+    ready(): void;
+    dispose(): void;
+}

package/lib/context/events.js

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

package/lib/context/index.d.ts

@@ -1,2 +1,5 @@
 export * from './context';
+export * from './events';
+export * from './modules';
+export * from './service';
 export * from './symbols';

package/lib/context/index.js

@@ -15,4 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./context"), exports);
+__exportStar(require("./events"), exports);
+__exportStar(require("./modules"), exports);
+__exportStar(require("./service"), exports);
 __exportStar(require("./symbols"), exports);

package/lib/context/modules.d.ts

@@ -0,0 +1,39 @@
+import { type Context } from './context';
+import { Service } from './service';
+type ModuleInstanceClass = new (ctx: Context, config: ModuleConfig) => void;
+type ModuleInstanceFunction = (ctx: Context, config: ModuleConfig) => void;
+export interface ModuleExport {
+    name?: string;
+    main?: ModuleInstanceFunction;
+    Main?: ModuleInstanceClass;
+    default?: ModuleInstanceFunction | ModuleInstanceClass;
+    inject?: string[];
+    config?: ModuleConfig;
+}
+export interface ModuleConfig {
+    filter: object;
+}
+declare module './events' {
+    interface EventsMapping {
+        ready_module(data: EventDataModule): void;
+        dispose_module(data: EventDataModule): void;
+    }
+}
+declare module './context' {
+    interface Context {
+        load: Modules['load'];
+        unload: Modules['unload'];
+        service: Modules['service'];
+    }
+}
+interface EventDataModule {
+    instance: ModuleExport | ModuleInstanceFunction | ModuleInstanceClass;
+}
+export declare class Modules {
+    private readonly ctx;
+    constructor(ctx: Context);
+    load(instance: EventDataModule['instance']): void;
+    unload(instance: EventDataModule['instance']): void;
+    service(name: string, instance: Service): void;
+}
+export default Modules;

package/lib/context/modules.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Modules = void 0;
+/* eslint import/no-dynamic-require: 0 */
+/* eslint global-require: 0 */
+const tools_1 = require("@kotori-bot/tools");
+const symbols_1 = require("./symbols");
+const service_1 = require("./service");
+function handleFunction(func, ctx, config) {
+    func(ctx, config);
+}
+function handleCconstructor(Class, ctx, config) {
+    (0, tools_1.none)(new Class(ctx, config));
+}
+const DEFAULT_MODULE_CONFIG = { filter: {} };
+class Modules {
+    ctx;
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    load(instance) {
+        const ctx = this.ctx.extends({}, !this.ctx.identity && typeof instance === 'object' ? instance.name : this.ctx.identity);
+        if (instance instanceof Function) {
+            if ((0, tools_1.isClass)(instance))
+                handleCconstructor(instance, ctx, DEFAULT_MODULE_CONFIG);
+            else
+                instance(ctx, DEFAULT_MODULE_CONFIG);
+            this.ctx.emit('ready_module', { instance });
+            return;
+        }
+        const { main, Main, inject, default: defaults, config } = instance;
+        if (Array.isArray(inject)) {
+            inject.forEach((identity) => {
+                ctx[symbols_1.Symbols.container].forEach((service, name) => {
+                    if (!(service instanceof service_1.Service) || service.identity !== identity)
+                        return;
+                    ctx.inject(name);
+                });
+            });
+        }
+        if (defaults) {
+            if ((0, tools_1.isClass)(defaults))
+                handleCconstructor(defaults, ctx, config ?? DEFAULT_MODULE_CONFIG);
+            else
+                handleFunction(defaults, ctx, config ?? DEFAULT_MODULE_CONFIG);
+        }
+        else if (main) {
+            handleFunction(main, ctx, config ?? DEFAULT_MODULE_CONFIG);
+        }
+        else if (Main) {
+            handleCconstructor(Main, ctx, config ?? DEFAULT_MODULE_CONFIG);
+        }
+        this.ctx.emit('ready_module', { instance });
+    }
+    unload(instance) {
+        this.ctx.emit('dispose_module', { instance });
+    }
+    service(name, instance) {
+        this.ctx.provide(name, instance);
+        this.ctx.on('ready', () => this.ctx.get(name).start());
+        this.ctx.on('dispose', () => this.ctx.get(name).stop());
+    }
+}
+exports.Modules = Modules;
+exports.default = Modules;

package/lib/context/service.d.ts

@@ -0,0 +1,16 @@
+import { Context } from './context';
+interface ServiceImpl<T extends object = object> {
+    readonly identity: string;
+    readonly config: T;
+    start(): void;
+    stop(): void;
+}
+export declare abstract class Service<T extends object = object> implements ServiceImpl<T> {
+    readonly ctx: Context;
+    readonly config: T;
+    readonly identity: string;
+    constructor(ctx: Context, config: T, identity: string);
+    start(): void;
+    stop(): void;
+}
+export default Service;

package/lib/context/service.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Service = void 0;
+const tools_1 = require("@kotori-bot/tools");
+class Service {
+    ctx;
+    config;
+    identity;
+    constructor(ctx, config, identity) {
+        this.ctx = ctx;
+        this.config = config;
+        this.identity = identity;
+    }
+    start() {
+        return (0, tools_1.none)(this);
+    }
+    stop() {
+        return (0, tools_1.none)(this);
+    }
+}
+exports.Service = Service;
+exports.default = Service;

package/lib/context/symbols.d.ts

@@ -2,7 +2,6 @@ export declare class Symbols {
     static readonly container: unique symbol;
     static readonly table: unique symbol;
     static readonly containerKey: (prop: string) => symbol;
-    static readonly service: unique symbol;
     static readonly adapter: unique symbol;
     static readonly bot: unique symbol;
     static readonly midware: unique symbol;

package/lib/context/symbols.js

@@ -6,7 +6,7 @@ class Symbols {
     static table = Symbol.for('kotori.context.table');
     static containerKey = (prop) => Symbol.for(`kotori.context.container.${prop}`);
     /* custom */
-    static service = Symbol.for('kotori.core.service');
+    // static readonly service = Symbol.for('kotori.core.service');
     static adapter = Symbol.for('kotori.core.adapter');
     static bot = Symbol.for('kotori.core.bot');
     static midware = Symbol.for('kotori.core.midware');

package/lib/context/test.d.ts

@@ -0,0 +1,6 @@
+import { Cache } from '../service/cache';
+declare module './context' {
+    interface Context {
+        cache: Cache;
+    }
+}

package/lib/context/test.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const symbols_1 = require("./symbols");
+const cache_1 = require("../service/cache");
+const context_1 = require("./context");
+class K extends context_1.Context {
+}
+const ctx = new K();
+ctx.provide('cache', new cache_1.Cache(ctx));
+const ctx2 = ctx.extends({}, 'tt');
+ctx2.inject('cache');
+console.log(ctx2[symbols_1.Symbols.container].get('cache').ctx.identity, ctx2.cache.ctx.identity, ctx[symbols_1.Symbols.container].get('cache').ctx.identity, ctx2.get('cache').ctx.identity);

package/lib/index.d.ts

@@ -8,4 +8,5 @@ export * from './utils/container';
 export * from './consts';
 export * from './types';
 export * from '@kotori-bot/tools';
+export * from '@kotori-bot/i18n';
 export * from 'tsukiko';

package/lib/index.js

@@ -14,6 +14,13 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+/*
+ * @Author: Hotaru biyuehuya@gmail.com
+ * @Blog: https://hotaru.icu
+ * @Date: 2024-02-07 13:44:38
+ * @LastEditors: Hotaru biyuehuya@gmail.com
+ * @LastEditTime: 2024-02-07 14:47:23
+ */
 __exportStar(require("./context"), exports);
 __exportStar(require("./components"), exports);
 __exportStar(require("./service"), exports);
@@ -24,4 +31,5 @@ __exportStar(require("./utils/container"), exports);
 __exportStar(require("./consts"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("@kotori-bot/tools"), exports);
+__exportStar(require("@kotori-bot/i18n"), exports);
 __exportStar(require("tsukiko"), exports);

package/lib/service/adapter.d.ts

@@ -1,7 +1,6 @@
 import type Api from './api';
-import { Context } from '../context';
-import { EventDataApiBase, EventsList, EventDataTargetId, AdapterConfig } from '../types';
-import Service from './service';
+import { Context, EventsList } from '../context';
+import { EventDataApiBase, EventDataTargetId, AdapterConfig } from '../types';
 import Elements from './elements';
 type EventApiType = {
     [K in keyof EventsList]: EventsList[K] extends EventDataApiBase ? EventsList[K] : never;
@@ -14,8 +13,9 @@ interface AdapterStatus {
     sentMsg: number;
     offlineTimes: number;
 }
-interface AdapterImpl<T extends Api = Api> extends Service {
+interface AdapterImpl<T extends Api = Api> {
     readonly ctx: Context;
+    readonly config: AdapterConfig;
     readonly platform: string;
     readonly selfId: EventDataTargetId;
     readonly identity: string;
@@ -23,12 +23,15 @@ interface AdapterImpl<T extends Api = Api> extends Service {
     readonly elements: Elements;
     readonly status: AdapterStatus;
 }
-export declare abstract class Adapter<T extends Api = Api> extends Service implements AdapterImpl<T> {
+export declare abstract class Adapter<T extends Api = Api> implements AdapterImpl<T> {
     constructor(ctx: Context, config: AdapterConfig, identity: string, Api: new (adapter: Adapter) => T, el?: Elements);
+    abstract handle(...data: unknown[]): void;
+    abstract start(): void;
+    abstract stop(): void;
     abstract send(action: string, params?: object): void | object | Promise<unknown> | null | undefined;
     protected online(): void;
     protected offline(): void;
-    protected session<N extends keyof EventApiType>(type: N, data: Omit<EventApiType[N], 'api' | 'send' | 'i18n' | 'quick' | 'el' | 'error'>): void;
+    protected session<N extends keyof EventApiType>(type: N, data: Omit<EventApiType[N], 'api' | 'send' | 'i18n' | 'format' | 'quick' | 'prompt' | 'confirm' | 'el' | 'error'>): void;
     readonly ctx: Context;
     readonly config: AdapterConfig;
     readonly identity: string;

package/lib/service/adapter.js

@@ -7,7 +7,6 @@ exports.Adapter = void 0;
 const tools_1 = require("@kotori-bot/tools");
 const context_1 = require("../context");
 const types_1 = require("../types");
-const service_1 = __importDefault(require("./service"));
 const elements_1 = __importDefault(require("./elements"));
 const factory_1 = require("../utils/factory");
 const commandError_1 = __importDefault(require("../utils/commandError"));
@@ -35,8 +34,8 @@ function setProxy(api, ctx) {
     });
     return proxy;
 }
-function sendMessageFactory(adapter, data) {
-    if (data.type === types_1.MessageScope.GROUP && 'groupId' in data) {
+function sendMessageFactory(adapter, type, data) {
+    if ((data.type === types_1.MessageScope.GROUP || type.includes('group')) && 'groupId' in data) {
         return (message) => {
             adapter.api.sendGroupMsg(message, data.groupId, data.extra);
         };
@@ -45,6 +44,24 @@ function sendMessageFactory(adapter, data) {
         adapter.api.sendPrivateMsg(message, data.userId, data.extra);
     };
 }
+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, tools_1.stringTemp)(i18n.locale(template), params);
+    };
+}
 function qucikFactory(send, i18n) {
     return async (message) => {
         const msg = await message;
@@ -54,21 +71,47 @@ function qucikFactory(send, i18n) {
             send(i18n.locale(msg));
             return;
         }
-        const params = msg[1];
-        Object.keys(params).forEach((key) => {
-            if (typeof params[key] !== 'string')
-                return;
-            params[key] = i18n.locale(params[key]);
-        });
-        send((0, tools_1.stringTemp)(i18n.locale(msg[0]), params));
+        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((resolve) => {
+        const handle = (session) => {
+            if (isSameSender(adapter, data, session)) {
+                resolve(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((resolve) => {
+        const handle = (session) => {
+            if (isSameSender(adapter, data, session)) {
+                resolve(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));
+    });
+}
 function error(type, data) {
     return new commandError_1.default(Object.assign(data ?? {}, { type }));
 }
-class Adapter extends service_1.default {
+class Adapter {
     constructor(ctx, config, identity, Api, el = new elements_1.default()) {
-        super('adapter', '');
         this.ctx = ctx;
         this.config = config;
         this.identity = identity;
@@ -93,11 +136,14 @@ class Adapter extends service_1.default {
         this.status.offlineTimes += 1;
     }
     session(type, data) {
-        const i18n = this.ctx.i18n.extends(this.config.lang ?? this.ctx.config.global.lang);
-        const send = sendMessageFactory(this, data);
+        const i18n = this.ctx.i18n.extends(this.config.lang);
+        const send = sendMessageFactory(this, type, data);
+        const format = formatFactory(i18n);
         const quick = qucikFactory(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, quick, error });
+        this.ctx.emit(type, ...[{ ...data, api, el, send, i18n, format, quick, prompt, confirm, error }]);
     }
     ctx;
     config;

package/lib/service/cache.d.ts

@@ -1,9 +1,13 @@
-import Service from './service';
+import { Service } from '../context';
+type CacheKey = string | symbol;
+type CacheValue = string | number | object;
 export declare class Cache extends Service {
-    private cacheStack?;
-    constructor();
-    handle(data: unknown[]): void;
+    private cache?;
+    constructor(ctx: ConstructorParameters<typeof Service>[0]);
     start(): void;
     stop(): void;
+    getContainer(): Map<CacheKey, CacheValue>;
+    get<T = CacheValue>(prop: CacheKey): T;
+    set(prop: CacheKey, value: CacheValue): void;
 }
 export default Cache;

package/lib/service/cache.js

@@ -1,27 +1,33 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Cache = void 0;
-const tools_1 = require("@kotori-bot/tools");
-const service_1 = __importDefault(require("./service"));
-class Cache extends service_1.default {
-    cacheStack;
-    constructor() {
-        super('custom', 'cache');
-    }
-    handle(data) {
-        (0, tools_1.none)(this);
+const context_1 = require("../context");
+class Cache extends context_1.Service {
+    cache;
+    constructor(ctx) {
+        super(ctx, {}, 'cache');
     }
     start() {
-        this.cacheStack = {};
+        if (this.cache)
+            return;
+        this.cache = new Map();
     }
     stop() {
-        Object.keys(this.cacheStack).forEach((key) => {
-            delete this.cacheStack[key];
-        });
-        delete this.cacheStack;
+        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, new Map());
+        return this.cache.get(key);
+    }
+    get(prop) {
+        return this.getContainer().get(prop);
+    }
+    set(prop, value) {
+        this.getContainer().set(prop, value);
     }
 }
 exports.Cache = Cache;

package/lib/service/index.d.ts

@@ -1,6 +1,4 @@
-export * from './service';
 export * from './adapter';
 export * from './api';
 export * from './elements';
-export * from './database';
 export * from './cache';

package/lib/service/index.js

@@ -14,9 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./service"), exports);
 __exportStar(require("./adapter"), exports);
 __exportStar(require("./api"), exports);
 __exportStar(require("./elements"), exports);
-__exportStar(require("./database"), exports);
 __exportStar(require("./cache"), exports);

package/lib/service/service.d.ts

@@ -1,20 +1,16 @@
-type ModuleType = 'database' | 'adapter' | 'service' | 'plugin';
-type ServiceType = Exclude<ModuleType, 'plugin' | 'service'> | 'custom';
-interface ServiceImpl {
-    readonly config: object;
-    readonly serviceType: ServiceType;
-    readonly service: string;
-    handle(...data: unknown[]): void;
+import { Context } from '../context';
+interface ServiceImpl<T extends object = object> {
+    readonly identity: string;
+    readonly config: T;
     start(): void;
     stop(): void;
 }
-export declare abstract class Service implements ServiceImpl {
-    handle(...data: unknown[]): void;
+export declare abstract class Service<T extends object = object> implements ServiceImpl<T> {
+    readonly ctx: Context;
+    readonly config: T;
+    readonly identity: string;
+    constructor(ctx: Context, config: T, identity: string);
     start(): void;
     stop(): void;
-    readonly serviceType: ServiceType;
-    readonly service: string;
-    readonly config: object;
-    constructor(serviceType: ServiceType, service: string, config?: object);
 }
 export default Service;

package/lib/service/service.js

@@ -3,8 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Service = void 0;
 const tools_1 = require("@kotori-bot/tools");
 class Service {
-    handle(...data) {
-        return (0, tools_1.none)(this, data);
+    ctx;
+    config;
+    identity;
+    constructor(ctx, config, identity) {
+        this.ctx = ctx;
+        this.config = config;
+        this.identity = identity;
     }
     start() {
         return (0, tools_1.none)(this);
@@ -12,22 +17,6 @@ class Service {
     stop() {
         return (0, tools_1.none)(this);
     }
-    serviceType;
-    service;
-    config;
-    constructor(serviceType, service, config = {}) {
-        this.serviceType = serviceType;
-        this.config = config;
-        if (serviceType === 'adapter') {
-            this.service = 'adapter';
-            return;
-        }
-        if (serviceType === 'database') {
-            this.service = 'database';
-            return;
-        }
-        this.service = service;
-    }
 }
 exports.Service = Service;
 exports.default = Service;

package/lib/types/adapter.d.ts

@@ -0,0 +1,22 @@
+import type { Context } from '../context';
+import type { Adapter } from '../service';
+import type { AdapterConfig } from './config';
+declare module '../context/events' {
+    interface EventsMapping {
+        connect(data: EventDataConnect): void;
+        status(data: EventDataStatus): void;
+    }
+}
+interface EventDataConnect {
+    adapter: Adapter;
+    type: 'connect' | 'disconnect';
+    normal: boolean;
+    mode: 'ws' | 'ws-reverse' | 'other';
+    address: string;
+}
+interface EventDataStatus {
+    adapter: Adapter;
+    status: Adapter['status']['value'];
+}
+export type AdapterClass = new (ctx: Context, config: AdapterConfig, identity: string) => Adapter;
+export {};

package/lib/types/adapter.js

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

package/lib/types/config.d.ts

@@ -1,5 +1,6 @@
-import { LocaleType } from '@kotori-bot/i18n';
-import { EventDataTargetId } from '.';
+import type { LocaleType } from '@kotori-bot/i18n';
+import type { EventDataTargetId } from './message';
+import { ModuleConfig } from '../context';
 export interface CoreConfig {
     global: GlobalConfig;
     adapter: {
@@ -19,6 +20,3 @@ export interface AdapterConfig {
     lang: LocaleType;
     'command-prefix': string;
 }
-export interface ModuleConfig {
-    filter: object;
-}

package/lib/types/index.d.ts

@@ -1,5 +1,3 @@
-export * from './core';
 export * from './config';
-export * from './modules';
 export * from './message';
-export * from './service';
+export * from './adapter';

package/lib/types/index.js

@@ -14,8 +14,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./core"), exports);
 __exportStar(require("./config"), exports);
-__exportStar(require("./modules"), exports);
 __exportStar(require("./message"), exports);
-__exportStar(require("./service"), exports);
+__exportStar(require("./adapter"), exports);

package/lib/types/message.d.ts

@@ -1,10 +1,10 @@
-import type { obj } from '@kotori-bot/tools';
 import Tsu, { TsuError } from 'tsukiko';
 import type I18n from '@kotori-bot/i18n';
-import type { EventsList } from './core';
+import type { EventsList } from '../context';
 import type CommandError from '../utils/commandError';
 import type { Api, Elements } from '../service';
-declare module './core' {
+import { Command } from '../utils/command';
+declare module '../context/events' {
     interface EventsMapping {
         midwares(data: EventDataMidwares): void;
         before_parse(data: EventDataBeforeParse): void;
@@ -30,7 +30,7 @@ export declare const enum CommandAccess {
 }
 export type CommandAction = (data: {
     args: CommandArgType[];
-    options: obj<CommandArgType>;
+    options: Record<string, CommandArgType>;
 }, 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">]>;
@@ -70,11 +70,13 @@ export interface CommandResult extends CommandParseResult {
     error: {
         error: unknown;
     };
+    data_error: {
+        target: string | number;
+    };
     res_error: {
         error: TsuError;
     };
     num_error: null;
-    num_choose: null;
     no_access_manger: null;
     no_access_admin: null;
     disable: null;
@@ -83,11 +85,11 @@ export interface CommandResult extends CommandParseResult {
     };
     no_exists: CommandResult['exists'];
 }
-type CommandResultNoArgs = 'num_error' | 'num_choose' | 'no_access_manger' | 'no_access_admin' | 'disable';
+type CommandResultNoArgs = 'num_error' | 'no_access_manger' | 'no_access_admin' | 'disable';
 export type CommandResultExtra = {
     [K in keyof CommandResult]: {
         type: K;
-    } & (K extends CommandResultNoArgs ? {} : CommandResult[K]);
+    } & (K extends CommandResultNoArgs ? object : CommandResult[K]);
 };
 export type SessionData = EventsList['on_message'];
 export declare enum MessageScope {
@@ -95,7 +97,7 @@ export declare enum MessageScope {
     GROUP = 1
 }
 export type MessageRaw = string;
-export type MessageQuickReal = MessageRaw | [string, obj<CommandArgType | void>] | CommandError | void;
+export type MessageQuickReal = MessageRaw | [string, Record<string, CommandArgType> | CommandArgType[]] | CommandError | void;
 export type MessageQuick = MessageQuickReal | Promise<MessageQuickReal>;
 export type MidwareCallback = (next: () => void, session: SessionData) => MessageQuick;
 export type RegexpCallback = (match: RegExpMatchArray, session: SessionData) => MessageQuick;
@@ -107,26 +109,24 @@ interface EventDataMidwares {
 }
 interface EventDataBeforeParse {
     session: SessionData;
-    command: string;
+    raw: string;
 }
 interface EventDataParse {
     session: SessionData;
-    command: string;
+    command: Command;
+    raw: string;
     result: CommandError | Parameters<CommandAction>[0];
     cancel(): void;
 }
 interface EventDataBeforeCommand {
     session: SessionData;
-    command: string;
-    scope: MessageScope;
-    access: CommandAccess;
+    raw: string;
     cancel(): void;
 }
 interface EventDataCommand {
     session: SessionData;
-    command: string;
-    scope: MessageScope;
-    access: CommandAccess;
+    raw: string;
+    command: Command;
     result: EventDataParse['result'] | MessageQuick;
 }
 interface EventDataBeforeSend {
@@ -154,7 +154,13 @@ export interface EventDataApiBase {
     operatorId?: EventDataTargetId;
     i18n: I18n;
     send(message: MessageRaw): void;
+    format(template: string, data: Record<string, unknown> | CommandArgType[]): 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;
@@ -169,7 +175,11 @@ interface EventDataGroupMsg extends EventDataApiBase {
     type: MessageScope.GROUP;
     messageId: EventDataTargetId;
     message: MessageRaw;
-    sender: SessionDataSender;
+    sender: SessionDataSender & {
+        level: string;
+        role: 'owner' | 'admin' | 'member';
+        title: string;
+    };
     groupId: EventDataTargetId;
 }
 interface EventDataPrivateRecall extends EventDataApiBase {
@@ -211,8 +221,8 @@ interface EventDataGroupAdmin extends EventDataApiBase {
 }
 interface EventDataGroupBan extends EventDataApiBase {
     userId: EventDataTargetId | 0;
-    operatorId?: EventDataTargetId;
-    time?: number | -1;
+    operatorId: EventDataTargetId;
+    time: number | -1;
     groupId: EventDataTargetId;
 }
 export {};

package/lib/types/service.js

@@ -1,3 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-// export type DatabaseClass = new (config: /* DatabaseConfig , identity: string */ /*  object) => Database;

package/lib/utils/command.d.ts

@@ -1,4 +1,3 @@
-import { obj } from '@kotori-bot/tools';
 import { CommandAccess, type CommandAction, type CommandArgType, type CommandArgTypeSign, type CommandConfig } from '../types';
 import { CommandError } from './commandError';
 interface CommandArg {
@@ -28,7 +27,7 @@ interface CommandData {
 export declare class Command {
     static run(input: string, data: CommandData): CommandError | {
         args: CommandArgType[];
-        options: obj<CommandArgType>;
+        options: Record<string, CommandArgType>;
     };
     private template;
     readonly meta: CommandData;

package/lib/utils/command.js

@@ -40,7 +40,11 @@ class Command {
         if (!starts)
             return new commandError_1.CommandError({ type: 'unknown', input });
         /* handle CommandOption[] to minimist.opts */
-        const opts = { string: [], boolean: [], alias: {} };
+        const opts = {
+            string: [],
+            boolean: [],
+            alias: {}
+        };
         data.options.forEach((option) => {
             if (option.type === 'string') {
                 opts.string.push(option.realname);

package/lib/utils/errror.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-type KotoriErrorType = 'DatabaseError' | 'ModuleError' | 'UnknownError' | 'DevError';
+type KotoriErrorType = 'ServiceError' | 'ModuleError' | 'UnknownError' | 'DevError';
 interface KotoriErrorImpl {
     readonly name: KotoriErrorType;
     readonly extend: () => typeof KotoriError;

package/lib/utils/factory.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.cancelFactory = exports.disposeFactory = void 0;
 function disposeFactory(ctx, dispose) {
     ctx.once('dispose_module', (data) => {
-        if ((typeof data.module === 'object' ? data.module.pkg.name : data.module) !== ctx.identity) {
+        if ((typeof data.instance === 'object' ? data.instance.name : data.instance) !== ctx.identity) {
             disposeFactory(ctx, dispose);
             return;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kotori-bot/core",
-  "version": "v1.2.0",
+  "version": "1.3.0",
   "description": "Kotori Core",
   "main": "lib/index.js",
   "license": "GPL-3.0",
@@ -27,7 +27,7 @@
     "@types/minimist": "^1.2.5",
     "minimist": "^1.2.8",
     "tsukiko": "^1.2.1",
-    "@kotori-bot/i18n": "^v1.2.0",
-    "@kotori-bot/tools": "^v1.2.0"
+    "@kotori-bot/tools": "^1.2.1",
+    "@kotori-bot/i18n": "^1.2.1"
   }
 }

package/lib/service/database.d.ts

@@ -1,5 +0,0 @@
-import Service from './service';
-export declare abstract class Database extends Service {
-    constructor();
-}
-export default Database;

package/lib/service/database.js

@@ -1,14 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Database = void 0;
-const service_1 = __importDefault(require("./service"));
-class Database extends service_1.default {
-    constructor() {
-        super('database', '');
-    }
-}
-exports.Database = Database;
-exports.default = Database;