node-karin 0.9.0 → 0.10.1

package/lib/utils/config/yamlEditor.js

@@ -0,0 +1,292 @@
+/*
+ * 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);
+        }
+        catch (error) {
+            logger.error(`[YamlEditor] 设置数据时出错：${error}`);
+            return null;
+        }
+    }
+    /**
+     * 向指定路径添加新值
+     * @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} 添加新的值`);
+        }
+        catch (error) {
+            logger.error(`[YamlEditor] 添加数据时出错：${error}`);
+        }
+    }
+    /**
+     * 删除指定路径
+     * @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)) {
+                throw new Error('[YamlEditor] 指定的路径不是数组');
+            }
+            else {
+                prepend ? current.items.unshift(value) : current.add(value);
+            }
+            logger.debug(`[YamlEditor] 已向 ${path} 数组${prepend ? '开头' : '末尾'}添加新元素：${value}`);
+        }
+        catch (error) {
+            logger.error(`[YamlEditor] 向数组添加元素时出错：${error}`);
+        }
+    }
+    /**
+     * 检查指定路径的键是否存在
+     * @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);
+        }
+        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/{handler.d.ts → core/handler.d.ts}

@@ -1,4 +1,4 @@
-import { PluginType, PluginApps } from '../types/index.js';
+import { PluginType, PluginApps } from '../../types/index.js';
 /**
  * 事件处理器类
  */

package/lib/utils/core/handler.js

@@ -0,0 +1,115 @@
+import lodash from 'lodash';
+import logger from './logger.js';
+import { pluginLoader as loader } from '../../core/index.js';
+/**
+ * 事件处理器类
+ */
+export const handler = new (class EventHandler {
+    /**
+     * 添加事件处理器
+     * @param index 插件索引
+     * @param Class 插件类
+     */
+    async add(index, Class) {
+        lodash.forEach(Class.handler, val => {
+            if (!val.key)
+                logger.error(`[Handler][Add]: [${Class.name}] 缺少 key`);
+            if (!val.fnc)
+                logger.error(`[Handler][Add]: [${Class.name}] 缺少 fnc`);
+            logger.debug(`[Handler][Reg]: [${Class.name}][${val.key}]`);
+            if (!Array.isArray(loader.handlerIds[val.key]))
+                loader.handlerIds[val.key] = [];
+            loader.handlerIds[val.key].push({ index, fnc: val.fnc, priority: val.priority || Class.priority });
+            loader.handlerIds[val.key] = lodash.orderBy(loader.handlerIds[val.key], ['priority'], ['asc']);
+        });
+    }
+    /**
+     * 删除事件处理器
+     * 如果不传参数则删除所有处理器
+     * @param index 插件索引
+     * @param key 事件键
+     */
+    del(index = '', key = '') {
+        /** 无参 */
+        if (!key && !index) {
+            loader.handlerIds = {};
+            return true;
+        }
+        /** 删除指定索引插件 */
+        if (!key) {
+            for (const v of Object.keys(loader.handlerIds)) {
+                loader.handlerIds[v] = loader.handlerIds[v].filter(v => v.index !== index);
+                // 如果处理器为空则删除键
+                if (!loader.handlerIds[v].length) {
+                    delete loader.handlerIds[v];
+                }
+                else {
+                    loader.handlerIds[v] = lodash.orderBy(loader.handlerIds[v], ['priority'], ['asc']);
+                }
+            }
+            return true;
+        }
+        /** 删除指定key */
+        if (!index) {
+            loader.handlerIds[key] && delete loader.handlerIds[key];
+            return true;
+        }
+        /** 删除指定key的index */
+        if (!loader.handlerIds[key])
+            return false;
+        loader.handlerIds[key] = loader.handlerIds[key].filter(v => v.index !== index);
+        if (!loader.handlerIds[key].length) {
+            delete loader.handlerIds[key];
+            return true;
+        }
+        loader.handlerIds[key] = lodash.orderBy(loader.handlerIds[key], ['priority'], ['asc']);
+        return true;
+    }
+    /**
+     * 调用事件处理器
+     * @param key 事件键
+     * @param args 自定义参数 一般用来传递e之类的
+     */
+    async call(key, args) {
+        let res;
+        for (const v of loader.handlerIds[key] || []) {
+            const info = loader.PluginList[v.index];
+            try {
+                let done = true;
+                /**
+                 * 拒绝处理器 调用后则不再继续执行下一个处理器
+                 * @param msg 错误信息
+                 */
+                const reject = (msg = '') => {
+                    if (msg)
+                        logger.mark(`[Handler][Reject]: [${info.file.dir}][${info.file.name}][${key}] ${msg}`);
+                    done = false;
+                };
+                if (info.file.type === 'function' && typeof v.fnc === 'function') {
+                    res = await v.fnc(args, reject);
+                }
+                else {
+                    const cla = new info.file.Fnc();
+                    if (args.e)
+                        cla.e = args.e;
+                    res = await cla[v.fnc](args, reject);
+                }
+                if (done) {
+                    logger.mark(`[Handler][Done]: [${info.file.dir}][${info.file.name}][${key}]`);
+                    return res;
+                }
+            }
+            catch (e) {
+                // 产生错误继续下一个处理器
+                logger.error(`[Handler][Error]: [${info.file.dir}][${info.file.name}][${key}] ${e}`);
+            }
+        }
+        return res;
+    }
+    /**
+     * 检查是否存在指定键的事件处理器
+     */
+    has(key) {
+        return !!loader.handlerIds[key];
+    }
+})();

package/lib/utils/core/init.js

@@ -0,0 +1,213 @@
+import fs from 'fs';
+import path from 'path';
+import { exec } from 'child_process';
+import { karinDir } from '../../core/index.js';
+export class KarinInit {
+    /**
+     * 基础目录
+     */
+    baseDir;
+    constructor() {
+        this.baseDir = [
+            './config/config',
+            './config/view',
+            './config/plugin',
+            './temp/input',
+            './temp/html',
+            './plugins/karin-plugin-example',
+        ];
+    }
+    init() {
+        this.baseDir.forEach(dir => this.mkdir(dir));
+        /** 非src源代码环境才创建 */
+        if (!fs.existsSync('./src')) {
+            this.copyFile();
+            this.modifyPackage();
+        }
+    }
+    /**
+     * 递归创建目录
+     * @param dirname - 路径
+     */
+    mkdir(dirname) {
+        if (fs.existsSync(dirname))
+            return true;
+        if (this.mkdir(path.dirname(dirname)))
+            fs.mkdirSync(dirname);
+        return true;
+    }
+    /**
+     * 解析json
+     */
+    readJson(file) {
+        return JSON.parse(fs.readFileSync(file, 'utf-8'));
+    }
+    /**
+     * 获取插件列表
+     */
+    getPlugins() {
+        const pluginsDir = './plugins';
+        const plugins = fs.readdirSync(pluginsDir);
+        return plugins.filter(dir => dir.startsWith('karin-plugin-'));
+    }
+    /**
+     * 从npm包内复制默认配置出来
+     */
+    copyFile() {
+        /** 配置 */
+        const list = ['config/view'];
+        list.forEach(dir => {
+            const pkgDir = path.join(karinDir, dir);
+            const projDir = path.join(process.cwd(), dir);
+            /** 清空projDir目录下的文件 保留目录 */
+            if (fs.existsSync(projDir))
+                fs.rmSync(projDir, { recursive: true });
+            this.mkdir(projDir);
+            /** 读取pkgDir目录下的所有文件 复制到projDir下 */
+            const files = fs.readdirSync(pkgDir).filter(file => file.endsWith('.yaml'));
+            files.forEach(file => {
+                const destPath = path.join(projDir, file);
+                const srcPath = path.join(pkgDir, file);
+                fs.copyFileSync(srcPath, destPath);
+            });
+        });
+        /** 创建pnpm工作区配置 */
+        fs.writeFileSync('./pnpm-workspace.yaml', `packages:\n  - 'plugins/**'\n`);
+        /** 为每个插件包创建统一存储的文件夹 */
+        const plugins = this.getPlugins();
+        const DataList = [
+            'data',
+            'temp',
+            'resources',
+            'temp/html',
+            'config/plugin',
+        ];
+        DataList.forEach(_path => {
+            _path = path.join(process.cwd(), _path);
+            plugins.forEach(plugin => this.mkdir(path.join(_path, plugin)));
+        });
+    }
+    /**
+     * 修改package.json以支持运行
+     */
+    modifyPackage() {
+        const pkg = this.readJson(path.join(karinDir, 'package.json'));
+        const projPkg = this.readJson('./package.json');
+        const main = 'node_modules/node-karin/lib/index.js';
+        delete pkg.bin;
+        pkg.main = `./${main}`;
+        pkg.types = `./${main.replace('.js', '.d.ts')}`;
+        pkg.dependencies = { ...projPkg.dependencies, ...pkg.dependencies };
+        pkg.devDependencies = { ...projPkg.devDependencies, ...pkg.devDependencies };
+        projPkg.type = 'module';
+        projPkg.private = true;
+        projPkg.main = `./${main}`;
+        projPkg.dependencies = { ...projPkg.dependencies, ...pkg.dependencies };
+        projPkg.dependencies['node-karin'] = 'latest';
+        projPkg.dependencies['kritor-proto'] = 'latest';
+        if (!projPkg.scripts)
+            projPkg.scripts = {};
+        if (!projPkg.devDependencies)
+            projPkg.devDependencies = {};
+        projPkg.scripts.debug = `node --watch ${main}`;
+        projPkg.scripts.dev = `tsx --watch ${main}`;
+        fs.writeFileSync('./package.json', JSON.stringify(projPkg, null, 2));
+    }
+    /**
+     * 更换镜像源为淘宝源
+     */
+    async changeRegistry(host) {
+        const cmd = `npm config set registry ${host}`;
+        // 检查当前镜像源是否为淘宝源
+        const registry = await this.shell('npm config get registry');
+        if (registry === host) {
+            console.log(`当前npm源已经是 ${host} ~`);
+            return;
+        }
+        if (!await this.shell(cmd)) {
+            console.log('更换npm源失败，请手动更换npm源！');
+            console.log(`可尝试手动执行 【 npm config set registry ${host} 】 更换镜像源~`);
+        }
+        else {
+            console.log('更换npm源成功~');
+        }
+    }
+    /**
+     * 安装pnpm或者yarn
+     * @param type - 包管理器名称
+     */
+    async install(type) {
+        /** 检查是否已经安装对应的包管理器 */
+        if (!(await this.shell(`${type} -v`))) {
+            console.log(`检测到未安装${type}，开始安装...`);
+            if (!await this.shell(`npm install -g ${type}`)) {
+                console.log(`${type}安装失败，请手动安装${type}！`);
+                console.log(`可尝试手动执行 【 npm install -g ${type} 】 安装${type}~`);
+                return;
+            }
+            else {
+                console.log(`${type}安装完成~`);
+            }
+        }
+        else {
+            console.log('检测到已安装pnpm，开始安装依赖...');
+        }
+        /** 安装依赖 */
+        if (!(await this.shell(`${type} -P --force`))) {
+            console.log('安装依赖失败，请手动安装依赖！');
+            console.log(`可尝试手动执行 【 ${type} install -P 】 安装依赖~`);
+            console.log('如中国大陆用户安装失败，请尝试执行换源 【 npm config set registry https://registry.npmmirror.com 】后再安装依赖~');
+        }
+        else {
+            console.log('依赖安装完成~');
+        }
+        /** 检查安装pm2 */
+        if (!(await this.shell('pm2 -v'))) {
+            console.log('检测到未安装pm2，开始安装pm2...');
+            if (!(await this.shell(`${type} install -g pm2`))) {
+                console.log('安装pm2失败，请手动安装pm2！');
+                console.log('可尝试手动执行 【 npm install -g pm2 】 安装pm2~');
+            }
+            else {
+                console.log('pm2安装完成~');
+            }
+        }
+        else {
+            console.log('检测到已安装pm2~');
+        }
+        console.log('依赖环境初始化完成~');
+    }
+    /**
+     * 执行命令
+     * @param cmd - 命令
+     */
+    shell(cmd) {
+        return new Promise(resolve => {
+            exec(cmd, { env: process.env, cwd: process.cwd() }, (err, stdout, stderr) => {
+                if (stdout)
+                    return resolve(stdout.trim());
+                if (err) {
+                    console.error(err);
+                    return resolve(false);
+                }
+                if (stderr) {
+                    console.error(stderr);
+                    return resolve(false);
+                }
+            });
+        });
+    }
+    /**
+     * 获取当前的包管理器 根据锁文件判断
+     */
+    getRegistry() {
+        if (fs.existsSync('./pnpm-lock.yaml'))
+            return 'pnpm';
+        if (fs.existsSync('./yarn.lock'))
+            return 'yarn';
+        if (fs.existsSync('./package-lock.json'))
+            return 'npm';
+        // cnpm 没有锁文件
+        return 'cnpm';
+    }
+}