node-karin 0.12.0 → 0.12.2-5.pr.206.027f2f2

package/lib/utils/config/yamlEditor.d.ts

@@ -1,101 +0,0 @@
-import Yaml from 'yaml';
-export type YamlValue = string | boolean | number | object | any[];
-export declare class YamlEditor {
-    filePath: string;
-    doc: Yaml.Document;
-    document: Yaml.Document;
-    constructor(file: string);
-    /**
-     * 获取指定路径的值
-     * @param path - 路径，多个路径使用`.`连接，例如：`a.b.c`
-     */
-    get(path: string): any;
-    /**
-     * 设置指定路径的值
-     * @param path - 路径，多个路径使用`.`连接，例如：`a.b.c`
-     * @param value - 要设置的值 允许的类型：`string`, `boolean`, `number`, `object`, `array`
-     */
-    set(path: string, value: YamlValue): boolean;
-    /**
-     * 向指定路径添加新值
-     * @param path - 路径，多个路径使用`.`连接，例如：`a.b.c`
-     * @param value - 要添加的值
-     */
-    add(path: string, value: YamlValue): boolean;
-    /**
-     * 删除指定路径
-     * @param path - 路径，多个路径使用`.`连接，例如：`a.b.c`
-     * @returns 是否删除成功
-     */
-    del(path: string): boolean;
-    /**
-     * 向指定路径的数组添加新值，可以选择添加到数组的开始或结束
-     * @param path - 路径，多个路径使用`.`连接，例如：`a.b.c`
-     * @param value - 要添加的值
-     * @param prepend - 如果为 true，则添加到数组的开头，否则添加到末尾
-     */
-    append(path: string, value: string, prepend?: boolean): boolean;
-    /**
-     * 向指定路径的数组删除值
-     * @param path - 路径，多个路径使用`.`连接，例如：`a.b.c`
-     * @param value - 要删除的值
-     */
-    remove(path: string, value: YamlValue): boolean;
-    /**
-     * 检查指定路径的键是否存在
-     * @param path - 路径，用点号分隔
-     */
-    has(path: string): boolean;
-    /**
-     * 查询指定路径中是否包含指定的值
-     * @param path - 路径，用点号分隔
-     * @param value - 要查询的值
-     */
-    hasval(path: string, value: YamlValue): boolean;
-    /**
-     * 查询指定路径中是否包含指定的值
-     * @param path - 路径，用点号分隔
-     * @param value - 要查询的值
-     * @deprecated 请使用 `hasval` 代替
-     */
-    hasVal(path: string, value: YamlValue): boolean;
-    /**
-     * 向根节点新增元素，如果根节点不是数组，则将其转换为数组再新增元素
-     * @param value - 要新增的元素
-     */
-    pusharr(value: YamlValue): boolean;
-    /**
-     * 根据索引从根节点数组删除元素
-     * @param index - 要删除元素的索引
-     */
-    delarr(index: number): boolean;
-    /**
-     * 获取指定路径的pair对象
-     * @param path - 路径，多个路径使用`.`连接，例如：`a.b.c`
-     */
-    getpair(path: string): any;
-    /**
-     * 设置指定键的注释
-     * @param path - 路径，多个路径使用`.`连接，例如：`a.b.c`
-     * @param comment - 要设置的注释
-     * @param prepend - 如果为 true，则添加到注释的开头，否则添加到同一行的末尾
-     */
-    comment(path: string, comment: string, prepend: boolean): void;
-    /**
-     * 删除指定键的注释
-     * @param path - 路径，多个路径使用`.`连接，例如：`a.b.c`
-     * @param type - 要删除的注释类型，`before` 为注释前，`after` 为注释后，`all` 为全部
-     */
-    uncomment(path: string, type?: 'before' | 'after' | 'all'): void;
-    /**
-     * 检查注释是否存在
-     * @param path - 路径，多个路径使用`.`连接，例如：`a.b.c`
-     * @param type - 要检查的注释类型，`before` 为注释前，`after` 为注释后
-     */
-    hascomment(path: string, type: 'before' | 'after'): boolean;
-    /**
-     * 保存文件
-     * 保存失败会抛出异常
-     */
-    save(): void;
-}

package/lib/utils/config/yamlEditor.js

@@ -1,330 +0,0 @@
-/*
- * YamlEditor - 一个用于编辑 YAML 文件的类
- * 本代码由 ChatGPT4 提供
- * https://github.com/OpenAI
- */
-import fs from 'fs';
-import lodash from 'lodash';
-import logger from '../core/logger.js';
-import Yaml, { isMap, isSeq, isPair } from 'yaml';
-export class YamlEditor {
-    filePath;
-    doc;
-    document;
-    constructor(file) {
-        this.filePath = file;
-        const data = Yaml.parseDocument(fs.readFileSync(file, 'utf8'));
-        this.doc = data;
-        this.document = data;
-    }
-    /**
-     * 获取指定路径的值
-     * @param path - 路径，多个路径使用`.`连接，例如：`a.b.c`
-     */
-    get(path) {
-        try {
-            if (!path)
-                return this.document.toJSON();
-            return lodash.get(this.document.toJSON(), path);
-        }
-        catch (error) {
-            logger.error(`[YamlEditor] 获取数据时出错：${error}`);
-            return null;
-        }
-    }
-    /**
-     * 设置指定路径的值
-     * @param path - 路径，多个路径使用`.`连接，例如：`a.b.c`
-     * @param value - 要设置的值 允许的类型：`string`, `boolean`, `number`, `object`, `array`
-     */
-    set(path, value) {
-        try {
-            const _path = typeof path === 'string' ? path.split('.') : path;
-            this.document.setIn(_path, value);
-            return true;
-        }
-        catch (error) {
-            logger.error(`[YamlEditor] 设置数据时出错：${error}`);
-            return false;
-        }
-    }
-    /**
-     * 向指定路径添加新值
-     * @param path - 路径，多个路径使用`.`连接，例如：`a.b.c`
-     * @param value - 要添加的值
-     */
-    add(path, value) {
-        try {
-            const _path = typeof path === 'string' ? path.split('.') : path;
-            this.document.addIn(_path, value);
-            logger.debug(`[YamlEditor] 已在 ${path} 添加新的值`);
-            return true;
-        }
-        catch (error) {
-            logger.error(`[YamlEditor] 添加数据时出错：${error}`);
-            return false;
-        }
-    }
-    /**
-     * 删除指定路径
-     * @param path - 路径，多个路径使用`.`连接，例如：`a.b.c`
-     * @returns 是否删除成功
-     */
-    del(path) {
-        try {
-            const _path = typeof path === 'string' ? path.split('.') : path;
-            this.document.deleteIn(_path);
-            return true;
-        }
-        catch (error) {
-            logger.error(`[YamlEditor] 删除数据时出错：${error}`);
-            return false;
-        }
-    }
-    /**
-     * 向指定路径的数组添加新值，可以选择添加到数组的开始或结束
-     * @param path - 路径，多个路径使用`.`连接，例如：`a.b.c`
-     * @param value - 要添加的值
-     * @param prepend - 如果为 true，则添加到数组的开头，否则添加到末尾
-     */
-    append(path, value, prepend = false) {
-        try {
-            const _path = typeof path === 'string' ? path.split('.') : path || [];
-            let current = this.document.getIn(_path);
-            if (!current) {
-                current = new Yaml.YAMLSeq();
-                this.document.setIn(_path, current);
-            }
-            else if (!(current instanceof Yaml.YAMLSeq)) {
-                logger.error('[YamlEditor] 指定的路径不是数组');
-                return false;
-            }
-            else {
-                prepend ? current.items.unshift(value) : current.add(value);
-            }
-            logger.debug(`[YamlEditor] 已向 ${path} 数组${prepend ? '开头' : '末尾'}添加新元素：${value}`);
-            return true;
-        }
-        catch (error) {
-            logger.error(`[YamlEditor] 向数组添加元素时出错：${error}`);
-            return false;
-        }
-    }
-    /**
-     * 向指定路径的数组删除值
-     * @param path - 路径，多个路径使用`.`连接，例如：`a.b.c`
-     * @param value - 要删除的值
-     */
-    remove(path, value) {
-        try {
-            const _path = typeof path === 'string' ? path.split('.') : path;
-            const current = this.document.getIn(_path);
-            if (!current) {
-                logger.error('[YamlEditor] 指定的路径不存在');
-                return false;
-            }
-            if (!(current instanceof Yaml.YAMLSeq)) {
-                logger.error('[YamlEditor] 指定的路径不是数组');
-                return false;
-            }
-            const index = current.items.findIndex(item => lodash.isEqual(item.toJSON(), value));
-            if (index < 0) {
-                logger.error('[YamlEditor] 未找到要删除的值');
-                return false;
-            }
-            current.items.splice(index, 1);
-            logger.debug(`[YamlEditor] 已从 ${path} 数组删除元素：${value}`);
-            return true;
-        }
-        catch (error) {
-            logger.error(`[YamlEditor] 从数组删除元素时出错：${error}`);
-            return false;
-        }
-    }
-    /**
-     * 检查指定路径的键是否存在
-     * @param path - 路径，用点号分隔
-     */
-    has(path) {
-        try {
-            const _path = typeof path === 'string' ? path.split('.') : path;
-            return this.document.hasIn(_path);
-        }
-        catch (error) {
-            logger.error(`[YamlEditor] 检查路径是否存在时出错：${error}`);
-            return false;
-        }
-    }
-    /**
-     * 查询指定路径中是否包含指定的值
-     * @param path - 路径，用点号分隔
-     * @param value - 要查询的值
-     */
-    hasval(path, value) {
-        try {
-            const _path = typeof path === 'string' ? path.split('.') : path;
-            const current = this.document.getIn(_path);
-            if (!current)
-                return false;
-            /** 检查当前节点是否包含指定的值 */
-            if (current instanceof Yaml.YAMLSeq) {
-                /** 如果是序列，遍历序列查找值 */
-                return current.items.some(item => lodash.isEqual(item.toJSON(), value));
-            }
-            else if (current instanceof Yaml.YAMLMap) {
-                /** 如果是映射，检查每个值 */
-                return Array.from(current.values()).some((v) => lodash.isEqual(v.toJSON(), value));
-            }
-            else {
-                /** 否则，直接比较值 */
-                return lodash.isEqual(current, value);
-            }
-        }
-        catch (error) {
-            logger.error(`[YamlEditor] 检查路径 ${path} 是否包含值时出错：${error}`);
-            return false;
-        }
-    }
-    /**
-     * 查询指定路径中是否包含指定的值
-     * @param path - 路径，用点号分隔
-     * @param value - 要查询的值
-     * @deprecated 请使用 `hasval` 代替
-     */
-    hasVal(path, value) {
-        return this.hasval(path, value);
-    }
-    /**
-     * 向根节点新增元素，如果根节点不是数组，则将其转换为数组再新增元素
-     * @param value - 要新增的元素
-     */
-    pusharr(value) {
-        try {
-            if (!(this.document.contents instanceof Yaml.YAMLSeq)) {
-                // 如果根节点不是数组，则将其转换为数组
-                this.document.contents = new Yaml.YAMLSeq();
-                logger.debug('[YamlEditor] 根节点已转换为数组');
-            }
-            this.document.contents.add(value);
-            logger.debug('[YamlEditor] 已向根节点数组新增元素：', value);
-            return true;
-        }
-        catch (error) {
-            logger.error(`[YamlEditor] 向根节点数组新增元素时出错：${error}`);
-            return false;
-        }
-    }
-    /**
-     * 根据索引从根节点数组删除元素
-     * @param index - 要删除元素的索引
-     */
-    delarr(index) {
-        try {
-            if (!(this.document.contents instanceof Yaml.YAMLSeq)) {
-                throw new Error('[YamlEditor] 根节点不是数组');
-            }
-            if (index < 0 || index >= this.document.contents.items.length) {
-                throw new Error('[YamlEditor] 索引超出范围');
-            }
-            this.document.contents.items.splice(index, 1);
-            logger.debug('[YamlEditor] 已根据索引从根节点数组删除元素，索引：', index);
-            return true;
-        }
-        catch (error) {
-            logger.error(`[YamlEditor] 根据索引删除根节点数组元素时出错：${error}`);
-            return false;
-        }
-    }
-    /**
-     * 获取指定路径的pair对象
-     * @param path - 路径，多个路径使用`.`连接，例如：`a.b.c`
-     */
-    getpair(path) {
-        if (!path)
-            throw new Error('path is required');
-        const keys = path.split('.');
-        // 好多any啊，我要当any糕手~
-        let pair = this.document.contents;
-        keys.forEach(key => {
-            if (isMap(pair)) {
-                pair = pair.items.find((item) => item.key.value === key);
-            }
-            else if (isSeq(pair)) {
-                pair = pair.items.find((item) => item.value === key);
-            }
-            else if (isPair(pair)) {
-                pair = pair.value.items.find((item) => item.key.value === key);
-            }
-        });
-        return pair;
-    }
-    /**
-     * 设置指定键的注释
-     * @param path - 路径，多个路径使用`.`连接，例如：`a.b.c`
-     * @param comment - 要设置的注释
-     * @param prepend - 如果为 true，则添加到注释的开头，否则添加到同一行的末尾
-     */
-    comment(path, comment, prepend) {
-        if (!path)
-            throw new Error('[YamlEditor] path 不能为空');
-        const pair = this.getpair(path);
-        if (!pair)
-            throw new Error(`[YamlEditor] 未找到节点 ${path}`);
-        comment = ` ${comment}`;
-        if (prepend) {
-            pair.key.commentBefore = comment;
-        }
-        else {
-            pair.key.comment = comment;
-        }
-    }
-    /**
-     * 删除指定键的注释
-     * @param path - 路径，多个路径使用`.`连接，例如：`a.b.c`
-     * @param type - 要删除的注释类型，`before` 为注释前，`after` 为注释后，`all` 为全部
-     */
-    uncomment(path, type = 'all') {
-        if (!path)
-            throw new Error('[YamlEditor] path 不能为空');
-        const pair = this.getpair(path);
-        if (!pair)
-            throw new Error(`[YamlEditor] 未找到节点 ${path}`);
-        if (type === 'all') {
-            delete pair.key.comment;
-            delete pair.key.commentBefore;
-        }
-        else if (type === 'before') {
-            delete pair.key.commentBefore;
-        }
-        else if (type === 'after') {
-            delete pair.key.comment;
-        }
-    }
-    /**
-     * 检查注释是否存在
-     * @param path - 路径，多个路径使用`.`连接，例如：`a.b.c`
-     * @param type - 要检查的注释类型，`before` 为注释前，`after` 为注释后
-     */
-    hascomment(path, type) {
-        if (!path)
-            throw new Error('[YamlEditor] path 不能为空');
-        const pair = this.getpair(path);
-        if (!pair)
-            throw new Error(`[YamlEditor] 未找到节点 ${path}`);
-        if (type === 'before') {
-            return !!pair.key.commentBefore;
-        }
-        else if (type === 'after') {
-            return !!pair.key.comment;
-        }
-        return false;
-    }
-    /**
-     * 保存文件
-     * 保存失败会抛出异常
-     */
-    save() {
-        fs.writeFileSync(this.filePath, this.document.toString());
-        logger.debug('[YamlEditor] 文件已保存');
-    }
-}

package/lib/utils/core/handler.d.ts

@@ -1,18 +0,0 @@
-/**
- * 事件处理器类
- */
-export declare const handler: {
-    /**
-     * 调用事件处理器
-     * @param key 事件键
-     * @param args 自定义参数 一般用来传递e之类的
-     */
-    call(key: string, args: {
-        [key: string]: any;
-        e?: any;
-    }): Promise<any>;
-    /**
-     * 检查是否存在指定键的事件处理器
-     */
-    has(key: string): boolean;
-};

package/lib/utils/core/handler.js

@@ -1,46 +0,0 @@
-import logger from './logger.js';
-import { pluginLoader as loader } from '../../core/index.js';
-/**
- * 事件处理器类
- */
-export const handler = new (class EventHandler {
-    /**
-     * 调用事件处理器
-     * @param key 事件键
-     * @param args 自定义参数 一般用来传递e之类的
-     */
-    async call(key, args) {
-        let res;
-        for (const info of loader.handler[key] || []) {
-            const plugin = loader.plugin.get(info.key);
-            try {
-                let done = true;
-                /**
-                 * 拒绝处理器 调用后则不再继续执行下一个处理器
-                 * @param msg 错误信息
-                 */
-                const reject = (msg = '') => {
-                    if (msg)
-                        logger.mark(`[Handler][Reject]: [${plugin.plugin}][${info.name}][${key}] ${msg}`);
-                    done = false;
-                };
-                res = await info.fn(args, reject);
-                if (done) {
-                    logger.mark(`[Handler][Done]: [${plugin.plugin}][${info.name}][${key}]`);
-                    return res;
-                }
-            }
-            catch (e) {
-                // 产生错误继续下一个处理器
-                logger.error(`[Handler][Error]: [${plugin.plugin}][${info.name}][${key}] ${e}`);
-            }
-        }
-        return res;
-    }
-    /**
-     * 检查是否存在指定键的事件处理器
-     */
-    has(key) {
-        return !!loader.handler[key];
-    }
-})();

package/lib/utils/core/logger.d.ts

@@ -1,3 +0,0 @@
-import log4js from 'log4js';
-export declare const logger: log4js.Logger;
-export default logger;

package/lib/utils/core/logger.js

@@ -1,105 +0,0 @@
-import fs from 'fs';
-import chalk from 'chalk';
-import log4js from 'log4js';
-import { config } from '../config/config.js';
-const logsDir = './logs';
-if (!fs.existsSync(logsDir))
-    fs.mkdirSync(logsDir);
-const { log_level, log_days_Keep, log4jsCfg } = config.Config;
-const level = log_level || log4jsCfg.level || 'info';
-const daysToKeep = log_days_Keep || log4jsCfg.daysToKeep || 7;
-const { overall, fragments, maxLogSize } = log4jsCfg;
-const defaultOptions = { appenders: ['console'], level, enableCallStack: process.env.KarinMode === 'dev' };
-const options = {
-    appenders: {
-        console: {
-            type: 'console',
-            layout: {
-                type: 'pattern',
-                pattern: `%[[Karin][%d{hh:mm:ss.SSS}][%4.4p]%] ${process.env.KarinMode === 'dev' ? '[%f{3}:%l] ' : ''}%m`,
-            },
-        },
-    },
-    categories: { default: defaultOptions },
-};
-if (overall) {
-    defaultOptions.appenders.unshift('overall');
-    options.appenders.overall = {
-        /** 输出到文件 */
-        type: 'file',
-        filename: 'logs/logger',
-        pattern: 'yyyy-MM-dd.log',
-        /** 日期后缀 */
-        keepFileExt: true,
-        /** 日志文件名中包含日期模式 */
-        alwaysIncludePattern: true,
-        /** 日志文件保留天数 */
-        daysToKeep,
-        /** 日志输出格式 */
-        layout: {
-            type: 'pattern',
-            pattern: '[%d{hh:mm:ss.SSS}][%4.4p] %m',
-        },
-    };
-}
-if (fragments) {
-    defaultOptions.appenders.unshift('fragments');
-    options.appenders.fragments = {
-        type: 'file',
-        filename: 'logs/app.log',
-        pattern: 'MM-dd.log',
-        keepFileExt: true,
-        alwaysIncludePattern: true,
-        daysToKeep,
-        maxLogSize: (maxLogSize || 30) * 1024 * 1024,
-        /** 最大文件数 */
-        numBackups: 9999999,
-        /** 日志输出格式 */
-        layout: {
-            type: 'pattern',
-            pattern: '[%d{hh:mm:ss.SSS}][%4.4p] %m',
-        },
-    };
-}
-log4js.configure(options);
-export const logger = log4js.getLogger('default');
-logger.chalk = chalk;
-logger.red = chalk.red;
-logger.green = chalk.green;
-logger.yellow = chalk.yellow;
-logger.blue = chalk.blue;
-logger.magenta = chalk.magenta;
-logger.cyan = chalk.cyan;
-logger.white = chalk.white;
-logger.gray = chalk.gray;
-logger.violet = chalk.hex('#868ECC');
-logger.fnc = chalk.hex(config.Config.log_color || '#FFFF00');
-logger.bot = (level, id, ...args) => {
-    switch (level) {
-        case 'trace':
-            logger.trace(logger.violet(`[Bot:${id}]`), ...args);
-            break;
-        case 'debug':
-            logger.debug(logger.violet(`[Bot:${id}]`), ...args);
-            break;
-        case 'mark':
-            logger.mark(logger.violet(`[Bot:${id}]`), ...args);
-            break;
-        case 'info':
-            logger.info(logger.violet(`[Bot:${id}]`), ...args);
-            break;
-        case 'warn':
-            logger.warn(logger.violet(`[Bot:${id}]`), ...args);
-            break;
-        case 'error':
-            logger.error(logger.violet(`[Bot:${id}]`), ...args);
-            break;
-        case 'fatal':
-            logger.fatal(logger.violet(`[Bot:${id}]`), ...args);
-            break;
-        default:
-            logger.info(logger.violet(`[Bot:${id}]`), ...args);
-    }
-};
-global.logger = logger;
-export default logger;