@geoscene/charts-components 5.0.19

package/dist/cdn/ML4GGRP6.js

@@ -0,0 +1,570 @@
+/* COPYRIGHT  - https://js.geoscene.cn/5.0/LICENSE.txt */
+import { c as h } from "./DPJE33GY.js";
+import g from "./ED7V65WK.js";
+import f from "./IJUDK7C2.js";
+import e from "./V2OPADQU.js";
+import d from "./ZLRKGGOO.js";
+import c from "./AENRD2JF.js";
+import b from "./P4UNBBUE.js";
+import a from "./A7YNU2NS.js";
+import { e as x, n as K, o as A, u as V, v as J } from "./4B3QBH5T.js";
+import { e as q } from "./KUVOINJC.js";
+import { a as B, y as W } from "./NKG4FLLR.js";
+export default $geoscene.t(
+  ([
+    {
+      Dc: U,
+      E: M,
+      Na: Q,
+      Nc: X,
+      Nd: k,
+      Oa: R,
+      Pc: Y,
+      Qa: v,
+      Ra: L,
+      gd: C,
+      xb: P,
+      yb: d,
+    },
+    { c: H },
+    { f: ee, g: E },
+    { ea: oe, fa: te, ga: ie },
+    { k: T, l: I, m: Z, x: re },
+    { b: ae },
+    { a: le, c: ne, d: se },
+  ]) => {
+    var Re = [
+        B.BarSeries,
+        B.BoxPlotSeries,
+        B.LineSeries,
+        B.PieSeries,
+        B.HistogramSeries,
+        B.ScatterSeries,
+      ],
+      he = 1,
+      Te = { PNG: "png" };
+    function ce(l, e) {
+      return !K(l, e);
+    }
+    function Ie(l, e) {
+      return ce(l, e) || l !== e;
+    }
+    function fe(l) {
+      return (new Intl.NumberFormat(l, {
+        minimumFractionDigits: 1,
+        maximumFractionDigits: 1,
+      })
+        .formatToParts(1.1)
+        .find((e) => e.type === "decimal")?.value ?? ".") === "."
+        ? ","
+        : ";";
+    }
+    function me(l) {
+      return (
+        new Intl.NumberFormat(l, {
+          minimumFractionDigits: 1,
+          maximumFractionDigits: 1,
+        })
+          .formatToParts(1.1)
+          .find((e) => e.type === "decimal")?.value ?? "."
+      );
+    }
+    var de = (l) => {
+      let { value: e, quoteAll: o = !1, locale: s } = l,
+        i = e == null ? "" : String(e);
+      if (e === null) i = "null";
+      else if (e === void 0) i = "";
+      else if (typeof e == "number" && Number.isFinite(e) && s !== void 0) {
+        let t = me(s),
+          a = i.split(t)[1]?.length ?? 3;
+        i = new Intl.NumberFormat(s, { maximumFractionDigits: a })
+          .format(e)
+          .replace(/\u202F/gu, " ");
+      }
+      return (
+        (o || /[",\r\n]/u.test(i)) && (i = `"${i.replace(/"/gu, '""')}"`), i
+      );
+    };
+    function Ne(l, e = {}) {
+      let {
+          columns: o,
+          delimiter: s,
+          includeHeader: i = !0,
+          quoteAll: t = !1,
+          locale: a,
+        } = e,
+        m = l.length === 0,
+        n = "";
+      if (!m) {
+        let f = o ?? Object.keys(l[0]),
+          y = [],
+          b = s ?? fe(a ?? "en");
+        if (
+          (a !== void 0 &&
+            b !== "," &&
+            (n += `sep=${b}\r
+`),
+          i)
+        ) {
+          let p = f.map((r) => de({ value: r, quoteAll: t, locale: a }));
+          y.push(p.join(b));
+        }
+        l.forEach((p) => {
+          let r = f.map((u) => de({ value: p[u], quoteAll: t, locale: a }));
+          y.push(r.join(b));
+        }),
+          (n += y.join(`\r
+`));
+      }
+      return n;
+    }
+    function je(l) {
+      let { rawData: e, config: o, layer: s, fieldList: i } = l,
+        t = e;
+      if (o !== void 0 && Array.isArray(e) && e.length > 0) {
+        let a = W(o?.series);
+        a === B.HistogramSeries
+          ? (t = pe(o, e))
+          : a === B.BarSeries ||
+            a === B.LineSeries ||
+            a === B.ComboLineAndBarSeries
+          ? (t = ge({ config: o, rows: e, layer: s, fieldList: i }))
+          : a === B.PieSeries
+          ? (t = ye({ config: o, rows: e, layer: s, fieldList: i }))
+          : a === B.BoxPlotSeries &&
+            (t = Pe({ config: o, rows: e, fieldList: i }));
+      }
+      return t;
+    }
+    function pe(l, e) {
+      let o = ae(l),
+        s = `${x(h.Min)} of ${o}`,
+        i = `${x(h.Max)} of ${o}`,
+        t = `${x(h.Count)} of ${o}`;
+      return e.map((a) => {
+        let { minValue: m, maxValue: n, count: f } = a,
+          y = A(m),
+          b = A(n),
+          p = A(f),
+          r = {};
+        return (
+          y && (r[s] = m.toFixed(2)),
+          b && (r[i] = n.toFixed(2)),
+          y && b && (r.Label = `${m.toFixed(2)} - ${n.toFixed(2)}`),
+          p && (r[t] = f),
+          r
+        );
+      });
+    }
+    function be(l, e, o) {
+      let s = Object.keys(l),
+        i = [];
+      return (
+        o
+          ? (i = o.map(
+              (t) =>
+                s.find((a) => a.toLowerCase().includes(t.toLowerCase())) || ""
+            ))
+          : (i = s.filter((t) => t.toLowerCase().includes(e.toLowerCase()))),
+        i.filter((t) => t.trim() !== "")
+      );
+    }
+    function ge(l) {
+      let { config: e, rows: o, layer: s, fieldList: i } = l,
+        t = ee(e),
+        a = oe(e),
+        m = x(a),
+        n = ie(e),
+        f = C(e.series),
+        y = H(e),
+        b = te(e),
+        { idField: p, isTraditionalTypeOID: r } = X(U(s)),
+        u = r && n.length === 1 && n[0] === p,
+        c;
+      switch (f) {
+        case d.BarAndLineNoAggregation:
+          c = o.map((g) => {
+            let F = S({ field: t, value: g[t], fieldList: i }),
+              w = { [t]: F };
+            return Object.assign(w, ...n.map(($) => ({ [$]: g[$] }))), w;
+          });
+          break;
+        case d.BarAndLineFromFields:
+          c = V(n, o).map(([g, F]) => {
+            let w = k(e.series)[0],
+              $ = {};
+            return (
+              F !== void 0 &&
+                g !== void 0 &&
+                (($.Field = F[t]), ($.Value = F[w])),
+              $
+            );
+          });
+          break;
+        case d.BarAndLineMonoField:
+        case d.BarAndLineMultiFields:
+          c = o.map((g) => {
+            let F = S({ field: t, value: g[t], fieldList: i }),
+              w = { [t]: F };
+            return (
+              n.forEach(($, O) => {
+                let j = E({
+                    config: e,
+                    xAxisField: t,
+                    numericFields: n,
+                    aggregationType: a,
+                    layer: s,
+                    numericFieldIndex: O,
+                    fieldList: i,
+                  }),
+                  _ = k(e.series)[O],
+                  z = _,
+                  G = _;
+                _.toLowerCase() === j.name.toLowerCase() &&
+                  ((z = j.description), (G = j.name)),
+                  (w[z] = g[G]);
+              }),
+              w
+            );
+          });
+          break;
+        case d.BarAndLineSplitBy:
+          c = o.flatMap((g) => {
+            let F = k(e.series),
+              w = S({ field: t, value: g[t], fieldList: i });
+            return y.map(($, O) => ({
+              [t]: w,
+              [b]: $,
+              [u ? m : `${m} of ${n[0]}`]: g[F[O]],
+            }));
+          });
+          break;
+        case d.BarAndLineSplitByNoAggregation:
+          c = o.map((g) => {
+            let F = S({ field: t, value: g[t], fieldList: i }),
+              w = be(g, n[0], y);
+            return { [t]: F, [b]: g[b], [n[0]]: g[w[0]] };
+          });
+          break;
+        default:
+          c = o;
+      }
+      return c;
+    }
+    function xe(l) {
+      if (l.length === 0) return [];
+      let e = l.reduce((o, s) => {
+        for (let [i, t] of Object.entries(s))
+          typeof t == "number" &&
+            Number.isFinite(t) &&
+            (o[i] = (o[i] ?? 0) + t);
+        return o;
+      }, {});
+      return l.map((o) => {
+        let s = { ...o };
+        for (let [i, t] of Object.entries(o))
+          if (typeof t == "number" && e[i] > 0) {
+            let a = t / e[i];
+            s[`${i}${v}`] = a.toPrecision(2);
+          }
+        return s;
+      });
+    }
+    function ye(l) {
+      let { config: e, rows: o, layer: s, fieldList: i } = l,
+        t = le(e),
+        a = C(e.series),
+        m = xe(o),
+        n = ne(e),
+        f = a !== d.PieFromFields ? q.Category : q.Fields,
+        y = se(e, f),
+        b = E({
+          config: e,
+          xAxisField: t,
+          numericFields: n,
+          aggregationType: y,
+          mode: f,
+          layer: s,
+          fieldList: i,
+        }),
+        p = k(e.series)[0];
+      return (
+        a === d.PieFromCategory || a === d.PieNoAggregation
+          ? (m = m.map((r) => {
+              let u = S({ field: t, value: r[t], fieldList: i }),
+                c = { [t]: u },
+                g = p,
+                F = p;
+              return (
+                a === d.PieFromCategory &&
+                  p.toLowerCase() === b.name.toLowerCase() &&
+                  ((g = b.description), (F = b.name)),
+                (c[g] = r[F]),
+                (c[x(v.trim())] = r[`${F}${v}`]),
+                c
+              );
+            }))
+          : a === d.PieFromFields &&
+            (m = V(n, m).map(([r, u]) => {
+              let c = {};
+              return (
+                u !== void 0 &&
+                  r !== void 0 &&
+                  ((c.Field = u[t]),
+                  (c.Value = u[p]),
+                  (c[x(v.trim())] = u[`${p}${v}`])),
+                c
+              );
+            })),
+        m
+      );
+    }
+    function N(l) {
+      let { rawData: e, keyBase: o = "", outRow: s } = l;
+      for (let [i, t] of Object.entries(P)) {
+        let a = e[o + t];
+        a !== void 0 && (s[i] = A(a) ? a.toFixed(2) : a);
+        let m = e[o + t + Q];
+        m !== void 0 && (s[`${i} Outlier`] = A(m) ? m.toFixed(2) : m);
+        let n = e[o + t + R];
+        n !== void 0 && (s[`${i} Z-Score`] = A(n) ? n.toFixed(2) : n);
+      }
+    }
+    function D(l) {
+      let {
+          rawData: e,
+          outRow: o,
+          config: s,
+          boxPlotSubType: i,
+          fieldList: t,
+        } = l,
+        a = T(s),
+        m = Z(s),
+        n = I(s),
+        f = P.Outlier,
+        y = M;
+      switch (i) {
+        case d.BoxPlotMonoFieldAndCategory: {
+          let r = S({ field: a, value: e[a], fieldList: t });
+          (o[a] = r), (o[x(P.Outlier)] = e[f]);
+          break;
+        }
+        case d.BoxPlotMultiFieldsAndCategory: {
+          (o[x(a)] = e[a]),
+            (f = `${
+              m.find((r) =>
+                Object.keys(e).some((u) =>
+                  u.toLowerCase().includes(r.toLowerCase())
+                )
+              ) ?? ""
+            }_${f}`),
+            (o[x(P.Outlier)] = e[f]);
+          break;
+        }
+        case d.BoxPlotMonoFieldAndSplitBy:
+        case d.BoxPlotMultiFieldsAndSplitBy: {
+          let r = e[n];
+          (f = `${r}_${f}`),
+            (o.Field = e[y]),
+            (o[x(n)] = r),
+            (o[x(P.Outlier)] = e[f]);
+          break;
+        }
+        case d.BoxPlotMonoFieldAndCategoryAndSplitBy: {
+          let r = e[n];
+          (f = `${r}_${f}`),
+            (o[x(a)] = e[a]),
+            (o[x(n)] = r),
+            (o[x(P.Outlier)] = e[f]);
+          break;
+        }
+        case d.BoxPlotMonoField:
+        case d.BoxPlotMultiFields:
+        default: {
+          (o.Field = e[y]), (o[x(P.Outlier)] = e[f]);
+          break;
+        }
+      }
+      let b = `${f}${R}`,
+        p = e[b];
+      p !== void 0 && (o[`${x(P.Outlier)} Z-Score`] = A(p) ? p.toFixed(2) : p);
+    }
+    function Fe(l) {
+      let { rawData: e, outRow: o, config: s, splitByValue: i } = l,
+        t = C(s.series),
+        a = e[`${i}_${P.Average}`],
+        m = I(s),
+        n = T(s),
+        f = "";
+      switch (t) {
+        case d.BoxPlotMonoFieldAndSplitBy: {
+          (f = `${i}_${m}`), (o.Field = e[M]), (o[x(m)] = e[f]);
+          break;
+        }
+        case d.BoxPlotMultiFieldsAndSplitBy: {
+          (f = `${i}_${P.Average}`), (o.Field = e[M]), (o[x(m)] = e[f]);
+          break;
+        }
+        case d.BoxPlotMonoFieldAndCategoryAndSplitBy: {
+          (f = `${i}_${P.Average}`), (o[n] = e[n]), (o[x(m)] = i);
+          break;
+        }
+      }
+      o[x(P.Average)] = A(a) ? a.toFixed(2) : a;
+      let y = `${a}${R}`,
+        b = e[y];
+      b !== void 0 && (o[`${x(P.Average)} Z-Score`] = A(b) ? b.toFixed(2) : b);
+    }
+    function Pe(l) {
+      let { config: e, rows: o, fieldList: s } = l,
+        i = C(e.series),
+        t = i,
+        a = re(e),
+        m =
+          Array.isArray(o) &&
+          o.length > 0 &&
+          o.every((r) => r[L.boxPlot.boxPlotMeanLineMarkerId] !== void 0);
+      a &&
+        !m &&
+        (i === d.BoxPlotMonoFieldAndSplitBy
+          ? (t = d.BoxPlotMonoField)
+          : i === d.BoxPlotMultiFieldsAndSplitBy
+          ? (t = d.BoxPlotMultiFields)
+          : i === d.BoxPlotMonoFieldAndCategoryAndSplitBy &&
+            (t = d.BoxPlotMonoFieldAndCategory));
+      let n = T(e),
+        f = Z(e),
+        y = H(e),
+        b = I(e),
+        p;
+      switch (t) {
+        case d.BoxPlotMonoField:
+        case d.BoxPlotMonoFieldAndCategory: {
+          p = o.map((r) => {
+            let u = {};
+            if (r[L.boxPlot.boxPlotOutlierId])
+              D({ rawData: r, outRow: u, config: e, boxPlotSubType: t });
+            else {
+              if (t === d.BoxPlotMonoFieldAndCategory) {
+                let c = S({ field: n, value: r[n], fieldList: s });
+                u[n] = c;
+              } else t === d.BoxPlotMonoField && (u.Field = r[M]);
+              N({ rawData: r, outRow: u });
+            }
+            return u;
+          });
+          break;
+        }
+        case d.BoxPlotMultiFields: {
+          p = o.flatMap((r) => {
+            let u = {};
+            return (
+              r[L.boxPlot.boxPlotOutlierId]
+                ? D({ rawData: r, outRow: u, config: e, boxPlotSubType: t })
+                : ((u.Field = r[M]), N({ rawData: r, outRow: u })),
+              [u]
+            );
+          });
+          break;
+        }
+        case d.BoxPlotMultiFieldsAndCategory: {
+          p = o.flatMap((r) =>
+            f.map((u) => {
+              let c = {},
+                g = "";
+              if (((c.Field = u), r[L.boxPlot.boxPlotOutlierId]))
+                D({ rawData: r, outRow: c, config: e, boxPlotSubType: t });
+              else {
+                if (t === d.BoxPlotMultiFieldsAndCategory) {
+                  let F = S({ field: n, value: r[n], fieldList: s });
+                  (c[n] = F), (g = `${u}_`);
+                }
+                N({ rawData: r, outRow: c, keyBase: g });
+              }
+              return c;
+            })
+          );
+          break;
+        }
+        case d.BoxPlotMonoFieldAndSplitBy:
+        case d.BoxPlotMultiFieldsAndSplitBy:
+        case d.BoxPlotMonoFieldAndCategoryAndSplitBy: {
+          p = o.flatMap((r) => {
+            if (r[L.boxPlot.boxPlotOutlierId]) {
+              let u = {};
+              return (
+                D({ rawData: r, outRow: u, config: e, boxPlotSubType: t }), [u]
+              );
+            } else
+              return r[L.boxPlot.boxPlotMeanLineMarkerId]
+                ? y?.map((u) => {
+                    let c = {};
+                    return (
+                      Fe({ rawData: r, outRow: c, splitByValue: u, config: e }),
+                      c
+                    );
+                  })
+                : y.map((u) => {
+                    let c = {};
+                    if (t === d.BoxPlotMonoFieldAndCategoryAndSplitBy) {
+                      let g = S({ field: n, value: r[n], fieldList: s });
+                      c[n] = g;
+                    }
+                    return (
+                      r[L.boxPlot.boxPlotOutlierId]
+                        ? D({
+                            rawData: r,
+                            outRow: c,
+                            config: e,
+                            boxPlotSubType: t,
+                          })
+                        : ((c[b] = u),
+                          N({ rawData: r, outRow: c, keyBase: `${u}_` })),
+                      c
+                    );
+                  });
+          });
+          break;
+        }
+        default:
+          p = o;
+      }
+      return p;
+    }
+    var ue = (l) => {
+        let e = !1;
+        return (
+          (typeof l == "string" || typeof l == "number") &&
+            (e = !Number.isNaN(new Date(l).getTime())),
+          e
+        );
+      },
+      S = (l) => {
+        let { field: e, value: o, fieldList: s } = l,
+          i = o,
+          t = s?.find((a) => a.name === e);
+        if (t) {
+          let a = t.type === J.DateOnly;
+          Y(t) && !a
+            ? (i = ue(o) ? new Date(o).toISOString() : o)
+            : a &&
+              typeof o != "string" &&
+              (i = ue(o) ? new Date(o).toISOString().split("T")[0] : o);
+        }
+        return i;
+      };
+    function _e() {
+      let l = () =>
+        (((1 + Math.random()) * 65536) | 0).toString(16).substring(1);
+      return `${l() + l()}-${l()}-${l()}-${l()}-${l()}${l()}${l()}`;
+    }
+    return { a: Re, b: he, c: Te, d: ce, e: Ie, f: Ne, g: je, h: _e };
+  },
+  a,
+  b,
+  c,
+  d,
+  e,
+  f,
+  g
+);