@graphysdk/geom-boxplot 0.0.0-stage → 0.1.1-beta.1791459323341

package/dist/index.mjs

@@ -0,0 +1,852 @@
+import { Dataset as me, Geom as ve, GeomCircle as ge, GeomLine as fe, GeomPath as ye, GeomRect as ke, IntroFade as we, POSITION_VARIABLES as B, Stat as xe, UserInputError as We, buildDotsEditOutlineShapes as Me, composePoint as Se, createStableKeyGenerator as Ie, defineGeomRenderer as Oe, defineGeomStyleTarget as be, getGroupVariables as Ee, getScaledAesthetic as b, getXMax as R, getXMin as U, getYMax as $, getYMin as A, readMainAxis as E, readVariableName as N, toPaintColor as T, toPercent as x, toStrokeDasharray as Te, toViewBoxX as _e, toViewBoxY as Be, token as M } from "@graphysdk/react";
+import { useMemo as S } from "react";
+import { Fragment as qe, jsx as k, jsxs as Pe } from "react/jsx-runtime";
+var y = {
+  q1: "boxplotQ1",
+  median: "boxplotMedian",
+  q3: "boxplotQ3",
+  lowerWhisker: "boxplotLowerWhisker",
+  upperWhisker: "boxplotUpperWhisker",
+  count: "boxplotCount",
+  mean: "boxplotMean",
+  notchLower: "boxplotNotchLower",
+  notchUpper: "boxplotNotchUpper",
+  relativeWidth: "boxplotRelativeWidth",
+  outlier: "boxplotOutlier"
+}, V = (e) => (e.start + e.end) / 2, re = (e, t) => {
+  const r = t === "x" ? U(e) : A(e), o = t === "x" ? R(e) : $(e), n = t === "x" ? A(e) : U(e), a = t === "x" ? $(e) : R(e), s = b(e, "q1"), i = b(e, "median"), u = b(e, "q3");
+  if (r === null || o === null || n === null || a === null || i === null || s === null || u === null) return null;
+  const l = C(e, "notchLower"), h = C(e, "notchUpper"), [p, g] = Ne(r, o, e);
+  return {
+    observation: e,
+    start: p,
+    end: g,
+    lowerWhisker: n,
+    q1: s,
+    median: i,
+    q3: u,
+    upperWhisker: a,
+    mean: C(e, "mean"),
+    notch: l === null || h === null ? null : {
+      lower: l,
+      upper: h
+    }
+  };
+}, oe = (e, t) => {
+  const r = t === "x" ? U(e) : A(e), o = t === "x" ? R(e) : $(e), n = b(e, "outlier");
+  return r === null || o === null || n === null ? null : {
+    observation: e,
+    band: V({
+      start: r,
+      end: o
+    }),
+    value: n
+  };
+}, I = (e, t) => {
+  const r = [], o = [];
+  for (const n of e) {
+    const a = re(n, t);
+    if (a !== null) {
+      r.push(a);
+      continue;
+    }
+    const s = oe(n, t);
+    s !== null && o.push(s);
+  }
+  return {
+    boxes: r,
+    outliers: o
+  };
+}, C = (e, t) => b(e, t) ?? null, Ne = (e, t, r) => {
+  const o = r[y.relativeWidth];
+  if (typeof o != "number") return [e, t];
+  const n = (e + t) / 2, a = (t - e) * o / 2;
+  return [n - a, n + a];
+}, P = 1.5, ne = (e) => e === "min-max" || typeof e == "number" && Number.isFinite(e) && e >= 0, Ve = 1.58, Le = (e, t) => {
+  if (e.length === 0) return null;
+  const r = [...e].sort((p, g) => p - g), o = D(r, 0.25), n = D(r, 0.5), a = D(r, 0.75), s = t === "min-max" ? 1 / 0 : t * (a - o), i = o - s, u = a + s, l = r.filter((p) => p >= i && p <= u), h = Ve * (a - o) / Math.sqrt(e.length);
+  return {
+    lowerWhisker: Math.min(l[0] ?? o, o),
+    q1: o,
+    median: n,
+    q3: a,
+    upperWhisker: Math.max(l[l.length - 1] ?? a, a),
+    count: e.length,
+    mean: r.reduce((p, g) => p + g, 0) / r.length,
+    notchLower: n - h,
+    notchUpper: n + h
+  };
+}, D = (e, t) => {
+  const r = (e.length - 1) * t, o = Math.floor(r), n = e[o] ?? 0;
+  return n + ((e[o + 1] ?? n) - n) * (r - o);
+}, ae = {
+  q1: y.q1,
+  median: y.median,
+  q3: y.q3,
+  lowerWhisker: y.lowerWhisker,
+  upperWhisker: y.upperWhisker,
+  count: y.count,
+  outlier: y.outlier
+}, se = /* @__PURE__ */ new Set([
+  ...Object.keys(ae),
+  "mean",
+  "notchLower",
+  "notchUpper"
+]), Ce = class extends xe {
+  constructor(...e) {
+    super(...e), this.type = "boxplot", this.computedVariables = se;
+  }
+  computeStat({ data: e, mapping: t, params: r }) {
+    const o = N(t.x), n = N(t.y);
+    if (o === null || n === null || !e.hasVariable(o) || !e.hasVariable(n)) return {
+      data: e,
+      mapping: {}
+    };
+    if (e.size() > 0 && e.getType(n) !== "numeric") {
+      const s = e.getType(n);
+      throw new We({
+        code: "INCOMPATIBLE_TYPE",
+        message: `'boxplot' stat requires a numeric 'y' (got '${s}' for variable '${n}')`,
+        context: {
+          aesthetic: "y",
+          variableName: n,
+          variableType: s
+        },
+        suggestion: "Map the raw values to 'y', or summarised columns under stat 'identity'."
+      });
+    }
+    const a = r?.extent;
+    return {
+      data: De({
+        data: e,
+        xVariable: o,
+        yVariable: n,
+        groupVariables: Ee(e, t).filter((s) => s !== o),
+        extent: ne(a) ? a : P
+      }),
+      mapping: ae
+    };
+  }
+}, De = ({ data: e, xVariable: t, yVariable: r, groupVariables: o, extent: n }) => {
+  const a = Ke(e, t, r, o), s = e.getVariableNames(), i = new Map(s.map((d) => [d, e.getValues(d)])), u = new Map(s.map((d) => [d, []])), l = {
+    q1: [],
+    median: [],
+    q3: [],
+    lowerWhisker: [],
+    upperWhisker: [],
+    count: [],
+    mean: [],
+    notchLower: [],
+    notchUpper: [],
+    outlier: []
+  }, h = [];
+  for (const d of a) {
+    const m = Le(d.values, n);
+    if (m === null) continue;
+    for (const c of s) u.get(c)?.push(Re(i.get(c) ?? [], d.indices));
+    l.q1.push(m.q1), l.median.push(m.median), l.q3.push(m.q3), l.lowerWhisker.push(m.lowerWhisker), l.upperWhisker.push(m.upperWhisker), l.count.push(m.count), l.mean.push(m.mean), l.notchLower.push(m.notchLower), l.notchUpper.push(m.notchUpper), l.outlier.push(null);
+    const w = {
+      low: m.lowerWhisker,
+      high: m.upperWhisker
+    };
+    d.indices.forEach((c, f) => {
+      const W = d.values[f];
+      W !== void 0 && (W < w.low || W > w.high) && h.push({
+        index: c,
+        value: W
+      });
+    });
+  }
+  for (const { index: d, value: m } of h) {
+    for (const w of s) u.get(w)?.push(i.get(w)?.[d] ?? null);
+    l.q1.push(null), l.median.push(null), l.q3.push(null), l.lowerWhisker.push(null), l.upperWhisker.push(null), l.count.push(null), l.mean.push(null), l.notchLower.push(null), l.notchUpper.push(null), l.outlier.push(m);
+  }
+  const p = e.getValueFormat(r), g = Object.fromEntries(s.map((d) => [d, {
+    type: e.getType(d),
+    values: u.get(d) ?? [],
+    valueFormat: e.getValueFormat(d)
+  }]));
+  for (const [d, m] of Object.entries(l)) {
+    const w = y[d];
+    g[w] = d === "count" ? {
+      type: "numeric",
+      values: m
+    } : {
+      type: "numeric",
+      values: m,
+      valueFormat: p
+    };
+  }
+  return new me(g);
+}, Ke = (e, t, r, o) => {
+  const n = [t, ...o].map((i) => e.getValues(i)), a = e.getValues(r, { type: "numeric" }), s = /* @__PURE__ */ new Map();
+  return a.forEach((i, u) => {
+    if (i === null || !Number.isFinite(i)) return;
+    const l = n.map((p) => H(p[u] ?? null)).join("\0"), h = s.get(l) ?? {
+      indices: [],
+      values: []
+    };
+    h.indices.push(u), h.values.push(i), s.set(l, h);
+  }), [...s.values()];
+}, Re = (e, t) => {
+  const r = e[t[0] ?? -1] ?? null, o = H(r);
+  return t.every((n) => H(e[n] ?? null) === o) ? r : null;
+}, H = (e) => e === null ? "\0null" : e instanceof Date ? `date:${e.getTime()}` : `${typeof e}:${String(e)}`, le = 0.6, Ue = 1.5, $e = 0.3, Ae = 2, z = 1.5, He = 6, Fe = 1.5, Ge = 7, Xe = 1.5, ze = [
+  "q1",
+  "median",
+  "q3"
+], Ye = { strokeWidth: "pixels" }, K = {
+  stroke: "color",
+  alpha: "unitInterval",
+  strokeWidth: "pixels",
+  dashArray: "dashArray"
+}, Y = {
+  fill: "color",
+  fillAlpha: "unitInterval",
+  stroke: "color",
+  alpha: "unitInterval",
+  size: "pixels",
+  strokeWidth: "pixels"
+}, je = class extends ve {
+  constructor(...e) {
+    super(...e), this.type = "boxplot", this.defaultParams = {
+      extent: P,
+      outliers: !0,
+      notch: !1,
+      showMean: !1,
+      varwidth: !1
+    }, this.defaultStat = new Ce(), this.derivedVariables = Object.values(y), this.positionRoles = [
+      {
+        axis: "x",
+        role: "point",
+        valueKind: "value"
+      },
+      {
+        axis: "y",
+        role: "min",
+        valueKind: "value",
+        aes: "lowerWhisker"
+      },
+      {
+        axis: "y",
+        role: "max",
+        valueKind: "value",
+        aes: "upperWhisker"
+      },
+      {
+        axis: "y",
+        role: "scalar",
+        valueKind: "value",
+        aes: "q1"
+      },
+      {
+        axis: "y",
+        role: "scalar",
+        valueKind: "value",
+        aes: "median"
+      },
+      {
+        axis: "y",
+        role: "scalar",
+        valueKind: "value",
+        aes: "q3"
+      },
+      {
+        axis: "y",
+        role: "scalar",
+        valueKind: "value",
+        aes: "outlier"
+      },
+      {
+        axis: "y",
+        role: "scalar",
+        valueKind: "value",
+        aes: "mean"
+      },
+      {
+        axis: "y",
+        role: "scalar",
+        valueKind: "value",
+        aes: "notchLower"
+      },
+      {
+        axis: "y",
+        role: "scalar",
+        valueKind: "value",
+        aes: "notchUpper"
+      }
+    ], this.aesthetics = [
+      {
+        kind: "visual",
+        name: "color"
+      },
+      {
+        kind: "data",
+        name: "y"
+      },
+      {
+        kind: "data",
+        name: "count"
+      }
+    ], this.defaultPosition = "dodge", this.supportedPositions = ["identity", "dodge"], this.supportedCoordTypes = ["cartesian", "flip"], this.scaleConstraints = { discreteMainAxis: !0 }, this.legend = { suppressWhenSingleItem: !0 }, this.spatialKind = "rects", this.highlightStrategy = "observation-rerender", this.tooltip = [
+      {
+        key: "Upper whisker",
+        aes: "upperWhisker",
+        optional: !0
+      },
+      {
+        key: "Q3",
+        aes: "q3",
+        optional: !0
+      },
+      {
+        key: "Median",
+        aes: "median",
+        optional: !0
+      },
+      {
+        key: "Q1",
+        aes: "q1",
+        optional: !0
+      },
+      {
+        key: "Lower whisker",
+        aes: "lowerWhisker",
+        optional: !0
+      },
+      {
+        key: "Count",
+        aes: "count",
+        optional: !0
+      },
+      {
+        key: "Mean",
+        aes: "mean",
+        optional: !0
+      },
+      {
+        key: "Outlier",
+        aes: "outlier",
+        optional: !0
+      }
+    ], this.styleTarget = be({
+      observation: {
+        vocabulary: Ye,
+        aesthetics: {
+          fill: "color",
+          stroke: "color"
+        },
+        rest: {
+          fill: M("geom"),
+          fillAlpha: $e,
+          stroke: M("geom"),
+          strokeWidth: Ue
+        }
+      },
+      parts: {
+        median: {
+          vocabulary: K,
+          aesthetics: { stroke: "color" },
+          rest: {
+            stroke: M("geom"),
+            alpha: 1,
+            strokeWidth: Ae,
+            dashArray: []
+          }
+        },
+        whisker: {
+          vocabulary: K,
+          aesthetics: { stroke: "color" },
+          rest: {
+            stroke: M("geom"),
+            alpha: 1,
+            strokeWidth: z,
+            dashArray: []
+          }
+        },
+        cap: {
+          vocabulary: K,
+          aesthetics: { stroke: "color" },
+          rest: {
+            stroke: M("geom"),
+            alpha: 1,
+            strokeWidth: z,
+            dashArray: []
+          }
+        },
+        outlier: {
+          vocabulary: Y,
+          aesthetics: {
+            fill: "color",
+            stroke: "color"
+          },
+          rest: {
+            fill: M("geom"),
+            fillAlpha: 0,
+            stroke: M("geom"),
+            alpha: 1,
+            size: He,
+            strokeWidth: Fe
+          }
+        },
+        mean: {
+          vocabulary: Y,
+          aesthetics: { fill: "color" },
+          rest: {
+            fill: M("geom"),
+            fillAlpha: 1,
+            stroke: M("graphBackground"),
+            alpha: 1,
+            size: Ge,
+            strokeWidth: Xe
+          }
+        }
+      }
+    }), this.resolveBandFraction = (t) => j(t), this.resolveValueSource = (t) => t.median ?? { variable: y.median }, this.validateMapping = ({ mapping: t, computedVariables: r }) => r.has("y") ? [{
+      code: "CONFLICTING_STAT_MAPPING",
+      message: "boxplot geom draws a summary, not a single 'y'; use the 'boxplot' stat or 'identity'"
+    }] : r.has("median") ? [...[...se].filter((o) => t[o] !== void 0).map((o) => ({
+      code: "CONFLICTING_STAT_MAPPING",
+      message: `boxplot stat computes '${o}' from 'y'; remove its mapping, or set the layer's stat to 'identity'`
+    })), ...t.y === void 0 ? [{
+      code: "MISSING_AESTHETIC",
+      message: "boxplot stat summarises 'y'; map it to the raw values"
+    }] : []] : ze.filter((o) => t[o] === void 0).map((o) => ({
+      code: "MISSING_AESTHETIC",
+      message: `boxplot geom requires '${o}' when its data is already summarised`,
+      context: { aesthetic: o }
+    })), this.resolveAnchorPosition = (t, { coordSystem: r }) => {
+      const o = E(r), n = Qe(t, o);
+      return n === null ? null : o === "x" ? {
+        x: n.band,
+        y: n.value
+      } : {
+        x: n.value,
+        y: n.band
+      };
+    };
+  }
+  resolveParams(e) {
+    const { extent: t, width: r, ...o } = super.resolveParams(e);
+    return {
+      ...o,
+      extent: this.resolveExtent(t, e.diagnostics),
+      ...this.resolveWidth(r, e.diagnostics)
+    };
+  }
+  compile({ data: e, mapping: t, params: r }) {
+    const o = q(e, t.lowerWhisker), n = q(e, t.upperWhisker);
+    if (o === null || n === null) return {
+      data: e,
+      mapping: {}
+    };
+    const { outliers: a, notch: s, showMean: i, varwidth: u } = r, l = q(e, t.outlier), h = a === !1 && l !== null ? et(e, l) : e, p = q(h, t.count), g = j(r) / 2;
+    return {
+      data: h.addVariable(y.relativeWidth, "numeric", u === !0 && p !== null ? Ze(h, p) : Je(h)).addVariable(B.yMin, "numeric", Q(h, o, l)).addVariable(B.yMax, "numeric", Q(h, n, l)).addConstantVariable(B.xMin, "numeric", -g).addConstantVariable(B.xMax, "numeric", g),
+      mapping: {
+        ...t.y === void 0 && { y: t.median },
+        ...i === !0 && t.mean === void 0 && h.hasVariable(y.mean) && { mean: y.mean },
+        ...s === !0 && t.notchLower === void 0 && h.hasVariable(y.notchLower) && {
+          notchLower: y.notchLower,
+          notchUpper: y.notchUpper
+        }
+      }
+    };
+  }
+  resolveExtent(e, t) {
+    return ne(e) ? e : (t?.addWarning({
+      code: "INVALID_GEOM_PARAM",
+      message: `Boxplot extent must be a non-negative number or 'min-max', got ${String(e)}; falling back to ${P}.`,
+      context: {
+        geom: this.type,
+        param: "extent",
+        expected: "extent >= 0 or 'min-max'",
+        actual: String(e)
+      },
+      suggestion: "Set params.extent to a number of interquartile ranges, or 'min-max'."
+    }), P);
+  }
+  resolveWidth(e, t) {
+    if (e === void 0) return {};
+    const r = typeof e == "number" && Number.isFinite(e) ? e : null;
+    if (r !== null && r > 0 && r <= 1) return { width: r };
+    const o = r !== null && r > 1 ? 1 : void 0;
+    return t?.addWarning({
+      code: "INVALID_GEOM_PARAM",
+      message: `Boxplot width must be a fraction in (0, 1], got ${String(e)}; falling back to ${o ?? le}.`,
+      context: {
+        geom: this.type,
+        param: "width",
+        expected: "0 < width <= 1",
+        actual: r ?? String(e)
+      },
+      suggestion: "Set params.width to a fraction of the category band in (0, 1]."
+    }), o !== void 0 ? { width: o } : {};
+  }
+}, Qe = (e, t) => {
+  const r = re(e, t);
+  if (r !== null) return {
+    band: V(r),
+    value: r.median
+  };
+  const o = oe(e, t);
+  return o === null ? null : {
+    band: o.band,
+    value: o.value
+  };
+}, j = ({ width: e }) => e ?? le, Ze = (e, t) => {
+  const r = e.getValues(t, { type: "numeric" }), o = Math.max(0, ...r.map((n) => n ?? 0));
+  return r.map((n) => n === null || o === 0 ? null : Math.sqrt(n / o));
+}, Je = (e) => Array.from({ length: e.size() }, () => null), Q = (e, t, r) => {
+  const o = r === null ? [] : e.getValues(r, { type: "numeric" });
+  return e.getValues(t, { type: "numeric" }).map((n, a) => n ?? o[a] ?? null);
+}, et = (e, t) => {
+  const r = e.getValues(t, { type: "numeric" });
+  return e.take(r.flatMap((o, n) => o === null ? [n] : []));
+}, q = (e, t) => {
+  const r = N(t);
+  return r !== null && e.hasVariable(r) ? r : null;
+}, tt = 5e-4, rt = 0.5, ot = 0.5, ie = (e, t) => {
+  const r = (e.q1 + e.q3) / 2, o = Math.max(Math.abs(e.q3 - e.q1), tt) / 2, n = v(t, e.start, r - o), a = v(t, e.end, r + o), [s, i] = Z(n.x, a.x), [u, l] = Z(n.y, a.y);
+  return {
+    x: s,
+    y: u,
+    width: i - s,
+    height: l - u
+  };
+}, ue = (e, t) => {
+  if (e.notch === null) return null;
+  const { lower: r, upper: o } = e.notch, [n, a] = he(e);
+  return [
+    v(t, e.start, e.q1),
+    v(t, e.start, r),
+    v(t, n, e.median),
+    v(t, e.start, o),
+    v(t, e.start, e.q3),
+    v(t, e.end, e.q3),
+    v(t, e.end, o),
+    v(t, a, e.median),
+    v(t, e.end, r),
+    v(t, e.end, e.q1)
+  ];
+}, nt = (e, t) => {
+  const [r, o] = e.notch === null ? [e.start, e.end] : he(e);
+  return {
+    from: v(t, r, e.median),
+    to: v(t, o, e.median)
+  };
+}, ce = (e, t) => e.mean === null ? null : v(t, V(e), e.mean), he = (e) => {
+  const t = (e.end - e.start) * (1 - ot) / 2;
+  return [e.start + t, e.end - t];
+}, de = (e, t) => {
+  const r = V(e), o = (e.end - e.start) * rt / 2;
+  return [{
+    side: "lower",
+    quartile: e.q1,
+    reach: e.lowerWhisker
+  }, {
+    side: "upper",
+    quartile: e.q3,
+    reach: e.upperWhisker
+  }].filter(({ quartile: n, reach: a }) => n !== a).map(({ side: n, quartile: a, reach: s }) => ({
+    side: n,
+    stem: {
+      from: v(t, r, a),
+      to: v(t, r, s)
+    },
+    cap: {
+      from: v(t, r - o, s),
+      to: v(t, r + o, s)
+    }
+  }));
+}, v = (e, t, r) => {
+  const o = Se(e, {
+    main: t,
+    cross: r
+  });
+  return {
+    x: _e(o.x),
+    y: Be(o.y)
+  };
+}, Z = (e, t) => e <= t ? [e, t] : [t, e], _ = (e, t) => ({
+  x: e.x * t.width,
+  y: e.y * t.height
+}), F = (e, t) => `${e.map((r, o) => {
+  const { x: n, y: a } = _(r, t);
+  return `${o === 0 ? "M" : "L"}${n},${a}`;
+}).join("")}Z`, at = (e, t) => F([
+  {
+    x: e.x,
+    y: e.y
+  },
+  {
+    x: e.x + e.width,
+    y: e.y
+  },
+  {
+    x: e.x + e.width,
+    y: e.y + e.height
+  },
+  {
+    x: e.x,
+    y: e.y + e.height
+  }
+], t), st = (e, t) => {
+  const r = _(e.from, t), o = _(e.to, t);
+  return `M${r.x},${r.y}L${o.x},${o.y}`;
+}, lt = ({ layer: e, coordSystem: t, panelRect: r, styleReaders: o }) => {
+  const n = E(t), { boxes: a, outliers: s } = I(e.data, n), i = a.map((c) => {
+    const f = ue(c, n);
+    return f !== null ? {
+      kind: "region",
+      pathData: F(f, r)
+    } : {
+      kind: "region",
+      pathData: at(ie(c, n), r)
+    };
+  }), u = o.part("whisker"), l = o.part("cap"), h = a.flatMap((c) => de(c, n).flatMap((f) => [{
+    segment: f.stem,
+    readers: u
+  }, {
+    segment: f.cap,
+    readers: l
+  }].flatMap(({ segment: W, readers: L }) => {
+    const O = L?.get("strokeWidth", c.observation) ?? 0;
+    return O > 0 ? [{
+      kind: "stroke",
+      pathData: st(W, r),
+      width: O
+    }] : [];
+  }))), p = o.part("outlier"), g = p === void 0 ? [] : s.map((c) => ({
+    center: _(v(n, c.band, c.value), r),
+    size: J(p, c.observation)
+  })), d = o.part("mean"), m = d === void 0 ? [] : a.flatMap((c) => {
+    const f = ce(c, n);
+    return f === null ? [] : [{
+      center: _(f, r),
+      size: J(d, c.observation)
+    }];
+  }), w = Me([...g, ...m]);
+  return [
+    ...h,
+    ...i,
+    ...w
+  ];
+}, J = (e, t) => (e.get("size", t) ?? 0) + (e.get("strokeWidth", t) ?? 0), G = (e) => {
+  const t = Ie(e.data, e.mapping, e.id), r = N(e.mapping.outlier), o = (n) => `${t(n.observation)}-outlier-${String(r === null ? n.value : n.observation[r])}`;
+  return {
+    readBoxKey: t,
+    readOutlierKeys: (n) => {
+      const a = /* @__PURE__ */ new Map();
+      return n.map((s) => {
+        const i = o(s), u = a.get(i) ?? 0;
+        return a.set(i, u + 1), u === 0 ? i : `${i}-${u}`;
+      });
+    }
+  };
+}, it = (e, t, r) => {
+  const o = e.data.getVariableNames(), n = (s) => JSON.stringify(o.map((i) => s.observation[i] ?? null)), a = new Set(r.map(n));
+  return t.filter((s) => a.has(n(s)));
+}, pe = (e, t, r) => {
+  const o = new Set(t.map((n) => r(n.observation)));
+  return e.filter((n) => o.has(r(n.observation)));
+}, X = ({ boxes: e, outliers: t, mainAxis: r, panelSize: o, source: n, styleReaders: a, keys: s, isHovered: i = !1, shouldAnimateTransitions: u = !1 }) => {
+  const l = i ? "hovered" : void 0, h = a.part("whisker"), p = a.part("cap"), g = a.part("median"), d = a.part("mean"), m = a.part("outlier"), w = s.readOutlierKeys(t);
+  return /* @__PURE__ */ Pe(qe, { children: [
+    e.flatMap((c) => de(c, r).flatMap((f) => [{
+      piece: "stem",
+      testId: "boxplot-whisker",
+      readers: h
+    }, {
+      piece: "cap",
+      testId: "boxplot-cap",
+      readers: p
+    }].map(({ piece: W, testId: L, readers: O }) => O === void 0 ? null : /* @__PURE__ */ k(ee, {
+      testId: L,
+      segment: f[W],
+      observation: c.observation,
+      readers: O,
+      state: l,
+      shouldAnimateTransitions: u
+    }, `${s.readBoxKey(c.observation)}-${f.side}-${W}`)))),
+    e.map((c) => /* @__PURE__ */ k(ut, {
+      box: c,
+      mainAxis: r,
+      panelSize: o,
+      source: n,
+      styleReaders: a,
+      state: l,
+      shouldAnimateTransitions: u
+    }, s.readBoxKey(c.observation))),
+    g && e.map((c) => /* @__PURE__ */ k(ee, {
+      testId: "boxplot-median",
+      segment: nt(c, r),
+      observation: c.observation,
+      readers: g,
+      state: l,
+      shouldAnimateTransitions: u
+    }, s.readBoxKey(c.observation))),
+    d && e.map((c) => {
+      const f = ce(c, r);
+      return f === null ? null : /* @__PURE__ */ k(te, {
+        testId: "boxplot-mean",
+        centre: f,
+        observation: c.observation,
+        readers: d,
+        state: l,
+        shouldAnimateTransitions: u
+      }, s.readBoxKey(c.observation));
+    }),
+    m && t.map((c, f) => /* @__PURE__ */ k(te, {
+      testId: "boxplot-outlier",
+      centre: v(r, c.band, c.value),
+      observation: c.observation,
+      readers: m,
+      state: l,
+      shouldAnimateTransitions: u
+    }, w[f]))
+  ] });
+}, ee = ({ testId: e, segment: t, observation: r, readers: o, state: n, shouldAnimateTransitions: a }) => {
+  const s = o.get("strokeWidth", r, n) ?? 0, i = o.get("stroke", r, n);
+  return /* @__PURE__ */ k(fe, {
+    "data-testid": e,
+    x1: x(t.from.x),
+    y1: x(t.from.y),
+    x2: x(t.to.x),
+    y2: x(t.to.y),
+    stroke: i === void 0 ? void 0 : T(i),
+    strokeOpacity: o.get("alpha", r, n),
+    strokeWidth: s,
+    strokeDasharray: Te(o.get("dashArray", r, n), s),
+    shouldAnimateTransitions: a
+  });
+}, ut = ({ box: e, mainAxis: t, panelSize: r, source: o, styleReaders: n, state: a, shouldAnimateTransitions: s }) => {
+  const i = n.get("fill", e.observation, a), u = n.get("stroke", e.observation, a), l = {
+    fill: i === void 0 ? void 0 : T(i),
+    opacity: n.get("alpha", e.observation, a),
+    fillOpacity: n.get("fillAlpha", e.observation, a),
+    stroke: u === void 0 ? void 0 : T(u),
+    strokeOpacity: n.get("strokeAlpha", e.observation, a),
+    strokeWidth: n.get("strokeWidth", e.observation, a),
+    shouldAnimateTransitions: s
+  }, h = ue(e, t);
+  if (h !== null) return /* @__PURE__ */ k(ye, {
+    "data-testid": "boxplot-box",
+    d: F(h, r),
+    source: o,
+    ...l
+  });
+  const p = ie(e, t);
+  return /* @__PURE__ */ k(ke, {
+    "data-testid": "boxplot-box",
+    x: x(p.x),
+    y: x(p.y),
+    width: x(p.width),
+    height: x(p.height),
+    ...l
+  });
+}, te = ({ testId: e, centre: t, observation: r, readers: o, state: n, shouldAnimateTransitions: a }) => {
+  const s = o.get("fill", r, n), i = o.get("stroke", r, n);
+  return /* @__PURE__ */ k(ge, {
+    "data-testid": e,
+    cx: x(t.x),
+    cy: x(t.y),
+    r: (o.get("size", r, n) ?? 0) / 2,
+    fill: s === void 0 ? void 0 : T(s),
+    opacity: o.get("alpha", r, n),
+    fillOpacity: o.get("fillAlpha", r, n),
+    stroke: i === void 0 ? void 0 : T(i),
+    strokeWidth: o.get("strokeWidth", r, n),
+    shouldAnimateTransitions: a
+  });
+}, ct = ({ layer: e, sourceLayer: t, mainAxis: r, panelSize: o, styleReaders: n }) => {
+  const a = S(() => G(t), [t]), s = S(() => I(t.data, r).outliers, [t.data, r]), { boxes: i, outliers: u } = S(() => {
+    const l = I(e.data, r), h = new Set(it(t, s, l.outliers)), p = new Set(pe(s, l.boxes, a.readBoxKey)), g = s.filter((d) => p.has(d) || h.has(d));
+    return {
+      boxes: l.boxes,
+      outliers: g
+    };
+  }, [
+    e.data,
+    r,
+    t,
+    s,
+    a
+  ]);
+  return /* @__PURE__ */ k(X, {
+    boxes: i,
+    outliers: u,
+    mainAxis: r,
+    panelSize: o,
+    source: t,
+    styleReaders: n,
+    keys: a
+  });
+}, ht = ({ layer: e, primary: t, mainAxis: r, panelSize: o, styleReaders: n }) => {
+  const a = S(() => I(e.data, r).outliers, [e.data, r]), s = S(() => G(e), [e]), { boxes: i, outliers: u } = I([t.observation], r);
+  return /* @__PURE__ */ k("g", {
+    "data-testid": "hovered-boxes",
+    children: /* @__PURE__ */ k(X, {
+      boxes: i,
+      outliers: i.length > 0 ? pe(a, i, s.readBoxKey) : u,
+      mainAxis: r,
+      panelSize: o,
+      source: e,
+      styleReaders: n,
+      keys: s,
+      isHovered: !0
+    })
+  });
+}, dt = ({ layer: e, mainAxis: t, panelSize: r, styleReaders: o, shouldAnimateTransitions: n, intro: a }) => {
+  const { boxes: s, outliers: i } = S(() => I(e.data, t), [e.data, t]), u = /* @__PURE__ */ k(X, {
+    boxes: s,
+    outliers: i,
+    mainAxis: t,
+    panelSize: r,
+    source: e,
+    styleReaders: o,
+    keys: S(() => G(e), [e]),
+    shouldAnimateTransitions: n
+  });
+  return a == null ? u : /* @__PURE__ */ k(we, {
+    intro: {
+      type: "fade",
+      layerId: a.layerId,
+      durationSeconds: a.durationSeconds
+    },
+    children: u
+  });
+}, gt = Oe(new je(), {
+  coord: "cartesian",
+  swatchShape: "square",
+  guideMode: "band",
+  render: ({ layer: e, coordSystem: t, panelRect: r, styleReaders: o, shouldAnimateTransitions: n, intro: a }) => /* @__PURE__ */ k(dt, {
+    layer: e,
+    mainAxis: E(t),
+    panelSize: r,
+    styleReaders: o,
+    shouldAnimateTransitions: n,
+    intro: a
+  }),
+  renderHighlight: ({ layer: e, sourceLayer: t, coordSystem: r, panelRect: o, styleReaders: n }) => /* @__PURE__ */ k(ct, {
+    layer: e,
+    sourceLayer: t,
+    mainAxis: E(r),
+    panelSize: o,
+    styleReaders: n
+  }),
+  renderHover: ({ layer: e, primary: t, coordSystem: r, panelRect: o, styleReaders: n }) => /* @__PURE__ */ k(ht, {
+    layer: e,
+    primary: t,
+    mainAxis: E(r),
+    panelSize: o,
+    styleReaders: n
+  }),
+  renderHoverCompanions: () => null,
+  getEditOutlineShapes: lt
+});
+export {
+  y as BOXPLOT_COLUMNS,
+  je as BoxplotGeom,
+  gt as boxplot
+};