@cardenelabs/dragon 0.37.0 → 0.40.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/README.md +38 -1
- package/dist/cli.cjs +2403 -550
- package/dist/cli.cjs.map +1 -1
- package/dist/cli.js +2408 -555
- package/dist/cli.js.map +1 -1
- package/dist/export.cjs +2252 -537
- package/dist/export.cjs.map +1 -1
- package/dist/export.d.cts +3 -1
- package/dist/export.d.ts +3 -1
- package/dist/export.js +2257 -542
- package/dist/export.js.map +1 -1
- package/dist/index.cjs +2387 -495
- package/dist/index.cjs.map +1 -1
- package/dist/index.d.cts +11 -154
- package/dist/index.d.ts +11 -154
- package/dist/index.js +2387 -496
- package/dist/index.js.map +1 -1
- package/dist/ink-B_7OXxtb.d.cts +360 -0
- package/dist/ink-B_7OXxtb.d.ts +360 -0
- package/dist/player.global.js +2 -2
- package/package.json +1 -1
- package/src/cli.ts +9 -0
- package/src/export/index.ts +4 -1
- package/src/field-messages.ts +8 -0
- package/src/figure-text.ts +28 -0
- package/src/index.ts +3 -0
- package/src/layout/architecture.ts +123 -44
- package/src/layout/git.ts +728 -0
- package/src/layout/measure.ts +10 -0
- package/src/layout/scene.ts +300 -19
- package/src/layout/sequence.ts +29 -11
- package/src/layout/state.ts +82 -62
- package/src/look/values.ts +57 -4
- package/src/messages.ts +47 -4
- package/src/parser.ts +142 -7
- package/src/player.ts +44 -0
- package/src/printer.ts +16 -4
- package/src/render/git.ts +161 -0
- package/src/render/ink.ts +104 -0
- package/src/render/parts.ts +103 -36
- package/src/render/svg.ts +63 -15
- package/src/schema.ts +47 -13
- package/src/schemas/diagram.schema.json +75 -8
- package/src/schemas/validate-diagram.js +1 -1
- package/src/timeline.ts +18 -3
- package/src/words.ts +19 -3
- package/dist/schema-B2MTRv66.d.cts +0 -133
- package/dist/schema-B2MTRv66.d.ts +0 -133
package/src/layout/measure.ts
CHANGED
|
@@ -3,6 +3,7 @@
|
|
|
3
3
|
*/
|
|
4
4
|
import { advance, EM, type Family } from "../look/fonts";
|
|
5
5
|
import type { TextStyle } from "../look/values";
|
|
6
|
+
import type { Rect } from "./scene";
|
|
6
7
|
|
|
7
8
|
/** 和文 (CJK) の字を含むか。等幅の字は和文を持たないので、含む字は Noto Sans JP で描く。 */
|
|
8
9
|
export const hasWide = (text: string): boolean => [...text].some((ch) => (ch.codePointAt(0) ?? 0) >= 0x2e80);
|
|
@@ -19,3 +20,12 @@ export function textWidth(text: string, style: TextStyle): number {
|
|
|
19
20
|
for (const ch of text) sum += advance(ch, family);
|
|
20
21
|
return (sum * style.size) / EM;
|
|
21
22
|
}
|
|
23
|
+
|
|
24
|
+
/**
|
|
25
|
+
* 1 行の字が占める四角 (#3175)。`x` は `anchor` が `start` なら左端、`middle` なら真ん中で、`y` は基準線。
|
|
26
|
+
* 高さは行の外枠ではなく字の形の高さ (基準線から上に字の大きさの 8 割、下に 2 割) を取る。上下に並べた 2 行 (箱の名前と下の字) を重なりに数えないため
|
|
27
|
+
*/
|
|
28
|
+
export function textBox(text: string, x: number, y: number, style: TextStyle, anchor: "start" | "middle" = "start"): Rect {
|
|
29
|
+
const w = textWidth(text, style);
|
|
30
|
+
return { x: anchor === "middle" ? x - w / 2 : x, y: y - style.size * 0.8, w, h: style.size };
|
|
31
|
+
}
|
package/src/layout/scene.ts
CHANGED
|
@@ -28,6 +28,10 @@ export interface SceneBox extends Rect {
|
|
|
28
28
|
cy: number;
|
|
29
29
|
/** 状態遷移図で、どの段も辿り着かない状態。点線の箱で脇道の囲みに描く */
|
|
30
30
|
ghost?: boolean;
|
|
31
|
+
/** 運ぶ物の置き場の枠 (#3176)。運ぶ物を出し入れする箱だけが持つ */
|
|
32
|
+
slot?: Rect;
|
|
33
|
+
/** 絵柄の真ん中の x。置き場を持つ箱は、絵柄を左へ寄せて右を置き場にする。無ければ箱の真ん中 */
|
|
34
|
+
iconX?: number;
|
|
31
35
|
}
|
|
32
36
|
|
|
33
37
|
export interface SceneRegion extends Rect {
|
|
@@ -52,6 +56,8 @@ export interface SceneEdge {
|
|
|
52
56
|
carry: Carry;
|
|
53
57
|
/** 着いた運ぶ物が留まる点。無ければ線の終わり */
|
|
54
58
|
settle?: Point;
|
|
59
|
+
/** 走り出す前に運ぶ物が待つ点 (#3176)。運ぶ物はここから線の始まりへ出て線を走る。無ければ線の始まり */
|
|
60
|
+
wait?: Point;
|
|
55
61
|
}
|
|
56
62
|
|
|
57
63
|
export interface SceneLabel extends Rect {
|
|
@@ -60,6 +66,8 @@ export interface SceneLabel extends Rect {
|
|
|
60
66
|
text: string;
|
|
61
67
|
family: Family;
|
|
62
68
|
color: ColorKey;
|
|
69
|
+
/** 同じ線の同じ名前を次に置く段 (状態遷移図、#3184)。その段が始まると、薄く残した名前を消す */
|
|
70
|
+
until?: number;
|
|
63
71
|
}
|
|
64
72
|
|
|
65
73
|
/** 状態遷移図の、最初の段より前に書いてどの段にも出ない線。点線で描き、運ぶ物を走らせない */
|
|
@@ -104,6 +112,8 @@ export interface SceneBadge {
|
|
|
104
112
|
x: number;
|
|
105
113
|
y: number;
|
|
106
114
|
color: ColorKey;
|
|
115
|
+
/** 同じ所に次に番号を置く段 (#3184)。その段が始まると、この番号を消して数字を入れ替える。無ければ最後まで残る */
|
|
116
|
+
until?: number;
|
|
107
117
|
}
|
|
108
118
|
|
|
109
119
|
export interface SceneLifeline {
|
|
@@ -199,6 +209,93 @@ export function boxWidth(diagram: Diagram, id: string, withActions: boolean): nu
|
|
|
199
209
|
return Math.max(LOOK.box.minW, Math.max(...lines) + LOOK.box.padX * 2);
|
|
200
210
|
}
|
|
201
211
|
|
|
212
|
+
/** 運ぶ物の半分の幅と高さ */
|
|
213
|
+
export function carrierHalf(carry: Carry): Point {
|
|
214
|
+
const C = LOOK.carrier;
|
|
215
|
+
if (carry.kind === "tag") return [(textWidth(carry.text, hasWide(carry.text) ? TYPE.carrierJa : TYPE.carrier) + C.tagPadX * 2) / 2, C.tagH / 2];
|
|
216
|
+
if (carry.kind === "coin") return [C.coinR, C.coinR];
|
|
217
|
+
return [C.envW / 2, C.envH / 2];
|
|
218
|
+
}
|
|
219
|
+
|
|
220
|
+
/**
|
|
221
|
+
* 置き場の中身の幅 (#3176)。主役の運ぶ物 (封筒と札) と硬貨は別々に動き、同じ箱に同時に留まることがあるので、
|
|
222
|
+
* 両方が出入りする箱は主役を左、硬貨を右に並べる。それぞれの幅は、その箱を出入りする物の最も広い幅
|
|
223
|
+
*/
|
|
224
|
+
export interface SlotRoom {
|
|
225
|
+
main: number;
|
|
226
|
+
coin: number;
|
|
227
|
+
}
|
|
228
|
+
|
|
229
|
+
const roomWidth = (room: SlotRoom): number => room.main + room.coin + (room.main > 0 && room.coin > 0 ? LOOK.slot.spread : 0);
|
|
230
|
+
|
|
231
|
+
/** 運ぶ物を出し入れする箱ごとの置き場の中身の幅。何も運ばない線だけの箱は持たない */
|
|
232
|
+
export function slotRooms(diagram: Diagram): Map<string, SlotRoom> {
|
|
233
|
+
const rooms = new Map<string, SlotRoom>();
|
|
234
|
+
const ids = new Set(diagram.boxes.map((b) => b.id));
|
|
235
|
+
for (const step of diagram.steps) {
|
|
236
|
+
for (const event of step.events) {
|
|
237
|
+
if (event.type !== "edge" || event.carry.kind === "none") continue;
|
|
238
|
+
const who = event.carry.kind === "coin" ? "coin" : "main";
|
|
239
|
+
const w = carrierHalf(event.carry)[0] * 2;
|
|
240
|
+
for (const id of [event.from, event.to]) {
|
|
241
|
+
if (!ids.has(id)) continue;
|
|
242
|
+
const room = rooms.get(id) ?? { main: 0, coin: 0 };
|
|
243
|
+
room[who] = Math.max(room[who], w);
|
|
244
|
+
rooms.set(id, room);
|
|
245
|
+
}
|
|
246
|
+
}
|
|
247
|
+
}
|
|
248
|
+
return rooms;
|
|
249
|
+
}
|
|
250
|
+
|
|
251
|
+
/**
|
|
252
|
+
* 置き場を持つ箱の幅。絵柄と枠を並べた幅の左に箱の余白を、右に `right` を空ける。
|
|
253
|
+
* 状態遷移図は右上の済んだ印を避けるため `right` を広く取る。両脇を同じだけ広げないのは、図が広がって読める大きさで収まらなくなるため
|
|
254
|
+
*/
|
|
255
|
+
export function slotBoxWidth(room: SlotRoom | undefined, icon: boolean, right: number): number {
|
|
256
|
+
if (!room) return 0;
|
|
257
|
+
return (icon ? LOOK.box.icon + LOOK.slot.gap : 0) + roomWidth(room) + LOOK.slot.pad * 2 + LOOK.box.padX + right;
|
|
258
|
+
}
|
|
259
|
+
|
|
260
|
+
/**
|
|
261
|
+
* 箱の絵柄の行に、絵柄と置き場の枠を並べる。絵柄を持たない箱は枠だけを置く。
|
|
262
|
+
* 並びは真ん中に置き、右に `right` を空けられない時だけ、空けられる所まで左へ寄せる
|
|
263
|
+
*/
|
|
264
|
+
export function placeSlot(box: SceneBox, room: SlotRoom | undefined, right: number = LOOK.box.padX): void {
|
|
265
|
+
if (!room) return;
|
|
266
|
+
const B = LOOK.box;
|
|
267
|
+
const S = LOOK.slot;
|
|
268
|
+
const w = roomWidth(room) + S.pad * 2;
|
|
269
|
+
const lead = box.icon ? B.icon + S.gap : 0;
|
|
270
|
+
const left = Math.max(box.x + B.padX, Math.min(box.cx - (lead + w) / 2, box.x + box.w - right - (lead + w)));
|
|
271
|
+
if (box.icon) box.iconX = left + B.icon / 2;
|
|
272
|
+
box.slot = { x: left + lead, y: box.cy + B.iconY - S.h / 2, w, h: S.h };
|
|
273
|
+
}
|
|
274
|
+
|
|
275
|
+
/**
|
|
276
|
+
* 箱を出入りする運ぶ物を、箱の置き場に座らせる。着いた物は着いた箱の置き場に留まり (`settle`)、
|
|
277
|
+
* 走り出す前の物は出る箱の置き場で待つ (`wait`)。主役は枠の左の区画、硬貨は右の区画の真ん中に置く
|
|
278
|
+
*/
|
|
279
|
+
export function seatCarriers(edges: SceneEdge[], boxes: Map<string, SceneBox>, rooms: Map<string, SlotRoom>): void {
|
|
280
|
+
const S = LOOK.slot;
|
|
281
|
+
const seat = (id: string, carry: Carry): Point | undefined => {
|
|
282
|
+
const box = boxes.get(id);
|
|
283
|
+
const room = rooms.get(id);
|
|
284
|
+
if (!box?.slot || !room) return undefined;
|
|
285
|
+
const inner = box.slot.x + S.pad;
|
|
286
|
+
const y = box.slot.y + box.slot.h / 2;
|
|
287
|
+
if (room.main > 0 && room.coin > 0) return carry.kind === "coin" ? [inner + room.main + S.spread + room.coin / 2, y] : [inner + room.main / 2, y];
|
|
288
|
+
return [box.slot.x + box.slot.w / 2, y];
|
|
289
|
+
};
|
|
290
|
+
for (const edge of edges) {
|
|
291
|
+
if (edge.carry.kind === "none") continue;
|
|
292
|
+
const settle = seat(edge.to, edge.carry);
|
|
293
|
+
const wait = seat(edge.from, edge.carry);
|
|
294
|
+
if (settle) edge.settle = settle;
|
|
295
|
+
if (wait) edge.wait = wait;
|
|
296
|
+
}
|
|
297
|
+
}
|
|
298
|
+
|
|
202
299
|
/** 2 つの四角の隙間。重なる時は負。縦か横のどちらかで離れていれば、その離れ方の大きい方。 */
|
|
203
300
|
export function gapBetween(a: Rect, b: Rect): number {
|
|
204
301
|
const dx = Math.max(b.x - (a.x + a.w), a.x - (b.x + b.w));
|
|
@@ -206,6 +303,35 @@ export function gapBetween(a: Rect, b: Rect): number {
|
|
|
206
303
|
return Math.max(dx, dy);
|
|
207
304
|
}
|
|
208
305
|
|
|
306
|
+
/**
|
|
307
|
+
* 折れ線が四角の内側を通るか (#3175)。四角を縁から `inset` だけ内へ縮めて見る。負の `inset` は四角を広げる。
|
|
308
|
+
* 区間ごとに、四角の左右と上下の境で区間を切り詰め (Liang-Barsky の切り取り)、残りが在れば通る
|
|
309
|
+
*/
|
|
310
|
+
export function crossesRect(points: Point[], rect: Rect, inset = 0): boolean {
|
|
311
|
+
const x0 = rect.x + inset;
|
|
312
|
+
const y0 = rect.y + inset;
|
|
313
|
+
const x1 = rect.x + rect.w - inset;
|
|
314
|
+
const y1 = rect.y + rect.h - inset;
|
|
315
|
+
if (x1 <= x0 || y1 <= y0) return false;
|
|
316
|
+
for (let i = 1; i < points.length; i++) {
|
|
317
|
+
const [ax, ay] = points[i - 1] as Point;
|
|
318
|
+
const [bx, by] = points[i] as Point;
|
|
319
|
+
const dx = bx - ax;
|
|
320
|
+
const dy = by - ay;
|
|
321
|
+
let lo = 0;
|
|
322
|
+
let hi = 1;
|
|
323
|
+
const cut = (p: number, q: number): boolean => {
|
|
324
|
+
if (p === 0) return q > 0;
|
|
325
|
+
const r = q / p;
|
|
326
|
+
if (p < 0) lo = Math.max(lo, r);
|
|
327
|
+
else hi = Math.min(hi, r);
|
|
328
|
+
return lo < hi;
|
|
329
|
+
};
|
|
330
|
+
if (cut(-dx, ax - x0) && cut(dx, x1 - ax) && cut(-dy, ay - y0) && cut(dy, y1 - ay)) return true;
|
|
331
|
+
}
|
|
332
|
+
return false;
|
|
333
|
+
}
|
|
334
|
+
|
|
209
335
|
/** 折れ線のうち一番長い区間。 */
|
|
210
336
|
export function longest(points: Point[]): { a: Point; b: Point; vertical: boolean } {
|
|
211
337
|
let best = { a: points[0] as Point, b: (points[1] ?? points[0]) as Point, length: -1 };
|
|
@@ -241,12 +367,137 @@ export function pathLength(points: Point[]): number {
|
|
|
241
367
|
return sum;
|
|
242
368
|
}
|
|
243
369
|
|
|
244
|
-
/**
|
|
245
|
-
|
|
370
|
+
/**
|
|
371
|
+
* 同じ箱へ戻る輪 (状態遷移図 #3163、構成図 #3186)。箱の下端の右から出て、下へ膨らむ弧を描いて左から箱へ戻る。
|
|
372
|
+
* 運ぶ物が弧の上を走れるよう、点で区切る。大きさは状態遷移図の値 (`LOOK.state.loop`) を 2 つの図で分け合う
|
|
373
|
+
*/
|
|
374
|
+
export function loopUnder(box: { cx: number; y: number; h: number }): Point[] {
|
|
375
|
+
const { w, h, samples } = LOOK.state.loop;
|
|
376
|
+
const bottom = box.y + box.h;
|
|
377
|
+
const p0: Point = [box.cx + w / 2, bottom];
|
|
378
|
+
const c1: Point = [box.cx + (w * 3) / 4, bottom + (h * 4) / 3];
|
|
379
|
+
const c2: Point = [box.cx - (w * 3) / 4, bottom + (h * 4) / 3];
|
|
380
|
+
const p3: Point = [box.cx - w / 2, bottom + LOOK.edge.inset];
|
|
381
|
+
return Array.from({ length: samples + 1 }, (_, k): Point => {
|
|
382
|
+
const t = k / samples;
|
|
383
|
+
const u = 1 - t;
|
|
384
|
+
const at = (i: 0 | 1): number => u * u * u * p0[i] + 3 * u * u * t * c1[i] + 3 * u * t * t * c2[i] + t * t * t * p3[i];
|
|
385
|
+
return [at(0), at(1)];
|
|
386
|
+
});
|
|
387
|
+
}
|
|
388
|
+
|
|
389
|
+
/** 輪の段の番号の点。弧に重ねず弧の右に置き、高さは弧の上端から深さの `LOOK.state.loop.badgeAt` の所 */
|
|
390
|
+
export function loopBadge(points: Point[]): Point {
|
|
391
|
+
const right = Math.max(...points.map(([px]) => px));
|
|
392
|
+
const top = (points[0] as Point)[1];
|
|
393
|
+
const deep = Math.max(...points.map(([, py]) => py));
|
|
394
|
+
return [right + LOOK.badge.r + LOOK.badge.inset, top + (deep - top) * LOOK.state.loop.badgeAt];
|
|
395
|
+
}
|
|
396
|
+
|
|
397
|
+
/** 輪の名前を探し始める札の左上。幅 `w` の札を輪の真下の真ん中に置く */
|
|
398
|
+
export function loopLabelBase(points: Point[], w: number): { x: number; y: number } {
|
|
399
|
+
return { x: (points[0]?.[0] ?? 0) - LOOK.state.loop.w / 2 - w / 2, y: Math.max(...points.map(([, y]) => y)) + LOOK.label.soft };
|
|
400
|
+
}
|
|
401
|
+
|
|
402
|
+
/** 輪と、その下に置く名前の札が、箱の下に要る高さ (#3186) */
|
|
403
|
+
export const LOOP_ROOM = LOOK.state.loop.h + LOOK.label.soft * 2 + LOOK.label.h;
|
|
404
|
+
|
|
405
|
+
/**
|
|
406
|
+
* 段の番号を置く点。線の始まりから少し進んだ所。`LOOK.badge.short` より短い線も始まりに置き、出る箱の縁から番号の半径と 1px だけ進める。
|
|
407
|
+
* 中ほどに置くと、往復する 2 本の短い線で 2 つの番号が同じ高さに並んで重なるため (#3189)。
|
|
408
|
+
* 先に置いた番号 (`taken`) に重なる時は、線に沿って進めて前の番号を避ける (#3175)。
|
|
409
|
+
* 線の上で避けきれない時は線の脇へずらし、ずらす向きはほかの線 (`lines`) に乗らない側にする (#3189)
|
|
410
|
+
*/
|
|
411
|
+
export function badgeOnPath(points: Point[], taken: Point[] = [], lines: Point[][] = []): Point {
|
|
412
|
+
const length = pathLength(points);
|
|
413
|
+
const first = length < LOOK.badge.short ? Math.min(LOOK.badge.r + 1, length / 2) : LOOK.badge.along;
|
|
414
|
+
const apart = LOOK.badge.r * 2 + LOOK.badge.inset;
|
|
415
|
+
for (let d = first; d <= length; d += 1) {
|
|
416
|
+
const p = along(points, d);
|
|
417
|
+
if (taken.every(([x, y]) => Math.hypot(p[0] - x, p[1] - y) >= apart)) return p;
|
|
418
|
+
}
|
|
419
|
+
return besideLine(points, first, taken, lines) ?? along(points, first);
|
|
420
|
+
}
|
|
421
|
+
|
|
422
|
+
/**
|
|
423
|
+
* 線の上で前の番号を避けきれない番号を、線の向きと直角に脇へずらした点 (#3189)。
|
|
424
|
+
* 前の番号の四角にも、ほかの線にも掛からない所のうち、線に一番近い所。番号 1 つ分ずらしても無ければ返さない。
|
|
425
|
+
* ほかの線は先に矢じりの幅だけ太らせて避け、それで空きが無い時だけ線そのものを避ける (矢じりに少し掛かっても、番号どうしを重ねるよりよい)
|
|
426
|
+
*/
|
|
427
|
+
function besideLine(points: Point[], at: number, taken: Point[], lines: Point[][]): Point | undefined {
|
|
246
428
|
const length = pathLength(points);
|
|
247
|
-
|
|
429
|
+
const [px, py] = along(points, at);
|
|
430
|
+
const [ax, ay] = along(points, Math.max(0, at - 1));
|
|
431
|
+
const [bx, by] = along(points, Math.min(length, at + 1));
|
|
432
|
+
const n = Math.hypot(bx - ax, by - ay);
|
|
433
|
+
if (n === 0) return undefined;
|
|
434
|
+
const [nx, ny] = [-(by - ay) / n, (bx - ax) / n];
|
|
435
|
+
const size = LOOK.badge.r * 2;
|
|
436
|
+
for (const margin of [LOOK.edge.arrowHalf, 0]) {
|
|
437
|
+
for (let s = 1; s <= size + LOOK.badge.inset; s++) {
|
|
438
|
+
for (const sign of [1, -1]) {
|
|
439
|
+
const c: Point = [px + nx * s * sign, py + ny * s * sign];
|
|
440
|
+
const free = taken.every(([x, y]) => Math.max(Math.abs(c[0] - x), Math.abs(c[1] - y)) >= size + 1);
|
|
441
|
+
if (free && lines.every((line) => !crossesRect(line, badgeRect(c), -margin))) return c;
|
|
442
|
+
}
|
|
443
|
+
}
|
|
444
|
+
}
|
|
445
|
+
return undefined;
|
|
446
|
+
}
|
|
447
|
+
|
|
448
|
+
/** 引いた線の形を表す鍵。同じ 2 つの箱を結んでも、時系列図の別の行のように形が違えば別の線 (#3184) */
|
|
449
|
+
export const lineKey = (edge: SceneEdge): string => edge.points.map(([x, y]) => `${Math.round(x * 10)},${Math.round(y * 10)}`).join(" ");
|
|
450
|
+
|
|
451
|
+
/**
|
|
452
|
+
* 線を持つ段の番号の点 (#3175)。段の最初の線の上に `at` で置き、別の線の番号に重なる時は線に沿ってずらす。
|
|
453
|
+
* 同じ線を前の段が通っていれば、前の段の番号と同じ所に置く。前の番号は後の段が始まると消え、数字が入れ替わる (#3184)。
|
|
454
|
+
* 番号は線だけで決まるので、線の名前を置く前に求め、名前が同じ時刻に見える番号を避けられるようにする。
|
|
455
|
+
* `at` には、形の違うほかの線 (段の前に点線で見えている線も含む) を渡し、脇へずらす番号がそれらに乗らないようにする (#3189)
|
|
456
|
+
*/
|
|
457
|
+
export function lineBadges(
|
|
458
|
+
edges: SceneEdge[],
|
|
459
|
+
steps: number,
|
|
460
|
+
at: (edge: SceneEdge, taken: Point[], lines: Point[][]) => Point = (edge, taken, lines) => badgeOnPath(edge.points, taken, lines),
|
|
461
|
+
): Map<number, { point: Point; edge: SceneEdge }> {
|
|
462
|
+
const out = new Map<number, { point: Point; edge: SceneEdge }>();
|
|
463
|
+
const taken: Point[] = [];
|
|
464
|
+
const placed = new Map<string, Point>();
|
|
465
|
+
for (let s = 0; s < steps; s++) {
|
|
466
|
+
const edge = edges.find((e) => e.step === s && e.points.length > 0);
|
|
467
|
+
if (!edge) continue;
|
|
468
|
+
const key = lineKey(edge);
|
|
469
|
+
const before = placed.get(key);
|
|
470
|
+
if (before) {
|
|
471
|
+
out.set(s, { point: before, edge });
|
|
472
|
+
continue;
|
|
473
|
+
}
|
|
474
|
+
const lines = edges.filter((e) => e.points.length > 1 && lineKey(e) !== key).map((e) => e.points);
|
|
475
|
+
const point = at(edge, taken, lines);
|
|
476
|
+
taken.push(point);
|
|
477
|
+
placed.set(key, point);
|
|
478
|
+
out.set(s, { point, edge });
|
|
479
|
+
}
|
|
480
|
+
return out;
|
|
481
|
+
}
|
|
482
|
+
|
|
483
|
+
/**
|
|
484
|
+
* 同じ所に置いた段の番号を入れ替える (#3184)。後の段の番号が前の段の番号と同じ所に来る時、前の段の番号に `until` を付けて、
|
|
485
|
+
* 後の段が始まると消す。同じ線を何度も通る段と、線の無い段が同じ箱か帯を続けて書き換える段がこれに当たる
|
|
486
|
+
*/
|
|
487
|
+
export function replaceSameSpot(badges: SceneBadge[]): SceneBadge[] {
|
|
488
|
+
const same = (a: SceneBadge, b: SceneBadge): boolean => Math.hypot(a.x - b.x, a.y - b.y) <= 0.5;
|
|
489
|
+
return badges.map((badge) => {
|
|
490
|
+
const next = badges.filter((other) => other.step > badge.step && same(other, badge)).sort((a, b) => a.step - b.step)[0];
|
|
491
|
+
return next ? { ...badge, until: next.step } : badge;
|
|
492
|
+
});
|
|
248
493
|
}
|
|
249
494
|
|
|
495
|
+
/** 段の番号の丸を囲む四角。線の名前が避ける相手にする (#3175) */
|
|
496
|
+
export const badgeRect = ([x, y]: Point): Rect => ({ x: x - LOOK.badge.r, y: y - LOOK.badge.r, w: LOOK.badge.r * 2, h: LOOK.badge.r * 2 });
|
|
497
|
+
|
|
498
|
+
/** 状態遷移図の始まりと終わりの印の右に添える字の左端と基準線。描く部品と、線の名前が字を避ける所の両方が読む (#3175) */
|
|
499
|
+
export const markText = (e: SceneEnd): Point => [e.x + LOOK.state.text, e.y + LOOK.baseline.mark];
|
|
500
|
+
|
|
250
501
|
export interface LabelRequest {
|
|
251
502
|
step: number;
|
|
252
503
|
event: number;
|
|
@@ -254,6 +505,14 @@ export interface LabelRequest {
|
|
|
254
505
|
points: Point[];
|
|
255
506
|
side?: LabelSide;
|
|
256
507
|
color: ColorKey;
|
|
508
|
+
/** 初めに試す札の左上。無ければ一番長い区間の真ん中から `side` の側へ離した所 (#3175) */
|
|
509
|
+
base?: { x: number; y: number };
|
|
510
|
+
/** 線に沿ってずらす長さの上限。無ければ上か下に置く札は札の幅、左か右に置く札は札の高さの 4 倍 (#3175) */
|
|
511
|
+
slide?: number;
|
|
512
|
+
/** 指示の側が埋まっている時、同じ離れで反対の側も探す (#3175) */
|
|
513
|
+
flip?: boolean;
|
|
514
|
+
/** 札を線の上か下に置く時の、線から札の真ん中までの離れ。無ければ `LOOK.label.offset` (#3177) */
|
|
515
|
+
offset?: number;
|
|
257
516
|
}
|
|
258
517
|
|
|
259
518
|
export interface Obstacles {
|
|
@@ -261,13 +520,20 @@ export interface Obstacles {
|
|
|
261
520
|
hard: Rect[];
|
|
262
521
|
/** 重ならなければよい物 (区画の名前、同じ段の線の名前) */
|
|
263
522
|
soft: Rect[];
|
|
523
|
+
/** 食い込まなければよい物 (同じ時刻に見えている段の番号の丸、#3175)。線のすぐ脇に置く名前を、線の上の丸のために遠ざけない */
|
|
524
|
+
touch?: Rect[];
|
|
525
|
+
/** 名前を横切らせない線 (#3175)。札を外して薄く残す名前は、地の色で線を隠せないため */
|
|
526
|
+
lines?: Point[][];
|
|
264
527
|
}
|
|
265
528
|
|
|
266
529
|
export const labelStyle = (text: string) => (hasWide(text) ? TYPE.labelJa : TYPE.label);
|
|
267
530
|
|
|
531
|
+
const OPPOSITE: Record<LabelSide, LabelSide> = { above: "below", below: "above", left: "right", right: "left" };
|
|
532
|
+
|
|
268
533
|
/**
|
|
269
534
|
* 線の名前を置く。線の一番長い区間の中ほどから、寄せの指示の側 (無ければ横の線は上、縦の線は右) へ
|
|
270
535
|
* 離して置く。箱や区画の名前に掛かる時は、指示の側へさらに離し、線に沿ってもずらして空きを探す。
|
|
536
|
+
* `flip` を立てると、同じ離れで反対の側も探す (#3175)。片側だけを遠くまで探すと、図の端の外へ出るため
|
|
271
537
|
*/
|
|
272
538
|
export function placeLabel(request: LabelRequest, obstacles: Obstacles): SceneLabel {
|
|
273
539
|
const w = textWidth(request.text, labelStyle(request.text)) + LOOK.label.padX * 2;
|
|
@@ -275,9 +541,10 @@ export function placeLabel(request: LabelRequest, obstacles: Obstacles): SceneLa
|
|
|
275
541
|
const segment = longest(request.points);
|
|
276
542
|
const mx = (segment.a[0] + segment.b[0]) / 2;
|
|
277
543
|
const my = (segment.a[1] + segment.b[1]) / 2;
|
|
278
|
-
const
|
|
279
|
-
const {
|
|
280
|
-
const
|
|
544
|
+
const preferred = request.side ?? (segment.vertical ? "right" : "above");
|
|
545
|
+
const { side: sideGap } = LOOK.label;
|
|
546
|
+
const offset = request.offset ?? LOOK.label.offset;
|
|
547
|
+
const baseOf = (side: LabelSide): Rect =>
|
|
281
548
|
side === "above"
|
|
282
549
|
? { x: mx - w / 2, y: my - offset - h / 2, w, h }
|
|
283
550
|
: side === "below"
|
|
@@ -285,22 +552,30 @@ export function placeLabel(request: LabelRequest, obstacles: Obstacles): SceneLa
|
|
|
285
552
|
: side === "left"
|
|
286
553
|
? { x: mx - sideGap - w, y: my - h / 2, w, h }
|
|
287
554
|
: { x: mx + sideGap, y: my - h / 2, w, h };
|
|
288
|
-
|
|
289
|
-
const
|
|
290
|
-
const slideAxis: Point = [Math.abs(away[1]), Math.abs(away[0])];
|
|
291
|
-
const slideMax = side === "above" || side === "below" ? w : h * 4;
|
|
555
|
+
const first: Rect = request.base ? { ...request.base, w, h } : baseOf(preferred);
|
|
556
|
+
const sides = request.flip ? [preferred, OPPOSITE[preferred]] : [preferred];
|
|
292
557
|
const clear = (rect: Rect): boolean =>
|
|
293
|
-
obstacles.hard.every((box) => gapBetween(rect, box) >= LOOK.gap) &&
|
|
558
|
+
obstacles.hard.every((box) => gapBetween(rect, box) >= LOOK.gap) &&
|
|
559
|
+
obstacles.soft.every((other) => gapBetween(rect, other) >= LOOK.label.soft) &&
|
|
560
|
+
(obstacles.touch ?? []).every((mark) => gapBetween(rect, mark) >= LOOK.label.touch) &&
|
|
561
|
+
(obstacles.lines ?? []).every((line) => !crossesRect(line, rect, -LOOK.label.touch));
|
|
294
562
|
const { search, searchMax } = LOOK.label;
|
|
295
563
|
for (let d = 0; d <= searchMax; d += search) {
|
|
296
|
-
for (
|
|
297
|
-
|
|
298
|
-
|
|
299
|
-
|
|
564
|
+
for (const side of sides) {
|
|
565
|
+
const base = side === preferred ? first : baseOf(side);
|
|
566
|
+
// 離す向き (その側) と、ずらす向き (それに直交する向き)
|
|
567
|
+
const away: Point = side === "above" ? [0, -1] : side === "below" ? [0, 1] : side === "left" ? [-1, 0] : [1, 0];
|
|
568
|
+
const slideAxis: Point = [Math.abs(away[1]), Math.abs(away[0])];
|
|
569
|
+
const slideMax = request.slide ?? (side === "above" || side === "below" ? w : h * 4);
|
|
570
|
+
for (let s = 0; s <= slideMax; s += search) {
|
|
571
|
+
for (const sign of s === 0 ? [1] : [1, -1]) {
|
|
572
|
+
const rect = { x: base.x + away[0] * d + slideAxis[0] * s * sign, y: base.y + away[1] * d + slideAxis[1] * s * sign, w, h };
|
|
573
|
+
if (clear(rect)) return { ...rect, step: request.step, event: request.event, text: request.text, family: labelStyle(request.text).family, color: request.color };
|
|
574
|
+
}
|
|
300
575
|
}
|
|
301
576
|
}
|
|
302
577
|
}
|
|
303
|
-
return { ...
|
|
578
|
+
return { ...first, step: request.step, event: request.event, text: request.text, family: labelStyle(request.text).family, color: request.color };
|
|
304
579
|
}
|
|
305
580
|
|
|
306
581
|
/** 中身の帯の欄の幅。欄の名前と、入る値と札を並べた最も長い形が収まる幅。 */
|
|
@@ -367,6 +642,8 @@ export function shiftContent(layout: Layout, dx: number, dy: number): void {
|
|
|
367
642
|
move(box);
|
|
368
643
|
box.cx += dx;
|
|
369
644
|
box.cy += dy;
|
|
645
|
+
if (box.slot) move(box.slot);
|
|
646
|
+
if (box.iconX !== undefined) box.iconX += dx;
|
|
370
647
|
}
|
|
371
648
|
for (const region of layout.regions) {
|
|
372
649
|
region.y += dy;
|
|
@@ -380,6 +657,7 @@ export function shiftContent(layout: Layout, dx: number, dy: number): void {
|
|
|
380
657
|
for (const edge of layout.edges) {
|
|
381
658
|
edge.points = edge.points.map(([px, py]) => [px + dx, py + dy]);
|
|
382
659
|
if (edge.settle) edge.settle = [edge.settle[0] + dx, edge.settle[1] + dy];
|
|
660
|
+
if (edge.wait) edge.wait = [edge.wait[0] + dx, edge.wait[1] + dy];
|
|
383
661
|
}
|
|
384
662
|
for (const label of layout.labels) move(label);
|
|
385
663
|
for (const path of layout.paths) {
|
|
@@ -409,15 +687,18 @@ export function shiftContent(layout: Layout, dx: number, dy: number): void {
|
|
|
409
687
|
}
|
|
410
688
|
}
|
|
411
689
|
|
|
412
|
-
/**
|
|
690
|
+
/**
|
|
691
|
+
* 線も処理も無い段の番号。書き換わる箱か最初の箱では、番号の中心を箱の左上の角に置き、半分を箱の外へ出す (#3187)。
|
|
692
|
+
* 箱の左上には絵柄が在り、箱の内側に置くと番号が絵柄の角に掛かるため。中身の帯だけを書き換える段は、帯の左上の角から内側に置く。
|
|
693
|
+
*/
|
|
413
694
|
export function cornerBadge(events: DiagramEvent[], step: number, layout: Layout): SceneBadge {
|
|
414
695
|
const { inset } = LOOK.badge;
|
|
415
696
|
for (const event of events) {
|
|
416
697
|
const id = event.type === "swap" || event.type === "action" ? event.box : undefined;
|
|
417
698
|
const box = layout.boxes.find((b) => b.id === id);
|
|
418
|
-
if (box) return { step, x: box.x
|
|
699
|
+
if (box) return { step, x: box.x, y: box.y, color: box.color };
|
|
419
700
|
}
|
|
420
701
|
if (layout.strip && events.some((event) => event.type === "strip")) return { step, x: layout.strip.x + inset, y: layout.strip.y + inset, color: "slate" };
|
|
421
702
|
const box = layout.boxes[0] as SceneBox;
|
|
422
|
-
return { step, x: box.x
|
|
703
|
+
return { step, x: box.x, y: box.y, color: box.color };
|
|
423
704
|
}
|
package/src/layout/sequence.ts
CHANGED
|
@@ -8,13 +8,16 @@ import { LOOK, TYPE } from "../look/values";
|
|
|
8
8
|
import type { Diagram } from "../schema";
|
|
9
9
|
import { textWidth } from "./measure";
|
|
10
10
|
import {
|
|
11
|
-
|
|
11
|
+
carrierHalf,
|
|
12
|
+
badgeRect,
|
|
12
13
|
boxColors,
|
|
13
14
|
cornerBadge,
|
|
14
15
|
boxWidth,
|
|
15
16
|
edgeColor,
|
|
16
17
|
labelStyle,
|
|
17
18
|
type Layout,
|
|
19
|
+
lineBadges,
|
|
20
|
+
replaceSameSpot,
|
|
18
21
|
layoutStrip,
|
|
19
22
|
type Point,
|
|
20
23
|
placeLabel,
|
|
@@ -99,8 +102,8 @@ export function layoutSequence(diagram: Diagram): Layout {
|
|
|
99
102
|
const side = event.labelSide ?? "above";
|
|
100
103
|
const self = event.from === event.to;
|
|
101
104
|
const named = event.label !== undefined;
|
|
102
|
-
above = named && side === "above" ?
|
|
103
|
-
under = self ? Q.selfH + gap : named && side === "below" ?
|
|
105
|
+
above = named && side === "above" ? Q.labelOffset + L.h / 2 : gap;
|
|
106
|
+
under = self ? Q.selfH + gap : named && side === "below" ? Q.labelOffset + L.h / 2 : gap;
|
|
104
107
|
} else {
|
|
105
108
|
above = LOOK.action.h / 2;
|
|
106
109
|
under = LOOK.action.h / 2;
|
|
@@ -126,7 +129,18 @@ export function layoutSequence(diagram: Diagram): Layout {
|
|
|
126
129
|
[xt - dir * LOOK.edge.inset, y],
|
|
127
130
|
];
|
|
128
131
|
const color = edgeColor(event, colors);
|
|
129
|
-
|
|
132
|
+
// 運ぶ物は着いた生存線の向こう側に留まって矢印の先を隠さず、出る生存線の手前側で走り出しを待って段の番号を隠さない (#3176)
|
|
133
|
+
const seats: Pick<SceneEdge, "settle" | "wait"> = {};
|
|
134
|
+
if (event.carry.kind !== "none") {
|
|
135
|
+
const reach = LOOK.slot.lifeline + carrierHalf(event.carry)[0];
|
|
136
|
+
const [p0, p1] = points as [Point, Point];
|
|
137
|
+
const [q0, q1] = points.slice(-2) as [Point, Point];
|
|
138
|
+
const out = Math.sign(p1[0] - p0[0]) || 1;
|
|
139
|
+
const into = Math.sign(q1[0] - q0[0]) || -1;
|
|
140
|
+
seats.wait = [xf - out * reach, p0[1]];
|
|
141
|
+
seats.settle = [xt + into * reach, q1[1]];
|
|
142
|
+
}
|
|
143
|
+
edges.push({ step: s, event: e, from: event.from, to: event.to, points, color, carry: event.carry, ...seats });
|
|
130
144
|
if (event.label !== undefined) {
|
|
131
145
|
requests.push({
|
|
132
146
|
step: s,
|
|
@@ -135,6 +149,7 @@ export function layoutSequence(diagram: Diagram): Layout {
|
|
|
135
149
|
points,
|
|
136
150
|
color,
|
|
137
151
|
...(event.labelSide ? { side: event.labelSide } : xf === xt ? { side: "right" as const } : {}),
|
|
152
|
+
offset: Q.labelOffset,
|
|
138
153
|
});
|
|
139
154
|
}
|
|
140
155
|
} else {
|
|
@@ -148,10 +163,13 @@ export function layoutSequence(diagram: Diagram): Layout {
|
|
|
148
163
|
const bottom = (first ? headBottom : y + below) + Q.tail;
|
|
149
164
|
const lifelines = order.map((id, i) => ({ id, x: xs[i] as number, y1: headBottom, y2: bottom }));
|
|
150
165
|
|
|
166
|
+
// 線の名前は、同じ時刻に見えている段の番号 (その段とそれより前の段の番号) も避ける (#3175)
|
|
167
|
+
const early = lineBadges(edges, diagram.steps.length);
|
|
151
168
|
const labels: SceneLabel[] = [];
|
|
152
169
|
for (const request of requests) {
|
|
170
|
+
const seen = [...early].filter(([s]) => s <= request.step).map(([, b]) => badgeRect(b.point));
|
|
153
171
|
const soft = [...labels.filter((l) => l.step === request.step), ...actions];
|
|
154
|
-
labels.push(placeLabel(request, { hard: boxes, soft }));
|
|
172
|
+
labels.push(placeLabel(request, { hard: boxes, soft, touch: seen }));
|
|
155
173
|
}
|
|
156
174
|
|
|
157
175
|
const layout: Layout = { kind: "sequence", width: 0, height: 0, regions: [], boxes, lifelines, edges, labels, actions, badges: [], paths: [], ends: [] };
|
|
@@ -175,15 +193,15 @@ export function layoutSequence(diagram: Diagram): Layout {
|
|
|
175
193
|
* 処理の札はその段の終わりに消えるので、札に付けると止め絵で丸だけが浮く (#3017)。
|
|
176
194
|
*/
|
|
177
195
|
function badges(diagram: Diagram, layout: Layout): SceneBadge[] {
|
|
178
|
-
|
|
179
|
-
|
|
180
|
-
|
|
181
|
-
|
|
182
|
-
return { step: s, x, y, color: edge.color };
|
|
183
|
-
}
|
|
196
|
+
const lines = lineBadges(layout.edges, diagram.steps.length);
|
|
197
|
+
const placed = diagram.steps.map((step, s): SceneBadge => {
|
|
198
|
+
const line = lines.get(s);
|
|
199
|
+
if (line) return { step: s, x: line.point[0], y: line.point[1], color: line.edge.color };
|
|
184
200
|
const action = layout.actions.find((a) => a.step === s);
|
|
185
201
|
const lifeline = action && layout.lifelines.find((l) => l.id === action.box);
|
|
186
202
|
if (action && lifeline) return { step: s, x: lifeline.x, y: action.y + action.h / 2, color: action.color };
|
|
187
203
|
return cornerBadge(step.events, s, layout);
|
|
188
204
|
});
|
|
205
|
+
// 同じ所に置いた番号は、後の段が始まると入れ替える (#3184)
|
|
206
|
+
return replaceSameSpot(placed);
|
|
189
207
|
}
|