@mstone6969/graph 0.0.0-stage → 0.2.0

package/dist/charts/frameworks/PositioningSamples.js

@@ -0,0 +1,191 @@
+import { randomLcg, randomNormal } from "d3";
+// src/charts/frameworks/PositioningSamples.ts
+/** Latent premium and practicality of each fictional brand, with its share. */
+var BRANDS = [
+	[
+		"Alder",
+		1.3,
+		.5,
+		9
+	],
+	[
+		"Brio",
+		-1.2,
+		.9,
+		24
+	],
+	[
+		"Cinder",
+		.4,
+		-1.3,
+		7
+	],
+	[
+		"Dune",
+		-.6,
+		-.8,
+		18
+	],
+	[
+		"Ember",
+		1,
+		-.5,
+		6
+	],
+	[
+		"Fable",
+		-1.4,
+		-.4,
+		21
+	],
+	[
+		"Grove",
+		.1,
+		1.2,
+		11
+	],
+	[
+		"Halo",
+		.7,
+		1.4,
+		4
+	]
+];
+/** How strongly each attribute reads the two latent dimensions. */
+var ATTRIBUTES = [
+	[
+		"Price",
+		1.3,
+		-.1
+	],
+	[
+		"Quality",
+		.8,
+		.9
+	],
+	[
+		"Style",
+		1.1,
+		-.5
+	],
+	[
+		"Reliability",
+		.1,
+		1.2
+	],
+	[
+		"Service",
+		.3,
+		.8
+	],
+	[
+		"Innovation",
+		.9,
+		-.2
+	]
+];
+var INITIATIVES = [
+	[
+		"Loyalty programme",
+		"Existing",
+		"Existing",
+		18
+	],
+	[
+		"Bundle pricing",
+		"Existing",
+		"Existing",
+		9
+	],
+	[
+		"Sales coverage",
+		"Existing",
+		"Existing",
+		14
+	],
+	[
+		"Win-back campaign",
+		"Existing",
+		"Existing",
+		5
+	],
+	[
+		"Premium tier",
+		"Existing",
+		"New",
+		22
+	],
+	[
+		"Mobile app",
+		"Existing",
+		"New",
+		16
+	],
+	[
+		"Add-on module",
+		"Existing",
+		"New",
+		7
+	],
+	[
+		"Export to Europe",
+		"New",
+		"Existing",
+		19
+	],
+	[
+		"Reseller channel",
+		"New",
+		"Existing",
+		11
+	],
+	[
+		"Public sector",
+		"New",
+		"Existing",
+		6
+	],
+	[
+		"Hardware line",
+		"New",
+		"New",
+		13
+	],
+	[
+		"Logistics venture",
+		"New",
+		"New",
+		8
+	]
+];
+/** Synthetic rows for the positioning charts: invented brands and initiatives, not measurements of anything real. */
+var PositioningSamples = class {
+	/** Mean ratings on a 1 to 7 scale for fictional brands, plus one ideal row, with noise drawn from `seed`. */
+	static perceptions(seed = 1) {
+		const noise = randomNormal.source(randomLcg(seed / 97))(0, .25);
+		const rating = (a, b, loadA, loadB) => +Math.max(1, Math.min(7, 4 + a * loadA + b * loadB + noise())).toFixed(2);
+		const rows = BRANDS.map(([brand, a, b, share]) => ({
+			brand,
+			role: "brand",
+			share,
+			...Object.fromEntries(ATTRIBUTES.map(([name, loadA, loadB]) => [name, rating(a, b, loadA, loadB)]))
+		}));
+		const ideal = {
+			brand: "Ideal",
+			role: "ideal",
+			...Object.fromEntries(ATTRIBUTES.map(([name, loadA, loadB]) => [name, rating(-.2, 1.2, loadA, loadB)]))
+		};
+		return [...rows, ideal];
+	}
+	/** Fictional growth initiatives with an invented investment in `value`. */
+	static initiatives(seed = 1) {
+		const random = randomLcg(seed / 89);
+		return INITIATIVES.map(([initiative, market, product, value]) => ({
+			initiative,
+			market,
+			product,
+			value: +(value * (.8 + random() * .4)).toFixed(1)
+		}));
+	}
+};
+export { PositioningSamples };

package/dist/charts/frameworks/RaciMatrix.js

@@ -0,0 +1,458 @@
+import { Chart2D } from "../../core/Chart2D.js";
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { FrameworkText } from "./FrameworkText.js";
+import { RaciHeader, RaciIssue, RaciLetter, RaciMark } from "./raciEnums.js";
+import { RaciPlan } from "./RaciPlan.js";
+import { RaciSamples } from "./RaciSamples.js";
+// src/charts/frameworks/RaciMatrix.ts
+var LETTERS = [
+	RaciLetter.Responsible,
+	RaciLetter.Accountable,
+	RaciLetter.Consulted,
+	RaciLetter.Informed
+];
+var NAMES = {
+	R: "Responsible",
+	A: "Accountable",
+	C: "Consulted",
+	I: "Informed"
+};
+var SHORT = {
+	[RaciIssue.NoAccountable]: "No A",
+	[RaciIssue.SeveralAccountable]: "A",
+	[RaciIssue.NoResponsible]: "No R"
+};
+var MIN_COLUMN = 24;
+var MIN_LABEL = 96;
+var MIN_ROW = 18;
+var MAX_ROW = 34;
+var BAND = 15;
+var LOAD = 18;
+var BADGE = 16;
+var HEAD = 11;
+var FOOT = 10.5;
+var FOOT_LEAD = 13;
+var COS45 = Math.SQRT1_2;
+/**
+* Assigns each task's work across roles: Responsible, Accountable, Consulted, Informed. Method: the
+* responsibility assignment matrix as in the PMBOK Guide, audited by the standard rule of exactly
+* one A and at least one R per task. A person holding both reads `A/R`, a common convention, and
+* counts toward both. Letters are always text, so colour is never the only encoding.
+*/
+var RaciMatrix = class RaciMatrix extends Chart2D {
+	static meta = {
+		id: "raci-matrix",
+		name: "RACI matrix",
+		family: ChartFamily.Project,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Sets tasks against roles with R, A, C and I letters and flags tasks with no Accountable, several, or no Responsible.",
+		tags: [
+			"framework",
+			"project",
+			"raci",
+			"responsibility",
+			"governance"
+		],
+		sample: (seed) => RaciSamples.launch(seed),
+		variants: {
+			header: [
+				RaciHeader.Wrapped,
+				RaciHeader.Angled,
+				RaciHeader.Vertical
+			],
+			mark: [RaciMark.Badge, RaciMark.Tile],
+			grouping: [false, true],
+			flags: [true, false],
+			load: [false, true]
+		}
+	};
+	defaults() {
+		return {
+			task: "task",
+			role: "role",
+			assignment: "assignment",
+			phase: "phase",
+			header: RaciHeader.Wrapped,
+			mark: RaciMark.Badge,
+			grouping: false,
+			flags: true,
+			load: false
+		};
+	}
+	plotMargin() {
+		return {
+			top: 8,
+			right: 16,
+			bottom: 10,
+			left: 16
+		};
+	}
+	legendItems() {
+		return this.palette.items().map((item) => ({
+			...item,
+			label: `${item.key} ${NAMES[item.key]}`
+		}));
+	}
+	/** The parsed tasks with their audit, for showing faults outside the chart. */
+	get plan() {
+		const { task, role, assignment, phase, data } = this.options;
+		return new RaciPlan(data, {
+			task,
+			role,
+			assignment,
+			phase
+		});
+	}
+	/** One row per task, one column per role, plus the audit. */
+	table() {
+		const plan = this.plan;
+		return {
+			columns: [
+				"Task",
+				...plan.roles,
+				"Check"
+			],
+			rows: plan.tasks.map((task) => [
+				task.name,
+				...plan.roles.map((role) => task.cells.get(role)?.join("/") ?? ""),
+				RaciMatrix.#check(task)
+			])
+		};
+	}
+	static #check(task) {
+		return task.issues.map((issue) => issue === RaciIssue.SeveralAccountable ? `${task.accountable.length} ${SHORT[issue]}` : SHORT[issue]).join(", ");
+	}
+	/** Equal columns no narrower than a letter badge. Roles past that are left out and counted in the footer. */
+	#columns(names, from, area, height) {
+		const longest = Math.max(0, ...names.map((name) => FrameworkText.width(name, HEAD)));
+		const { header } = this.options;
+		const rise = header === RaciHeader.Angled ? Math.min(longest * COS45 + 8, height * .3) : Math.min(longest + 8, height * .34);
+		let shown = Math.min(names.length, Math.max(1, Math.floor(area / MIN_COLUMN))), width = 0;
+		for (;; shown--) {
+			width = area / (shown || 1);
+			if (header === RaciHeader.Angled && rise > width / 2) width = (area - rise) / Math.max(.5, shown - .5);
+			if (shown <= 1 || width >= MIN_COLUMN) break;
+		}
+		const columns = names.slice(0, shown).map((role, i) => ({
+			role,
+			x: from + i * width,
+			width
+		}));
+		const wrapped = Math.max(1, ...columns.map(({ role, width: room }) => Math.min(3, FrameworkText.wrap(role, room - 4, HEAD).length)));
+		return {
+			columns,
+			hiddenRoles: names.slice(shown),
+			headerHeight: header === RaciHeader.Wrapped ? wrapped * 14 + 6 : rise
+		};
+	}
+	/** The largest type and most lines per task that fit. Whatever still does not fit is left out and named in the footer. */
+	#rows(ordered, labelWidth, top, room) {
+		const { grouping } = this.options;
+		const wrap = labelWidth - 10;
+		const band = (i) => grouping && ordered[i].phase !== ordered[i - 1]?.phase ? BAND : 0;
+		const bands = ordered.reduce((sum, _, i) => sum + band(i), 0);
+		const attempt = (size, most) => {
+			const lead = Math.round(size * 1.25);
+			const lines = ordered.map((task) => FrameworkText.clamp(FrameworkText.wrap(task.name, wrap, size), most, wrap, size));
+			return {
+				size,
+				lead,
+				lines,
+				heights: lines.map((list) => Math.max(MIN_ROW, list.length * lead + 5))
+			};
+		};
+		const fits = (pick) => pick.heights.reduce((sum, height) => sum + height, bands) <= room;
+		const pick = [
+			[11, 3],
+			[11, 2],
+			[10, 3],
+			[10, 2],
+			[11, 1],
+			[10, 1]
+		].map(([size, most]) => attempt(size, most)).find(fits) ?? attempt(10, 1);
+		const used = pick.heights.reduce((sum, height) => sum + height, bands);
+		const spare = ordered.length && used < room ? (room - used) / ordered.length : 0;
+		let y = top;
+		const tasks = [], phases = [];
+		let i = 0;
+		for (; i < ordered.length; i++) {
+			const task = ordered[i], lift = band(i), height = Math.min(MAX_ROW, pick.heights[i] + spare);
+			if (y + lift + height > top + room + .5) break;
+			if (lift) phases.push({
+				name: task.phase,
+				top: y
+			});
+			y += lift;
+			const lines = pick.lines[i];
+			tasks.push({
+				task,
+				lines,
+				x: 0,
+				y: y + (height - lines.length * pick.lead) / 2 + pick.size - 1,
+				lead: pick.lead,
+				top: y,
+				height
+			});
+			y += height;
+		}
+		return {
+			tasks,
+			hiddenTasks: ordered.slice(i),
+			phases,
+			size: pick.size,
+			lead: pick.lead,
+			loadTop: y
+		};
+	}
+	/** Wrapped names break between words if each column is as wide as the longest word. */
+	#headerRoom(roles) {
+		if (this.options.header !== RaciHeader.Wrapped) return 0;
+		const words = roles.flatMap((role) => role.split(" ")).map((word) => FrameworkText.width(word, HEAD) + 6);
+		return Math.max(0, ...words) * roles.length;
+	}
+	#layout(ctx, plan, note) {
+		const { flags, load, grouping } = this.options;
+		const { width, height } = ctx.plot;
+		const lines = FrameworkText.clamp(FrameworkText.wrap(note, width, FOOT), 2, width, FOOT);
+		const footerHeight = lines.length ? lines.length * FOOT_LEAD + 6 : 0;
+		const checks = flags ? plan.tasks.map((task) => RaciMatrix.#check(task)) : [];
+		const wanted = flags ? Math.ceil(Math.max(FrameworkText.width("Check", 10.5), ...checks.map((text) => FrameworkText.width(text, 10) + 12))) + 8 : 0;
+		const longest = Math.max(0, ...plan.tasks.map((task) => FrameworkText.width(task.name, 11)));
+		const label = Math.min(longest + 10, width * .42, Math.max(width * .34, width - wanted - this.#headerRoom(plan.roles)));
+		const labelWidth = Math.max(0, Math.min(Math.max(MIN_LABEL, label), width * .5, width - MIN_COLUMN));
+		const checkWidth = width - labelWidth - wanted >= MIN_COLUMN ? wanted : 0;
+		const area = Math.max(1, width - labelWidth - checkWidth);
+		const columns = this.#columns(plan.roles, labelWidth, area, height);
+		const ordered = grouping ? [...new Set(plan.tasks.map((task) => task.phase))].flatMap((phase) => plan.tasks.filter((task) => task.phase === phase)) : plan.tasks;
+		const room = height - columns.headerHeight - footerHeight - (load ? LOAD : 0);
+		const rows = this.#rows(ordered, labelWidth, columns.headerHeight, room);
+		const footer = {
+			lines,
+			x: 0,
+			y: height - footerHeight + 6 + FOOT,
+			lead: FOOT_LEAD
+		};
+		return {
+			...columns,
+			...rows,
+			labelWidth,
+			checkWidth,
+			footer
+		};
+	}
+	static #summary(plan, flags) {
+		const parts = [];
+		if (flags && plan.tasks.length) {
+			const count = (issue) => plan.tasks.filter((task) => task.issues.includes(issue)).length;
+			const none = count(RaciIssue.NoAccountable), several = count(RaciIssue.SeveralAccountable), noR = count(RaciIssue.NoResponsible);
+			const faults = [
+				none && `${none} no A`,
+				several && `${several} several A`,
+				noR && `${noR} no R`
+			].filter(Boolean).join(", ");
+			parts.push(plan.flagged.length ? `${plan.flagged.length} of ${plan.tasks.length} tasks flagged: ${faults}` : `All ${plan.tasks.length} tasks have one A and an R`);
+		}
+		if (plan.skipped) parts.push(`${plan.skipped} ${plan.skipped === 1 ? "row" : "rows"} unreadable`);
+		return parts;
+	}
+	#plan(ctx, plan) {
+		const summary = RaciMatrix.#summary(plan, !!this.options.flags);
+		const shown = (hidden, total, noun) => hidden ? [`Showing ${total - hidden} of ${total} ${noun}`] : [];
+		let layout = this.#layout(ctx, plan, summary.join(" · "));
+		for (let pass = 0; pass < 2 && (layout.hiddenTasks.length || layout.hiddenRoles.length); pass++) {
+			const notes = [
+				...summary,
+				...shown(layout.hiddenTasks.length, plan.tasks.length, "tasks"),
+				...shown(layout.hiddenRoles.length, plan.roles.length, "roles")
+			];
+			layout = this.#layout(ctx, plan, notes.join(" · "));
+		}
+		return layout;
+	}
+	#cells(plan, ctx) {
+		const { mark } = this.options;
+		return plan.tasks.flatMap((row) => plan.columns.flatMap(({ role, x, width }) => {
+			const letters = row.task.cells.get(role);
+			if (!letters) return [];
+			const label = letters.join("/"), fill = ctx.palette.color(letters[0]), room = Math.max(0, width - 6);
+			const size = FrameworkText.width(label, 11) <= room - 6 ? 11 : 9;
+			const text = FrameworkText.fit(label, room, size), middle = x + width / 2, y = row.top + row.height / 2;
+			const wide = Math.min(room, Math.max(BADGE, FrameworkText.width(text, size) + 8));
+			const box = mark === RaciMark.Tile ? {
+				x: x + 1,
+				y: row.top + 1,
+				width: Math.max(0, width - 2),
+				height: row.height - 2
+			} : {
+				x: middle - wide / 2,
+				y: y - BADGE / 2,
+				width: wide,
+				height: BADGE
+			};
+			return [{
+				key: `${row.task.name}\u0000${role}`,
+				task: row.task,
+				role,
+				letters,
+				text,
+				size,
+				fill,
+				...box,
+				middle,
+				baseline: y + size * .36
+			}];
+		}));
+	}
+	#pills(plan, ctx) {
+		const { theme, palette } = ctx;
+		if (!plan.checkWidth) return [];
+		return plan.tasks.filter((row) => row.task.issues.length).map((row) => {
+			const text = RaciMatrix.#check(row.task), width = Math.min(plan.checkWidth - 8, FrameworkText.width(text, 10) + 12);
+			const fill = row.task.issues[0] === RaciIssue.NoResponsible ? theme.warning : theme.critical;
+			return {
+				row,
+				text: FrameworkText.fit(text, width - 8, 10),
+				width,
+				height: 16,
+				x: ctx.plot.width - plan.checkWidth + 8,
+				y: row.top + row.height / 2 - 8,
+				baseline: row.top + row.height / 2 + 3.5,
+				fill,
+				ink: palette.inkOn(fill)
+			};
+		});
+	}
+	#drawHeader(ctx, plan, layout) {
+		const { header } = this.options;
+		const { headerHeight: rise, columns, checkWidth } = layout;
+		const wrapped = header === RaciHeader.Wrapped;
+		const rows = columns.map((column) => {
+			const lines = this.#headerLines(column, rise), middle = column.x + column.width / 2;
+			if (wrapped) return {
+				role: column.role,
+				lines,
+				x: middle,
+				y: rise - 5 - (lines.length - 1) * 14,
+				lead: 14,
+				turn: ""
+			};
+			const vertical = header === RaciHeader.Vertical;
+			return {
+				role: column.role,
+				lines,
+				x: 0,
+				y: 0,
+				lead: 14,
+				turn: `translate(${middle + (vertical ? 4 : -2)},${rise - 4}) rotate(${vertical ? -90 : -45})`
+			};
+		});
+		const heads = ctx.text(ctx.marks("role-names", "text", rows, (d) => d.role), HEAD, "ink").attr("font-weight", 600).attr("text-anchor", wrapped ? "middle" : "start");
+		ctx.set(heads, { transform: (d) => d.turn || null });
+		FrameworkText.write(ctx, heads);
+		ctx.hover(heads, (d) => {
+			const load = plan.load(d.role);
+			return FrameworkText.tip(d.role, LETTERS.map((letter) => [NAMES[letter], load[letter]]));
+		});
+		const check = ctx.text(ctx.marks("check-name", "text", checkWidth ? ["Check"] : []), 10.5, "secondary").attr("font-weight", 600).text((d) => d);
+		ctx.set(check, {
+			x: ctx.plot.width - checkWidth + 8,
+			y: rise - 5
+		});
+	}
+	#headerLines({ role, width }, rise) {
+		const { header } = this.options;
+		if (header === RaciHeader.Wrapped) return FrameworkText.clamp(FrameworkText.wrap(role, width - 4, HEAD), 3, width - 4, HEAD);
+		return [FrameworkText.fit(role, header === RaciHeader.Angled ? (rise - 6) / COS45 : rise - 6, HEAD)];
+	}
+	draw(ctx) {
+		const { load } = this.options;
+		const plan = this.plan, { plot, theme, palette } = ctx;
+		if (plan.tasks.length) for (const letter of LETTERS) palette.color(letter);
+		const layout = this.#plan(ctx, plan);
+		const rightEdge = plot.width;
+		const empty = ctx.text(ctx.marks("empty", "text", plan.tasks.length ? [] : ["No assignments"]), 12, "muted").attr("text-anchor", "middle").text((d) => d);
+		ctx.set(empty, {
+			x: plot.width / 2,
+			y: plot.height / 2
+		});
+		this.#drawHeader(ctx, plan, layout);
+		const rows = ctx.marks("task-rows", "g", layout.tasks, (d) => d.task.name);
+		const stripes = rows.selectAll(":scope > rect").data((d) => [d]).join("rect").attr("rx", 4).attr("fill", (d) => layout.checkWidth && d.task.issues.length ? d.task.issues[0] === RaciIssue.NoResponsible ? theme.warning : theme.critical : "transparent").attr("fill-opacity", .12);
+		ctx.set(stripes, {
+			x: 0,
+			y: (d) => d.top + 1,
+			width: rightEdge,
+			height: (d) => d.height - 2
+		});
+		const labels = rows.selectAll(":scope > text").data((d) => [d]).join("text");
+		FrameworkText.write(ctx, ctx.text(labels, layout.size, "ink").attr("pointer-events", "none"));
+		ctx.hover(rows, ({ task }) => FrameworkText.tip(task.name, [
+			["Phase", task.phase],
+			["Accountable", task.accountable.join(", ") || "None"],
+			["Responsible", task.responsible.join(", ") || "None"],
+			...task.issues.length ? [["Check", RaciMatrix.#check(task)]] : []
+		]));
+		const levels = plan.tasks.length ? [layout.headerHeight, ...layout.tasks.slice(0, -1).map((d) => d.top + d.height)] : [];
+		const rules = ctx.marks("rules", "line", levels).attr("stroke", (_, i) => i ? theme.grid : theme.axis);
+		ctx.set(rules, {
+			x1: 0,
+			x2: rightEdge,
+			y1: (d) => d,
+			y2: (d) => d
+		});
+		const phases = ctx.text(ctx.marks("phases", "text", layout.phases, (d) => d.name), 10.5, "secondary").attr("font-weight", 600).text((d) => FrameworkText.fit(d.name, plot.width, 10.5));
+		ctx.set(phases, {
+			x: 0,
+			y: (d) => d.top + 11
+		});
+		const cells = ctx.marks("cells", "g", this.#cells(layout, ctx), (d) => d.key);
+		const tiles = cells.selectAll("rect").data((d) => [d]).join("rect").attr("rx", 4).attr("fill", (d) => d.fill);
+		ctx.set(tiles, {
+			x: (d) => d.x,
+			y: (d) => d.y,
+			width: (d) => d.width,
+			height: (d) => d.height
+		});
+		const letters = cells.selectAll("text").data((d) => [d]).join("text").attr("text-anchor", "middle").attr("font-weight", 700).attr("font-size", (d) => d.size).attr("font-family", theme.fontFamily).attr("pointer-events", "none").attr("fill", (d) => palette.inkOn(d.fill)).text((d) => d.text);
+		ctx.set(letters, {
+			x: (d) => d.middle,
+			y: (d) => d.baseline
+		});
+		ctx.hover(cells, (d) => FrameworkText.tip(d.task.name, [["Role", d.role], ["Assignment", d.letters.map((letter) => NAMES[letter]).join(" and ")]], d.fill));
+		const pills = ctx.marks("pills", "g", this.#pills(layout, ctx), (d) => d.row.task.name).attr("pointer-events", "none");
+		const plates = pills.selectAll("rect").data((d) => [d]).join("rect").attr("rx", 4).attr("fill", (d) => d.fill);
+		ctx.set(plates, {
+			x: (d) => d.x,
+			y: (d) => d.y,
+			width: (d) => d.width,
+			height: (d) => d.height
+		});
+		const words = pills.selectAll("text").data((d) => [d]).join("text").attr("font-size", 10).attr("font-weight", 600).attr("font-family", theme.fontFamily).attr("fill", (d) => d.ink).text((d) => d.text);
+		ctx.set(words, {
+			x: (d) => d.x + 6,
+			y: (d) => d.baseline
+		});
+		const counts = load && plan.tasks.length ? layout.columns.map((column) => ({
+			column,
+			tasks: plan.tasks.filter((task) => task.cells.has(column.role)).length
+		})) : [];
+		const loads = ctx.text(ctx.marks("loads", "text", counts, (d) => d.column.role), 11, "ink").attr("text-anchor", "middle").attr("font-weight", 600).text((d) => d.tasks);
+		ctx.set(loads, {
+			x: (d) => d.column.x + d.column.width / 2,
+			y: layout.loadTop + 13
+		});
+		const loadName = ctx.text(ctx.marks("load-name", "text", counts.length ? ["Tasks per role"] : []), 10.5, "secondary").text((d) => d);
+		ctx.set(loadName, {
+			x: 0,
+			y: layout.loadTop + 13
+		});
+		const footer = ctx.text(ctx.marks("footer", "text", layout.footer.lines.length ? [layout.footer] : []), FOOT, "secondary");
+		FrameworkText.write(ctx, footer);
+		ctx.hover(footer, () => ({
+			title: layout.footer.lines.join(" "),
+			rows: [...layout.hiddenTasks.map((task) => [FrameworkText.fit(task.name, 240, 12), "task not shown"]), ...layout.hiddenRoles.map((role) => [FrameworkText.fit(role, 240, 12), "role not shown"])]
+		}));
+	}
+};
+export { RaciMatrix };