@geoscene/charts-components 5.0.19

package/dist/cdn/ZLRKGGOO.js

@@ -0,0 +1,1414 @@
+/* COPYRIGHT  - https://js.geoscene.cn/5.0/LICENSE.txt */
+import g from "./AENRD2JF.js";
+import f from "./P4UNBBUE.js";
+import e from "./DKENL7TV.js";
+import d from "./ISWZQ6CS.js";
+import c from "./P5SSZWMH.js";
+import {
+  g as ce,
+  i as b,
+  j as B,
+  k,
+  l as ye,
+  m as He,
+  n as Je,
+} from "./UG7LOBJE.js";
+import a from "./A7YNU2NS.js";
+import { B as ve, d as xe, g as ie, m as be, v as se } from "./4B3QBH5T.js";
+import { a as z } from "./KUVOINJC.js";
+import {
+  a as L,
+  b as C,
+  e as Be,
+  h as he,
+  k as Y,
+  n as j,
+  o as Te,
+  v,
+  y as Ce,
+} from "./NKG4FLLR.js";
+export default $geoscene.t(
+  ([
+    { substitute: R },
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    {
+      Bc: $e,
+      Dc: je,
+      Ec: De,
+      Gb: N,
+      Gc: Pe,
+      Hd: ze,
+      Ia: Ne,
+      Ic: Ee,
+      Nc: E,
+      Oc: Ue,
+      Qc: re,
+      Ra: P,
+      Rc: Xe,
+      Tc: ne,
+      Uc: oe,
+      Wd: X,
+      X: te,
+      Y: qe,
+      Ya: Q,
+      Yc: _e,
+      Z: ke,
+      _b: Re,
+      ac: ae,
+      dd: We,
+      ed: le,
+      f: D,
+      fd: Ye,
+      gd: U,
+      hd: Qe,
+      ic: Ve,
+      id: I,
+      ja: we,
+      k: Ie,
+      ma: Me,
+      na: Le,
+      pa: Oe,
+      x: Ae,
+      yb: O,
+    },
+    { a: V, b: ge, d: A, e: ue, f: Ge, g: de, n: Ke, r: ei },
+    { a: Ze },
+    { c: J },
+    { a: si, e: ti },
+    { a: ii, b: me, f: $, g: H, i: pe },
+  ]) => {
+    function es(i, e) {
+      let s;
+      return (
+        e !== void 0 &&
+          ((s = { ...e }), s.legend !== void 0 && (s.legend.position = i)),
+        s
+      );
+    }
+    function is(i, e) {
+      let s;
+      return (
+        e !== void 0 &&
+          ((s = { ...e }), s.legend !== void 0 && (s.legend.visible = i)),
+        s
+      );
+    }
+    function ss(i, e) {
+      let s;
+      return e !== void 0 && (s = { ...e, rotated: i }), s;
+    }
+    function oi(i) {
+      let e;
+      return (
+        i !== void 0 &&
+          ((e = { ...i }),
+          delete e.axes?.[0]?.minimum,
+          delete e.axes?.[0]?.maximum,
+          delete e.axes?.[1]?.minimum,
+          delete e.axes?.[1]?.maximum),
+        e
+      );
+    }
+    function ts(i, e) {
+      return e != null || ce(i);
+    }
+    async function li(i) {
+      let { queryObject: e, chartConfig: s, options: r, splitByField: a } = i,
+        t = [],
+        n,
+        l = ie(s),
+        o = l.series[0],
+        u = _e({
+          queryObject: e,
+          chartConfig: l,
+          runtimeDataFilters: r?.runtimeDataFilters,
+          ignoreViewExtent: r?.ignoreViewExtent,
+        });
+      if (
+        (u.outStatistics?.[0]?.outStatisticFieldName &&
+          (u.outStatistics[0].outStatisticFieldName =
+            Ae.outStatistics.outStatisticFieldName),
+        I(o) &&
+          Qe({
+            xAxisValueFormatType: Ie(l),
+            setTimeBinningInfoWhenNotProvided:
+              r?.setTimeBinningInfoWhenNotProvided,
+            seriesConfig: o,
+          }) &&
+          $e(e))
+      ) {
+        let { temporalBinning: F, x: y } = o,
+          { uniqueQuery: p } = await ae({
+            chartConfig: l,
+            queryConfig: u,
+            queryObject: e,
+            options: r,
+          });
+        (n = await Ee({
+          queryObject: e,
+          dateField: y,
+          splitByField: a,
+          queryConfig: p,
+          temporalBinning: F,
+        })),
+          (t = Array.from(
+            new Set(
+              n.flatMap((f) => {
+                let { stackedAttributes: d } = f,
+                  g = [];
+                return (
+                  d && (g = d.map((S) => S[a]).filter((S) => S !== void 0)), g
+                );
+              })
+            ).values()
+          ));
+      } else {
+        let { uniqueQuery: F } = await ae({
+            chartConfig: l,
+            queryObject: e,
+            queryConfig: u,
+            options: r,
+          }),
+          { elementCount: y } = await Ve({
+            chartConfig: l,
+            queryObject: e,
+            queryConfig: u,
+            behaviorAfterLimit: r?.chartLimits?.behaviorAfterLimit,
+            numberMaxOfFeaturesToFetch: F.num,
+          });
+        (n = await Pe({ queryObject: e, queryConfig: F, featureCount: y })),
+          (t = Array.from(
+            new Set(
+              n.map((p) => p.attributes[a]).filter((p) => p !== void 0)
+            ).values()
+          ));
+      }
+      return { allValues: t, preFetchedQueryResponse: n };
+    }
+    function ci(i, e) {
+      let s = new Map();
+      return (
+        i.series.forEach((r) => {
+          let a = le({ where: r.query?.where, normalize: !0, escape: !1 });
+          e && a !== null && (a = Number(a));
+          let t = Ce([r]);
+          t !== void 0 && s.set(t, [...(s.get(t) ?? []), a]);
+        }),
+        s
+      );
+    }
+    function yi(i) {
+      let {
+          allValues: e,
+          configUniqueValuesPerSeriesType: s,
+          initialConfigWasEmpty: r,
+        } = i,
+        a = new Map();
+      return (
+        Array.from(s.keys()).forEach((t) => {
+          let n = s.get(t) ?? [],
+            l = [];
+          r
+            ? (l = e)
+            : e.forEach((o) => {
+                n.includes(o) || l.push(o);
+              }),
+            a.set(t, l);
+        }),
+        a
+      );
+    }
+    function gi(i) {
+      let {
+          chartConfig: e,
+          missingValue: s,
+          splitByField: r,
+          seriesTemplate: a,
+        } = i,
+        t = JSON.parse(JSON.stringify({ ...e.series[0], ...a }));
+      if (t.query) {
+        if (
+          ((t.id = `${s}-${e.series.length}-${Date.now()}`),
+          (t.name = `${s}`),
+          t.query.outStatistics?.[0] !== void 0)
+        ) {
+          let l = t.id;
+          (t.query.outStatistics[0].outStatisticFieldName = l),
+            "y" in t && (t.y = l);
+        }
+        let n = typeof s == "number" || s === null ? s : `'${s}'`;
+        t.query.where = `${r}=${n}`;
+      }
+      return t;
+    }
+    async function ui(i) {
+      let { updateSplitBySeries: e, config: s, options: r, queryObject: a } = i,
+        { seriesTemplate: t } = e ?? {},
+        n;
+      if (
+        a &&
+        e !== void 0 &&
+        s !== void 0 &&
+        (s.series.length > 0 || t !== void 0) &&
+        e.addMissingSeries
+      ) {
+        let l = s.series.length === 0;
+        s.series.length === 0 && t !== void 0 && s.series.push(t);
+        let o = U(s.series);
+        if (
+          o === O.BoxPlotMonoFieldAndSplitBy ||
+          o === O.BoxPlotMultiFieldsAndSplitBy ||
+          o === O.BoxPlotMonoFieldAndCategoryAndSplitBy ||
+          o === O.BarAndLineSplitBy ||
+          o === O.BarAndLineSplitByNoAggregation
+        ) {
+          let u = We(s.series[0]?.query?.where),
+            F = je(a);
+          await F.load();
+          let y = F.getField(u)?.toJSON(),
+            p = Ue(y),
+            f = await li({
+              queryObject: a,
+              chartConfig: s,
+              splitByField: u,
+              options: r,
+            }),
+            { allValues: d } = f;
+          if ((({ preFetchedQueryResponse: n } = f), d.length > 0)) {
+            let g = ci(s, p),
+              S = yi({
+                allValues: d,
+                configUniqueValuesPerSeriesType: g,
+                initialConfigWasEmpty: l,
+              });
+            Array.from(S.keys()).forEach((h) => {
+              (S.get(h) ?? []).forEach((x) => {
+                s.series.push(
+                  gi({
+                    chartConfig: s,
+                    seriesTemplate: t,
+                    missingValue: x,
+                    splitByField: u,
+                  })
+                );
+              }),
+                l && s.series.shift();
+            });
+          }
+        }
+      }
+      return n;
+    }
+    function di(i, e) {
+      e && !ce(e) && (e = De({ chartConfig: e, queryObject: i }));
+    }
+    async function as(i) {
+      let {
+          configToAlter: e,
+          layer: s,
+          addMissingSeries: r,
+          updateSplitBySeries: a,
+          chartContainer: t,
+          queryObject: n,
+          options: l,
+        } = i,
+        o = e,
+        u;
+      return (
+        o &&
+          (di(s, o),
+          (o = await Ze(o, s)),
+          r &&
+            (u = await ui({
+              updateSplitBySeries: a,
+              config: o,
+              options: l,
+              queryObject: n,
+            })),
+          (o = ze(o, t))),
+        { alteredConfig: o, preFetchedQueryResponse: u }
+      );
+    }
+    var rs = (i) => {
+        let e,
+          s = i.series[0];
+        return I(s) && (e = s.temporalBinning?.size), e;
+      },
+      mi = (i) => {
+        let e,
+          s = i.series[0];
+        return I(s) && (e = s.temporalBinning?.unit), e;
+      },
+      ns = (i) => {
+        let e,
+          s = i.series[0];
+        return I(s) && (e = s.temporalBinning?.timeAggregationType), e;
+      },
+      os = (i) => {
+        let e,
+          s = i.series[0];
+        return I(s) && (e = s.temporalBinning?.trimIncompleteTimeInterval), e;
+      },
+      ls = (i) => {
+        let e,
+          s = i.series[0];
+        return I(s) && (e = s.temporalBinning?.nullPolicy), e;
+      },
+      pi = (i, e) => {
+        e?.series?.forEach((s) => {
+          I(s) && ((s.temporalBinning ??= {}), (s.temporalBinning.size = i));
+        }),
+          A({ config: e, value: null, axisIndex: 1, isMax: !1 }),
+          A({ config: e, value: null, axisIndex: 1, isMax: !0 });
+      },
+      fi = (i, e) => {
+        e?.series?.forEach((s) => {
+          I(s) &&
+            ((s.temporalBinning ??= {}), (s.temporalBinning.nullPolicy = i));
+        }),
+          A({ config: e, value: null, axisIndex: 1, isMax: !1 }),
+          A({ config: e, value: null, axisIndex: 1, isMax: !0 });
+      },
+      cs = (i, e) => {
+        e.series?.forEach((s) => {
+          I(s) && ((s.temporalBinning ??= {}), (s.temporalBinning.unit = i));
+        }),
+          A({ config: e, value: null, axisIndex: 1, isMax: !1 }),
+          A({ config: e, value: null, axisIndex: 1, isMax: !0 });
+      },
+      ys = (i, e) => {
+        e.series?.forEach((s) => {
+          I(s) &&
+            ((s.temporalBinning ??= {}),
+            (s.temporalBinning.timeAggregationType = i));
+        }),
+          A({ config: e, value: null, axisIndex: 1, isMax: !1 }),
+          A({ config: e, value: null, axisIndex: 1, isMax: !0 });
+      },
+      gs = (i, e) => {
+        e.series?.forEach((s) => {
+          I(s) &&
+            ((s.temporalBinning ??= {}),
+            (s.temporalBinning.trimIncompleteTimeInterval = i));
+        }),
+          A({ config: e, value: null, axisIndex: 1, isMax: !1 }),
+          A({ config: e, value: null, axisIndex: 1, isMax: !0 });
+      },
+      us = (i) => {
+        pi(0, i);
+      },
+      ds = (i) => i.hideEmptyRowsAndColumns,
+      ms = (i, e) => {
+        i.hideEmptyRowsAndColumns = e;
+      },
+      ps = (i, e) => {
+        let s = i.series[0];
+        s.heatRulesType = e;
+      },
+      fs = (i) => i.series[0].heatRulesType,
+      Ss = (i, e) => {
+        let s = i.series[0];
+        s.gradientRules = e;
+      },
+      Fs = (i) => i.series[0].gradientRules,
+      xs = (i) => {
+        let { yField: e, config: s, layerInfo: r } = i,
+          { layerFieldsInfo: a } = r,
+          t = J(1, s),
+          n = Si(s),
+          l = X(s),
+          o = s.series[0];
+        if (
+          typeof e == "string" &&
+          n !== e &&
+          o &&
+          ((o.y = e), oi(s), n === t || l)
+        ) {
+          let u = N(a, e);
+          V(s, 1, u);
+        }
+      },
+      Si = (i) => i.series[0].y ?? "",
+      bs = (i) => {
+        let { binning: e, config: s, commonStrings: r } = i,
+          a = s.series[0];
+        if (
+          ((a.xTemporalBinning = e),
+          e?.unit !== void 0 &&
+            e.unit in r.utilsStrings.heatChartCalendarDatePartsUnits)
+        ) {
+          let t = r.utilsStrings.heatChartCalendarDatePartsUnits[e.unit];
+          V(s, 0, t);
+        }
+      },
+      Bs = (i) => i.series[0].xTemporalBinning,
+      hs = (i) => {
+        let { binning: e, config: s, commonStrings: r } = i,
+          a = s.series[0];
+        if (
+          ((a.yTemporalBinning = e),
+          e?.unit !== void 0 &&
+            e.unit in r.utilsStrings.heatChartCalendarDatePartsUnits)
+        ) {
+          let t = r.utilsStrings.heatChartCalendarDatePartsUnits[e.unit];
+          V(s, 1, t);
+        }
+      },
+      Ts = (i) => i.series[0].yTemporalBinning,
+      Fi = (i, e) => {
+        e.orderOptions ??= {};
+        let s =
+            e.axes?.[0]?.valueFormat?.type === "category"
+              ? v.Category
+              : v.YValue,
+          r = fe(e)[0],
+          a =
+            e.axes?.[1]?.valueFormat?.type === "category"
+              ? v.Category
+              : v.YValue,
+          t = fe(e)[1],
+          n = { ...(e.orderOptions.data ?? {}), orderType: v.MultiAxes };
+        r === z.customSort && s === v.Category && (n.orderByX = [...i]),
+          t === z.customSort && a === v.Category && (n.orderByY = [...i]),
+          Object.keys(n).length > 1 && (e.orderOptions.data = n);
+      },
+      Cs = (i, e) => {
+        let s = e.series[0];
+        s.gridLine && (s.gridLine.width = i);
+      },
+      vs = (i) => i.series[0].gridLine?.width,
+      Is = (i, e) => {
+        let s = e.series[0],
+          r = i?.length === 4 && i.every((a) => typeof a == "number");
+        s.gridLine && r && (s.gridLine.color = i);
+      },
+      As = (i) => i.series[0].gridLine?.color,
+      qs = (i, e) => {
+        let s = e.legend;
+        s && (s.position = i);
+      },
+      ks = (i) => i.legend?.position ?? Be.Bottom,
+      ws = (i) => i.series[0].query?.outStatistics?.[0]?.onStatisticField,
+      Ms = (i) => {
+        let { field: e, config: s, layerInfo: r, commonStrings: a } = i,
+          t = s.series[0].query?.outStatistics?.[0],
+          n = Fe(s, r, a);
+        t
+          ? ((t.onStatisticField = e),
+            (t.outStatisticFieldName = `${t.statisticType}_${e}`))
+          : (s.series[0].query = {
+              outStatistics: [
+                {
+                  onStatisticField: e,
+                  outStatisticFieldName: `${C.Count}_${e}`,
+                  statisticType: C.Count,
+                },
+              ],
+            }),
+          s.title && n && (s.title.content.text = G(s, r, a));
+      },
+      Ls = (i) =>
+        i.series[0].query?.outStatistics?.[0].statisticType ?? C.Count,
+      Os = (i) => {
+        let {
+            aggregationType: e,
+            config: s,
+            layerInfo: r,
+            commonStrings: a,
+          } = i,
+          t = s.series[0]?.query?.outStatistics?.[0],
+          n = Fe(s, r, a);
+        t &&
+          e !== C.NoAggregation &&
+          ((t.statisticType = e),
+          (t.outStatisticFieldName = `${e}_${t.onStatisticField}`)),
+          (e === C.Count || e === C.Sum) && xi(j.Zero, s),
+          s.title && n && (s.title.content.text = G(s, r, a));
+      },
+      Ns = (i) => i.nullPolicy,
+      xi = (i, e) => {
+        e.nullPolicy = i;
+      },
+      Rs = (i) => i.series[0].emptyCells,
+      Vs = (i, e) => {
+        e.series[0].emptyCells = i;
+      },
+      $s = (i) => i.series[0].emptyCells?.text,
+      js = (i, e) => {
+        e.series[0].emptyCells
+          ? (e.series[0].emptyCells.text = i)
+          : (e.series[0].emptyCells = { text: i });
+      },
+      Ds = (i) => i.includeLeapDay,
+      Ps = (i, e) => {
+        e.includeLeapDay = i;
+      },
+      Es = (i) => i.series[0].emptyCells?.symbol,
+      Us = (i, e) => {
+        e.series[0].emptyCells
+          ? (e.series[0].emptyCells.symbol = i)
+          : (e.series[0].emptyCells = { symbol: i });
+      };
+    function Xs(i) {
+      return i.viewType;
+    }
+    function _s(i, e) {
+      Re(e) || (e.viewType = i);
+    }
+    function Ws(i) {
+      return (
+        i.series[0].classBreaksRules?.breaksCount ?? P.classBreaks.breaksCount
+      );
+    }
+    function Ys(i, e) {
+      e.series[0].classBreaksRules !== void 0
+        ? (e.series[0].classBreaksRules.breaksCount =
+            i ?? P.classBreaks.breaksCount)
+        : (e.series[0].classBreaksRules = {
+            breaksCount: i ?? P.classBreaks.breaksCount,
+          });
+    }
+    function Qs(i) {
+      return i.series[0].classBreaksRules?.classificationMethod;
+    }
+    function zs(i, e) {
+      e.series[0].classBreaksRules !== void 0
+        ? (e.series[0].classBreaksRules.classificationMethod = i)
+        : (e.series[0].classBreaksRules = { classificationMethod: i }),
+        (e.series[0].classBreaksRules.breaksCount =
+          e.series[0].classBreaksRules.breaksCount ??
+          P.classBreaks.breaksCount);
+    }
+    function Hs(i, e) {
+      e.firstDayOfWeek = i;
+    }
+    function Js(i) {
+      return i.firstDayOfWeek;
+    }
+    function _(i) {
+      let {
+          seriesIndex: e,
+          xAxisField: s,
+          aggregationType: r,
+          config: a,
+          layerInfo: t,
+          commonStrings: n,
+        } = i,
+        l = E(t?.layer).idField,
+        o,
+        u = a.series[e ?? 0],
+        F = !1,
+        y = !1,
+        p = !1;
+      if (u === void 0) {
+        let g = a.series;
+        (F = g.slice(0, e).every((S) => b(S))),
+          (y = g.slice(0, e).every((S) => B(S))),
+          (p = g.slice(0, e).every((S) => ye(S)));
+      } else (F = b(u)), (y = B(u)), (p = ye(u));
+      F
+        ? (o = Me({ commonStrings: n, seriesIndex: e, objectIDField: l }))
+        : y
+        ? (o = Le({ commonStrings: n, seriesIndex: e, objectIDField: l }))
+        : p
+        ? (o = we(n, l))
+        : (o = Oe({ seriesIndex: e, objectIDField: l, commonStrings: n }));
+      let f = a.series[0]?.dataLabels,
+        d = {
+          ...o,
+          x: s,
+          y: "",
+          dataLabels: {
+            ...o.dataLabels,
+            type: o.dataLabels?.type ?? L.Text,
+            content: { ...o.dataLabels?.content, ...f?.content, type: ve.TS },
+            visible: f?.visible ?? !1,
+          },
+        };
+      if (
+        ((d.query = { groupByFieldsForStatistics: [s] }),
+        r !== C.NoAggregation && l !== void 0)
+      ) {
+        let g = `${r}_${l}_0`.toUpperCase();
+        (d.y = g),
+          (d.query.outStatistics = [
+            { statisticType: r, onStatisticField: l, outStatisticFieldName: g },
+          ]);
+      }
+      if (I(a.series[0]) && I(d)) {
+        let g;
+        if (
+          (a?.series?.[0] !== void 0 && (g = U(a.series)),
+          g !== O.BarAndLineNoAggregation &&
+            g !== O.BarAndLineSplitByNoAggregation)
+        ) {
+          let S = mi(a);
+          S === Y.Quarter && (S = Y.Month),
+            (d.temporalBinning = { ...a.series[0]?.temporalBinning, unit: S });
+        }
+      }
+      return ie(d);
+    }
+    function G(i, e, s) {
+      let { layerFieldsInfo: r } = e,
+        { idField: a, isTraditionalTypeOID: t } = E(e.layer),
+        n = $(i),
+        l = Se(i),
+        o = ri(i),
+        u = Z(i),
+        F = t && (l.length === 0 || l.includes(a)),
+        y = Ne(o, s),
+        p = F ? "" : l.map((c) => N(r ?? [], c)).join(", "),
+        f = N(r ?? [], n),
+        d = N(r ?? [], u),
+        g = i.series.some((c) => k(c)),
+        S = g ? "category" : "xAxisField",
+        h = f,
+        x = "";
+      if (pe({ fieldName: n, numericFields: l, fieldList: r }))
+        x = R(s.titleLabels.aggrTypeOfAggrFields, {
+          aggregationType: y,
+          aggregationFields: p,
+        });
+      else if (o === C.NoAggregation) {
+        let c = F ? a : p;
+        if (u === "") {
+          let q = g ? "aggrTypeCategory" : "aggrTypeXAxisField";
+          x = R(s.titleLabels[q], { aggregationType: c, [S]: h });
+        } else {
+          let q = g
+            ? "aggrTypeCategoryBySplitBy"
+            : "aggrTypeXAxisFieldBySplitBy";
+          x = R(s.titleLabels[q], {
+            aggregationType: c,
+            [S]: h,
+            splitByField: d,
+          });
+        }
+      } else if (o === C.Count)
+        if (u === "") {
+          let c = g ? "aggrTypeCategory" : "aggrTypeXAxisField";
+          x = R(s.titleLabels[c], { aggregationType: y, [S]: h });
+        } else {
+          let c = g
+            ? "aggrTypeCategoryBySplitBy"
+            : "aggrTypeXAxisFieldBySplitBy";
+          x = R(s.titleLabels[c], {
+            aggregationType: y,
+            [S]: h,
+            splitByField: d,
+          });
+        }
+      else if (u !== "") {
+        let c = g
+          ? "aggrTypeOfAggrFieldByCategoryBySplitByField"
+          : "aggrTypeOfAggrFieldByXAxisFieldBySplitByField";
+        x = R(s.titleLabels[c], {
+          aggregationType: y,
+          aggregationField: p,
+          [S]: h,
+          splitByField: d,
+        });
+      } else if (l.length > 0) {
+        let c = g
+          ? "aggrTypeOfAggrFieldsByCategory"
+          : "aggrTypeOfAggrFieldsByXAxisField";
+        x = R(s.titleLabels[c], {
+          aggregationType: y,
+          aggregationFields: p,
+          [S]: h,
+        });
+      }
+      return x;
+    }
+    var ai = (i) =>
+        le({ where: i.query?.where, normalize: !1, escape: !1 }) ?? "",
+      ri = (i) =>
+        i?.series?.[0]?.query?.outStatistics?.[0]?.statisticType ??
+        C.NoAggregation,
+      Z = xe(
+        (i) => {
+          let e = i?.series?.[0]?.query?.where?.split("=")[0].trim() ?? "";
+          return Ye(i?.series?.[0]?.query?.where) ? "" : e;
+        },
+        (i) => i?.series?.[0]?.query?.where
+      ),
+      Se = (i) => {
+        let e = [];
+        if (Z(i) === "")
+          e =
+            i?.series
+              .map((s) => {
+                let r =
+                  s.query?.outStatistics?.map((a) => a.onStatisticField) ?? [];
+                return r?.length > 0 ? r : s.y;
+              })
+              .flat() ?? [];
+        else {
+          let s = i?.series?.[0],
+            r =
+              s?.query?.outStatistics?.[0]?.onStatisticField ??
+              [s?.y].flat()[0];
+          e = r !== void 0 ? [r] : [];
+        }
+        return [...new Set(e.filter((s) => s !== ""))];
+      };
+    function bi(i) {
+      let { numericFields: e, aggregationType: s, config: r, layerInfo: a } = i,
+        t = !1;
+      s === C.Count
+        ? (t = !0)
+        : s === C.NoAggregation &&
+          (t = e.every((o) => {
+            let u = a.layerFieldsInfo.find((F) => F.name === o);
+            return u !== void 0 ? re(u) : !1;
+          })),
+        de(r, 1, t);
+      let n = r.series.some((o) => b(o)),
+        l = r.series.some((o) => B(o));
+      if (n || l) {
+        let o = $(r),
+          u = a.layerFieldsInfo.find((y) => y.name === o),
+          F = u !== void 0 && re(u);
+        de(r, 0, F);
+      }
+    }
+    var fe = (i) => {
+      let e;
+      if (Q(i)) {
+        let s = i.orderOptions?.data?.orderByX ?? [""],
+          r = i.orderOptions?.data?.orderByY ?? [""],
+          a =
+            i.axes?.[0]?.valueFormat?.type === "category"
+              ? v.Category
+              : v.YValue,
+          t =
+            i.axes?.[1]?.valueFormat?.type === "category"
+              ? v.Category
+              : v.YValue;
+        e = [me(s, a), me(r, t)];
+      } else {
+        let s = i.orderOptions?.data?.orderType ?? v.Category,
+          r =
+            i.orderOptions?.data && "orderBy" in i.orderOptions.data
+              ? i.orderOptions.data.orderBy
+              : he.Ascending;
+        e = [ii(r, s)];
+      }
+      return e;
+    };
+    function Bi(i) {
+      let {
+          xAxisField: e,
+          numericFields: s,
+          aggregationType: r,
+          config: a,
+          layerInfo: t,
+          commonStrings: n,
+        } = i,
+        { layerFieldsInfo: l } = t,
+        o = !1,
+        u = _({
+          config: a,
+          xAxisField: e,
+          aggregationType: r,
+          layerInfo: t,
+          seriesIndex: 0,
+          commonStrings: n,
+        }),
+        F = H({
+          config: a,
+          xAxisField: e,
+          numericFields: s,
+          aggregationType: r,
+          layer: t.layer,
+          fieldList: l,
+        }).name,
+        y = {
+          ...u,
+          id: `series_${Date.now()}`,
+          name: n.axisLabels.values,
+          x: D,
+          y: F,
+        },
+        p = [];
+      for (let d of s)
+        p.push({
+          onStatisticField: d,
+          outStatisticFieldName: `${d}_0`.toUpperCase(),
+          statisticType: r,
+        });
+      y.query = { outStatistics: p };
+      let f = a.series[0];
+      return (
+        f !== void 0 &&
+          ((y.id = f.id),
+          ((b(y) && b(f)) || (B(y) && B(f))) && W(y, f),
+          a.colorMatch ||
+            (k(f) && k(y)
+              ? (y.fillSymbol = f.fillSymbol)
+              : ((b(y) && b(f)) || (B(y) && B(f))) &&
+                ((y.lineSymbol = f.lineSymbol),
+                (y.markerSymbol = f.markerSymbol)),
+            (o = !0)),
+          (y.id = f.id),
+          f.name !== u.name && (y.name = f.name)),
+        a.series.length === 1 &&
+          ((b(y) || B(y)) && W(y, a.series[0]),
+          a.colorMatch ||
+            (k(y)
+              ? (y.fillSymbol = a.series[0].fillSymbol)
+              : (b(y) || B(y)) &&
+                ((y.lineSymbol = a.series[0].lineSymbol),
+                (y.markerSymbol = a.series[0].markerSymbol)),
+            (o = !0))),
+        (a.colorMatch = !o),
+        [y]
+      );
+    }
+    function ni(i) {
+      let {
+          xAxisField: e,
+          numericFields: s,
+          aggregationType: r,
+          config: a,
+          layerInfo: t,
+          commonStrings: n,
+        } = i,
+        { layerFieldsInfo: l } = t,
+        o = E(t.layer).idField,
+        u = [],
+        F = !1;
+      for (let g = 0; g < s.length; g += 1) {
+        let S = _({
+            config: a,
+            xAxisField: e,
+            aggregationType: r,
+            layerInfo: t,
+            seriesIndex: g,
+            commonStrings: n,
+          }),
+          h = H({
+            config: a,
+            xAxisField: e,
+            numericFields: s,
+            aggregationType: r,
+            layer: t.layer,
+            numericFieldIndex: g,
+            fieldList: l,
+          }).name,
+          x = s[g],
+          c = { ...S, query: { ...S.query } };
+        s && x !== o && (c = { ...c, id: x, name: N(l, x) });
+        let q = x;
+        c.query !== void 0 &&
+          (r !== C.NoAggregation
+            ? ((q = h),
+              (c.query.outStatistics = [
+                {
+                  ...(S.query?.outStatistics?.[0] ?? {}),
+                  onStatisticField: x,
+                  outStatisticFieldName: h,
+                  statisticType: r,
+                },
+              ]))
+            : delete c.query.outStatistics),
+          (c.y = q);
+        let m = a.series.find(
+          (w) =>
+            (w.query?.outStatistics?.[0]?.onStatisticField === x &&
+              w.query.where === void 0) ||
+            (w.query?.outStatistics === void 0 && (w.y === x || w.x === x))
+        );
+        if (m !== void 0 && typeof m.y == "string" && m.y.trim() !== "") {
+          ((b(c) && b(m)) || (B(c) && B(m))) && W(c, m),
+            a.colorMatch ||
+              (k(c) && k(m)
+                ? (c.fillSymbol = m.fillSymbol)
+                : ((b(c) && b(m)) || (B(c) && B(m))) &&
+                  ((c.lineSymbol = m.lineSymbol),
+                  (c.markerSymbol = m.markerSymbol)),
+              (F = !0));
+          let w = _({
+            config: a,
+            xAxisField: e,
+            aggregationType: r,
+            layerInfo: t,
+            seriesIndex: g,
+            commonStrings: n,
+          });
+          (c.id = m.id),
+            m.id !== w.id &&
+              m.name !== w.name &&
+              ((c.id = m.id), (c.name = m.name)),
+            c.type === L.HeatSeries &&
+              m.type === L.HeatSeries &&
+              ((c.y = m.y), (c.heatRulesType = m.heatRulesType));
+        }
+        u.push(c);
+      }
+      let y = u.filter((g) => k(g)),
+        p = u.filter((g) => b(g) || B(g)),
+        f = a.series.filter((g) => k(g)),
+        d = a.series.filter((g) => b(g) || B(g));
+      return (
+        f.length === 1 &&
+          y.length === 1 &&
+          !a.colorMatch &&
+          (k(f[0]) && k(y[0]) && (y[0].fillSymbol = f[0].fillSymbol), (F = !0)),
+        d.length === 1 &&
+          p.length === 1 &&
+          (((b(d[0]) && b(p[0])) || (B(d[0]) && B(p[0]))) && W(p[0], d[0]),
+          a.colorMatch ||
+            (((b(d[0]) && b(p[0])) || (B(d[0]) && B(p[0]))) &&
+              ((p[0].lineSymbol = d[0].lineSymbol),
+              (p[0].markerSymbol = d[0].markerSymbol)),
+            (F = !0))),
+        (a.colorMatch = !F),
+        u
+      );
+    }
+    async function hi(i) {
+      let {
+          splitByField: e,
+          xAxisField: s,
+          numericFields: r,
+          aggregationType: a,
+          config: t,
+          layerInfo: n,
+          commonStrings: l,
+        } = i,
+        { layer: o, layerFieldsInfo: u } = n,
+        { fetchNullValues: F } = t?.series?.[0]?.query ?? {},
+        y = s !== D ? s : void 0,
+        {
+          categoriesArray: p,
+          splitByFieldType: f,
+          numericalField: d,
+        } = await Ke({
+          config: t,
+          layer: o,
+          layerFieldsInfo: u,
+          xAxisField: y,
+          aggregationFields: r,
+          splitByField: e,
+          fetchNullValues: F,
+        }),
+        g = [],
+        S = !1;
+      if (p.length === 0) {
+        g = ni({
+          xAxisField: s,
+          numericFields: r,
+          aggregationType: a,
+          config: t,
+          layerInfo: n,
+          commonStrings: l,
+        });
+        for (let h of g) h.query && (h.query.where = `${e}=''`);
+      } else
+        for (let h = 0; h < p.length; h += 1) {
+          let x = p[h],
+            c = H({
+              config: t,
+              xAxisField: s,
+              numericFields: r,
+              aggregationType: a,
+              layer: n.layer,
+              seriesIndex: h,
+              splitByField: e,
+              fieldList: u,
+            }).name,
+            q = _({
+              config: t,
+              xAxisField: s,
+              aggregationType: a,
+              layerInfo: n,
+              seriesIndex: h,
+              commonStrings: l,
+            }),
+            m = {
+              fieldName: e,
+              fieldValueToMatch: x ?? "",
+              subtypeInfo: ne(n.layer),
+              fieldList: n.layerFieldsInfo,
+            },
+            w = oe(m),
+            K = `${x}`,
+            T = {
+              ...q,
+              id: K,
+              name: w ?? K,
+              y: c,
+              query: {
+                ...q.query,
+                where: `${e}=${f === se.String && x !== null ? `'${x}'` : x}`,
+                outStatistics:
+                  a !== C.NoAggregation
+                    ? [
+                        {
+                          ...(q.query?.outStatistics?.[0] ?? {}),
+                          onStatisticField: d,
+                          outStatisticFieldName: c,
+                          statisticType: a,
+                        },
+                      ]
+                    : void 0,
+              },
+            };
+          a === C.NoAggregation &&
+            (T.query !== void 0 &&
+              (delete T.query.outStatistics,
+              delete T.query.groupByFieldsForStatistics),
+            (T.y = d));
+          let M = t.series.find(
+            (ee) => String(ai(ee)).trim().replace(/'/gu, "") === K
+          );
+          M !== void 0 &&
+            (((b(T) && b(M)) || (B(T) && B(M))) && W(T, M),
+            t.colorMatch ||
+              (k(T) && k(M)
+                ? (T.fillSymbol = M.fillSymbol)
+                : ((b(T) && b(M)) || (B(T) && B(M))) &&
+                  ((T.lineSymbol = M.lineSymbol),
+                  (T.markerSymbol = M.markerSymbol)),
+              (S = !0)),
+            (T.id = M.id),
+            (T.name = M.name)),
+            T.query &&
+              (T.query.fetchNullValues = t.series.some(
+                (ee) => ee.query?.fetchNullValues
+              )),
+            g.push(T);
+        }
+      return (t.colorMatch = !S), g;
+    }
+    var Zs = async (i) => {
+        let {
+            xAxisField: e,
+            splitByField: s,
+            numericFields: r,
+            aggregationType: a,
+            config: t,
+            layerInfo: n,
+            commonStrings: l,
+          } = i,
+          { layerFieldsInfo: o } = n ?? {},
+          u = ti(t),
+          F = $(t),
+          y = Fe(t, n, l),
+          p = Ti(t, n, l),
+          f = Ci(t, n),
+          d = ue(t),
+          g = t.series.some((m) => k(m)),
+          S = He(t.series),
+          h = Je(t.series),
+          x = Q(t),
+          c = {};
+        x &&
+          ((c.classBreaksRules = t.series[0]?.classBreaksRules),
+          (c.xTemporalBinning = t.series[0]?.xTemporalBinning),
+          (c.yTemporalBinning = t.series[0]?.yTemporalBinning),
+          (c.emptyCells = t.series[0]?.emptyCells),
+          (c.nullPolicy = t.nullPolicy));
+        let q = !1;
+        if (o !== void 0) {
+          let m = Xe(o);
+          !m.includes(F) && m.includes(e)
+            ? ((d = qe()), (q = !0))
+            : m.includes(F) &&
+              !m.includes(e) &&
+              (g ? (d = te()) : (d = ke()), (q = !0)),
+            o.find((w) => w.name === e)?.type === se.String && (d = te()),
+            d !== void 0 && Ge(t, l, d);
+        }
+        if (
+          (u === 0 &&
+            (t.series = [
+              _({
+                config: t,
+                xAxisField: e,
+                aggregationType: a,
+                layerInfo: n,
+                commonStrings: l,
+              }),
+            ]),
+          t.series.forEach((m) => {
+            (m.x = e),
+              m.query !== void 0 && (m.query.groupByFieldsForStatistics = [e]);
+          }),
+          s === "" || r.length > 1
+            ? pe({ fieldName: e, numericFields: r, fieldList: o })
+              ? (t.series = Bi({
+                  config: t,
+                  layerInfo: n,
+                  xAxisField: e,
+                  numericFields: r,
+                  aggregationType: a,
+                  commonStrings: l,
+                }))
+              : (t.series = ni({
+                  config: t,
+                  layerInfo: n,
+                  xAxisField: e,
+                  numericFields: r,
+                  aggregationType: a,
+                  commonStrings: l,
+                }))
+            : (await Promise.resolve(),
+              (t.series = await hi({
+                config: t,
+                layerInfo: n,
+                splitByField: s,
+                xAxisField: e,
+                numericFields: r,
+                aggregationType: a,
+                commonStrings: l,
+              }))),
+          f && t.series[0].type !== L.HeatSeries)
+        ) {
+          let m = N(o, e);
+          V(t, 0, m);
+        }
+        if (p && t.series[0].type !== L.HeatSeries) {
+          let m = ge({
+            config: t,
+            layerInfo: n,
+            commonStrings: l,
+            numericFields: r,
+            aggregationType: a,
+          });
+          V(t, 1, m);
+        }
+        if (
+          (t.title && y && (t.title.content.text = G(t, n, l)),
+          A({ config: t, value: null, axisIndex: 1, isMax: !1 }),
+          A({ config: t, value: null, axisIndex: 1, isMax: !0 }),
+          bi({ numericFields: r, aggregationType: a, config: t, layerInfo: n }),
+          (S || h) &&
+            (A({ config: t, value: null, axisIndex: 0, isMax: !1 }),
+            A({ config: t, value: null, axisIndex: 0, isMax: !0 }),
+            q))
+        ) {
+          let m = d?.type === L.DateAxisFormat ? j.Null : j.Interpolate;
+          fi(m, t);
+        }
+        x &&
+          ((t.series[0].classBreaksRules = c.classBreaksRules),
+          (t.series[0].xTemporalBinning = c.xTemporalBinning),
+          (t.series[0].yTemporalBinning = c.yTemporalBinning),
+          (t.series[0].emptyCells = c.emptyCells),
+          (t.nullPolicy = c.nullPolicy));
+      },
+      W = (i, e) => {
+        (i.markerVisible = e.markerVisible),
+          (i.lineSmoothed = e.lineSmoothed),
+          (i.showArea = e.showArea),
+          (i.areaColor = e.areaColor),
+          (i.stackNegativeValuesToBaseline = e.stackNegativeValuesToBaseline),
+          e.lineSymbol &&
+            (i.lineSymbol = { ...e.lineSymbol, color: i.lineSymbol?.color }),
+          e.markerSymbol &&
+            (i.markerSymbol = {
+              ...e.markerSymbol,
+              color: i.markerSymbol?.color,
+            });
+      },
+      Gs = (i) => {
+        let { config: e, seriesIndex: s, layerInfo: r, commonStrings: a } = i,
+          t = e.series?.[s],
+          n = Z(e),
+          l;
+        if (U(e.series) === O.BarAndLineFromFields) l = a.axisLabels.values;
+        else if (be(n)) {
+          let o = t.query?.outStatistics?.[0]?.onStatisticField;
+          o !== void 0 &&
+            o !== E(r.layer).idField &&
+            (l = N(r.layerFieldsInfo, o));
+        } else {
+          let o = String(ai(t)).trim().replace(/'/gu, ""),
+            u = {
+              fieldName: Z(e),
+              fieldValueToMatch: o ?? "",
+              subtypeInfo: ne(r.layer),
+              fieldList: r.layerFieldsInfo,
+            };
+          l = oe(u) ?? o;
+        }
+        return l ?? t.id;
+      },
+      Ks = (i, e) => {
+        if (Q(e)) Fi(i, e);
+        else {
+          e.orderOptions ??= {};
+          let s = e.orderOptions?.data?.orderType;
+          fe(e)[0] === z.customSort &&
+            s === v.Category &&
+            (e.orderOptions.data = { orderType: v.Category, orderBy: [...i] });
+        }
+      },
+      et = async (i, e) => {
+        let s = $(i),
+          r = ue(i)?.type,
+          a = Se(i),
+          t = U(i.series),
+          n = [];
+        return (
+          r === L.CategoryAxisFormat &&
+            (t === O.BarAndLineFromFields || s === D
+              ? (n = a.map((l) => N(e?.layerFieldsInfo, l)))
+              : s.trim() !== "" &&
+                s !== D &&
+                e !== void 0 &&
+                (n = await ei({ layerInfo: e, config: i, category: s }))),
+          n
+        );
+      };
+    function Fe(i, e, s) {
+      let r = G(i, e, s),
+        a = si(i),
+        t = X(i);
+      return r === a || t;
+    }
+    function Ti(i, e, s) {
+      let r = ge({
+          config: i,
+          layerInfo: e,
+          commonStrings: s,
+          numericFields: Se(i),
+          aggregationType: ri(i),
+        }),
+        a = J(1, i),
+        t = X(i);
+      return r === a || t;
+    }
+    function Ci(i, e) {
+      let s = N(e.layerFieldsInfo, $(i)),
+        r = J(0, i),
+        a = X(i);
+      return s === r || a;
+    }
+    function it(i) {
+      return I(i.series[0]) ? i.series[0].binTemporalData ?? !0 : !1;
+    }
+    function st(i, e) {
+      e?.series.forEach((s) => {
+        (s?.type === L.BarSeries || s?.type === L.LineSeries) &&
+          ((s.binTemporalData = i),
+          i
+            ? (s.temporalBinning = {
+                unit: Y.Day,
+                size: 0,
+                timeAggregationType: Te.Start,
+                trimIncompleteTimeInterval: !0,
+                nullPolicy: j.Null,
+              })
+            : delete s.temporalBinning);
+      });
+    }
+    return {
+      a: es,
+      b: is,
+      c: ss,
+      d: oi,
+      e: ts,
+      f: as,
+      g: rs,
+      h: mi,
+      i: ns,
+      j: os,
+      k: ls,
+      l: pi,
+      m: fi,
+      n: cs,
+      o: ys,
+      p: gs,
+      q: us,
+      r: ds,
+      s: ms,
+      t: ps,
+      u: fs,
+      v: Ss,
+      w: Fs,
+      x: xs,
+      y: Si,
+      z: bs,
+      A: Bs,
+      B: hs,
+      C: Ts,
+      D: Cs,
+      E: vs,
+      F: Is,
+      G: As,
+      H: qs,
+      I: ks,
+      J: ws,
+      K: Ms,
+      L: Ls,
+      M: Os,
+      N: Ns,
+      O: xi,
+      P: Rs,
+      Q: Vs,
+      R: $s,
+      S: js,
+      T: Ds,
+      U: Ps,
+      V: Es,
+      W: Us,
+      X: Xs,
+      Y: _s,
+      Z: Ws,
+      _: Ys,
+      $: Qs,
+      aa: zs,
+      ba: Hs,
+      ca: Js,
+      da: G,
+      ea: ri,
+      fa: Z,
+      ga: Se,
+      ha: fe,
+      ia: Zs,
+      ja: Gs,
+      ka: Ks,
+      la: et,
+      ma: it,
+      na: st,
+    };
+  },
+  "intl",
+  "geometry/support/jsonUtils",
+  "rest/support/AttributeBinsQuery",
+  "rest/support/StatisticDefinition",
+  "time/TimeExtent",
+  "core/promiseUtils",
+  "request",
+  "Graphic",
+  "renderers/support/jsonUtils",
+  "symbols/support/symbolUtils",
+  "layers/support/FeatureFilter",
+  "smartMapping/statistics/histogram",
+  "smartMapping/statistics/summaryStatistics",
+  "core/sql",
+  "AttributeBinsGraphic",
+  a,
+  c,
+  d,
+  e,
+  f,
+  g
+);