super-page-runtime 2.3.34 → 2.3.35-sit1

package/dist/es/components/runtime/utils/charts/chart-columnline-util.js

@@ -1,10 +1,10 @@
-import { getValueFromSource as t, formatVariableValue as e, setValueForVariableName as o } from "../page-helper-util.js";
-import { deepCopy as i } from "../common-util.js";
-import { setDefaultGrid as s, CommonName as a, caculateFormulaValue as l, executeChartFormula as r, sortDatas as n, limitDatas as u, formatToolboxI18n as f } from "./chart-util.js";
-import { handleChartEvent as d } from "../events/event-util.js";
+import { getValueFromSource as e, formatVariableValue as t, setValueForVariableName as i } from "../page-helper-util.js";
+import { deepCopy as o } from "../common-util.js";
+import { setDefaultGrid as s, CommonName as a, caculateFormulaValue as l, executeChartFormula as r, sortDatas as n, limitDatas as u, formatToolboxI18n as d } from "./chart-util.js";
+import { handleChartEvent as f } from "../events/event-util.js";
 function c(c2, m, h, y) {
   if (!y || !y.result) return;
-  s(h), h.tooltip || (h.tooltip = {}), d(c2, m, "beforeUpdateChart", h, { resultData: y });
+  s(h), h.tooltip || (h.tooltip = {}), f(c2, m, "beforeUpdateChart", h, { resultData: y });
   const g = y && y.result ? y.result : {};
   let v = y && y.groupValue ? y.groupValue : void 0;
   const F = m.serviceDataField;
@@ -13,152 +13,154 @@ function c(c2, m, h, y) {
   let D = m.props ? m.props.groups : null;
   if (D || (D = []), !v || 0 === v.length) {
     v = [];
-    for (const t2 of D) v.push(t2.group);
+    for (const e2 of D) v.push(e2.group);
   }
   const _ = {}, x = [], A = [];
-  for (const t2 of D) _[t2.group] = t2.target, t2.target && !x.includes(t2.target) && (x.push(t2.target), v.includes(t2.group) && A.push(t2.target));
+  for (const e2 of D) _[e2.group] = e2.target, e2.target && !x.includes(e2.target) && (x.push(e2.target), v.includes(e2.group) && A.push(e2.target));
   let N = m.props ? m.props.mulGroupShow : "";
   N = "break" == N ? "\r\n" : " ";
-  for (const e2 of S) {
-    if (!e2) continue;
-    const o2 = [];
-    for (const i3 of v) {
-      const s2 = _[i3], a2 = t(e2, s2, void 0);
-      a2 && o2.push(a2);
+  for (const t2 of S) {
+    if (!t2) continue;
+    const i2 = [];
+    for (const o3 of v) {
+      const s2 = _[o3], a2 = e(t2, s2, void 0);
+      a2 && i2.push(a2);
     }
-    const i2 = o2.join(N);
-    e2[a.X_FIELD_NAME] = i2;
+    const o2 = i2.join(N);
+    t2[a.X_FIELD_NAME] = o2;
   }
   const E = m.items ? m.items : [], C = [], b = {}, w = [], I = {}, X = [], L = [], M = /* @__PURE__ */ new Set(), j = l(E, S, M);
-  for (const t2 of M) X.push(t2);
-  for (const t2 of E) {
-    const e2 = t2.props ? t2.props : {}, o2 = e2.yaxisSource, i2 = e2.yaxisField, s2 = e2.isCumulative;
+  for (const e2 of M) X.push(e2);
+  for (const e2 of E) {
+    const t2 = e2.props ? e2.props : {}, i2 = t2.yaxisSource, o2 = t2.yaxisField, s2 = t2.isCumulative;
     let a2 = null;
-    if (!i2 || o2 && "variable" != o2) if ("formula" == o2) {
-      let o3 = e2.formula ? e2.formula : "";
-      for (const t3 in j) o3 = o3.replace(new RegExp(t3.replace("$", "\\$"), "g"), j[t3]);
-      a2 = { uuid: t2.uuid, type: "formula", formula: o3, isFormulaCalculateAfterSort: e2.isFormulaCalculateAfterSort, data: [], dynamicDatas: [] };
-    } else a2 = { uuid: t2.uuid, type: "fixed", field: e2.yaxisFix, data: [], dynamicDatas: [] };
-    else a2 = { uuid: t2.uuid, type: "variable", field: i2, isCumulative: s2, data: [], dynamicDatas: [] }, i2 && !X.includes(i2) && X.push(i2), i2 && !L.includes(i2) && L.push(i2), s2 && !M.has(i2) && M.add(i2);
-    null != a2 && (C.push(a2), b[t2.uuid] = a2), e2.dynamicSeriesField && !w.includes(e2.dynamicSeriesField) && a2 && (a2.dynamicField = e2.dynamicSeriesField, a2.dynamicSeriesTitle = e2.dynamicSeriesTitle, a2.dynamicShowStack = e2.dynamicShowStack, w.push(e2.dynamicSeriesField), I[e2.dynamicSeriesField] = i2);
+    if (!o2 || i2 && "variable" != i2) if ("formula" == i2) {
+      let i3 = t2.formula ? t2.formula : "";
+      for (const e3 in j) i3 = i3.replace(new RegExp(e3.replace("$", "\\$"), "g"), j[e3]);
+      a2 = { uuid: e2.uuid, type: "formula", formula: i3, isFormulaCalculateAfterSort: t2.isFormulaCalculateAfterSort, data: [], dynamicDatas: [] };
+    } else a2 = { uuid: e2.uuid, type: "fixed", field: t2.yaxisFix, data: [], dynamicDatas: [] };
+    else a2 = { uuid: e2.uuid, type: "variable", field: o2, isCumulative: s2, data: [], dynamicDatas: [] }, o2 && !X.includes(o2) && X.push(o2), o2 && !L.includes(o2) && L.push(o2), s2 && !M.has(o2) && M.add(o2);
+    null != a2 && (C.push(a2), b[e2.uuid] = a2), t2.dynamicSeriesField && !w.includes(t2.dynamicSeriesField) && a2 && (a2.dynamicField = t2.dynamicSeriesField, a2.dynamicSeriesTitle = t2.dynamicSeriesTitle, a2.dynamicShowStack = t2.dynamicShowStack, w.push(t2.dynamicSeriesField), I[t2.dynamicSeriesField] = o2), t2.dynamicSeriesDataField && t2.dynamicSeriesDataField.forEach((e3) => {
+      X.includes(e3) || X.push(e3);
+    });
   }
   const k = {};
   if (w.length > 0) {
-    const e2 = [], o2 = {};
-    for (const i2 of S) if (i2) for (const s2 of X) {
-      const l2 = i2[a.X_FIELD_NAME];
-      let r2 = o2[l2];
+    const t2 = [], i2 = {};
+    for (const o2 of S) if (o2) for (const s2 of X) {
+      const l2 = o2[a.X_FIELD_NAME];
+      let r2 = i2[l2];
       if (!r2) {
         r2 = {};
-        for (const t2 of x) r2[t2] = i2[t2];
-        r2[a.X_FIELD_NAME] = i2[a.X_FIELD_NAME], o2[l2] = r2, e2.push(r2);
+        for (const e2 of x) r2[e2] = o2[e2];
+        r2[a.X_FIELD_NAME] = o2[a.X_FIELD_NAME], i2[l2] = r2, t2.push(r2);
       }
-      let n2 = t(i2, s2, void 0);
+      let n2 = e(o2, s2, void 0);
       if (!isNaN(n2)) {
-        const t2 = r2[s2];
-        isNaN || (n2 += t2), r2[s2] = n2;
+        const e2 = r2[s2];
+        isNaN(e2) || (n2 += e2), r2[s2] = n2;
       }
     }
-    for (const e3 of w) {
-      const i2 = [];
+    for (const t3 of w) {
+      const o2 = [];
       for (const s2 of S) {
         if (!s2) continue;
-        const l2 = o2[s2[a.X_FIELD_NAME]];
+        const l2 = i2[s2[a.X_FIELD_NAME]];
         if (!l2) continue;
-        let r2 = t(s2, e3, void 0);
-        r2 = null == r2 || null == r2 ? "" : r2, i2.includes(r2) || (i2.push(r2), L.push(r2), M.add(r2));
-        const n2 = I[e3];
+        let r2 = e(s2, t3, void 0);
+        r2 = null == r2 || null == r2 ? "" : r2, o2.includes(r2) || (o2.push(r2), L.push(r2), M.add(r2));
+        const n2 = I[t3];
         if (void 0 !== n2) {
-          const e4 = t(s2, n2, void 0);
-          let o3 = l2[r2];
-          void 0 === o3 ? o3 = e4 : isNaN(e4) || (o3 += e4), l2[r2] = o3;
+          const t4 = e(s2, n2, void 0);
+          let i3 = l2[r2];
+          void 0 === i3 ? i3 = t4 : isNaN(t4) || (i3 += t4), l2[r2] = i3;
         }
       }
-      k[e3] = i2;
+      k[t3] = o2;
     }
-    S = e2;
+    S = t2;
   }
   let T = {};
   const V = /* @__PURE__ */ new Set(), $ = m.props ? m.props.orderByTarget : "";
-  for (const t2 of C) "formula" === t2.type && t2.isFormulaCalculateAfterSort && $ !== t2.uuid && V.add(t2.uuid + "_field");
-  for (const t2 of S) if (t2) {
-    p(t2, M, T);
-    for (const e2 of C) if ("formula" === e2.type && !e2.isFormulaCalculateAfterSort) {
-      const o2 = r(e2.formula, T, t2, c2);
-      t2[e2.uuid + "_field"] = o2;
+  for (const e2 of C) "formula" === e2.type && e2.isFormulaCalculateAfterSort && $ !== e2.uuid && V.add(e2.uuid + "_field");
+  for (const e2 of S) if (e2) {
+    p(e2, M, T);
+    for (const t2 of C) if ("formula" === t2.type && !t2.isFormulaCalculateAfterSort) {
+      const i2 = r(t2.formula, T, e2, c2);
+      e2[t2.uuid + "_field"] = i2;
     }
   }
   if (n(c2, m, S), V.size > 0) {
-    const t2 = {};
-    for (const e2 of S) {
-      p(e2, M, t2);
-      for (const o2 of C) if ("formula" === o2.type && V.has(o2.uuid + "_field")) {
-        const i2 = r(o2.formula, t2, e2, c2);
-        e2[o2.uuid + "_field"] = i2;
+    const e2 = {};
+    for (const t2 of S) {
+      p(t2, M, e2);
+      for (const i2 of C) if ("formula" === i2.type && V.has(i2.uuid + "_field")) {
+        const o2 = r(i2.formula, e2, t2, c2);
+        t2[i2.uuid + "_field"] = o2;
       }
     }
   }
   S = u(c2, m, S, x, L);
   const B = [];
   T = {};
-  for (const e2 of S) if (e2) {
-    for (const o2 of M) {
-      const i2 = t(e2, o2, void 0);
-      let s2 = T[o2];
-      void 0 === i2 || isNaN(i2) || (void 0 === s2 ? s2 = i2 : s2 += i2), T[o2] = s2;
+  for (const t2 of S) if (t2) {
+    for (const i2 of M) {
+      const o2 = e(t2, i2, void 0);
+      let s2 = T[i2];
+      void 0 === o2 || isNaN(o2) || (void 0 === s2 ? s2 = o2 : s2 += o2), T[i2] = s2;
     }
-    B.push(e2[a.X_FIELD_NAME]);
-    for (const o2 of C) {
-      let i2 = o2.data;
-      const s2 = o2.dynamicDatas;
-      if (o2.dynamicField) {
-        let a2 = k[o2.dynamicField];
+    B.push(t2[a.X_FIELD_NAME]);
+    for (const i2 of C) {
+      let o2 = i2.data;
+      const s2 = i2.dynamicDatas;
+      if (i2.dynamicField) {
+        let a2 = k[i2.dynamicField];
         a2 = a2 || [];
         for (let l2 = 0; l2 < a2.length; l2++) {
-          l2 >= s2.length && s2.push([]), i2 = s2[l2];
+          l2 >= s2.length && s2.push([]), o2 = s2[l2];
           const r2 = a2[l2];
-          let n2 = t(e2, r2, void 0);
-          o2.isCumulative && (n2 = T[r2]), i2.push(n2);
+          let n2 = e(t2, r2, void 0);
+          i2.isCumulative && (n2 = T[r2]), o2.push(n2);
         }
-      } else if ("fixed" === o2.type) i2.push(o2.field);
-      else if ("variable" === o2.type) {
-        let s3 = t(e2, o2.field, void 0);
-        o2.isCumulative && (s3 = T[o2.field]), i2.push(s3);
-      } else "formula" === o2.type ? i2.push(e2[o2.uuid + "_field"]) : i2.push(void 0);
+      } else if ("fixed" === i2.type) o2.push(i2.field);
+      else if ("variable" === i2.type) {
+        let s3 = e(t2, i2.field, void 0);
+        i2.isCumulative && (s3 = T[i2.field]), o2.push(s3);
+      } else "formula" === i2.type ? o2.push(t2[i2.uuid + "_field"]) : o2.push(void 0);
     }
   }
-  const G = m.defaultSeries, R = i(null == G ? [] : G), U = [];
-  for (const t2 of R) {
-    const o2 = b[t2.uuid];
-    if (o2.dynamicField) {
-      let s2 = k[o2.dynamicField];
+  const G = m.defaultSeries, R = o(null == G ? [] : G), U = [];
+  for (const e2 of R) {
+    const i2 = b[e2.uuid];
+    if (i2.dynamicField) {
+      let s2 = k[i2.dynamicField];
       s2 = s2 || [];
-      const a2 = o2.dynamicDatas ? o2.dynamicDatas : [];
+      const a2 = i2.dynamicDatas ? i2.dynamicDatas : [];
       for (let l2 = 0; l2 < s2.length; l2++) {
-        const r2 = s2[l2], n2 = i(t2);
-        if (o2.dynamicSeriesTitle) {
-          const t3 = o2.dynamicSeriesTitle.replace("${name}", r2);
-          n2.name = e(c2, t3);
+        const r2 = s2[l2], n2 = o(e2);
+        if (i2.dynamicSeriesTitle) {
+          const e3 = i2.dynamicSeriesTitle.replace("${name}", r2);
+          n2.name = t(c2, e3);
         } else n2.name = r2;
-        n2.data = l2 < a2.length ? a2[l2] : [], "bar" == t2.type && o2.dynamicShowStack && (n2.stack = t2.uuid), U.push(n2);
+        n2.data = l2 < a2.length ? a2[l2] : [], "bar" == e2.type && i2.dynamicShowStack && (n2.stack = e2.uuid), U.push(n2);
       }
-    } else t2.data = o2 ? o2.data : [], U.push(t2);
+    } else e2.data = i2 ? i2.data : [], U.push(e2);
   }
   h.series = U;
   const z = m.defaultXaxis, Y = m.defaultYaxis;
   if (h.isBar) {
-    if (Y) for (const t2 of Y) t2.data = B;
+    if (Y) for (const e2 of Y) e2.data = B;
     h.xAxis = z, h.yAxis = Y;
   } else z && z.length > 0 && (z[0].data = B), h.xAxis = z, h.yAxis = Y;
-  f(h);
+  d(h);
   const q = m.props ? m.props.selGroupVariable : null;
-  !(m.props ? m.props.enableDrill : null) && q && (m.highlightInfos = [], o(c2.entity, q, null)), d(c2, m, "afterUpdateChart", h, { resultData: y }), m.groupFields = A, m.cacheDatas = S, m.rawResult = y;
+  !(m.props ? m.props.enableDrill : null) && q && (m.highlightInfos = [], i(c2.entity, q, null)), f(c2, m, "afterUpdateChart", h, { resultData: y }), m.groupFields = A, m.cacheDatas = S, m.rawResult = y;
 }
-function p(e2, o2, i2) {
-  for (const s2 of o2) {
-    const o3 = t(e2, s2, void 0);
-    let a2 = i2[s2];
-    void 0 === o3 || isNaN(o3) || (void 0 === a2 ? a2 = o3 : a2 += o3), i2[s2] = a2;
+function p(t2, i2, o2) {
+  for (const s2 of i2) {
+    const i3 = e(t2, s2, void 0);
+    let a2 = o2[s2];
+    void 0 === i3 || isNaN(i3) || (void 0 === a2 ? a2 = i3 : a2 += i3), o2[s2] = a2;
   }
 }
 export {