koishi-plugin-canvas - npm Package Compare versions

Comparing version 0.1.1 to 0.1.2

dist/index.d.ts

 /// <reference types="koishi/lib" />
-import { Context, Service, Schema } from 'koishi';
+import { Context, Service, Schema as S } from 'koishi';
 import skiaCanvas from 'skia-canvas';
@@ -12,7 +12,19 @@ declare module 'koishi' {
 interface FontOptions {
+    /**
+     * 字体注册成的名字。
+     */
     family: string;
-    weight?: string;
+    /**
+     * 字体注册成的字重，如 700 或者 bold。
+     */
+    weight?: string | number;
+    /**
+     * 字体注册成的样式，如斜体、花体等。
+     */
     style?: string;
 }
 interface FontOptionsConfig extends FontOptions {
+    /**
+     * 字体对于工作路径的相对路径。
+     */
     path: string;
@@ -32,5 +44,10 @@ }
     interface Config {
+        /**
+         * 字体列表。
+         *
+         * @default []
+         */
         fonts?: FontOptionsConfig[];
     }
-    const Config: Schema<{
+    const Config: S<{
         fonts?: ({
@@ -61,1 +78,2 @@ path?: string | undefined;
 export default ServiceCanvas;
+export * from 'skia-canvas';

dist/index.js

@@ -37,2 +37,3 @@ var __create = Object.create;
 var import_skia_canvas = __toESM(require("skia-canvas"));
+__reExport(src_exports, require("skia-canvas"));
 import_koishi.Context.service("canvas");
@@ -73,7 +74,7 @@ var logger = new import_koishi.Logger("canvas");
     fonts: import_koishi.Schema.array(import_koishi.Schema.object({
-      path: import_koishi.Schema.string().required(),
-      family: import_koishi.Schema.string().required(),
-      weight: import_koishi.Schema.union([import_koishi.Schema.string(), import_koishi.Schema.number()]),
-      style: import_koishi.Schema.string()
-    })).default([])
+      path: import_koishi.Schema.string().required().description("\u5B57\u4F53\u5BF9\u4E8E\u5DE5\u4F5C\u8DEF\u5F84\u7684\u76F8\u5BF9\u8DEF\u5F84\u3002"),
+      family: import_koishi.Schema.string().required().description("\u5B57\u4F53\u6CE8\u518C\u6210\u7684\u540D\u5B57\u3002"),
+      weight: import_koishi.Schema.union([import_koishi.Schema.string(), import_koishi.Schema.number()]).description("\u5B57\u4F53\u6CE8\u518C\u6210\u7684\u5B57\u91CD\uFF0C\u5982 700 \u6216\u8005 bold\u3002"),
+      style: import_koishi.Schema.string().description("\u5B57\u4F53\u6CE8\u518C\u6210\u7684\u6837\u5F0F\uFF0C\u5982\u659C\u4F53\u3001\u82B1\u4F53\u7B49\u3002")
+    })).default([]).description("\u5B57\u4F53\u5217\u8868\u3002\u683C\u5F0F\u53C2\u7167 https://github.com/idlist/koishi-plugin-canvas \u7684 README\uFF0C\u6682\u65F6\u65E0\u6CD5\u5728\u63A7\u5236\u53F0\u914D\u7F6E\u3002")
   });
@@ -87,2 +88,2 @@ })(ServiceCanvas || (ServiceCanvas = {}));
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package.json

 {
   "name": "koishi-plugin-canvas",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Provide `ctx.canvas` using skia-canvas for Koishi.js",
@@ -5,0 +5,0 @@ "author": "i'DLisT <[e-mail]> (https://idl.ist)",

README.md

 # koishi-plugin-canvas
 
-非常简陋的 `ctx.canvas` 接口提供，主要是我自己用着方便（其实也并没有很方便）。
+使用 [skia-canvas](https://github.com/samizdatco/skia-canvas) 提供的简陋的 `ctx.canvas` 接口，主要是我自己用着方便（虽然其实并没有多方便）。
 
+## 为什么？
+
+这个服务主要是为了解决 **字体注册** 的问题。为了使用本地字体，需要使用 `registerFont` (`node-canvas`) 或者 `Fontlibrary.use` (`skia-canvas`) 注册字体，但是这么做有个问题：同一个字体在不同的插件中会需要以不同的名字重复注册，因为不知道其他插件是否注册过这个字体。同名重复注册会导致报错，而且就算 `try catch` 了报错，也不知道其他插件用这个名字注册的字体是不是就是想用的字体。
+
+将 `canvas` 独立成服务能一定程度上解决这个问题，因为可以在 `canvas` 服务的配置项中统一注册字体，然后在其他需要用到字体的插件中将字体暴露为配置项，进行统一配置。
+
 ## 安装方法
@@ -11,4 +17,106 @@
 
-## 使用方法
+然后在配置文件或入口文件中将插件添加至你的机器人中。
 
-咕咕，配置项主要是用来配置字体的。
+## 插件配置项
+
+这个插件提供了以下配置项：
+
+| 配置项 | 默认值 | 说明 |
+| - | - | - |
+| `fonts` | `[]` **\*1**  | 注册字体 |
+
+**\*1** 这个列表的每个元素的类型为
+
+```ts
+interface {
+  path: string
+  family: string
+  weight?: string | number
+  style?: string
+}
+```
+
+- `path`: 字体对于工作路径的相对路径
+
+- `family`: 字体注册成的名字
+
+- `weight`（可选）: 字体注册成的字重，如 700 或者 bold
+
+- `style`（可选）：字体注册成的样式，如斜体、花体等
+
+而且实际上，`skia-canvas` 注册字体的时候是 **无法提供** `weight` 和 `style` 的，所以不填也没关系。我也不知道为什么要留这两个选项在这里。
+
+成功注册字体时，控制台会提示字体注册成功，以及字体的名字、字重和样式。
+
+## 服务拓展方法
+
+以下方法通过 `ctx.canvas` 暴露给插件：
+
+#### `canvas.createCanvas(width?: number, height?: number)`
+
+- `width`（可选）: 画布的宽度
+
+- `height`（可选）: 画布的高度
+
+- 返回值: `Canvas`
+
+新建一个 `Canvas` 对象并返回它。下面是一个一般的新建样例，因为 `canvas` 的 `ctx` 和 `koishi` 的 `ctx` 重名，你需要在代码中给其中一个赋予不同的名字。
+
+```js
+const canvas = ctx.canvas.createCanvas // 这里的 ctx 是 koishi 的 ctx
+const canvasCtx = canvas.getContext('2d')
+```
+
+`Canvas` 的用法请参照 MDN。
+
+#### `canvas.registerFont(path: string, options: FontOptions)`
+
+- `path`: 字体对于工作路径的相对路径
+
+- `options`: 字体详情，各属性的意义和 **插件配置项** 中的意义一致。
+
+```ts
+interface FontOptions {
+  family: string
+  weight?: string
+  style?: string
+}
+```
+
+注册本地字体。配置项中的 `fonts` 也是通过这个方法进行注册。
+
+#### `loadImage(url: string)`
+
+加载图片，详情见 [这里](https://github.com/samizdatco/skia-canvas#loadimage) 。简单地说，可以快速加载网络图片或者本地图片为 `canvas` 可用的对象。
+
+## `Canvas` 拓展方法
+
+以下方法扩展由 `ctx.createCanvas` 所创建的 `Canvas` 对象，并非标准方法，基本是我自己用起来方便所以整出来的。
+
+#### `Canvas.renderResize(factor: number)`
+
+- `factor`: 倍率
+
+- 返回值：`Canvas`
+
+将当前 `Canvas` 按一定倍率（`factor`）缩放渲染，然后返回选然后的新的 `Canvas`。这个方法的意义在于通过在创建的时候按 N 倍于设计大小作图，然后输出时缩放回设计大小，达成不同平台之间渲染结果在一定程度上的一致。
+
+#### `Canvas.toBase64()`
+
+- 返回值：`string` 被 Base64 编码的图片
+
+将图片转化为 Base64 编码以供发送。
+
+## 最终手段
+
+这个插件也重新导出了 `skia-canvas` 本身。在有需要的情况下，可以直接从插件中获取原始方法。反正一时半会这玩意成不了规范，先随便写了。
+
+```js
+const { FontLibrary } = require('koishi-plugin-canvas')
+```
+
+## Q&A
+
+- 这玩意怎么实现得这么粗糙？
+
+因为就是这么粗糙。

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

24550

increased by47.49%

Lines of code

187

increased by15.43%

Number of lines in readme file

121

increased by830.77%

Worsened metrics

Number of downloads

38

decreased by-30.91%

No dependency changes