@mstone6969/graph 0.0.0-stage → 0.2.0

package/dist/charts/frameworks/VanWestendorpChart.js

@@ -0,0 +1,187 @@
+import { CartesianChart } from "../../core/CartesianChart.js";
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { ZoomAxis } from "../../core/ChartViewport.js";
+import { SampleData } from "../../data/SampleData.js";
+import { VanWestendorpCurves, VanWestendorpPoint, VanWestendorpSurvey, VanWestendorpTrace } from "./VanWestendorpSurvey.js";
+import { extent, line, scaleLinear } from "d3";
+// src/charts/frameworks/VanWestendorpChart.ts
+var LANE = 15;
+var MOST_LANES = 2;
+var CHAR = 6.2;
+var money = (value) => value.toLocaleString("en", { maximumFractionDigits: 2 });
+/** Synthetic survey, invented for the sample: anchored on a person's price sense, heaped on multiples of 5 as stated prices are. */
+var syntheticResponses = (seed) => {
+	const draws = SampleData.distribution(seed, 1500, 1).map((row) => (row.value - 40) / 8);
+	const stated = (value) => Math.max(0, Math.round(value / 5) * 5);
+	return Array.from({ length: 300 }, (_, i) => {
+		const z = draws.slice(i * 5, i * 5 + 5), anchor = 40 + 13 * Math.max(-2, Math.min(2, z[0]));
+		const tooCheap = stated(anchor * (.5 + .08 * z[1])), cheap = Math.max(tooCheap, stated(anchor * (.78 + .1 * z[2])));
+		const expensive = Math.max(cheap, stated(anchor * (1.2 + .12 * z[3])));
+		return {
+			tooCheap,
+			cheap,
+			expensive,
+			tooExpensive: Math.max(expensive, stated(anchor * (1.6 + .16 * z[4])))
+		};
+	});
+};
+/**
+* Van Westendorp's Price Sensitivity Meter: reads an acceptable price range and a stress-free price off four
+* cumulative curves of stated price thresholds. PMC and PME bound the range, OPP is Too Cheap × Too Expensive
+* and IPP is Cheap × Expensive. See P. van Westendorp, "NSS Price Sensitivity Meter", ESOMAR Congress, 1976.
+* Shows stated acceptability, not demand, so it does not by itself give a revenue-maximising price.
+*/
+var VanWestendorpChart = class extends CartesianChart {
+	static meta = {
+		id: "van-westendorp",
+		name: "Van Westendorp price sensitivity meter",
+		family: ChartFamily.Statistical,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Finds the acceptable price range and indifference point from four cumulative price-perception curves.",
+		tags: [
+			"pricing",
+			"survey",
+			"psm",
+			"price sensitivity"
+		],
+		sample: syntheticResponses,
+		variants: {
+			curves: [VanWestendorpCurves.Direct, VanWestendorpCurves.Inverted],
+			trace: [VanWestendorpTrace.Interpolated, VanWestendorpTrace.Stepped],
+			band: [true, false]
+		}
+	};
+	#placed = [];
+	#lanes = 0;
+	defaults() {
+		return {
+			tooCheap: "tooCheap",
+			cheap: "cheap",
+			expensive: "expensive",
+			tooExpensive: "tooExpensive",
+			curves: VanWestendorpCurves.Direct,
+			trace: VanWestendorpTrace.Interpolated,
+			band: true,
+			validate: true,
+			xLabel: "Price",
+			yLabel: "Respondents (%)"
+		};
+	}
+	/** The computed curves' source: read `crossings()` from it for the four prices. */
+	get survey() {
+		const { data, tooCheap, cheap, expensive, tooExpensive, validate } = this.options;
+		return new VanWestendorpSurvey(data, {
+			tooCheap,
+			cheap,
+			expensive,
+			tooExpensive
+		}, validate);
+	}
+	/** The share axis is fixed at 0 to 100 and shares the plot with the label lanes. */
+	zoomAxes() {
+		return ZoomAxis.X;
+	}
+	/** Labels go in lanes above 100%, one more each time two would touch. Crowded ones give up their prices, which tooltips keep. */
+	#place(crossings, x, width) {
+		const clusters = crossings.reduce((all, crossing) => {
+			const last = all.at(-1);
+			if (last && x(crossing.price) - x(last[0].price) < 1) last.push(crossing);
+			else all.push([crossing]);
+			return all;
+		}, []);
+		const names = (cluster) => cluster.map((crossing) => crossing.point).join(" · ");
+		const lay = (label) => {
+			const ends = [];
+			return {
+				placed: clusters.flatMap((cluster) => {
+					const text = label(cluster), span = text.length * CHAR;
+					const left = Math.max(0, Math.min(width - span, x(cluster[0].price) - span / 2));
+					const free = ends.findIndex((end) => left >= end + 6), lane = free < 0 ? ends.length : free;
+					ends[lane] = left + span;
+					return cluster.map((crossing, i) => ({
+						...crossing,
+						label: i ? "" : text,
+						lane
+					}));
+				}),
+				lanes: ends.length
+			};
+		};
+		const priced = lay((cluster) => `${names(cluster)} ${money(cluster[0].price)}`);
+		const { placed, lanes } = priced.lanes <= MOST_LANES ? priced : lay(names);
+		this.#placed = placed;
+		this.#lanes = lanes;
+	}
+	get #top() {
+		return this.#lanes ? this.#lanes * LANE + 4 : 0;
+	}
+	scales(ctx) {
+		const { width, height } = ctx.plot;
+		const { survey } = this;
+		const [low = 0, high = 1] = extent(survey.prices);
+		const x = scaleLinear().domain(low === high ? [Math.max(0, low - 1), high + 1] : [low, high]).nice().range([0, width]);
+		this.#place(survey.crossings(this.options.curves, this.options.trace), x, width);
+		return {
+			x,
+			y: scaleLinear().domain([0, 100]).range([height, this.#top])
+		};
+	}
+	plotMarks(ctx, { x, y }) {
+		const { width, height } = ctx.plot;
+		const { theme, palette } = ctx;
+		const placed = this.#placed.filter((crossing) => x(crossing.price) >= 0 && x(crossing.price) <= width);
+		const { survey } = this;
+		const curves = survey.curves(this.options.curves, this.options.trace).filter((curve) => curve.vertices.length);
+		const low = this.#placed.find((crossing) => crossing.point === VanWestendorpPoint.PMC), high = this.#placed.find((crossing) => crossing.point === VanWestendorpPoint.PME);
+		const range = this.options.band && low && high ? [{
+			low: Math.min(low.price, high.price),
+			high: Math.max(low.price, high.price)
+		}] : [];
+		const band = ctx.marks("band", "rect", range).attr("fill", theme.grid).attr("opacity", .55);
+		ctx.set(band, {
+			x: (d) => x(d.low),
+			width: (d) => Math.max(0, x(d.high) - x(d.low)),
+			y: this.#top,
+			height: height - this.#top
+		});
+		ctx.hover(band, (d) => ({
+			title: "Acceptable price range",
+			rows: [["PMC", money(d.low)], ["PME", money(d.high)]]
+		}));
+		const trace = line().x((vertex) => x(vertex.price)).y((vertex) => y(vertex.share));
+		const paths = ctx.marks("curves", "path", curves, (curve) => curve.name).attr("fill", "none").attr("stroke-width", 2).attr("stroke-linejoin", "round").attr("stroke", (curve) => palette.color(curve.name));
+		ctx.set(paths, { d: (curve) => trace(curve.vertices) });
+		ctx.drawOn(paths);
+		ctx.hover(paths, (curve) => ({
+			title: curve.name,
+			color: palette.color(curve.name),
+			rows: [["Respondents", survey.respondents]]
+		}));
+		const row = (crossing) => 11 + (this.#lanes - 1 - crossing.lane) * LANE;
+		const drops = ctx.marks("drops", "line", placed, (crossing) => crossing.point).attr("stroke", theme.axis).attr("stroke-dasharray", "3 3");
+		ctx.set(drops, {
+			x1: (d) => x(d.price),
+			x2: (d) => x(d.price),
+			y1: (d) => row(d) + 3,
+			y2: height
+		});
+		const dots = ctx.marks("crossings", "circle", placed, (crossing) => crossing.point).attr("fill", theme.ink).attr("stroke", theme.surface).attr("stroke-width", 2);
+		ctx.set(dots, {
+			cx: (d) => x(d.price),
+			cy: (d) => y(d.share),
+			r: 5
+		}, { r: 0 }, 60);
+		ctx.hover(dots, (d) => ({
+			title: d.name,
+			rows: [["Price", money(d.price)], ["Respondents", `${money(d.share)}%`]]
+		}));
+		const labels = ctx.marks("crossing-labels", "text", placed.filter((crossing) => crossing.label), (crossing) => crossing.point).attr("stroke", theme.surface).attr("stroke-width", 3).attr("paint-order", "stroke").attr("text-anchor", "middle").attr("font-weight", 600).text((d) => d.label);
+		ctx.text(labels, 11, "ink");
+		ctx.set(labels, {
+			x: (d) => Math.max(d.label.length * CHAR / 2, Math.min(width - d.label.length * CHAR / 2, x(d.price))),
+			y: row
+		});
+	}
+};
+export { VanWestendorpChart };

package/dist/charts/frameworks/VanWestendorpSurvey.js

@@ -0,0 +1,197 @@
+import { bisectLeft, bisectRight } from "d3";
+// src/charts/frameworks/VanWestendorpSurvey.ts
+/** Which pair of middle curves the chart plots and intersects. Both are in published use. */
+var VanWestendorpCurves = /* @__PURE__ */ function(VanWestendorpCurves) {
+	/** Cheap and Expensive as asked: PMC is Too Cheap × Expensive, PME is Too Expensive × Cheap. */
+	VanWestendorpCurves["Direct"] = "direct";
+	/** Not Cheap (100 − Cheap) and Not Expensive (100 − Expensive): PMC is Too Cheap × Not Cheap, PME is Too Expensive × Not Expensive. */
+	VanWestendorpCurves["Inverted"] = "inverted";
+	return VanWestendorpCurves;
+}({});
+/** How the survey's discrete prices join up. */
+var VanWestendorpTrace = /* @__PURE__ */ function(VanWestendorpTrace) {
+	VanWestendorpTrace["Interpolated"] = "interpolated";
+	VanWestendorpTrace["Stepped"] = "stepped";
+	return VanWestendorpTrace;
+}({});
+var VanWestendorpPoint = /* @__PURE__ */ function(VanWestendorpPoint) {
+	VanWestendorpPoint["PMC"] = "PMC";
+	VanWestendorpPoint["OPP"] = "OPP";
+	VanWestendorpPoint["IPP"] = "IPP";
+	VanWestendorpPoint["PME"] = "PME";
+	return VanWestendorpPoint;
+}({});
+var SNAP = 1e-9;
+var NAMES = {
+	["PMC"]: "Point of marginal cheapness",
+	["OPP"]: "Optimal price point",
+	["IPP"]: "Indifference price point",
+	["PME"]: "Point of marginal expensiveness"
+};
+var price = (cell) => {
+	const value = typeof cell === "number" ? cell : typeof cell === "string" && cell.trim() ? Number(cell) : NaN;
+	return Number.isFinite(value) && value >= 0 ? value : null;
+};
+/**
+* Van Westendorp's Price Sensitivity Meter (1976) from raw survey answers. Each curve is the share of
+* respondents placing a price in that category: Too Cheap and Cheap at or above the price, Expensive and
+* Too Expensive at or below it. Every crossing pairs a rising curve with a falling one, so their gap never
+* falls and a crossing is one price, or a flat stretch whose middle is taken.
+*/
+var VanWestendorpSurvey = class VanWestendorpSurvey {
+	#answers;
+	#prices;
+	/** Respondents answering nothing usable or, when validating, out of order. */
+	dropped;
+	respondents;
+	/** With `validate`, keeps only complete answers ordered Too Cheap ≤ Cheap ≤ Expensive ≤ Too Expensive. */
+	constructor(rows, columns, validate = true) {
+		const all = Array.isArray(rows) ? rows : [];
+		const kept = all.map((row) => {
+			const read = (column) => row !== null && typeof row === "object" ? price(row[column]) : null;
+			return [
+				read(columns.tooCheap),
+				read(columns.cheap),
+				read(columns.expensive),
+				read(columns.tooExpensive)
+			];
+		}).filter((row) => validate ? row.every((value, i) => value !== null && (!i || row[i - 1] <= value)) : row.some((value) => value !== null));
+		const column = (i) => kept.map((row) => row[i]).filter((value) => value !== null).sort((a, b) => a - b);
+		this.#answers = {
+			tooCheap: column(0),
+			cheap: column(1),
+			expensive: column(2),
+			tooExpensive: column(3)
+		};
+		this.#prices = [...new Set(Object.values(this.#answers).flat())].sort((a, b) => a - b);
+		this.respondents = kept.length;
+		this.dropped = all.length - kept.length;
+	}
+	get prices() {
+		return this.#prices;
+	}
+	#falling(answers, trace) {
+		const share = (count) => count / answers.length * 100;
+		return !answers.length ? [] : this.#prices.flatMap((at) => {
+			const reached = {
+				price: at,
+				share: share(answers.length - bisectLeft(answers, at))
+			};
+			return trace === "stepped" ? [reached, {
+				price: at,
+				share: share(answers.length - bisectRight(answers, at))
+			}] : [reached];
+		});
+	}
+	#rising(answers, trace) {
+		const share = (count) => count / answers.length * 100;
+		return !answers.length ? [] : this.#prices.flatMap((at) => {
+			const reached = {
+				price: at,
+				share: share(bisectRight(answers, at))
+			};
+			return trace === "stepped" ? [{
+				price: at,
+				share: share(bisectLeft(answers, at))
+			}, reached] : [reached];
+		});
+	}
+	#slots(form, trace) {
+		const flip = (vertices) => vertices.map((vertex) => ({
+			price: vertex.price,
+			share: 100 - vertex.share
+		}));
+		const { tooCheap, cheap, expensive, tooExpensive } = this.#answers;
+		const cheapShare = this.#falling(cheap, trace), expensiveShare = this.#rising(expensive, trace);
+		const inverted = form === "inverted";
+		return {
+			tooCheap: this.#falling(tooCheap, trace),
+			tooExpensive: this.#rising(tooExpensive, trace),
+			up: inverted ? flip(cheapShare) : expensiveShare,
+			down: inverted ? flip(expensiveShare) : cheapShare
+		};
+	}
+	/** The four curves, cheapest first, over the same prices. */
+	curves(form = "direct", trace = "interpolated") {
+		const { tooCheap, tooExpensive, up, down } = this.#slots(form, trace);
+		return [
+			{
+				name: "Too cheap",
+				vertices: tooCheap
+			},
+			...form === "inverted" ? [{
+				name: "Not cheap",
+				vertices: up
+			}, {
+				name: "Not expensive",
+				vertices: down
+			}] : [{
+				name: "Cheap",
+				vertices: down
+			}, {
+				name: "Expensive",
+				vertices: up
+			}],
+			{
+				name: "Too expensive",
+				vertices: tooExpensive
+			}
+		];
+	}
+	/** The four published intersections, ordered by price. A curve with no answers has no crossing. */
+	crossings(form = "direct", trace = "interpolated") {
+		const { tooCheap, tooExpensive, up, down } = this.#slots(form, trace);
+		return [
+			[
+				"PMC",
+				up,
+				tooCheap
+			],
+			[
+				"OPP",
+				tooExpensive,
+				tooCheap
+			],
+			[
+				"IPP",
+				up,
+				down
+			],
+			[
+				"PME",
+				tooExpensive,
+				down
+			]
+		].flatMap(([point, rising, falling]) => {
+			const hit = VanWestendorpSurvey.#cross(rising, falling);
+			return hit ? [{
+				point,
+				name: NAMES[point],
+				...hit
+			}] : [];
+		}).sort((a, b) => a.price - b.price);
+	}
+	/** Both lists share their prices, vertex by vertex. */
+	static #cross(rising, falling) {
+		if (!rising.length || !falling.length) return null;
+		const gaps = rising.map((vertex, i) => {
+			const gap = vertex.share - falling[i].share;
+			return Math.abs(gap) < SNAP ? 0 : gap;
+		});
+		const first = gaps.findIndex((gap) => gap >= 0);
+		if (first < 0) return null;
+		if (!first || !gaps[first]) {
+			const last = Math.max(first, gaps.findLastIndex((gap) => gap <= 0));
+			return {
+				price: (rising[first].price + rising[last].price) / 2,
+				share: rising[first].share
+			};
+		}
+		const before = rising[first - 1], after = rising[first], t = -gaps[first - 1] / (gaps[first] - gaps[first - 1]);
+		return {
+			price: before.price + (after.price - before.price) * t,
+			share: before.share + (after.share - before.share) * t
+		};
+	}
+};
+export { VanWestendorpCurves, VanWestendorpPoint, VanWestendorpSurvey, VanWestendorpTrace };

package/dist/charts/frameworks/index.js

@@ -0,0 +1,26 @@
+import { FrameworkText } from "./FrameworkText.js";
+import { RaciHeader, RaciIssue, RaciLetter, RaciMark } from "./raciEnums.js";
+import { RaciPlan } from "./RaciPlan.js";
+import { RaciSamples } from "./RaciSamples.js";
+import { RaciMatrix } from "./RaciMatrix.js";
+import { SwotItemMark, SwotLayout, SwotOrder, SwotQuadrant, SwotSizing } from "./swotEnums.js";
+import { SwotSamples } from "./SwotSamples.js";
+import { SwotMatrix } from "./SwotMatrix.js";
+import { NpsBand, NpsSurvey } from "./NpsSurvey.js";
+import { NpsGauge, NpsIndicator, NpsSweep } from "./NpsGauge.js";
+import { VanWestendorpCurves, VanWestendorpPoint, VanWestendorpSurvey, VanWestendorpTrace } from "./VanWestendorpSurvey.js";
+import { VanWestendorpChart } from "./VanWestendorpChart.js";
+import { PositioningSamples } from "./PositioningSamples.js";
+import { AnsoffDisplay, AnsoffMarketOrder, AnsoffMatrix, AnsoffStage, AnsoffStrategy } from "./AnsoffMatrix.js";
+import { PerceptualMethod, PerceptualProjection, PerceptualRole } from "./PerceptualProjection.js";
+import { PerceptualMap } from "./PerceptualMap.js";
+// src/charts/frameworks/index.ts
+var frameworksCatalog = [
+	SwotMatrix,
+	RaciMatrix,
+	NpsGauge,
+	VanWestendorpChart,
+	AnsoffMatrix,
+	PerceptualMap
+];
+export { AnsoffDisplay, AnsoffMarketOrder, AnsoffMatrix, AnsoffStage, AnsoffStrategy, FrameworkText, NpsBand, NpsGauge, NpsIndicator, NpsSurvey, NpsSweep, PerceptualMap, PerceptualMethod, PerceptualProjection, PerceptualRole, PositioningSamples, RaciHeader, RaciIssue, RaciLetter, RaciMark, RaciMatrix, RaciPlan, RaciSamples, SwotItemMark, SwotLayout, SwotMatrix, SwotOrder, SwotQuadrant, SwotSamples, SwotSizing, VanWestendorpChart, VanWestendorpCurves, VanWestendorpPoint, VanWestendorpSurvey, VanWestendorpTrace, frameworksCatalog };

package/dist/charts/frameworks/raciEnums.js

@@ -0,0 +1,30 @@
+// src/charts/frameworks/raciEnums.ts
+/** RACI responsibility assignment: who does the work, who answers for it, who is asked, who is told. */
+var RaciLetter = /* @__PURE__ */ function(RaciLetter) {
+	RaciLetter["Responsible"] = "R";
+	RaciLetter["Accountable"] = "A";
+	RaciLetter["Consulted"] = "C";
+	RaciLetter["Informed"] = "I";
+	return RaciLetter;
+}({});
+/** Faults in a task's assignments, from the rule of exactly one A and at least one R. */
+var RaciIssue = /* @__PURE__ */ function(RaciIssue) {
+	RaciIssue["NoAccountable"] = "no-accountable";
+	RaciIssue["SeveralAccountable"] = "several-accountable";
+	RaciIssue["NoResponsible"] = "no-responsible";
+	return RaciIssue;
+}({});
+/** How role names sit above their columns. */
+var RaciHeader = /* @__PURE__ */ function(RaciHeader) {
+	RaciHeader["Wrapped"] = "wrapped";
+	RaciHeader["Angled"] = "angled";
+	RaciHeader["Vertical"] = "vertical";
+	return RaciHeader;
+}({});
+/** How an assignment is drawn. The letter is always text. */
+var RaciMark = /* @__PURE__ */ function(RaciMark) {
+	RaciMark["Badge"] = "badge";
+	RaciMark["Tile"] = "tile";
+	return RaciMark;
+}({});
+export { RaciHeader, RaciIssue, RaciLetter, RaciMark };

package/dist/charts/frameworks/swotEnums.js

@@ -0,0 +1,34 @@
+// src/charts/frameworks/swotEnums.ts
+/** The four SWOT headings, in reading order. */
+var SwotQuadrant = /* @__PURE__ */ function(SwotQuadrant) {
+	SwotQuadrant["Strengths"] = "Strengths";
+	SwotQuadrant["Weaknesses"] = "Weaknesses";
+	SwotQuadrant["Opportunities"] = "Opportunities";
+	SwotQuadrant["Threats"] = "Threats";
+	return SwotQuadrant;
+}({});
+/** How the quadrants are arranged. */
+var SwotLayout = /* @__PURE__ */ function(SwotLayout) {
+	SwotLayout["Grid"] = "grid";
+	SwotLayout["Columns"] = "columns";
+	SwotLayout["Rows"] = "rows";
+	return SwotLayout;
+}({});
+/** Whether stacked quadrants share height equally or by how much text each holds. */
+var SwotSizing = /* @__PURE__ */ function(SwotSizing) {
+	SwotSizing["Equal"] = "equal";
+	SwotSizing["Content"] = "content";
+	return SwotSizing;
+}({});
+/** What leads each item: a bullet, or a reference code such as S1 for citing it in a TOWS analysis. */
+var SwotItemMark = /* @__PURE__ */ function(SwotItemMark) {
+	SwotItemMark["Bullet"] = "bullet";
+	SwotItemMark["Code"] = "code";
+	return SwotItemMark;
+}({});
+var SwotOrder = /* @__PURE__ */ function(SwotOrder) {
+	SwotOrder["Input"] = "input";
+	SwotOrder["Weight"] = "weight";
+	return SwotOrder;
+}({});
+export { SwotItemMark, SwotLayout, SwotOrder, SwotQuadrant, SwotSizing };

package/dist/charts/genomics/CircosFrame.js

@@ -0,0 +1,32 @@
+// src/charts/genomics/CircosFrame.ts
+var TAU = Math.PI * 2;
+/** Maps genomic position to angle: clockwise from 12 o'clock, chromosomes in karyotype order. */
+var CircosFrame = class {
+	sectors;
+	opening;
+	#byName;
+	constructor(chromosomes, radius, opening, focus, magnify) {
+		this.opening = chromosomes.length > 1 ? opening : 0;
+		const gap = Math.max(2.5 / radius, .006);
+		const weight = (chromosome) => chromosome.length * (chromosome.name === focus ? magnify : 1);
+		const total = chromosomes.reduce((sum, chromosome) => sum + weight(chromosome), 0) || 1;
+		const room = TAU - this.opening - gap * Math.max(0, chromosomes.length - (this.opening ? 1 : 0));
+		let cursor = this.opening / 2;
+		this.sectors = chromosomes.map((chromosome) => {
+			const a0 = cursor, a1 = a0 + weight(chromosome) / total * room;
+			cursor = a1 + gap;
+			return {
+				chromosome,
+				a0,
+				a1,
+				perBp: (a1 - a0) / chromosome.length
+			};
+		});
+		this.#byName = new Map(this.sectors.map((sector) => [sector.chromosome.name, sector]));
+	}
+	angle(chrom, position) {
+		const sector = this.#byName.get(chrom);
+		return sector ? sector.a0 + position * sector.perBp : 0;
+	}
+};
+export { CircosFrame };