@geoscene/charts-components 5.0.19

package/dist/cdn/ISWZQ6CS.js

@@ -0,0 +1,1163 @@
+/* COPYRIGHT  - https://js.geoscene.cn/5.0/LICENSE.txt */
+import { a as se, b as ne, g as ae } from "./UG7LOBJE.js";
+import a from "./A7YNU2NS.js";
+import { g as n, m as h } from "./4B3QBH5T.js";
+import { f as N, g as C } from "./XLDY6CTA.js";
+import {
+  a as c,
+  b as x,
+  d as G,
+  h as v,
+  k as S,
+  p as L,
+  q as k,
+  v as y,
+  y as T,
+} from "./NKG4FLLR.js";
+import { G as _ } from "./KRZ433BT.js";
+export default $geoscene.t(
+  ([
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    {
+      $c: Z,
+      D: W,
+      Dc: Q,
+      E: z,
+      Id: oe,
+      Jc: X,
+      Ka: R,
+      Kb: D,
+      Kc: O,
+      Mc: J,
+      Nc: K,
+      Qb: b,
+      Vc: B,
+      Xc: q,
+      Ya: Y,
+      Za: M,
+      _c: U,
+      a: j,
+      aa: H,
+      ad: ee,
+      c: V,
+      d: A,
+      dd: te,
+      ed: ie,
+      gd: F,
+      id: re,
+      va: $,
+      yb: l,
+    },
+  ]) => {
+    var I = ((i) => (
+      (i.NONE = "none"),
+      (i.ROTATE = "rotate"),
+      (i.STAGGER = "stagger"),
+      (i.WRAP = "wrap"),
+      i
+    ))(I || {});
+    function De(i) {
+      let { configToUpdate: e, chartContainer: r, layer: t } = i,
+        o = n(e);
+      if (
+        t?.capabilities?.queryAttributeBins?.supportsFirstDayOfWeek === !0 &&
+        (!("firstDayOfWeek" in e) ||
+          e.firstDayOfWeek === void 0 ||
+          e.firstDayOfWeek === null)
+      ) {
+        let { lang: s } = C(r ?? document.documentElement);
+        try {
+          o.firstDayOfWeek = j
+            .local()
+            .setLocale(s.replaceAll("_", "-"))
+            .startOf("week", { useLocaleWeeks: !0 }).weekday;
+        } catch {}
+      }
+      return o;
+    }
+    function qe(i) {
+      let e = n(i);
+      return (
+        h(i.axes) ||
+          (e.axes = i.axes?.map((r) => {
+            let t = r;
+            return (
+              delete t.calculateAutomaticMaximum,
+              delete t.calculateAutomaticMinimum,
+              t.title?.content.font?.style !== void 0 &&
+                (t.title.content.font.style =
+                  t.title.content.font.style.toLowerCase()),
+              t
+            );
+          })),
+        e
+      );
+    }
+    function Ue(i) {
+      let e = n(i);
+      return (
+        h(i.series) ||
+          (e.series = i.series.map((r, t) => {
+            let o = r;
+            r.id === void 0 && (o.id = `Series ${Date.now()}-${t}`);
+            let s = T(i.series, t);
+            return (
+              (s === c.BarSeries ||
+                s === c.LineSeries ||
+                s === c.RadarSeries) &&
+                o.query?.outStatistics?.[0]?.statisticType === "median" &&
+                (o.query.outStatistics[0].statisticType =
+                  x.ContinuousPercentile),
+              s === c.BarSeries &&
+                o.multipleBarType !== void 0 &&
+                ((o.stackedType = o.multipleBarType), delete o.multipleBarType),
+              s === c.PieSeries &&
+                o.sliceGrouping !== void 0 &&
+                ((o.sliceGrouping.sliceId = W.defaultGroupOfSlicesId),
+                o.sliceGrouping.groupName !== void 0 &&
+                  ((o.sliceGrouping = {
+                    ...o.sliceGrouping,
+                    label: o.sliceGrouping.groupName,
+                  }),
+                  delete o.sliceGrouping.groupName),
+                o.sliceGrouping.groupSliceSymbol !== void 0 &&
+                  ((o.sliceGrouping = {
+                    ...o.sliceGrouping,
+                    fillSymbol: o.sliceGrouping.groupSliceSymbol,
+                  }),
+                  delete o.sliceGrouping.groupSliceSymbol)),
+              o
+            );
+          })),
+        e
+      );
+    }
+    async function de(i, e) {
+      let r = [];
+      return (
+        await Promise.all(
+          i.map(async (t) => {
+            if (!D(t)) {
+              let o = b(t, !1);
+              if (o.fieldToSort !== void 0) {
+                let s = await B({
+                  queryObject: e,
+                  fieldToMatch: o.fieldToSort,
+                });
+                s !== void 0 &&
+                  r.push(o.orderBy === void 0 ? s : `${s} ${o.orderBy}`);
+              }
+            }
+          })
+        ),
+        r
+      );
+    }
+    async function Ie(i, e) {
+      let r = { ...i },
+        t = e;
+      if (!t) {
+        let o = ae(i) ? i.iLayer : i.dataSource?.layer;
+        o && (t = await O(o));
+      }
+      if (t) {
+        let o = F(r.series),
+          s = T(r.series),
+          p =
+            (r.series && r.series.length > 0 && r.series[0].x.trim() === "") ||
+            (s === c.GaugeSeries && !oe(i)) ||
+            o === l.PieFromFields ||
+            o === l.BarAndLineFromFields ||
+            o === l.BoxPlotMonoField ||
+            o === l.BoxPlotMonoFieldAndSplitBy ||
+            o === l.BoxPlotMultiFields ||
+            o === l.BoxPlotMultiFieldsAndSplitBy,
+          u =
+            s === c.ScatterSeries ||
+            o === l.BarAndLineNoAggregation ||
+            o === l.BarAndLineSplitByNoAggregation ||
+            o === l.BoxPlotMonoField ||
+            o === l.BoxPlotMonoFieldAndSplitBy ||
+            o === l.BoxPlotMonoFieldAndCategory ||
+            o === l.BoxPlotMonoFieldAndCategoryAndSplitBy ||
+            o === l.PieNoAggregation;
+        if (
+          ((r.series = await Promise.all(
+            i.series.map(async (d) => {
+              let a = { ...d };
+              if (
+                (p || (a.x = await B({ queryObject: t, fieldToMatch: d.x })),
+                "y" in a && u)
+              ) {
+                let m = a.y;
+                if (Array.isArray(m)) {
+                  let f = await q({ fieldsList: m, queryObject: t });
+                  f !== void 0 && "y" in a && (a.y = f);
+                } else
+                  "y" in a &&
+                    typeof m == "string" &&
+                    (a.y = await B({ queryObject: t, fieldToMatch: m }));
+              }
+              if (d.query !== void 0) {
+                let {
+                  where: m,
+                  groupByFieldsForStatistics: f,
+                  outStatistics: g,
+                } = d.query;
+                if (
+                  ((f = await q({ fieldsList: f, queryObject: t })),
+                  g !== void 0 &&
+                    (g = await Promise.all(
+                      g.map(async (P) => {
+                        let w = { ...P };
+                        return (
+                          (w.onStatisticField = await B({
+                            queryObject: t,
+                            fieldToMatch: P.onStatisticField,
+                          })),
+                          w
+                        );
+                      })
+                    )),
+                  m !== void 0 && o === l.BarAndLineSplitBy)
+                ) {
+                  let P = te(d.query?.where),
+                    w = ie({
+                      where: d.query?.where,
+                      normalize: !1,
+                      escape: !1,
+                    });
+                  m = `${await B({ queryObject: t, fieldToMatch: P })}=${w}`;
+                }
+                a.query !== void 0 &&
+                  (m !== void 0 && (a.query.where = m),
+                  f !== void 0 && (a.query.groupByFieldsForStatistics = f),
+                  g !== void 0 && (a.query.outStatistics = g));
+              }
+              return a;
+            })
+          )),
+          r.series[0]?.query !== void 0)
+        ) {
+          let d = r.series[0].query,
+            { orderByFields: a } = d;
+          a !== void 0 &&
+            a.length > 0 &&
+            ((a = await de(a, t)),
+            a.length > 0 &&
+              d.orderByFields !== void 0 &&
+              (r.series[0].query.orderByFields = a));
+        }
+        if (r.orderOptions?.orderByFields !== void 0) {
+          let { orderByFields: d } = r.orderOptions;
+          d !== void 0 &&
+            d.length > 0 &&
+            ((d = await de(d, t)),
+            d.length > 0 && (r.orderOptions.orderByFields = d));
+        }
+        if (s === c.GaugeSeries && i.axes?.[0] !== void 0) {
+          let { minimumFromField: d, maximumFromField: a } = i.axes[0];
+          if (d !== void 0) {
+            let m = typeof d == "string" ? d : d.onStatisticField,
+              f = await B({ queryObject: t, fieldToMatch: m }),
+              g = d;
+            typeof i.axes[0].minimumFromField == "string"
+              ? (g = f)
+              : typeof d == "object" && (g = { ...d, onStatisticField: f }),
+              (i.axes[0].minimumFromField = g);
+          }
+          if (a !== void 0) {
+            let m = typeof a == "string" ? a : a.onStatisticField,
+              f = await B({ queryObject: t, fieldToMatch: m }),
+              g = a;
+            typeof i.axes[0].maximumFromField == "string"
+              ? (g = f)
+              : typeof a == "object" && (g = { ...a, onStatisticField: f }),
+              (i.axes[0].maximumFromField = g);
+          }
+        }
+      }
+      return r;
+    }
+    function Ee(i) {
+      let e = n(i);
+      if (!h(i.series) && T(i.series) === c.BoxPlotSeries) {
+        let r = e.series[0];
+        r &&
+          (r.showOutliers !== void 0 &&
+            (i.showOutliers === void 0 && (e.showOutliers = r.showOutliers),
+            delete r.showOutliers),
+          r.standardizeValues !== void 0 &&
+            (i.standardizeValues === void 0 &&
+              (e.standardizeValues = r.standardizeValues),
+            delete r.standardizeValues),
+          r.showMean !== void 0 &&
+            (i.showMean === void 0 && (e.showMean = r.showMean),
+            delete r.showMean));
+      }
+      return e;
+    }
+    function _e(i) {
+      let e = { orderType: y.Category, orderBy: v.Ascending },
+        r = i.query?.orderByFields?.[0];
+      if (r !== void 0) {
+        let { outStatisticFieldName: t, statisticType: o } =
+            i.query?.outStatistics?.[0] ?? {},
+          s = b(r);
+        t !== void 0 &&
+          s.fieldToSort === t &&
+          o !== void 0 &&
+          (o === x.Average || o === "mean"
+            ? (e.orderType = y.Mean)
+            : o === x.ContinuousPercentile && (e.orderType = y.Median)),
+          (e.orderBy = s.orderBy ?? v.Ascending);
+      }
+      return e;
+    }
+    function Ne(i) {
+      let e = !1,
+        r = Array.from(new Set(i.series.map((t) => t.type)));
+      return (
+        r.length === 2 &&
+          r.includes(c.BoxPlotSeries) &&
+          r.includes(c.LineSeries) &&
+          (e =
+            i.series.find((t) => t.type === c.LineSeries)?.query
+              ?.outStatistics?.[0] !== void 0),
+        e
+      );
+    }
+    function je(i) {
+      let e = n(i);
+      if (!h(e.series) && T(i.series) === c.BoxPlotSeries) {
+        if (e.orderOptions?.data === void 0) {
+          let r = _e(i.series[0]);
+          r.orderType !== void 0 &&
+            ((e.orderOptions ??= {}),
+            (e.orderOptions.data = {
+              orderType: r.orderType,
+              orderBy: r.orderBy,
+            }));
+        }
+        if (
+          ((e.series = i.series.map((r) => {
+            let t = r;
+            return (
+              h(t.x?.trim()) && (t.x = z), delete t.query?.orderByFields, t
+            );
+          })),
+          Ne(e))
+        ) {
+          e.showMean = !0;
+          let r = e.series.find((t) => t.type === c.BoxPlotSeries);
+          e.series.forEach((t) => {
+            t.type === c.LineSeries &&
+              (delete t.query?.groupByFieldsForStatistics,
+              delete t.query?.outStatistics,
+              delete t.query?.orderByFields,
+              r && (t.y = r.y));
+          });
+        }
+        e.series = i.series.map((r) => {
+          let t = r;
+          return delete t.query?.outStatistics, t;
+        });
+      }
+      return e;
+    }
+    function Ge(i) {
+      let e = n(i);
+      return (
+        e.legend !== void 0 &&
+          !Number.isFinite(e.legend.maxHeight) &&
+          (e.legend.maxHeight = Number.NaN),
+        e
+      );
+    }
+    function Ve(i) {
+      let e = n(i);
+      return (
+        "dataSource" in e &&
+          e.dataSource.layer &&
+          ((e.iLayer = e.dataSource.layer), delete e.dataSource),
+        e
+      );
+    }
+    function We(i) {
+      let e = n(i),
+        r = new Set(),
+        t = e.id ?? "";
+      return (
+        r.add(t),
+        e.series.forEach((o) => {
+          let s = o.id;
+          r.has(s) && ((s = `${s}_${Date.now()}`), (o.id = s)), r.add(s);
+        }),
+        e
+      );
+    }
+    async function ze(i) {
+      let { configToUpdate: e, layer: r, chartContainer: t } = i,
+        o = n(e);
+      if (((o = qe(o)), (o = Ue(o)), (o = await Ie(o, r)), M(o))) {
+        let s = Ee(o);
+        o = je(s);
+      }
+      return (
+        (o = Ge(o)),
+        (o = We(o)),
+        Y(o) && (o = De({ configToUpdate: o, chartContainer: t, layer: r })),
+        o
+      );
+    }
+    function He(i) {
+      let e = n(i);
+      return (
+        e?.orderOptions?.orderByFields !== void 0 &&
+          F(i.series) === l.PieFromFields &&
+          (e.orderOptions.orderByFields = i?.orderOptions?.orderByFields?.map(
+            (r) => {
+              let t = n(r);
+              return (
+                r !== void 0 &&
+                  r.includes("geoscene_charts_pie_category_from_fields_name") &&
+                  (t = r.replace(
+                    "geoscene_charts_pie_category_from_fields_name",
+                    A
+                  )),
+                t
+              );
+            }
+          )),
+        e
+      );
+    }
+    function $e(i) {
+      let e = n(i);
+      if (
+        !h(i.series) &&
+        e.axes?.[0] !== void 0 &&
+        T(i.series) === c.GaugeSeries &&
+        i.axes?.[0] !== void 0
+      ) {
+        let r = i.axes[0];
+        r.ticks !== void 0 &&
+          Object.hasOwn(r.ticks, "spacing") &&
+          delete r.ticks.spacing,
+          (e.axes[0] = r);
+      }
+      return e;
+    }
+    function Re(i) {
+      let e = n(i),
+        { extent: r } = e.series[0]?.query ?? {};
+      return (
+        r !== void 0 &&
+          ((e.dataFilters = { ...e.dataFilters, geometry: r }),
+          e.series.forEach((t) => {
+            "query" in t && "extent" in t.query && delete t.query.extent;
+          })),
+        e
+      );
+    }
+    function Ae(i) {
+      let e = n(i);
+      return (
+        h(i.series) ||
+          (se(i) &&
+            i.rotated === void 0 &&
+            (e.rotated = i.series[0].rotated ?? $()),
+          e.series.forEach((r) => {
+            r.rotated !== void 0 && delete r.rotated;
+          })),
+        e
+      );
+    }
+    function Ye(i) {
+      let e = n(i),
+        r = i.dataSource;
+      return (
+        "dataSource" in e &&
+          !h(r) &&
+          (r.type === "featureLayer" &&
+            e.dataSource !== void 0 &&
+            (e.dataSource.type = "layer"),
+          "featureLayer" in r &&
+            ((e.dataSource.layer = r.featureLayer),
+            delete e.dataSource.featureLayer)),
+        e
+      );
+    }
+    function Qe(i) {
+      let e = n(i);
+      if ("dataSource" in i) {
+        let r = i.dataSource;
+        if (r.filter !== void 0 && r.filter.trim() !== "") {
+          let t = X([r.filter, e.dataFilters?.where]);
+          (e.dataFilters = { ...e.dataFilters, where: t }),
+            delete e.dataSource.filter;
+        }
+      }
+      return e;
+    }
+    function Xe(i) {
+      return i !== "originalValue";
+    }
+    function Le(i) {
+      let e;
+      switch (i) {
+        case "mean":
+          e = y.Mean;
+          break;
+        case "median":
+          e = y.Median;
+          break;
+        case "category":
+          e = y.Category;
+          break;
+      }
+      return e;
+    }
+    function Je(i) {
+      let e = n(i);
+      if (!h(i.series) && T(i.series) === c.PieSeries) {
+        let r = e.series[0];
+        if (r) {
+          if (r.sortLabelsBy === "originalValue")
+            e.sortLabelsBy = r.sortLabelsBy;
+          else if (
+            r.sortLabelsBy !== void 0 &&
+            e.orderOptions?.data === void 0
+          ) {
+            let t = E(e);
+            t !== void 0 &&
+              ((e.orderOptions ??= {}), (e.orderOptions.data = t));
+          }
+          r.sortLabelsBy && delete r.sortLabelsBy;
+        }
+      }
+      return e;
+    }
+    function Ke(i) {
+      let e = n(i);
+      return (
+        h(i.series) ||
+          (ne(i) &&
+            i.stackedType === void 0 &&
+            (e.stackedType = i.series[0].stackedType ?? R()),
+          e.series.forEach((r) => {
+            "stackedType" in r && delete r.stackedType;
+          })),
+        e
+      );
+    }
+    function Ze(i) {
+      let e = n(i),
+        r = i.sortOptions?.sortSeriesBy;
+      return (
+        e.orderOptions === void 0 &&
+          typeof r == "string" &&
+          ((e.orderOptions ??= {}),
+          (e.orderOptions.series = {
+            orderBy: r === "DESC" ? v.Descending : v.Ascending,
+          })),
+        e
+      );
+    }
+    function et(i) {
+      let e = n(i);
+      return (
+        e.colorMatch === void 0 &&
+          e.series[0]?.colorType !== void 0 &&
+          (e.colorMatch = e.series[0]?.colorType === G.Match),
+        e.series.forEach((r) => {
+          r.colorType !== void 0 && delete r.colorType;
+        }),
+        e
+      );
+    }
+    function tt(i) {
+      let e = n(i);
+      if (e.sortDataBy !== void 0) {
+        if (e.orderOptions?.data === void 0) {
+          let r = i.sortDataBy,
+            t = Le(r?.sortType);
+          t &&
+            t !== y.MultiAxes &&
+            ((e.orderOptions ??= {}),
+            (e.orderOptions.data = {
+              orderType: t,
+              orderBy: r?.sortOrder ?? v.Ascending,
+            }));
+        }
+        delete e.sortDataBy;
+      }
+      return e;
+    }
+    function it(i) {
+      let e = n(i);
+      return (
+        e.axes?.forEach((r) => {
+          r !== void 0 &&
+            r.scrollbarVisible !== void 0 &&
+            r.scrollbar?.visible === void 0 &&
+            ((r.scrollbar = { ...r.scrollbar, visible: r.scrollbarVisible }),
+            delete r.scrollbarVisible);
+        }),
+        e
+      );
+    }
+    function rt(i) {
+      let e = n(i),
+        r = e.series[0]?.query?.orderByFields;
+      if (
+        r !== void 0 &&
+        r.length > 0 &&
+        e.orderOptions?.orderByFields === void 0
+      ) {
+        e.orderOptions ??= {};
+        let t = !0;
+        if (r.length === 1) {
+          let { fieldToSort: o, orderBy: s } = b(r[0]),
+            p;
+          o === i.series[0].x || o === A
+            ? (p = y.Category)
+            : "y" in i.series[0] && o === i.series[0].y && (p = y.YValue),
+            p &&
+              p !== y.MultiAxes &&
+              ((t = !1),
+              e.orderOptions.data === void 0 &&
+                (e.orderOptions.data = {
+                  orderType: p,
+                  orderBy:
+                    s?.toUpperCase() === "DESC" ? v.Descending : v.Ascending,
+                }));
+        }
+        t && (e.orderOptions.orderByFields = r);
+      }
+      return (
+        e.series.forEach((t) => {
+          delete t.query?.orderByFields;
+        }),
+        e
+      );
+    }
+    function E(i) {
+      let e,
+        r = i.orderOptions?.orderByFields?.[0];
+      if (i.series?.length > 0) {
+        let t = T(i.series),
+          o = F(i.series);
+        if (
+          (t !== c.PieSeries &&
+            o !== l.BarAndLineFromFields &&
+            (r = r ?? i.series[0].x),
+          r && !D(r))
+        ) {
+          let { fieldToSort: s, orderBy: p } = b(r),
+            u;
+          s === i.series[0].x || s === A
+            ? (u = y.Category)
+            : "y" in i.series[0] && s === i.series[0].y && (u = y.YValue),
+            u &&
+              u !== y.MultiAxes &&
+              (e = {
+                orderType: u,
+                orderBy:
+                  p?.toUpperCase() === "DESC" ? v.Descending : v.Ascending,
+              });
+        }
+      }
+      return e;
+    }
+    function ot(i) {
+      let e = n(i),
+        r = i,
+        t = i,
+        o = i,
+        s = i,
+        p = i;
+      if (e) {
+        if (
+          (e.orderOptions?.series === void 0 &&
+            r.sortOptions?.sortSeriesBy !== void 0 &&
+            ((e.orderOptions ??= {}),
+            (e.orderOptions.series = {
+              preferLabel: Xe(
+                t.sortLabelsBy ?? r.sortOptions.sortSeriesBy.sortType
+              ),
+              orderBy: r.sortOptions.sortSeriesBy.sortOrder ?? v.Ascending,
+            })),
+          t.sortLabelsBy === "originalValue" ||
+            s.orderOptions?.data?.preferDataLabel === !1 ||
+            p.orderOptions?.data?.preferLabel === !1)
+        )
+          e.orderOptions?.data && delete e.orderOptions.data;
+        else if (e.orderOptions?.data === void 0)
+          if (T(e.series) === c.BoxPlotSeries) {
+            if (t.sortLabelsBy || o.sortOptions?.sortDataBy !== void 0) {
+              let u = Le(o.sortOptions?.sortDataBy?.sortType);
+              u &&
+                u !== y.MultiAxes &&
+                ((e.orderOptions ??= {}),
+                (e.orderOptions.data = {
+                  orderType: u,
+                  orderBy: o.sortOptions?.sortDataBy?.sortOrder ?? v.Ascending,
+                }));
+            }
+          } else {
+            let u = E(e);
+            u !== void 0 &&
+              ((e.orderOptions ??= {}), (e.orderOptions.data = u));
+          }
+        "sortLabelsBy" in e && delete e.sortLabelsBy,
+          "sortOptions" in e && delete e.sortOptions;
+      }
+      return e;
+    }
+    function st(i) {
+      let e = n(i);
+      if (e) {
+        let r = F(e.series);
+        if (
+          (r === l.BarAndLineFromFields || r === l.PieFromFields) &&
+          e.orderOptions?.data === void 0 &&
+          e.orderOptions?.orderByFields !== void 0
+        ) {
+          let t = E(e);
+          t !== void 0 &&
+            ((e.orderOptions ??= {}),
+            (e.orderOptions.data = t),
+            delete e.orderOptions.orderByFields);
+        }
+      }
+      return e;
+    }
+    function nt(i) {
+      let e = n(i);
+      return (
+        e.horizontalAxisLabelsBehavior === I.NONE &&
+          (e.horizontalAxisLabelsBehavior = L.Hide),
+        e.verticalAxisLabelsBehavior === I.NONE &&
+          (e.verticalAxisLabelsBehavior = L.Hide),
+        e
+      );
+    }
+    function at(i) {
+      let e = n(i),
+        r = e.series[0];
+      if (
+        r &&
+        !r.temporalBinning &&
+        re(e.series[0]) &&
+        ("timeIntervalSize" in r ||
+          "timeIntervalUnits" in r ||
+          "timeAggregationType" in r ||
+          "trimIncompleteTimeInterval" in r ||
+          "nullPolicy" in r)
+      ) {
+        if (
+          ((r.temporalBinning = {}),
+          r.timeIntervalSize !== void 0 &&
+            ((r.temporalBinning.size = r.timeIntervalSize),
+            delete r.timeIntervalSize),
+          r.timeIntervalUnits)
+        ) {
+          let t;
+          switch (r.timeIntervalUnits) {
+            case "esriTimeUnitsSeconds":
+              t = S.Second;
+              break;
+            case "esriTimeUnitsMinutes":
+              t = S.Minute;
+              break;
+            case "esriTimeUnitsHours":
+              t = S.Hour;
+              break;
+            case "esriTimeUnitsDays":
+              t = S.Day;
+              break;
+            case "esriTimeUnitsWeeks":
+              t = S.Week;
+              break;
+            case "esriTimeUnitsMonths":
+              t = S.Month;
+              break;
+            case "esriTimeUnitsYears":
+              t = S.Year;
+              break;
+          }
+          t !== void 0 && (r.temporalBinning.unit = t),
+            delete r.timeIntervalUnits;
+        }
+        r.timeAggregationType &&
+          ((r.temporalBinning.timeAggregationType = r.timeAggregationType),
+          delete r.timeAggregationType),
+          r.trimIncompleteTimeInterval !== void 0 &&
+            ((r.temporalBinning.trimIncompleteTimeInterval =
+              r.trimIncompleteTimeInterval),
+            delete r.trimIncompleteTimeInterval),
+          r.nullPolicy &&
+            ((r.temporalBinning.nullPolicy = r.nullPolicy),
+            delete r.nullPolicy);
+      }
+      return e;
+    }
+    function dt(i) {
+      let e = n(i);
+      return (
+        e.series.forEach((r) => {
+          r.query?.outStatistics?.forEach((t) => {
+            t.statisticType === "percentile_cont"
+              ? (t.statisticType = x.ContinuousPercentile)
+              : t.statisticType === "percentile_disc" &&
+                (t.statisticType = x.DiscretePercentile);
+          });
+        }),
+        e
+      );
+    }
+    function ct(i) {
+      let e = n(i);
+      return (
+        e.subtitle === void 0 && e.subTitle && (e.subtitle = e.subTitle),
+        delete e.subTitle,
+        e
+      );
+    }
+    function lt(i) {
+      let e = n(i),
+        r = e.series[0];
+      return r?.temporalBinning && delete r.temporalBinning?.type, e;
+    }
+    function ut(i) {
+      let e = n(i),
+        r = e.series[0],
+        t = i;
+      return (
+        t.series[0]?.xTemporalBinning &&
+          (r.xTemporalBinning = {
+            ...t.series[0]?.xTemporalBinning,
+            type: c.CalendarDateParts,
+          }),
+        t.series[0]?.yTemporalBinning &&
+          (r.yTemporalBinning = {
+            ...t.series[0]?.yTemporalBinning,
+            type: c.CalendarDateParts,
+          }),
+        e
+      );
+    }
+    function pt(i) {
+      let e = n(i);
+      return (e = He(e)), e;
+    }
+    function ce(i) {
+      let e = n(i);
+      return (e = $e(e)), e;
+    }
+    function le(i) {
+      let e = n(i);
+      return (e = Re(e)), e;
+    }
+    function ue(i) {
+      let e = n(i);
+      return (e = Ae(e)), e;
+    }
+    function pe(i) {
+      let e = n(i);
+      return (e = Ye(e)), e;
+    }
+    function ye(i) {
+      let e = n(i);
+      return (e = Qe(e)), e;
+    }
+    function me(i) {
+      let e = n(i);
+      return (e = Je(e)), e;
+    }
+    function fe(i) {
+      let e = n(i);
+      return (e = Ze(e)), e;
+    }
+    function ge(i) {
+      let e = n(i);
+      return (e = et(e)), e;
+    }
+    function ve(i) {
+      return it(i);
+    }
+    function he(i) {
+      let e = n(i);
+      return M(e) && (e = tt(e)), e;
+    }
+    function Te(i) {
+      return Ke(i);
+    }
+    function Se(i) {
+      return ot(i);
+    }
+    function Be(i) {
+      return Ve(i);
+    }
+    function xe(i) {
+      return st(i);
+    }
+    function be(i) {
+      return nt(i);
+    }
+    function Oe(i) {
+      return at(i);
+    }
+    function Fe(i) {
+      return dt(i);
+    }
+    function Pe(i) {
+      let e = n(i);
+      return (e = Ae(e)), ct(e);
+    }
+    function we(i) {
+      let e = n(i);
+      return (e = lt(e)), e;
+    }
+    function Ce(i) {
+      let e = n(i);
+      return (e = ut(e)), e;
+    }
+    function yt(i) {
+      let { versionsToConvert: e = [], configToUpdate: r } = i,
+        t = n(r);
+      return (
+        e.length > 0 &&
+          t !== void 0 &&
+          ((t = rt(t)),
+          e.includes(U) || e.includes(Z)
+            ? ((t = pt(t)),
+              (t = ce(t)),
+              (t = le(t)),
+              (t = ue(t)),
+              (t = pe(t)),
+              (t = ye(t)),
+              (t = me(t)),
+              (t = fe(t)),
+              (t = ge(t)),
+              (t = ve(t)),
+              (t = he(t)),
+              (t = Te(t)),
+              (t = Se(t)),
+              (t = Be(t)),
+              (t = xe(t)),
+              (t = be(t)),
+              (t = Oe(t)),
+              (t = Fe(t)),
+              (t = Pe(t)),
+              (t = we(t)),
+              (t = Ce(t)))
+            : e.forEach((o) => {
+                if (t !== void 0)
+                  switch (o) {
+                    case "1.0.1":
+                      t = ce(t);
+                      break;
+                    case "3.4.0":
+                      t = le(t);
+                      break;
+                    case "4.0.0":
+                      t = ue(t);
+                      break;
+                    case "4.0.1":
+                      t = pe(t);
+                      break;
+                    case "6.4.0":
+                      t = ye(t);
+                      break;
+                    case "7.5.1":
+                      t = me(t);
+                      break;
+                    case "8.0.0":
+                      t = fe(t);
+                      break;
+                    case "9.2.0":
+                      t = ge(t);
+                      break;
+                    case "9.7.0":
+                      t = ve(t);
+                      break;
+                    case "10.0.0":
+                      t = he(t);
+                      break;
+                    case "11.0.0":
+                      t = Te(t);
+                      break;
+                    case "14.0.1":
+                      t = Se(t);
+                      break;
+                    case "16.0.0":
+                      t = Be(t);
+                      break;
+                    case "16.1.0":
+                      t = xe(t);
+                      break;
+                    case "18.1.3":
+                      t = be(t);
+                      break;
+                    case "20.1.0":
+                      t = Oe(t);
+                      break;
+                    case "21.0.0":
+                      t = Fe(t);
+                      break;
+                    case "23.2.0":
+                      t = Pe(t);
+                      break;
+                    case "24.7.0":
+                      t = we(t);
+                      break;
+                    case "25.0.0":
+                      t = Ce(t);
+                      break;
+                  }
+              }),
+          (t.version = V)),
+        t
+      );
+    }
+    async function ke(i, e, r) {
+      let t = i;
+      if (i) {
+        let o = Q(e);
+        t = await ze({ configToUpdate: i, layer: o, chartContainer: r });
+        let s = i.version ?? U,
+          { versionStatus: p, versions: u } = ee(s);
+        (p === k.Older || p === k.Unrecognized) &&
+          (t = yt({ versionsToConvert: u, configToUpdate: t }));
+      }
+      return t;
+    }
+    var Me = class extends EventTarget {
+      constructor(...e) {
+        super(),
+          (this.dirtyAsyncSetters = []),
+          (this.asyncConfigUpdateInProgress = !1),
+          (this.pendingUpdates = 0),
+          (this.dataStore = {}),
+          (this.asyncUpdatesPromise = new Promise((r) => {
+            this.resolveSetup = r;
+          })),
+          (this.emitConfigUpdate = (r) => {
+            this.dispatchEvent(
+              new CustomEvent("geosceneChartsModelConfigChange", {
+                detail: { config: this._config, setterName: r },
+              })
+            );
+          }),
+          (this.guardSetterFromAsyncOverwrite = async (r) => {
+            r(),
+              this.asyncConfigUpdateInProgress &&
+                (await this.asyncUpdatesPromise, r());
+          });
+      }
+      get chartType() {
+        return this._chartType;
+      }
+      isSameChartAs(e) {
+        let r = e?.layer;
+        return (
+          r !== void 0 &&
+          this._config.id === e?.chartId &&
+          this.layerInfo?.layer.id === r.id
+        );
+      }
+      async update() {
+        await this.asyncUpdatesPromise;
+      }
+      async loadConfigFromLayer(e) {
+        let { layer: r, iLayer: t, config: o } = e;
+        this.commonStrings = await N(
+          C(document.documentElement).t9nLocale,
+          _("./assets/common/t9n"),
+          "messages."
+        );
+        let s = r;
+        if (
+          (!s && t
+            ? (s = await O(t))
+            : !s && o?.iLayer && (s = await O(o.iLayer)),
+          s)
+        ) {
+          let p = await J(s, !0),
+            u = K(s).idField;
+          this.layerInfo = { layer: s, layerFieldsInfo: p, objectIdField: u };
+        }
+        (this._config = o ? await ke(o) : this.generateDefaultConfig()),
+          this._config.legend !== void 0 &&
+            this._config.legend?.title === void 0 &&
+            (this._config.legend.title = H().title),
+          t && (this._config.iLayer = t);
+      }
+      startAsyncUpdate() {
+        this.pendingUpdates === 0 &&
+          ((this.asyncConfigUpdateInProgress = !0),
+          (this.asyncUpdatesPromise = new Promise((e) => {
+            this.resolveSetup = e;
+          }))),
+          (this.pendingUpdates += 1);
+      }
+      finishAsyncUpdate() {
+        (this.pendingUpdates -= 1),
+          this.pendingUpdates === 0 &&
+            ((this.asyncConfigUpdateInProgress = !1), this.resolveSetup?.());
+      }
+    };
+    function Wt(i, e, r) {
+      let t = r.set,
+        o = r.value;
+      return (
+        t &&
+          (r.set = function (s) {
+            this.guardSetterFromAsyncOverwrite(() => {
+              t.call(this, s), this.emitConfigUpdate(e);
+            });
+          }),
+        o &&
+          (r.value = function (...s) {
+            this.guardSetterFromAsyncOverwrite(() => {
+              o.apply(this, s), this.emitConfigUpdate(e);
+            });
+          }),
+        r
+      );
+    }
+    return { a: ke, b: Me, c: Wt };
+  },
+  "core/promiseUtils",
+  "request",
+  "geometry/support/jsonUtils",
+  "rest/support/AttributeBinsQuery",
+  "rest/support/StatisticDefinition",
+  "time/TimeExtent",
+  "intl",
+  "Graphic",
+  "renderers/support/jsonUtils",
+  "symbols/support/symbolUtils",
+  "layers/support/FeatureFilter",
+  "smartMapping/statistics/histogram",
+  "smartMapping/statistics/summaryStatistics",
+  "core/sql",
+  "AttributeBinsGraphic",
+  a
+);