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

package/dist/core/histogram.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"histogram.js","names":[],"sources":["../../src/core/histogram.ts"],"sourcesContent":["import { barLabels, drawBars, type BarStyle } from './bar'\nimport { warnOnce } from './warn'\nimport { nextNiceStep, niceStep } from './scale'\nimport type { ChartSeriesKind, ChartView } from './series'\n\n/** The most bins a histogram has: more would be thinner than a pixel, and slow. */\nexport const MAX_BINS = 1000\n\n/*\n * A histogram: values counted into bins of equal width, and a bar for each\n * bin across all of it, so the bars stand side by side with only a\n * hairline between them. The bins' edges are round numbers.\n */\n\nexport interface HistogramBin {\n  /** Where the bin starts, inclusive. */\n  x0: number\n  /** Where it ends: exclusive, but for the last bin. */\n  x1: number\n  /** Its middle, where the bar is placed. */\n  x: number\n  count: number\n}\n\n/**\n * Counts `values` into bins of width `step`, or of a round width giving\n * about `count` bins (by default, by the number of values: Sturges' rule).\n * Values that aren't numbers are left out.\n */\nexport function histogramBins(\n  values: ArrayLike<number>,\n  { count, step }: { count?: number; step?: number } = {},\n): HistogramBin[] {\n  let min = Infinity\n  let max = -Infinity\n  let n = 0\n  for (let i = 0; i < values.length; i++) {\n    const v = values[i]!\n    if (!Number.isFinite(v)) continue\n    n++\n    if (v < min) min = v\n    if (v > max) max = v\n  }\n  if (!n) return []\n  if (step !== undefined && !(step > 0))\n    warnOnce('histogram-step', `a histogram's \\`step\\` must be above 0; ${step} is left out.`)\n  let width =\n    step && step > 0\n      ? step\n      : max > min\n        ? niceStep(max - min, Math.min(MAX_BINS, Math.max(1, count ?? Math.ceil(Math.log2(n)) + 1)))\n        : 1\n  // too many bins to draw (or to hold): the narrowest round width that keeps within the most\n  if ((max - Math.floor(min / width) * width) / width > MAX_BINS) {\n    warnOnce(\n      'histogram-bins',\n      `a histogram's \\`step\\` of ${width} makes more than ${MAX_BINS} bins; they are widened.`,\n    )\n    width = niceStep(max - min, MAX_BINS / 2)\n    while ((max - Math.floor(min / width) * width) / width > MAX_BINS) width = nextNiceStep(width)\n  }\n  const start = Math.floor(min / width) * width\n  // the largest value falls in the last bin, which includes its end\n  const bins = Math.max(1, Math.ceil((max - start) / width - 1e-9))\n  const out: HistogramBin[] = []\n  for (let k = 0; k < bins; k++) {\n    // round each edge, so 0.1 steps give 0.3, not 0.30000000000000004\n    const x0 = round(start + k * width, width)\n    const x1 = round(start + (k + 1) * width, width)\n    out.push({ x0, x1, x: (x0 + x1) / 2, count: 0 })\n  }\n  for (let i = 0; i < values.length; i++) {\n    const v = values[i]!\n    if (!Number.isFinite(v)) continue\n    const k = Math.min(bins - 1, Math.floor((v - start) / width + 1e-9))\n    out[k]!.count++\n  }\n  return out\n}\n\nfunction round(value: number, step: number) {\n  const digits = Math.max(0, -Math.floor(Math.log10(step)) + 1)\n  return Number(value.toFixed(Math.min(20, digits)))\n}\n\n/** The bars across all of each bin, a hairline apart. */\nconst placement = (view: ChartView) => {\n  const gap = view.band > 4 ? 1 : 0\n  return { offset: -view.band / 2 + gap / 2, width: view.band - gap }\n}\n\nexport const histogramKind: ChartSeriesKind<BarStyle> = {\n  type: 'bar',\n  zero: true,\n  band: true,\n  draw: (painter, series, view) => drawBars(painter, series, view, placement(view)),\n  labels: (series, view) => barLabels(series, view, placement(view)),\n  xTitle: (series, row, text) => {\n    const bin = series.rows as unknown as HistogramBin[]\n    const b = bin[row]\n    return b ? `${text(b.x0)} – ${text(b.x1)}` : ''\n  },\n  xStep: (series) => {\n    const b = (series.rows as unknown as HistogramBin[])[0]\n    return b ? b.x1 - b.x0 : Number.NaN\n  },\n}\n"],"mappings":";;;;;AAMA,IAAa,WAAW;;;;;;AAuBxB,SAAgB,cACd,QACA,EAAE,OAAO,SAA4C,CAAC,GACtC;CAChB,IAAI,MAAM;CACV,IAAI,MAAM;CACV,IAAI,IAAI;CACR,KAAK,IAAI,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;EACtC,MAAM,IAAI,OAAO;EACjB,IAAI,CAAC,OAAO,SAAS,CAAC,GAAG;EACzB;EACA,IAAI,IAAI,KAAK,MAAM;EACnB,IAAI,IAAI,KAAK,MAAM;CACrB;CACA,IAAI,CAAC,GAAG,OAAO,CAAC;CAChB,IAAI,SAAS,KAAA,KAAa,EAAE,OAAO,IACjC,SAAS,kBAAkB,2CAA2C,KAAK,cAAc;CAC3F,IAAI,QACF,QAAQ,OAAO,IACX,OACA,MAAM,MACJ,SAAS,MAAM,KAAK,KAAK,IAAI,UAAU,KAAK,IAAI,GAAG,SAAS,KAAK,KAAK,KAAK,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IACzF;CAER,KAAK,MAAM,KAAK,MAAM,MAAM,KAAK,IAAI,SAAS,QAAA,KAAkB;EAC9D,SACE,kBACA,6BAA6B,MAAM,mBAAmB,SAAS,yBACjE;EACA,QAAQ,SAAS,MAAM,KAAK,WAAW,CAAC;EACxC,QAAQ,MAAM,KAAK,MAAM,MAAM,KAAK,IAAI,SAAS,QAAQ,UAAU,QAAQ,aAAa,KAAK;CAC/F;CACA,MAAM,QAAQ,KAAK,MAAM,MAAM,KAAK,IAAI;CAExC,MAAM,OAAO,KAAK,IAAI,GAAG,KAAK,MAAM,MAAM,SAAS,QAAQ,IAAI,CAAC;CAChE,MAAM,MAAsB,CAAC;CAC7B,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,KAAK;EAE7B,MAAM,KAAK,MAAM,QAAQ,IAAI,OAAO,KAAK;EACzC,MAAM,KAAK,MAAM,SAAS,IAAI,KAAK,OAAO,KAAK;EAC/C,IAAI,KAAK;GAAE;GAAI;GAAI,IAAI,KAAK,MAAM;GAAG,OAAO;EAAE,CAAC;CACjD;CACA,KAAK,IAAI,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;EACtC,MAAM,IAAI,OAAO;EACjB,IAAI,CAAC,OAAO,SAAS,CAAC,GAAG;EACzB,MAAM,IAAI,KAAK,IAAI,OAAO,GAAG,KAAK,OAAO,IAAI,SAAS,QAAQ,IAAI,CAAC;EACnE,IAAI,EAAE,CAAE;CACV;CACA,OAAO;AACT;AAEA,SAAS,MAAM,OAAe,MAAc;CAC1C,MAAM,SAAS,KAAK,IAAI,GAAG,CAAC,KAAK,MAAM,KAAK,MAAM,IAAI,CAAC,IAAI,CAAC;CAC5D,OAAO,OAAO,MAAM,QAAQ,KAAK,IAAI,IAAI,MAAM,CAAC,CAAC;AACnD;;AAGA,IAAM,aAAa,SAAoB;CACrC,MAAM,MAAM,KAAK,OAAO,IAAI,IAAI;CAChC,OAAO;EAAE,QAAQ,CAAC,KAAK,OAAO,IAAI,MAAM;EAAG,OAAO,KAAK,OAAO;CAAI;AACpE;AAEA,IAAa,gBAA2C;CACtD,MAAM;CACN,MAAM;CACN,MAAM;CACN,OAAO,SAAS,QAAQ,SAAS,SAAS,SAAS,QAAQ,MAAM,UAAU,IAAI,CAAC;CAChF,SAAS,QAAQ,SAAS,UAAU,QAAQ,MAAM,UAAU,IAAI,CAAC;CACjE,SAAS,QAAQ,KAAK,SAAS;EAE7B,MAAM,IADM,OAAO,KACL;EACd,OAAO,IAAI,GAAG,KAAK,EAAE,EAAE,EAAE,KAAK,KAAK,EAAE,EAAE,MAAM;CAC/C;CACA,QAAQ,WAAW;EACjB,MAAM,IAAK,OAAO,KAAmC;EACrD,OAAO,IAAI,EAAE,KAAK,EAAE,KAAK;CAC3B;AACF"}

package/dist/core/hit.js

@@ -0,0 +1,115 @@
+// src/core/hit.ts
+var orders = /* @__PURE__ */ new WeakMap();
+/** The indices of `values` from the smallest to the largest, `NaN` left out. Cached per array. */
+function sortedOrder(values) {
+	let order = orders.get(values);
+	if (!order) {
+		let n = 0;
+		for (let i = 0; i < values.length; i++) if (values[i] === values[i]) n++;
+		order = new Int32Array(n);
+		for (let i = 0, j = 0; i < values.length; i++) if (values[i] === values[i]) order[j++] = i;
+		let sorted = true;
+		for (let j = 1; j < n && sorted; j++) if (values[order[j]] < values[order[j - 1]]) sorted = false;
+		if (!sorted) order.sort((a, b) => values[a] - values[b]);
+		orders.set(values, order);
+	}
+	return order;
+}
+var identity = /* @__PURE__ */ new Int32Array(0);
+/**
+* Notes that `values` go up with no gaps, so their order is just
+* 0, 1, 2…: shared, so it costs nothing to make.
+*/
+function inOrder(values) {
+	const n = values.length;
+	if (identity.length < n) {
+		identity = new Int32Array(Math.max(n, identity.length * 2));
+		for (let i = 0; i < identity.length; i++) identity[i] = i;
+	}
+	orders.set(values, identity.subarray(0, n));
+}
+/** The position in `order` of the first value not below `value`. */
+function lowerBound(values, order, value) {
+	let lo = 0;
+	let hi = order.length;
+	while (lo < hi) {
+		const mid = lo + hi >> 1;
+		if (values[order[mid]] < value) lo = mid + 1;
+		else hi = mid;
+	}
+	return lo;
+}
+/** How far `value` is from the nearest other value of `values`; `Infinity` when there is none. */
+function neighborGap(values, value) {
+	const order = sortedOrder(values);
+	const at = lowerBound(values, order, value);
+	let gap = Number.POSITIVE_INFINITY;
+	if (at > 0) gap = value - values[order[at - 1]];
+	let next = at;
+	while (next < order.length && values[order[next]] <= value) next++;
+	if (next < order.length) gap = Math.min(gap, values[order[next]] - value);
+	return gap;
+}
+/** The row of `values` whose value is exactly `value`, or -1. */
+function rowAt(values, value) {
+	const order = sortedOrder(values);
+	const at = lowerBound(values, order, value);
+	return at < order.length && values[order[at]] === value ? order[at] : -1;
+}
+/**
+* Of all the x values of `columns`, the one nearest to `pixel` along the
+* x scale; `null` when there are none. Category axes snap to the nearest
+* category.
+*/
+function nearestX(columns, scale, pixel) {
+	const target = scale.invert(pixel);
+	let best = null;
+	let distance = Infinity;
+	for (const values of columns) {
+		const order = sortedOrder(values);
+		if (!order.length) continue;
+		const at = lowerBound(values, order, target);
+		for (const k of [at - 1, at]) {
+			if (k < 0 || k >= order.length) continue;
+			const value = values[order[k]];
+			const d = Math.abs(scale.map(value) - pixel);
+			if (d < distance) [best, distance] = [value, d];
+		}
+	}
+	return best;
+}
+/** The x values of `columns` together, from the smallest, each once. */
+function allX(columns) {
+	const seen = /* @__PURE__ */ new Set();
+	for (const values of columns) for (const value of values) if (value === value) seen.add(value);
+	return [...seen].sort((a, b) => a - b);
+}
+/**
+* The point nearest to `(px, py)` among `n` points placed by `point`,
+* if one is within `reach(i)` px of it. Points of equal distance go to the
+* one drawn last, which is on top.
+*/
+function nearestPoint(n, point, px, py, reach) {
+	let index = -1;
+	let distance = Infinity;
+	for (let i = 0; i < n; i++) {
+		const at = point(i);
+		if (!at) continue;
+		const dx = at[0] - px;
+		const dy = at[1] - py;
+		const d = Math.sqrt(dx * dx + dy * dy);
+		if (d <= reach(i) && d <= distance) [index, distance] = [i, d];
+	}
+	return index < 0 ? null : {
+		index,
+		distance
+	};
+}
+/** Angles clockwise from 12 o'clock, as pies use them. */
+function angleAt(cx, cy, px, py) {
+	const angle = Math.atan2(px - cx, cy - py);
+	return angle < 0 ? angle + Math.PI * 2 : angle;
+}
+export { allX, angleAt, inOrder, nearestPoint, nearestX, neighborGap, rowAt, sortedOrder };
+
+//# sourceMappingURL=hit.js.map

package/dist/core/hit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hit.js","names":[],"sources":["../../src/core/hit.ts"],"sourcesContent":["/*\n * Finding what is under the pointer: the x nearest to it (for a tooltip of\n * every series at one x), or the point nearest to it (for one point).\n */\nimport type { Scale } from './scale'\n\nconst orders = new WeakMap<Float64Array, Int32Array>()\n\n/** The indices of `values` from the smallest to the largest, `NaN` left out. Cached per array. */\nexport function sortedOrder(values: Float64Array): Int32Array {\n  let order = orders.get(values)\n  if (!order) {\n    let n = 0\n    for (let i = 0; i < values.length; i++) if (values[i] === values[i]) n++\n    order = new Int32Array(n)\n    for (let i = 0, j = 0; i < values.length; i++) if (values[i] === values[i]) order[j++] = i\n    let sorted = true\n    for (let j = 1; j < n && sorted; j++)\n      if (values[order[j]!]! < values[order[j - 1]!]!) sorted = false\n    // oxlint-disable-next-line unicorn/no-array-sort -- sorts its own array\n    if (!sorted) order.sort((a, b) => values[a]! - values[b]!)\n    orders.set(values, order)\n  }\n  return order\n}\n\nlet identity = new Int32Array(0)\n/**\n * Notes that `values` go up with no gaps, so their order is just\n * 0, 1, 2…: shared, so it costs nothing to make.\n */\nexport function inOrder(values: Float64Array) {\n  const n = values.length\n  if (identity.length < n) {\n    identity = new Int32Array(Math.max(n, identity.length * 2))\n    for (let i = 0; i < identity.length; i++) identity[i] = i\n  }\n  orders.set(values, identity.subarray(0, n))\n}\n\n/** The position in `order` of the first value not below `value`. */\nfunction lowerBound(values: Float64Array, order: Int32Array, value: number): number {\n  let lo = 0\n  let hi = order.length\n  while (lo < hi) {\n    const mid = (lo + hi) >> 1\n    if (values[order[mid]!]! < value) lo = mid + 1\n    else hi = mid\n  }\n  return lo\n}\n\n/** How far `value` is from the nearest other value of `values`; `Infinity` when there is none. */\nexport function neighborGap(values: Float64Array, value: number): number {\n  const order = sortedOrder(values)\n  const at = lowerBound(values, order, value)\n  let gap = Number.POSITIVE_INFINITY\n  if (at > 0) gap = value - values[order[at - 1]!]!\n  let next = at\n  while (next < order.length && values[order[next]!]! <= value) next++\n  if (next < order.length) gap = Math.min(gap, values[order[next]!]! - value)\n  return gap\n}\n\n/** The row of `values` whose value is exactly `value`, or -1. */\nexport function rowAt(values: Float64Array, value: number): number {\n  const order = sortedOrder(values)\n  const at = lowerBound(values, order, value)\n  return at < order.length && values[order[at]!] === value ? order[at]! : -1\n}\n\n/**\n * Of all the x values of `columns`, the one nearest to `pixel` along the\n * x scale; `null` when there are none. Category axes snap to the nearest\n * category.\n */\nexport function nearestX(columns: Float64Array[], scale: Scale, pixel: number): number | null {\n  const target = scale.invert(pixel)\n  let best: number | null = null\n  let distance = Infinity\n  for (const values of columns) {\n    const order = sortedOrder(values)\n    if (!order.length) continue\n    const at = lowerBound(values, order, target)\n    for (const k of [at - 1, at]) {\n      if (k < 0 || k >= order.length) continue\n      const value = values[order[k]!]!\n      const d = Math.abs(scale.map(value) - pixel)\n      if (d < distance) [best, distance] = [value, d]\n    }\n  }\n  return best\n}\n\n/** The x values of `columns` together, from the smallest, each once. */\nexport function allX(columns: Float64Array[]): number[] {\n  const seen = new Set<number>()\n  for (const values of columns) for (const value of values) if (value === value) seen.add(value)\n  // oxlint-disable-next-line unicorn/no-array-sort -- sorts its own array\n  return [...seen].sort((a, b) => a - b)\n}\n\n/**\n * The point nearest to `(px, py)` among `n` points placed by `point`,\n * if one is within `reach(i)` px of it. Points of equal distance go to the\n * one drawn last, which is on top.\n */\nexport function nearestPoint(\n  n: number,\n  point: (i: number) => [number, number] | null,\n  px: number,\n  py: number,\n  reach: (i: number) => number,\n): { index: number; distance: number } | null {\n  let index = -1\n  let distance = Infinity\n  for (let i = 0; i < n; i++) {\n    const at = point(i)\n    if (!at) continue\n    const dx = at[0] - px\n    const dy = at[1] - py\n    const d = Math.sqrt(dx * dx + dy * dy)\n    if (d <= reach(i) && d <= distance) [index, distance] = [i, d]\n  }\n  return index < 0 ? null : { index, distance }\n}\n\n/** Angles clockwise from 12 o'clock, as pies use them. */\nexport function angleAt(cx: number, cy: number, px: number, py: number): number {\n  const angle = Math.atan2(px - cx, cy - py)\n  return angle < 0 ? angle + Math.PI * 2 : angle\n}\n"],"mappings":"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"}

package/dist/core/labels.js

@@ -0,0 +1,141 @@
+/** Room between a label and its point, or the edge of its bar. */
+var GAP = 4;
+var overlaps = (a, b) => a[0] < b[2] && b[0] < a[2] && a[1] < b[3] && b[1] < a[3];
+/**
+* Places labels in the order given; one that covers a label placed before
+* it (or one of `taken`), or doesn't fit in `bounds` (or in its bar), is
+* left out.
+*/
+function placeDataLabels(inputs, bounds, measure, taken = []) {
+	const out = [];
+	const right = bounds.x + bounds.width;
+	const bottom = bounds.y + bounds.height;
+	for (const input of inputs) {
+		const { anchor, text } = input;
+		const width = measure(text);
+		const [x, y] = anchor.at;
+		const gap = GAP + (input.offset ?? 0);
+		let box;
+		let align;
+		switch (anchor.side) {
+			case "top":
+				box = [
+					x - width / 2,
+					y - gap - 16,
+					x + width / 2,
+					y - gap
+				];
+				align = "middle";
+				break;
+			case "bottom":
+				box = [
+					x - width / 2,
+					y + gap,
+					x + width / 2,
+					y + gap + 16
+				];
+				align = "middle";
+				break;
+			case "right":
+				box = [
+					x + gap,
+					y - 8,
+					x + gap + width,
+					y + 8
+				];
+				align = "start";
+				break;
+			case "left":
+				box = [
+					x - gap - width,
+					y - 8,
+					x - gap,
+					y + 8
+				];
+				align = "end";
+				break;
+			default: {
+				box = [
+					x - width / 2,
+					y - 8,
+					x + width / 2,
+					y + 8
+				];
+				align = "middle";
+				const shape = anchor.box;
+				if (shape && (width + 8 > shape.width + .5 || 20 > shape.height + .5)) continue;
+			}
+		}
+		const room = anchor.room;
+		if (room !== void 0) {
+			if ((anchor.side === "top" || anchor.side === "bottom" ? width : 16) > room + .5) continue;
+		}
+		if (box[0] < bounds.x - .5 || box[2] > right + .5) continue;
+		if (box[1] < bounds.y - .5 || box[3] > bottom + .5) continue;
+		if (taken.some((other) => overlaps(box, other))) continue;
+		taken.push(box);
+		out.push({
+			key: input.key,
+			series: input.series,
+			text,
+			left: align === "start" ? box[0] : align === "end" ? box[2] : x,
+			top: box[1],
+			align,
+			on: anchor.side === "center" ? anchor.box?.color : void 0
+		});
+	}
+	return out;
+}
+/**
+* Moves boxes of `height` centered at `centers` apart along one line so
+* none overlaps the next, keeping each as near its own center as it can
+* and all within `[from, to]`. Gives the new centers, in the same order.
+*/
+function spread(centers, height, from, to) {
+	const order = centers.map((_, i) => i);
+	order.sort((a, b) => centers[a] - centers[b]);
+	const placed = order.map((i) => centers[i]);
+	const half = height / 2;
+	for (let k = 0; k < placed.length; k++) {
+		const least = k === 0 ? from + half : placed[k - 1] + height;
+		if (placed[k] < least) placed[k] = least;
+	}
+	for (let k = placed.length - 1; k >= 0; k--) {
+		const most = k === placed.length - 1 ? to - half : placed[k + 1] - height;
+		if (placed[k] > most) placed[k] = most;
+	}
+	const out = Array.from({ length: centers.length });
+	order.forEach((i, k) => out[i] = placed[k]);
+	return out;
+}
+/** Relative luminance of an `rgb()` / `rgba()` color (as the browser gives computed colors), 0 to 1. */
+function luminance(color) {
+	const m = /rgba?\(\s*([\d.]+)[\s,]+([\d.]+)[\s,]+([\d.]+)/.exec(color);
+	if (!m) {
+		const hex = /^#([\da-f]{6})$/i.exec(color);
+		if (!hex) return null;
+		const n = Number.parseInt(hex[1], 16);
+		return relative([
+			n >> 16 & 255,
+			n >> 8 & 255,
+			n & 255
+		]);
+	}
+	return relative([
+		Number(m[1]),
+		Number(m[2]),
+		Number(m[3])
+	]);
+}
+function relative(rgb) {
+	const [r, g, b] = rgb.map((c) => {
+		const v = c / 255;
+		return v <= .03928 ? v / 12.92 : ((v + .055) / 1.055) ** 2.4;
+	});
+	return .2126 * r + .7152 * g + .0722 * b;
+}
+/** Contrast ratio between two luminances. */
+var contrast = (a, b) => (Math.max(a, b) + .05) / (Math.min(a, b) + .05);
+export { contrast, luminance, placeDataLabels, spread };
+
+//# sourceMappingURL=labels.js.map

package/dist/core/labels.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"labels.js","names":[],"sources":["../../src/core/labels.ts"],"sourcesContent":["import type { Rect } from './painter'\nimport type { ChartLabelAnchor } from './series'\n\n/*\n * Data labels: text by a point or in a bar. The series say where each\n * label may go; here the text is placed beside that point, and labels\n * that would cover one placed before them, or run off the room they\n * have, are left out. Lines' labels at their end are moved apart instead,\n * so each line keeps its name.\n */\n\n/** Height of a label's box, as tick labels. */\nexport const DATA_LABEL = 16\n/** Room between a label and its point, or the edge of its bar. */\nconst GAP = 4\n/** Room around a label's text inside a bar. */\nconst PAD = 4\n\nexport interface DataLabelInput {\n  key: string\n  /** The series' index. */\n  series: number\n  text: string\n  anchor: ChartLabelAnchor\n  /** Room from the point, past a dot or a line. */\n  offset?: number\n}\n\nexport interface PlacedDataLabel {\n  key: string\n  series: number\n  text: string\n  /** The box's top left, in px from the chart's top left. */\n  left: number\n  top: number\n  /** Which end of the text `left` is. */\n  align: 'start' | 'middle' | 'end'\n  /** In a bar: the color of the bar, for text that reads on it. */\n  on?: string\n}\n\ntype Box = [left: number, top: number, right: number, bottom: number]\n\nconst overlaps = (a: Box, b: Box) => a[0] < b[2] && b[0] < a[2] && a[1] < b[3] && b[1] < a[3]\n\n/**\n * Places labels in the order given; one that covers a label placed before\n * it (or one of `taken`), or doesn't fit in `bounds` (or in its bar), is\n * left out.\n */\nexport function placeDataLabels(\n  inputs: DataLabelInput[],\n  bounds: Rect,\n  measure: (text: string) => number,\n  /** Labels already there that these must not cover (the ends of lines, say). */\n  taken: Box[] = [],\n): PlacedDataLabel[] {\n  const out: PlacedDataLabel[] = []\n  const right = bounds.x + bounds.width\n  const bottom = bounds.y + bounds.height\n  for (const input of inputs) {\n    const { anchor, text } = input\n    const width = measure(text)\n    const [x, y] = anchor.at\n    const gap = GAP + (input.offset ?? 0)\n    let box: Box\n    let align: PlacedDataLabel['align']\n    switch (anchor.side) {\n      case 'top':\n        box = [x - width / 2, y - gap - DATA_LABEL, x + width / 2, y - gap]\n        align = 'middle'\n        break\n      case 'bottom':\n        box = [x - width / 2, y + gap, x + width / 2, y + gap + DATA_LABEL]\n        align = 'middle'\n        break\n      case 'right':\n        box = [x + gap, y - DATA_LABEL / 2, x + gap + width, y + DATA_LABEL / 2]\n        align = 'start'\n        break\n      case 'left':\n        box = [x - gap - width, y - DATA_LABEL / 2, x - gap, y + DATA_LABEL / 2]\n        align = 'end'\n        break\n      default: {\n        box = [x - width / 2, y - DATA_LABEL / 2, x + width / 2, y + DATA_LABEL / 2]\n        align = 'middle'\n        const shape = anchor.box\n        // inside a bar: with room around it, or not at all\n        if (shape && (width + PAD * 2 > shape.width + 0.5 || DATA_LABEL + PAD > shape.height + 0.5))\n          continue\n      }\n    }\n    const room = anchor.room\n    if (room !== undefined) {\n      const across = anchor.side === 'top' || anchor.side === 'bottom' ? width : DATA_LABEL\n      if (across > room + 0.5) continue\n    }\n    if (box[0] < bounds.x - 0.5 || box[2] > right + 0.5) continue\n    if (box[1] < bounds.y - 0.5 || box[3] > bottom + 0.5) continue\n    if (taken.some((other) => overlaps(box, other))) continue\n    taken.push(box)\n    out.push({\n      key: input.key,\n      series: input.series,\n      text,\n      left: align === 'start' ? box[0] : align === 'end' ? box[2] : x,\n      top: box[1],\n      align,\n      on: anchor.side === 'center' ? anchor.box?.color : undefined,\n    })\n  }\n  return out\n}\n\n/**\n * Moves boxes of `height` centered at `centers` apart along one line so\n * none overlaps the next, keeping each as near its own center as it can\n * and all within `[from, to]`. Gives the new centers, in the same order.\n */\nexport function spread(centers: number[], height: number, from: number, to: number): number[] {\n  const order = centers.map((_, i) => i)\n  order.sort((a, b) => centers[a]! - centers[b]!)\n  const placed = order.map((i) => centers[i]!)\n  const half = height / 2\n  // down, keeping each clear of the one above\n  for (let k = 0; k < placed.length; k++) {\n    const least = k === 0 ? from + half : placed[k - 1]! + height\n    if (placed[k]! < least) placed[k] = least\n  }\n  // then up from the end, where the last ran past it\n  for (let k = placed.length - 1; k >= 0; k--) {\n    const most = k === placed.length - 1 ? to - half : placed[k + 1]! - height\n    if (placed[k]! > most) placed[k] = most\n  }\n  const out: number[] = Array.from({ length: centers.length })\n  order.forEach((i, k) => (out[i] = placed[k]!))\n  return out\n}\n\n/** Relative luminance of an `rgb()` / `rgba()` color (as the browser gives computed colors), 0 to 1. */\nexport function luminance(color: string): number | null {\n  const m = /rgba?\\(\\s*([\\d.]+)[\\s,]+([\\d.]+)[\\s,]+([\\d.]+)/.exec(color)\n  if (!m) {\n    const hex = /^#([\\da-f]{6})$/i.exec(color)\n    if (!hex) return null\n    const n = Number.parseInt(hex[1]!, 16)\n    return relative([(n >> 16) & 255, (n >> 8) & 255, n & 255])\n  }\n  return relative([Number(m[1]), Number(m[2]), Number(m[3])])\n}\n\nfunction relative(rgb: number[]): number {\n  const [r, g, b] = rgb.map((c) => {\n    const v = c / 255\n    return v <= 0.039_28 ? v / 12.92 : ((v + 0.055) / 1.055) ** 2.4\n  })\n  return 0.2126 * r! + 0.7152 * g! + 0.0722 * b!\n}\n\n/** Contrast ratio between two luminances. */\nexport const contrast = (a: number, b: number) => (Math.max(a, b) + 0.05) / (Math.min(a, b) + 0.05)\n"],"mappings":"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"}