react-semaphor 0.1.532 → 0.1.534

package/dist/chunks/pivot-header-presentation-CHs2GFrM.js

@@ -0,0 +1,753 @@
+var W = Object.defineProperty;
+var Y = (e, t, o) => t in e ? W(e, t, { enumerable: !0, configurable: !0, writable: !0, value: o }) : e[t] = o;
+var A = (e, t, o) => Y(e, typeof t != "symbol" ? t + "" : t, o);
+import { i as q } from "./raw-temporal-iMXRK-Qz.js";
+import { e as v, i as Z } from "./numeric-presentation-CWu3gunq.js";
+import { e as N, m as S, h as V, i as J, j as O } from "./matrix-formatter-DJCk8Znf.js";
+import { i as E } from "./pivot-result-lifecycle-DQz_gjGu.js";
+import { B as Q, bi as B, E as T, bd as ee, ba as te } from "./validators-DMSH81OM.js";
+import "./matrix-operation-contract-BKupLHXL.js";
+import "zod";
+import { g as G } from "./matrix-definition-D9iShKZI.js";
+import { PDF_SAFETY_LIMIT_EXCEEDED as U, getUtf8ByteLength as re, FAST_PDF_POLICY as oe } from "../pdf-export-policy/index.js";
+import { a as ne } from "./zoned-wall-clock-1qlWCE20.js";
+import { f as ae } from "./temporal-bucket-DlFuhCnT.js";
+function se(e, t, o) {
+  const a = {
+    ...t,
+    locale: t.locale ?? o
+  };
+  if (a.type === "number")
+    return v(e, a);
+  const { prefix: r, suffix: s, ...n } = a;
+  return `${r ?? ""}${v(e, {
+    ...n,
+    negativeStyle: a.type === "currency" ? a.negativeStyle : "minus"
+  })}${s ?? ""}`;
+}
+function M(e, t, o) {
+  return e === null ? { value: e, text: null } : !t || !q(t) && t.type !== "duration" ? {
+    value: e,
+    text: v(e, { type: "number", locale: o })
+  } : t.type === "duration" ? {
+    value: e,
+    text: Z(e, {
+      inputUnit: t.inputUnit,
+      outputStyle: t.outputStyle,
+      largestUnit: t.largestUnit,
+      smallestUnit: t.smallestUnit,
+      maxUnits: t.maxUnits,
+      prefix: t.prefix,
+      suffix: t.suffix,
+      negativeInParentheses: t.negativeStyle === "parentheses"
+    })
+  } : { value: e, text: se(e, t, o) };
+}
+function I(e, t, o, a) {
+  return e === null ? { value: e, text: null } : a === "percent" ? {
+    value: e,
+    text: v(e, {
+      type: "percent",
+      locale: o,
+      minimumFractionDigits: t,
+      maximumFractionDigits: t,
+      percentValueMode: "fraction"
+    })
+  } : {
+    value: e,
+    text: v(e, {
+      type: "number",
+      locale: o,
+      minimumFractionDigits: t,
+      maximumFractionDigits: t,
+      suffix: "×"
+    })
+  };
+}
+function _(e, t) {
+  if (e === void 0) return t;
+  if (!Number.isInteger(e) || e < 0 || e > 6)
+    throw new RangeError("Comparison precision must be an integer from 0 to 6.");
+  return e;
+}
+function Ve(e, t) {
+  const o = {
+    mode: t.displayMode,
+    current: M(
+      e.currentValue,
+      t.metricFormat,
+      t.locale
+    ),
+    comparison: M(
+      e.comparisonValue,
+      t.metricFormat,
+      t.locale
+    )
+  };
+  return (t.displayMode === "difference" || t.displayMode === "both") && (o.difference = M(
+    e.delta,
+    t.metricFormat,
+    t.locale
+  )), (t.displayMode === "percent_change" || t.displayMode === "both") && (o.percentChange = I(
+    e.percentChange,
+    _(t.precision, 1),
+    t.locale,
+    "percent"
+  )), t.displayMode === "ratio" && (o.ratio = I(
+    e.ratio,
+    _(t.precision, 2),
+    t.locale,
+    "ratio"
+  )), o;
+}
+const le = 1e4, Oe = 1e6, Be = 5e6, Ge = 1024 ** 3, Ue = 1024 ** 3;
+function je(e) {
+  return e > le;
+}
+const Xe = {
+  rowLabels: "tabular",
+  subtotals: "after"
+};
+function ze(e, t) {
+  const o = t.rowLabels === "outline" ? { kind: "compact" } : e.layout.kind === "tabular" ? e.layout : { kind: "tabular", repeatLabels: !1 }, a = e.totals.rows;
+  return {
+    ...e,
+    layout: o,
+    totals: {
+      ...e.totals,
+      rows: {
+        ...a,
+        levels: Object.fromEntries(
+          Object.entries(a.levels).map(([r, s]) => [
+            r,
+            { ...s, position: t.subtotals }
+          ])
+        )
+      }
+    }
+  };
+}
+const ie = 2;
+function ce(e) {
+  return typeof e == "number" ? Number.isInteger(e) : B(e) ? !e.value.includes(".") : !0;
+}
+function ue(e, t, o) {
+  const a = e.descriptors.measures.filter(
+    (n) => o.measureFormats[n.id] === void 0 && n.semanticFormat === void 0 && Q(n.column.dataType) === "number"
+  );
+  if (a.length === 0) return o;
+  const r = /* @__PURE__ */ new Set();
+  e.columns.forEach((n, l) => {
+    if (!(n.kind !== "measure" || r.has(n.measureId)))
+      for (const u of t) {
+        const i = u.values[l];
+        if ((i == null ? void 0 : i.kind) === "value" && !ce(i.value)) {
+          r.add(n.measureId);
+          return;
+        }
+      }
+  });
+  const s = { ...o.measureFormats };
+  for (const { id: n } of a) {
+    const l = r.has(n) ? ie : 0;
+    s[n] = {
+      type: "number",
+      minimumFractionDigits: l,
+      maximumFractionDigits: l,
+      useGrouping: !0
+    };
+  }
+  return { ...o, measureFormats: s };
+}
+function P(e) {
+  return T(e.slice(0, -1));
+}
+function me(e, t) {
+  return t.length > e.length && T(t.slice(0, e.length)) === T(e);
+}
+function fe(e) {
+  return e.map((t, o) => {
+    if (o === 0 || t.kind !== "layout") return !1;
+    const a = e[o - 1];
+    if (a.kind !== "layout") return !1;
+    if (t.role !== "member" || me(a.rowPath, t.rowPath)) return !0;
+    const r = e[o - 2];
+    return a.role === "member" && (!r || r.kind !== "layout" || r.role !== "member" || P(r.rowPath) !== P(a.rowPath)) && t.rowPath.length === a.rowPath.length && P(t.rowPath) === P(a.rowPath);
+  });
+}
+const de = "pdf-group-continuation";
+function ge(e) {
+  if (!e.previousRow || e.row.isSubtotal === !0 || e.row.isGrandTotal === !0 || e.previousRow.isSubtotal === !0 || e.previousRow.isGrandTotal === !0)
+    return !0;
+  for (let t = 0; t <= e.levelIndex; t++)
+    if (e.getValue(e.row, t) !== e.getValue(e.previousRow, t))
+      return !0;
+  return !1;
+}
+function j(e, t, o) {
+  return !(o != null && o.hasTextAffixes) && t.kind === "value" && (typeof t.value == "number" || B(t.value)) ? e : E(e);
+}
+function he(e, t, o) {
+  const a = N(e.descriptors, t.presentation, o), r = e.columns.map((c) => {
+    var m;
+    return c.kind === "measure" && ((m = a.measureSemantics.get(c.measureId)) == null ? void 0 : m.isNumeric) === !0;
+  }), s = (c) => S([c], a.levels), n = (c, m, f) => V(c, m, t.presentation.totals[f], a.levels), l = e.columns.map((c) => {
+    if (c.kind !== "measure") return c.label;
+    const m = c.columnPath.map(s);
+    return c.role !== "member" && m.push(n(c.columnPath, c.role, "columns")), [...m, c.label].join(" / ");
+  }), u = Math.min(t.spec.columns.length, Math.max(
+    0,
+    ...e.columns.map((c) => c.kind === "measure" ? c.columnPath.length + (c.role !== "member" ? 1 : 0) : 0)
+  )), i = Array.from({ length: u + 1 }, (c, m) => e.columns.map((f) => m === u ? f.label : f.kind !== "measure" ? "" : m < f.columnPath.length ? s(f.columnPath[m]) : m === f.columnPath.length && f.role !== "member" ? n(f.columnPath, f.role, "columns") : "")), d = (c, m) => J({
+    path: c.rowPath,
+    role: c.kind === "layout" ? c.role : "member",
+    levelCount: Math.max(1, t.spec.rows.length),
+    repeatLabels: t.presentation.layout.kind !== "tabular" || t.presentation.layout.repeatLabels,
+    previousPath: m == null ? void 0 : m.rowPath
+  }), g = (c, m) => {
+    if (c.kind !== "layout") throw new Error("Layout presentation requires layout rows.");
+    if (c.values.length !== e.columns.length) throw new Error("Matrix row does not match its frozen layout.");
+    const f = d(c, m);
+    return e.columns.map((p, w) => {
+      if (p.kind === "hierarchy")
+        return `${"  ".repeat(Math.max(0, c.rowPath.length - 1))}${n(c.rowPath, c.role, "rows")}`;
+      if (p.kind === "level") {
+        const x = t.spec.rows.findIndex((H) => H.id === p.levelId), b = f[x];
+        return b != null && b.visible ? b.total ? n(c.rowPath, c.role, "rows") : S(b.path, a.levels) : "";
+      }
+      const L = c.values[w], y = a.measures.get(p.measureId);
+      if (L.kind === "value" && !y)
+        throw new Error("Matrix value is missing its measure descriptor.");
+      return O(L, y, t.presentation.absence);
+    });
+  }, h = (c, m) => g(c, m).map((f, p) => {
+    const w = e.columns[p];
+    return w.kind === "measure" ? j(f, c.values[p], a.measureSemantics.get(w.measureId)) : E(f);
+  });
+  return {
+    headers: l,
+    headerBands: i,
+    numericColumns: r,
+    /** A row's cells; after `previous`, a tabular layout prints each label once. */
+    row: (c, m) => g(c, m),
+    /**
+     * Level columns whose group label the row above shows, so this row
+     * continues the group (Plan 2, 2d, C8). Only a member row after a member
+     * row continues one: a total prints as a band, and its rules stay whole
+     * above and below it.
+     */
+    continuedColumns: (c, m) => {
+      const f = (w) => (w == null ? void 0 : w.kind) === "layout" && w.role === "member";
+      if (!f(c) || !f(m)) return [];
+      const p = d(c, m);
+      return e.columns.flatMap((w, L) => {
+        var x;
+        if (w.kind !== "level") return [];
+        const y = t.spec.rows.findIndex((b) => b.id === w.levelId);
+        return y < c.rowPath.length && ((x = p[y]) == null ? void 0 : x.visible) === !1 ? [L] : [];
+      });
+    },
+    csvRow: (c) => h(c),
+    /**
+     * `previousRow` is the row before `data[0]`, carried by the export's
+     * continuation, so a tabular layout prints each label once across the
+     * whole file. Retries are pure: suppression never relies on mutable
+     * formatter state or an earlier worker. Without it, the first row prints
+     * its labels.
+     */
+    csvRows: (c, m) => c.map((f, p) => h(f, p ? c[p - 1] : m ?? void 0))
+  };
+}
+function Ke(e) {
+  return e.columns.map((t) => E(t.label));
+}
+function He(e, t, o) {
+  if (e.kind !== "flat") throw new Error("Flat Matrix CSV requires flat rows.");
+  if (e.values.length !== t.columns.length) throw new Error("Matrix row does not match its frozen layout.");
+  const a = [...e.rowPath, ...e.columnPath];
+  return t.columns.map((r, s) => {
+    if (r.kind === "measure") {
+      const l = e.values[s], u = o.measures.get(r.measureId);
+      if (l.kind === "value" && !u) throw new Error("Matrix value is missing its measure descriptor.");
+      return j(
+        O(l, u, o.absence),
+        l,
+        o.measureSemantics.get(r.measureId)
+      );
+    }
+    const n = r.kind === "level" ? a.find((l) => l.levelId === r.levelId) : void 0;
+    if (!n) throw new Error("Flat Matrix row does not match its frozen layout.");
+    return E(S([n], o.levels));
+  });
+}
+function pe(e) {
+  const t = he(e.layout, e.request, e.report), o = e.layout.columns.map((n, l) => ({
+    index: l,
+    columnId: `matrix:${l}`,
+    label: t.headers[l],
+    isNumeric: t.numericColumns[l]
+  })), a = (n, l, u) => ({
+    text: n,
+    colspan: 1,
+    rowspan: 1,
+    columnId: o[l].columnId,
+    isHeader: u,
+    isNumeric: o[l].isNumeric,
+    className: o[l].isNumeric ? "numeric" : e.layout.columns[l].kind === "hierarchy" ? "matrix-hierarchy" : ""
+  }), r = [], s = e.layout.columns.findIndex((n) => n.kind === "measure");
+  e.request.spec.columns.length && s >= 0 && r.push({
+    repeatHeader: !0,
+    headerType: "pivot-axis",
+    headerRowIndex: 0,
+    cells: [
+      ...s ? [{ ...a("", 0, !0), colspan: s }] : [],
+      {
+        ...a(e.request.spec.columns.map((n) => G(n, e.request.presentation)).join(" / "), s, !0),
+        colspan: e.layout.columns.length - s,
+        isNumeric: !1,
+        className: ""
+      }
+    ]
+  });
+  for (const [n, l] of t.headerBands.entries())
+    r.push({
+      repeatHeader: !0,
+      headerType: n === t.headerBands.length - 1 ? "metrics" : "pivot-level",
+      headerRowIndex: r.length,
+      cells: l.map((u, i) => a(u, i, !0))
+    });
+  return {
+    headers: r,
+    rows: e.rows.map((n, l) => {
+      const u = new Set(t.continuedColumns(n, e.rows[l - 1]));
+      return {
+        index: l,
+        type: n.kind === "layout" && n.role !== "member" ? "subtotal" : "data",
+        subtotalLevel: String(n.rowPath.length),
+        // A tabular layout prints each label once unless it repeats them; the
+        // blank cell continues its group, so a grid draws no rule above it.
+        cells: t.row(n, e.rows[l - 1]).map((i, d) => u.has(d) ? { ...a(i, d, !1), className: de } : a(i, d, !1))
+      };
+    }),
+    grandTotal: null,
+    // Totals are already in the ordered body at their authored position.
+    metadata: {
+      tableType: "pivot",
+      totalRows: e.rows.length,
+      totalColumns: o.length,
+      rowLevels: e.layout.columns.filter((n) => n.kind !== "measure").length,
+      pivotLevels: e.request.spec.columns.length,
+      hasGrandTotal: !1,
+      columnOrder: o.map((n) => n.columnId),
+      columns: o
+    }
+  };
+}
+function we(e, t, o) {
+  const { levels: a } = N(e.descriptors, t.presentation, o), r = t.spec.columns.length > 0, s = [], n = [], l = e.columns.map((i, d) => {
+    if (i.kind !== "measure") return null;
+    const g = r ? `${i.role}:${T(i.columnPath)}` : `measure:${d}`;
+    let h = s.indexOf(g);
+    return h < 0 && (h = s.push(g) - 1, n.push(r ? V(i.columnPath, i.role, t.presentation.totals.columns, a) : i.label)), h;
+  }), u = t.spec.columns[t.spec.columns.length - 1];
+  return {
+    columnGroups: l,
+    groupLabels: n,
+    /** What bands name their groups by: the innermost column level, or "Measures". */
+    groupLevelLabel: u ? G(u, t.presentation) : "Measures"
+  };
+}
+function We(e) {
+  const { layout: t, rows: o, report: a } = e, r = {
+    ...e.request,
+    presentation: ue(t, o, e.request.presentation)
+  }, s = pe({ layout: t, rows: o, request: r, report: a }), n = fe(o), l = we(t, r, a), u = {
+    ...s,
+    rows: s.rows.map((i, d) => ({ ...i, keepWithPrevious: n[d] })),
+    metadata: { ...s.metadata, ...l }
+  };
+  return { request: r, table: u, ...l };
+}
+class be extends Error {
+  constructor() {
+    super(...arguments);
+    A(this, "code", U);
+  }
+}
+function R(e) {
+  if (!e || typeof e != "object")
+    return;
+  const { error: t, message: o, detail: a } = e;
+  for (const r of [t, o, a])
+    if (typeof r == "string" && r.trim())
+      return r.trim();
+}
+async function ye(e) {
+  const t = `PDF request failed: ${e.status} ${e.statusText}`.trim(), o = e.headers.get("content-type") || "";
+  try {
+    if (o.includes("application/json")) {
+      const r = await e.json(), s = typeof r.code == "string" ? r.code : typeof r.errorCode == "string" ? r.errorCode : void 0;
+      return { message: R(r) || t, code: s };
+    }
+    const a = await e.text();
+    if (!a.trim())
+      return { message: t };
+    try {
+      const r = JSON.parse(a), s = typeof r.code == "string" ? r.code : typeof r.errorCode == "string" ? r.errorCode : void 0;
+      return {
+        message: R(r) || a.trim(),
+        code: s
+      };
+    } catch {
+      return { message: a.trim() };
+    }
+  } catch {
+    return { message: t };
+  }
+}
+async function Ye(e) {
+  if (!e.token) throw new Error("Missing auth token for PDF export");
+  if (re(e.serializedPayload) > oe.maxRequestBytes)
+    throw new Error("Fast-path PDF request exceeds the structured body limit");
+  const t = await (e.fetchImpl ?? fetch)(e.url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", Authorization: `Bearer ${e.token}` },
+    body: e.serializedPayload,
+    signal: e.signal
+  });
+  if (!t.ok) {
+    const a = await ye(t);
+    throw a.code === U ? new be(a.message) : new Error(a.message);
+  }
+  const o = await t.json();
+  if (o != null && o.error) throw new Error(o.error);
+  if (typeof (o == null ? void 0 : o.url) != "string" || !o.url.trim())
+    throw new Error("Fast-path PDF response missing download URL");
+  return o;
+}
+const ve = /^\d{4}-\d{2}-\d{2}$/;
+function X(e) {
+  const t = e.split(".");
+  return t[t.length - 1].replace(/_/g, " ").replace(/([a-z])([A-Z])/g, "$1 $2").split(" ").map((r) => r.charAt(0).toUpperCase() + r.slice(1).toLowerCase()).join(" ");
+}
+const F = 10;
+function C(e, t) {
+  const o = e.slice(0, F).map(t).join(", "), a = e.length - F;
+  return a > 0 ? `${o}, and ${a} more` : o;
+}
+function Le(e) {
+  if (e.valueType !== "date" || e.operation !== "between" && e.operation !== "not between")
+    return;
+  const t = ee(e.relativeMeta);
+  if (t)
+    return te(t) || t.unit === "quarter" || t.unit === "year" ? t : void 0;
+}
+function D(e, t = {}) {
+  const { name: o, operation: a, values: r, valueType: s } = e, n = t.label ?? X(o), l = Le(e);
+  if (l) {
+    const i = ne(l);
+    if (i)
+      return a === "between" ? `${n}: ${i}` : `${n} not in ${i}`;
+  }
+  if (!r || r.length === 0)
+    return a === "is null" ? `${n} is empty` : a === "is not null" ? `${n} is not empty` : "";
+  const u = (i) => {
+    if (s === "date" && i) {
+      const d = e.temporalPrecision === "minute", g = {
+        year: "numeric",
+        month: "short",
+        day: "numeric",
+        ...d ? {
+          hour: "numeric",
+          minute: "2-digit"
+        } : {}
+      };
+      if (typeof i == "string" && ve.test(i)) {
+        const [c, m, f] = i.split("-").map(Number);
+        return new Intl.DateTimeFormat(void 0, {
+          year: "numeric",
+          month: "short",
+          day: "numeric",
+          timeZone: "UTC"
+        }).format(new Date(Date.UTC(c, m - 1, f)));
+      }
+      const h = new Date(i);
+      if (!isNaN(h.getTime()))
+        try {
+          return new Intl.DateTimeFormat(void 0, {
+            ...g,
+            ...t.timezone ? { timeZone: t.timezone } : {}
+          }).format(h);
+        } catch {
+          return d ? h.toLocaleString(void 0, g) : h.toLocaleDateString(void 0, g);
+        }
+    }
+    return String(i);
+  };
+  switch (a) {
+    case "=":
+      return `${n}: ${u(r[0])}`;
+    case "!=":
+      return `${n} ≠ ${u(r[0])}`;
+    case ">":
+      return `${n} > ${u(r[0])}`;
+    case "<":
+      return `${n} < ${u(r[0])}`;
+    case ">=":
+      return `${n} ≥ ${u(r[0])}`;
+    case "<=":
+      return `${n} ≤ ${u(r[0])}`;
+    case "between":
+    case "not between": {
+      const i = `${u(r[0])} - ${u(r[1])}`;
+      return a === "between" ? `${n}: ${i}` : `${n} not in ${i}`;
+    }
+    case "in":
+      return r.length === 1 ? `${n}: ${u(r[0])}` : `${n}: ${C(r, u)}`;
+    case "not in":
+      return `${n} not in (${C(r, u)})`;
+    case "like":
+      return `${n} contains "${r[0]}"`;
+    case "not like":
+      return `${n} doesn't contain "${r[0]}"`;
+    default:
+      return `${n}: ${C(r, u)}`;
+  }
+}
+function qe(e, t = {}) {
+  if (!e || e.length === 0)
+    return "";
+  const o = /* @__PURE__ */ new Map();
+  e.forEach((r) => {
+    const s = o.get(r.name) || [];
+    s.push(r), o.set(r.name, s);
+  });
+  const a = [];
+  return o.forEach((r, s) => {
+    if (r.length === 1) {
+      const n = D(r[0], t);
+      n && a.push(n);
+    } else {
+      const n = X(s), l = r.map((u) => D(u, t).replace(`${n}: `, "").replace(`${n} `, "")).filter(Boolean);
+      l.length > 0 && a.push(`${n}: ${l.join(" and ")}`);
+    }
+  }), a.join(" | ");
+}
+const xe = "__TOTAL__";
+function $(e) {
+  return typeof e == "object" && e !== null && !Array.isArray(e);
+}
+function k(e) {
+  return e === xe;
+}
+function Ze(e) {
+  const t = /* @__PURE__ */ new Map(), o = (e.groupByColumns ?? []).map((r, s) => {
+    var i, d, g;
+    if (!$(r))
+      throw new Error(`Aggregate groupByColumns[${s}] is invalid`);
+    const n = typeof r.id == "string" && r.id.length > 0 ? r.id : void 0, l = n ? (g = (d = (i = e.columnKeyMap) == null ? void 0 : i.byRole) == null ? void 0 : d.groupby) == null ? void 0 : g[n] : void 0, u = (l == null ? void 0 : l.outputKey) || (l == null ? void 0 : l.rawKey) || (typeof r.alias == "string" && r.alias.length > 0 ? r.alias : typeof r.name == "string" && r.name.length > 0 ? r.name : void 0);
+    if (!u)
+      throw new Error(`Aggregate groupByColumns[${s}] has no output key`);
+    return [n, r.alias, r.name, u].forEach((h) => {
+      typeof h == "string" && h.length > 0 && t.set(h, u);
+    }), u;
+  }), a = (e.rowAggregates ?? []).flatMap((r) => !$(r) || typeof r.function != "string" || typeof r.groupLevel != "string" ? [] : [
+    {
+      function: r.function,
+      groupLevel: r.groupLevel === "ALL" ? "ALL" : t.get(r.groupLevel) || r.groupLevel,
+      ...typeof r.label == "string" ? { label: r.label } : {}
+    }
+  ]);
+  return { groupColumnKeys: o, rowAggregates: a };
+}
+function z(e) {
+  return e === "SUM" ? "Total" : e.charAt(0).toUpperCase() + e.slice(1).toLowerCase();
+}
+function Pe(e) {
+  var o;
+  if (e.customLabel) return e.customLabel;
+  const t = z(e.aggregateFunction);
+  if (e.levelValue !== void 0 && !k(e.levelValue)) {
+    if (e.levelValue === null) {
+      const r = (o = e.formatValue) == null ? void 0 : o.call(e, null);
+      return r ? `Subtotal ${r}` : `Subtotal ${t}`;
+    }
+    const a = e.formatValue ? e.formatValue(e.levelValue) : String(e.levelValue);
+    if (a) return `Subtotal (${a})`;
+  }
+  return `Subtotal ${t}`;
+}
+function Te(e, t) {
+  return t || `Grand ${z(e)}`;
+}
+function Je(e) {
+  const t = e.context.groupColumnKeys.indexOf(e.columnKey);
+  if (t < 0)
+    throw new Error(
+      `Aggregate group column "${e.columnKey}" is unknown`
+    );
+  return ge({
+    row: e.row,
+    previousRow: e.previousRow,
+    levelIndex: t,
+    getValue: (o, a) => o[e.context.groupColumnKeys[a]]
+  });
+}
+function K(e) {
+  var a, r;
+  const t = e.context.groupColumnKeys, o = typeof e.row.aggregate == "string" ? e.row.aggregate : "SUM";
+  if (e.row.isGrandTotal === !0) {
+    const s = (a = e.context.rowAggregates.find(
+      (n) => n.groupLevel === "ALL"
+    )) == null ? void 0 : a.label;
+    return {
+      kind: "grand-total",
+      cells: t.map((n, l) => ({
+        columnKey: n,
+        text: l === 0 ? Te(o, s) : "",
+        placement: l === 0 ? "label" : "empty",
+        colSpan: l === 0 ? t.length : 1
+      }))
+    };
+  }
+  if (e.row.isSubtotal === !0) {
+    if (typeof e.row.subtotalLevel != "string")
+      throw new Error("Aggregate subtotal row is missing subtotalLevel");
+    const s = t.indexOf(e.row.subtotalLevel);
+    if (s < 0)
+      throw new Error(
+        `Aggregate subtotal level "${e.row.subtotalLevel}" has no group column`
+      );
+    const n = $(e.row.subtotalContext) ? e.row.subtotalContext : void 0, l = $(n == null ? void 0 : n.groupByValues) ? n.groupByValues : {}, u = (r = e.context.rowAggregates.find(
+      (i) => i.groupLevel === e.row.subtotalLevel && i.function === o
+    )) == null ? void 0 : r.label;
+    return {
+      kind: "subtotal",
+      cells: t.map((i, d) => {
+        if (d > s)
+          return {
+            columnKey: i,
+            text: "",
+            placement: "empty",
+            colSpan: 1
+          };
+        if (d < s) {
+          const g = e.row[i];
+          return {
+            columnKey: i,
+            text: g === void 0 || k(g) ? "" : e.formatValue(g, i),
+            placement: "value",
+            colSpan: 1
+          };
+        }
+        return {
+          columnKey: i,
+          text: Pe({
+            aggregateFunction: o,
+            customLabel: u,
+            levelValue: l[i],
+            formatValue: (g) => e.formatLabelValue ? e.formatLabelValue(g, i) : String(e.formatValue(g, i) ?? "")
+          }),
+          placement: "label",
+          colSpan: t.length - s
+        };
+      })
+    };
+  }
+  return {
+    kind: "data",
+    cells: t.map((s) => {
+      const n = e.row[s];
+      return {
+        columnKey: s,
+        text: n === void 0 || k(n) ? "" : e.formatValue(n, s),
+        placement: "value",
+        colSpan: 1
+      };
+    })
+  };
+}
+function Qe(e) {
+  const t = K(e).cells.find(
+    (o) => o.columnKey === e.columnKey
+  );
+  if (!t)
+    throw new Error(`Aggregate group column "${e.columnKey}" is unknown`);
+  return t.text;
+}
+function et(e) {
+  return K(e).cells.map((t) => t.text);
+}
+class $e extends Error {
+  constructor(o, a) {
+    super(`${o}: ${a}`);
+    A(this, "deliveryBlocking", !0);
+    this.code = o, this.name = "PivotHeaderPresentationError";
+  }
+}
+function tt(e) {
+  var r;
+  const t = e.mode ?? "formatted", o = e.members.map((s) => {
+    var l;
+    if (t === "canonical" || !s.temporalBucket)
+      return s.value === null ? "" : String(s.value);
+    const n = (l = e.resolveTemporalFormat) == null ? void 0 : l.call(e, s.fieldId);
+    if (!n)
+      throw new $e(
+        "missing_resolved_temporal_format",
+        `Missing resolved temporal presentation for pivot field "${s.fieldId}"`
+      );
+    return ae({
+      value: s.value,
+      metadata: s.temporalBucket,
+      format: n
+    });
+  }), a = ((r = e.metricLabel) == null ? void 0 : r.trim()) || void 0;
+  return {
+    memberLabels: o,
+    ...a ? { metricLabel: a } : {},
+    flattenedLabel: [
+      ...o,
+      ...a ? [a] : []
+    ].join(" / ")
+  };
+}
+export {
+  xe as A,
+  K as B,
+  Qe as C,
+  le as D,
+  et as E,
+  Oe as F,
+  $e as G,
+  tt as H,
+  ge as I,
+  Be as M,
+  de as P,
+  Ge as a,
+  Ue as b,
+  He as c,
+  pe as d,
+  We as e,
+  Ve as f,
+  Xe as g,
+  ze as h,
+  ie as i,
+  ue as j,
+  fe as k,
+  be as l,
+  Ke as m,
+  ye as n,
+  Ye as o,
+  he as p,
+  F as q,
+  je as r,
+  Le as s,
+  D as t,
+  qe as u,
+  k as v,
+  Ze as w,
+  Pe as x,
+  Te as y,
+  Je as z
+};