@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.
Files changed (48) hide show
  1. package/README.md +38 -1
  2. package/dist/cli.cjs +2403 -550
  3. package/dist/cli.cjs.map +1 -1
  4. package/dist/cli.js +2408 -555
  5. package/dist/cli.js.map +1 -1
  6. package/dist/export.cjs +2252 -537
  7. package/dist/export.cjs.map +1 -1
  8. package/dist/export.d.cts +3 -1
  9. package/dist/export.d.ts +3 -1
  10. package/dist/export.js +2257 -542
  11. package/dist/export.js.map +1 -1
  12. package/dist/index.cjs +2387 -495
  13. package/dist/index.cjs.map +1 -1
  14. package/dist/index.d.cts +11 -154
  15. package/dist/index.d.ts +11 -154
  16. package/dist/index.js +2387 -496
  17. package/dist/index.js.map +1 -1
  18. package/dist/ink-B_7OXxtb.d.cts +360 -0
  19. package/dist/ink-B_7OXxtb.d.ts +360 -0
  20. package/dist/player.global.js +2 -2
  21. package/package.json +1 -1
  22. package/src/cli.ts +9 -0
  23. package/src/export/index.ts +4 -1
  24. package/src/field-messages.ts +8 -0
  25. package/src/figure-text.ts +28 -0
  26. package/src/index.ts +3 -0
  27. package/src/layout/architecture.ts +123 -44
  28. package/src/layout/git.ts +728 -0
  29. package/src/layout/measure.ts +10 -0
  30. package/src/layout/scene.ts +300 -19
  31. package/src/layout/sequence.ts +29 -11
  32. package/src/layout/state.ts +82 -62
  33. package/src/look/values.ts +57 -4
  34. package/src/messages.ts +47 -4
  35. package/src/parser.ts +142 -7
  36. package/src/player.ts +44 -0
  37. package/src/printer.ts +16 -4
  38. package/src/render/git.ts +161 -0
  39. package/src/render/ink.ts +104 -0
  40. package/src/render/parts.ts +103 -36
  41. package/src/render/svg.ts +63 -15
  42. package/src/schema.ts +47 -13
  43. package/src/schemas/diagram.schema.json +75 -8
  44. package/src/schemas/validate-diagram.js +1 -1
  45. package/src/timeline.ts +18 -3
  46. package/src/words.ts +19 -3
  47. package/dist/schema-B2MTRv66.d.cts +0 -133
  48. package/dist/schema-B2MTRv66.d.ts +0 -133
@@ -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
+ }
@@ -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
- export function badgeOnPath(points: Point[]): Point {
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
- return along(points, length < LOOK.badge.short ? length / 2 : LOOK.badge.along);
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 side = request.side ?? (segment.vertical ? "right" : "above");
279
- const { offset, side: sideGap } = LOOK.label;
280
- const base: Rect =
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 away: Point = side === "above" ? [0, -1] : side === "below" ? [0, 1] : side === "left" ? [-1, 0] : [1, 0];
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) && obstacles.soft.every((other) => gapBetween(rect, other) >= LOOK.label.soft);
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 (let s = 0; s <= slideMax; s += search) {
297
- for (const sign of s === 0 ? [1] : [1, -1]) {
298
- const rect = { x: base.x + away[0] * d + slideAxis[0] * s * sign, y: base.y + away[1] * d + slideAxis[1] * s * sign, w, h };
299
- if (clear(rect)) return { ...rect, step: request.step, event: request.event, text: request.text, family: labelStyle(request.text).family, color: request.color };
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 { ...base, step: request.step, event: request.event, text: request.text, family: labelStyle(request.text).family, color: request.color };
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 + inset, y: box.y + inset, color: box.color };
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 + inset, y: box.y + inset, color: box.color };
703
+ return { step, x: box.x, y: box.y, color: box.color };
423
704
  }
@@ -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
- badgeOnPath,
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" ? L.offset + L.h / 2 : gap;
103
- under = self ? Q.selfH + gap : named && side === "below" ? L.offset + L.h / 2 : gap;
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
- edges.push({ step: s, event: e, from: event.from, to: event.to, points, color, carry: event.carry });
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
- return diagram.steps.map((step, s) => {
179
- const edge = layout.edges.find((e) => e.step === s);
180
- if (edge) {
181
- const [x, y] = badgeOnPath(edge.points);
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
  }