@agile-team/mach-report 2.16.0 → 2.18.0

package/dist/tree-CjVZLRw7.js

@@ -1,172 +0,0 @@
-import { e as A, c as w } from "./computed-C-4C2S5h.js";
-class b extends Error {
-  constructor(r) {
-    super(`树节点超出行数预算 ${r}`), this.limit = r, this.code = "tree-row-limit", this.name = "TreeRowLimitError";
-  }
-}
-function s(e, r, i, t) {
-  const n = e ?? r;
-  if (!Number.isInteger(n) || n < 1 || n > i) throw new Error(`${t}应为 1–${i} 的整数`);
-  return n;
-}
-function u(e) {
-  return { rows: s(e.maxRows, 1e5, 1e6, "树行数预算"), depth: s(e.maxDepth, 64, 256, "树深度预算"), visits: s(e.maxAggregationVisits, 1e6, 1e7, "树聚合访问预算") };
-}
-function g(e) {
-  return typeof e == "string" && !!e.trim();
-}
-function c(e) {
-  return g(e) && !["__proto__", "prototype", "constructor"].includes(e);
-}
-function m(e) {
-  if (g(e) || typeof e == "number" && Number.isFinite(e)) return e;
-  throw new Error("树节点业务键应为非空字符串或有限数字");
-}
-function E(e) {
-  return JSON.stringify([typeof e, e]);
-}
-function p(e) {
-  return [e.idField, ...e.input === "flat" ? [e.parentField ?? ""] : [e.childrenField ?? "children"]];
-}
-function k(e, r) {
-  const i = p(e);
-  if (r?.some((t) => t.scope && t.scope !== "row" || i.includes(t.field))) throw new Error("树形布局仅支持不覆盖结构键的当前行计算");
-}
-function h(e) {
-  if (!e?.aborted) return;
-  const r = new Error("树报表处理已取消");
-  throw r.name = "AbortError", r;
-}
-function N(e) {
-  const r = e.aggregates ?? [];
-  if (!Array.isArray(r) || r.length > 32) throw new Error("树聚合最多 32 项");
-  if (e.parentValues !== "leaf-aggregate" && r.length) throw new Error("树聚合需显式选择 leaf-aggregate 父级取值策略");
-  if (e.parentValues === "leaf-aggregate" && !r.length) throw new Error("叶子聚合策略至少需要一个聚合字段");
-  const i = /* @__PURE__ */ new Set();
-  for (const t of r) {
-    if (!t || !c(t.field) || i.has(t.field)) throw new Error("树聚合输出字段应安全、非空且唯一");
-    for (const n of [t.valueField, t.weightField]) if (n !== void 0 && !c(n)) throw new Error("树聚合来源字段应安全且非空");
-    if ([...p(e), e.labelField].includes(t.field)) throw new Error("树聚合不能覆盖结构键或标签字段");
-    i.add(t.field), w({ ...t, field: t.valueField ?? t.field });
-  }
-}
-function T(e) {
-  if (!c(e.idField) || !c(e.labelField)) throw new Error("树需要安全的业务键和标签字段");
-  if (e.input === "flat" && (!c(e.parentField) || e.parentField === e.idField)) throw new Error("扁平树需要独立的父键字段");
-  if (e.childrenField !== void 0 && !c(e.childrenField)) throw new Error("子节点字段应安全且非空");
-  if (e.input === "nested" && [e.idField, e.labelField].includes(e.childrenField ?? "children")) throw new Error("子节点字段不能覆盖业务键或标签字段");
-}
-function $(e) {
-  if (!e || typeof e != "object" || !["flat", "nested"].includes(e.input)) throw new Error("树输入应为 flat 或 nested");
-  if (T(e), e.orphan !== void 0 && !["error", "root"].includes(e.orphan)) throw new Error("树孤儿策略应为 error 或 root");
-  if (e.parentValues !== void 0 && !["source", "leaf-aggregate"].includes(e.parentValues)) throw new Error("未知树父级取值策略");
-  if (e.indentMm !== void 0 && (!Number.isFinite(e.indentMm) || e.indentMm < 0 || e.indentMm > 20)) throw new Error("树每级缩进应为 0–20 mm");
-  u(e), N(e);
-}
-function F(e, r, i, t) {
-  if (!e || typeof e != "object" || Array.isArray(e)) throw new Error("树节点应为对象");
-  if (i.size >= t.rows) throw new b(t.rows);
-  const n = m(e[r.idField]), l = E(n);
-  if (i.has(l)) throw new Error(`树节点业务键重复：${String(n)}`);
-  const o = { original: e, row: e, key: n, depth: 0, children: [] };
-  return i.set(l, o), o;
-}
-function M(e, r, i, t, n) {
-  for (const o of e)
-    h(n), F(o, r, i, t);
-  const l = [];
-  for (const o of i.values()) {
-    h(n);
-    const a = o.row[r.parentField];
-    if (a == null) {
-      l.push(o);
-      continue;
-    }
-    const f = i.get(E(m(a)));
-    if (!f) {
-      if (r.orphan !== "root") throw new Error(`树节点 ${String(o.key)} 的父节点不存在`);
-      l.push(o);
-      continue;
-    }
-    if (f === o) throw new Error("树节点不能以自身为父节点");
-    o.parent = f, f.children.push(o);
-  }
-  return l;
-}
-function V(e, r, i, t, n) {
-  const l = [], o = [{ rows: e, next: 0 }];
-  for (; o.length; ) {
-    h(n);
-    const a = o[o.length - 1];
-    if (a.next >= a.rows.length) {
-      o.pop();
-      continue;
-    }
-    const f = F(a.rows[a.next++], r, i, t);
-    if (f.parent = a.parent, f.depth = o.length - 1, o.length > t.depth) throw new Error(`树节点超出深度预算 ${t.depth}`);
-    (a.parent?.children ?? l).push(f);
-    const d = f.row[r.childrenField ?? "children"];
-    if (d != null) {
-      if (!Array.isArray(d)) throw new Error("嵌套树 children 字段应为数组");
-      d.length && o.push({ rows: d, next: 0, parent: f });
-    }
-  }
-  return l;
-}
-function x(e, r, i, t) {
-  const n = [], l = [{ nodes: e, next: 0 }];
-  for (; l.length; ) {
-    h(t);
-    const o = l[l.length - 1];
-    if (o.next >= o.nodes.length) {
-      l.pop();
-      continue;
-    }
-    if (l.length > i.depth) throw new Error(`树节点超出深度预算 ${i.depth}`);
-    const a = o.nodes[o.next++];
-    a.depth = l.length - 1, n.push(a), a.children.length && l.push({ nodes: a.children, next: 0 });
-  }
-  if (n.length !== r) throw new Error("树父子关系存在循环");
-  return n;
-}
-function S(e, r, i, t) {
-  if (r.parentValues !== "leaf-aggregate") return;
-  const n = r.aggregates, l = /* @__PURE__ */ new Map();
-  for (const a of e) a.children.length && l.set(a, n.map((f) => w({ ...f, field: f.valueField ?? f.field })));
-  let o = 0;
-  for (const a of e)
-    if (!a.children.length)
-      for (let f = a.parent; f; f = f.parent) {
-        if (h(t), o += n.length, o > i.visits) throw new Error(`树聚合超出访问预算 ${i.visits}`);
-        for (const d of l.get(f)) d.add(a.row);
-      }
-  for (const [a, f] of l)
-    a.row = { ...a.row }, n.forEach((d, v) => {
-      a.row[d.field] = f[v].value();
-    });
-}
-function y(e, r, i) {
-  if ($(r), h(i), !Array.isArray(e)) throw new Error("树数据应为节点数组");
-  const t = u(r), n = /* @__PURE__ */ new Map(), l = r.input === "flat" ? M(e, r, n, t, i) : V(e, r, n, t, i);
-  return x(l, n.size, t, i);
-}
-function O(e, r, i) {
-  return y(e, r, i).map((t) => t.original);
-}
-function R(e, r, i = {}) {
-  const t = y(e, r, i.signal);
-  if (k(r, i.computed?.fields), i.computed?.fields.length) {
-    const n = A(t.map((l) => l.row), { ...i.computed, signal: i.signal }).rows;
-    t.forEach((l, o) => {
-      l.row = n[o];
-    });
-  }
-  return S(t, r, u(r), i.signal), { rows: t.map((n) => n.row), entries: t.map((n) => ({ row: n.row, original: n.original, key: n.key, depth: n.depth, hasChildren: !!n.children.length })), leaves: t.filter((n) => !n.children.length).map((n) => n.row) };
-}
-export {
-  b as T,
-  k as a,
-  R as c,
-  O as f,
-  $ as v
-};