node-karin 0.6.27 → 0.6.28

package/lib/core/plugin.loader.d.ts

@@ -103,8 +103,9 @@ declare class PluginLoader {
      * @param name - 插件名称
      * @param isOrderBy - 是否为动态导入 默认为静态导入
      * @param isNpm - 是否为npm包
+     * @param isMain - 是否为主入口文件
      */
-    createdApp(dir: dirName, name: fileName, isOrderBy?: boolean, isNpm?: boolean): Promise<boolean>;
+    createdApp(dir: dirName, name: fileName, isOrderBy?: boolean, isNpm?: boolean, isMain?: boolean): Promise<boolean>;
     /**
      * 新增rule
      */

package/lib/core/plugin.loader.js

@@ -98,7 +98,7 @@ class PluginLoader {
     /** 获取npm插件 */
     const npm = await common.getNpmPlugins(true)
     /** 载入npm插件 */
-    promises.push(...npm.map(async ({ dir, name }) => await this.createdApp(dir, name, false, true)))
+    promises.push(...npm.map(async ({ dir, name, isMain }) => await this.createdApp(dir, name, false, true, isMain)))
     /** 等待所有插件加载完成 */
     await Promise.all(promises)
     /** 释放缓存 */
@@ -252,13 +252,16 @@ class PluginLoader {
      * @param name - 插件名称
      * @param isOrderBy - 是否为动态导入 默认为静态导入
      * @param isNpm - 是否为npm包
+     * @param isMain - 是否为主入口文件
      */
-  async createdApp (dir, name, isOrderBy = false, isNpm = false) {
+  async createdApp (dir, name, isOrderBy = false, isNpm = false, isMain = false) {
     try {
       const list = []
       let path = `${this.dirPath}${isNpm ? 'node_modules' : 'plugins'}/${dir}/${name}`
       if (isOrderBy) { path = path + `?${Date.now()}` }
       const tmp = await import(path)
+      /** npm包的入口文件不作为app载入 只加载 */
+      if (isMain) { return true }
       lodash.forEach(tmp, (App) => {
         const index = this.index
         this.index++

package/lib/utils/common.d.ts

@@ -148,6 +148,7 @@ export declare const common: {
     getNpmPlugins<T extends boolean>(showDetails: T): Promise<T extends true ? {
         dir: string;
         name: fileName;
+        isMain: boolean;
     }[] : string[]>;
     /**
      * 获取运行时间

package/lib/utils/common.js

@@ -426,7 +426,7 @@ export const common = new (class Common {
           if (pkg?.karin) {
             if (pkg?.main) {
               const dir = `${name}/${path.dirname(pkg.main).replace(/\.\//, '')}`
-              list.push({ dir, name: path.basename(pkg.main) })
+              list.push({ dir, name: path.basename(pkg.main), isMain: true })
             }
             if (pkg?.karin?.apps?.length) {
               pkg.karin.apps.forEach((app) => {
@@ -434,7 +434,7 @@ export const common = new (class Common {
                   /** 忽略非js */
                   if (!name.endsWith('.js')) { return }
                   const dir = `${name}/${app}`
-                  list.push({ dir, name })
+                  list.push({ dir, name, isMain: false })
                 })
               })
             }

package/lib/utils/yamlEditor.d.ts

@@ -1,60 +1,85 @@
 import Yaml from 'yaml';
+export type YamlValue = string | boolean | number | object | any[];
 export declare class YamlEditor {
     filePath: string;
     document: Yaml.Document;
-    constructor(filePath: string);
-    load(): void;
+    constructor(file: string);
     /**
      * 获取指定路径的值
-     * @param path - 路径，用点号分隔，例如：'a.b.c'
+     * @param path - 路径，多个路径使用`.`连接，例如：`a.b.c`
      */
     get(path: string): any;
     /**
      * 设置指定路径的值
-     * @param path - 路径，用点号分隔，例如：'a.b.c'
-     * @param value - 要设置的值
+     * @param path - 路径，多个路径使用`.`连接，例如：`a.b.c`
+     * @param value - 要设置的值 允许的类型：`string`, `boolean`, `number`, `object`, `array`
      */
-    set(path: string | string[], value: string | boolean): null | undefined;
+    set(path: string, value: YamlValue): null | undefined;
     /**
      * 向指定路径添加新值
-     * @param path - 路径，用点号分隔，例如：'a.b.c'
+     * @param path - 路径，多个路径使用`.`连接，例如：`a.b.c`
      * @param value - 要添加的值
      */
-    add(path: string | string[], value: string): void;
+    add(path: string, value: YamlValue): void;
     /**
      * 删除指定路径
-     * @param path - 路径，用点号分隔，例如：'a.b.c'
+     * @param path - 路径，多个路径使用`.`连接，例如：`a.b.c`
      * @returns 是否删除成功
      */
-    del(path: string | string[]): boolean;
+    del(path: string): boolean;
     /**
      * 向指定路径的数组添加新值，可以选择添加到数组的开始或结束
-     * @param path - 路径，用点号分隔，例如：'a.b.c'
+     * @param path - 路径，多个路径使用`.`连接，例如：`a.b.c`
      * @param value - 要添加的值
      * @param prepend - 如果为 true，则添加到数组的开头，否则添加到末尾
      */
-    append(path: string | string[], value: string, prepend?: boolean): void;
+    append(path: string, value: string, prepend?: boolean): void;
     /**
      * 检查指定路径的键是否存在
      * @param path - 路径，用点号分隔
      */
-    has(path: string | string[]): boolean;
+    has(path: string): boolean;
     /**
      * 查询指定路径中是否包含指定的值
      * @param path - 路径，用点号分隔
      * @param value - 要查询的值
      */
-    hasVal(path: string | string[], value: any): boolean;
+    hasval(path: string, value: YamlValue): boolean;
+    /**
+     * 查询指定路径中是否包含指定的值
+     * @param path - 路径，用点号分隔
+     * @param value - 要查询的值
+     * @deprecated 请使用 `hasval` 代替
+     */
+    hasVal(path: string, value: YamlValue): boolean;
     /**
      * 向根节点新增元素，如果根节点不是数组，则将其转换为数组再新增元素
      * @param value - 要新增的元素
      */
-    pusharr(value: any): false | undefined;
+    pusharr(value: YamlValue): false | undefined;
     /**
      * 根据索引从根节点数组删除元素
      * @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;
     /**
      * 保存文件
      */

package/lib/utils/yamlEditor.js

@@ -4,30 +4,20 @@
  * https://github.com/OpenAI
  */
 import fs from 'fs'
-import Yaml from 'yaml'
 import lodash from 'lodash'
 import logger from './logger.js'
+import Yaml, { isMap, isSeq, isPair } from 'yaml'
 export class YamlEditor {
   filePath
   document
-  constructor (filePath) {
-    this.filePath = filePath
-    this.load()
-  }
-
-  load () {
-    try {
-      const fileContents = fs.readFileSync(this.filePath, 'utf8')
-      this.document = Yaml.parseDocument(fileContents)
-      logger.debug('[YamlEditor] 文件加载成功')
-    } catch (error) {
-      logger.error(`[YamlEditor] 加载文件时出错：${error}`)
-    }
+  constructor (file) {
+    this.filePath = file
+    this.document = Yaml.parseDocument(fs.readFileSync(file, 'utf8'))
   }
 
   /**
      * 获取指定路径的值
-     * @param path - 路径，用点号分隔，例如：'a.b.c'
+     * @param path - 路径，多个路径使用`.`连接，例如：`a.b.c`
      */
   get (path) {
     try {
@@ -41,13 +31,13 @@ export class YamlEditor {
 
   /**
      * 设置指定路径的值
-     * @param path - 路径，用点号分隔，例如：'a.b.c'
-     * @param value - 要设置的值
+     * @param path - 路径，多个路径使用`.`连接，例如：`a.b.c`
+     * @param value - 要设置的值 允许的类型：`string`, `boolean`, `number`, `object`, `array`
      */
   set (path, value) {
     try {
-      path = typeof path === 'string' ? path.split('.') : path
-      this.document.setIn(path, value)
+      const _path = typeof path === 'string' ? path.split('.') : path
+      this.document.setIn(_path, value)
     } catch (error) {
       logger.error(`[YamlEditor] 设置数据时出错：${error}`)
       return null
@@ -56,13 +46,13 @@ export class YamlEditor {
 
   /**
      * 向指定路径添加新值
-     * @param path - 路径，用点号分隔，例如：'a.b.c'
+     * @param path - 路径，多个路径使用`.`连接，例如：`a.b.c`
      * @param value - 要添加的值
      */
   add (path, value) {
     try {
-      path = typeof path === 'string' ? path.split('.') : path
-      this.document.addIn(path, value)
+      const _path = typeof path === 'string' ? path.split('.') : path
+      this.document.addIn(_path, value)
       logger.debug(`[YamlEditor] 已在 ${path} 添加新的值`)
     } catch (error) {
       logger.error(`[YamlEditor] 添加数据时出错：${error}`)
@@ -71,13 +61,13 @@ export class YamlEditor {
 
   /**
      * 删除指定路径
-     * @param path - 路径，用点号分隔，例如：'a.b.c'
+     * @param path - 路径，多个路径使用`.`连接，例如：`a.b.c`
      * @returns 是否删除成功
      */
   del (path) {
     try {
-      path = typeof path === 'string' ? path.split('.') : path
-      this.document.deleteIn(path)
+      const _path = typeof path === 'string' ? path.split('.') : path
+      this.document.deleteIn(_path)
       return true
     } catch (error) {
       logger.error(`[YamlEditor] 删除数据时出错：${error}`)
@@ -87,25 +77,21 @@ export class YamlEditor {
 
   /**
      * 向指定路径的数组添加新值，可以选择添加到数组的开始或结束
-     * @param path - 路径，用点号分隔，例如：'a.b.c'
+     * @param path - 路径，多个路径使用`.`连接，例如：`a.b.c`
      * @param value - 要添加的值
      * @param prepend - 如果为 true，则添加到数组的开头，否则添加到末尾
      */
   append (path, value, prepend = false) {
     try {
-      path = typeof path === 'string' ? path.split('.') : path || []
-      let current = this.document.getIn(path)
+      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)
+        this.document.setIn(_path, current)
       } else if (!(current instanceof Yaml.YAMLSeq)) {
         throw new Error('[YamlEditor] 指定的路径不是数组')
       } else {
-        if (prepend) {
-          current.items.unshift(value)
-        } else {
-          current.add(value)
-        }
+        prepend ? current.items.unshift(value) : current.add(value)
       }
       logger.debug(`[YamlEditor] 已向 ${path} 数组${prepend ? '开头' : '末尾'}添加新元素：${value}`)
     } catch (error) {
@@ -119,8 +105,8 @@ export class YamlEditor {
      */
   has (path) {
     try {
-      path = typeof path === 'string' ? path.split('.') : path
-      return this.document.hasIn(path)
+      const _path = typeof path === 'string' ? path.split('.') : path
+      return this.document.hasIn(_path)
     } catch (error) {
       logger.error(`[YamlEditor] 检查路径是否存在时出错：${error}`)
       return false
@@ -132,10 +118,10 @@ export class YamlEditor {
      * @param path - 路径，用点号分隔
      * @param value - 要查询的值
      */
-  hasVal (path, value) {
+  hasval (path, value) {
     try {
-      path = typeof path === 'string' ? path.split('.') : path
-      const current = this.document.getIn(path)
+      const _path = typeof path === 'string' ? path.split('.') : path
+      const current = this.document.getIn(_path)
       if (!current) { return false }
       /** 检查当前节点是否包含指定的值 */
       if (current instanceof Yaml.YAMLSeq) {
@@ -154,6 +140,16 @@ export class YamlEditor {
     }
   }
 
+  /**
+     * 查询指定路径中是否包含指定的值
+     * @param path - 路径，用点号分隔
+     * @param value - 要查询的值
+     * @deprecated 请使用 `hasval` 代替
+     */
+  hasVal (path, value) {
+    return this.hasval(path, value)
+  }
+
   /**
      * 向根节点新增元素，如果根节点不是数组，则将其转换为数组再新增元素
      * @param value - 要新增的元素
@@ -194,6 +190,63 @@ export class YamlEditor {
     }
   }
 
+  /**
+     * 获取指定路径的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 = false) {
+    if (!path) { throw new Error('[YamlEditor] path 不能为空') }
+    const pair = this.getpair(path)
+    if (!pair) { throw new Error(`[YamlEditor] 未找到节点 ${path}`) }
+    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
+    }
+  }
+
   /**
      * 保存文件
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-karin",
-  "version": "0.6.27",
+  "version": "0.6.28",
   "private": false,
   "description": "基于 Kritor 进行开发的nodejs机器人框架",
   "homepage": "https://github.com/KarinJS/Karin",