@arcgis/charts-components 4.33.0-next.119 → 4.33.0-next.120

package/dist/chunks/index.js

@@ -1,95 +1,617 @@
-import { RESTSymbolType as n, WebChartTypes as r } from "@arcgis/charts-spec";
-import { c2 as s } from "./interfaces.js";
+import { WebChartVersionStatus as A, WebChartCurrentVersion as re, WebChartTypes as l, WebChartStatisticType as x, defaultPieFromFieldsName as P, WebChartOrderDataByTypes as B, WebChartSortOrderKinds as m, WebChartColoringPatterns as ie, WebChartLabelBehavior as k, WebChartTemporalBinningTypes as oe, WebChartFixedDateBinningUnits as b } from "@arcgis/charts-spec";
+import { cloneDeep as s, isEmpty as h } from "lodash-es";
+import { bN as X, f as Z, a as se, u as ne, c2 as g, V as ae, g as de, k as C, r as le, cs as c, b9 as O, ba as D, e as ce, h as ue, W as U, cm as T, cd as ee, ax as ye, bs as fe, aN as pe, m as me, bk as Se } from "./interfaces.js";
+import { h as ve, i as Be, a as he } from "./index2.js";
 /*! All material copyright Esri, All Rights Reserved, unless otherwise specified.
 See https://js.arcgis.com/4.33/esri/copyright.txt for details.
-v4.33.0-next.119 */
-function S(e) {
-  const t = [
-    r.BarSeries,
-    r.LineSeries,
-    r.ComboLineAndBarSeries,
-    r.BoxPlotSeries
-  ], i = s(e?.series);
-  return i !== void 0 ? t.includes(i) : !1;
+v4.33.0-next.120 */
+var w = /* @__PURE__ */ ((r) => (r.NONE = "none", r.ROTATE = "rotate", r.STAGGER = "stagger", r.WRAP = "wrap", r))(w || {});
+function Fe(r) {
+  const e = s(r);
+  return h(r.axes) || (e.axes = r.axes?.map((i) => {
+    const t = i;
+    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 c(e) {
-  const t = [
-    r.BarSeries,
-    r.LineSeries,
-    r.ComboLineAndBarSeries,
-    r.RadarSeries
-  ], i = s(e?.series);
-  return i !== void 0 ? t.includes(i) : !1;
+function ge(r) {
+  const e = s(r);
+  return h(r.series) || (e.series = r.series.map((i, t) => {
+    const o = i;
+    i.id === void 0 && (o.id = `Series ${Date.now()}-${t}`);
+    const n = g(r.series, t);
+    return (n === l.BarSeries || n === l.LineSeries || n === l.RadarSeries) && o.query?.outStatistics?.[0]?.statisticType === "median" && (o.query.outStatistics[0].statisticType = x.ContinuousPercentile), n === l.BarSeries && o.multipleBarType !== void 0 && (o.stackedType = o.multipleBarType, delete o.multipleBarType), n === l.PieSeries && o.sliceGrouping !== void 0 && (o.sliceGrouping.sliceId = ae.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;
 }
-function p(e) {
-  return e?.type === n.SFS;
+async function M(r, e) {
+  const i = [];
+  return await Promise.all(
+    r.map(async (t) => {
+      if (!ee(t)) {
+        const o = T(t, !1);
+        if (o.fieldToSort !== void 0) {
+          const n = await O({
+            queryObject: e,
+            fieldToMatch: o.fieldToSort
+          });
+          n !== void 0 && i.push(
+            o.orderBy === void 0 ? n : `${n} ${o.orderBy}`
+          );
+        }
+      }
+    })
+  ), i;
 }
-function y(e) {
-  return e?.type === n.SLS;
+async function be(r, e) {
+  const i = { ...r };
+  let t = e;
+  if (!t) {
+    const o = ve(r) ? r.iLayer : r.dataSource?.layer;
+    o && (t = await de(o));
+  }
+  if (t) {
+    const o = C(i.series), n = g(i.series), f = i.series && i.series.length > 0 && i.series[0].x.trim() === "" || n === l.GaugeSeries && !le(r) || o === c.PieFromFields || o === c.BarAndLineFromFields || o === c.BoxPlotMonoField || o === c.BoxPlotMonoFieldAndSplitBy || o === c.BoxPlotMultiFields || o === c.BoxPlotMultiFieldsAndSplitBy, S = n === l.ScatterSeries || o === c.BarAndLineNoAggregation || o === c.BarAndLineSplitByNoAggregation || o === c.BoxPlotMonoField || o === c.BoxPlotMonoFieldAndSplitBy || o === c.BoxPlotMonoFieldAndCategory || o === c.BoxPlotMonoFieldAndCategoryAndSplitBy || o === c.PieNoAggregation;
+    if (i.series = await Promise.all(
+      r.series.map(async (a) => {
+        const d = { ...a };
+        if (f || (d.x = await O({ queryObject: t, fieldToMatch: a.x })), "y" in d && S) {
+          const u = d.y;
+          if (Array.isArray(u)) {
+            const y = await D({
+              fieldsList: u,
+              queryObject: t
+            });
+            y !== void 0 && "y" in d && (d.y = y);
+          } else "y" in d && typeof u == "string" && (d.y = await O({ queryObject: t, fieldToMatch: u }));
+        }
+        if (a.query !== void 0) {
+          let { where: u, groupByFieldsForStatistics: y, outStatistics: p } = a.query;
+          if (y = await D({ fieldsList: y, queryObject: t }), p !== void 0 && (p = await Promise.all(
+            p.map(async (v) => {
+              const F = { ...v };
+              return F.onStatisticField = await O({
+                queryObject: t,
+                fieldToMatch: v.onStatisticField
+              }), F;
+            })
+          )), u !== void 0 && o === c.BarAndLineSplitBy) {
+            const v = ce(a.query?.where), F = ue({
+              where: a.query?.where,
+              normalize: !1,
+              escape: !1
+            });
+            u = `${await O({ queryObject: t, fieldToMatch: v })}=${F}`;
+          }
+          d.query !== void 0 && (u !== void 0 && (d.query.where = u), y !== void 0 && (d.query.groupByFieldsForStatistics = y), p !== void 0 && (d.query.outStatistics = p));
+        }
+        return d;
+      })
+    ), i.series[0]?.query !== void 0) {
+      const a = i.series[0].query;
+      let { orderByFields: d } = a;
+      d !== void 0 && d.length > 0 && (d = await M(d, t), d.length > 0 && a.orderByFields !== void 0 && (i.series[0].query.orderByFields = d));
+    }
+    if (i.orderOptions?.orderByFields !== void 0) {
+      let { orderByFields: a } = i.orderOptions;
+      a !== void 0 && a.length > 0 && (a = await M(a, t), a.length > 0 && (i.orderOptions.orderByFields = a));
+    }
+    if (n === l.GaugeSeries && r.axes?.[0] !== void 0) {
+      const { minimumFromField: a, maximumFromField: d } = r.axes[0];
+      if (a !== void 0) {
+        const u = typeof a == "string" ? a : a.onStatisticField, y = await O({ queryObject: t, fieldToMatch: u });
+        let p = a;
+        typeof r.axes[0].minimumFromField == "string" ? p = y : typeof a == "object" && (p = {
+          ...a,
+          onStatisticField: y
+        }), r.axes[0].minimumFromField = p;
+      }
+      if (d !== void 0) {
+        const u = typeof d == "string" ? d : d.onStatisticField, y = await O({ queryObject: t, fieldToMatch: u });
+        let p = d;
+        typeof r.axes[0].maximumFromField == "string" ? p = y : typeof d == "object" && (p = {
+          ...d,
+          onStatisticField: y
+        }), r.axes[0].maximumFromField = p;
+      }
+    }
+  }
+  return i;
 }
-function d(e) {
-  return e?.type === n.SMS;
+function Oe(r) {
+  const e = s(r);
+  if (!h(r.series) && g(r.series) === l.BoxPlotSeries) {
+    const t = e.series[0];
+    t.showOutliers !== void 0 && (r.showOutliers === void 0 && (e.showOutliers = t.showOutliers), delete t.showOutliers), t.standardizeValues !== void 0 && (r.standardizeValues === void 0 && (e.standardizeValues = t.standardizeValues), delete t.standardizeValues), t.showMean !== void 0 && (r.showMean === void 0 && (e.showMean = t.showMean), delete t.showMean);
+  }
+  return e;
 }
-function h(e) {
-  return e?.type === n.TS;
+function xe(r) {
+  const e = {
+    orderType: B.Category,
+    orderBy: m.Ascending
+  }, i = r.query?.orderByFields?.[0];
+  if (i !== void 0) {
+    const { outStatisticFieldName: t, statisticType: o } = r.query?.outStatistics?.[0] ?? {}, n = T(i);
+    t !== void 0 && n.fieldToSort === t && o !== void 0 && (o === x.Average || o === "mean" ? e.orderType = B.Mean : o === x.ContinuousPercentile && (e.orderType = B.Median)), e.orderBy = n.orderBy ?? m.Ascending;
+  }
+  return e;
 }
-function f(e) {
-  return e && "iLayer" in e && e.iLayer;
+function Ce(r) {
+  let e = !1;
+  const i = Array.from(new Set(r.series.map((t) => t.type)));
+  return i.length === 2 && i.includes(l.BoxPlotSeries) && i.includes(l.LineSeries) && (e = r.series.find((o) => o.type === l.LineSeries)?.query?.outStatistics?.[0] !== void 0), e;
 }
-function m(e, t) {
-  return e !== void 0 && t !== void 0 && e.series[0]?.type === t;
+function Te(r) {
+  const e = s(r);
+  if (!h(e.series) && g(r.series) === l.BoxPlotSeries) {
+    if (e.orderOptions?.data === void 0) {
+      const t = xe(r.series[0]);
+      t.orderType !== void 0 && (e.orderOptions ??= {}, e.orderOptions.data = {
+        orderType: t.orderType,
+        orderBy: t.orderBy
+      });
+    }
+    if (e.series = r.series.map((t) => {
+      const o = t;
+      return h(o.x?.trim()) && (o.x = U), delete o.query?.orderByFields, o;
+    }), Ce(e)) {
+      e.showMean = !0;
+      const t = e.series.find(
+        (o) => o.type === l.BoxPlotSeries
+      );
+      e.series.forEach((o) => {
+        o.type === l.LineSeries && (delete o.query?.groupByFieldsForStatistics, delete o.query?.outStatistics, delete o.query?.orderByFields, t && (o.y = t.y));
+      });
+    }
+    e.series = r.series.map((t) => {
+      const o = t;
+      return delete o.query?.outStatistics, o;
+    });
+  }
+  return e;
 }
-function a(e) {
-  return e.type === r.BoxPlotSeries;
+function we(r) {
+  const e = s(r);
+  return e.legend !== void 0 && !Number.isFinite(e.legend.maxHeight) && (e.legend.maxHeight = Number.NaN), e;
 }
-function T(e) {
-  return e.type === r.LineSeries;
+function Pe(r) {
+  const e = s(r);
+  return "dataSource" in e && e.dataSource.layer && (e.iLayer = e.dataSource.layer, delete e.dataSource), e;
 }
-function C(e) {
-  return e.type === r.RadarSeries;
+function Le(r) {
+  const e = s(r), i = /* @__PURE__ */ new Set(), t = e.id ?? "";
+  return i.add(t), e.series.forEach((o) => {
+    let n = o.id;
+    i.has(n) && (n = `${n}_${Date.now()}`, o.id = n), i.add(n);
+  }), e;
 }
-function b(e) {
-  return e.type === r.BarSeries;
+function Ae(r) {
+  const e = s(r);
+  return e?.orderOptions?.orderByFields !== void 0 && C(r.series) === c.PieFromFields && (e.orderOptions.orderByFields = r?.orderOptions?.orderByFields?.map(
+    (i) => {
+      let t = s(i);
+      return i !== void 0 && i.includes("arcgis_charts_pie_category_from_fields_name") && (t = i.replace(
+        "arcgis_charts_pie_category_from_fields_name",
+        P
+      )), t;
+    }
+  )), e;
 }
-const l = (e) => s(e) === r.BarSeries, L = (e) => s(e) === r.LineSeries, B = (e) => s(e) === r.RadarSeries;
-function v(e) {
-  return e.every(a);
+function ke(r) {
+  const e = s(r);
+  if (!h(r.series) && e.axes?.[0] !== void 0 && g(r.series) === l.GaugeSeries && r.axes?.[0] !== void 0) {
+    const t = r.axes[0];
+    t.ticks !== void 0 && Object.hasOwn(t.ticks, "spacing") && delete t.ticks.spacing, e.axes[0] = t;
+  }
+  return e;
 }
-function x(e) {
-  return e !== void 0 && e.type === r.NumberAxisFormat;
+function De(r) {
+  const e = s(r), { extent: i } = e.series[0]?.query ?? {};
+  return i !== void 0 && (e.dataFilters = {
+    ...e.dataFilters,
+    geometry: i
+  }, e.series.forEach((t) => {
+    "query" in t && "extent" in t.query && delete t.query.extent;
+  })), e;
 }
-function A(e) {
-  return e === void 0 || "bins" in e;
+function Me(r) {
+  const e = s(r);
+  return h(r.series) || (Be(r) && r.rotated === void 0 && (e.rotated = r.series[0].rotated ?? ye()), e.series.forEach((i) => {
+    i.rotated !== void 0 && delete i.rotated;
+  })), e;
 }
-function I(e) {
-  return e === void 0 || "dataItems" in e;
+function qe(r) {
+  const e = s(r), i = r.dataSource;
+  return "dataSource" in e && !h(i) && (i.type === "featureLayer" && e.dataSource !== void 0 && (e.dataSource.type = "layer"), "featureLayer" in i && (e.dataSource.layer = i.featureLayer, delete e.dataSource.featureLayer)), e;
 }
-function R(e) {
-  return e === void 0 || "dataItems" in e && "r2" in e;
+function Ne(r) {
+  const e = s(r);
+  if ("dataSource" in r) {
+    const i = r.dataSource;
+    if (i.filter !== void 0 && i.filter.trim() !== "") {
+      const t = fe([i.filter, e.dataFilters?.where]);
+      e.dataFilters = {
+        ...e.dataFilters,
+        where: t
+      }, delete e.dataSource.filter;
+    }
+  }
+  return e;
 }
-function O(e) {
-  return "value" in e;
+function Ie(r) {
+  return r !== "originalValue";
+}
+function te(r) {
+  let e;
+  switch (r) {
+    case "mean":
+      e = B.Mean;
+      break;
+    case "median":
+      e = B.Median;
+      break;
+    case "category":
+      e = B.Category;
+      break;
+  }
+  return e;
+}
+function Ve(r) {
+  const e = s(r);
+  if (!h(r.series) && g(r.series) === l.PieSeries) {
+    const t = e.series[0];
+    if (t.sortLabelsBy === "originalValue")
+      e.sortLabelsBy = t.sortLabelsBy;
+    else if (t.sortLabelsBy !== void 0 && e.orderOptions?.data === void 0) {
+      const o = L(e);
+      o !== void 0 && (e.orderOptions ??= {}, e.orderOptions.data = o);
+    }
+    t.sortLabelsBy && delete t.sortLabelsBy;
+  }
+  return e;
+}
+function We(r) {
+  const e = s(r);
+  return h(r.series) || (he(r) && r.stackedType === void 0 && (e.stackedType = r.series[0].stackedType ?? pe()), e.series.forEach((i) => {
+    "stackedType" in i && delete i.stackedType;
+  })), e;
+}
+function Ee(r) {
+  const e = s(r), i = r.sortOptions?.sortSeriesBy;
+  return e.orderOptions === void 0 && typeof i == "string" && (e.orderOptions ??= {}, e.orderOptions.series = {
+    orderBy: i === "DESC" ? m.Descending : m.Ascending
+  }), e;
+}
+function Ge(r) {
+  const e = s(r);
+  return e.colorMatch === void 0 && e.series[0].colorType !== void 0 && (e.colorMatch = e.series[0].colorType === ie.Match), e.series.forEach((i) => {
+    i.colorType !== void 0 && delete i.colorType;
+  }), e;
+}
+function je(r) {
+  const e = s(r);
+  if (e.sortDataBy !== void 0) {
+    if (e.orderOptions?.data === void 0) {
+      const i = r.sortDataBy, t = te(i?.sortType);
+      t !== void 0 && (e.orderOptions ??= {}, e.orderOptions.data = {
+        orderType: t,
+        orderBy: i?.sortOrder ?? m.Ascending
+      });
+    }
+    delete e.sortDataBy;
+  }
+  return e;
+}
+function _e(r) {
+  const e = s(r);
+  return e.axes?.forEach((i) => {
+    i !== void 0 && i.scrollbarVisible !== void 0 && i.scrollbar?.visible === void 0 && (i.scrollbar = {
+      ...i.scrollbar,
+      visible: i.scrollbarVisible
+    }, delete i.scrollbarVisible);
+  }), e;
+}
+function ze(r) {
+  const e = s(r), i = e.series[0]?.query?.orderByFields;
+  if (i !== void 0 && i.length > 0 && e.orderOptions?.orderByFields === void 0) {
+    e.orderOptions ??= {};
+    let t = !0;
+    if (i.length === 1) {
+      const { fieldToSort: o, orderBy: n } = T(i[0]);
+      let f;
+      o === r.series[0].x || o === P ? f = B.Category : "y" in r.series[0] && o === r.series[0].y && (f = B.YValue), f !== void 0 && (t = !1, e.orderOptions.data === void 0 && (e.orderOptions.data = {
+        orderType: f,
+        orderBy: n?.toUpperCase() === "DESC" ? m.Descending : m.Ascending
+      }));
+    }
+    t && (e.orderOptions.orderByFields = i);
+  }
+  return e.series.forEach((t) => {
+    delete t.query?.orderByFields;
+  }), e;
+}
+function L(r) {
+  let e, i = r.orderOptions?.orderByFields?.[0];
+  if (r.series?.length > 0) {
+    const t = g(r.series), o = C(r.series);
+    if (t !== l.PieSeries && o !== c.BarAndLineFromFields && (i = i ?? r.series[0].x), i && !ee(i)) {
+      const { fieldToSort: n, orderBy: f } = T(i);
+      let S;
+      n === r.series[0].x || n === P ? S = B.Category : "y" in r.series[0] && n === r.series[0].y && (S = B.YValue), S !== void 0 && (e = {
+        orderType: S,
+        orderBy: f?.toUpperCase() === "DESC" ? m.Descending : m.Ascending
+      });
+    }
+  }
+  return e;
+}
+function $e(r) {
+  const e = s(r), i = r, t = r, o = r, n = r, f = r;
+  if (e) {
+    if (e.orderOptions?.series === void 0 && i.sortOptions?.sortSeriesBy !== void 0 && (e.orderOptions ??= {}, e.orderOptions.series = {
+      preferLabel: Ie(
+        t.sortLabelsBy ?? i.sortOptions.sortSeriesBy.sortType
+      ),
+      orderBy: i.sortOptions.sortSeriesBy.sortOrder ?? m.Ascending
+    }), t.sortLabelsBy === "originalValue" || n.orderOptions?.data?.preferDataLabel === !1 || f.orderOptions?.data?.preferLabel === !1)
+      e.orderOptions?.data && delete e.orderOptions.data;
+    else if (e.orderOptions?.data === void 0)
+      if (g(e.series) === l.BoxPlotSeries) {
+        if (t.sortLabelsBy || o.sortOptions?.sortDataBy !== void 0) {
+          const a = te(o.sortOptions?.sortDataBy?.sortType);
+          a !== void 0 && (e.orderOptions ??= {}, e.orderOptions.data = {
+            orderType: a,
+            orderBy: o.sortOptions?.sortDataBy?.sortOrder ?? m.Ascending
+          });
+        }
+      } else {
+        const a = L(e);
+        a !== void 0 && (e.orderOptions ??= {}, e.orderOptions.data = a);
+      }
+    "sortLabelsBy" in e && delete e.sortLabelsBy, "sortOptions" in e && delete e.sortOptions;
+  }
+  return e;
+}
+function He(r) {
+  const e = s(r);
+  if (e) {
+    const i = C(e.series);
+    if ((i === c.BarAndLineFromFields || i === c.PieFromFields) && e.orderOptions?.data === void 0 && e.orderOptions?.orderByFields !== void 0) {
+      const t = L(e);
+      t !== void 0 && (e.orderOptions ??= {}, e.orderOptions.data = t, delete e.orderOptions.orderByFields);
+    }
+  }
+  return e;
+}
+function Re(r) {
+  const e = s(r);
+  return e.horizontalAxisLabelsBehavior === w.NONE && (e.horizontalAxisLabelsBehavior = k.Hide), e.verticalAxisLabelsBehavior === w.NONE && (e.verticalAxisLabelsBehavior = k.Hide), e;
+}
+function Qe(r) {
+  const e = s(r), i = e.series[0];
+  if (me(e.series[0]) && !i.temporalBinning && ("timeIntervalSize" in i || "timeIntervalUnits" in i || "timeAggregationType" in i || "trimIncompleteTimeInterval" in i || "nullPolicy" in i)) {
+    if (i.temporalBinning = {
+      type: oe.FixedDateBased
+    }, i.timeIntervalSize !== void 0 && (i.temporalBinning.size = i.timeIntervalSize, delete i.timeIntervalSize), i.timeIntervalUnits) {
+      let t;
+      switch (i.timeIntervalUnits) {
+        case "esriTimeUnitsSeconds":
+          t = b.Second;
+          break;
+        case "esriTimeUnitsMinutes":
+          t = b.Minute;
+          break;
+        case "esriTimeUnitsHours":
+          t = b.Hour;
+          break;
+        case "esriTimeUnitsDays":
+          t = b.Day;
+          break;
+        case "esriTimeUnitsWeeks":
+          t = b.Week;
+          break;
+        case "esriTimeUnitsMonths":
+          t = b.Month;
+          break;
+        case "esriTimeUnitsYears":
+          t = b.Year;
+          break;
+      }
+      t !== void 0 && (i.temporalBinning.unit = t), delete i.timeIntervalUnits;
+    }
+    i.timeAggregationType && (i.temporalBinning.timeAggregationType = i.timeAggregationType, delete i.timeAggregationType), i.trimIncompleteTimeInterval !== void 0 && (i.temporalBinning.trimIncompleteTimeInterval = i.trimIncompleteTimeInterval, delete i.trimIncompleteTimeInterval), i.nullPolicy && (i.temporalBinning.nullPolicy = i.nullPolicy, delete i.nullPolicy);
+  }
+  return e;
+}
+function Ye(r) {
+  const e = s(r);
+  return e.series.forEach((i) => {
+    i.query?.outStatistics?.forEach((t) => {
+      t.statisticType === "percentile_cont" ? t.statisticType = x.ContinuousPercentile : t.statisticType === "percentile_disc" && (t.statisticType = x.DiscretePercentile);
+    });
+  }), e;
+}
+async function Ke(r, e) {
+  let i = s(r);
+  return i = Fe(i), i = ge(i), i = await be(i, e), i = Oe(i), i = Te(i), i = we(i), i = Le(i), i;
+}
+function Je(r) {
+  let e = s(r);
+  return e = Ae(e), e;
+}
+function q(r) {
+  let e = s(r);
+  return e = ke(e), e;
+}
+function N(r) {
+  let e = s(r);
+  return e = De(e), e;
+}
+function I(r) {
+  let e = s(r);
+  return e = Me(e), e;
+}
+function V(r) {
+  let e = s(r);
+  return e = qe(e), e;
+}
+function W(r) {
+  let e = s(r);
+  return e = Ne(e), e;
+}
+function E(r) {
+  let e = s(r);
+  return e = Ve(e), e;
+}
+function G(r) {
+  let e = s(r);
+  return e = Ee(e), e;
+}
+function j(r) {
+  let e = s(r);
+  return e = Ge(e), e;
+}
+function _(r) {
+  return _e(r);
+}
+function z(r) {
+  let e = s(r);
+  return r.series[0]?.type === l.BoxPlotSeries && (e = je(e)), e;
+}
+function $(r) {
+  return We(r);
+}
+function H(r) {
+  return $e(r);
+}
+function R(r) {
+  return Pe(r);
+}
+function Q(r) {
+  return He(r);
+}
+function Y(r) {
+  return Re(r);
+}
+function K(r) {
+  return Qe(r);
+}
+function J(r) {
+  return Ye(r);
+}
+function Xe(r) {
+  const { versionsToConvert: e = [], configToUpdate: i } = r;
+  let t = s(i);
+  return e.length > 0 && t !== void 0 && (t = ze(t), e.includes(Z) || e.includes(ne) ? (t = Je(t), t = q(t), t = N(t), t = I(t), t = V(t), t = W(t), t = E(t), t = G(t), t = j(t), t = _(t), t = z(t), t = $(t), t = H(t), t = R(t), t = Q(t), t = Y(t), t = K(t), t = J(t)) : e.forEach((o) => {
+    if (t !== void 0)
+      switch (o) {
+        case "1.0.1":
+          t = q(t);
+          break;
+        case "3.4.0":
+          t = N(t);
+          break;
+        case "4.0.0":
+          t = I(t);
+          break;
+        case "4.0.1":
+          t = V(t);
+          break;
+        case "6.4.0":
+          t = W(t);
+          break;
+        case "7.5.1":
+          t = E(t);
+          break;
+        case "8.0.0":
+          t = G(t);
+          break;
+        case "9.2.0":
+          t = j(t);
+          break;
+        case "9.7.0":
+          t = _(t);
+          break;
+        case "10.0.0":
+          t = z(t);
+          break;
+        case "11.0.0":
+          t = $(t);
+          break;
+        case "14.0.1":
+          t = H(t);
+          break;
+        case "16.0.0":
+          t = R(t);
+          break;
+        case "16.1.0":
+          t = Q(t);
+          break;
+        case "18.1.3":
+          t = Y(t);
+          break;
+        case "20.1.0":
+          t = K(t);
+          break;
+        case "21.0.0":
+          t = J(t);
+          break;
+      }
+  }), t.version = re), t;
+}
+async function it(r, e) {
+  let i = r;
+  if (r) {
+    const t = X(e);
+    i = await Ke(r, t);
+    const o = r.version ?? Z, { versionStatus: n, versions: f } = se(o);
+    (n === A.Older || n === A.Unrecognized) && (i = Xe({
+      versionsToConvert: f,
+      configToUpdate: i
+    }));
+  }
+  return i;
+}
+async function ot(r) {
+  const { queryObject: e, queryConfig: i, category: t, splitByField: o, chartLimits: n, abortKey: f } = r, S = o !== void 0, a = t !== U ? [t] : [];
+  S && a.push(o);
+  const d = X(e), u = {
+    ...i,
+    groupByFieldsForStatistics: Array.from(new Set(a)),
+    outStatistics: [
+      {
+        statisticType: x.Count,
+        onStatisticField: d.objectIdField,
+        // Generating an out stat field name. Letting it to COUNT only can fail the query on arcObject layers
+        outStatisticFieldName: `${x.Count}_OBJECTID`
+      }
+    ],
+    orderByFields: void 0,
+    // Adding num (resultRecordCount) to match the query fetching the results (build by `buildUniqueQuery()). We pick an arbitrary limit (maxBarThreePlusSeriesCountTotal)
+    // as we don't know in advance how many results we will get.
+    // TODO: once the servers are able to make a distinction between values with a different number of trailing spaces we'll be able to revert that function to its previous
+    // state, using the `returnDistinctValues` on a specific field.
+    // Refer to: https://devtopia.esri.com/WebGIS/arcgis-charts/issues/8208
+    num: n?.maxBarThreePlusSeriesCountTotal
+  }, y = await Se({
+    queryObject: e,
+    featureCount: 1,
+    // skipping the count
+    queryConfig: u,
+    abortKey: f
+  });
+  return Array.from(
+    new Set(
+      y.map((v) => v.attributes[S ? o : t])
+    )
+  ).sort((v, F) => typeof v == "string" && typeof F == "string" ? v.localeCompare(F) : Number(v) - Number(F));
 }
 export {
-  c as a,
-  p as b,
-  y as c,
-  d,
-  h as e,
-  m as f,
-  a as g,
-  f as h,
-  S as i,
-  T as j,
-  C as k,
-  b as l,
-  l as m,
-  L as n,
-  B as o,
-  v as p,
-  x as q,
-  A as r,
-  I as s,
-  R as t,
-  O as u
+  it as c,
+  ot as u
 };