@dou-ui/chart 0.0.0-stage → 0.1.0-alpha.0

package/dist/core/time.js

@@ -0,0 +1,217 @@
+// src/core/time.ts
+var SECOND = 1e3;
+var MINUTE = 60 * SECOND;
+var HOUR = 60 * MINUTE;
+var DAY = 24 * HOUR;
+var INTERVALS = [
+	[
+		"second",
+		1,
+		SECOND
+	],
+	[
+		"second",
+		5,
+		5 * SECOND
+	],
+	[
+		"second",
+		15,
+		15 * SECOND
+	],
+	[
+		"second",
+		30,
+		30 * SECOND
+	],
+	[
+		"minute",
+		1,
+		MINUTE
+	],
+	[
+		"minute",
+		2,
+		2 * MINUTE
+	],
+	[
+		"minute",
+		5,
+		5 * MINUTE
+	],
+	[
+		"minute",
+		10,
+		10 * MINUTE
+	],
+	[
+		"minute",
+		15,
+		15 * MINUTE
+	],
+	[
+		"minute",
+		30,
+		30 * MINUTE
+	],
+	[
+		"hour",
+		1,
+		HOUR
+	],
+	[
+		"hour",
+		2,
+		2 * HOUR
+	],
+	[
+		"hour",
+		3,
+		3 * HOUR
+	],
+	[
+		"hour",
+		6,
+		6 * HOUR
+	],
+	[
+		"hour",
+		12,
+		12 * HOUR
+	],
+	[
+		"day",
+		1,
+		DAY
+	],
+	[
+		"day",
+		2,
+		2 * DAY
+	],
+	[
+		"week",
+		1,
+		7 * DAY
+	],
+	[
+		"week",
+		2,
+		14 * DAY
+	],
+	[
+		"month",
+		1,
+		30 * DAY
+	],
+	[
+		"month",
+		3,
+		91 * DAY
+	],
+	[
+		"month",
+		6,
+		182 * DAY
+	],
+	[
+		"year",
+		1,
+		365 * DAY
+	]
+];
+/** The smallest interval that gives at most `count` ticks across `span` ms. */
+function timeInterval(span, count) {
+	for (const [unit, every, length] of INTERVALS) if (span / length <= Math.max(1, count)) return {
+		unit,
+		every
+	};
+	const years = span / (365 * DAY) / Math.max(1, count);
+	const power = 10 ** Math.floor(Math.log10(years));
+	const fraction = years / power;
+	return {
+		unit: "year",
+		every: (fraction <= 1 ? 1 : fraction <= 2 ? 2 : fraction <= 5 ? 5 : 10) * power
+	};
+}
+/** The start of the `unit` that `time` falls in (weeks start on Monday). */
+function floorTime(time, unit) {
+	const d = new Date(time);
+	switch (unit) {
+		case "year": return new Date(d.getFullYear(), 0, 1);
+		case "month": return new Date(d.getFullYear(), d.getMonth(), 1);
+		case "week": {
+			const back = (d.getDay() + 6) % 7;
+			return new Date(d.getFullYear(), d.getMonth(), d.getDate() - back);
+		}
+		case "day": return new Date(d.getFullYear(), d.getMonth(), d.getDate());
+		case "hour": return new Date(d.getFullYear(), d.getMonth(), d.getDate(), d.getHours());
+		case "minute": return new Date(d.getFullYear(), d.getMonth(), d.getDate(), d.getHours(), d.getMinutes());
+		default: return /* @__PURE__ */ new Date(Math.floor(time / SECOND) * SECOND);
+	}
+}
+/** Whether `date` is on a multiple of `every` within the next unit up, so steps line up. */
+function aligned(date, { unit, every }) {
+	if (every === 1) return true;
+	switch (unit) {
+		case "year": return date.getFullYear() % every === 0;
+		case "month": return date.getMonth() % every === 0;
+		case "day": return (date.getDate() - 1) % every === 0 && date.getDate() + every - 1 <= 31;
+		case "hour": return date.getHours() % every === 0;
+		case "minute": return date.getMinutes() % every === 0;
+		case "second": return date.getSeconds() % every === 0;
+		case "week": return Math.round((date.getTime() - new Date(1970, 0, 5).getTime()) / (7 * DAY)) % every === 0;
+		default: return true;
+	}
+}
+function next(date, unit) {
+	const d = new Date(date);
+	switch (unit) {
+		case "year":
+			d.setFullYear(d.getFullYear() + 1);
+			break;
+		case "month":
+			d.setMonth(d.getMonth() + 1);
+			break;
+		case "week":
+			d.setDate(d.getDate() + 7);
+			break;
+		case "day":
+			d.setDate(d.getDate() + 1);
+			break;
+		case "hour": return new Date(d.getTime() + HOUR);
+		case "minute": return new Date(d.getTime() + MINUTE);
+		default: return new Date(d.getTime() + SECOND);
+	}
+	return d;
+}
+/** The ticks of `interval` from `lo` to `hi` (ms), both ends included when they fall on one. */
+function timeTicks(lo, hi, interval) {
+	const ticks = [];
+	if (!(hi >= lo)) return ticks;
+	let date = floorTime(lo, interval.unit);
+	for (let guard = 0; guard < 1e4 && date.getTime() <= hi; guard++) {
+		if (date.getTime() >= lo && aligned(date, interval)) ticks.push(date.getTime());
+		date = next(date, interval.unit);
+	}
+	return ticks;
+}
+/** The next unit up, whose boundaries a tick label marks with more context. */
+function parentUnit(unit) {
+	switch (unit) {
+		case "second": return "minute";
+		case "minute":
+		case "hour": return "day";
+		case "day":
+		case "week": return "month";
+		case "month": return "year";
+		default: return null;
+	}
+}
+/** Whether `time` is the very start of a `unit`. */
+function startsUnit(time, unit) {
+	return floorTime(time, unit).getTime() === time;
+}
+export { floorTime, parentUnit, startsUnit, timeInterval, timeTicks };
+
+//# sourceMappingURL=time.js.map

package/dist/core/time.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"time.js","names":[],"sources":["../../src/core/time.ts"],"sourcesContent":["/**\n * Ticks on a time axis, at round points of local time: whole minutes,\n * midnights, the first of a month. The step is the smallest one that\n * gives no more than the wanted number of ticks.\n */\n\nexport type TimeUnit = 'second' | 'minute' | 'hour' | 'day' | 'week' | 'month' | 'year'\n\nexport interface TimeInterval {\n  unit: TimeUnit\n  every: number\n}\n\nconst SECOND = 1000\nconst MINUTE = 60 * SECOND\nconst HOUR = 60 * MINUTE\nconst DAY = 24 * HOUR\n\nconst INTERVALS: Array<[TimeUnit, number, number]> = [\n  ['second', 1, SECOND],\n  ['second', 5, 5 * SECOND],\n  ['second', 15, 15 * SECOND],\n  ['second', 30, 30 * SECOND],\n  ['minute', 1, MINUTE],\n  ['minute', 2, 2 * MINUTE],\n  ['minute', 5, 5 * MINUTE],\n  ['minute', 10, 10 * MINUTE],\n  ['minute', 15, 15 * MINUTE],\n  ['minute', 30, 30 * MINUTE],\n  ['hour', 1, HOUR],\n  ['hour', 2, 2 * HOUR],\n  ['hour', 3, 3 * HOUR],\n  ['hour', 6, 6 * HOUR],\n  ['hour', 12, 12 * HOUR],\n  ['day', 1, DAY],\n  ['day', 2, 2 * DAY],\n  ['week', 1, 7 * DAY],\n  ['week', 2, 14 * DAY],\n  ['month', 1, 30 * DAY],\n  ['month', 3, 91 * DAY],\n  ['month', 6, 182 * DAY],\n  ['year', 1, 365 * DAY],\n]\n\n/** The smallest interval that gives at most `count` ticks across `span` ms. */\nexport function timeInterval(span: number, count: number): TimeInterval {\n  for (const [unit, every, length] of INTERVALS) {\n    if (span / length <= Math.max(1, count)) return { unit, every }\n  }\n  // whole years, a nice number of them\n  const years = span / (365 * DAY) / Math.max(1, count)\n  const power = 10 ** Math.floor(Math.log10(years))\n  const fraction = years / power\n  return {\n    unit: 'year',\n    every: (fraction <= 1 ? 1 : fraction <= 2 ? 2 : fraction <= 5 ? 5 : 10) * power,\n  }\n}\n\n/** The start of the `unit` that `time` falls in (weeks start on Monday). */\nexport function floorTime(time: number, unit: TimeUnit): Date {\n  const d = new Date(time)\n  switch (unit) {\n    case 'year':\n      return new Date(d.getFullYear(), 0, 1)\n    case 'month':\n      return new Date(d.getFullYear(), d.getMonth(), 1)\n    case 'week': {\n      const back = (d.getDay() + 6) % 7\n      return new Date(d.getFullYear(), d.getMonth(), d.getDate() - back)\n    }\n    case 'day':\n      return new Date(d.getFullYear(), d.getMonth(), d.getDate())\n    case 'hour':\n      return new Date(d.getFullYear(), d.getMonth(), d.getDate(), d.getHours())\n    case 'minute':\n      return new Date(d.getFullYear(), d.getMonth(), d.getDate(), d.getHours(), d.getMinutes())\n    default:\n      return new Date(Math.floor(time / SECOND) * SECOND)\n  }\n}\n\n/** Whether `date` is on a multiple of `every` within the next unit up, so steps line up. */\nfunction aligned(date: Date, { unit, every }: TimeInterval): boolean {\n  if (every === 1) return true\n  switch (unit) {\n    case 'year':\n      return date.getFullYear() % every === 0\n    case 'month':\n      return date.getMonth() % every === 0\n    case 'day':\n      return (date.getDate() - 1) % every === 0 && date.getDate() + every - 1 <= 31\n    case 'hour':\n      return date.getHours() % every === 0\n    case 'minute':\n      return date.getMinutes() % every === 0\n    case 'second':\n      return date.getSeconds() % every === 0\n    case 'week':\n      // counted from a Monday long ago, so the same weeks are picked whatever is shown\n      return Math.round((date.getTime() - new Date(1970, 0, 5).getTime()) / (7 * DAY)) % every === 0\n    default:\n      return true\n  }\n}\n\nfunction next(date: Date, unit: TimeUnit): Date {\n  const d = new Date(date)\n  switch (unit) {\n    case 'year':\n      d.setFullYear(d.getFullYear() + 1)\n      break\n    case 'month':\n      d.setMonth(d.getMonth() + 1)\n      break\n    case 'week':\n      d.setDate(d.getDate() + 7)\n      break\n    case 'day':\n      d.setDate(d.getDate() + 1)\n      break\n    case 'hour':\n      // by the clock, so a daylight saving change doesn't shift every tick after it\n      return new Date(d.getTime() + HOUR)\n    case 'minute':\n      return new Date(d.getTime() + MINUTE)\n    default:\n      return new Date(d.getTime() + SECOND)\n  }\n  return d\n}\n\n/** The ticks of `interval` from `lo` to `hi` (ms), both ends included when they fall on one. */\nexport function timeTicks(lo: number, hi: number, interval: TimeInterval): number[] {\n  const ticks: number[] = []\n  if (!(hi >= lo)) return ticks\n  let date = floorTime(lo, interval.unit)\n  // a guard against runaway loops on absurd spans\n  for (let guard = 0; guard < 10000 && date.getTime() <= hi; guard++) {\n    if (date.getTime() >= lo && aligned(date, interval)) ticks.push(date.getTime())\n    date = next(date, interval.unit)\n  }\n  return ticks\n}\n\n/** The next unit up, whose boundaries a tick label marks with more context. */\nexport function parentUnit(unit: TimeUnit): TimeUnit | null {\n  switch (unit) {\n    case 'second':\n      return 'minute'\n    case 'minute':\n    case 'hour':\n      return 'day'\n    case 'day':\n    case 'week':\n      return 'month'\n    case 'month':\n      return 'year'\n    default:\n      return null\n  }\n}\n\n/** Whether `time` is the very start of a `unit`. */\nexport function startsUnit(time: number, unit: TimeUnit): boolean {\n  return floorTime(time, unit).getTime() === time\n}\n"],"mappings":"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"}

package/dist/core/tree.js

@@ -0,0 +1,348 @@
+import { read } from "./data.js";
+// src/core/tree.ts
+/** The tree read from nested rows, and its nodes walked parents first; nodes without value are left out. */
+function buildTree(data, { label, value, children }) {
+	const make = (row, place, depth, parent) => ({
+		index: -1,
+		name: row ? String(read(row, label, place) ?? "") : "",
+		value: 0,
+		depth,
+		parent,
+		children: [],
+		row,
+		place,
+		group: -1,
+		x0: 0,
+		y0: 0,
+		x1: 0,
+		y1: 0
+	});
+	const root = make(null, -1, 0, null);
+	const grow = (node, rows) => {
+		if (!Array.isArray(rows)) return;
+		rows.forEach((row, i) => {
+			const child = make(row, i, node.depth + 1, node);
+			const kids = read(row, children, i);
+			if (Array.isArray(kids) && kids.length) grow(child, kids);
+			if (child.children.length) child.value = child.children.reduce((sum, c) => sum + c.value, 0);
+			else {
+				const own = Number(read(row, value, i));
+				child.value = Number.isFinite(own) && own > 0 ? own : 0;
+			}
+			if (child.value > 0) node.children.push(child);
+		});
+	};
+	grow(root, data);
+	root.value = root.children.reduce((sum, c) => sum + c.value, 0);
+	const nodes = [];
+	const walk = (node) => {
+		node.index = nodes.length;
+		nodes.push(node);
+		for (const child of node.children) walk(child);
+	};
+	root.children.forEach((top, k) => {
+		const mark = (node) => {
+			node.group = k;
+			node.children.forEach(mark);
+		};
+		mark(top);
+	});
+	walk(root);
+	return {
+		root,
+		nodes
+	};
+}
+/** The names from the top level down to `node`. */
+function treePath(node) {
+	const out = [];
+	for (let at = node; at && at.depth > 0; at = at.parent) out.unshift(at.name);
+	return out;
+}
+/** Room around a group's children, in px. */
+var TREE_PAD = 2;
+/** The smallest group that gets a header of its own, in px. */
+var HEADED = {
+	width: 56,
+	height: 52
+};
+/**
+* Lays the treemap out in `rect`: each node's rectangle as near a square
+* as can be (the squarified layout), largest first, children inside their
+* group below its header.
+*/
+function layoutTreemap(root, rect) {
+	root.x0 = rect.x;
+	root.y0 = rect.y;
+	root.x1 = rect.x + rect.width;
+	root.y1 = rect.y + rect.height;
+	const place = (node) => {
+		if (!node.children.length) return;
+		let { x0, y0, x1, y1 } = node;
+		if (node.depth > 0) {
+			const headed = x1 - x0 >= HEADED.width && y1 - y0 >= HEADED.height;
+			x0 += TREE_PAD;
+			x1 -= TREE_PAD;
+			y0 += headed ? 20 : TREE_PAD;
+			y1 -= TREE_PAD;
+		}
+		squarify(node.children, x0, y0, Math.max(0, x1 - x0), Math.max(0, y1 - y0));
+		node.children.forEach(place);
+	};
+	place(root);
+}
+/** Whether a treemap group has room for its header (see `layoutTreemap`). */
+function hasHeader(node) {
+	return node.depth > 0 && node.children.length > 0 && node.x1 - node.x0 >= HEADED.width && node.y1 - node.y0 >= HEADED.height;
+}
+function squarify(nodes, x, y, width, height) {
+	const list = [...nodes];
+	list.sort((a, b) => b.value - a.value);
+	const total = list.reduce((sum, n) => sum + n.value, 0);
+	if (!(total > 0) || !(width > 0) || !(height > 0)) {
+		for (const n of list) [n.x0, n.y0, n.x1, n.y1] = [
+			x,
+			y,
+			x,
+			y
+		];
+		return;
+	}
+	const scale = width * height / total;
+	let i = 0;
+	while (i < list.length) {
+		const short = Math.min(width, height);
+		let row = [list[i]];
+		let sum = list[i].value * scale;
+		let worst = ratio(row, sum, short, scale);
+		let j = i + 1;
+		while (j < list.length) {
+			const next = [...row, list[j]];
+			const nextSum = sum + list[j].value * scale;
+			const w = ratio(next, nextSum, short, scale);
+			if (w > worst) break;
+			row = next;
+			sum = nextSum;
+			worst = w;
+			j++;
+		}
+		const thick = sum / short;
+		let at = 0;
+		for (const n of row) {
+			const length = n.value * scale / thick;
+			if (width >= height) [n.x0, n.y0, n.x1, n.y1] = [
+				x,
+				y + at,
+				x + thick,
+				y + at + length
+			];
+			else [n.x0, n.y0, n.x1, n.y1] = [
+				x + at,
+				y,
+				x + at + length,
+				y + thick
+			];
+			at += length;
+		}
+		if (width >= height) {
+			x += thick;
+			width -= thick;
+		} else {
+			y += thick;
+			height -= thick;
+		}
+		i = j;
+	}
+}
+/** The worst (largest) side ratio of the rectangles of a row laid along a side `short` long. */
+function ratio(row, sum, short, scale) {
+	let lo = Infinity;
+	let hi = 0;
+	for (const n of row) {
+		const area = n.value * scale;
+		if (area < lo) lo = area;
+		if (area > hi) hi = area;
+	}
+	const s2 = sum * sum;
+	const w2 = short * short;
+	return Math.max(w2 * hi / s2, s2 / (w2 * lo));
+}
+/** The deepest node of a treemap under `(px, py)`. */
+function treemapAt(root, px, py) {
+	let found = null;
+	let at = root;
+	while (at) {
+		const inside = at.children.find((c) => px >= c.x0 && px < c.x1 && py >= c.y0 && py < c.y1);
+		if (!inside) break;
+		found = inside;
+		at = inside;
+	}
+	return found;
+}
+/**
+* Draws a treemap: a leaf filled with its color, a group a light wash of
+* it under its children. `focus` (a node's index) is ringed.
+*/
+function drawTreemap(painter, nodes, colors, { surface, ring, focus = -1, t = 1 }) {
+	painter.save();
+	painter.globalAlpha *= t;
+	for (const node of nodes) {
+		if (node.depth === 0) continue;
+		const w = node.x1 - node.x0;
+		const h = node.y1 - node.y0;
+		if (w < 1 || h < 1) continue;
+		painter.beginPath();
+		roundRect(painter, node.x0, node.y0, w, h, w > 8 && h > 8 ? 4 : 0);
+		if (node.children.length) {
+			painter.save();
+			painter.fillStyle = colors[node.index];
+			painter.globalAlpha *= .14;
+			painter.fill();
+			painter.restore();
+		} else {
+			painter.fillStyle = colors[node.index];
+			painter.fill();
+		}
+	}
+	painter.strokeStyle = surface;
+	painter.lineWidth = 1;
+	painter.beginPath();
+	for (const node of nodes) {
+		if (node.depth === 0) continue;
+		const w = node.x1 - node.x0;
+		const h = node.y1 - node.y0;
+		if (w > 2 && h > 2) roundRect(painter, node.x0 + .5, node.y0 + .5, w - 1, h - 1, w > 8 && h > 8 ? 3.5 : 0);
+	}
+	painter.stroke();
+	painter.restore();
+	if (focus >= 0) ringTreemap(painter, nodes[focus], ring);
+}
+/** Rings a treemap's node: the one under the pointer or picked with the keys. */
+function ringTreemap(painter, node, ring) {
+	if (!node || node.depth === 0) return;
+	painter.save();
+	painter.strokeStyle = ring;
+	painter.lineWidth = 2;
+	painter.beginPath();
+	roundRect(painter, node.x0 + 1, node.y0 + 1, node.x1 - node.x0 - 2, node.y1 - node.y0 - 2, 3);
+	painter.stroke();
+	painter.restore();
+}
+function roundRect(painter, x, y, w, h, r) {
+	if (w <= 0 || h <= 0) return;
+	r = Math.max(0, Math.min(r, w / 2, h / 2));
+	if (r < .5) {
+		painter.rect(x, y, w, h);
+		return;
+	}
+	painter.moveTo(x + r, y);
+	painter.arcTo(x + w, y, x + w, y + h, r);
+	painter.arcTo(x + w, y + h, x, y + h, r);
+	painter.arcTo(x, y + h, x, y, r);
+	painter.arcTo(x, y, x + w, y, r);
+	painter.closePath();
+}
+/**
+* Lays a sunburst out round `(cx, cy)`: the top level in the ring just out
+* of the hole (`inner`), each level a ring further out to `radius`; each
+* node's arc a share of its parent's as its value is of the parent's.
+* Angles run clockwise from 12 o'clock.
+*/
+function layoutSunburst(root, inner, radius) {
+	let depth = 0;
+	const deepest = (node) => {
+		if (node.depth > depth) depth = node.depth;
+		node.children.forEach(deepest);
+	};
+	deepest(root);
+	const ring = depth ? (radius - inner) / depth : 0;
+	root.x0 = 0;
+	root.x1 = Math.PI * 2;
+	root.y0 = 0;
+	root.y1 = inner;
+	const place = (node) => {
+		let angle = node.x0;
+		const span = node.x1 - node.x0;
+		for (const child of node.children) {
+			child.x0 = angle;
+			angle += node.value > 0 ? child.value / node.value * span : 0;
+			child.x1 = angle;
+			child.y0 = inner + (child.depth - 1) * ring;
+			child.y1 = child.y0 + ring;
+			place(child);
+		}
+	};
+	place(root);
+}
+/** The node of a sunburst under the angle `angle` (clockwise from 12 o'clock) and radius `r`. */
+function sunburstAt(root, angle, r) {
+	let at = root;
+	while (at) {
+		const inside = at.children.find((c) => angle >= c.x0 && angle < c.x1);
+		if (!inside) return null;
+		if (r >= inside.y0 && r < inside.y1) return inside;
+		at = inside;
+	}
+	return null;
+}
+/** The gap between a sunburst's arcs, in px. */
+var ARC_GAP = 1.5;
+/**
+* Draws a sunburst round `(cx, cy)`, sweeping in with `sweep` (0 to 1).
+* Nodes other than `focus`, its ancestors and its descendants are faded.
+*/
+/** How much of a sunburst shows off the branch pointed at. */
+var SUNBURST_FADE = .4;
+/** A node with its ancestors and all its descendants: what stays lit when it is pointed at. */
+function sunburstBranch(node) {
+	const out = [];
+	for (let a = node.parent; a; a = a.parent) out.push(a);
+	const stack = [node];
+	while (stack.length) {
+		const n = stack.pop();
+		out.push(n);
+		for (const c of n.children) stack.push(c);
+	}
+	return out;
+}
+function drawSunburst(painter, nodes, colors, { cx, cy, surface, focus = -1, sweep = 1 }) {
+	const at = (angle) => angle * sweep - Math.PI / 2;
+	const focused = nodes[focus];
+	const lit = (node) => {
+		if (!focused) return true;
+		for (let a = node; a; a = a.parent) if (a === focused) return true;
+		for (let a = focused; a; a = a.parent) if (a === node) return true;
+		return false;
+	};
+	painter.save();
+	for (const node of nodes) {
+		if (node.depth === 0 || !(node.x1 > node.x0)) continue;
+		painter.save();
+		if (!lit(node)) painter.globalAlpha *= SUNBURST_FADE;
+		painter.fillStyle = colors[node.index];
+		painter.beginPath();
+		painter.arc(cx, cy, node.y1, at(node.x0), at(node.x1));
+		painter.arc(cx, cy, node.y0, at(node.x1), at(node.x0), true);
+		painter.closePath();
+		painter.fill();
+		painter.restore();
+	}
+	painter.strokeStyle = surface;
+	painter.lineWidth = ARC_GAP;
+	painter.beginPath();
+	for (const node of nodes) {
+		if (node.depth === 0 || !(node.x1 > node.x0)) continue;
+		const a = at(node.x0);
+		if ((node.x1 - node.x0) * sweep * node.y1 >= ARC_GAP * 3 || !node.parent || node.parent.depth === 0 || node.x0 === node.parent.x0) {
+			painter.moveTo(cx + Math.cos(a) * node.y0, cy + Math.sin(a) * node.y0);
+			painter.lineTo(cx + Math.cos(a) * node.y1, cy + Math.sin(a) * node.y1);
+		}
+		painter.moveTo(cx + Math.cos(at(node.x0)) * node.y0, cy + Math.sin(at(node.x0)) * node.y0);
+		painter.arc(cx, cy, node.y0, at(node.x0), at(node.x1));
+	}
+	painter.stroke();
+	painter.restore();
+}
+export { SUNBURST_FADE, buildTree, drawSunburst, drawTreemap, hasHeader, layoutSunburst, layoutTreemap, ringTreemap, sunburstAt, sunburstBranch, treePath, treemapAt };
+
+//# sourceMappingURL=tree.js.map

package/dist/core/tree.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree.js","names":[],"sources":["../../src/core/tree.ts"],"sourcesContent":["import { read, type ChartAccessor, type ChartRow } from './data'\nimport type { Painter, Rect } from './painter'\n\n/*\n * Charts of a tree: what a whole is made of, level by level. A treemap\n * fills a rectangle, each node a rectangle as large as its value, its\n * children inside it; a sunburst draws rings out from a center, each node\n * an arc of its parent's, one ring per level.\n */\n\nexport interface TreeNode {\n  /** Its place in `nodes`, in the order the tree is walked (parents first). */\n  index: number\n  name: string\n  /** Its own value (a leaf's), or the sum of its children's. */\n  value: number\n  /** 1 for the top level: the root, which holds the whole, is 0. */\n  depth: number\n  parent: TreeNode | null\n  children: TreeNode[]\n  /** The row it was read from; the root has none. */\n  row: ChartRow | null\n  /** Its row's place among its siblings' rows, as accessors are given it. */\n  place: number\n  /** The place of its top-level node among the top level, which picks its color. */\n  group: number\n  /** A treemap's rectangle, or a sunburst's arc (angles and radii). */\n  x0: number\n  y0: number\n  x1: number\n  y1: number\n}\n\nexport interface TreeAccessors {\n  label: ChartAccessor\n  value: ChartAccessor\n  children: ChartAccessor\n}\n\n/** The tree read from nested rows, and its nodes walked parents first; nodes without value are left out. */\nexport function buildTree(\n  data: readonly ChartRow[] | undefined,\n  { label, value, children }: TreeAccessors,\n): { root: TreeNode; nodes: TreeNode[] } {\n  const make = (\n    row: ChartRow | null,\n    place: number,\n    depth: number,\n    parent: TreeNode | null,\n  ): TreeNode => ({\n    index: -1,\n    name: row ? String(read(row, label, place) ?? '') : '',\n    value: 0,\n    depth,\n    parent,\n    children: [],\n    row,\n    place,\n    group: -1,\n    x0: 0,\n    y0: 0,\n    x1: 0,\n    y1: 0,\n  })\n  const root = make(null, -1, 0, null)\n  const grow = (node: TreeNode, rows: unknown) => {\n    if (!Array.isArray(rows)) return\n    rows.forEach((row: ChartRow, i) => {\n      const child = make(row, i, node.depth + 1, node)\n      const kids = read(row, children, i)\n      if (Array.isArray(kids) && kids.length) grow(child, kids)\n      if (child.children.length) child.value = child.children.reduce((sum, c) => sum + c.value, 0)\n      else {\n        const own = Number(read(row, value, i))\n        child.value = Number.isFinite(own) && own > 0 ? own : 0\n      }\n      if (child.value > 0) node.children.push(child)\n    })\n  }\n  grow(root, data)\n  root.value = root.children.reduce((sum, c) => sum + c.value, 0)\n  const nodes: TreeNode[] = []\n  const walk = (node: TreeNode) => {\n    node.index = nodes.length\n    nodes.push(node)\n    for (const child of node.children) walk(child)\n  }\n  root.children.forEach((top, k) => {\n    const mark = (node: TreeNode) => {\n      node.group = k\n      node.children.forEach(mark)\n    }\n    mark(top)\n  })\n  walk(root)\n  return { root, nodes }\n}\n\n/** The names from the top level down to `node`. */\nexport function treePath(node: TreeNode): string[] {\n  const out: string[] = []\n  for (let at: TreeNode | null = node; at && at.depth > 0; at = at.parent) out.unshift(at.name)\n  return out\n}\n\n/* the treemap */\n\n/** Room above a group's children for its name, in px. */\nexport const TREE_HEADER = 20\n/** Room around a group's children, in px. */\nconst TREE_PAD = 2\n/** The smallest group that gets a header of its own, in px. */\nconst HEADED = { width: 56, height: 52 }\n\n/**\n * Lays the treemap out in `rect`: each node's rectangle as near a square\n * as can be (the squarified layout), largest first, children inside their\n * group below its header.\n */\nexport function layoutTreemap(root: TreeNode, rect: Rect) {\n  root.x0 = rect.x\n  root.y0 = rect.y\n  root.x1 = rect.x + rect.width\n  root.y1 = rect.y + rect.height\n  const place = (node: TreeNode) => {\n    if (!node.children.length) return\n    let { x0, y0, x1, y1 } = node\n    if (node.depth > 0) {\n      const headed = x1 - x0 >= HEADED.width && y1 - y0 >= HEADED.height\n      x0 += TREE_PAD\n      x1 -= TREE_PAD\n      y0 += headed ? TREE_HEADER : TREE_PAD\n      y1 -= TREE_PAD\n    }\n    squarify(node.children, x0, y0, Math.max(0, x1 - x0), Math.max(0, y1 - y0))\n    node.children.forEach(place)\n  }\n  place(root)\n}\n\n/** Whether a treemap group has room for its header (see `layoutTreemap`). */\nexport function hasHeader(node: TreeNode) {\n  return (\n    node.depth > 0 &&\n    node.children.length > 0 &&\n    node.x1 - node.x0 >= HEADED.width &&\n    node.y1 - node.y0 >= HEADED.height\n  )\n}\n\nfunction squarify(nodes: TreeNode[], x: number, y: number, width: number, height: number) {\n  const list = [...nodes]\n  list.sort((a, b) => b.value - a.value)\n  const total = list.reduce((sum, n) => sum + n.value, 0)\n  if (!(total > 0) || !(width > 0) || !(height > 0)) {\n    for (const n of list) [n.x0, n.y0, n.x1, n.y1] = [x, y, x, y]\n    return\n  }\n  // area per unit of value\n  const scale = (width * height) / total\n  let i = 0\n  while (i < list.length) {\n    const short = Math.min(width, height)\n    // add to the row while it makes its worst rectangle squarer\n    let row = [list[i]!]\n    let sum = list[i]!.value * scale\n    let worst = ratio(row, sum, short, scale)\n    let j = i + 1\n    while (j < list.length) {\n      const next = [...row, list[j]!]\n      const nextSum = sum + list[j]!.value * scale\n      const w = ratio(next, nextSum, short, scale)\n      if (w > worst) break\n      row = next\n      sum = nextSum\n      worst = w\n      j++\n    }\n    // the row along the short side, as thick as it needs\n    const thick = sum / short\n    let at = 0\n    for (const n of row) {\n      const length = (n.value * scale) / thick\n      if (width >= height) [n.x0, n.y0, n.x1, n.y1] = [x, y + at, x + thick, y + at + length]\n      else [n.x0, n.y0, n.x1, n.y1] = [x + at, y, x + at + length, y + thick]\n      at += length\n    }\n    if (width >= height) {\n      x += thick\n      width -= thick\n    } else {\n      y += thick\n      height -= thick\n    }\n    i = j\n  }\n}\n\n/** The worst (largest) side ratio of the rectangles of a row laid along a side `short` long. */\nfunction ratio(row: TreeNode[], sum: number, short: number, scale: number) {\n  let lo = Infinity\n  let hi = 0\n  for (const n of row) {\n    const area = n.value * scale\n    if (area < lo) lo = area\n    if (area > hi) hi = area\n  }\n  const s2 = sum * sum\n  const w2 = short * short\n  return Math.max((w2 * hi) / s2, s2 / (w2 * lo))\n}\n\n/** The deepest node of a treemap under `(px, py)`. */\nexport function treemapAt(root: TreeNode, px: number, py: number): TreeNode | null {\n  let found: TreeNode | null = null\n  let at: TreeNode | undefined = root\n  while (at) {\n    const inside: TreeNode | undefined = at.children.find(\n      (c) => px >= c.x0 && px < c.x1 && py >= c.y0 && py < c.y1,\n    )\n    if (!inside) break\n    found = inside\n    at = inside\n  }\n  return found\n}\n\n/**\n * Draws a treemap: a leaf filled with its color, a group a light wash of\n * it under its children. `focus` (a node's index) is ringed.\n */\nexport function drawTreemap(\n  painter: Painter,\n  nodes: TreeNode[],\n  colors: string[],\n  {\n    surface,\n    ring,\n    focus = -1,\n    t = 1,\n  }: { surface: string; ring: string; focus?: number; t?: number },\n) {\n  painter.save()\n  painter.globalAlpha *= t\n  for (const node of nodes) {\n    if (node.depth === 0) continue\n    const w = node.x1 - node.x0\n    const h = node.y1 - node.y0\n    // under a pixel: nothing to see, and very many of them are slow to draw\n    if (w < 1 || h < 1) continue\n    painter.beginPath()\n    roundRect(painter, node.x0, node.y0, w, h, w > 8 && h > 8 ? 4 : 0)\n    if (node.children.length) {\n      painter.save()\n      painter.fillStyle = colors[node.index]!\n      painter.globalAlpha *= 0.14\n      painter.fill()\n      painter.restore()\n    } else {\n      painter.fillStyle = colors[node.index]!\n      painter.fill()\n    }\n  }\n  // a hairline of the surface between neighbors, groups and leaves alike\n  painter.strokeStyle = surface\n  painter.lineWidth = 1\n  painter.beginPath()\n  for (const node of nodes) {\n    if (node.depth === 0) continue\n    const w = node.x1 - node.x0\n    const h = node.y1 - node.y0\n    // square corners on small ones: rounding thousands of them is slow, and unseen\n    if (w > 2 && h > 2)\n      roundRect(painter, node.x0 + 0.5, node.y0 + 0.5, w - 1, h - 1, w > 8 && h > 8 ? 3.5 : 0)\n  }\n  painter.stroke()\n  painter.restore()\n  if (focus >= 0) ringTreemap(painter, nodes[focus], ring)\n}\n\n/** Rings a treemap's node: the one under the pointer or picked with the keys. */\nexport function ringTreemap(painter: Painter, node: TreeNode | undefined, ring: string) {\n  if (!node || node.depth === 0) return\n  painter.save()\n  painter.strokeStyle = ring\n  painter.lineWidth = 2\n  painter.beginPath()\n  roundRect(painter, node.x0 + 1, node.y0 + 1, node.x1 - node.x0 - 2, node.y1 - node.y0 - 2, 3)\n  painter.stroke()\n  painter.restore()\n}\n\nfunction roundRect(painter: Painter, x: number, y: number, w: number, h: number, r: number) {\n  if (w <= 0 || h <= 0) return\n  r = Math.max(0, Math.min(r, w / 2, h / 2))\n  if (r < 0.5) {\n    painter.rect(x, y, w, h)\n    return\n  }\n  painter.moveTo(x + r, y)\n  painter.arcTo(x + w, y, x + w, y + h, r)\n  painter.arcTo(x + w, y + h, x, y + h, r)\n  painter.arcTo(x, y + h, x, y, r)\n  painter.arcTo(x, y, x + w, y, r)\n  painter.closePath()\n}\n\n/* the sunburst */\n\n/**\n * Lays a sunburst out round `(cx, cy)`: the top level in the ring just out\n * of the hole (`inner`), each level a ring further out to `radius`; each\n * node's arc a share of its parent's as its value is of the parent's.\n * Angles run clockwise from 12 o'clock.\n */\nexport function layoutSunburst(root: TreeNode, inner: number, radius: number) {\n  let depth = 0\n  const deepest = (node: TreeNode) => {\n    if (node.depth > depth) depth = node.depth\n    node.children.forEach(deepest)\n  }\n  deepest(root)\n  const ring = depth ? (radius - inner) / depth : 0\n  root.x0 = 0\n  root.x1 = Math.PI * 2\n  root.y0 = 0\n  root.y1 = inner\n  const place = (node: TreeNode) => {\n    let angle = node.x0\n    const span = node.x1 - node.x0\n    for (const child of node.children) {\n      child.x0 = angle\n      angle += node.value > 0 ? (child.value / node.value) * span : 0\n      child.x1 = angle\n      child.y0 = inner + (child.depth - 1) * ring\n      child.y1 = child.y0 + ring\n      place(child)\n    }\n  }\n  place(root)\n}\n\n/** The node of a sunburst under the angle `angle` (clockwise from 12 o'clock) and radius `r`. */\nexport function sunburstAt(root: TreeNode, angle: number, r: number): TreeNode | null {\n  let at: TreeNode | undefined = root\n  while (at) {\n    const inside: TreeNode | undefined = at.children.find((c) => angle >= c.x0 && angle < c.x1)\n    if (!inside) return null\n    if (r >= inside.y0 && r < inside.y1) return inside\n    at = inside\n  }\n  return null\n}\n\n/** The gap between a sunburst's arcs, in px. */\nconst ARC_GAP = 1.5\n\n/**\n * Draws a sunburst round `(cx, cy)`, sweeping in with `sweep` (0 to 1).\n * Nodes other than `focus`, its ancestors and its descendants are faded.\n */\n/** How much of a sunburst shows off the branch pointed at. */\nexport const SUNBURST_FADE = 0.4\n\n/** A node with its ancestors and all its descendants: what stays lit when it is pointed at. */\nexport function sunburstBranch(node: TreeNode): TreeNode[] {\n  const out: TreeNode[] = []\n  for (let a = node.parent; a; a = a.parent) out.push(a)\n  const stack = [node]\n  while (stack.length) {\n    const n = stack.pop()!\n    out.push(n)\n    for (const c of n.children) stack.push(c)\n  }\n  return out\n}\n\nexport function drawSunburst(\n  painter: Painter,\n  nodes: TreeNode[],\n  colors: string[],\n  {\n    cx,\n    cy,\n    surface,\n    focus = -1,\n    sweep = 1,\n  }: { cx: number; cy: number; surface: string; focus?: number; sweep?: number },\n) {\n  const at = (angle: number) => angle * sweep - Math.PI / 2\n  const focused = nodes[focus]\n  const lit = (node: TreeNode) => {\n    if (!focused) return true\n    for (let a: TreeNode | null = node; a; a = a.parent) if (a === focused) return true\n    for (let a: TreeNode | null = focused; a; a = a.parent) if (a === node) return true\n    return false\n  }\n  painter.save()\n  for (const node of nodes) {\n    if (node.depth === 0 || !(node.x1 > node.x0)) continue\n    painter.save()\n    if (!lit(node)) painter.globalAlpha *= SUNBURST_FADE\n    painter.fillStyle = colors[node.index]!\n    painter.beginPath()\n    painter.arc(cx, cy, node.y1, at(node.x0), at(node.x1))\n    painter.arc(cx, cy, node.y0, at(node.x1), at(node.x0), true)\n    painter.closePath()\n    painter.fill()\n    painter.restore()\n  }\n  // the gaps: rings and spokes of the surface's color\n  painter.strokeStyle = surface\n  painter.lineWidth = ARC_GAP\n  painter.beginPath()\n  for (const node of nodes) {\n    if (node.depth === 0 || !(node.x1 > node.x0)) continue\n    const a = at(node.x0)\n    // arcs too thin to show beside a gap run together, but a group's edge stays\n    const wide = (node.x1 - node.x0) * sweep * node.y1 >= ARC_GAP * 3\n    if (wide || !node.parent || node.parent.depth === 0 || node.x0 === node.parent.x0) {\n      painter.moveTo(cx + Math.cos(a) * node.y0, cy + Math.sin(a) * node.y0)\n      painter.lineTo(cx + Math.cos(a) * node.y1, cy + Math.sin(a) * node.y1)\n    }\n    painter.moveTo(cx + Math.cos(at(node.x0)) * node.y0, cy + Math.sin(at(node.x0)) * node.y0)\n    painter.arc(cx, cy, node.y0, at(node.x0), at(node.x1))\n  }\n  painter.stroke()\n  painter.restore()\n}\n"],"mappings":"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"}

package/dist/core/warn.js

@@ -0,0 +1,11 @@
+// src/core/warn.ts
+var warned = /* @__PURE__ */ new Set();
+/** A warning in development, once per kind of mistake. */
+function warnOnce(key, text) {
+	if (process.env.NODE_ENV === "production" || warned.has(key)) return;
+	warned.add(key);
+	console.warn(`[@dou-ui/chart] ${text}`);
+}
+export { warnOnce };
+
+//# sourceMappingURL=warn.js.map

package/dist/core/warn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"warn.js","names":[],"sources":["../../src/core/warn.ts"],"sourcesContent":["const warned = new Set<string>()\n/** A warning in development, once per kind of mistake. */\nexport function warnOnce(key: string, text: string) {\n  // the app's bundler replaces this, as for Vue's own warnings\n  if (process.env.NODE_ENV === 'production' || warned.has(key)) return\n  warned.add(key)\n  console.warn(`[@dou-ui/chart] ${text}`)\n}\n\n/** Forgets what was warned about, so a test sees each warning afresh. */\nexport function forgetWarnings() {\n  warned.clear()\n}\n"],"mappings":";AAAA,IAAM,yBAAS,IAAI,IAAY;;AAE/B,SAAgB,SAAS,KAAa,MAAc;CAElD,IAAA,QAAA,IAAA,aAA6B,gBAAgB,OAAO,IAAI,GAAG,GAAG;CAC9D,OAAO,IAAI,GAAG;CACd,QAAQ,KAAK,mBAAmB,MAAM;AACxC"}