react-semaphor 0.1.514 → 0.1.516

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

@@ -0,0 +1,661 @@
+var U = Object.defineProperty;
+var j = (e, r, t) => r in e ? U(e, r, { enumerable: !0, configurable: !0, writable: !0, value: t }) : e[r] = t;
+var A = (e, r, t) => j(e, typeof r != "symbol" ? r + "" : r, t);
+import { i as X } from "./index-C8w91oj4.js";
+import { g as L, i as H } from "./raw-temporal-BqOfk-xN.js";
+import { e as F, m as I, h as O, i as K, j as z } from "./matrix-formatter-CCXNRt3s.js";
+import { al as W, b5 as k, S } from "./validators-CsdOtZI6.js";
+import "./matrix-operation-contract-D32U2CSw.js";
+import { g as D } from "./matrix-definition-E5gXXSTZ.js";
+import { PDF_SAFETY_LIMIT_EXCEEDED as $, getUtf8ByteLength as Y, FAST_PDF_POLICY as q } from "../pdf-export-policy/index.js";
+import { f as J } from "./temporal-bucket-DlFuhCnT.js";
+function Z(e, r, t) {
+  const n = {
+    ...r,
+    locale: r.locale ?? t
+  };
+  if (n.type === "number")
+    return L(e, n);
+  const { prefix: o, suffix: s, ...a } = n;
+  return `${o ?? ""}${L(e, {
+    ...a,
+    negativeStyle: n.type === "currency" ? n.negativeStyle : "minus"
+  })}${s ?? ""}`;
+}
+function E(e, r, t) {
+  return e === null ? { value: e, text: null } : !r || !X(r) && r.type !== "duration" ? {
+    value: e,
+    text: L(e, { type: "number", locale: t })
+  } : r.type === "duration" ? {
+    value: e,
+    text: H(e, {
+      inputUnit: r.inputUnit,
+      outputStyle: r.outputStyle,
+      largestUnit: r.largestUnit,
+      smallestUnit: r.smallestUnit,
+      maxUnits: r.maxUnits,
+      prefix: r.prefix,
+      suffix: r.suffix,
+      negativeInParentheses: r.negativeStyle === "parentheses"
+    })
+  } : { value: e, text: Z(e, r, t) };
+}
+function _(e, r, t, n) {
+  return e === null ? { value: e, text: null } : n === "percent" ? {
+    value: e,
+    text: L(e, {
+      type: "percent",
+      locale: t,
+      minimumFractionDigits: r,
+      maximumFractionDigits: r,
+      percentValueMode: "fraction"
+    })
+  } : {
+    value: e,
+    text: L(e, {
+      type: "number",
+      locale: t,
+      minimumFractionDigits: r,
+      maximumFractionDigits: r,
+      suffix: "×"
+    })
+  };
+}
+function R(e, r) {
+  if (e === void 0) return r;
+  if (!Number.isInteger(e) || e < 0 || e > 6)
+    throw new RangeError("Comparison precision must be an integer from 0 to 6.");
+  return e;
+}
+function Ce(e, r) {
+  const t = {
+    mode: r.displayMode,
+    current: E(
+      e.currentValue,
+      r.metricFormat,
+      r.locale
+    ),
+    comparison: E(
+      e.comparisonValue,
+      r.metricFormat,
+      r.locale
+    )
+  };
+  return (r.displayMode === "difference" || r.displayMode === "both") && (t.difference = E(
+    e.delta,
+    r.metricFormat,
+    r.locale
+  )), (r.displayMode === "percent_change" || r.displayMode === "both") && (t.percentChange = _(
+    e.percentChange,
+    R(r.precision, 1),
+    r.locale,
+    "percent"
+  )), r.displayMode === "ratio" && (t.ratio = _(
+    e.ratio,
+    R(r.precision, 2),
+    r.locale,
+    "ratio"
+  )), t;
+}
+function M(e) {
+  const r = e.trimStart().charAt(0);
+  return ["=", "+", "-", "@"].includes(r) || ["	", "\r", `
+`].includes(e.charAt(0)) ? `'${e}` : e;
+}
+function Q(e, r = ",") {
+  if (e == null)
+    return "";
+  const t = String(e);
+  return t.includes(r) || t.includes('"') || t.includes(`
+`) || t.includes("\r") ? `"${t.replace(/"/g, '""')}"` : t;
+}
+function ee(e, r = ",") {
+  return e.map((t) => Q(t, r)).join(r);
+}
+function re(e, r = {}) {
+  const { delimiter: t = ",", lineEnding: n = `
+` } = r;
+  return e.map((o) => ee(o, t)).join(n);
+}
+function ke(e, r = {}) {
+  if (e.length === 0)
+    return "";
+  const {
+    delimiter: t = ",",
+    lineEnding: n = `
+`,
+    includeHeaders: o = !0,
+    columns: s
+  } = r, a = s || Object.keys(e[0]), l = [];
+  o && l.push(a);
+  for (const m of e) {
+    const u = a.map((d) => {
+      const g = m[d];
+      return g == null ? "" : String(g);
+    });
+    l.push(u);
+  }
+  return re(l, { delimiter: t, lineEnding: n });
+}
+const te = 1e4, Me = 1e6, Ie = 5e6, _e = 1024 ** 3, Re = 1024 ** 3;
+function Ve(e) {
+  return e > te;
+}
+const Fe = {
+  rowLabels: "tabular",
+  subtotals: "after"
+};
+function Oe(e, r) {
+  const t = r.rowLabels === "outline" ? { kind: "compact" } : e.layout.kind === "tabular" ? e.layout : { kind: "tabular", repeatLabels: !1 }, n = e.totals.rows;
+  return {
+    ...e,
+    layout: t,
+    totals: {
+      ...e.totals,
+      rows: {
+        ...n,
+        levels: Object.fromEntries(
+          Object.entries(n.levels).map(([o, s]) => [
+            o,
+            { ...s, position: r.subtotals }
+          ])
+        )
+      }
+    }
+  };
+}
+const oe = 2;
+function ne(e) {
+  return typeof e == "number" ? Number.isInteger(e) : k(e) ? !e.value.includes(".") : !0;
+}
+function ae(e, r, t) {
+  const n = e.descriptors.measures.filter(
+    (a) => t.measureFormats[a.id] === void 0 && a.semanticFormat === void 0 && W(a.column.dataType) === "number"
+  );
+  if (n.length === 0) return t;
+  const o = /* @__PURE__ */ new Set();
+  e.columns.forEach((a, l) => {
+    if (!(a.kind !== "measure" || o.has(a.measureId)))
+      for (const m of r) {
+        const u = m.values[l];
+        if ((u == null ? void 0 : u.kind) === "value" && !ne(u.value)) {
+          o.add(a.measureId);
+          return;
+        }
+      }
+  });
+  const s = { ...t.measureFormats };
+  for (const { id: a } of n) {
+    const l = o.has(a) ? oe : 0;
+    s[a] = {
+      type: "number",
+      minimumFractionDigits: l,
+      maximumFractionDigits: l,
+      useGrouping: !0
+    };
+  }
+  return { ...t, measureFormats: s };
+}
+function P(e) {
+  return S(e.slice(0, -1));
+}
+function se(e, r) {
+  return r.length > e.length && S(r.slice(0, e.length)) === S(e);
+}
+function le(e) {
+  return e.map((r, t) => {
+    if (t === 0 || r.kind !== "layout") return !1;
+    const n = e[t - 1];
+    if (n.kind !== "layout") return !1;
+    if (r.role !== "member" || se(n.rowPath, r.rowPath)) return !0;
+    const o = e[t - 2];
+    return n.role === "member" && (!o || o.kind !== "layout" || o.role !== "member" || P(o.rowPath) !== P(n.rowPath)) && r.rowPath.length === n.rowPath.length && P(r.rowPath) === P(n.rowPath);
+  });
+}
+const ie = "pdf-group-continuation";
+function ue(e) {
+  if (!e.previousRow || e.row.isSubtotal === !0 || e.row.isGrandTotal === !0 || e.previousRow.isSubtotal === !0 || e.previousRow.isGrandTotal === !0)
+    return !0;
+  for (let r = 0; r <= e.levelIndex; r++)
+    if (e.getValue(e.row, r) !== e.getValue(e.previousRow, r))
+      return !0;
+  return !1;
+}
+function ce(e, r, t) {
+  const n = F(e.descriptors, r.presentation, t), o = e.columns.map((i) => {
+    var c;
+    return i.kind === "measure" && ((c = n.measureSemantics.get(i.measureId)) == null ? void 0 : c.isNumeric) === !0;
+  }), s = (i) => I([i], n.levels), a = (i, c, f) => O(i, c, r.presentation.totals[f], n.levels), l = e.columns.map((i) => {
+    if (i.kind !== "measure") return i.label;
+    const c = i.columnPath.map(s);
+    return i.role !== "member" && c.push(a(i.columnPath, i.role, "columns")), [...c, i.label].join(" / ");
+  }), m = Math.min(r.spec.columns.length, Math.max(
+    0,
+    ...e.columns.map((i) => i.kind === "measure" ? i.columnPath.length + (i.role !== "member" ? 1 : 0) : 0)
+  )), u = Array.from({ length: m + 1 }, (i, c) => e.columns.map((f) => c === m ? f.label : f.kind !== "measure" ? "" : c < f.columnPath.length ? s(f.columnPath[c]) : c === f.columnPath.length && f.role !== "member" ? a(f.columnPath, f.role, "columns") : "")), d = (i, c) => K({
+    path: i.rowPath,
+    role: i.kind === "layout" ? i.role : "member",
+    levelCount: Math.max(1, r.spec.rows.length),
+    repeatLabels: r.presentation.layout.kind !== "tabular" || r.presentation.layout.repeatLabels,
+    previousPath: c == null ? void 0 : c.rowPath
+  }), g = (i, c) => {
+    if (i.kind !== "layout") throw new Error("Layout presentation requires layout rows.");
+    if (i.values.length !== e.columns.length) throw new Error("Matrix row does not match its frozen layout.");
+    const f = d(i, c);
+    return e.columns.map((w, p) => {
+      if (w.kind === "hierarchy")
+        return `${"  ".repeat(Math.max(0, i.rowPath.length - 1))}${a(i.rowPath, i.role, "rows")}`;
+      if (w.kind === "level") {
+        const y = r.spec.rows.findIndex((B) => B.id === w.levelId), v = f[y];
+        return v != null && v.visible ? v.total ? a(i.rowPath, i.role, "rows") : I(v.path, n.levels) : "";
+      }
+      const b = i.values[p], x = n.measures.get(w.measureId);
+      if (b.kind === "value" && !x)
+        throw new Error("Matrix value is missing its measure descriptor.");
+      return z(b, x, r.presentation.absence);
+    });
+  }, h = (i, c) => g(i, c).map((f, w) => {
+    var y;
+    const p = i.values[w], b = e.columns[w];
+    return b.kind === "measure" && !((y = n.measureSemantics.get(b.measureId)) != null && y.hasTextAffixes) && p.kind === "value" && (typeof p.value == "number" || k(p.value)) ? f : M(f);
+  });
+  return {
+    headers: l,
+    headerBands: u,
+    numericColumns: o,
+    /** A row's cells; after `previous`, a tabular layout prints each label once. */
+    row: (i, c) => g(i, c),
+    /**
+     * 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: (i, c) => {
+      const f = (p) => (p == null ? void 0 : p.kind) === "layout" && p.role === "member";
+      if (!f(i) || !f(c)) return [];
+      const w = d(i, c);
+      return e.columns.flatMap((p, b) => {
+        var y;
+        if (p.kind !== "level") return [];
+        const x = r.spec.rows.findIndex((v) => v.id === p.levelId);
+        return x < i.rowPath.length && ((y = w[x]) == null ? void 0 : y.visible) === !1 ? [b] : [];
+      });
+    },
+    csvRow: (i) => h(i),
+    // Each committed batch starts with identifying labels. Retries are pure;
+    // suppression never relies on mutable formatter state or an earlier worker.
+    csvRows: (i) => i.map((c, f) => h(c, i[f - 1]))
+  };
+}
+function De(e) {
+  return e.columns.map((r) => M(r.label));
+}
+function $e(e) {
+  if (e.kind !== "flat") throw new Error("Raw Matrix CSV requires flat rows.");
+  return e.values.map((r) => r.kind !== "value" ? null : k(r.value) ? r.value.value : typeof r.value == "string" ? M(r.value) : typeof r.value == "boolean" ? String(r.value) : r.value);
+}
+function me(e) {
+  const r = ce(e.layout, e.request, e.report), t = e.layout.columns.map((a, l) => ({
+    index: l,
+    columnId: `matrix:${l}`,
+    label: r.headers[l],
+    isNumeric: r.numericColumns[l]
+  })), n = (a, l, m) => ({
+    text: a,
+    colspan: 1,
+    rowspan: 1,
+    columnId: t[l].columnId,
+    isHeader: m,
+    isNumeric: t[l].isNumeric,
+    className: t[l].isNumeric ? "numeric" : e.layout.columns[l].kind === "hierarchy" ? "matrix-hierarchy" : ""
+  }), o = [], s = e.layout.columns.findIndex((a) => a.kind === "measure");
+  e.request.spec.columns.length && s >= 0 && o.push({
+    repeatHeader: !0,
+    headerType: "pivot-axis",
+    headerRowIndex: 0,
+    cells: [
+      ...s ? [{ ...n("", 0, !0), colspan: s }] : [],
+      {
+        ...n(e.request.spec.columns.map((a) => D(a, e.request.presentation)).join(" / "), s, !0),
+        colspan: e.layout.columns.length - s,
+        isNumeric: !1,
+        className: ""
+      }
+    ]
+  });
+  for (const [a, l] of r.headerBands.entries())
+    o.push({
+      repeatHeader: !0,
+      headerType: a === r.headerBands.length - 1 ? "metrics" : "pivot-level",
+      headerRowIndex: o.length,
+      cells: l.map((m, u) => n(m, u, !0))
+    });
+  return {
+    headers: o,
+    rows: e.rows.map((a, l) => {
+      const m = new Set(r.continuedColumns(a, e.rows[l - 1]));
+      return {
+        index: l,
+        type: a.kind === "layout" && a.role !== "member" ? "subtotal" : "data",
+        subtotalLevel: String(a.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: r.row(a, e.rows[l - 1]).map((u, d) => m.has(d) ? { ...n(u, d, !1), className: ie } : n(u, d, !1))
+      };
+    }),
+    grandTotal: null,
+    // Totals are already in the ordered body at their authored position.
+    metadata: {
+      tableType: "pivot",
+      totalRows: e.rows.length,
+      totalColumns: t.length,
+      rowLevels: e.layout.columns.filter((a) => a.kind !== "measure").length,
+      pivotLevels: e.request.spec.columns.length,
+      hasGrandTotal: !1,
+      columnOrder: t.map((a) => a.columnId),
+      columns: t
+    }
+  };
+}
+function fe(e, r, t) {
+  const { levels: n } = F(e.descriptors, r.presentation, t), o = r.spec.columns.length > 0, s = [], a = [], l = e.columns.map((u, d) => {
+    if (u.kind !== "measure") return null;
+    const g = o ? `${u.role}:${S(u.columnPath)}` : `measure:${d}`;
+    let h = s.indexOf(g);
+    return h < 0 && (h = s.push(g) - 1, a.push(o ? O(u.columnPath, u.role, r.presentation.totals.columns, n) : u.label)), h;
+  }), m = r.spec.columns[r.spec.columns.length - 1];
+  return {
+    columnGroups: l,
+    groupLabels: a,
+    /** What bands name their groups by: the innermost column level, or "Measures". */
+    groupLevelLabel: m ? D(m, r.presentation) : "Measures"
+  };
+}
+function Ne(e) {
+  const { layout: r, rows: t, report: n } = e, o = {
+    ...e.request,
+    presentation: ae(r, t, e.request.presentation)
+  }, s = me({ layout: r, rows: t, request: o, report: n }), a = le(t), l = fe(r, o, n), m = {
+    ...s,
+    rows: s.rows.map((u, d) => ({ ...u, keepWithPrevious: a[d] })),
+    metadata: { ...s.metadata, ...l }
+  };
+  return { request: o, table: m, ...l };
+}
+class ge extends Error {
+  constructor() {
+    super(...arguments);
+    A(this, "code", $);
+  }
+}
+function V(e) {
+  if (!e || typeof e != "object")
+    return;
+  const { error: r, message: t, detail: n } = e;
+  for (const o of [r, t, n])
+    if (typeof o == "string" && o.trim())
+      return o.trim();
+}
+async function de(e) {
+  const r = `PDF request failed: ${e.status} ${e.statusText}`.trim(), t = e.headers.get("content-type") || "";
+  try {
+    if (t.includes("application/json")) {
+      const o = await e.json(), s = typeof o.code == "string" ? o.code : typeof o.errorCode == "string" ? o.errorCode : void 0;
+      return { message: V(o) || r, code: s };
+    }
+    const n = await e.text();
+    if (!n.trim())
+      return { message: r };
+    try {
+      const o = JSON.parse(n), s = typeof o.code == "string" ? o.code : typeof o.errorCode == "string" ? o.errorCode : void 0;
+      return {
+        message: V(o) || n.trim(),
+        code: s
+      };
+    } catch {
+      return { message: n.trim() };
+    }
+  } catch {
+    return { message: r };
+  }
+}
+async function Ge(e) {
+  if (!e.token) throw new Error("Missing auth token for PDF export");
+  if (Y(e.serializedPayload) > q.maxRequestBytes)
+    throw new Error("Fast-path PDF request exceeds the structured body limit");
+  const r = await (e.fetchImpl ?? fetch)(e.url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", Authorization: `Bearer ${e.token}` },
+    body: e.serializedPayload,
+    signal: e.signal
+  });
+  if (!r.ok) {
+    const n = await de(r);
+    throw n.code === $ ? new ge(n.message) : new Error(n.message);
+  }
+  const t = await r.json();
+  if (t != null && t.error) throw new Error(t.error);
+  if (typeof (t == null ? void 0 : t.url) != "string" || !t.url.trim())
+    throw new Error("Fast-path PDF response missing download URL");
+  return t;
+}
+const pe = "__TOTAL__";
+function T(e) {
+  return typeof e == "object" && e !== null && !Array.isArray(e);
+}
+function C(e) {
+  return e === pe;
+}
+function Be(e) {
+  const r = /* @__PURE__ */ new Map(), t = (e.groupByColumns ?? []).map((o, s) => {
+    var u, d, g;
+    if (!T(o))
+      throw new Error(`Aggregate groupByColumns[${s}] is invalid`);
+    const a = typeof o.id == "string" && o.id.length > 0 ? o.id : void 0, l = a ? (g = (d = (u = e.columnKeyMap) == null ? void 0 : u.byRole) == null ? void 0 : d.groupby) == null ? void 0 : g[a] : void 0, m = (l == null ? void 0 : l.outputKey) || (l == null ? void 0 : l.rawKey) || (typeof o.alias == "string" && o.alias.length > 0 ? o.alias : typeof o.name == "string" && o.name.length > 0 ? o.name : void 0);
+    if (!m)
+      throw new Error(`Aggregate groupByColumns[${s}] has no output key`);
+    return [a, o.alias, o.name, m].forEach((h) => {
+      typeof h == "string" && h.length > 0 && r.set(h, m);
+    }), m;
+  }), n = (e.rowAggregates ?? []).flatMap((o) => !T(o) || typeof o.function != "string" || typeof o.groupLevel != "string" ? [] : [
+    {
+      function: o.function,
+      groupLevel: o.groupLevel === "ALL" ? "ALL" : r.get(o.groupLevel) || o.groupLevel,
+      ...typeof o.label == "string" ? { label: o.label } : {}
+    }
+  ]);
+  return { groupColumnKeys: t, rowAggregates: n };
+}
+function N(e) {
+  return e === "SUM" ? "Total" : e.charAt(0).toUpperCase() + e.slice(1).toLowerCase();
+}
+function he(e) {
+  var t;
+  if (e.customLabel) return e.customLabel;
+  const r = N(e.aggregateFunction);
+  if (e.levelValue !== void 0 && !C(e.levelValue)) {
+    if (e.levelValue === null) {
+      const o = (t = e.formatValue) == null ? void 0 : t.call(e, null);
+      return o ? `Subtotal ${o}` : `Subtotal ${r}`;
+    }
+    const n = e.formatValue ? e.formatValue(e.levelValue) : String(e.levelValue);
+    if (n) return `Subtotal (${n})`;
+  }
+  return `Subtotal ${r}`;
+}
+function we(e, r) {
+  return r || `Grand ${N(e)}`;
+}
+function Ue(e) {
+  const r = e.context.groupColumnKeys.indexOf(e.columnKey);
+  if (r < 0)
+    throw new Error(
+      `Aggregate group column "${e.columnKey}" is unknown`
+    );
+  return ue({
+    row: e.row,
+    previousRow: e.previousRow,
+    levelIndex: r,
+    getValue: (t, n) => t[e.context.groupColumnKeys[n]]
+  });
+}
+function G(e) {
+  var n, o;
+  const r = e.context.groupColumnKeys, t = typeof e.row.aggregate == "string" ? e.row.aggregate : "SUM";
+  if (e.row.isGrandTotal === !0) {
+    const s = (n = e.context.rowAggregates.find(
+      (a) => a.groupLevel === "ALL"
+    )) == null ? void 0 : n.label;
+    return {
+      kind: "grand-total",
+      cells: r.map((a, l) => ({
+        columnKey: a,
+        text: l === 0 ? we(t, s) : "",
+        placement: l === 0 ? "label" : "empty",
+        colSpan: l === 0 ? r.length : 1
+      }))
+    };
+  }
+  if (e.row.isSubtotal === !0) {
+    if (typeof e.row.subtotalLevel != "string")
+      throw new Error("Aggregate subtotal row is missing subtotalLevel");
+    const s = r.indexOf(e.row.subtotalLevel);
+    if (s < 0)
+      throw new Error(
+        `Aggregate subtotal level "${e.row.subtotalLevel}" has no group column`
+      );
+    const a = T(e.row.subtotalContext) ? e.row.subtotalContext : void 0, l = T(a == null ? void 0 : a.groupByValues) ? a.groupByValues : {}, m = (o = e.context.rowAggregates.find(
+      (u) => u.groupLevel === e.row.subtotalLevel && u.function === t
+    )) == null ? void 0 : o.label;
+    return {
+      kind: "subtotal",
+      cells: r.map((u, d) => {
+        if (d > s)
+          return {
+            columnKey: u,
+            text: "",
+            placement: "empty",
+            colSpan: 1
+          };
+        if (d < s) {
+          const g = e.row[u];
+          return {
+            columnKey: u,
+            text: g === void 0 || C(g) ? "" : e.formatValue(g, u),
+            placement: "value",
+            colSpan: 1
+          };
+        }
+        return {
+          columnKey: u,
+          text: he({
+            aggregateFunction: t,
+            customLabel: m,
+            levelValue: l[u],
+            formatValue: (g) => e.formatLabelValue ? e.formatLabelValue(g, u) : String(e.formatValue(g, u) ?? "")
+          }),
+          placement: "label",
+          colSpan: r.length - s
+        };
+      })
+    };
+  }
+  return {
+    kind: "data",
+    cells: r.map((s) => {
+      const a = e.row[s];
+      return {
+        columnKey: s,
+        text: a === void 0 || C(a) ? "" : e.formatValue(a, s),
+        placement: "value",
+        colSpan: 1
+      };
+    })
+  };
+}
+function je(e) {
+  const r = G(e).cells.find(
+    (t) => t.columnKey === e.columnKey
+  );
+  if (!r)
+    throw new Error(`Aggregate group column "${e.columnKey}" is unknown`);
+  return r.text;
+}
+function Xe(e) {
+  return G(e).cells.map((r) => r.text);
+}
+class be extends Error {
+  constructor(t, n) {
+    super(`${t}: ${n}`);
+    A(this, "deliveryBlocking", !0);
+    this.code = t, this.name = "PivotHeaderPresentationError";
+  }
+}
+function He(e) {
+  var o;
+  const r = e.mode ?? "formatted", t = e.members.map((s) => {
+    var l;
+    if (r === "canonical" || !s.temporalBucket)
+      return s.value === null ? "" : String(s.value);
+    const a = (l = e.resolveTemporalFormat) == null ? void 0 : l.call(e, s.fieldId);
+    if (!a)
+      throw new be(
+        "missing_resolved_temporal_format",
+        `Missing resolved temporal presentation for pivot field "${s.fieldId}"`
+      );
+    return J({
+      value: s.value,
+      metadata: s.temporalBucket,
+      format: a
+    });
+  }), n = ((o = e.metricLabel) == null ? void 0 : o.trim()) || void 0;
+  return {
+    memberLabels: t,
+    ...n ? { metricLabel: n } : {},
+    flattenedLabel: [
+      ...t,
+      ...n ? [n] : []
+    ].join(" / ")
+  };
+}
+export {
+  pe as A,
+  Ue as B,
+  G as C,
+  te as D,
+  je as E,
+  Me as F,
+  Xe as G,
+  be as H,
+  He as I,
+  ue as J,
+  Ie as M,
+  ie as P,
+  ee as a,
+  re as b,
+  _e as c,
+  Re as d,
+  Q as e,
+  Ce as f,
+  ce as g,
+  $e as h,
+  me as i,
+  Ne as j,
+  Fe as k,
+  Oe as l,
+  De as m,
+  oe as n,
+  ke as o,
+  M as p,
+  ae as q,
+  Ve as r,
+  le as s,
+  ge as t,
+  de as u,
+  Ge as v,
+  C as w,
+  Be as x,
+  he as y,
+  we as z
+};