@cardenelabs/dragon 0.30.0 → 0.32.0

package/src/compile/journey.ts

@@ -1,14 +1,14 @@
 import { diagram } from "@cardenelabs/cdl";
 import type { CdlDiagram } from "@cardenelabs/cdl";
 import type { DslActor, DslDocument } from "../types";
-import { 図表の大きさ, 語の欄から参照できる名前 } from "./chart-fields";
+import { 図表の大きさ, 図表の大きさを読む, 語の欄から参照できる名前 } from "./chart-fields";
 import { 箱の題 } from "./node-title";
 import type { CompileNotice } from "./notice";
 import { slugify } from "./slug";
 import { 図の小見出し } from "./subtitle";
 import { 気持ち } from "./word-state";
 /**
- * 体験の道筋 (`type: journey`) の組み立て (#1154)。 描画側に 1 つの箱で渡す。
+ * ユーザージャーニー (`type: journey`) の組み立て (#1154)。 描画側に 1 つの箱で渡す。
  *
  * 登場人物ごとに **気持ち** を読む (`- 登録: "不満"`)。 使える語は `気持ち` が持つ。
  */
@@ -17,7 +17,7 @@ export function compileJourney(
   onNotice?: (n: CompileNotice) => void,
 ): CdlDiagram {
   const b = diagram(slugify(doc.title), { topic: doc.title, type: "journey" });
-  const { w: W, h: H } = 図表の大きさ.journey;
+  const { w: W, h: H } = 図表の大きさを読む(doc, 図表の大きさ.journey);
   b.lane("chart", { width: W + 64 });
   const data: NonNullable<CdlDiagram["nodes"][number]["journeyData"]> = [];
   const 読めない: string[] = [];
@@ -66,19 +66,28 @@ export function compileJourney(
     w: W,
     h: H,
     journeyData: data,
+    ...(doc.journeyForm !== undefined ? { journeyForm: doc.journeyForm } : {}),
+    ...(doc.journeyLineForm !== undefined ? { journeyLineForm: doc.journeyLineForm } : {}),
+    ...(doc.journeyLabels !== undefined ? { journeyLabels: doc.journeyLabels } : {}),
+    ...(doc.journeySize !== undefined ? { journeySize: doc.journeySize } : {}),
   });
   return b.build();
 }
 
 /**
- * 体験の道筋の段に添える欄 (#1251)。
+ * ユーザージャーニーの段に添える欄 (#1251)。
  *
  * 書かなければ項目ごと落とす = `undefined` を明示して渡すと、 組立て側が「空を書いた」 と
  * 区別できなくなる (`図の小見出し` と同じ理由)。
  */
-function 道筋の欄(a: DslActor): { touchpoint?: string; opportunity?: string } {
+function 道筋の欄(a: DslActor): {
+  touchpoint?: string;
+  opportunity?: string;
+  opportunityPosition?: DslActor["opportunityPosition"];
+} {
   return {
     ...(a.touchpoint !== undefined ? { touchpoint: a.touchpoint } : {}),
     ...(a.opportunity !== undefined ? { opportunity: a.opportunity } : {}),
+    ...(a.opportunityPosition !== undefined ? { opportunityPosition: a.opportunityPosition } : {}),
   };
 }

package/src/compile/kinds.ts

@@ -32,6 +32,7 @@ import type { PresetType } from "../types";
  * | `contract` / `proxy` / `library` / `interface` | `card` | 契約は札で表す (`solidity` の置き換え先に合わせた) |
  * | `eoa` | `person` | 人が持つ財布 |
  * | `multisig` | `signer` | 複数人で署名する (`solidity` の置き換え先に合わせた) |
+ * | `loop` | `card` | 繰り返しは札で表す。 分かれ道の図では形に読み替わるのでここを通らない (#2523) |
  *
  * **表は `DSL_ONLY_KINDS` を鍵にして書く**。 種類を足した時に読み替え先が無いと
  * 型検査が落ちるので、足し忘れが残らない。
@@ -46,6 +47,7 @@ export const 記法だけの種類の読み替え: Readonly<Record<(typeof DSL_O
     interface: "card",
     eoa: "person",
     multisig: "signer",
+    loop: "card",
   };
 
 /** 描画側へ渡せる種類にする。 記法だけの種類はここで読み替わる (#1420) */
@@ -82,24 +84,14 @@ export const 図種の作り: Record<PresetType, "登場人物ごとに箱" | "
   // 矢印の端と登場人物の名前が、 そのまま箱や枠の id になる
   sequence: "登場人物ごとに箱",
   flow: "登場人物ごとに箱",
+  flowchart: "登場人物ごとに箱",
   swimlane: "登場人物ごとに箱",
-  er: "登場人物ごとに箱",
-  state: "登場人物ごとに箱",
+  record: "登場人物ごとに箱",
   topology: "登場人物ごとに箱",
-  solidity: "登場人物ごとに箱",
-  class: "登場人物ごとに箱",
   c4: "登場人物ごとに箱",
   // 中身は payload が持ち、 図そのものは 1 箱。 矢印は描かず本数を数えて知らせる
   gantt: "図全体を 1 箱",
-  pie: "図全体を 1 箱",
-  bar: "図全体を 1 箱",
-  line: "図全体を 1 箱",
-  gauge: "図全体を 1 箱",
-  radial: "図全体を 1 箱",
-  stat: "図全体を 1 箱",
-  waffle: "図全体を 1 箱",
-  stacked: "図全体を 1 箱",
-  slope: "図全体を 1 箱",
+  chart: "図全体を 1 箱",
   funnel: "図全体を 1 箱",
   tree: "図全体を 1 箱",
   journey: "図全体を 1 箱",

package/src/compile/lanes.ts

@@ -17,27 +17,30 @@ import type { DslDocument, PresetType } from "../types";
  * `er` は「1 縦列 1 箱」 が図の読み方そのもの (表が横に並ぶ) なので、2 つの箱を同じ縦列へ
  * 入れられる形にはしない。
  *
- * **クラス図と状態遷移図は外した** (#1466)。 設計が格子に置く形になり (クラス 3 列 3 段 /
- * 状態 2 列 5 段)、「箱の 1 つの辺には関係を 1 本まで」 を守るには 1 つの縦列に複数の箱が要る。
+ * 状態遷移図は外した (#1466)。設計が格子に置く形になり、
+ * 「箱の 1 つの辺には関係を 1 本まで」 を守るには 1 つの縦列に複数の箱が要る。
  * 「1 縦列 1 箱」 が読み方だった前提はここで崩れている。
  */
 export const 縦列を選べる図種: ReadonlySet<PresetType> = new Set<PresetType>([
   "flow",
   "topology",
   "swimlane",
-  "class",
-  "state",
   /*
-   * ER 図 (#1571)。
+   * 分かれ道の図 (#2513)。
    *
-   * `er` の組み立て器は実体 1 つにつき帯を 1 本作り、必ず段 0 に置く = 表が横 1 列にしか
-   * 並ばない。 関係を 4 本持つ実体があると、どう並べ替えても 2 本は隣を飛び越す
-   * (意匠帳 `docs/design/er/note.md` § 記法の制約 が 4 通りを実測しており、1 列は縦横比 7.0 /
-   * 最長の線 4068、格子は 3.5 / 836)。
+   * この図種は **縦列が役割で、箱はその中に置く**。 1 人の役割の中に複数の箱が並ぶ形
+   * (申請を出す / 直して出し直す) が図の読み方そのものなので、書いた縦列をそのまま使う。
+   */
+  "flowchart",
+  /*
+   * 行を持つ図 (#1571 / #2782)。
    *
-   * **全ての箱が縦列を書いた時だけ** 効くので、書かない図はいままでどおり組み立て器が並べる。
+   * 畳む前の表の図は、組み立て器が実体 1 つにつき帯を 1 本作り必ず段 0 に置いていた =
+   * 表が横 1 列にしか並ばない。 関係を 4 本持つ実体があると、どう並べ替えても 2 本は隣を
+   * 飛び越す (意匠帳 `docs/design/er/note.md` § 記法の制約 が 4 通りを実測しており、
+   * 1 列は縦横比 7.0 / 最長の線 4068、格子は 3.5 / 836)。
    */
-  "er",
+  "record",
 ]);
 
 /**
@@ -47,10 +50,89 @@ export const 縦列を選べる図種: ReadonlySet<PresetType> = new Set<PresetT
  * 行き先を決める規則が要る (既定の縦列に集める / 自分の縦列を作る) が、どちらも
  * 書いた人の意図と一致する保証が無い。 混ざった形は `reportLaneMixed` が知らせる。
  *
- * 見本 (parts) は縦列を張替え先として使うため、この判定からは外す。
+ * 数える箱は `縦列の判定に数える箱` が決める (#2372)。
  */
 export function 書いた縦列に置く(kind: PresetType, doc: DslDocument): boolean {
   if (!縦列を選べる図種.has(kind)) return false;
-  const 対象 = doc.actors.filter((a) => a.partId === undefined);
+  const 対象 = 縦列の判定に数える箱(doc);
   return 対象.length > 0 && 対象.every((a) => a.lane !== undefined);
 }
+
+/**
+ * 縦列の判定で数える箱 (#2372)。
+ *
+ * **見本 (`parts`) は縦列を書いた時だけ数える**。 見本の縦列は張替え先の指定で、
+ * 箱を並べる話ではない = 書いていない見本を数に入れると、普通の箱が全部書いた図まで
+ * 「一部だけ書いた」 に倒れる。
+ *
+ * 逆に見本を **常に** 外すと、箱が全部見本の図で対象が 0 件になり
+ * 「全ての箱が縦列を書いた」 が成立しない。 結果は 3 つ重なる =
+ * 書いた縦列に箱が入らない / 宣言した縦列が空のまま残る / 誤って「どの箱も入らない」 と知らせる
+ * (実測 = カタログの見本 19 枚で知らせが 38 件)。
+ *
+ * 見本が混ざった図では普通の箱が対象になって成立し、**見本も一緒に書いた縦列へ入っていた**
+ * = 見本を縦列へ入れられないわけではなく、数え方だけが割れていた。
+ *
+ * **置く側と知らせる側で同じ数え方を使う**。 別々に数えると、見本だけの図で
+ * 「一部だけ書いた」 形が知らせずに落ちる。
+ */
+export function 縦列の判定に数える箱(doc: DslDocument): DslDocument["actors"] {
+  const 見本が縦列を書いた = doc.actors.some((a) => a.partId !== undefined && a.lane !== undefined);
+  return 見本が縦列を書いた ? doc.actors : doc.actors.filter((a) => a.partId === undefined);
+}
+
+/**
+ * 縦列ごとに箱の段を決める (#1394 / #2396)。
+ *
+ * 段は **書いた番号をそのまま持つ**。 書き順で 0 から詰め直すと、`stack: 1` と書いた箱が
+ * 0 へ落ちる = 決定木のように「同じ高さに並ばない」 ことが図の意味そのものになる形では、
+ * 詰めた瞬間に別の図になる (実測 = 3 段の木の根が 1 段目へ上がった)。
+ *
+ * 書かなかった箱は、その縦列で **空いている一番小さい段** に置く。 単に数え上げると
+ * 書いた番号と重なり、2 つの箱が同じ段に載る。
+ *
+ * **箱を並べる図種すべてが同じ決め方を使う** (#2396)。かつてのクラス図だけこの決め方を持たず、
+ * 段を書かない箱を全て 0 に残していた。 同じ縦列に箱を 2 つ置くと配置の計算が
+ * 「同じ場所に 2 つある」 として投げ、図が 1 枚も描けない (実測 = 24 図種で落ちるのは
+ * class 専用経路だけ)。
+ *
+ * @param actors 記法から読んだ箱を書いた順に並べたもの
+ * @param 縦列を引く 箱を同じ段の集合へ分ける鍵。 省略時は `lane` を使う
+ * @returns 段を持つ箱だけの表。 縦列も段も書かない箱は入らない (呼出側が既定に任せる)
+ */
+export function 縦列ごとの段を決める(
+  actors: DslDocument["actors"],
+  縦列を引く: (actor: DslDocument["actors"][number]) => string | undefined = (actor) =>
+    actor.lane,
+): ReadonlyMap<DslDocument["actors"][number], number> {
+  const 埋まった段 = new Map<string, Set<number>>();
+  const 埋める = (lid: string, stack: number): void => {
+    const 集合 = 埋まった段.get(lid) ?? new Set<number>();
+    集合.add(stack);
+    埋まった段.set(lid, 集合);
+  };
+  // 書いた番号を先に全て埋める = 書き順が後の箱の番号とも重ならない
+  for (const a of actors) {
+    const 縦列 = 縦列を引く(a);
+    if (縦列 !== undefined && a.stack !== undefined) 埋める(縦列, a.stack);
+  }
+  const 決めた = new Map<DslDocument["actors"][number], number>();
+  for (const a of actors) {
+    const 縦列 = 縦列を引く(a);
+    if (縦列 === undefined) {
+      // 縦列を書かない箱は縦列の中の段を持たない。 段だけ書いた箱はその番号を渡す
+      if (a.stack !== undefined) 決めた.set(a, a.stack);
+      continue;
+    }
+    if (a.stack !== undefined) {
+      決めた.set(a, a.stack);
+      continue;
+    }
+    let stack = 0;
+    const 集合 = 埋まった段.get(縦列);
+    while (集合?.has(stack)) stack += 1;
+    埋める(縦列, stack);
+    決めた.set(a, stack);
+  }
+  return 決めた;
+}

package/src/compile/metro.ts

@@ -0,0 +1,271 @@
+import type { DslActor, DslDocument } from "../types";
+import { 箱の題 } from "./node-title";
+import { slugify } from "./slug";
+
+/**
+ * 路線図の形 (`shape: metro`, #2799) の配置規則。
+ *
+ * 担当 (`lane`) ごとに横の帯を 1 本作り、箱を駅として書いた順に左から並べる。
+ * 担当を書かない箱は箱の名前を線路にする。省略したことは `compile.ts` の
+ * `reportTrackFromName` が知らせる。
+ */
+
+/**
+ * 帯 1 本の高さ。見本の担当の線路の中心 (240 / 460 / 680) の差 220 に合わせる。
+ */
+const TRACK_HEIGHT = 220;
+
+/**
+ * 最初の駅の中心。
+ * 見本の名札の左端 46 を描く側 0.125.0 の inset 24 に合わせると、lane の左端は 22 になる。
+ * 見本の始まりの中心 290 から lane の左端 22 を引いた 268 に合わせる。
+ * 名札 (24..224) と案内線の始まり (248) より右へ置く。
+ */
+const FIRST_STATION_X = 268;
+
+/** 同じ線路の図形どうしに空ける 40。見本の駅と線を詰めすぎない値。 */
+const NODE_SHAPE_GAP = 40;
+
+/** 見本で始まりの中心 290 から最初の駅 380 まで離した 90。 */
+const START_MARK_CENTER_GAP = 90;
+
+/** 見本で「届けに行く」の中心 1410 から分かれ道「在宅?」の中心 1520 まで離した 110。 */
+const STATION_DECISION_CENTER_GAP = 110;
+
+/** 見本で最後の駅の中心 1690 から終わり 1752 まで離した 62。 */
+const END_MARK_CENTER_GAP = 62;
+
+/**
+ * 担当が替わる 2 駅の間に足す 140。見本の中心間 360 から線路間 220 を引いた値。
+ * 傾き ±1 の斜線の前後に横線と円弧を置く余裕になる。
+ */
+const TRANSFER_MARGIN = 140;
+
+/**
+ * 同じ担当で隣り合う駅名どうしの最小の隙間と、名前の幅の見積りに使う字の大きさ。
+ * 25 は描く側 0.125.0 が駅名に使う字の大きさ。
+ * 描く側が字の大きさを変えたら、ここも合わせる。
+ */
+const TITLE_GAP = 27;
+/** 駅名を下へ回した組だけは、見本の中心間 130 まで詰められる。 */
+const BOTTOM_TITLE_GAP = 14.5;
+const STATION_TITLE_FONT_SIZE = 25;
+/** 太字の駅名が字面の外へ張り出す分を 3 と見積もる。 */
+const STATION_TITLE_BOLD_OVERHANG = 3;
+
+/** 見本の分かれ道の枝を、半幅 58 + 直線 30 + 半径 22 の曲がり 2 つ + 余白 22 で作る。 */
+const DECISION_HALF_WIDTH = 58;
+const BRANCH_STUB = 30;
+const BRANCH_CORNER_RADIUS = 22;
+const BRANCH_END_MARGIN = 22;
+
+/** 見本で分かれ道の中心 y=680 から真下の駅 y=910 まで離した 230。 */
+const DECISION_DOWN_GAP = 230;
+
+/**
+ * 線路の右側に残す 26。
+ * 見本の案内線は、終わりの中心 1752 より 2 先の x2=1754 で終わる。
+ * 描く側 0.125.0 は `METRO_LANE_BADGE_INSET` の 24 を使い、案内線を lane の右端から 24 手前で止める。
+ * 2 と 24 の和を使う。
+ */
+const TRACK_END_PADDING = 26;
+
+type MetroNodeKind = "station" | "decision" | "mark-start" | "mark-end";
+
+/** 描く側 0.125.0 の路線図の図形の半幅。 */
+function nodeHalfWidth(kind: MetroNodeKind): number {
+  if (kind === "decision") return DECISION_HALF_WIDTH;
+  if (kind === "mark-start") return 17;
+  if (kind === "mark-end") return 19;
+  return 16;
+}
+
+/** 始まりと終わりの枠を、描く側が見せる丸の直径に合わせる。 */
+export function metroMarkFrameSize(kind: DslActor["kind"]): number | undefined {
+  if (kind !== "mark-start" && kind !== "mark-end") return undefined;
+  return nodeHalfWidth(kind) * 2;
+}
+
+/** 路線図では3種の印だけをその形で描き、それ以外の箱は駅として描く。 */
+function metroNodeKind(actor: DslActor): MetroNodeKind {
+  if (actor.kind === "decision" || actor.kind === "mark-start" || actor.kind === "mark-end") {
+    return actor.kind;
+  }
+  return "station";
+}
+
+export type MetroTrack = {
+  id: string;
+  label: string;
+  subtitle?: string;
+  posX: number;
+  posY: number;
+  posW: number;
+  posH: number;
+};
+
+export type MetroStation = {
+  actorName: string;
+  trackId: string;
+  posX: number;
+  posY: number;
+};
+
+export type MetroPlacement = {
+  width: number;
+  tracks: MetroTrack[];
+  stations: MetroStation[];
+};
+
+/** 担当を書かない箱を独立した線路にするため、その箱の名前を線路の鍵として返す。 */
+function 線路の鍵(actor: DslActor): string {
+  return actor.lane ?? actor.name;
+}
+
+/** 駅名が重ならない間隔を取るため、描く側と同じ字の大きさで名前の幅を概算する。 */
+function estimateStationTitleWidth(title: string): number {
+  if (title === "") return 0;
+  return (
+    [...title].reduce(
+      (width, char) =>
+        width +
+        (/^[\x20-\x7e]$/u.test(char) ? STATION_TITLE_FONT_SIZE * 0.6 : STATION_TITLE_FONT_SIZE),
+      0,
+    ) + STATION_TITLE_BOLD_OVERHANG
+  );
+}
+
+/**
+ * 路線図の幅と、線路・駅の絶対座標を返す。
+ *
+ * 静止図と動く図はどちらも `compileGenericWithAnimate` からここを呼び、同じ配置を使う。
+ */
+export function placeMetro(doc: Pick<DslDocument, "actors" | "flow" | "lanes">): MetroPlacement {
+  const usedTracks: string[] = [];
+  for (const actor of doc.actors) {
+    const track = 線路の鍵(actor);
+    if (!usedTracks.includes(track)) usedTracks.push(track);
+  }
+
+  const declared = doc.lanes ? Object.keys(doc.lanes) : [];
+  const trackOrder = [
+    ...declared.filter((track) => usedTracks.includes(track)),
+    ...usedTracks.filter((track) => !declared.includes(track)),
+  ];
+
+  const usedIds = new Set<string>();
+  const trackIdByKey = new Map<string, string>();
+  for (const [index, track] of trackOrder.entries()) {
+    const base = `track-${slugify(track) || index}`;
+    let id = base;
+    let suffix = 2;
+    while (usedIds.has(id)) id = `${base}-${suffix++}`;
+    usedIds.add(id);
+    trackIdByKey.set(track, id);
+  }
+
+  const actorByName = new Map(doc.actors.map((actor) => [actor.name, actor]));
+  const 下へ置く = new Map<string, { decision: string; order: number }>();
+  for (const decision of doc.actors.filter((actor) => metroNodeKind(actor) === "decision")) {
+    let order = 0;
+    const branches = doc.flow.filter((step) => step.from === decision.name);
+    for (const branch of branches.slice(1)) {
+      const target = actorByName.get(branch.to);
+      if (
+        target === undefined ||
+        線路の鍵(target) !== 線路の鍵(decision) ||
+        metroNodeKind(target) !== "station" ||
+        下へ置く.has(target.name)
+      ) {
+        continue;
+      }
+      order += 1;
+      下へ置く.set(target.name, { decision: decision.name, order });
+    }
+  }
+
+  const stations: MetroStation[] = [];
+  const stationByActor = new Map<string, MetroStation>();
+  let previousOnTrack: { actor: DslActor; station: MetroStation } | undefined;
+  for (const [index, actor] of doc.actors.entries()) {
+    const track = 線路の鍵(actor);
+    const trackIndex = trackOrder.indexOf(track);
+    const posY = trackIndex * TRACK_HEIGHT + TRACK_HEIGHT / 2;
+    const below = 下へ置く.get(actor.name);
+    const decisionStation = below === undefined ? undefined : stationByActor.get(below.decision);
+    if (below !== undefined && decisionStation !== undefined) {
+      const station = {
+        actorName: actor.name,
+        trackId: trackIdByKey.get(track) ?? `track-${index}`,
+        posX: decisionStation.posX,
+        posY: decisionStation.posY + DECISION_DOWN_GAP * below.order,
+      };
+      stations.push(station);
+      stationByActor.set(actor.name, station);
+      continue;
+    }
+
+    let posX = FIRST_STATION_X;
+    if (previousOnTrack !== undefined) {
+      const previousActor = previousOnTrack.actor;
+      const previous = previousOnTrack.station;
+      const previousKind = metroNodeKind(previousActor);
+      const currentKind = metroNodeKind(actor);
+      if (線路の鍵(previousActor) !== track) {
+        const gap =
+          previousKind === "decision"
+            ? DECISION_HALF_WIDTH +
+              BRANCH_STUB +
+              BRANCH_CORNER_RADIUS * 2 +
+              BRANCH_END_MARGIN +
+              nodeHalfWidth(currentKind)
+            : Math.abs(posY - previous.posY) + TRANSFER_MARGIN;
+        posX = previous.posX + gap;
+      } else {
+        const shapeGap = previousKind === "mark-start" && currentKind === "station"
+          ? START_MARK_CENTER_GAP
+          : previousKind === "station" && currentKind === "decision"
+            ? STATION_DECISION_CENTER_GAP
+            : previousKind === "station" && currentKind === "mark-end"
+              ? END_MARK_CENTER_GAP
+              : nodeHalfWidth(previousKind) + nodeHalfWidth(currentKind) + NODE_SHAPE_GAP;
+        const titleGap =
+          previousKind === "station" && currentKind === "station"
+            ? estimateStationTitleWidth(箱の題(previousActor)) / 2 +
+              estimateStationTitleWidth(箱の題(actor)) / 2 +
+              (actor.stationNamePosition === "bottom" ? BOTTOM_TITLE_GAP : TITLE_GAP)
+            : 0;
+        posX = previous.posX + Math.max(shapeGap, titleGap);
+      }
+    }
+    const station = {
+      actorName: actor.name,
+      trackId: trackIdByKey.get(track) ?? `track-${index}`,
+      posX,
+      posY,
+    };
+    stations.push(station);
+    stationByActor.set(actor.name, station);
+    previousOnTrack = { actor, station };
+  }
+
+  const last = previousOnTrack;
+  const titleEndPadding =
+    last !== undefined && metroNodeKind(last.actor) === "station"
+      ? estimateStationTitleWidth(箱の題(last.actor)) / 2 + 8
+      : 0;
+  const width = (last?.station.posX ?? 0) + Math.max(TRACK_END_PADDING, titleEndPadding);
+  const tracks = trackOrder.map((track, index): MetroTrack => ({
+    id: trackIdByKey.get(track) ?? `track-${index}`,
+    label: doc.lanes?.[track]?.label ?? track,
+    ...(doc.lanes?.[track]?.subtitle !== undefined
+      ? { subtitle: doc.lanes[track].subtitle }
+      : {}),
+    posX: 0,
+    posY: index * TRACK_HEIGHT,
+    posW: width,
+    posH: TRACK_HEIGHT,
+  }));
+
+  return { width, tracks, stations };
+}

package/src/compile/mind.ts

@@ -1,7 +1,7 @@
 import { diagram } from "@cardenelabs/cdl";
 import type { CdlDiagram } from "@cardenelabs/cdl";
 import type { DslActor, DslDocument } from "../types";
-import { 図表の大きさ } from "./chart-fields";
+import { 図表の大きさ, 図表の大きさを読む } from "./chart-fields";
 import { 矢印から親を決める, 放射に出す文字 } from "./hierarchy";
 import type { CompileNotice } from "./notice";
 import { slugify } from "./slug";
@@ -56,13 +56,27 @@ type 放射で描ける欄 =
 /** 放射では描けない欄。 書かれていたら伝える */
 type 放射で描けない欄 =
   | "kind"
+  | "kindForm"
+  | "icon"
+  | "emptyRowsNote"
+  | "titleAlign"
+  | "rowRules"
+  | "rowDividerForm"
+  | "rowWell"
+  | "rowMarkForm"
+  | "nestIn"
+  | "figureCard"
   | "eyebrow"
   | "touchpoint"
   | "opportunity"
+  | "opportunityPosition"
   | "owner"
   | "end"
+  | "at"
+  | "atPos"
   | "rows"
   | "marks"
+  | "stage"
   | "lane"
   | "stack"
   | "initial"
@@ -90,7 +104,16 @@ type 放射で描けない欄 =
   | "hBind"
   | "opacity"
   | "renderOffsetX"
-  | "renderOffsetY";
+  | "renderOffsetY"
+  | "stationNamePosition"
+  | "subtitlePlacement"
+  | "titleFontSize"
+  | "startLabel"
+  | "milestone"
+  | "emphasis"
+  | "markGap"
+  | "rowStripe"
+  | "rowLayout";
 
 /** 引数が `never` でなければ型検査が落ちる */
 type 空であること<T extends never> = T;
@@ -123,13 +146,32 @@ export type _放射の欄が重なっていない = 空であること<Extract<
  */
 const 放射で描けない欄の名前: Record<放射で描けない欄, string> = {
   kind: "種類",
+  kindForm: "部品箱の形",
+  icon: "部品箱の線画",
+  emptyRowsNote: "行のない表の注記",
+  titleAlign: "表の題の位置",
+  rowRules: "表の行の罫線",
+  rowStripe: "表の行の縞",
+  rowLayout: "表の題と行の位置",
+  rowDividerForm: "表の見出し下の罫線",
+  rowWell: "表の行の受け皿",
+  rowMarkForm: "表の印の形",
+  nestIn: "表の入れ子",
+  figureCard: "表・部品箱の足",
   eyebrow: "上の小見出し",
-  touchpoint: "場所 (体験の道筋の欄)",
-  opportunity: "改善の余地 (体験の道筋の欄)",
+  touchpoint: "場所 (ユーザージャーニーの欄)",
+  opportunity: "改善の余地 (ユーザージャーニーの欄)",
+  opportunityPosition: "改善の余地の位置 (ユーザージャーニーの欄)",
   owner: "担当 (工程の並びの欄)",
   end: "終わる時期 (工程の並びの欄)",
+  startLabel: "始まりの札 (工程の並びの欄)",
+  milestone: "節目 (工程の並びの欄)",
+  emphasis: "主役 (工程の並びの欄)",
+  at: "点の位置 (四象限の欄)",
+  atPos: "点の位置 (四象限の欄)",
   rows: "行",
   marks: "印",
+  stage: "段階",
   lane: "枠の指定",
   stack: "積む順",
   initial: "始まり / 終わり の印",
@@ -154,6 +196,10 @@ const 放射で描けない欄の名前: Record<放射で描けない欄, string
   opacity: "濃さ",
   renderOffsetX: "描く時のずらし",
   renderOffsetY: "描く時のずらし",
+  stationNamePosition: "駅名の位置",
+  subtitlePlacement: "副題の位置",
+  titleFontSize: "題の字の大きさ",
+  markGap: "印までの間隔",
 };
 
 /**
@@ -190,7 +236,7 @@ export function compileMind(
 ): CdlDiagram {
   // 図の型は描画側の組み立て関数 `mindMap()` と同じ綴り (cdl 0.63.0 で `mindmap` から `mind` に揃った)
   const b = diagram(slugify(doc.title), { topic: doc.title, type: "mind" });
-  const { w: W, h: H } = 図表の大きさ.mind;
+  const { w: W, h: H } = 図表の大きさを読む(doc, 図表の大きさ.mind);
 
   const 伝える = (kind: CompileNotice["kind"], 名: string, message: string, line = 0): void => {
     onNotice?.({ kind, actor: 名, line, message });
@@ -338,6 +384,10 @@ export function compileMind(
         branches,
       };
     })(),
+    ...(doc.mindForm !== undefined ? { mindForm: doc.mindForm } : {}),
+    ...(doc.mindSize !== undefined ? { mindSize: doc.mindSize } : {}),
+    ...(doc.figureKindLabel !== undefined ? { figureKindLabel: doc.figureKindLabel } : {}),
+    ...(doc.terminalDecoration !== undefined ? { terminalDecoration: doc.terminalDecoration } : {}),
   });
   return b.build();
 }