@sinm/kai 1.15.6 → 1.15.10
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +1 -1
- package/RELEASE_NOTES.md +140 -0
- package/dist-cli/kai-cli.js +134618 -122260
- package/dist-electron/main/image-worker.js +783 -0
- package/dist-electron/main/plugin-host.js +2131 -0
- package/dist-electron/renderer/assets/{ContextDraftStrip-CjD_aIKS.js → ContextDraftStrip-CM-2aRnV.js} +35 -4
- package/dist-electron/renderer/assets/{abnfDiagram-VCTEODGH-CbE-5j7z.js → abnfDiagram-VCTEODGH-iLecW1TW.js} +5 -5
- package/dist-electron/renderer/assets/{architectureDiagram-5GKGNRK7-yQjlB7ZG.js → architectureDiagram-5GKGNRK7-BIvCfRiX.js} +4 -4
- package/dist-electron/renderer/assets/{blockDiagram-I7D4REHJ-WzSifSeB.js → blockDiagram-I7D4REHJ-NRGeggD5.js} +4 -4
- package/dist-electron/renderer/assets/{c4Diagram-7LVT6UL2-CE9PPqyg.js → c4Diagram-7LVT6UL2-BSg76RQu.js} +3 -3
- package/dist-electron/renderer/assets/{channel-Bwk5OnRr.js → channel-CZNpz8aZ.js} +1 -1
- package/dist-electron/renderer/assets/{chunk-2Q5K7J3B-CMuA7hzd.js → chunk-2Q5K7J3B-TpREfQNV.js} +1 -1
- package/dist-electron/renderer/assets/{chunk-5VM5RSS4-BGmDWpiK.js → chunk-5VM5RSS4-Dx5XBylO.js} +1 -1
- package/dist-electron/renderer/assets/{chunk-F27PBJKO-2l13DDtO.js → chunk-F27PBJKO-ssuB-RvV.js} +1 -1
- package/dist-electron/renderer/assets/{chunk-IMKFNOWR-BWPxoDGL.js → chunk-IMKFNOWR-DGJglT7u.js} +4 -4
- package/dist-electron/renderer/assets/{chunk-JWPE2WC7-DO_UqdYo.js → chunk-JWPE2WC7-BxMNJ3kw.js} +1 -1
- package/dist-electron/renderer/assets/{chunk-POPQ4Y6H-CgMCEtdY.js → chunk-POPQ4Y6H-DsOrhId-.js} +1 -1
- package/dist-electron/renderer/assets/{chunk-SVP7TREG-DN-3IlG9.js → chunk-SVP7TREG-tFyzBLY8.js} +1 -1
- package/dist-electron/renderer/assets/{chunk-TICWLB2K-C_yHqIxf.js → chunk-TICWLB2K-BIDFdR0r.js} +5 -5
- package/dist-electron/renderer/assets/{chunk-XXDRQBXY-PgAVqYFz.js → chunk-XXDRQBXY-BfO9Gf-s.js} +1 -1
- package/dist-electron/renderer/assets/{classDiagram-v2-VYDZK3BY-DfOdpdD2.js → classDiagram-ZZMXUADV-CT83I5Ut.js} +7 -7
- package/dist-electron/renderer/assets/{classDiagram-ZZMXUADV-DfOdpdD2.js → classDiagram-v2-VYDZK3BY-CT83I5Ut.js} +7 -7
- package/dist-electron/renderer/assets/{cose-bilkent-JH36ORCC-Cnvclovc.js → cose-bilkent-JH36ORCC-9OEb8wry.js} +2 -2
- package/dist-electron/renderer/assets/{cynefin-OW5HDTMX-mcHo_rI0.js → cynefin-OW5HDTMX-C6cuZzhi.js} +1 -1
- package/dist-electron/renderer/assets/{cynefinDiagram-5FMLGOSQ-DbeJYBSc.js → cynefinDiagram-5FMLGOSQ-Dk2M-Zyq.js} +4 -4
- package/dist-electron/renderer/assets/{dagre-GXQ25YYZ-iGV1ny9W.js → dagre-GXQ25YYZ-Dmj1MVY7.js} +3 -3
- package/dist-electron/renderer/assets/desktop-overlay-reason-Lk3ArWYm.js +19050 -0
- package/dist-electron/renderer/assets/{diagram-S7CK7UJ4-ShxiibVl.js → diagram-S7CK7UJ4-DbapKOYy.js} +5 -5
- package/dist-electron/renderer/assets/{diagram-UQ7AKVKN-CieHgqW1.js → diagram-UQ7AKVKN-DHiczmNF.js} +4 -4
- package/dist-electron/renderer/assets/{diagram-VSXAHHWV-Itrh88Dw.js → diagram-VSXAHHWV-DOXR4DBZ.js} +4 -4
- package/dist-electron/renderer/assets/{diagram-VX7I27RA-C7iFOLds.js → diagram-VX7I27RA-Cb3JjTIf.js} +5 -5
- package/dist-electron/renderer/assets/{diagram-Z3DM3KII-vZxoo-6B.js → diagram-Z3DM3KII-zdd4OLYV.js} +4 -4
- package/dist-electron/renderer/assets/{ebnfDiagram-PWID7BFC-C-JC0fE4.js → ebnfDiagram-PWID7BFC-DIYkJiP7.js} +5 -5
- package/dist-electron/renderer/assets/{erDiagram-RLTQ6QDP-CjA2HjVB.js → erDiagram-RLTQ6QDP-CkH-F7Sv.js} +5 -5
- package/dist-electron/renderer/assets/{flowDiagram-HODETNUW-DB6NEym8.js → flowDiagram-HODETNUW-DsFNh2D5.js} +6 -6
- package/dist-electron/renderer/assets/{ganttDiagram-EL5Y4UJY-BQAp3mcf.js → ganttDiagram-EL5Y4UJY-CJ0JsQc4.js} +2 -2
- package/dist-electron/renderer/assets/{gitGraphDiagram-WWUBYQGX-CdbWsPmz.js → gitGraphDiagram-WWUBYQGX-d-Ppg-Uz.js} +5 -5
- package/dist-electron/renderer/assets/{image-Dv4svyoY.js → image-Br69X9uG.js} +2 -2
- package/dist-electron/renderer/assets/{index-BN25btDJ.js → index-2o21y_A2.js} +32526 -44529
- package/dist-electron/renderer/assets/{index-b6YGvhfY.js → index-B5MYHOIO.js} +3 -3
- package/dist-electron/renderer/assets/{index-iqyO2BeT.js → index-BOyfEjY-.js} +5 -5
- package/dist-electron/renderer/assets/{index-C29v38NI.css → index-CNIvLq5A.css} +5265 -2551
- package/dist-electron/renderer/assets/{index-DFCIIX3A.js → index-D-VQacpk.js} +4 -4
- package/dist-electron/renderer/assets/{index-D7Ss9lNE.js → index-D13SQmIx.js} +65 -11
- package/dist-electron/renderer/assets/{index-DPIe5Yez.js → index-DJvBCnCx.js} +4 -4
- package/dist-electron/renderer/assets/{index-DfdSq5dL.js → index-DQKbw6RS.js} +6 -6
- package/dist-electron/renderer/assets/{infoDiagram-27XIBGKW-CqdoBJIL.js → infoDiagram-27XIBGKW-CzIB68AG.js} +3 -3
- package/dist-electron/renderer/assets/{ishikawaDiagram-5VMMS53U-B-ImA85a.js → ishikawaDiagram-5VMMS53U-D7gtYlK2.js} +2 -2
- package/dist-electron/renderer/assets/{journeyDiagram-3NMN7TZE-ClVdMCq6.js → journeyDiagram-3NMN7TZE-CMlMWBQy.js} +4 -4
- package/dist-electron/renderer/assets/{kanban-definition-UXKFOSKX-s93O9mC-.js → kanban-definition-UXKFOSKX-Dq0uosw3.js} +3 -3
- package/dist-electron/renderer/assets/{layout-Dbkx9J-l.js → layout-NTzyHFiX.js} +1 -1
- package/dist-electron/renderer/assets/{preload-helper-D4nQg559.js → localUrlCodec-DIa41KGx.js} +66 -94
- package/dist-electron/renderer/assets/{mermaid-render-DKBZpycW.js → mermaid-render-gG8hfEWR.js} +44 -44
- package/dist-electron/renderer/assets/{mindmap-definition-YA3MSWOX-DWtFv4JS.js → mindmap-definition-YA3MSWOX-yqBHEzFo.js} +4 -4
- package/dist-electron/renderer/assets/{index.es-B-PFCvGY.js → office-preview-BS5mB52v.js} +526 -1
- package/dist-electron/renderer/assets/overlay-C9ghz5je.css +153 -0
- package/dist-electron/renderer/assets/overlay-CBbZ1t7x.js +246 -0
- package/dist-electron/renderer/assets/{parser-Bse9GBCb.js → parser-BfKF1DWc.js} +3 -3
- package/dist-electron/renderer/assets/{pdf-DghWS7CU.js → pdf-Pm8fIsHg.js} +2 -2
- package/dist-electron/renderer/assets/{pegDiagram-XKGWAZYB-CazTNniw.js → pegDiagram-XKGWAZYB-CQy2w74e.js} +5 -5
- package/dist-electron/renderer/assets/{pieDiagram-E7YTZNPT-DUy0GMEM.js → pieDiagram-E7YTZNPT-DYYvCQil.js} +4 -4
- package/dist-electron/renderer/assets/{ppt-BSkCMEWZ.js → ppt-DmaxBdOX.js} +2 -2
- package/dist-electron/renderer/assets/{pptx-BVHcfCC0.js → pptx-D-wfYDMz.js} +2 -2
- package/dist-electron/renderer/assets/preload-helper-DVzrZ_Op.js +64 -0
- package/dist-electron/renderer/assets/{quadrantDiagram-AXDQQJYC-DD3Hp2Re.js → quadrantDiagram-AXDQQJYC-BD_6NG8F.js} +2 -2
- package/dist-electron/renderer/assets/{railroadDiagram-O6MQD6OU-BueL6fLj.js → railroadDiagram-O6MQD6OU-D2EdLuh6.js} +5 -5
- package/dist-electron/renderer/assets/{requirementDiagram-BXWQKSXE-ytpwrhLl.js → requirementDiagram-BXWQKSXE-BPA9nTLW.js} +4 -4
- package/dist-electron/renderer/assets/{sankeyDiagram-P5KCCOFB-CLilC1YM.js → sankeyDiagram-P5KCCOFB-D4WTrTOn.js} +2 -2
- package/dist-electron/renderer/assets/{sequenceDiagram-WJ2MYXX4-DrBha2YE.js → sequenceDiagram-WJ2MYXX4-Dq6sE9RB.js} +4 -4
- package/dist-electron/renderer/assets/{sizeCapture-INFHLROL-CMpQXmxJ.js → sizeCapture-INFHLROL-jYMm7qP_.js} +2 -2
- package/dist-electron/renderer/assets/{spreadsheet-BvknmhbS.js → spreadsheet-1QmRJRGI.js} +5 -5
- package/dist-electron/renderer/assets/{stateDiagram-D77RDMKH-DdNr6wsi.js → stateDiagram-D77RDMKH-BN6ZpH9T.js} +7 -7
- package/dist-electron/renderer/assets/{stateDiagram-v2-MP3YSRHH-C_2qSETH.js → stateDiagram-v2-MP3YSRHH-KQpnpSwC.js} +6 -6
- package/dist-electron/renderer/assets/{swimlanes-42K2YHIH-D6pHZlJ5.js → swimlanes-42K2YHIH-B8g_jOE8.js} +2 -2
- package/dist-electron/renderer/assets/{swimlanesDiagram-VR7AAH4N-Bbn_zDmu.js → swimlanesDiagram-VR7AAH4N-CnxwEcyu.js} +8 -8
- package/dist-electron/renderer/assets/{timeline-definition-24CTP7MA-Dl5yEcro.js → timeline-definition-24CTP7MA-B2bIdbRb.js} +2 -2
- package/dist-electron/renderer/assets/{vennDiagram-4TSXK5OY-CcgVZsjE.js → vennDiagram-4TSXK5OY-ivHGSZPk.js} +2 -2
- package/dist-electron/renderer/assets/{wardleyDiagram-VM6X3IG4-LMe6ZbWY.js → wardleyDiagram-VM6X3IG4-Cm4RrdIY.js} +4 -4
- package/dist-electron/renderer/assets/{wordDoc-7nY9NJhb.js → wordDoc-DKvAKhDG.js} +2 -2
- package/dist-electron/renderer/assets/{wordDocx-DvAKErWb.js → wordDocx-DeeVPVCg.js} +2 -2
- package/dist-electron/renderer/assets/{xychartDiagram-S5SC5T6Z-D9R_Rm8C.js → xychartDiagram-S5SC5T6Z-CoLQMI-_.js} +2 -2
- package/dist-electron/renderer/index.html +5 -3
- package/dist-electron/renderer/office-preview.html +3 -2
- package/dist-electron/renderer/overlay.html +43 -0
- package/package.json +4 -1
- package/dist-electron/renderer/assets/office-preview-6k-9ssZM.js +0 -239
|
@@ -0,0 +1,783 @@
|
|
|
1
|
+
"use strict";
|
|
2
|
+
var __create = Object.create;
|
|
3
|
+
var __defProp = Object.defineProperty;
|
|
4
|
+
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
|
5
|
+
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
6
|
+
var __getProtoOf = Object.getPrototypeOf;
|
|
7
|
+
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
8
|
+
var __copyProps = (to, from, except, desc) => {
|
|
9
|
+
if (from && typeof from === "object" || typeof from === "function") {
|
|
10
|
+
for (let key of __getOwnPropNames(from))
|
|
11
|
+
if (!__hasOwnProp.call(to, key) && key !== except)
|
|
12
|
+
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
|
|
13
|
+
}
|
|
14
|
+
return to;
|
|
15
|
+
};
|
|
16
|
+
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
|
|
17
|
+
// If the importer is in node compatibility mode or this is not an ESM
|
|
18
|
+
// file that has been converted to a CommonJS file using a Babel-
|
|
19
|
+
// compatible transform (i.e. "__esModule" has not been set), then set
|
|
20
|
+
// "default" to the CommonJS "module.exports" for node compatibility.
|
|
21
|
+
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
|
|
22
|
+
mod
|
|
23
|
+
));
|
|
24
|
+
|
|
25
|
+
// src/main/infra/image/errors.ts
|
|
26
|
+
var IMAGE_SCOPE_DENIED = "IMAGE_SCOPE_DENIED";
|
|
27
|
+
var IMAGE_INPUT_TOO_LARGE = "IMAGE_INPUT_TOO_LARGE";
|
|
28
|
+
var IMAGE_INPUT_UNSUPPORTED = "IMAGE_INPUT_UNSUPPORTED";
|
|
29
|
+
var ImageOpError = class extends Error {
|
|
30
|
+
};
|
|
31
|
+
var ImageScopeDeniedError = class extends ImageOpError {
|
|
32
|
+
code = IMAGE_SCOPE_DENIED;
|
|
33
|
+
constructor(message) {
|
|
34
|
+
super(`${IMAGE_SCOPE_DENIED}: ${message}`);
|
|
35
|
+
this.name = "ImageScopeDeniedError";
|
|
36
|
+
}
|
|
37
|
+
};
|
|
38
|
+
var ImageInputTooLargeError = class extends ImageOpError {
|
|
39
|
+
code = IMAGE_INPUT_TOO_LARGE;
|
|
40
|
+
constructor(message) {
|
|
41
|
+
super(`${IMAGE_INPUT_TOO_LARGE}: ${message}`);
|
|
42
|
+
this.name = "ImageInputTooLargeError";
|
|
43
|
+
}
|
|
44
|
+
};
|
|
45
|
+
var ImageInputUnsupportedError = class extends ImageOpError {
|
|
46
|
+
code = IMAGE_INPUT_UNSUPPORTED;
|
|
47
|
+
constructor(message) {
|
|
48
|
+
super(`${IMAGE_INPUT_UNSUPPORTED}: ${message}`);
|
|
49
|
+
this.name = "ImageInputUnsupportedError";
|
|
50
|
+
}
|
|
51
|
+
};
|
|
52
|
+
function toWireError(error) {
|
|
53
|
+
const code = error?.code;
|
|
54
|
+
const message = error instanceof Error ? error.message : String(error);
|
|
55
|
+
return { code: typeof code === "string" ? code : "IMAGE_WORKER_FAILURE", message };
|
|
56
|
+
}
|
|
57
|
+
|
|
58
|
+
// src/utils/id.ts
|
|
59
|
+
var ID_TYPE = {
|
|
60
|
+
MSG: "msg",
|
|
61
|
+
// 消息
|
|
62
|
+
QUICK_REPLY: "qr",
|
|
63
|
+
// 快捷回复
|
|
64
|
+
CONV: "conv",
|
|
65
|
+
// 会话
|
|
66
|
+
GROUP: "group",
|
|
67
|
+
// 群组
|
|
68
|
+
SESS: "sess",
|
|
69
|
+
// 会话 session
|
|
70
|
+
RUN: "run",
|
|
71
|
+
// LLM 运行
|
|
72
|
+
TASK: "task",
|
|
73
|
+
// 任务
|
|
74
|
+
AGENT: "agent",
|
|
75
|
+
// Agent
|
|
76
|
+
CRON: "cron",
|
|
77
|
+
// 定时任务
|
|
78
|
+
CHUNK: "chunk",
|
|
79
|
+
// 流式内容块
|
|
80
|
+
MCP: "mcp",
|
|
81
|
+
// MCP 服务配置
|
|
82
|
+
REQ: "req",
|
|
83
|
+
// 客户端请求
|
|
84
|
+
SEARCH: "search",
|
|
85
|
+
// 搜索请求
|
|
86
|
+
WS: "ws",
|
|
87
|
+
// WebSocket 消息
|
|
88
|
+
BROADCAST: "broadcast",
|
|
89
|
+
// 广播
|
|
90
|
+
CHANNEL: "ch",
|
|
91
|
+
// LLM 通道
|
|
92
|
+
STREAM: "stream",
|
|
93
|
+
// 流式消息
|
|
94
|
+
ATTACHMENT: "att",
|
|
95
|
+
// 附件
|
|
96
|
+
CMD: "cmd",
|
|
97
|
+
// 宿主指令
|
|
98
|
+
BLOCK: "blk",
|
|
99
|
+
// 持久化 Block 节点(message_blocks.block_id)
|
|
100
|
+
STEP: "step",
|
|
101
|
+
// thread 的一步(一次模型回合 + 本次工具结果)
|
|
102
|
+
COMPACT: "compact",
|
|
103
|
+
// thread 的一次上下文压缩(换基底:requested / completed 两条事件的配对 id)
|
|
104
|
+
INTENT: "intent",
|
|
105
|
+
// 卡片动作的用户意图 id(「用户点了什么」与「实际执行了什么」的对齐键)
|
|
106
|
+
QUESTION: "q"
|
|
107
|
+
// 一次结构化提问的批 id(`ask_question` 签发,状态记录与块载荷共用)
|
|
108
|
+
};
|
|
109
|
+
var BODY_LENGTH_BY_TYPE = {
|
|
110
|
+
[ID_TYPE.TASK]: 8,
|
|
111
|
+
[ID_TYPE.SESS]: 8,
|
|
112
|
+
[ID_TYPE.AGENT]: 8,
|
|
113
|
+
[ID_TYPE.GROUP]: 8
|
|
114
|
+
};
|
|
115
|
+
|
|
116
|
+
// src/utils/binary-formats.ts
|
|
117
|
+
var BINARY_FORMAT_FAMILIES = {
|
|
118
|
+
image: [".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp", ".ico", ".svg", ".ppm"],
|
|
119
|
+
audio: [".mp3", ".wav", ".flac", ".ogg", ".m4a", ".aac", ".aiff", ".opus", ".wma"],
|
|
120
|
+
video: [".mp4", ".m4v", ".avi", ".mov", ".mkv", ".ogv", ".wmv", ".webm"],
|
|
121
|
+
document: [".pdf", ".doc", ".docx", ".xls", ".xlsx", ".ppt", ".pptx"],
|
|
122
|
+
archive: [".zip", ".tar", ".gz", ".bz2", ".xz", ".7z", ".rar"],
|
|
123
|
+
database: [".sqlite", ".db"],
|
|
124
|
+
font: [".woff", ".woff2", ".ttf", ".otf", ".eot"],
|
|
125
|
+
native: [
|
|
126
|
+
".exe",
|
|
127
|
+
".dll",
|
|
128
|
+
".so",
|
|
129
|
+
".dylib",
|
|
130
|
+
".bin",
|
|
131
|
+
".dmg",
|
|
132
|
+
".iso",
|
|
133
|
+
".class",
|
|
134
|
+
".o",
|
|
135
|
+
".pyc",
|
|
136
|
+
".wasm"
|
|
137
|
+
]
|
|
138
|
+
};
|
|
139
|
+
var FAMILY_OF_FORMAT = new Map(
|
|
140
|
+
Object.entries(BINARY_FORMAT_FAMILIES).flatMap(
|
|
141
|
+
([family, extensions]) => extensions.map((extension) => [extension, family])
|
|
142
|
+
)
|
|
143
|
+
);
|
|
144
|
+
|
|
145
|
+
// src/utils/assert-never.ts
|
|
146
|
+
function assertNever(value, context = "value") {
|
|
147
|
+
throw new Error(`Unhandled ${context}: ${JSON.stringify(value)}`);
|
|
148
|
+
}
|
|
149
|
+
|
|
150
|
+
// src/main/infra/image/sharp-gateway.ts
|
|
151
|
+
var IMAGE_ENGINE_UNAVAILABLE = "IMAGE_ENGINE_UNAVAILABLE";
|
|
152
|
+
var UNAVAILABLE_HINT = "\u8BF7\u5B89\u88C5\u4E0E\u5F53\u524D\u5E73\u53F0\u5339\u914D\u7684 sharp \u4F9D\u8D56\u540E\u91CD\u8BD5\uFF1B\u65E0\u6CD5\u63D0\u4F9B\u8BE5\u4E8C\u8FDB\u5236\u7684\u5BBF\u4E3B\u8BF7\u8DF3\u8FC7\u56FE\u7247\u80FD\u529B\uFF08\u5934\u50CF\u4E0A\u4F20\u3001\u56FE\u7247\u7F29\u653E\u3001PPM \u9884\u89C8\u4E00\u5E76\u964D\u7EA7\uFF09\u3002";
|
|
153
|
+
var ImageEngineUnavailableError = class extends Error {
|
|
154
|
+
code = IMAGE_ENGINE_UNAVAILABLE;
|
|
155
|
+
constructor(cause) {
|
|
156
|
+
super(
|
|
157
|
+
`${IMAGE_ENGINE_UNAVAILABLE}: \u56FE\u50CF\u5F15\u64CE sharp \u52A0\u8F7D\u5931\u8D25\uFF08${describeCause(cause)}\uFF09\u3002${UNAVAILABLE_HINT}`,
|
|
158
|
+
{ cause }
|
|
159
|
+
);
|
|
160
|
+
this.name = "ImageEngineUnavailableError";
|
|
161
|
+
}
|
|
162
|
+
};
|
|
163
|
+
function describeCause(cause) {
|
|
164
|
+
return cause instanceof Error ? cause.message : String(cause);
|
|
165
|
+
}
|
|
166
|
+
async function loadEngine() {
|
|
167
|
+
try {
|
|
168
|
+
const loaded = await import("sharp");
|
|
169
|
+
const engine = loaded.default ?? loaded;
|
|
170
|
+
if (typeof engine !== "function") throw new Error("sharp \u6A21\u5757\u672A\u5BFC\u51FA\u53EF\u8C03\u7528\u7684\u5F15\u64CE");
|
|
171
|
+
return engine;
|
|
172
|
+
} catch (failure) {
|
|
173
|
+
throw new ImageEngineUnavailableError(failure);
|
|
174
|
+
}
|
|
175
|
+
}
|
|
176
|
+
var probe = null;
|
|
177
|
+
async function loadSharp() {
|
|
178
|
+
probe ??= loadEngine();
|
|
179
|
+
return probe;
|
|
180
|
+
}
|
|
181
|
+
|
|
182
|
+
// src/main/infra/image/ops/input.ts
|
|
183
|
+
var import_promises2 = require("fs/promises");
|
|
184
|
+
|
|
185
|
+
// src/main/infra/image/ops/limits.ts
|
|
186
|
+
var import_promises = require("fs/promises");
|
|
187
|
+
var IMAGE_MAX_BYTES = 32 * 1024 * 1024;
|
|
188
|
+
var IMAGE_MAX_PIXELS = 4e7;
|
|
189
|
+
var IMAGE_MAX_SHAPES = 512;
|
|
190
|
+
function formatBytes(bytes) {
|
|
191
|
+
return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
|
|
192
|
+
}
|
|
193
|
+
function formatPixels(pixels) {
|
|
194
|
+
return `${(pixels / 1e6).toFixed(1)}MP`;
|
|
195
|
+
}
|
|
196
|
+
async function readFileBytes(path) {
|
|
197
|
+
try {
|
|
198
|
+
const stats = await (0, import_promises.stat)(path);
|
|
199
|
+
return stats.size;
|
|
200
|
+
} catch {
|
|
201
|
+
return 0;
|
|
202
|
+
}
|
|
203
|
+
}
|
|
204
|
+
function assertInputBytes(bytes, path) {
|
|
205
|
+
if (bytes > IMAGE_MAX_BYTES) {
|
|
206
|
+
throw new ImageInputTooLargeError(
|
|
207
|
+
`${path} \u6709 ${formatBytes(bytes)}\uFF0C\u8D85\u8FC7\u8F93\u5165\u4E0A\u9650 ${formatBytes(IMAGE_MAX_BYTES)}`
|
|
208
|
+
);
|
|
209
|
+
}
|
|
210
|
+
}
|
|
211
|
+
function assertInputPixels(width, height, path, limit = IMAGE_MAX_PIXELS) {
|
|
212
|
+
const pixels = width * height;
|
|
213
|
+
if (pixels > limit) {
|
|
214
|
+
throw new ImageInputTooLargeError(
|
|
215
|
+
`${path} \u662F ${width}\xD7${height}\uFF08${formatPixels(pixels)}\uFF09\uFF0C\u8D85\u8FC7\u8F93\u5165\u4E0A\u9650 ${formatPixels(limit)}`
|
|
216
|
+
);
|
|
217
|
+
}
|
|
218
|
+
}
|
|
219
|
+
async function assertOutputBytes(path) {
|
|
220
|
+
const bytes = await readFileBytes(path);
|
|
221
|
+
if (bytes > IMAGE_MAX_BYTES) {
|
|
222
|
+
throw new ImageInputTooLargeError(
|
|
223
|
+
`\u8F93\u51FA ${path} \u6709 ${formatBytes(bytes)}\uFF0C\u8D85\u8FC7\u4E0A\u9650 ${formatBytes(IMAGE_MAX_BYTES)}\uFF1B\u8BF7\u964D\u4F4E\u5C3A\u5BF8\u6216\u6539\u7528\u6709\u635F\u683C\u5F0F`
|
|
224
|
+
);
|
|
225
|
+
}
|
|
226
|
+
return bytes;
|
|
227
|
+
}
|
|
228
|
+
|
|
229
|
+
// src/main/infra/image/ops/input.ts
|
|
230
|
+
var SWAPPED_ORIENTATIONS = /* @__PURE__ */ new Set([5, 6, 7, 8]);
|
|
231
|
+
function orientedSize(metadata) {
|
|
232
|
+
const width = metadata.width ?? 0;
|
|
233
|
+
const height = metadata.height ?? 0;
|
|
234
|
+
const orientation = metadata.orientation ?? 1;
|
|
235
|
+
return SWAPPED_ORIENTATIONS.has(orientation) ? { width: height, height: width } : { width, height };
|
|
236
|
+
}
|
|
237
|
+
function mapDecodeError(error, src) {
|
|
238
|
+
const message = error instanceof Error ? error.message : String(error);
|
|
239
|
+
if (/pixel limit|exceeds pixel/i.test(message)) {
|
|
240
|
+
return new ImageInputTooLargeError(`${src} \u8D85\u51FA\u50CF\u7D20\u4E0A\u9650 ${IMAGE_MAX_PIXELS}\uFF0C\u62D2\u7EDD\u89E3\u7801`);
|
|
241
|
+
}
|
|
242
|
+
return new ImageInputUnsupportedError(`${src} \u65E0\u6CD5\u4F5C\u4E3A\u56FE\u7247\u89E3\u7801\uFF1A${message}`);
|
|
243
|
+
}
|
|
244
|
+
async function openImage(engine, src) {
|
|
245
|
+
const stats = await (0, import_promises2.stat)(src).catch(() => null);
|
|
246
|
+
if (!stats || !stats.isFile()) {
|
|
247
|
+
throw new ImageInputUnsupportedError(`${src} \u4E0D\u5B58\u5728\u6216\u4E0D\u662F\u666E\u901A\u6587\u4EF6`);
|
|
248
|
+
}
|
|
249
|
+
assertInputBytes(stats.size, src);
|
|
250
|
+
const image = engine(src, { limitInputPixels: IMAGE_MAX_PIXELS, failOn: "none" });
|
|
251
|
+
const metadata = await image.metadata().catch((error) => {
|
|
252
|
+
throw mapDecodeError(error, src);
|
|
253
|
+
});
|
|
254
|
+
const { width, height } = orientedSize(metadata);
|
|
255
|
+
if (width === 0 || height === 0) {
|
|
256
|
+
throw new ImageInputUnsupportedError(`${src} \u4E0D\u662F\u56FE\u7247\uFF0C\u6216\u683C\u5F0F\u7F3A\u5C11\u5C3A\u5BF8\u4FE1\u606F`);
|
|
257
|
+
}
|
|
258
|
+
assertInputPixels(width, height, src);
|
|
259
|
+
return {
|
|
260
|
+
image,
|
|
261
|
+
format: metadata.format ?? "",
|
|
262
|
+
width,
|
|
263
|
+
height,
|
|
264
|
+
bytes: stats.size,
|
|
265
|
+
channels: metadata.channels ?? 0,
|
|
266
|
+
hasAlpha: metadata.hasAlpha ?? false,
|
|
267
|
+
orientation: metadata.orientation ?? 1
|
|
268
|
+
};
|
|
269
|
+
}
|
|
270
|
+
async function orientedPipeline(engine, input) {
|
|
271
|
+
if (input.orientation === 1) return input.image;
|
|
272
|
+
return engine(await input.image.autoOrient().toBuffer());
|
|
273
|
+
}
|
|
274
|
+
async function readOutputInfo(engine, path, format) {
|
|
275
|
+
const metadata = await engine(path).metadata();
|
|
276
|
+
return {
|
|
277
|
+
width: metadata.width ?? 0,
|
|
278
|
+
height: metadata.height ?? 0,
|
|
279
|
+
bytes: await readFileBytes(path),
|
|
280
|
+
format: metadata.format ?? format
|
|
281
|
+
};
|
|
282
|
+
}
|
|
283
|
+
|
|
284
|
+
// src/main/infra/image/ops/normalize-shapes.ts
|
|
285
|
+
var IMAGE_DEFAULT_STROKE = "#e11d48";
|
|
286
|
+
var IMAGE_BADGE_FILL = "#e11d48";
|
|
287
|
+
var IMAGE_BADGE_TEXT_COLOR = "#ffffff";
|
|
288
|
+
var IMAGE_DEFAULT_TEXT_COLOR = "#ffffff";
|
|
289
|
+
var SHAPE_TYPES = ["rect", "arrow", "text", "badge"];
|
|
290
|
+
function defaultStrokeWidth(width, height) {
|
|
291
|
+
return Math.max(2, Math.round(Math.min(width, height) / 400));
|
|
292
|
+
}
|
|
293
|
+
function badgeMetrics(width, height) {
|
|
294
|
+
const radius = Math.min(48, Math.max(10, Math.round(Math.min(width, height) * 0.02)));
|
|
295
|
+
return { radius, fontSize: Math.round(radius * 1.1) };
|
|
296
|
+
}
|
|
297
|
+
function finiteNumber(value, label) {
|
|
298
|
+
if (typeof value !== "number" || !Number.isFinite(value)) {
|
|
299
|
+
throw new ImageInputUnsupportedError(`${label} \u5FC5\u987B\u662F\u6709\u9650\u6570\u5B57\uFF0C\u6536\u5230 ${String(value)}`);
|
|
300
|
+
}
|
|
301
|
+
return value;
|
|
302
|
+
}
|
|
303
|
+
function positiveNumber(value, label) {
|
|
304
|
+
const number = finiteNumber(value, label);
|
|
305
|
+
if (number <= 0) throw new ImageInputUnsupportedError(`${label} \u5FC5\u987B\u4E3A\u6B63\uFF0C\u6536\u5230 ${number}`);
|
|
306
|
+
return number;
|
|
307
|
+
}
|
|
308
|
+
function optionalColor(value, label, fallback) {
|
|
309
|
+
if (value === void 0 || value === null) return fallback;
|
|
310
|
+
if (typeof value !== "string" || value.trim() === "") {
|
|
311
|
+
throw new ImageInputUnsupportedError(
|
|
312
|
+
`${label} \u5FC5\u987B\u662F\u975E\u7A7A\u989C\u8272\u5B57\u7B26\u4E32\uFF08\u5982 #e11d48\uFF09\uFF0C\u6536\u5230 ${String(value)}`
|
|
313
|
+
);
|
|
314
|
+
}
|
|
315
|
+
return value.trim();
|
|
316
|
+
}
|
|
317
|
+
function requiredLabel(value, label) {
|
|
318
|
+
if (typeof value !== "string" || value === "") {
|
|
319
|
+
throw new ImageInputUnsupportedError(`${label} \u5FC5\u586B\u4E14\u4E0D\u80FD\u4E3A\u7A7A\u4E32`);
|
|
320
|
+
}
|
|
321
|
+
return value;
|
|
322
|
+
}
|
|
323
|
+
function normalizePoint(value, label) {
|
|
324
|
+
return {
|
|
325
|
+
x: finiteNumber(value?.x, `${label}.x`),
|
|
326
|
+
y: finiteNumber(value?.y, `${label}.y`)
|
|
327
|
+
};
|
|
328
|
+
}
|
|
329
|
+
function normalizeRect(value, label) {
|
|
330
|
+
const width = positiveNumber(value?.width, `${label}.width`);
|
|
331
|
+
const height = positiveNumber(value?.height, `${label}.height`);
|
|
332
|
+
return {
|
|
333
|
+
x: finiteNumber(value?.x, `${label}.x`),
|
|
334
|
+
y: finiteNumber(value?.y, `${label}.y`),
|
|
335
|
+
width,
|
|
336
|
+
height
|
|
337
|
+
};
|
|
338
|
+
}
|
|
339
|
+
function normalizeShape(shape, index, size) {
|
|
340
|
+
const at = `shapes[${index}]`;
|
|
341
|
+
switch (shape.type) {
|
|
342
|
+
case "rect": {
|
|
343
|
+
const draft = shape;
|
|
344
|
+
return {
|
|
345
|
+
type: "rect",
|
|
346
|
+
rect: normalizeRect(draft.rect, `${at}.rect`),
|
|
347
|
+
stroke: optionalColor(draft.stroke, `${at}.stroke`, IMAGE_DEFAULT_STROKE),
|
|
348
|
+
strokeWidth: draft.strokeWidth === void 0 ? defaultStrokeWidth(size.width, size.height) : positiveNumber(draft.strokeWidth, `${at}.strokeWidth`),
|
|
349
|
+
fill: draft.fill === void 0 ? null : optionalColor(draft.fill, `${at}.fill`, "")
|
|
350
|
+
};
|
|
351
|
+
}
|
|
352
|
+
case "arrow": {
|
|
353
|
+
const draft = shape;
|
|
354
|
+
return {
|
|
355
|
+
type: "arrow",
|
|
356
|
+
from: normalizePoint(draft.from, `${at}.from`),
|
|
357
|
+
to: normalizePoint(draft.to, `${at}.to`),
|
|
358
|
+
stroke: optionalColor(draft.stroke, `${at}.stroke`, IMAGE_DEFAULT_STROKE),
|
|
359
|
+
strokeWidth: draft.strokeWidth === void 0 ? defaultStrokeWidth(size.width, size.height) : positiveNumber(draft.strokeWidth, `${at}.strokeWidth`)
|
|
360
|
+
};
|
|
361
|
+
}
|
|
362
|
+
case "text": {
|
|
363
|
+
const draft = shape;
|
|
364
|
+
if (draft.fontSize === void 0) {
|
|
365
|
+
throw new ImageInputUnsupportedError(
|
|
366
|
+
`${at}.fontSize \u5FC5\u586B\uFF1A\u6587\u5B57\u5927\u5C0F\u662F\u610F\u56FE\uFF0C\u4E0D\u7ED9\u9ED8\u8BA4\uFF08\u5982\u56FE\u5E45 800px \u53EF\u8BD5 24\uFF09`
|
|
367
|
+
);
|
|
368
|
+
}
|
|
369
|
+
return {
|
|
370
|
+
type: "text",
|
|
371
|
+
at: normalizePoint(draft.at, `${at}.at`),
|
|
372
|
+
text: requiredLabel(draft.text, `${at}.text`),
|
|
373
|
+
fontSize: positiveNumber(draft.fontSize, `${at}.fontSize`),
|
|
374
|
+
color: optionalColor(draft.color, `${at}.color`, IMAGE_DEFAULT_TEXT_COLOR)
|
|
375
|
+
};
|
|
376
|
+
}
|
|
377
|
+
case "badge": {
|
|
378
|
+
const draft = shape;
|
|
379
|
+
const metrics = badgeMetrics(size.width, size.height);
|
|
380
|
+
return {
|
|
381
|
+
type: "badge",
|
|
382
|
+
at: normalizePoint(draft.at, `${at}.at`),
|
|
383
|
+
label: requiredLabel(draft.label, `${at}.label`),
|
|
384
|
+
fill: optionalColor(draft.fill, `${at}.fill`, IMAGE_BADGE_FILL),
|
|
385
|
+
color: IMAGE_BADGE_TEXT_COLOR,
|
|
386
|
+
radius: metrics.radius,
|
|
387
|
+
fontSize: metrics.fontSize
|
|
388
|
+
};
|
|
389
|
+
}
|
|
390
|
+
default:
|
|
391
|
+
throw new ImageInputUnsupportedError(
|
|
392
|
+
`${at}.type \u53EA\u6536 ${SHAPE_TYPES.join(" / ")}\uFF0C\u6536\u5230 ${String(shape.type)}`
|
|
393
|
+
);
|
|
394
|
+
}
|
|
395
|
+
}
|
|
396
|
+
function normalizeShapes(shapes, size) {
|
|
397
|
+
if (!Array.isArray(shapes)) {
|
|
398
|
+
throw new ImageInputUnsupportedError("annotate.shapes \u5FC5\u987B\u662F\u6570\u7EC4");
|
|
399
|
+
}
|
|
400
|
+
if (shapes.length > IMAGE_MAX_SHAPES) {
|
|
401
|
+
throw new ImageInputUnsupportedError(
|
|
402
|
+
`\u4E00\u6B21\u6700\u591A ${IMAGE_MAX_SHAPES} \u4E2A\u5F62\u72B6\uFF0C\u6536\u5230 ${shapes.length}`
|
|
403
|
+
);
|
|
404
|
+
}
|
|
405
|
+
return shapes.map((shape, index) => {
|
|
406
|
+
if (!shape || typeof shape !== "object" || !SHAPE_TYPES.includes(shape.type)) {
|
|
407
|
+
throw new ImageInputUnsupportedError(
|
|
408
|
+
`shapes[${index}].type \u53EA\u6536 ${SHAPE_TYPES.join(" / ")}\uFF0C\u6536\u5230 ${String(shape?.type)}`
|
|
409
|
+
);
|
|
410
|
+
}
|
|
411
|
+
return normalizeShape(shape, index, size);
|
|
412
|
+
});
|
|
413
|
+
}
|
|
414
|
+
|
|
415
|
+
// src/main/infra/image/ops/output.ts
|
|
416
|
+
var import_promises4 = require("fs/promises");
|
|
417
|
+
var import_path2 = require("path");
|
|
418
|
+
|
|
419
|
+
// src/main/infra/image/ops/scope.ts
|
|
420
|
+
var import_promises3 = require("fs/promises");
|
|
421
|
+
var import_path = require("path");
|
|
422
|
+
async function resolveRealPath(path) {
|
|
423
|
+
let current = path;
|
|
424
|
+
const missing = [];
|
|
425
|
+
for (; ; ) {
|
|
426
|
+
try {
|
|
427
|
+
const real = await (0, import_promises3.realpath)(current);
|
|
428
|
+
return missing.length > 0 ? (0, import_path.join)(real, ...missing.reverse()) : real;
|
|
429
|
+
} catch (error) {
|
|
430
|
+
const code = error.code;
|
|
431
|
+
if (code !== "ENOENT") {
|
|
432
|
+
throw new ImageScopeDeniedError(
|
|
433
|
+
`\u65E0\u6CD5\u89E3\u6790 ${current} \u7684\u771F\u5B9E\u8DEF\u5F84\uFF08${code ?? "UNKNOWN"}\uFF09\uFF1A${error instanceof Error ? error.message : String(error)}`
|
|
434
|
+
);
|
|
435
|
+
}
|
|
436
|
+
const parent = (0, import_path.dirname)(current);
|
|
437
|
+
if (parent === current) return (0, import_path.join)(current, ...missing.reverse());
|
|
438
|
+
missing.push(current.slice(parent.length).replace(/^[/\\]/, ""));
|
|
439
|
+
current = parent;
|
|
440
|
+
}
|
|
441
|
+
}
|
|
442
|
+
}
|
|
443
|
+
function isInside(root, target) {
|
|
444
|
+
const rel = (0, import_path.relative)(root, target);
|
|
445
|
+
return rel === "" || !rel.startsWith("..") && !(0, import_path.isAbsolute)(rel);
|
|
446
|
+
}
|
|
447
|
+
async function assertPathAllowed(path, roots) {
|
|
448
|
+
const resolved = await resolveRealPath(path);
|
|
449
|
+
if (roots.length === 0) {
|
|
450
|
+
throw new ImageScopeDeniedError(`\u672A\u914D\u7F6E\u56FE\u7247\u5141\u8BB8\u6839\u76EE\u5F55\uFF0C\u62D2\u7EDD\u8BBF\u95EE ${resolved}`);
|
|
451
|
+
}
|
|
452
|
+
for (const root of roots) {
|
|
453
|
+
const realRoot = await resolveRealPath(root);
|
|
454
|
+
if (isInside(realRoot, resolved)) return resolved;
|
|
455
|
+
}
|
|
456
|
+
throw new ImageScopeDeniedError(
|
|
457
|
+
`${resolved} \u4E0D\u5728\u5141\u8BB8\u7684\u6839\u76EE\u5F55\u5185\uFF08\u5141\u8BB8\uFF1A${roots.join(`${import_path.sep}\u2026${import_path.sep}`)}\uFF09`
|
|
458
|
+
);
|
|
459
|
+
}
|
|
460
|
+
|
|
461
|
+
// src/main/infra/image/ops/output.ts
|
|
462
|
+
var SUPPORTED_FORMATS = ["png", "jpeg", "webp", "avif"];
|
|
463
|
+
var EXTENSIONS = {
|
|
464
|
+
png: "png",
|
|
465
|
+
jpeg: "jpg",
|
|
466
|
+
webp: "webp",
|
|
467
|
+
avif: "avif"
|
|
468
|
+
};
|
|
469
|
+
var DEFAULT_QUALITY = 82;
|
|
470
|
+
function isImageFormat(value) {
|
|
471
|
+
return typeof value === "string" && SUPPORTED_FORMATS.includes(value);
|
|
472
|
+
}
|
|
473
|
+
function resolveOutputFormat(sourceFormat, requested) {
|
|
474
|
+
if (requested) {
|
|
475
|
+
if (!isImageFormat(requested)) {
|
|
476
|
+
throw new ImageInputUnsupportedError(
|
|
477
|
+
`\u4E0D\u652F\u6301\u7684\u8F93\u51FA\u683C\u5F0F ${String(requested)}\uFF08\u53EA\u6536 ${SUPPORTED_FORMATS.join(" / ")}\uFF09`
|
|
478
|
+
);
|
|
479
|
+
}
|
|
480
|
+
return requested;
|
|
481
|
+
}
|
|
482
|
+
return isImageFormat(sourceFormat) ? sourceFormat : "png";
|
|
483
|
+
}
|
|
484
|
+
function normalizeQuality(quality) {
|
|
485
|
+
if (quality === void 0) return DEFAULT_QUALITY;
|
|
486
|
+
if (!Number.isFinite(quality) || quality < 1 || quality > 100) {
|
|
487
|
+
throw new ImageInputUnsupportedError(`quality \u5FC5\u987B\u662F 1\u2013100 \u7684\u6574\u6570\uFF0C\u6536\u5230 ${String(quality)}`);
|
|
488
|
+
}
|
|
489
|
+
return Math.round(quality);
|
|
490
|
+
}
|
|
491
|
+
function applyEncoder(pipeline, format, quality) {
|
|
492
|
+
const resolved = normalizeQuality(quality);
|
|
493
|
+
switch (format) {
|
|
494
|
+
case "png":
|
|
495
|
+
return pipeline.png();
|
|
496
|
+
case "jpeg":
|
|
497
|
+
return pipeline.jpeg({ quality: resolved });
|
|
498
|
+
case "webp":
|
|
499
|
+
return pipeline.webp({ quality: resolved });
|
|
500
|
+
case "avif":
|
|
501
|
+
return pipeline.avif({ quality: resolved });
|
|
502
|
+
}
|
|
503
|
+
}
|
|
504
|
+
function defaultOutputPath(src, op, format) {
|
|
505
|
+
const stem = (0, import_path2.basename)(src, (0, import_path2.extname)(src));
|
|
506
|
+
return (0, import_path2.join)((0, import_path2.dirname)(src), `${stem}-${op}.${EXTENSIONS[format]}`);
|
|
507
|
+
}
|
|
508
|
+
async function resolveOutputPath(args) {
|
|
509
|
+
const target = args.to ?? defaultOutputPath(args.src, args.op, args.format);
|
|
510
|
+
const resolved = await assertPathAllowed(target, args.roots);
|
|
511
|
+
if (resolved === args.src) {
|
|
512
|
+
throw new ImageInputUnsupportedError(
|
|
513
|
+
`\u8F93\u51FA\u8DEF\u5F84\u4E0E\u6E90\u6587\u4EF6\u76F8\u540C\uFF08${resolved}\uFF09\uFF1B\u8BF7\u663E\u5F0F\u7ED9 to\uFF0C\u907F\u514D\u8986\u76D6\u539F\u56FE`
|
|
514
|
+
);
|
|
515
|
+
}
|
|
516
|
+
await (0, import_promises4.mkdir)((0, import_path2.dirname)(resolved), { recursive: true });
|
|
517
|
+
return resolved;
|
|
518
|
+
}
|
|
519
|
+
|
|
520
|
+
// src/main/infra/image/ops/annotate.ts
|
|
521
|
+
var FONT_FAMILY = "sans-serif";
|
|
522
|
+
var ARROW_MIN_HEAD = 10;
|
|
523
|
+
var ESCAPES = {
|
|
524
|
+
"&": "&",
|
|
525
|
+
"<": "<",
|
|
526
|
+
">": ">",
|
|
527
|
+
'"': """,
|
|
528
|
+
"'": "'"
|
|
529
|
+
};
|
|
530
|
+
function escapeXmlText(value) {
|
|
531
|
+
return value.replace(/[&<>"']/g, (char) => ESCAPES[char]);
|
|
532
|
+
}
|
|
533
|
+
function round(value) {
|
|
534
|
+
return Math.round(value * 100) / 100;
|
|
535
|
+
}
|
|
536
|
+
function rectShape(shape) {
|
|
537
|
+
const { rect } = shape;
|
|
538
|
+
const fill = shape.fill === null ? "none" : escapeXmlText(shape.fill);
|
|
539
|
+
return `<rect x="${round(rect.x)}" y="${round(rect.y)}" width="${round(rect.width)}" height="${round(rect.height)}" fill="${fill}" stroke="${escapeXmlText(shape.stroke)}" stroke-width="${round(shape.strokeWidth)}"/>`;
|
|
540
|
+
}
|
|
541
|
+
function arrowShape(shape) {
|
|
542
|
+
const { from, to } = shape;
|
|
543
|
+
const dx = to.x - from.x;
|
|
544
|
+
const dy = to.y - from.y;
|
|
545
|
+
const length = Math.hypot(dx, dy);
|
|
546
|
+
const stroke = escapeXmlText(shape.stroke);
|
|
547
|
+
if (length === 0) {
|
|
548
|
+
return `<circle cx="${round(from.x)}" cy="${round(from.y)}" r="${round(shape.strokeWidth)}" fill="${stroke}"/>`;
|
|
549
|
+
}
|
|
550
|
+
const head = Math.max(ARROW_MIN_HEAD, shape.strokeWidth * 3.5);
|
|
551
|
+
const ux = dx / length;
|
|
552
|
+
const uy = dy / length;
|
|
553
|
+
const baseX = to.x - ux * head;
|
|
554
|
+
const baseY = to.y - uy * head;
|
|
555
|
+
const wing = head / 2;
|
|
556
|
+
const left = `${round(baseX - uy * wing)},${round(baseY + ux * wing)}`;
|
|
557
|
+
const right = `${round(baseX + uy * wing)},${round(baseY - ux * wing)}`;
|
|
558
|
+
return [
|
|
559
|
+
`<line x1="${round(from.x)}" y1="${round(from.y)}" x2="${round(baseX)}" y2="${round(baseY)}" stroke="${stroke}" stroke-width="${round(shape.strokeWidth)}" stroke-linecap="round"/>`,
|
|
560
|
+
`<polygon points="${round(to.x)},${round(to.y)} ${left} ${right}" fill="${stroke}"/>`
|
|
561
|
+
].join("");
|
|
562
|
+
}
|
|
563
|
+
function badgeShape(shape) {
|
|
564
|
+
const baseline = round(shape.at.y + shape.fontSize * 0.35);
|
|
565
|
+
return [
|
|
566
|
+
`<circle cx="${round(shape.at.x)}" cy="${round(shape.at.y)}" r="${round(shape.radius)}" fill="${escapeXmlText(shape.fill)}"/>`,
|
|
567
|
+
`<text x="${round(shape.at.x)}" y="${baseline}" font-family="${FONT_FAMILY}" font-size="${round(shape.fontSize)}" fill="${escapeXmlText(shape.color)}" text-anchor="middle">${escapeXmlText(shape.label)}</text>`
|
|
568
|
+
].join("");
|
|
569
|
+
}
|
|
570
|
+
function textShape(shape) {
|
|
571
|
+
const baseline = round(shape.at.y + shape.fontSize * 0.8);
|
|
572
|
+
return `<text x="${round(shape.at.x)}" y="${baseline}" font-family="${FONT_FAMILY}" font-size="${round(shape.fontSize)}" fill="${escapeXmlText(shape.color)}">${escapeXmlText(shape.text)}</text>`;
|
|
573
|
+
}
|
|
574
|
+
function shapeToSvg(shape) {
|
|
575
|
+
switch (shape.type) {
|
|
576
|
+
case "rect":
|
|
577
|
+
return rectShape(shape);
|
|
578
|
+
case "arrow":
|
|
579
|
+
return arrowShape(shape);
|
|
580
|
+
case "text":
|
|
581
|
+
return textShape(shape);
|
|
582
|
+
case "badge":
|
|
583
|
+
return badgeShape(shape);
|
|
584
|
+
default:
|
|
585
|
+
return assertNever(shape, "annotate shape");
|
|
586
|
+
}
|
|
587
|
+
}
|
|
588
|
+
function shapesToSvg(shapes, width, height) {
|
|
589
|
+
const body = shapes.map(shapeToSvg).join("");
|
|
590
|
+
return `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}">${body}</svg>`;
|
|
591
|
+
}
|
|
592
|
+
async function annotateImage(ctx, req) {
|
|
593
|
+
const input = await openImage(ctx.engine, req.src);
|
|
594
|
+
const shapes = normalizeShapes(req.shapes, { width: input.width, height: input.height });
|
|
595
|
+
const format = resolveOutputFormat(input.format, req.format);
|
|
596
|
+
const to = await resolveOutputPath({
|
|
597
|
+
src: req.src,
|
|
598
|
+
to: req.to,
|
|
599
|
+
format,
|
|
600
|
+
op: "annotate",
|
|
601
|
+
roots: ctx.roots
|
|
602
|
+
});
|
|
603
|
+
const base = await orientedPipeline(ctx.engine, input);
|
|
604
|
+
const svg = Buffer.from(shapesToSvg(shapes, input.width, input.height));
|
|
605
|
+
await applyEncoder(base.composite([{ input: svg, top: 0, left: 0 }]), format, req.quality).toFile(
|
|
606
|
+
to
|
|
607
|
+
);
|
|
608
|
+
const info = await readOutputInfo(ctx.engine, to, format);
|
|
609
|
+
const bytes = await assertOutputBytes(to);
|
|
610
|
+
return { path: to, format, width: info.width, height: info.height, bytes };
|
|
611
|
+
}
|
|
612
|
+
|
|
613
|
+
// src/main/infra/image/ops/crop.ts
|
|
614
|
+
function assertIntegerRect(rect, bounds) {
|
|
615
|
+
const values = [rect?.x, rect?.y, rect?.width, rect?.height];
|
|
616
|
+
if (values.some((value) => !Number.isInteger(value))) {
|
|
617
|
+
throw new ImageInputUnsupportedError(
|
|
618
|
+
`rect \u5FC5\u987B\u662F\u6574\u6570\u50CF\u7D20\uFF08\u6536\u5230 x=${String(rect?.x)} y=${String(rect?.y)} w=${String(rect?.width)} h=${String(rect?.height)}\uFF09`
|
|
619
|
+
);
|
|
620
|
+
}
|
|
621
|
+
if (rect.width <= 0 || rect.height <= 0) {
|
|
622
|
+
throw new ImageInputUnsupportedError(`rect \u5BBD\u9AD8\u5FC5\u987B\u4E3A\u6B63\uFF08\u6536\u5230 ${rect.width}\xD7${rect.height}\uFF09`);
|
|
623
|
+
}
|
|
624
|
+
if (rect.x < 0 || rect.y < 0 || rect.x + rect.width > bounds.width || rect.y + rect.height > bounds.height) {
|
|
625
|
+
throw new ImageInputUnsupportedError(
|
|
626
|
+
`rect ${rect.x},${rect.y} ${rect.width}\xD7${rect.height} \u8D85\u51FA\u56FE\u7247\u8303\u56F4 ${bounds.width}\xD7${bounds.height}`
|
|
627
|
+
);
|
|
628
|
+
}
|
|
629
|
+
return { left: rect.x, top: rect.y, width: rect.width, height: rect.height };
|
|
630
|
+
}
|
|
631
|
+
async function cropImage(ctx, req) {
|
|
632
|
+
const input = await openImage(ctx.engine, req.src);
|
|
633
|
+
const rect = assertIntegerRect(req.rect, input);
|
|
634
|
+
const format = resolveOutputFormat(input.format, req.format);
|
|
635
|
+
const to = await resolveOutputPath({
|
|
636
|
+
src: req.src,
|
|
637
|
+
to: req.to,
|
|
638
|
+
format,
|
|
639
|
+
op: "crop",
|
|
640
|
+
roots: ctx.roots
|
|
641
|
+
});
|
|
642
|
+
const base = await orientedPipeline(ctx.engine, input);
|
|
643
|
+
await applyEncoder(base.extract(rect), format, req.quality).toFile(to);
|
|
644
|
+
const info = await readOutputInfo(ctx.engine, to, format);
|
|
645
|
+
const bytes = await assertOutputBytes(to);
|
|
646
|
+
return { path: to, format, width: info.width, height: info.height, bytes };
|
|
647
|
+
}
|
|
648
|
+
|
|
649
|
+
// src/main/infra/image/ops/inspect.ts
|
|
650
|
+
async function inspectImage(ctx, src) {
|
|
651
|
+
const input = await openImage(ctx.engine, src);
|
|
652
|
+
return {
|
|
653
|
+
path: src,
|
|
654
|
+
format: input.format,
|
|
655
|
+
width: input.width,
|
|
656
|
+
height: input.height,
|
|
657
|
+
bytes: input.bytes,
|
|
658
|
+
channels: input.channels,
|
|
659
|
+
hasAlpha: input.hasAlpha,
|
|
660
|
+
orientation: input.orientation
|
|
661
|
+
};
|
|
662
|
+
}
|
|
663
|
+
|
|
664
|
+
// src/main/infra/image/ops/resize.ts
|
|
665
|
+
var FITS = ["inside", "cover", "contain"];
|
|
666
|
+
function positiveInt(value, name) {
|
|
667
|
+
if (value === void 0) return void 0;
|
|
668
|
+
if (!Number.isInteger(value) || value <= 0) {
|
|
669
|
+
throw new ImageInputUnsupportedError(`${name} \u5FC5\u987B\u662F\u6B63\u6574\u6570\uFF0C\u6536\u5230 ${String(value)}`);
|
|
670
|
+
}
|
|
671
|
+
return value;
|
|
672
|
+
}
|
|
673
|
+
function resolveFit(fit) {
|
|
674
|
+
if (fit === void 0) return "inside";
|
|
675
|
+
if (!FITS.includes(fit)) {
|
|
676
|
+
throw new ImageInputUnsupportedError(`fit \u53EA\u6536 ${FITS.join(" / ")}\uFF0C\u6536\u5230 ${String(fit)}`);
|
|
677
|
+
}
|
|
678
|
+
return fit;
|
|
679
|
+
}
|
|
680
|
+
async function resizeImage(ctx, req) {
|
|
681
|
+
const maxWidth = positiveInt(req.maxWidth, "maxWidth");
|
|
682
|
+
const maxHeight = positiveInt(req.maxHeight, "maxHeight");
|
|
683
|
+
if (maxWidth === void 0 && maxHeight === void 0) {
|
|
684
|
+
throw new ImageInputUnsupportedError("resize \u9700\u8981 maxWidth \u6216 maxHeight \u81F3\u5C11\u4E00\u4E2A");
|
|
685
|
+
}
|
|
686
|
+
const input = await openImage(ctx.engine, req.src);
|
|
687
|
+
const format = resolveOutputFormat(input.format, req.format);
|
|
688
|
+
const to = await resolveOutputPath({
|
|
689
|
+
src: req.src,
|
|
690
|
+
to: req.to,
|
|
691
|
+
format,
|
|
692
|
+
op: "resize",
|
|
693
|
+
roots: ctx.roots
|
|
694
|
+
});
|
|
695
|
+
const base = await orientedPipeline(ctx.engine, input);
|
|
696
|
+
const pipeline = applyEncoder(
|
|
697
|
+
base.resize({
|
|
698
|
+
width: maxWidth,
|
|
699
|
+
height: maxHeight,
|
|
700
|
+
fit: resolveFit(req.fit),
|
|
701
|
+
withoutEnlargement: true
|
|
702
|
+
}),
|
|
703
|
+
format,
|
|
704
|
+
req.quality
|
|
705
|
+
);
|
|
706
|
+
await pipeline.toFile(to);
|
|
707
|
+
const info = await readOutputInfo(ctx.engine, to, format);
|
|
708
|
+
const bytes = await assertOutputBytes(to);
|
|
709
|
+
return { path: to, format, width: info.width, height: info.height, bytes };
|
|
710
|
+
}
|
|
711
|
+
|
|
712
|
+
// src/main/infra/image/image-ops.ts
|
|
713
|
+
function assertRequestShape(req) {
|
|
714
|
+
if (!req || typeof req !== "object" || typeof req.op !== "string") {
|
|
715
|
+
throw new ImageInputUnsupportedError("\u56FE\u7247\u8BF7\u6C42\u7F3A\u5C11 op \u5B57\u6BB5");
|
|
716
|
+
}
|
|
717
|
+
const src = req.src;
|
|
718
|
+
if (typeof src !== "string" || src.trim() === "") {
|
|
719
|
+
throw new ImageInputUnsupportedError(`${req.op} \u9700\u8981\u975E\u7A7A\u7684 src \u8DEF\u5F84`);
|
|
720
|
+
}
|
|
721
|
+
return req;
|
|
722
|
+
}
|
|
723
|
+
async function runImageOp(request, options) {
|
|
724
|
+
const req = assertRequestShape(request);
|
|
725
|
+
const engine = options.engine ?? await loadSharp();
|
|
726
|
+
const ctx = { engine, roots: options.roots };
|
|
727
|
+
switch (req.op) {
|
|
728
|
+
case "inspect":
|
|
729
|
+
return inspectImage(ctx, await assertPathAllowed(req.src, ctx.roots));
|
|
730
|
+
case "resize":
|
|
731
|
+
return resizeImage(ctx, { ...req, src: await assertPathAllowed(req.src, ctx.roots) });
|
|
732
|
+
case "crop":
|
|
733
|
+
return cropImage(ctx, { ...req, src: await assertPathAllowed(req.src, ctx.roots) });
|
|
734
|
+
case "annotate":
|
|
735
|
+
return annotateImage(ctx, { ...req, src: await assertPathAllowed(req.src, ctx.roots) });
|
|
736
|
+
default:
|
|
737
|
+
return assertNever(req, "image op");
|
|
738
|
+
}
|
|
739
|
+
}
|
|
740
|
+
function createImageOps(options) {
|
|
741
|
+
return {
|
|
742
|
+
run: (request) => runImageOp(request, options)
|
|
743
|
+
};
|
|
744
|
+
}
|
|
745
|
+
|
|
746
|
+
// src/main/infra/image/worker/protocol.ts
|
|
747
|
+
var IMAGE_SCOPE_ROOTS_ENV = "KAI_IMAGE_SCOPE_ROOTS";
|
|
748
|
+
function parseScopeRoots(raw) {
|
|
749
|
+
if (!raw) return [];
|
|
750
|
+
try {
|
|
751
|
+
const parsed = JSON.parse(raw);
|
|
752
|
+
if (!Array.isArray(parsed)) return [];
|
|
753
|
+
return parsed.filter((root) => typeof root === "string" && root !== "");
|
|
754
|
+
} catch {
|
|
755
|
+
return [];
|
|
756
|
+
}
|
|
757
|
+
}
|
|
758
|
+
|
|
759
|
+
// src/main/infra/image/worker/main.ts
|
|
760
|
+
var ops = createImageOps({ roots: parseScopeRoots(process.env[IMAGE_SCOPE_ROOTS_ENV]) });
|
|
761
|
+
function send(message) {
|
|
762
|
+
process.send?.(message);
|
|
763
|
+
}
|
|
764
|
+
var queue = Promise.resolve();
|
|
765
|
+
function enqueue(request) {
|
|
766
|
+
queue = queue.then(async () => {
|
|
767
|
+
try {
|
|
768
|
+
send({ kind: "result", id: request.id, value: await ops.run(request.op) });
|
|
769
|
+
} catch (error) {
|
|
770
|
+
send({ kind: "error", id: request.id, ...toWireError(error) });
|
|
771
|
+
}
|
|
772
|
+
});
|
|
773
|
+
}
|
|
774
|
+
function asRequest(raw) {
|
|
775
|
+
const candidate = raw;
|
|
776
|
+
if (!candidate || candidate.kind !== "run" || typeof candidate.id !== "number") return null;
|
|
777
|
+
return raw;
|
|
778
|
+
}
|
|
779
|
+
process.on("message", (raw) => {
|
|
780
|
+
const request = asRequest(raw);
|
|
781
|
+
if (request) enqueue(request);
|
|
782
|
+
});
|
|
783
|
+
void loadSharp().catch(() => void 0);
|