@kotori-bot/core 1.1.0 → 1.2.0

package/lib/context/symbols.d.ts

@@ -0,0 +1,13 @@
+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;
+    static readonly command: unique symbol;
+    static readonly regexp: unique symbol;
+    static readonly modules: unique symbol;
+}
+export default Symbols;

package/lib/context/symbols.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Symbols = void 0;
+class Symbols {
+    static container = Symbol.for('kotori.context.container');
+    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 adapter = Symbol.for('kotori.core.adapter');
+    static bot = Symbol.for('kotori.core.bot');
+    static midware = Symbol.for('kotori.core.midware');
+    static command = Symbol.for('kotori.core.command');
+    static regexp = Symbol.for('kotori.core.regexp');
+    static modules = Symbol.for('kotori.loader.module');
+}
+exports.Symbols = Symbols;
+exports.default = Symbols;

package/lib/index.d.ts

@@ -1,17 +1,11 @@
-import Context from './context';
-export * from './components/adapter';
-export * from './components/api';
-export * from './components/elements';
 export * from './context';
+export * from './components';
+export * from './service';
+export * from './utils/command';
 export * from './utils/errror';
+export * from './utils/commandError';
+export * from './utils/container';
 export * from './consts';
 export * from './types';
 export * from '@kotori-bot/tools';
 export * from 'tsukiko';
-export declare class ContextInstance {
-    protected constructor();
-    private static instance;
-    protected static setInstance(ctx: Context): void;
-    static getInstance(): Context;
-    static getMixin(): any;
-}

package/lib/index.js

@@ -14,30 +14,14 @@ 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 });
-exports.ContextInstance = void 0;
-const tools_1 = require("@kotori-bot/tools");
-__exportStar(require("./components/adapter"), exports);
-__exportStar(require("./components/api"), exports);
-__exportStar(require("./components/elements"), exports);
 __exportStar(require("./context"), exports);
+__exportStar(require("./components"), exports);
+__exportStar(require("./service"), exports);
+__exportStar(require("./utils/command"), exports);
 __exportStar(require("./utils/errror"), exports);
+__exportStar(require("./utils/commandError"), exports);
+__exportStar(require("./utils/container"), exports);
 __exportStar(require("./consts"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("@kotori-bot/tools"), exports);
 __exportStar(require("tsukiko"), exports);
-class ContextInstance {
-    constructor() {
-        (0, tools_1.none)();
-    }
-    static instance = {};
-    static setInstance(ctx) {
-        this.instance = ctx;
-    }
-    static getInstance() {
-        return this.instance;
-    }
-    static getMixin() {
-        return Object.assign(ContextInstance.getInstance() /* , Context */);
-    }
-}
-exports.ContextInstance = ContextInstance;

package/lib/{components → service}/adapter.d.ts

@@ -1,8 +1,12 @@
 import type Api from './api';
-import type Context from '../context';
-import type { EventDataApiBase, AdapterConfig, EventType, EventDataTargetId, ApiConstructor, ElementsParam, MessageScope } from '../types';
+import { Context } from '../context';
+import { EventDataApiBase, EventsList, EventDataTargetId, AdapterConfig } from '../types';
 import Service from './service';
-interface Status {
+import Elements from './elements';
+type EventApiType = {
+    [K in keyof EventsList]: EventsList[K] extends EventDataApiBase ? EventsList[K] : never;
+};
+interface AdapterStatus {
     value: 'online' | 'offline';
     createTime: Date;
     lastMsgTime: Date | null;
@@ -10,29 +14,28 @@ interface Status {
     sentMsg: number;
     offlineTimes: number;
 }
-interface AdapterImpl<T extends Api> {
+interface AdapterImpl<T extends Api = Api> extends Service {
+    readonly ctx: Context;
     readonly platform: string;
     readonly selfId: EventDataTargetId;
     readonly identity: string;
     readonly api: T;
-    readonly status: Status;
+    readonly elements: Elements;
+    readonly status: AdapterStatus;
 }
-export declare function ApiProxy<T extends Api>(api: T, ctx: Context): T;
-type EventApiType = {
-    [K in Extract<EventType[keyof EventType], EventDataApiBase<keyof EventType, MessageScope>>['type']]: EventType[K];
-};
 export declare abstract class Adapter<T extends Api = Api> extends Service implements AdapterImpl<T> {
-    constructor(ctx: Context, config: AdapterConfig, identity: string, ApiConstructor: ApiConstructor<T>, el?: ElementsParam);
+    constructor(ctx: Context, config: AdapterConfig, identity: string, Api: new (adapter: Adapter) => T, el?: Elements);
     abstract send(action: string, params?: object): void | object | Promise<unknown> | null | undefined;
     protected online(): void;
     protected offline(): void;
-    protected emit<N extends keyof EventApiType>(type: N, data: Omit<EventApiType[N], 'type' | 'api' | 'send' | 'locale' | 'quick' | 'error' | 'el' | 'messageType'>): void;
+    protected session<N extends keyof EventApiType>(type: N, data: Omit<EventApiType[N], 'api' | 'send' | 'i18n' | 'quick' | 'el' | 'error'>): void;
     readonly ctx: Context;
     readonly config: AdapterConfig;
     readonly identity: string;
     readonly platform: string;
     readonly api: T;
-    readonly status: Status;
+    readonly elements: Elements;
+    readonly status: AdapterStatus;
     selfId: EventDataTargetId;
 }
 export default Adapter;

package/lib/service/adapter.js

@@ -0,0 +1,119 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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"));
+function setProxy(api, ctx) {
+    const proxy = Object.create(api);
+    proxy.sendPrivateMsg = new Proxy(api.sendPrivateMsg, {
+        apply(_, __, argArray) {
+            const { '0': message, '1': targetId } = argArray;
+            const cancel = (0, factory_1.cancelFactory)();
+            ctx.emit('before_send', { api, message, messageType: types_1.MessageScope.PRIVATE, targetId, cancel: cancel.get() });
+            if (cancel.value)
+                return;
+            api.sendPrivateMsg(message, targetId, argArray[2]);
+        }
+    });
+    proxy.sendGroupMsg = new Proxy(api.sendGroupMsg, {
+        apply(_, __, argArray) {
+            const { '0': message, '1': targetId } = argArray;
+            const cancel = (0, factory_1.cancelFactory)();
+            ctx.emit('before_send', { api, message, messageType: types_1.MessageScope.PRIVATE, targetId, cancel: cancel.get() });
+            if (cancel.value)
+                return;
+            api.sendGroupMsg(message, targetId, argArray[2]);
+        }
+    });
+    return proxy;
+}
+function sendMessageFactory(adapter, data) {
+    if (data.type === types_1.MessageScope.GROUP && 'groupId' in data) {
+        return (message) => {
+            adapter.api.sendGroupMsg(message, data.groupId, data.extra);
+        };
+    }
+    return (message) => {
+        adapter.api.sendPrivateMsg(message, data.userId, data.extra);
+    };
+}
+function qucikFactory(send, i18n) {
+    return async (message) => {
+        const msg = await message;
+        if (!msg || msg instanceof commandError_1.default)
+            return;
+        if (typeof msg === 'string') {
+            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));
+    };
+}
+function error(type, data) {
+    return new commandError_1.default(Object.assign(data ?? {}, { type }));
+}
+class Adapter extends service_1.default {
+    constructor(ctx, config, identity, Api, el = new elements_1.default()) {
+        super('adapter', '');
+        this.ctx = ctx;
+        this.config = config;
+        this.identity = identity;
+        this.platform = config.extends;
+        this.api = setProxy(new Api(this), this.ctx);
+        this.elements = el;
+        if (!this.ctx[context_1.Symbols.bot].get(this.platform))
+            this.ctx[context_1.Symbols.bot].set(this.platform, new Set());
+        this.ctx[context_1.Symbols.bot].get(this.platform).add(this.api);
+    }
+    online() {
+        if (this.status.value !== 'offline')
+            return;
+        this.ctx.emit('status', { adapter: this, status: 'online' });
+        this.status.value = 'online';
+    }
+    offline() {
+        if (this.status.value !== 'online')
+            return;
+        this.ctx.emit('status', { adapter: this, status: 'offline' });
+        this.status.value = 'offline';
+        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 quick = qucikFactory(send, i18n);
+        const { api, elements: el } = this;
+        this.ctx.emit(type, { ...data, api, el, send, i18n, quick, error });
+    }
+    ctx;
+    config;
+    identity;
+    platform;
+    api;
+    elements;
+    status = {
+        value: 'offline',
+        createTime: new Date(),
+        lastMsgTime: null,
+        receivedMsg: 0,
+        sentMsg: 0,
+        offlineTimes: 0
+    };
+    selfId = -1;
+}
+exports.Adapter = Adapter;
+exports.default = Adapter;

package/lib/service/api.d.ts

@@ -0,0 +1,32 @@
+import type Adapter from './adapter';
+import type { EventDataTargetId, MessageRaw } from '../types';
+interface ApiImpl {
+    readonly adapter: Adapter<this>;
+    sendPrivateMsg(message: MessageRaw, userId: EventDataTargetId): void;
+    sendGroupMsg(message: MessageRaw, groupId: EventDataTargetId): void;
+    deleteMsg(messageId: EventDataTargetId): void;
+    setGroupName(groupId: EventDataTargetId, groupName: string): void;
+    setGroupAvatar(groupId: EventDataTargetId, image: string): void;
+    setGroupAdmin(groupId: EventDataTargetId, userId: EventDataTargetId, enable: boolean): void;
+    setGroupCard(groupId: EventDataTargetId, userId: EventDataTargetId, card: string): void;
+    setGroupBan(groupId: EventDataTargetId, userId?: EventDataTargetId, time?: number): void;
+    sendGroupNotice(groupId: EventDataTargetId, content: string, image?: string): void;
+    setGroupKick(groupId: EventDataTargetId, userId: EventDataTargetId): void;
+    setGroupLeave(groupId: EventDataTargetId): void;
+}
+export declare abstract class Api implements ApiImpl {
+    readonly adapter: Adapter<this>;
+    constructor(adapter: Adapter);
+    sendPrivateMsg(message: MessageRaw, userId: EventDataTargetId, ...extra: unknown[]): void;
+    sendGroupMsg(message: MessageRaw, groupId: EventDataTargetId, ...extra: unknown[]): void;
+    deleteMsg(messageId: EventDataTargetId, ...extra: unknown[]): void;
+    setGroupName(groupId: EventDataTargetId, groupName: string, ...extra: unknown[]): void;
+    setGroupAvatar(groupId: EventDataTargetId, image: string, ...extra: unknown[]): void;
+    setGroupAdmin(groupId: EventDataTargetId, userId: EventDataTargetId, enable: boolean, ...extra: unknown[]): void;
+    setGroupCard(groupId: EventDataTargetId, userId: EventDataTargetId, card: string, ...extra: unknown[]): void;
+    setGroupBan(groupId: EventDataTargetId, userId?: EventDataTargetId, time?: number, ...extra: unknown[]): void;
+    sendGroupNotice(groupId: EventDataTargetId, content: string, image?: string, ...extra: unknown[]): void;
+    setGroupKick(groupId: EventDataTargetId, userId: EventDataTargetId, ...extra: unknown[]): void;
+    setGroupLeave(groupId: EventDataTargetId, ...extra: unknown[]): void;
+}
+export default Api;

package/lib/{components → service}/api.js

@@ -4,42 +4,40 @@ exports.Api = void 0;
 const tools_1 = require("@kotori-bot/tools");
 class Api {
     adapter;
-    elements;
-    constructor(adapter, el) {
+    constructor(adapter) {
         this.adapter = adapter;
-        this.elements = el;
     }
-    send_private_msg(message, userId, extra) {
+    sendPrivateMsg(message, userId, ...extra) {
         (0, tools_1.none)(this, message, userId, extra);
     }
-    send_group_msg(message, groupId, extra) {
+    sendGroupMsg(message, groupId, ...extra) {
         (0, tools_1.none)(this, message, groupId, extra, extra);
     }
-    delete_msg(messageId, extra) {
+    deleteMsg(messageId, ...extra) {
         (0, tools_1.none)(this, messageId, extra);
     }
-    set_group_name(groupId, groupName, extra) {
+    setGroupName(groupId, groupName, ...extra) {
         (0, tools_1.none)(this, groupId, groupName, extra);
     }
-    set_group_avatar(groupId, image, extra) {
+    setGroupAvatar(groupId, image, ...extra) {
         (0, tools_1.none)(this, groupId, image, extra);
     }
-    set_group_admin(groupId, userId, enable, extra) {
+    setGroupAdmin(groupId, userId, enable, ...extra) {
         (0, tools_1.none)(this, groupId, userId, enable, extra);
     }
-    set_group_card(groupId, userId, card, extra) {
+    setGroupCard(groupId, userId, card, ...extra) {
         (0, tools_1.none)(this, groupId, userId, card, extra);
     }
-    set_group_ban(groupId, userId, time, extra) {
+    setGroupBan(groupId, userId, time, ...extra) {
         (0, tools_1.none)(this, groupId, userId, time, extra);
     }
-    send_group_notice(groupId, content, image, extra) {
+    sendGroupNotice(groupId, content, image, ...extra) {
         (0, tools_1.none)(this, groupId, content, image, extra);
     }
-    set_group_kick(groupId, userId, extra) {
+    setGroupKick(groupId, userId, ...extra) {
         (0, tools_1.none)(this, groupId, userId, extra);
     }
-    set_group_leave(groupId, extra) {
+    setGroupLeave(groupId, ...extra) {
         (0, tools_1.none)(this, groupId, groupId, extra);
     }
 }

package/lib/service/cache.d.ts

@@ -0,0 +1,9 @@
+import Service from './service';
+export declare class Cache extends Service {
+    private cacheStack?;
+    constructor();
+    handle(data: unknown[]): void;
+    start(): void;
+    stop(): void;
+}
+export default Cache;

package/lib/service/cache.js

@@ -0,0 +1,28 @@
+"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);
+    }
+    start() {
+        this.cacheStack = {};
+    }
+    stop() {
+        Object.keys(this.cacheStack).forEach((key) => {
+            delete this.cacheStack[key];
+        });
+        delete this.cacheStack;
+    }
+}
+exports.Cache = Cache;
+exports.default = Cache;

package/lib/service/database.d.ts

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

package/lib/service/database.js

@@ -0,0 +1,14 @@
+"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;

package/lib/service/elements.d.ts

@@ -0,0 +1,12 @@
+import type { EventDataTargetId } from '../types';
+export declare class Elements {
+    private default;
+    at(target: EventDataTargetId, ...extra: unknown[]): string;
+    image(url: string, ...extra: unknown[]): string;
+    voice(url: string, ...extra: unknown[]): string;
+    video(url: string, ...extra: unknown[]): string;
+    face(id: number | string, ...extra: unknown[]): string;
+    file(data: unknown, ...extra: unknown[]): string;
+    supports(): (keyof Elements)[];
+}
+export default Elements;

package/lib/service/elements.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Elements = void 0;
+const tools_1 = require("@kotori-bot/tools");
+class Elements {
+    default(...args) {
+        (0, tools_1.none)(this, args);
+        return '';
+    }
+    at(target, ...extra) {
+        return this.default(target, extra);
+    }
+    image(url, ...extra) {
+        return this.default(url, extra);
+    }
+    voice(url, ...extra) {
+        return this.default(url, extra);
+    }
+    video(url, ...extra) {
+        return this.default(url, extra);
+    }
+    face(id, ...extra) {
+        return this.default(id, extra);
+    }
+    file(data, ...extra) {
+        return this.default(data, extra);
+    }
+    supports() {
+        const supports = [];
+        const keys = ['at', 'image', 'voice', 'video', 'face', 'file'];
+        keys.forEach((key) => {
+            if (this[key] !== new Elements()[key])
+                supports.push(key);
+        });
+        return supports;
+    }
+}
+exports.Elements = Elements;
+exports.default = Elements;

package/lib/service/index.d.ts

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

package/lib/service/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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

@@ -0,0 +1,20 @@
+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;
+    start(): void;
+    stop(): void;
+}
+export declare abstract class Service implements ServiceImpl {
+    handle(...data: unknown[]): void;
+    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

@@ -0,0 +1,33 @@
+"use strict";
+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);
+    }
+    start() {
+        return (0, tools_1.none)(this);
+    }
+    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/config.d.ts

@@ -0,0 +1,24 @@
+import { LocaleType } from '@kotori-bot/i18n';
+import { EventDataTargetId } from '.';
+export interface CoreConfig {
+    global: GlobalConfig;
+    adapter: {
+        [propName: string]: AdapterConfig;
+    };
+    plugin: {
+        [propName: string]: ModuleConfig;
+    };
+}
+export interface GlobalConfig {
+    lang: LocaleType;
+    'command-prefix': string;
+}
+export interface AdapterConfig {
+    extends: string;
+    master: EventDataTargetId;
+    lang: LocaleType;
+    'command-prefix': string;
+}
+export interface ModuleConfig {
+    filter: object;
+}

package/lib/types/core.d.ts

@@ -0,0 +1,7 @@
+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/types/core.js

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

package/lib/types/index.d.ts

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

package/lib/types/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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);