@geoscene/charts-components 5.0.19

package/dist/cdn/V2OPADQU.js

@@ -0,0 +1,696 @@
+/* COPYRIGHT  - https://js.geoscene.cn/5.0/LICENSE.txt */
+import g from "./AENRD2JF.js";
+import e from "./P4UNBBUE.js";
+import c from "./DKENL7TV.js";
+import b from "./P5SSZWMH.js";
+import { h as O, o as ae } from "./UG7LOBJE.js";
+import a from "./A7YNU2NS.js";
+import { d as $, g as E, m as Z, n as ee, v as oe } from "./4B3QBH5T.js";
+import { b as d } from "./KUVOINJC.js";
+import { a as f, h as x, v as u } from "./NKG4FLLR.js";
+export default $geoscene.t(
+  ([
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    { substitute: V },
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    {
+      C: j,
+      E: I,
+      Gb: B,
+      Nd: le,
+      Pa: _,
+      Rc: ne,
+      Tc: Q,
+      Uc: X,
+      W: J,
+      Wd: L,
+      X: ie,
+      Y: re,
+      bd: A,
+      da: D,
+      ea: R,
+      fd: te,
+      ma: se,
+      qa: W,
+    },
+    { a: C, d: Y, e: G, f: ce, n: me, r: ye },
+    { c: P },
+    { a: de },
+    { i: T },
+  ]) => {
+    var uo = (o, e) => e?.series?.[o]?.name,
+      So = (o, e, i) => {
+        let r = i;
+        r?.series?.[e] !== void 0 && (r.series[e].name = o);
+      },
+      po = (o, e) => {
+        let i,
+          r = e.series?.[o];
+        return (
+          r?.type === f.BoxPlotSeries
+            ? (i = r.fillSymbol?.color)
+            : r?.type === f.LineSeries && (i = r.lineSymbol?.color),
+          i
+        );
+      },
+      ve = (o) => {
+        let e = o.series[0];
+        return o.showMean === !0 && O(e) ? e.fillSymbol?.color : void 0;
+      },
+      Be = (o, e) => {
+        let i = e.series[0];
+        e.showMean === !0 &&
+          O(i) &&
+          (i.fillSymbol !== void 0
+            ? (i.fillSymbol.color = o)
+            : (i.fillSymbol = { ...D(), color: o }));
+      },
+      bo = (o, e, i) => {
+        let r = i?.series?.[e];
+        r?.type === f.BoxPlotSeries && r.fillSymbol !== void 0
+          ? (r.fillSymbol.color = o)
+          : r?.type === f.LineSeries &&
+            r.lineSymbol !== void 0 &&
+            ((r.lineSymbol.color = o),
+            r.markerSymbol !== void 0 && (r.markerSymbol.color = o));
+      },
+      Me = (o) => o.series.map((e) => e.id),
+      Ae = (o, e) => {
+        e?.series?.sort(
+          (i, r) =>
+            o.findIndex((s) => i.id === s) - o.findIndex((s) => r.id === s)
+        );
+      },
+      ho = (o, e, i) => {
+        let r = Me(i),
+          [s] = r.splice(o, 1);
+        r.splice(e, 0, s), Ae(r, i);
+      },
+      xo = (o) =>
+        H(o) ? o.series.findIndex((e) => e.type === f.BoxPlotSeries) : -1;
+    function Le(o, e, i) {
+      let r = he(o, e, i),
+        s = de(o),
+        n = L(o);
+      return r === s || n;
+    }
+    function fe(o, e, i) {
+      let r = k(o, e, i),
+        s = P(1, o),
+        n = L(o);
+      return r === s || n;
+    }
+    function Oe(o) {
+      let { config: e, layerInfo: i, newCategory: r } = o,
+        { layerFieldsInfo: s } = i,
+        n = M(e),
+        l = r !== I ? B(s, n) : "",
+        t = P(0, e),
+        a = L(e);
+      return l === t || a || t.trim() === "";
+    }
+    var M = (o) => A(o)?.x ?? I,
+      Ce = $(
+        (o) => {
+          let e = A(o),
+            i = e?.query?.where?.split("=")[0].trim() ?? "";
+          return te(e?.query?.where) ? "" : i;
+        },
+        (o) => A(o)?.query?.where
+      ),
+      ge = $(
+        (o) => le(o?.series).filter((e) => e !== ""),
+        (o) => o?.series
+      ),
+      N = (o) => {
+        let { category: e, seriesIndex: i, y: r, commonStrings: s } = o,
+          n = {
+            ...W(s, i),
+            x: e === void 0 || e === "" ? I : e,
+            y: r,
+            query: {},
+          };
+        return E(n);
+      },
+      ke = (o) => {
+        let { category: e, seriesIndex: i, y: r, commonStrings: s } = o,
+          n = {
+            ...se({ commonStrings: s, seriesIndex: i }),
+            x: e === void 0 || e === "" ? I : e,
+            y: r,
+            query: {},
+          };
+        return E(n);
+      };
+    function ue(o) {
+      let { x: e, y: i, seriesTemplate: r, commonStrings: s } = o,
+        { id: n, fillSymbol: l } = r ?? {},
+        t = W(s),
+        a = n ?? `series_${Date.now()}`;
+      return (
+        (t.id = a),
+        (t.name = a),
+        (t.x = e),
+        (t.y = i),
+        l
+          ? (t.fillSymbol = l)
+          : t.fillSymbol &&
+            ((t.fillSymbol.color = _),
+            t.fillSymbol?.outline && (t.fillSymbol.outline.color = _)),
+        t
+      );
+    }
+    function Se(o) {
+      let {
+          numericFields: e,
+          config: i,
+          layerInfo: r,
+          category: s,
+          commonStrings: n,
+        } = o,
+        { layerFieldsInfo: l } = r,
+        t = [],
+        a = s ?? M(i),
+        m = !1,
+        c = T({ fieldName: a, numericFields: e, fieldList: l });
+      if (e.length === 0) {
+        let S = N({ y: "", seriesIndex: 0, category: a, commonStrings: n });
+        t.push(S);
+      } else if (c) {
+        let S = e.length > 1 ? e : e[0],
+          w = N({ y: S, seriesIndex: 0, category: a, commonStrings: n }),
+          b = e.length > 1 ? n.axisLabels.values : B(r.layerFieldsInfo, e[0]),
+          p = { ...w, id: e[0], name: b, x: c ? I : a },
+          g = i.series.find((y) => ee(S, y.y) && y.query?.where === void 0);
+        g !== void 0 &&
+          (!i.colorMatch &&
+            "fillSymbol" in g &&
+            ((p.fillSymbol = g.fillSymbol), (m = !0)),
+          (p.id = g.id),
+          (p.name = g.name)),
+          t.push(p);
+      } else
+        for (let S = 0; S < e.length; S += 1) {
+          let w = e[S],
+            b = N({ y: w, seriesIndex: S, category: a, commonStrings: n }),
+            p = B(l, w),
+            g = { ...b, id: w, name: p, x: a },
+            y = i.series.find((v) => w === v.y);
+          y !== void 0 &&
+            (!i.colorMatch &&
+              "fillSymbol" in y &&
+              ((g.fillSymbol = y.fillSymbol), (m = !0)),
+            (g.id = y.id),
+            (g.name = y.name)),
+            t.push(g);
+        }
+      return (
+        i.series.length === 1 &&
+          t.length === 1 &&
+          !i.colorMatch &&
+          "fillSymbol" in i.series[0] &&
+          ((t[0].fillSymbol = i.series[0].fillSymbol), (m = !0)),
+        (i.colorMatch = !m),
+        t
+      );
+    }
+    var pe = (o) =>
+        o?.query?.where?.split("=")[1].trim().replace(/'/gu, "") ?? "",
+      qe = (o) =>
+        o.series.some((e) => e.type === f.LineSeries) &&
+        o.series.some((e) => e.type === f.BoxPlotSeries);
+    function De(o, e, i) {
+      let r = [];
+      return (
+        o.forEach((s) => {
+          if (s.type === f.BoxPlotSeries) {
+            let { type: n, fillSymbol: l, ...t } = s;
+            r.push({
+              ...t,
+              type: f.LineSeries,
+              lineSymbol: {
+                ...J({ width: j }),
+                ...(l !== void 0 ? { color: l.color } : {}),
+              },
+              markerSymbol: {
+                ...R(),
+                ...(l !== void 0 ? { color: l.color } : {}),
+              },
+            });
+          }
+        }),
+        r.unshift(
+          ue({ x: o[0].x, y: o[0].y, seriesTemplate: i, commonStrings: e })
+        ),
+        r
+      );
+    }
+    function Te(o) {
+      let e = o.slice(1),
+        i = [];
+      return (
+        e.forEach((r) => {
+          if (r.type === f.LineSeries) {
+            let { type: s, lineSymbol: n, markerSymbol: l, ...t } = r,
+              a = D();
+            i.push({
+              ...t,
+              type: f.BoxPlotSeries,
+              fillSymbol: { ...a, color: n?.color },
+            });
+          }
+        }),
+        i
+      );
+    }
+    function be(o) {
+      let { formerSeries: e, newSeries: i, showMean: r } = o,
+        s = i,
+        n = (a) => a.type === (r ? f.LineSeries : f.BoxPlotSeries),
+        l = e.filter(n).map((a) => a.id),
+        t = i.filter(n).map((a) => a.id);
+      return (
+        l.length === t.length &&
+          JSON.stringify(l) !== JSON.stringify(t) &&
+          (s = s.sort(
+            (a, m) =>
+              l.findIndex((c) => c === a.id) - l.findIndex((c) => c === m.id)
+          )),
+        s
+      );
+    }
+    async function Pe(o) {
+      let {
+          config: e,
+          layerInfo: i,
+          commonStrings: r,
+          splitByField: s,
+          numericFields: n,
+          category: l,
+        } = o,
+        { layer: t, layerFieldsInfo: a } = i,
+        { fetchNullValues: m } = A(e)?.query ?? {},
+        c = l ?? M(e),
+        { categoriesArray: S, splitByFieldType: w } = await me({
+          config: e,
+          layer: t,
+          layerFieldsInfo: a,
+          xAxisField: K(c) ? void 0 : c,
+          aggregationFields: n,
+          splitByField: s,
+          fetchNullValues: m,
+        }),
+        b = [],
+        p = !1,
+        g = qe(e);
+      if (S.length === 0) {
+        b = Se({
+          numericFields: n,
+          category: c,
+          config: e,
+          layerInfo: i,
+          commonStrings: r,
+        });
+        for (let y of b) y.query && (y.query.where = `${s}=''`);
+      } else
+        for (let y = 0; y < S.length; y += 1) {
+          let v = S[y],
+            q = { y: n, seriesIndex: y, category: c, commonStrings: r },
+            U = g ? ke(q) : N(q),
+            we = {
+              fieldName: s,
+              fieldValueToMatch: v ?? "",
+              subtypeInfo: Q(i.layer),
+              fieldList: i.layerFieldsInfo,
+            },
+            Fe = X(we),
+            z = `${v}`,
+            F = {
+              ...U,
+              id: z,
+              name: Fe ?? z,
+              x: c === void 0 || c === "" ? I : c,
+              query: {
+                ...U.query,
+                where: `${s}=${w === oe.String && v !== null ? `'${v}'` : v}`,
+              },
+            },
+            h = e.series.find((Ie) => pe(Ie) === z);
+          h !== void 0 &&
+            (e.colorMatch ||
+              (F.type === f.BoxPlotSeries
+                ? O(h)
+                  ? (F.fillSymbol = h.fillSymbol)
+                  : (F.fillSymbol = { ...D(), color: h.lineSymbol?.color })
+                : O(h)
+                ? ((F.lineSymbol = {
+                    ...J({ width: j }),
+                    ...(h.fillSymbol !== void 0
+                      ? { color: h.fillSymbol.color }
+                      : {}),
+                  }),
+                  (F.markerSymbol = {
+                    ...R(),
+                    ...(h.fillSymbol !== void 0
+                      ? { color: h.fillSymbol.color }
+                      : {}),
+                  }))
+                : ((F.lineSymbol = h.lineSymbol),
+                  (F.markerSymbol = h.markerSymbol)),
+              (p = !0)),
+            (F.id = h.id),
+            (F.name = h.name)),
+            b.push(F);
+        }
+      if (
+        ((b = be({ formerSeries: e.series, newSeries: b, showMean: H(e) })),
+        (e.colorMatch = !p),
+        H(e))
+      ) {
+        let y = e.series.find((q) => q.type === f.BoxPlotSeries),
+          v = ue({ x: c, y: n, seriesTemplate: y, commonStrings: r });
+        b.unshift(v);
+      }
+      return b;
+    }
+    var wo = async (o) => {
+        let {
+            splitByField: e,
+            numericFields: i,
+            category: r,
+            config: s,
+            layerInfo: n,
+            commonStrings: l,
+          } = o,
+          { layerFieldsInfo: t } = n,
+          a = $e(r, i, e),
+          m = ne(t),
+          c = M(s),
+          S = Le(s, n, l),
+          w = fe(s, n, l),
+          b = Oe({ config: s, layerInfo: n, newCategory: r }),
+          p = G(s);
+        if (
+          (!m.includes(c) && m.includes(r)
+            ? (p = re())
+            : m.includes(c) && !m.includes(r) && (p = ie()),
+          p !== void 0 && ce(s, l, p),
+          Ne(
+            a
+              ? { newShowMeanLines: s.showMean, config: s, commonStrings: l }
+              : { newShowMeanLines: !1, config: s, commonStrings: l }
+          ),
+          (s.series = a
+            ? await Pe({
+                config: s,
+                layerInfo: n,
+                splitByField: e,
+                numericFields: i,
+                category: r,
+                commonStrings: l,
+              })
+            : Se({
+                numericFields: i,
+                config: s,
+                layerInfo: n,
+                category: r,
+                commonStrings: l,
+              })),
+          b)
+        ) {
+          let g = T({ fieldName: r, numericFields: i, fieldList: t })
+            ? ""
+            : B(t, r);
+          C(s, 0, g);
+        }
+        if (w) {
+          let g = k(s, n, l);
+          C(s, 1, g);
+        }
+        s?.title !== void 0 && S && (s.title.content.text = he(s, n, l)),
+          Y({ config: s, value: null, axisIndex: 1, isMax: !1 }),
+          Y({ config: s, value: null, axisIndex: 1, isMax: !0 });
+      },
+      Ve = (o) => o?.standardizeValues ?? !1;
+    function k(o, e, i) {
+      let { layerFieldsInfo: r } = e,
+        s = Ve(o) ? i.axisLabels.standardizedValues : i.axisLabels.values,
+        n = o?.series?.map((l) => l.y).flat();
+      return (n = [...new Set(n)]), n.length === 1 && (s = B(r, n[0])), s;
+    }
+    function he(o, e, i) {
+      let { layerFieldsInfo: r } = e,
+        s = M(o),
+        n = ge(o),
+        l = Ce(o),
+        t = n.map((c) => B(r ?? [], c)).join(", "),
+        a = B(r ?? [], s),
+        m = "";
+      return (
+        n.length > 0 &&
+          (s !== I && l !== ""
+            ? (m = V(i.titleLabels.distributionOfFieldsByCategoryAndSplitBy, {
+                valueFields: t,
+                category: a,
+                splitByField: l,
+              }))
+            : s !== I
+            ? (m = V(i.titleLabels.distributionOfFieldsByCategory, {
+                valueFields: t,
+                category: a,
+              }))
+            : l !== ""
+            ? (m = V(i.titleLabels.distributionOfFieldsByCategory, {
+                valueFields: t,
+                category: l,
+              }))
+            : (m = V(i.titleLabels.distributionOfField, { valueField: t }))),
+        m
+      );
+    }
+    var Fo = (o) => {
+        let { series: e, splitByField: i, layerInfo: r, commonStrings: s } = o,
+          n =
+            typeof e.y == "string"
+              ? B(r.layerFieldsInfo, e.y)
+              : s.axisLabels.values;
+        Z(i) || (n = pe(e));
+        let l = {
+          fieldName: i,
+          fieldValueToMatch: n ?? "",
+          subtypeInfo: Q(r.layer),
+          fieldList: r.layerFieldsInfo,
+        };
+        return (n = X(l) ?? n), n ?? e.id;
+      },
+      Io = (o) => o?.showOutliers ?? !1,
+      vo = (o) => {
+        let {
+          newShowOutliers: e,
+          config: i,
+          layerInfo: r,
+          commonStrings: s,
+        } = o;
+        if (((i.showOutliers = e), fe(i, r, s))) {
+          let n = k(i, r, s);
+          C(i, 1, n);
+        }
+      },
+      Bo = (o) => {
+        let {
+            newStandardizeValues: e,
+            config: i,
+            layerInfo: r,
+            commonStrings: s,
+          } = o,
+          n = P(1, i),
+          l = k(i, r, s),
+          t = L(i);
+        if (((i.standardizeValues = e), n === l || t)) {
+          let a = k(i, r, s);
+          C(i, 1, a);
+        }
+      },
+      xe = (o) => {
+        let e = d.xAxisAsc,
+          i = o.orderOptions?.data?.orderType ?? u.Category,
+          r =
+            o.orderOptions?.data && "orderBy" in o.orderOptions.data
+              ? o.orderOptions.data.orderBy
+              : x.Ascending;
+        switch (i) {
+          case u.Category:
+            e = Array.isArray(r)
+              ? d.customSort
+              : r === x.Ascending
+              ? d.xAxisAsc
+              : d.xAxisDesc;
+            break;
+          case u.Mean:
+            e = r === x.Ascending ? d.meanAsc : d.meanDesc;
+            break;
+          case u.Median:
+            e = r === x.Ascending ? d.medianAsc : d.medianDesc;
+            break;
+        }
+        return e;
+      },
+      Mo = (o, e, i) => {
+        let r = u.Category,
+          s = x.Ascending;
+        if (
+          ((e.orderOptions = e.orderOptions ?? {}),
+          o === d.customSort && i !== void 0)
+        )
+          e.orderOptions.data = { orderType: u.Category, orderBy: i };
+        else {
+          switch (o) {
+            case d.xAxisAsc: {
+              (r = u.Category), (s = x.Ascending);
+              break;
+            }
+            case d.xAxisDesc: {
+              (r = u.Category), (s = x.Descending);
+              break;
+            }
+            case d.meanAsc: {
+              (r = u.Mean), (s = x.Ascending);
+              break;
+            }
+            case d.meanDesc: {
+              (r = u.Mean), (s = x.Descending);
+              break;
+            }
+            case d.medianAsc: {
+              (r = u.Median), (s = x.Ascending);
+              break;
+            }
+            case d.medianDesc: {
+              (r = u.Median), (s = x.Descending);
+              break;
+            }
+          }
+          e.orderOptions.data = { orderType: r, orderBy: s };
+        }
+      },
+      H = (o) => o.showMean ?? !1,
+      Ne = (o) => {
+        let {
+            newShowMeanLines: e = !1,
+            config: i,
+            commonStrings: r,
+            previousMeanLinesBoxColor: s,
+          } = o,
+          n = e ? s : ve(i),
+          l = (e ?? !1) !== (i.showMean ?? !1);
+        if (((i.showMean = e), l)) {
+          let t;
+          e
+            ? (t = ae(i.series) ? De(i.series, r) : i.series)
+            : (t = Te(i.series)),
+            t &&
+              ((t = be({ formerSeries: i.series, newSeries: t, showMean: e })),
+              (i.series = t));
+        }
+        return e && s !== void 0 && Be(s, i), { previousMeanLinesBoxColor: n };
+      },
+      Ao = (o) => {
+        let e = [],
+          i = o.orderOptions?.data?.orderType;
+        return (
+          xe(o) === d.customSort &&
+            i === u.Category &&
+            (e = o.orderOptions?.data?.orderBy),
+          e
+        );
+      },
+      Lo = (o, e) => {
+        e.orderOptions ??= {};
+        let i = e.orderOptions?.data?.orderType;
+        xe(e) === d.customSort &&
+          i === u.Category &&
+          (e.orderOptions.data = { orderType: u.Category, orderBy: o });
+      },
+      Oo = async (o, e) => {
+        let i = M(o),
+          r = G(o)?.type,
+          s = ge(o),
+          n = [];
+        return (
+          r === f.CategoryAxisFormat &&
+            (T({ fieldName: i, numericFields: s, fieldList: e.layerFieldsInfo })
+              ? (n = s)
+              : K(i) ||
+                (n = await ye({ layerInfo: e, config: o, category: i }))),
+          n
+        );
+      },
+      K = (o) => o.trim() === "" || o === I,
+      ze = (o, e) => e.length > 1 && !K(o),
+      $e = (o, e, i) => !ze(o, e) && i !== "";
+    return {
+      a: uo,
+      b: So,
+      c: po,
+      d: ve,
+      e: Be,
+      f: bo,
+      g: Me,
+      h: Ae,
+      i: ho,
+      j: xo,
+      k: M,
+      l: Ce,
+      m: ge,
+      n: wo,
+      o: Ve,
+      p: k,
+      q: he,
+      r: Fo,
+      s: Io,
+      t: vo,
+      u: Bo,
+      v: xe,
+      w: Mo,
+      x: H,
+      y: Ne,
+      z: Ao,
+      A: Lo,
+      B: Oo,
+      C: ze,
+      D: $e,
+    };
+  },
+  "geometry/support/jsonUtils",
+  "rest/support/AttributeBinsQuery",
+  "rest/support/StatisticDefinition",
+  "time/TimeExtent",
+  "core/promiseUtils",
+  "request",
+  "intl",
+  "Graphic",
+  "renderers/support/jsonUtils",
+  "symbols/support/symbolUtils",
+  "layers/support/FeatureFilter",
+  "smartMapping/statistics/histogram",
+  "smartMapping/statistics/summaryStatistics",
+  "core/sql",
+  "AttributeBinsGraphic",
+  a,
+  b,
+  c,
+  e,
+  g
+);