@mstone6969/graph 0.0.0-stage → 0.2.0

package/dist/charts/frameworks/RaciPlan.js

@@ -0,0 +1,81 @@
+import { FrameworkText } from "./FrameworkText.js";
+import { RaciIssue, RaciLetter } from "./raciEnums.js";
+// src/charts/frameworks/RaciPlan.ts
+var ORDER = [
+	RaciLetter.Accountable,
+	RaciLetter.Responsible,
+	RaciLetter.Consulted,
+	RaciLetter.Informed
+];
+var WORDS = {
+	responsible: RaciLetter.Responsible,
+	accountable: RaciLetter.Accountable,
+	consulted: RaciLetter.Consulted,
+	informed: RaciLetter.Informed
+};
+var UNPHASED = "Other";
+/** Reads long RACI rows into tasks and roles, and audits each task for exactly one A and at least one R. */
+var RaciPlan = class RaciPlan {
+	tasks = [];
+	roles = [];
+	/** Rows with no task, no role, or an assignment that is not R, A, C or I. */
+	skipped = 0;
+	constructor(data, fields) {
+		const byName = /* @__PURE__ */ new Map();
+		for (const raw of Array.isArray(data) ? data : []) {
+			const row = raw ?? {};
+			const name = FrameworkText.clean(row[fields.task]), role = FrameworkText.clean(row[fields.role]);
+			if (!name || !role) {
+				this.skipped++;
+				continue;
+			}
+			let task = byName.get(name);
+			if (!task) {
+				task = {
+					name,
+					phase: FrameworkText.clean(row[fields.phase]) || UNPHASED,
+					cells: /* @__PURE__ */ new Map(),
+					accountable: [],
+					responsible: [],
+					issues: []
+				};
+				byName.set(name, task);
+				this.tasks.push(task);
+			}
+			if (!this.roles.includes(role)) this.roles.push(role);
+			const letters = RaciPlan.letters(row[fields.assignment]);
+			if (!letters) {
+				this.skipped++;
+				continue;
+			}
+			if (letters.length) task.cells.set(role, ORDER.filter((letter) => letters.includes(letter) || task.cells.get(role)?.includes(letter)));
+		}
+		for (const task of this.tasks) RaciPlan.#audit(task);
+	}
+	/** Letters in a cell such as `R`, `A/R`, `ar` or `Accountable`. Blank is none; null means unreadable. */
+	static letters(value) {
+		const text = FrameworkText.clean(value).toLowerCase();
+		const found = /* @__PURE__ */ new Set();
+		for (const token of text.split(/[^a-z]+/).filter(Boolean)) if (WORDS[token]) found.add(WORDS[token]);
+		else if (/^[raci]{1,4}$/.test(token)) for (const char of token) found.add(char.toUpperCase());
+		else return null;
+		return [...found];
+	}
+	static #audit(task) {
+		const holding = (letter) => [...task.cells].filter(([, letters]) => letters.includes(letter)).map(([role]) => role);
+		task.accountable = holding(RaciLetter.Accountable);
+		task.responsible = holding(RaciLetter.Responsible);
+		if (!task.accountable.length) task.issues.push(RaciIssue.NoAccountable);
+		if (task.accountable.length > 1) task.issues.push(RaciIssue.SeveralAccountable);
+		if (!task.responsible.length) task.issues.push(RaciIssue.NoResponsible);
+	}
+	get flagged() {
+		return this.tasks.filter((task) => task.issues.length);
+	}
+	/** How many tasks have this role, by letter. */
+	load(role) {
+		const count = (letter) => this.tasks.filter((task) => task.cells.get(role)?.includes(letter)).length;
+		return Object.fromEntries(ORDER.map((letter) => [letter, count(letter)]));
+	}
+};
+export { RaciPlan };

package/dist/charts/frameworks/RaciSamples.js

@@ -0,0 +1,76 @@
+// src/charts/frameworks/RaciSamples.ts
+/**
+* SYNTHETIC: an invented product launch, with three faults planted so the validation has something
+* to find: one task with no A, one with two, one with no R.
+*/
+var LAUNCH = [
+	[
+		"Plan",
+		"Agree launch scope",
+		{
+			PM: "A/R",
+			Engineering: "C",
+			Design: "C",
+			Marketing: "I"
+		}
+	],
+	[
+		"Plan",
+		"Estimate engineering effort and staffing",
+		{
+			PM: "C",
+			Engineering: "R",
+			Finance: "I"
+		}
+	],
+	[
+		"Plan",
+		"Approve launch budget",
+		{
+			PM: "A",
+			Finance: "A",
+			Marketing: "R"
+		}
+	],
+	[
+		"Ship",
+		"Build and test release candidate",
+		{
+			PM: "A",
+			Engineering: "R",
+			Design: "C"
+		}
+	],
+	[
+		"Ship",
+		"Write launch announcement",
+		{
+			PM: "A",
+			Design: "C",
+			Marketing: "C",
+			Support: "I"
+		}
+	],
+	[
+		"Ship",
+		"Brief customer support",
+		{
+			PM: "A",
+			Marketing: "I",
+			Support: "R"
+		}
+	]
+];
+var RaciSamples = class {
+	/** The invented launch as long rows. A new seed rotates its tasks. */
+	static launch(seed = 1) {
+		const turn = (seed - 1) % LAUNCH.length;
+		return [...LAUNCH.slice(turn), ...LAUNCH.slice(0, turn)].flatMap(([phase, task, assignments]) => Object.entries(assignments).map(([role, assignment]) => ({
+			phase,
+			task,
+			role,
+			assignment
+		})));
+	}
+};
+export { RaciSamples };

package/dist/charts/frameworks/SwotMatrix.js

@@ -0,0 +1,358 @@
+import { Chart2D } from "../../core/Chart2D.js";
+import { ChartFamily, DataShape, Dimension, LegendPosition } from "../../core/enums.js";
+import { FrameworkText } from "./FrameworkText.js";
+import { SwotItemMark, SwotLayout, SwotOrder, SwotQuadrant, SwotSizing } from "./swotEnums.js";
+import { SwotSamples } from "./SwotSamples.js";
+// src/charts/frameworks/SwotMatrix.ts
+var QUADRANTS = Object.values(SwotQuadrant);
+var HEADER = 24;
+var PAD = 6;
+var SIDE = 124;
+var GAP = 6;
+var RAIL = 18;
+var NOTE = 16;
+var ITEM_GAP = 4;
+var DOT = 4;
+var SIZES = [
+	12,
+	11,
+	10
+];
+var INTERNAL = /* @__PURE__ */ new Set([SwotQuadrant.Strengths, SwotQuadrant.Weaknesses]);
+var HELPFUL = /* @__PURE__ */ new Set([SwotQuadrant.Strengths, SwotQuadrant.Opportunities]);
+var NAMES = /* @__PURE__ */ new Map([
+	["s", SwotQuadrant.Strengths],
+	["strength", SwotQuadrant.Strengths],
+	["strengths", SwotQuadrant.Strengths],
+	["w", SwotQuadrant.Weaknesses],
+	["weakness", SwotQuadrant.Weaknesses],
+	["weaknesses", SwotQuadrant.Weaknesses],
+	["o", SwotQuadrant.Opportunities],
+	["opportunity", SwotQuadrant.Opportunities],
+	["opportunities", SwotQuadrant.Opportunities],
+	["t", SwotQuadrant.Threats],
+	["threat", SwotQuadrant.Threats],
+	["threats", SwotQuadrant.Threats]
+]);
+/**
+* Lists a situation's internal strengths and weaknesses against its external opportunities and
+* threats. Method: SWOT analysis, usually traced to the Harvard business policy school (Learned,
+* Christensen, Andrews and Guth, 1965): rows are origin, columns are effect. Items that do not fit
+* are counted in a "+N more" line and text shrinks no further than 10px; only a lone item too long
+* for its whole box ends in an ellipsis. Hidden and cut text stays in the tooltip and the CSV.
+*/
+var SwotMatrix = class extends Chart2D {
+	static meta = {
+		id: "swot-matrix",
+		name: "SWOT matrix",
+		family: ChartFamily.Matrix,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Sets out strengths, weaknesses, opportunities and threats as four lists of wrapped text for strategy reviews.",
+		tags: [
+			"framework",
+			"strategy",
+			"swot",
+			"text",
+			"quadrant"
+		],
+		sample: (seed) => SwotSamples.bakery(seed),
+		variants: {
+			layout: [
+				SwotLayout.Grid,
+				SwotLayout.Columns,
+				SwotLayout.Rows
+			],
+			sizing: [SwotSizing.Equal, SwotSizing.Content],
+			framing: [true, false],
+			itemMark: [SwotItemMark.Bullet, SwotItemMark.Code]
+		},
+		/** Side-by-side columns share one height, so there is nothing to size. */
+		valid: (v) => v.layout !== SwotLayout.Columns || v.sizing === SwotSizing.Equal
+	};
+	defaults() {
+		return {
+			quadrant: "quadrant",
+			item: "item",
+			weight: "weight",
+			layout: SwotLayout.Grid,
+			sizing: SwotSizing.Equal,
+			framing: true,
+			itemMark: SwotItemMark.Bullet,
+			order: SwotOrder.Input
+		};
+	}
+	plotMargin() {
+		return {
+			top: 8,
+			right: 16,
+			bottom: 12,
+			left: 16
+		};
+	}
+	/** Each quadrant is named on its own header. */
+	get legendPosition() {
+		return LegendPosition.None;
+	}
+	/** Rows dropped for naming no SWOT quadrant or no item text. */
+	get skipped() {
+		return this.#parse().skipped;
+	}
+	#parse() {
+		const { quadrant, item, weight, data, order } = this.options;
+		const rows = Array.isArray(data) ? data : [];
+		const lists = Object.fromEntries(QUADRANTS.map((name) => [name, []]));
+		let skipped = 0;
+		for (const row of rows) {
+			const cells = row ?? {};
+			const name = NAMES.get(FrameworkText.clean(cells[quadrant]).toLowerCase()), text = FrameworkText.clean(cells[item]);
+			if (!name || !text) {
+				skipped++;
+				continue;
+			}
+			const raw = cells[weight], score = raw === null || raw === "" ? NaN : Number(raw);
+			lists[name].push({
+				quadrant: name,
+				text,
+				weight: Number.isFinite(score) ? score : null,
+				code: ""
+			});
+		}
+		for (const name of QUADRANTS) {
+			if (order === SwotOrder.Weight) lists[name].sort((a, b) => (b.weight ?? -Infinity) - (a.weight ?? -Infinity));
+			lists[name].forEach((entry, i) => {
+				entry.code = `${name[0]}${i + 1}`;
+			});
+		}
+		return {
+			lists,
+			skipped
+		};
+	}
+	#indent(size) {
+		return this.options.itemMark === SwotItemMark.Code ? Math.ceil(FrameworkText.width("T00", size)) + 6 : 16;
+	}
+	/** Rows put the quadrant's heading beside its text, where the other layouts put it above. */
+	#side(width) {
+		return this.options.layout === SwotLayout.Rows ? Math.min(SIDE, width * .4) : 0;
+	}
+	#chrome() {
+		return (this.options.layout === SwotLayout.Rows ? 0 : HEADER) + 12;
+	}
+	/** Height a quadrant wants at this size and width. */
+	#wants(list, width, size) {
+		const lead = Math.round(size * 1.3), wrap = width - this.#side(width) - 12 - this.#indent(size);
+		const text = list.reduce((sum, entry) => sum + FrameworkText.wrap(entry.text, wrap, size).length * lead + ITEM_GAP, -4);
+		return this.#chrome() + Math.max(text, lead);
+	}
+	#heights(frame, grid, lists, width, size) {
+		const room = frame.height - GAP * (grid.length - 1);
+		const equal = room / grid.length;
+		if (this.options.sizing !== SwotSizing.Content) return grid.map(() => equal);
+		const floor = this.#chrome() + Math.round(size * 1.3) * 2 + ITEM_GAP;
+		const wants = grid.map((row) => Math.max(0, Math.max(...row.map((name) => this.#wants(lists[name], width, size))) - floor));
+		const total = wants.reduce((sum, want) => sum + want, 0), spare = room - floor * grid.length;
+		return total > 0 && spare > 0 ? wants.map((want) => floor + spare * (want / total)) : grid.map(() => equal);
+	}
+	#boxes(frame, lists, size) {
+		const { layout } = this.options;
+		const grid = layout === SwotLayout.Columns ? [QUADRANTS] : layout === SwotLayout.Rows ? QUADRANTS.map((name) => [name]) : [QUADRANTS.slice(0, 2), QUADRANTS.slice(2)];
+		const across = grid[0].length, width = (frame.width - GAP * (across - 1)) / across;
+		let y = frame.y;
+		return this.#heights(frame, grid, lists, width, size).flatMap((height, r) => {
+			const row = grid[r].map((quadrant, c) => ({
+				quadrant,
+				x: frame.x + c * (width + GAP),
+				y,
+				width,
+				height,
+				count: lists[quadrant].length,
+				side: this.#side(width)
+			}));
+			y += height + GAP;
+			return row;
+		});
+	}
+	/** Lists whole items while they fit, keeping a line for the count of the rest. Only a lone item too long for the box is cut. */
+	#fill(box, list, size) {
+		const lead = Math.round(size * 1.3), indent = this.#indent(size), inner = box.width - box.side - 12, width = inner - indent;
+		const left = box.x + box.side + PAD, x = left + indent, room = box.height - this.#chrome();
+		const wrapped = list.map((entry) => FrameworkText.wrap(entry.text, width, size));
+		const cost = (count) => wrapped.slice(0, count).reduce((sum, lines) => sum + lines.length * lead + ITEM_GAP, 0);
+		let shown = list.length;
+		if (cost(shown) - ITEM_GAP > room) {
+			shown--;
+			while (shown > 0 && cost(shown) + lead > room) shown--;
+		}
+		let cut = false;
+		if (shown === 0 && list.length) {
+			const rest = list.length > 1 ? lead + ITEM_GAP : 0, rows = Math.floor((room - rest) / lead);
+			if (rows >= 1) {
+				cut = wrapped[0].length > rows;
+				wrapped[0] = FrameworkText.clamp(wrapped[0], rows, width, size);
+				shown = 1;
+			}
+		}
+		let top = box.y + this.#chrome() - PAD;
+		const place = (entry, hidden, lines, key) => {
+			const block = {
+				key,
+				quadrant: box.quadrant,
+				entry,
+				hidden,
+				lines,
+				x,
+				y: top + size,
+				lead,
+				left,
+				top,
+				width: inner,
+				height: lines.length * lead,
+				size
+			};
+			top += block.height + ITEM_GAP;
+			return block;
+		};
+		const blocks = list.slice(0, shown).map((entry, i) => place(entry, [], wrapped[i], `${box.quadrant}:${i}`));
+		const hidden = list.slice(shown);
+		if (hidden.length && room >= lead + (shown ? cost(shown) : 0)) blocks.push(place(null, hidden, [`+${hidden.length} more`], `${box.quadrant}:more`));
+		return {
+			blocks,
+			whole: !hidden.length && !cut
+		};
+	}
+	#plan(frame, lists) {
+		let boxes = [], blocks = [];
+		for (const size of SIZES) {
+			boxes = this.#boxes(frame, lists, size);
+			const filled = boxes.map((box) => this.#fill(box, lists[box.quadrant], size));
+			blocks = filled.flatMap((fill) => fill.blocks);
+			if (filled.every((fill) => fill.whole)) break;
+		}
+		return {
+			boxes,
+			blocks
+		};
+	}
+	#rails(frame) {
+		const { layout, framing } = this.options;
+		if (!framing) return [];
+		const across = (frame.width - GAP) / 2, down = (frame.height - GAP) / 2;
+		const top = (key, i) => ({
+			key,
+			label: key,
+			x: frame.x + (across + GAP) * i + across / 2,
+			y: 11,
+			along: across,
+			turned: false
+		});
+		const side = (key, i) => ({
+			key,
+			label: key,
+			x: 11,
+			y: frame.y + (down + GAP) * i + down / 2,
+			along: down,
+			turned: true
+		});
+		if (layout === SwotLayout.Columns) return ["Internal", "External"].map(top);
+		if (layout === SwotLayout.Rows) return ["Internal", "External"].map(side);
+		return [...["Helpful", "Harmful"].map(top), ...["Internal", "External"].map(side)];
+	}
+	draw(ctx) {
+		const { framing, layout, itemMark } = this.options;
+		const { lists, skipped } = this.#parse(), { plot, theme, palette } = ctx;
+		const colors = new Map(QUADRANTS.map((name) => [name, palette.color(name)]));
+		const left = framing && layout !== SwotLayout.Columns ? RAIL : 0, top = framing && layout !== SwotLayout.Rows ? RAIL : 0;
+		const frame = {
+			x: left,
+			y: top,
+			width: Math.max(0, plot.width - left),
+			height: Math.max(0, plot.height - top - (skipped ? NOTE : 0))
+		};
+		const { boxes, blocks } = this.#plan(frame, lists);
+		const rails = ctx.text(ctx.marks("rails", "text", this.#rails(frame), (d) => d.key), 11).attr("text-anchor", "middle").attr("font-weight", 600);
+		rails.text((d) => FrameworkText.fit(d.label, d.along, 11));
+		ctx.set(rails, { transform: (d) => `translate(${d.x},${d.y})${d.turned ? " rotate(-90)" : ""}` });
+		const rect = {
+			x: (d) => d.x,
+			y: (d) => d.y,
+			width: (d) => d.width
+		};
+		const panels = ctx.marks("panels", "rect", boxes, (d) => d.quadrant).attr("rx", 4).attr("fill", (d) => colors.get(d.quadrant)).attr("fill-opacity", .1);
+		ctx.set(panels, {
+			...rect,
+			height: (d) => d.height
+		});
+		const bands = ctx.marks("bands", "rect", boxes, (d) => d.quadrant).attr("rx", 4).attr("fill", (d) => colors.get(d.quadrant));
+		ctx.set(bands, {
+			x: (d) => d.x,
+			y: (d) => d.y,
+			width: (d) => d.side || d.width,
+			height: (d) => d.side ? d.height : Math.min(HEADER, d.height)
+		});
+		const shown = boxes.filter((box) => box.height >= HEADER);
+		const titles = ctx.text(ctx.marks("titles", "text", shown, (d) => d.quadrant), 12, "ink").attr("font-weight", 600).attr("fill", (d) => palette.inkOn(colors.get(d.quadrant)));
+		const headed = (d) => d.side || d.width;
+		titles.text((d) => FrameworkText.fit(d.quadrant, headed(d) - 12 - (headed(d) >= 70 ? 22 : 0), 12));
+		ctx.set(titles, {
+			x: (d) => d.x + PAD,
+			y: (d) => d.y + 16
+		});
+		const counts = ctx.text(ctx.marks("counts", "text", shown.filter((box) => headed(box) >= 70), (d) => d.quadrant), 12, "ink").attr("text-anchor", "end").attr("fill", (d) => palette.inkOn(colors.get(d.quadrant)));
+		counts.text((d) => d.count);
+		ctx.set(counts, {
+			x: (d) => d.x + headed(d) - PAD,
+			y: (d) => d.y + 16
+		});
+		const empties = boxes.filter((box) => !box.count && box.height >= this.#chrome() + 12);
+		const none = ctx.text(ctx.marks("none", "text", empties, (d) => d.quadrant), 11, "muted").text("None listed");
+		ctx.set(none, {
+			x: (d) => d.x + d.side + PAD,
+			y: (d) => d.y + this.#chrome() - PAD + 11
+		});
+		const items = ctx.marks("items", "g", blocks, (d) => d.key);
+		ctx.hover(items, (d) => {
+			const color = colors.get(d.quadrant);
+			if (!d.entry) return {
+				title: `${d.hidden.length} more ${d.quadrant}`,
+				color,
+				rows: d.hidden.flatMap((entry) => FrameworkText.wrap(entry.text, 320, 12).map((line) => [line, ""]))
+			};
+			const score = d.entry.weight === null ? [] : [["Weight", d.entry.weight]];
+			return FrameworkText.tip(d.entry.text, [
+				["Quadrant", d.quadrant],
+				["Origin", INTERNAL.has(d.quadrant) ? "Internal" : "External"],
+				["Effect", HELPFUL.has(d.quadrant) ? "Helpful" : "Harmful"],
+				...score
+			], color);
+		});
+		const hits = items.selectAll(":scope > rect").data((d) => [d]).join("rect").attr("fill", "transparent");
+		ctx.set(hits, {
+			x: (d) => d.left,
+			y: (d) => d.top,
+			width: (d) => d.width,
+			height: (d) => d.height
+		});
+		const bulleted = (d) => itemMark === SwotItemMark.Bullet && d.entry ? [d] : [];
+		const dots = items.selectAll("circle").data(bulleted).join("circle").attr("r", DOT).attr("fill", (d) => colors.get(d.quadrant)).attr("stroke", theme.surface).attr("stroke-width", 2);
+		ctx.set(dots, {
+			cx: (d) => d.left + DOT + 1,
+			cy: (d) => d.top + d.lead / 2
+		});
+		const coded = (d) => itemMark === SwotItemMark.Code && d.entry ? [d] : [];
+		const codes = ctx.text(items.selectAll("text.code").data(coded).join("text").attr("class", "code")).attr("font-weight", 600).attr("font-size", (d) => d.size).text((d) => d.entry.code);
+		ctx.set(codes, {
+			x: (d) => d.left,
+			y: (d) => d.y
+		});
+		const body = ctx.text(items.selectAll("text.body").data((d) => [d]).join("text").attr("class", "body"), 11, "ink").attr("font-size", (d) => d.size).attr("pointer-events", "none");
+		FrameworkText.write(ctx, body);
+		const notes = skipped ? [`${skipped} ${skipped === 1 ? "row" : "rows"} left out: no SWOT quadrant or no item text`] : [];
+		const note = ctx.text(ctx.marks("note", "text", notes), 10.5, "muted").text((d) => FrameworkText.fit(d, plot.width, 10.5));
+		ctx.set(note, {
+			x: 0,
+			y: plot.height - 3
+		});
+	}
+};
+export { SwotMatrix };

package/dist/charts/frameworks/SwotSamples.js

@@ -0,0 +1,85 @@
+import { SwotQuadrant } from "./swotEnums.js";
+// src/charts/frameworks/SwotSamples.ts
+/** SYNTHETIC: an invented neighbourhood bakery. Nothing here describes a real business or measurement. */
+var BAKERY = [
+	[
+		SwotQuadrant.Strengths,
+		"Loyal weekday breakfast regulars",
+		8
+	],
+	[
+		SwotQuadrant.Strengths,
+		"Sourdough starter and recipes nobody nearby can copy",
+		9
+	],
+	[
+		SwotQuadrant.Strengths,
+		"Corner site with heavy foot traffic",
+		7
+	],
+	[
+		SwotQuadrant.Strengths,
+		"Staff who have stayed for years",
+		5
+	],
+	[
+		SwotQuadrant.Strengths,
+		"Own delivery bike",
+		2
+	],
+	[
+		SwotQuadrant.Weaknesses,
+		"Oven capacity caps the morning bake",
+		8
+	],
+	[
+		SwotQuadrant.Weaknesses,
+		"No online ordering or card-on-file for wholesale accounts",
+		6
+	],
+	[
+		SwotQuadrant.Weaknesses,
+		"Owner does all the buying",
+		7
+	],
+	[
+		SwotQuadrant.Opportunities,
+		"Office lunch catering within walking distance of the shop",
+		7
+	],
+	[
+		SwotQuadrant.Opportunities,
+		"Weekend baking classes",
+		4
+	],
+	[
+		SwotQuadrant.Opportunities,
+		"Wholesale bread for two new cafes",
+		8
+	],
+	[
+		SwotQuadrant.Threats,
+		"Flour and butter prices keep rising",
+		9
+	],
+	[
+		SwotQuadrant.Threats,
+		"A supermarket in-store bakery opening nearby next spring",
+		7
+	]
+];
+var SwotSamples = class {
+	/** The invented bakery, with items rotated by seed so a new seed reorders each quadrant. */
+	static bakery(seed = 1) {
+		return Object.values(SwotQuadrant).flatMap((quadrant) => {
+			const items = BAKERY.filter((item) => item[0] === quadrant);
+			const turn = (seed - 1) % items.length;
+			return [...items.slice(turn), ...items.slice(0, turn)].map(([, item, weight]) => ({
+				quadrant,
+				item,
+				weight
+			}));
+		});
+	}
+};
+export { SwotSamples };