@fengwk/kchart 0.1.0 → 0.2.0
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/CHANGELOG.md +43 -0
- package/README.md +31 -2
- package/README.zh-CN.md +31 -2
- package/dist/esm/_virtual/_kchart-families.js +2 -1
- package/dist/esm/assets/themes/cloudmusic.js +1 -1
- package/dist/esm/chart/composition.js +7 -5
- package/dist/esm/chart/maps.js +9 -7
- package/dist/esm/chart/mindmap.js +19 -5
- package/dist/esm/chart/multivariate.js +99 -49
- package/dist/esm/chart/relations.js +15 -7
- package/dist/esm/chart/spec.js +11 -4
- package/dist/esm/core/context.js +29 -10
- package/dist/esm/core/scene.js +238 -21
- package/dist/esm/core/text.js +1 -1
- package/dist/esm/diagram/block.js +287 -295
- package/dist/esm/diagram/blocks.js +541 -605
- package/dist/esm/diagram/board-paint.js +594 -0
- package/dist/esm/diagram/board-route.js +60 -0
- package/dist/esm/diagram/c4.js +75 -35
- package/dist/esm/diagram/class.js +3 -2
- package/dist/esm/diagram/cynefin.js +55 -9
- package/dist/esm/diagram/eventmodeling.js +21 -10
- package/dist/esm/diagram/gantt.js +37 -15
- package/dist/esm/diagram/gitgraph.js +26 -5
- package/dist/esm/diagram/graph-layout.js +39 -2
- package/dist/esm/diagram/graph-route.js +296 -38
- package/dist/esm/diagram/info.js +32 -0
- package/dist/esm/diagram/journey.js +5 -5
- package/dist/esm/diagram/kanban.js +3 -3
- package/dist/esm/diagram/layers.js +9 -7
- package/dist/esm/diagram/mindmap.js +5 -1
- package/dist/esm/diagram/numeric-composition.js +24 -4
- package/dist/esm/diagram/numeric-model.js +1 -1
- package/dist/esm/diagram/numeric-radar.js +25 -7
- package/dist/esm/diagram/numeric-sankey.js +4 -3
- package/dist/esm/diagram/numeric-xy.js +14 -4
- package/dist/esm/diagram/packet.js +4 -4
- package/dist/esm/diagram/quadrant.js +12 -5
- package/dist/esm/diagram/railroad-parse.js +20 -10
- package/dist/esm/diagram/railroad.js +1 -1
- package/dist/esm/diagram/registry.js +46 -8
- package/dist/esm/diagram/sequence.js +43 -6
- package/dist/esm/diagram/swimlane.js +2 -2
- package/dist/esm/diagram/time.js +3 -3
- package/dist/esm/diagram/timeline.js +5 -5
- package/dist/esm/diagram/treeview.js +5 -3
- package/dist/esm/diagram/venn.js +117 -149
- package/dist/esm/diagram/wardley.js +61 -26
- package/dist/esm/diagram/zenuml.js +338 -0
- package/dist/esm/index.d.ts +3 -1
- package/dist/esm/mermaid.d.ts +1 -1
- package/dist/esm/mermaid.js +2 -1
- package/dist/esm/node.js +8 -2
- package/dist/esm/src/families.js +6 -1
- package/dist/units/chart/composition.js +1 -1
- package/dist/units/chart/maps.js +1 -1
- package/dist/units/chart/mindmap.js +1 -1
- package/dist/units/chart/multivariate.js +1 -1
- package/dist/units/chart/relations.js +1 -1
- package/dist/units/chart/spec.js +1 -1
- package/dist/units/core/context.js +1 -1
- package/dist/units/core/scene.js +1 -1
- package/dist/units/core/text.js +1 -1
- package/dist/units/core/theme.js +1 -1
- package/dist/units/diagram/block.js +2 -2
- package/dist/units/diagram/blocks.js +2 -2
- package/dist/units/diagram/board-paint.js +1 -0
- package/dist/units/diagram/board-route.js +1 -0
- package/dist/units/diagram/c4.js +1 -1
- package/dist/units/diagram/class.js +2 -2
- package/dist/units/diagram/cynefin.js +2 -2
- package/dist/units/diagram/eventmodeling.js +4 -4
- package/dist/units/diagram/gantt.js +3 -3
- package/dist/units/diagram/gitgraph.js +2 -1
- package/dist/units/diagram/graph-layout.js +1 -1
- package/dist/units/diagram/graph-route.js +1 -1
- package/dist/units/diagram/info.js +2 -0
- package/dist/units/diagram/journey.js +3 -3
- package/dist/units/diagram/kanban.js +1 -1
- package/dist/units/diagram/layers.js +1 -1
- package/dist/units/diagram/mindmap.js +1 -1
- package/dist/units/diagram/numeric-composition.js +1 -1
- package/dist/units/diagram/numeric-model.js +1 -1
- package/dist/units/diagram/numeric-radar.js +2 -2
- package/dist/units/diagram/numeric-sankey.js +1 -1
- package/dist/units/diagram/numeric-xy.js +1 -1
- package/dist/units/diagram/packet.js +1 -1
- package/dist/units/diagram/quadrant.js +1 -1
- package/dist/units/diagram/railroad-parse.js +2 -2
- package/dist/units/diagram/railroad.js +1 -1
- package/dist/units/diagram/registry.js +2 -2
- package/dist/units/diagram/sequence.js +1 -1
- package/dist/units/diagram/swimlane.js +2 -2
- package/dist/units/diagram/time.js +1 -1
- package/dist/units/diagram/timeline.js +1 -1
- package/dist/units/diagram/treeview.js +1 -1
- package/dist/units/diagram/venn.js +2 -2
- package/dist/units/diagram/wardley.js +4 -4
- package/dist/units/diagram/zenuml.js +2 -0
- package/dist/units.json +82 -52
- package/package.json +1 -1
- package/dist/esm/diagram/relations.js +0 -966
- package/dist/units/diagram/relations.js +0 -3
|
@@ -0,0 +1,594 @@
|
|
|
1
|
+
import { __exportAll } from "../_virtual/_rolldown/runtime.js";
|
|
2
|
+
import { contrast, deltaE2000, pushContrast } from "../core/color.js";
|
|
3
|
+
import { FONT, appearance, maxWidthOf, wrapText } from "./support.js";
|
|
4
|
+
// src/diagram/board-paint.js
|
|
5
|
+
var board_paint_exports = /* @__PURE__ */ __exportAll({
|
|
6
|
+
CARD: () => CARD,
|
|
7
|
+
CHIP: () => CHIP,
|
|
8
|
+
EDGE_KINDS: () => EDGE_KINDS,
|
|
9
|
+
FRAME: () => FRAME,
|
|
10
|
+
ICON: () => ICON,
|
|
11
|
+
ITEM: () => ITEM,
|
|
12
|
+
LABEL: () => LABEL,
|
|
13
|
+
LEGEND: () => LEGEND,
|
|
14
|
+
NOTE: () => NOTE,
|
|
15
|
+
STYLES: () => STYLES,
|
|
16
|
+
boardLook: () => boardLook,
|
|
17
|
+
drawCard: () => drawCard,
|
|
18
|
+
drawEdge: () => drawEdge,
|
|
19
|
+
drawFrame: () => drawFrame,
|
|
20
|
+
drawItem: () => drawItem,
|
|
21
|
+
drawLabel: () => drawLabel,
|
|
22
|
+
drawLegend: () => drawLegend,
|
|
23
|
+
drawNote: () => drawNote,
|
|
24
|
+
frameTitle: () => frameTitle,
|
|
25
|
+
iconGlyph: () => iconGlyph,
|
|
26
|
+
markers: () => markers,
|
|
27
|
+
measureCard: () => measureCard,
|
|
28
|
+
measureItem: () => measureItem,
|
|
29
|
+
measureLabel: () => measureLabel,
|
|
30
|
+
measureLegend: () => measureLegend,
|
|
31
|
+
measureNote: () => measureNote,
|
|
32
|
+
surfaceAt: () => surfaceAt,
|
|
33
|
+
titleRect: () => titleRect
|
|
34
|
+
});
|
|
35
|
+
var STYLES = Object.freeze([
|
|
36
|
+
"accent",
|
|
37
|
+
"new",
|
|
38
|
+
"info",
|
|
39
|
+
"ok",
|
|
40
|
+
"warn",
|
|
41
|
+
"danger",
|
|
42
|
+
"ext"
|
|
43
|
+
]);
|
|
44
|
+
var STATUS = /* @__PURE__ */ new Set([
|
|
45
|
+
"new",
|
|
46
|
+
"info",
|
|
47
|
+
"ok",
|
|
48
|
+
"warn",
|
|
49
|
+
"danger"
|
|
50
|
+
]);
|
|
51
|
+
var CARD = Object.freeze({
|
|
52
|
+
padX: 14,
|
|
53
|
+
padY: 12,
|
|
54
|
+
text: 240,
|
|
55
|
+
min: 112,
|
|
56
|
+
title: 20,
|
|
57
|
+
desc: 18,
|
|
58
|
+
gap: 4
|
|
59
|
+
});
|
|
60
|
+
var CHIP = Object.freeze({
|
|
61
|
+
h: 18,
|
|
62
|
+
padX: 6,
|
|
63
|
+
gap: 8,
|
|
64
|
+
font: Object.freeze({
|
|
65
|
+
size: 12,
|
|
66
|
+
weight: 600
|
|
67
|
+
})
|
|
68
|
+
});
|
|
69
|
+
var FRAME = Object.freeze({
|
|
70
|
+
inset: 12,
|
|
71
|
+
top: 10,
|
|
72
|
+
line: 17,
|
|
73
|
+
after: 8,
|
|
74
|
+
text: 360,
|
|
75
|
+
cylinder: 7,
|
|
76
|
+
font: Object.freeze({
|
|
77
|
+
size: 13,
|
|
78
|
+
weight: 600
|
|
79
|
+
})
|
|
80
|
+
});
|
|
81
|
+
var NOTE = Object.freeze({
|
|
82
|
+
line: 18,
|
|
83
|
+
font: FONT.label
|
|
84
|
+
});
|
|
85
|
+
var LEGEND = Object.freeze({
|
|
86
|
+
swatch: 22,
|
|
87
|
+
gap: 6,
|
|
88
|
+
item: 18,
|
|
89
|
+
row: 22,
|
|
90
|
+
font: FONT.label
|
|
91
|
+
});
|
|
92
|
+
var LABEL = Object.freeze({
|
|
93
|
+
text: 160,
|
|
94
|
+
line: 16,
|
|
95
|
+
padX: 6,
|
|
96
|
+
padY: 2,
|
|
97
|
+
font: FONT.label
|
|
98
|
+
});
|
|
99
|
+
var ITEM = Object.freeze({
|
|
100
|
+
h: 36,
|
|
101
|
+
padX: 12,
|
|
102
|
+
min: 72,
|
|
103
|
+
gap: 8,
|
|
104
|
+
font: FONT.body
|
|
105
|
+
});
|
|
106
|
+
var EDGE_KINDS = Object.freeze({
|
|
107
|
+
"->": "plain",
|
|
108
|
+
"=>": "strong",
|
|
109
|
+
"~>": "dashed"
|
|
110
|
+
});
|
|
111
|
+
var ICON = Object.freeze({
|
|
112
|
+
size: 16,
|
|
113
|
+
gap: 6
|
|
114
|
+
});
|
|
115
|
+
var DASH = "5 4";
|
|
116
|
+
var TILE = .07;
|
|
117
|
+
var OUTLINE = .72;
|
|
118
|
+
var DISTINCT = 12;
|
|
119
|
+
var TEXT_CONTRAST = 4.5;
|
|
120
|
+
var round = (value) => +Number(value).toFixed(2);
|
|
121
|
+
var chipWidth = (text, measure) => text ? Math.ceil(measure(String(text), CHIP.font) + CHIP.padX * 2) : 0;
|
|
122
|
+
function measureCard({ title, desc = [], badge, tag }, measure) {
|
|
123
|
+
const badgeW = chipWidth(badge, measure), tagW = chipWidth(tag, measure);
|
|
124
|
+
const lead = badgeW ? badgeW + CHIP.gap : 0, trail = tagW ? tagW + CHIP.gap : 0;
|
|
125
|
+
const titleLines = wrapText(String(title ?? ""), Math.max(48, CARD.text - lead - trail), FONT.title, measure);
|
|
126
|
+
const descLines = desc.flatMap((line) => wrapText(String(line), CARD.text, FONT.label, measure));
|
|
127
|
+
const content = Math.max(lead + maxWidthOf(titleLines, FONT.title, measure) + trail, maxWidthOf(descLines, FONT.label, measure));
|
|
128
|
+
return {
|
|
129
|
+
w: Math.max(CARD.min, Math.ceil(content + CARD.padX * 2)),
|
|
130
|
+
h: CARD.padY * 2 + titleLines.length * CARD.title + (descLines.length ? CARD.gap + descLines.length * CARD.desc : 0),
|
|
131
|
+
titleLines,
|
|
132
|
+
descLines,
|
|
133
|
+
badgeW,
|
|
134
|
+
tagW
|
|
135
|
+
};
|
|
136
|
+
}
|
|
137
|
+
function measureItem({ label, icon }, measure) {
|
|
138
|
+
return Math.max(ITEM.min, Math.ceil(measure(String(label), ITEM.font) + (icon ? ICON.size + ICON.gap : 0) + ITEM.padX * 2));
|
|
139
|
+
}
|
|
140
|
+
function frameTitle({ title = "", badge, icon, db = false }, measure) {
|
|
141
|
+
const badgeW = chipWidth(badge, measure), lead = (badgeW ? badgeW + CHIP.gap : 0) + (icon ? ICON.size + ICON.gap : 0);
|
|
142
|
+
const lines = String(title).trim() ? wrapText(String(title), FRAME.text - lead, FRAME.font, measure) : [];
|
|
143
|
+
const rows = Math.max(lines.length, badge || icon ? 1 : 0);
|
|
144
|
+
const w = rows ? Math.ceil(lead + maxWidthOf(lines, FRAME.font, measure)) : 0;
|
|
145
|
+
const top = FRAME.top + (db ? FRAME.cylinder : 0);
|
|
146
|
+
return {
|
|
147
|
+
lines,
|
|
148
|
+
badgeW,
|
|
149
|
+
w,
|
|
150
|
+
top,
|
|
151
|
+
rows,
|
|
152
|
+
band: rows ? top + rows * FRAME.line + FRAME.after : 0,
|
|
153
|
+
minW: rows ? w + FRAME.inset * 2 : 0
|
|
154
|
+
};
|
|
155
|
+
}
|
|
156
|
+
function titleRect(frame, title) {
|
|
157
|
+
if (!title?.rows) return null;
|
|
158
|
+
return {
|
|
159
|
+
x: frame.x + FRAME.inset - 2,
|
|
160
|
+
y: frame.y + title.top - 2,
|
|
161
|
+
w: title.w + 4,
|
|
162
|
+
h: title.rows * FRAME.line + 4
|
|
163
|
+
};
|
|
164
|
+
}
|
|
165
|
+
function measureNote(text, measure, width = CARD.text) {
|
|
166
|
+
const lines = wrapText(String(text ?? ""), Math.max(24, width), NOTE.font, measure);
|
|
167
|
+
return {
|
|
168
|
+
lines,
|
|
169
|
+
w: Math.ceil(maxWidthOf(lines, NOTE.font, measure)),
|
|
170
|
+
h: lines.length * NOTE.line
|
|
171
|
+
};
|
|
172
|
+
}
|
|
173
|
+
function measureLabel(text, measure, icon) {
|
|
174
|
+
const lines = String(text ?? "").trim() ? wrapText(String(text), LABEL.text, LABEL.font, measure) : [];
|
|
175
|
+
if (!lines.length && !icon) return null;
|
|
176
|
+
const lead = icon ? ICON.size + (lines.length ? ICON.gap : 0) : 0;
|
|
177
|
+
return {
|
|
178
|
+
lines,
|
|
179
|
+
w: Math.ceil(lead + maxWidthOf(lines, LABEL.font, measure)) + LABEL.padX * 2,
|
|
180
|
+
h: Math.max(lines.length * LABEL.line, icon ? ICON.size : 0) + LABEL.padY * 2
|
|
181
|
+
};
|
|
182
|
+
}
|
|
183
|
+
function measureLegend(entries, measure, width = Infinity) {
|
|
184
|
+
const rows = [];
|
|
185
|
+
let row = [], x = 0, widest = 0;
|
|
186
|
+
for (const entry of entries) {
|
|
187
|
+
const lines = wrapText(String(entry.label), Math.max(24, Math.min(width, 480) - LEGEND.swatch - LEGEND.gap), LEGEND.font, measure);
|
|
188
|
+
const w = Math.ceil(LEGEND.swatch + LEGEND.gap + maxWidthOf(lines, LEGEND.font, measure));
|
|
189
|
+
if (row.length && x + LEGEND.item + w > width) {
|
|
190
|
+
rows.push(row);
|
|
191
|
+
row = [];
|
|
192
|
+
x = 0;
|
|
193
|
+
}
|
|
194
|
+
const at = row.length ? x + LEGEND.item : 0;
|
|
195
|
+
row.push({
|
|
196
|
+
...entry,
|
|
197
|
+
lines,
|
|
198
|
+
x: at,
|
|
199
|
+
w
|
|
200
|
+
});
|
|
201
|
+
x = at + w;
|
|
202
|
+
widest = Math.max(widest, x);
|
|
203
|
+
}
|
|
204
|
+
if (row.length) rows.push(row);
|
|
205
|
+
const heights = rows.map((items) => Math.max(...items.map((item) => item.lines.length)) * LEGEND.row);
|
|
206
|
+
return {
|
|
207
|
+
rows,
|
|
208
|
+
heights,
|
|
209
|
+
w: widest,
|
|
210
|
+
h: heights.reduce((sum, h) => sum + h, 0) + Math.max(0, rows.length - 1) * 6
|
|
211
|
+
};
|
|
212
|
+
}
|
|
213
|
+
function boardLook(ctx, styles = []) {
|
|
214
|
+
const d = ctx.design, a = appearance(ctx), bg = d.bg;
|
|
215
|
+
const outlined = (color) => ctx.tint(bg, color, OUTLINE);
|
|
216
|
+
const chartAccent = ctx.frameTone(ctx.color("accent"), true);
|
|
217
|
+
const accent = styles.includes("accent") && styles.some((style) => STATUS.has(style) && deltaE2000(outlined(chartAccent), outlined(d[style])) < DISTINCT) ? d.fg1 : chartAccent;
|
|
218
|
+
const hue = (style) => style === "accent" ? accent : STATUS.has(style) ? d[style] : null;
|
|
219
|
+
const ink = (color, under) => contrast(color, under) >= TEXT_CONTRAST ? color : pushContrast(color, d.fg1, under, TEXT_CONTRAST);
|
|
220
|
+
const neutral = ctx.tint(bg, ctx.color("muted"), .62);
|
|
221
|
+
const recessed = a.node === d.surface2 ? d.surface : d.surface2;
|
|
222
|
+
const tile = (under) => ctx.tint(under, d.fg3, TILE);
|
|
223
|
+
const chip = (color) => {
|
|
224
|
+
const fill = ctx.tint(bg, color, .14);
|
|
225
|
+
return {
|
|
226
|
+
fill,
|
|
227
|
+
color: ink(color, fill)
|
|
228
|
+
};
|
|
229
|
+
};
|
|
230
|
+
return {
|
|
231
|
+
bg,
|
|
232
|
+
radius: Math.min(a.radius, 10),
|
|
233
|
+
smallRadius: Math.min(a.smallRadius, 8),
|
|
234
|
+
fg: d.fg1,
|
|
235
|
+
muted: d.fg3,
|
|
236
|
+
line: neutral,
|
|
237
|
+
tag: {
|
|
238
|
+
fill: a.node,
|
|
239
|
+
stroke: d.line2,
|
|
240
|
+
color: ink(d.fg3, a.node)
|
|
241
|
+
},
|
|
242
|
+
item(tone, under = d.surface) {
|
|
243
|
+
const color = STATUS.has(tone) ? d[tone] : null;
|
|
244
|
+
return color ? {
|
|
245
|
+
fill: a.node,
|
|
246
|
+
stroke: ctx.mix(bg, color, .4),
|
|
247
|
+
mark: ink(color, a.node)
|
|
248
|
+
} : {
|
|
249
|
+
fill: tile(under),
|
|
250
|
+
stroke: null,
|
|
251
|
+
mark: d.fg1
|
|
252
|
+
};
|
|
253
|
+
},
|
|
254
|
+
card(style, under = d.surface) {
|
|
255
|
+
if (style === "ext") return {
|
|
256
|
+
fill: recessed,
|
|
257
|
+
stroke: neutral,
|
|
258
|
+
dash: DASH,
|
|
259
|
+
desc: ink(d.fg3, recessed),
|
|
260
|
+
badge: chip(accent)
|
|
261
|
+
};
|
|
262
|
+
const color = hue(style);
|
|
263
|
+
if (!color) {
|
|
264
|
+
const fill = tile(under);
|
|
265
|
+
return {
|
|
266
|
+
fill,
|
|
267
|
+
stroke: null,
|
|
268
|
+
dash: null,
|
|
269
|
+
desc: ink(d.fg3, fill),
|
|
270
|
+
badge: chip(accent)
|
|
271
|
+
};
|
|
272
|
+
}
|
|
273
|
+
return {
|
|
274
|
+
fill: a.node,
|
|
275
|
+
stroke: outlined(color),
|
|
276
|
+
dash: null,
|
|
277
|
+
desc: ink(d.fg3, a.node),
|
|
278
|
+
badge: chip(color)
|
|
279
|
+
};
|
|
280
|
+
},
|
|
281
|
+
frame(style) {
|
|
282
|
+
const color = style === "ext" ? null : hue(style), fill = style === "ext" ? d.surface2 : d.surface;
|
|
283
|
+
return {
|
|
284
|
+
fill,
|
|
285
|
+
stroke: color ? ctx.tint(bg, color, .55) : d.line2,
|
|
286
|
+
title: ink(color || d.fg3, fill),
|
|
287
|
+
badge: chip(color || accent)
|
|
288
|
+
};
|
|
289
|
+
},
|
|
290
|
+
edge(kind = "plain", status) {
|
|
291
|
+
return {
|
|
292
|
+
stroke: STATUS.has(status) ? d[status] : kind === "strong" ? accent : ctx.color("muted"),
|
|
293
|
+
width: kind === "strong" ? 1.75 : 1.25,
|
|
294
|
+
dash: kind === "dashed" ? DASH : null
|
|
295
|
+
};
|
|
296
|
+
}
|
|
297
|
+
};
|
|
298
|
+
}
|
|
299
|
+
function chip(ctx, x, cy, w, text, { fill, stroke, color }) {
|
|
300
|
+
return ctx.el("g", {}, [ctx.rect(x, cy - CHIP.h / 2, w, CHIP.h, {
|
|
301
|
+
rx: CHIP.h / 2,
|
|
302
|
+
fill,
|
|
303
|
+
...stroke ? {
|
|
304
|
+
stroke,
|
|
305
|
+
"stroke-width": 1
|
|
306
|
+
} : {}
|
|
307
|
+
}), ctx.text(x + w / 2, cy, text, {
|
|
308
|
+
anchor: "middle",
|
|
309
|
+
size: CHIP.font.size,
|
|
310
|
+
weight: CHIP.font.weight,
|
|
311
|
+
fill: color,
|
|
312
|
+
"dominant-baseline": "central"
|
|
313
|
+
})]);
|
|
314
|
+
}
|
|
315
|
+
function iconGlyph(ctx, icon, x, cy, color, size = ICON.size) {
|
|
316
|
+
const [vx, vy, w, h] = icon.viewBox.split(/\s+/).map(Number), scale = size / Math.max(w, h);
|
|
317
|
+
const stroke = icon.set === "tabler";
|
|
318
|
+
return ctx.el("g", {
|
|
319
|
+
transform: `translate(${round(x + (size - w * scale) / 2)} ${round(cy - h * scale / 2)}) scale(${round(scale)}) translate(${-vx} ${-vy})`,
|
|
320
|
+
fill: stroke ? "none" : color,
|
|
321
|
+
stroke: stroke ? color : "none",
|
|
322
|
+
"stroke-width": 1.8,
|
|
323
|
+
"stroke-linecap": "round",
|
|
324
|
+
"stroke-linejoin": "round"
|
|
325
|
+
}, icon.elements.map(({ tag, attrs }) => ctx.shape(tag, attrs)));
|
|
326
|
+
}
|
|
327
|
+
function cylinderPath({ x, y, w, h }) {
|
|
328
|
+
const ry = FRAME.cylinder;
|
|
329
|
+
return `M${x} ${y + ry} A${w / 2} ${ry} 0 0 1 ${x + w} ${y + ry} V${y + h - ry} A${w / 2} ${ry} 0 0 1 ${x} ${y + h - ry} Z M${x} ${y + ry} A${w / 2} ${ry} 0 0 0 ${x + w} ${y + ry}`;
|
|
330
|
+
}
|
|
331
|
+
function drawFrame(ctx, frame, look) {
|
|
332
|
+
const { id, x, y, w, h, style, db, badge, icon, title } = frame, s = look.frame(style);
|
|
333
|
+
const parts = [db ? ctx.path(cylinderPath(frame), {
|
|
334
|
+
fill: s.fill,
|
|
335
|
+
stroke: s.stroke,
|
|
336
|
+
"stroke-width": 1
|
|
337
|
+
}) : ctx.rect(x, y, w, h, {
|
|
338
|
+
rx: look.radius,
|
|
339
|
+
fill: s.fill,
|
|
340
|
+
stroke: s.stroke,
|
|
341
|
+
"stroke-width": 1,
|
|
342
|
+
"stroke-dasharray": DASH
|
|
343
|
+
})];
|
|
344
|
+
if (title?.rows) {
|
|
345
|
+
let tx = x + FRAME.inset;
|
|
346
|
+
const ty = y + title.top + FRAME.line / 2;
|
|
347
|
+
if (badge) {
|
|
348
|
+
parts.push(chip(ctx, tx, ty, title.badgeW, badge, s.badge));
|
|
349
|
+
tx += title.badgeW + CHIP.gap;
|
|
350
|
+
}
|
|
351
|
+
if (icon) {
|
|
352
|
+
parts.push(iconGlyph(ctx, icon, tx, ty, s.title));
|
|
353
|
+
tx += ICON.size + ICON.gap;
|
|
354
|
+
}
|
|
355
|
+
title.lines.forEach((line, i) => parts.push(ctx.text(tx, ty + i * FRAME.line, line, {
|
|
356
|
+
size: FRAME.font.size,
|
|
357
|
+
weight: FRAME.font.weight,
|
|
358
|
+
fill: s.title,
|
|
359
|
+
"dominant-baseline": "central",
|
|
360
|
+
meta: {
|
|
361
|
+
kind: "frame-title",
|
|
362
|
+
id
|
|
363
|
+
}
|
|
364
|
+
})));
|
|
365
|
+
}
|
|
366
|
+
return {
|
|
367
|
+
...ctx.el("g", {}, parts),
|
|
368
|
+
meta: {
|
|
369
|
+
kind: "frame",
|
|
370
|
+
id,
|
|
371
|
+
...style ? { style } : {}
|
|
372
|
+
}
|
|
373
|
+
};
|
|
374
|
+
}
|
|
375
|
+
var outline = (s, width) => s.stroke ? {
|
|
376
|
+
stroke: s.stroke,
|
|
377
|
+
"stroke-width": width,
|
|
378
|
+
...s.dash ? { "stroke-dasharray": s.dash } : {}
|
|
379
|
+
} : {};
|
|
380
|
+
function drawCard(ctx, card, look) {
|
|
381
|
+
const { id, x, y, w, h, style, badge, tag, titleLines, descLines, badgeW, tagW, under } = card, s = look.card(style, under);
|
|
382
|
+
const parts = [ctx.rect(x, y, w, h, {
|
|
383
|
+
rx: look.radius,
|
|
384
|
+
fill: s.fill,
|
|
385
|
+
...outline(s, 1.25)
|
|
386
|
+
})];
|
|
387
|
+
let tx = x + CARD.padX;
|
|
388
|
+
const ty = y + CARD.padY + CARD.title / 2;
|
|
389
|
+
if (badge) {
|
|
390
|
+
parts.push(chip(ctx, tx, ty, badgeW, badge, s.badge));
|
|
391
|
+
tx += badgeW + CHIP.gap;
|
|
392
|
+
}
|
|
393
|
+
titleLines.forEach((line, i) => parts.push(ctx.text(tx, ty + i * CARD.title, line, {
|
|
394
|
+
size: FONT.title.size,
|
|
395
|
+
weight: FONT.title.weight,
|
|
396
|
+
fill: look.fg,
|
|
397
|
+
"dominant-baseline": "central"
|
|
398
|
+
})));
|
|
399
|
+
if (tag) parts.push(chip(ctx, x + w - CARD.padX - tagW, ty, tagW, tag, look.tag));
|
|
400
|
+
const top = y + CARD.padY + titleLines.length * CARD.title + CARD.gap + CARD.desc / 2;
|
|
401
|
+
descLines.forEach((line, i) => parts.push(ctx.text(x + CARD.padX, top + i * CARD.desc, line, {
|
|
402
|
+
size: FONT.label.size,
|
|
403
|
+
weight: FONT.label.weight,
|
|
404
|
+
fill: s.desc,
|
|
405
|
+
"dominant-baseline": "central"
|
|
406
|
+
})));
|
|
407
|
+
return {
|
|
408
|
+
...ctx.el("g", {}, parts),
|
|
409
|
+
meta: {
|
|
410
|
+
kind: "node",
|
|
411
|
+
id,
|
|
412
|
+
...style ? { style } : {}
|
|
413
|
+
}
|
|
414
|
+
};
|
|
415
|
+
}
|
|
416
|
+
function drawItem(ctx, item, look) {
|
|
417
|
+
const { x, y, w, h, label, name, mark, tone, icon, under } = item, s = look.item(tone, under);
|
|
418
|
+
const lead = icon ? ICON.size + ICON.gap : 0, left = x + (w - lead - ctx.measure(label, ITEM.font.size, ITEM.font.weight)) / 2, cy = y + h / 2;
|
|
419
|
+
const parts = [ctx.rect(x, y, w, h, {
|
|
420
|
+
rx: look.smallRadius,
|
|
421
|
+
fill: s.fill,
|
|
422
|
+
...outline(s, 1)
|
|
423
|
+
})];
|
|
424
|
+
if (icon) parts.push(iconGlyph(ctx, icon, left, cy, look.muted));
|
|
425
|
+
const font = {
|
|
426
|
+
size: ITEM.font.size,
|
|
427
|
+
weight: ITEM.font.weight,
|
|
428
|
+
fill: look.fg,
|
|
429
|
+
"dominant-baseline": "central"
|
|
430
|
+
};
|
|
431
|
+
const mapped = ctx.font(font.size, font.weight);
|
|
432
|
+
parts.push(mark ? ctx.el("text", {
|
|
433
|
+
x: left + lead,
|
|
434
|
+
y: cy,
|
|
435
|
+
"text-anchor": "start",
|
|
436
|
+
"dominant-baseline": "central",
|
|
437
|
+
"font-size": mapped.size,
|
|
438
|
+
"font-weight": mapped.weight,
|
|
439
|
+
fill: look.fg
|
|
440
|
+
}, [{
|
|
441
|
+
...ctx.el("tspan", { fill: s.mark }),
|
|
442
|
+
text: mark
|
|
443
|
+
}, {
|
|
444
|
+
...ctx.el("tspan"),
|
|
445
|
+
text: ` ${name}`
|
|
446
|
+
}]) : ctx.text(left + lead, cy, label, font));
|
|
447
|
+
return ctx.el("g", {}, parts);
|
|
448
|
+
}
|
|
449
|
+
function drawNote(ctx, note, look) {
|
|
450
|
+
return {
|
|
451
|
+
...ctx.el("g", {}, note.lines.map((line, i) => ctx.text(note.x, note.y + (i + .5) * NOTE.line, line, {
|
|
452
|
+
size: NOTE.font.size,
|
|
453
|
+
weight: NOTE.font.weight,
|
|
454
|
+
fill: look.muted,
|
|
455
|
+
"dominant-baseline": "central"
|
|
456
|
+
}))),
|
|
457
|
+
meta: { kind: "note" }
|
|
458
|
+
};
|
|
459
|
+
}
|
|
460
|
+
function markers(ctx) {
|
|
461
|
+
const defs = /* @__PURE__ */ new Map();
|
|
462
|
+
return {
|
|
463
|
+
url(kind, color) {
|
|
464
|
+
const id = `board-${kind}-${String(color).replace(/[^\da-z]/gi, "")}`;
|
|
465
|
+
if (!defs.has(id)) {
|
|
466
|
+
const child = kind === "circle" ? ctx.el("circle", {
|
|
467
|
+
cx: 5,
|
|
468
|
+
cy: 5,
|
|
469
|
+
r: 4,
|
|
470
|
+
fill: ctx.design.bg,
|
|
471
|
+
stroke: color
|
|
472
|
+
}) : kind === "cross" ? ctx.path("M1 1 L9 9 M9 1 L1 9", {
|
|
473
|
+
fill: "none",
|
|
474
|
+
stroke: color,
|
|
475
|
+
"stroke-width": 1.8
|
|
476
|
+
}) : ctx.path("M0 0 L10 5 L0 10 Z", { fill: color });
|
|
477
|
+
defs.set(id, ctx.el("marker", {
|
|
478
|
+
id,
|
|
479
|
+
viewBox: "0 0 10 10",
|
|
480
|
+
refX: 9,
|
|
481
|
+
refY: 5,
|
|
482
|
+
markerWidth: 7,
|
|
483
|
+
markerHeight: 7,
|
|
484
|
+
markerUnits: "userSpaceOnUse",
|
|
485
|
+
orient: "auto-start-reverse"
|
|
486
|
+
}, [child]));
|
|
487
|
+
}
|
|
488
|
+
return `url(#${id})`;
|
|
489
|
+
},
|
|
490
|
+
defs: () => defs.size ? [ctx.el("defs", {}, [...defs.values()])] : []
|
|
491
|
+
};
|
|
492
|
+
}
|
|
493
|
+
function surfaceAt(frames, look, x, y) {
|
|
494
|
+
let best = null;
|
|
495
|
+
for (const f of frames) if (x >= f.x && x <= f.x + f.w && y >= f.y && y <= f.y + f.h && (!best || f.w * f.h < best.w * best.h)) best = f;
|
|
496
|
+
return best ? look.frame(best.style).fill : look.bg;
|
|
497
|
+
}
|
|
498
|
+
function drawEdge(ctx, edge, stroke, { start, end } = {}) {
|
|
499
|
+
const d = `M${edge.points.map((p) => `${round(p.x)} ${round(p.y)}`).join(" L")}`;
|
|
500
|
+
const attrs = {
|
|
501
|
+
fill: "none",
|
|
502
|
+
stroke: stroke.stroke,
|
|
503
|
+
"stroke-width": stroke.width,
|
|
504
|
+
"stroke-linecap": "round",
|
|
505
|
+
"stroke-linejoin": "round",
|
|
506
|
+
...stroke.dash ? { "stroke-dasharray": stroke.dash } : {},
|
|
507
|
+
...start ? { "marker-start": start } : {},
|
|
508
|
+
...end ? { "marker-end": end } : {}
|
|
509
|
+
};
|
|
510
|
+
return {
|
|
511
|
+
...ctx.path(d, attrs),
|
|
512
|
+
meta: {
|
|
513
|
+
kind: "edge",
|
|
514
|
+
from: edge.from,
|
|
515
|
+
to: edge.to
|
|
516
|
+
}
|
|
517
|
+
};
|
|
518
|
+
}
|
|
519
|
+
function drawLabel(ctx, { from, to, rect, lines, icon, plate }, look) {
|
|
520
|
+
const lead = icon ? ICON.size + (lines.length ? ICON.gap : 0) : 0;
|
|
521
|
+
const cx = rect.x + (rect.w + lead) / 2, cy = rect.y + rect.h / 2;
|
|
522
|
+
return {
|
|
523
|
+
...ctx.el("g", {}, [
|
|
524
|
+
ctx.rect(rect.x, rect.y, rect.w, rect.h, {
|
|
525
|
+
rx: 3,
|
|
526
|
+
fill: plate
|
|
527
|
+
}),
|
|
528
|
+
...icon ? [iconGlyph(ctx, icon, rect.x + LABEL.padX, cy, look.muted)] : [],
|
|
529
|
+
...lines.map((line, i) => ctx.text(cx, cy + (i - (lines.length - 1) / 2) * LABEL.line, line, {
|
|
530
|
+
anchor: "middle",
|
|
531
|
+
size: LABEL.font.size,
|
|
532
|
+
weight: LABEL.font.weight,
|
|
533
|
+
fill: look.muted,
|
|
534
|
+
"dominant-baseline": "central"
|
|
535
|
+
}))
|
|
536
|
+
]),
|
|
537
|
+
meta: {
|
|
538
|
+
kind: "edge-label-group",
|
|
539
|
+
from,
|
|
540
|
+
to
|
|
541
|
+
}
|
|
542
|
+
};
|
|
543
|
+
}
|
|
544
|
+
function drawLegend(ctx, legend, look, marks, under) {
|
|
545
|
+
const items = [];
|
|
546
|
+
let top = legend.y;
|
|
547
|
+
legend.rows.forEach((row, r) => {
|
|
548
|
+
for (const item of row) {
|
|
549
|
+
const x = legend.x + item.x, cy = top + LEGEND.row / 2, parts = [];
|
|
550
|
+
const kind = EDGE_KINDS[item.key];
|
|
551
|
+
if (kind) {
|
|
552
|
+
const stroke = look.edge(kind);
|
|
553
|
+
parts.push(drawEdge(ctx, { points: [{
|
|
554
|
+
x: x + 1,
|
|
555
|
+
y: cy
|
|
556
|
+
}, {
|
|
557
|
+
x: x + LEGEND.swatch - 1,
|
|
558
|
+
y: cy
|
|
559
|
+
}] }, stroke, { end: marks.url("arrow", stroke.stroke) }));
|
|
560
|
+
delete parts[0].meta;
|
|
561
|
+
} else if (item.key === "db") {
|
|
562
|
+
const s = look.frame();
|
|
563
|
+
parts.push(ctx.path(`M${x + 2} ${cy - 4} A8 3 0 0 1 ${x + 18} ${cy - 4} V${cy + 4} A8 3 0 0 1 ${x + 2} ${cy + 4} Z M${x + 2} ${cy - 4} A8 3 0 0 0 ${x + 18} ${cy - 4}`, {
|
|
564
|
+
fill: s.fill,
|
|
565
|
+
stroke: look.line,
|
|
566
|
+
"stroke-width": 1
|
|
567
|
+
}));
|
|
568
|
+
} else {
|
|
569
|
+
const s = look.card(item.key === "default" ? void 0 : item.key, under);
|
|
570
|
+
parts.push(ctx.rect(x + 1, cy - 6, LEGEND.swatch - 2, 12, {
|
|
571
|
+
rx: 3,
|
|
572
|
+
fill: s.fill,
|
|
573
|
+
...outline({
|
|
574
|
+
...s,
|
|
575
|
+
dash: s.dash && "3 2"
|
|
576
|
+
}, 1.25)
|
|
577
|
+
}));
|
|
578
|
+
}
|
|
579
|
+
item.lines.forEach((line, i) => parts.push(ctx.text(x + LEGEND.swatch + LEGEND.gap, cy + i * LEGEND.row, line, {
|
|
580
|
+
size: LEGEND.font.size,
|
|
581
|
+
weight: LEGEND.font.weight,
|
|
582
|
+
fill: look.fg,
|
|
583
|
+
"dominant-baseline": "central"
|
|
584
|
+
})));
|
|
585
|
+
items.push(ctx.el("g", {}, parts));
|
|
586
|
+
}
|
|
587
|
+
top += legend.heights[r] + 6;
|
|
588
|
+
});
|
|
589
|
+
return {
|
|
590
|
+
...ctx.el("g", {}, items),
|
|
591
|
+
meta: { kind: "legend" }
|
|
592
|
+
};
|
|
593
|
+
}
|
|
594
|
+
export { CARD, CHIP, EDGE_KINDS, FRAME, ICON, ITEM, LABEL, LEGEND, NOTE, STYLES, boardLook, board_paint_exports, drawCard, drawEdge, drawFrame, drawItem, drawLabel, drawLegend, drawNote, frameTitle, iconGlyph, markers, measureCard, measureItem, measureLabel, measureLegend, measureNote, surfaceAt, titleRect };
|
|
@@ -0,0 +1,60 @@
|
|
|
1
|
+
import { __exportAll } from "../_virtual/_rolldown/runtime.js";
|
|
2
|
+
import { repairRoutes } from "./graph-route.js";
|
|
3
|
+
// src/diagram/board-route.js
|
|
4
|
+
var board_route_exports = /* @__PURE__ */ __exportAll({ routeBoard: () => routeBoard });
|
|
5
|
+
var center = (box) => ({
|
|
6
|
+
x: box.x + box.w / 2,
|
|
7
|
+
y: box.y + box.h / 2
|
|
8
|
+
});
|
|
9
|
+
var straight = (a, b) => ({
|
|
10
|
+
p0: a,
|
|
11
|
+
c1: a,
|
|
12
|
+
c2: b,
|
|
13
|
+
p1: b
|
|
14
|
+
});
|
|
15
|
+
var BLOCKER = "\0blocker";
|
|
16
|
+
function routeBoard({ width, height, nodes, frames, blockers = [], edges }) {
|
|
17
|
+
const boxes = new Map([...nodes, ...frames].map((box) => [box.id, box]));
|
|
18
|
+
const routed = edges.map((edge) => {
|
|
19
|
+
const a = center(boxes.get(edge.from)), b = center(boxes.get(edge.to));
|
|
20
|
+
const segments = [straight(a, b)];
|
|
21
|
+
return {
|
|
22
|
+
id: edge.id,
|
|
23
|
+
from: edge.from,
|
|
24
|
+
to: edge.to,
|
|
25
|
+
start: a,
|
|
26
|
+
end: b,
|
|
27
|
+
segments,
|
|
28
|
+
initial: segments,
|
|
29
|
+
...edge.label ? { labelRect: {
|
|
30
|
+
w: edge.label.w,
|
|
31
|
+
h: edge.label.h
|
|
32
|
+
} } : {}
|
|
33
|
+
};
|
|
34
|
+
});
|
|
35
|
+
const geometry = {
|
|
36
|
+
type: "board",
|
|
37
|
+
width,
|
|
38
|
+
height,
|
|
39
|
+
labels: [],
|
|
40
|
+
edges: routed,
|
|
41
|
+
nodes: [...nodes.map((node) => ({ ...node })), ...blockers.map((box, i) => ({
|
|
42
|
+
...box,
|
|
43
|
+
id: `${BLOCKER}${i}`
|
|
44
|
+
}))],
|
|
45
|
+
frames: frames.map((frame) => ({ ...frame }))
|
|
46
|
+
};
|
|
47
|
+
repairRoutes(geometry, new Map(routed.map((edge) => [edge.id, {
|
|
48
|
+
from: edge.from,
|
|
49
|
+
to: edge.to
|
|
50
|
+
}])), { board: true });
|
|
51
|
+
return {
|
|
52
|
+
failed: routed.filter((edge) => edge.segments === edge.initial).map((edge) => edge.id),
|
|
53
|
+
edges: routed.filter((edge) => edge.segments !== edge.initial).map((edge) => ({
|
|
54
|
+
id: edge.id,
|
|
55
|
+
points: [edge.segments[0].p0, ...edge.segments.map((segment) => segment.p1)],
|
|
56
|
+
...edge.labelRect ? { labelRect: edge.labelRect } : {}
|
|
57
|
+
}))
|
|
58
|
+
};
|
|
59
|
+
}
|
|
60
|
+
export { board_route_exports, routeBoard };
|