@arcgis/charts-components 4.34.0-next.23 → 4.34.0-next.25

package/dist/chunks/data.js

@@ -0,0 +1,859 @@
+import { WebChartStackedKinds as he, WebChartStatisticType as h, WebChartOrderDataByTypes as L, WebChartSortOrderKinds as N, WebChartTypes as U, WebChartTemporalBinningTypes as K, RESTFieldType as ne, WebChartNullPolicyTypes as re, defaultBarLineFromFieldsName as W, RESTSymbolType as Te, WebChartCalendarBinningUnits as Be, WebChartFixedDateBinningUnits as we, defaultBarLineFromFieldsValue as Ce } from "@arcgis/charts-spec";
+import { memoize as ce, isEmpty as Le, cloneDeep as ke } from "lodash-es";
+import "d3-array";
+import { bS as Ne, c0 as d, a4 as Q, al as ve, a2 as Ie, a0 as Ve, aV as Oe, c5 as De, aL as de, c9 as j, bR as O, m as I, b5 as qe, bt as ye, b6 as Z, b7 as ee, cd as Me, h as te, cr as je, k as z, cs as $, i as Ue, b4 as $e, a5 as Ee, a6 as Ke, ao as Pe, ap as We, ar as Re, b3 as le } from "./interfaces.js";
+import "@arcgis/core/geometry/support/jsonUtils.js";
+import "@arcgis/core/rest/support/AttributeBinsQuery.js";
+import "@arcgis/core/rest/support/Query.js";
+import "@arcgis/core/rest/support/StatisticDefinition.js";
+import "@arcgis/core/time/TimeExtent.js";
+import "@arcgis/core/core/promiseUtils.js";
+import "@arcgis/core/request.js";
+import { q as Xe, l as k, n as ze, o as Ye, j as w, k as C } from "./index4.js";
+import { S } from "./common.js";
+import { g as ue } from "./series-types.js";
+import { u as me } from "./index3.js";
+/*! All material copyright Esri, All Rights Reserved, unless otherwise specified.
+See https://js.arcgis.com/4.34/esri/copyright.txt for details.
+v4.34.0-next.25 */
+async function ie(t = Ne().locale) {
+  let e = await import("./messages.en3.js");
+  switch (t) {
+    case d.Arabic:
+      e = await import("./messages.ar3.js");
+      break;
+    case d.Bosnian:
+      e = await import("./messages.bs3.js");
+      break;
+    case d.Bulgarian:
+      e = await import("./messages.bg3.js");
+      break;
+    case d.Catalan:
+      e = await import("./messages.ca3.js");
+      break;
+    case d.Czech:
+      e = await import("./messages.cs3.js");
+      break;
+    case d.Danish:
+      e = await import("./messages.da3.js");
+      break;
+    case d.German:
+      e = await import("./messages.de3.js");
+      break;
+    case d.Greek:
+      e = await import("./messages.el3.js");
+      break;
+    case d.EnglishUSA:
+      e = await import("./messages.en-US3.js");
+      break;
+    case d.Spanish:
+      e = await import("./messages.es3.js");
+      break;
+    case d.Estonian:
+      e = await import("./messages.et3.js");
+      break;
+    case d.French:
+      e = await import("./messages.fr3.js");
+      break;
+    case d.Finnish:
+      e = await import("./messages.fi3.js");
+      break;
+    case d.Hebrew:
+      e = await import("./messages.he3.js");
+      break;
+    case d.Croatian:
+      e = await import("./messages.hr3.js");
+      break;
+    case d.Hungarian:
+      e = await import("./messages.hu3.js");
+      break;
+    case d.Indonesian:
+      e = await import("./messages.id3.js");
+      break;
+    case d.Italian:
+      e = await import("./messages.it3.js");
+      break;
+    case d.Japanese:
+      e = await import("./messages.ja3.js");
+      break;
+    case d.Korean:
+      e = await import("./messages.ko3.js");
+      break;
+    case d.Lithuanian:
+      e = await import("./messages.lt3.js");
+      break;
+    case d.Latvian:
+      e = await import("./messages.lv3.js");
+      break;
+    case d.NorwegianBokml:
+      e = await import("./messages.no3.js");
+      break;
+    case d.Dutch:
+      e = await import("./messages.nl3.js");
+      break;
+    case d.Polish:
+      e = await import("./messages.pl3.js");
+      break;
+    case d.PortugueseBrazil:
+      e = await import("./messages.pt-BR3.js");
+      break;
+    case d.PortuguesePortugal:
+      e = await import("./messages.pt-PT3.js");
+      break;
+    case d.Romanian:
+      e = await import("./messages.ro3.js");
+      break;
+    case d.Russian:
+      e = await import("./messages.ru3.js");
+      break;
+    case d.Serbian:
+      e = await import("./messages.sr3.js");
+      break;
+    case d.Slovak:
+      e = await import("./messages.sk3.js");
+      break;
+    case d.Slovenian:
+      e = await import("./messages.sl3.js");
+      break;
+    case d.Swedish:
+      e = await import("./messages.sv3.js");
+      break;
+    case d.Thai:
+      e = await import("./messages.th3.js");
+      break;
+    case d.Turkish:
+      e = await import("./messages.tr3.js");
+      break;
+    case d.Ukrainian:
+      e = await import("./messages.uk3.js");
+      break;
+    case d.Vietnamese:
+      e = await import("./messages.vi3.js");
+      break;
+    case d.ChineseChina:
+      e = await import("./messages.zh-CN3.js");
+      break;
+    case d.ChineseHongKong:
+      e = await import("./messages.zh-HK3.js");
+      break;
+    case d.ChineseTaiwan:
+      e = await import("./messages.zh-TW3.js");
+      break;
+    case d.English:
+  }
+  return e;
+}
+function R(t, e, i) {
+  const s = t?.axes?.[e];
+  s?.title !== void 0 ? s.title.content.text = i : s !== void 0 && (s.title = Ie({
+    text: i,
+    visible: !0,
+    font: Ve(Oe.AxisTitle)
+  }));
+}
+async function Y(t) {
+  const { config: e, layerInfo: i, numericFields: s, aggregationType: a } = t;
+  let r = "";
+  if (e) {
+    const n = De(e) === he.Stacked100, l = await ie();
+    if (n)
+      r = l.axisLabels.percent;
+    else {
+      const o = await de(a);
+      if (s.length === 1) {
+        const m = j(i.layerFieldsInfo, s[0]);
+        a === h.NoAggregation ? r = m : a === h.Count && s[0] === i.objectIdField ? r = l.axisLabels.count : r = O(l.axisLabels.aggregationOfFieldName, {
+          aggregation: o,
+          fieldName: m
+        });
+      } else s.length > 1 && (a === h.NoAggregation ? r = l.axisLabels.values : r = O(l.axisLabels.aggregationOfValues, {
+        aggregation: o
+      }));
+    }
+  }
+  return r;
+}
+const pe = async (t, e) => t.axes?.[e] ?? (await ve(t.type))[e], ge = (t, e, i) => {
+  t.axes !== void 0 && (t.axes[i] = e);
+}, _ = (t, e, i) => {
+  let s = Number.NaN;
+  return i ? s = t.axes?.[e]?.maximum : s = t.axes?.[e]?.minimum, s ?? Number.NaN;
+}, H = async (t, e, i, s) => {
+  const a = t?.axes?.[i];
+  s && a !== void 0 ? a.maximum = e : !s && a !== void 0 && (a.minimum = e);
+}, kt = (t) => _(t, 1, !0), q = async (t, e) => {
+  await H(t, e, 1, !0);
+}, Nt = (t) => _(t, 1, !1), M = async (t, e) => {
+  await H(t, e, 1, !1);
+}, vt = (t) => _(t, 0, !0), _e = async (t, e) => {
+  await H(t, e, 0, !0);
+}, It = (t) => _(t, 0, !1), He = async (t, e) => {
+  await H(t, e, 0, !1);
+}, Ge = (t) => t.axes?.[0]?.valueFormat ?? Q(), Je = async (t, e) => {
+  const i = await pe(t, 0);
+  if (i !== void 0 && e !== void 0) {
+    const s = {
+      ...i,
+      valueFormat: e
+    };
+    ge(t, s, 0);
+  }
+}, Vt = (t) => {
+  let e;
+  return Xe(t.axes?.[1]?.valueFormat) && (e = t.axes?.[1]?.valueFormat), e;
+}, Ot = async (t, e) => {
+  const i = await pe(t, 1);
+  if (i !== void 0 && e !== void 0) {
+    const s = {
+      ...i,
+      valueFormat: e
+    };
+    ge(t, s, 1);
+  }
+}, oe = (t, e, i) => {
+  const s = t.axes?.[e];
+  s !== void 0 && (s.integerOnlyValues = i);
+}, Qe = (t) => {
+  let e = S.xAxisAsc;
+  const i = t.orderOptions?.data?.orderType ?? L.Category, s = t.orderOptions?.data?.orderBy ?? N.Ascending;
+  return i === L.Category && Array.isArray(s) ? e = S.customSort : i === L.Category ? s === N.Ascending ? e = S.xAxisAsc : e = S.xAxisDesc : s === N.Ascending ? e = S.yAxisAsc : e = S.yAxisDesc, e;
+}, Ze = (t) => {
+  const e = ue(t.series);
+  let i = !1;
+  return (e === U.BarSeries || e === U.LineSeries) && (i = Qe(t) === S.customSort), i;
+}, Dt = (t) => {
+  let e = [];
+  const i = t.orderOptions?.data?.orderType;
+  return Ze(t) && i === L.Category && (e = t.orderOptions?.data?.orderBy), e;
+}, qt = (t, e, i) => {
+  let s = L.Category, a = N.Ascending;
+  const r = ue(e.series);
+  e.orderOptions ??= {}, t === S.customSort && i !== void 0 ? (a = [...i], e.orderOptions.data = {
+    orderType: s,
+    orderBy: a
+  }) : (r === U.BarSeries || r === U.LineSeries) && (s = t === S.xAxisAsc || t === S.xAxisDesc ? L.Category : L.YValue, a = t === S.xAxisAsc || t === S.yAxisAsc ? N.Ascending : N.Descending, e.orderOptions.data = {
+    orderType: s,
+    orderBy: a
+  });
+}, P = (t) => t?.series?.[0]?.x ?? "", et = (t) => {
+  let e;
+  const i = t.series[0];
+  return I(i) && (e = i.temporalBinning?.size), e;
+}, tt = (t) => {
+  let e;
+  const i = t.series[0];
+  return I(i) && (e = i.temporalBinning?.unit), e;
+}, it = (t) => {
+  let e;
+  const i = t.series[0];
+  return I(i) && (e = i.temporalBinning?.timeAggregationType), e;
+}, st = (t) => {
+  let e;
+  const i = t.series[0];
+  return I(i) && (e = i.temporalBinning?.trimIncompleteTimeInterval), e;
+}, at = (t) => {
+  let e;
+  const i = t.series[0];
+  return I(i) && (e = i.temporalBinning?.nullPolicy), e;
+}, Fe = (t, e) => {
+  e?.series?.forEach((i) => {
+    I(i) && (i.temporalBinning ??= { type: K.FixedDateBased }, i.temporalBinning.size = t);
+  }), M(e, null), q(e, null);
+}, rt = (t, e) => {
+  e?.series?.forEach((i) => {
+    I(i) && (i.temporalBinning ??= { type: K.FixedDateBased }, i.temporalBinning.nullPolicy = t);
+  }), M(e, null), q(e, null);
+}, Mt = (t, e) => {
+  e.series?.forEach((i) => {
+    I(i) && (i.temporalBinning ??= { type: K.FixedDateBased }, i.temporalBinning.unit = t);
+  }), M(e, null), q(e, null);
+}, jt = (t, e) => {
+  e.series?.forEach((i) => {
+    I(i) && (i.temporalBinning ??= { type: K.FixedDateBased }, i.temporalBinning.timeAggregationType = t);
+  }), M(e, null), q(e, null);
+}, Ut = (t, e) => {
+  e.series?.forEach((i) => {
+    I(i) && (i.temporalBinning ??= { type: K.FixedDateBased }, i.temporalBinning.trimIncompleteTimeInterval = t);
+  }), M(e, null), q(e, null);
+}, $t = (t) => {
+  Fe(0, t);
+};
+async function lt(t) {
+  const {
+    config: e,
+    layer: i,
+    xAxisField: s,
+    splitByField: a,
+    layerFieldsInfo: r,
+    aggregationFields: n,
+    aggregationType: l,
+    fetchNullValues: o
+  } = t, y = r.filter((f) => f.name === a)[0]?.type, c = o !== !0 ? `${a} IS NOT NULL` : "", b = s && o !== !0 ? `${s} IS NOT NULL` : "", { where: g } = e?.dataFilters ?? {}, u = {
+    where: ye([g, c, b]),
+    // excluding the null values from the list
+    orderByFields: Me(a) ? [] : [`${a} ${N.Ascending}`],
+    // default sorting ascending for split-by field
+    geometry: e?.dataFilters?.geometry
+  }, x = i;
+  let p = "";
+  n.length === 0 ? p = x?.objectIdField ?? "" : [p] = n;
+  const F = l !== void 0 ? `${l}_${p}` : "";
+  let A = await me({
+    queryObject: x,
+    category: e?.series[0].x ?? "",
+    splitByField: a,
+    queryConfig: u
+  });
+  if (e) {
+    const f = e?.series.map((T) => te({ where: T.query?.where })?.toString() ?? "").filter((T) => T !== void 0 && T !== "");
+    A = je({
+      arrayA: A,
+      arrayB: f,
+      getKey: (T) => T.toString()
+    });
+  }
+  return { categoriesArray: A, fieldName: F, splitByFieldType: y, numericalField: p };
+}
+function Et(t, e) {
+  let i = e === "";
+  for (const s of t)
+    if (e === s.name) {
+      i = !0;
+      break;
+    }
+  return i;
+}
+function Kt(t, e) {
+  const i = qe(t);
+  let s = e.length === 0, a = 0;
+  for (const r of e) {
+    for (const n of i)
+      if (r === n && (a += 1), a === e.length) {
+        s = !0;
+        break;
+      }
+    if (s)
+      break;
+  }
+  return s;
+}
+function Pt(t, e) {
+  e.forEach((i) => {
+    Object.getOwnPropertyNames(i.prototype).forEach((s) => {
+      Object.defineProperty(
+        t.prototype,
+        s,
+        Object.getOwnPropertyDescriptor(i.prototype, s) || /* @__PURE__ */ Object.create(null)
+      );
+    });
+  });
+}
+async function ot(t) {
+  const { layerInfo: e, config: i, category: s } = t, { layer: a } = e, { where: r } = i?.dataFilters ?? {}, { fetchNullValues: n } = i?.series?.[0]?.query ?? {}, l = n !== !0 ? `${s} IS NOT NULL` : "", o = {
+    where: ye([r, l]),
+    // excluding the null values from the list
+    orderByFields: [],
+    geometry: i?.dataFilters?.geometry
+  }, m = Z(a);
+  return (
+    // fetch unique category values asynchronously
+    (await me({ queryObject: a, category: s, queryConfig: o })).map((c) => {
+      const b = String(c);
+      return ee({
+        fieldName: s,
+        fieldValueToMatch: b,
+        subtypeInfo: m,
+        // use the retrieved subtype information
+        fieldList: e.layerFieldsInfo
+        // list of field information from the layer
+      }) ?? b;
+    })
+  );
+}
+async function X(t) {
+  const { seriesIndex: e, config: i, layerInfo: s } = t, { objectIdField: a } = s ?? {};
+  let r;
+  const n = i.series[e ?? 0];
+  let l = !1, o = !1;
+  if (n === void 0) {
+    const g = i.series;
+    l = g.slice(0, e).every((u) => w(u)), o = g.slice(0, e).every((u) => C(u));
+  } else
+    l = w(n), o = C(n);
+  l ? r = await Pe({
+    seriesIndex: e,
+    objectIDField: a
+  }) : o ? r = await We({
+    seriesIndex: e,
+    objectIDField: a
+  }) : r = await Re({
+    seriesIndex: e,
+    objectIDField: a
+  });
+  const m = P(i), y = i.series[0]?.dataLabels?.visible ?? !1, c = {
+    ...r,
+    x: m,
+    y: "",
+    dataLabels: {
+      ...r.dataLabels,
+      type: r.dataLabels?.type ?? U.Text,
+      content: r.dataLabels?.content ?? { type: Te.TS },
+      visible: y
+    }
+  }, b = D(i);
+  if (c.query = {
+    groupByFieldsForStatistics: [m]
+  }, b !== h.NoAggregation && a !== void 0) {
+    const g = `${b}_${a}_0`.toUpperCase();
+    c.y = g, c.query.outStatistics = [
+      {
+        statisticType: b,
+        onStatisticField: a,
+        outStatisticFieldName: g
+      }
+    ];
+  }
+  if (w(c) || C(c)) {
+    let g;
+    if (i?.series?.[0] !== void 0 && (g = z(i.series)), g !== $.BarAndLineNoAggregation && g !== $.BarAndLineSplitByNoAggregation) {
+      let u = tt(i);
+      u === Be.Quarter && (u = we.Month), c.temporalBinning = {
+        type: K.FixedDateBased,
+        size: et(i),
+        unit: u,
+        timeAggregationType: it(i),
+        trimIncompleteTimeInterval: st(i),
+        nullPolicy: at(i)
+      };
+    }
+  }
+  return ke(c);
+}
+async function G(t, e) {
+  const { layerFieldsInfo: i, objectIdField: s } = e, a = P(t), r = z(t.series), n = v(t), l = D(t), o = E(t), m = n.length === 0 || n.includes(s), y = await de(l), c = m ? "" : n.map((f) => j(i ?? [], f)).join(", "), b = j(i ?? [], a), g = j(i ?? [], o), u = t.series.some((f) => k(f)), x = u ? "category" : "xAxisField", p = b;
+  let F = "";
+  const A = await ie();
+  if (r === $.BarAndLineFromFields)
+    F = O(A.titleLabels.aggrTypeOfAggrFields, {
+      aggregationType: y,
+      aggregationFields: c
+    });
+  else if (l === h.NoAggregation) {
+    const f = m ? s : c;
+    if (o === "") {
+      const T = u ? "aggrTypeCategory" : "aggrTypeXAxisField";
+      F = O(A.titleLabels[T], {
+        aggregationType: f,
+        [x]: p
+      });
+    } else {
+      const T = u ? "aggrTypeCategoryBySplitBy" : "aggrTypeXAxisFieldBySplitBy";
+      F = O(A.titleLabels[T], {
+        aggregationType: f,
+        [x]: p,
+        splitByField: g
+      });
+    }
+  } else if (l === h.Count)
+    if (o === "") {
+      const f = u ? "aggrTypeCategory" : "aggrTypeXAxisField";
+      F = O(A.titleLabels[f], {
+        aggregationType: y,
+        [x]: p
+      });
+    } else {
+      const f = u ? "aggrTypeCategoryBySplitBy" : "aggrTypeXAxisFieldBySplitBy";
+      F = O(A.titleLabels[f], {
+        aggregationType: y,
+        [x]: p,
+        splitByField: g
+      });
+    }
+  else if (o !== "") {
+    const f = u ? "aggrTypeOfAggrFieldByCategoryBySplitByField" : "aggrTypeOfAggrFieldByXAxisFieldBySplitByField";
+    F = O(A.titleLabels[f], {
+      aggregationType: y,
+      aggregationField: c,
+      [x]: p,
+      splitByField: g
+    });
+  } else if (n.length > 0) {
+    const f = u ? "aggrTypeOfAggrFieldsByCategory" : "aggrTypeOfAggrFieldsByXAxisField";
+    F = O(A.titleLabels[f], {
+      aggregationType: y,
+      aggregationFields: c,
+      [x]: p
+    });
+  }
+  return F;
+}
+const fe = (t) => te({
+  where: t.query?.where,
+  normalize: !1,
+  escape: !1
+}) ?? "", D = (t) => t?.series?.[0]?.query?.outStatistics?.[0]?.statisticType ?? h.NoAggregation, Wt = async (t, e, i) => {
+  const s = v(e), a = E(e);
+  await ae({
+    splitByField: a,
+    numericFields: s,
+    aggregationType: t,
+    config: e,
+    layerInfo: i
+  });
+  const r = await Y({
+    config: e,
+    layerInfo: i,
+    numericFields: v(e),
+    aggregationType: D(e)
+  });
+  R(e, 1, r), e.title && (e.title.content.text = await G(e, i)), await M(e, null), await q(e, null), se(e, i);
+}, E = ce(
+  (t) => {
+    const e = t?.series?.[0]?.query?.where?.split("=")[0].trim() ?? "";
+    return Ue(t?.series?.[0]?.query?.where) ? "" : e;
+  },
+  (t) => t?.series?.[0]?.query?.where
+), Rt = async (t, e, i) => {
+  const s = v(e), a = D(e);
+  await ae({
+    splitByField: t,
+    numericFields: s,
+    aggregationType: a,
+    config: e,
+    layerInfo: i
+  });
+  const r = await Y({
+    config: e,
+    layerInfo: i,
+    numericFields: v(e),
+    aggregationType: D(e)
+  });
+  R(e, 1, r), e.title && (e.title.content.text = await G(e, i)), await M(e, null), await q(e, null);
+}, v = ce(
+  // without memoizing, the worst case efficiency is O(series.length), best case is O(1)
+  // with memoizing, the worst case efficiency for repeated calls becomes O(1)
+  (t) => {
+    let e = [];
+    if (E(t) === "")
+      e = t?.series.map((i) => {
+        const s = i.query?.outStatistics?.map((a) => a.onStatisticField) ?? [];
+        return s?.length > 0 ? s : i.y;
+      }).flat() ?? [];
+    else {
+      const i = t?.series?.[0], s = i?.query?.outStatistics?.[0]?.onStatisticField ?? [i?.y].flat()[0];
+      e = s !== void 0 ? [s] : [];
+    }
+    return [...new Set(e.filter((i) => i !== ""))];
+  },
+  // using series array address as key, since a change to the numeric fields will always rebuild a fresh series array
+  (t) => t?.series
+), nt = async (t, e, i) => {
+  const { objectIdField: s } = i;
+  let a = D(e);
+  t.length === 0 ? (t.push(s), a = h.Count) : a === h.Count && t.length >= 1 && !t.includes(s) && (a = h.Sum);
+  const r = E(e);
+  await ae({
+    splitByField: r,
+    numericFields: t,
+    aggregationType: a,
+    config: e,
+    layerInfo: i
+  });
+  const n = await Y({
+    config: e,
+    layerInfo: i,
+    numericFields: v(e),
+    aggregationType: D(e)
+  });
+  R(e, 1, n), e.title && (e.title.content.text = await G(e, i)), await M(e, null), await q(e, null), se(e, i);
+}, Xt = async (t, e, i) => {
+  const { layerFieldsInfo: s } = i ?? {}, a = e?.series?.length ?? 0, r = P(e);
+  let n;
+  const l = e.series.some((c) => k(c)), o = ze(e.series), m = Ye(e.series);
+  if (s !== void 0) {
+    const c = $e(s);
+    !c.includes(r) && c.includes(t) ? n = Ee() : c.includes(r) && !c.includes(t) && (l ? n = Q() : n = Ke()), s.find((g) => g.name === t)?.type === ne.String && (n = Q()), n !== void 0 && await Je(e, n);
+  }
+  a === 0 && (e.series = [await X({ config: e, layerInfo: i })]), e.series.forEach((c) => {
+    c.x = t, c.query !== void 0 && (c.query.groupByFieldsForStatistics = [t]);
+  });
+  const y = j(s, t);
+  if (R(e, 0, y), i !== void 0) {
+    const c = await Y({
+      config: e,
+      layerInfo: i,
+      numericFields: v(e),
+      aggregationType: D(e)
+    });
+    R(e, 1, c), e.title && (e.title.content.text = await G(e, i)), se(e, i);
+    const b = v(e);
+    await nt(b, e, i);
+  }
+  if (await M(e, null), await q(e, null), o || m) {
+    await He(e, null), await _e(e, null), Fe(0, e);
+    const c = n?.type === U.DateAxisFormat ? re.Null : re.Interpolate;
+    rt(c, e);
+  }
+};
+function se(t, e) {
+  let i = !1;
+  const s = D(t), a = v(t);
+  s === h.Count ? i = !0 : s === h.NoAggregation && (i = a.every((l) => {
+    const o = e.layerFieldsInfo.find((m) => m.name === l);
+    return o !== void 0 ? le(o) : !1;
+  })), oe(t, 1, i);
+  const r = t.series.some((l) => w(l)), n = t.series.some((l) => C(l));
+  if (r || n) {
+    const l = P(t), o = e.layerFieldsInfo.find((y) => y.name === l), m = o !== void 0 && le(o);
+    oe(t, 0, m);
+  }
+}
+const ct = (t) => {
+  let e = S.xAxisAsc;
+  const i = t.orderOptions?.data?.orderType ?? L.Category, s = t.orderOptions?.data?.orderBy ?? N.Ascending;
+  return i === L.Category && Array.isArray(s) ? e = S.customSort : i === L.Category ? s === N.Ascending ? e = S.xAxisAsc : e = S.xAxisDesc : s === N.Ascending ? e = S.yAxisAsc : e = S.yAxisDesc, e;
+};
+async function dt(t) {
+  const { numericFields: e, aggregationType: i, config: s, layerInfo: a } = t;
+  let r = !1;
+  const n = await X({
+    config: s,
+    layerInfo: a,
+    seriesIndex: 0
+  }), l = await ie(), o = {
+    ...n,
+    id: `series_${Date.now()}`,
+    name: l.axisLabels.values,
+    x: W,
+    y: Ce
+  }, m = [];
+  for (const c of e)
+    m.push({
+      onStatisticField: c,
+      outStatisticFieldName: `${c}_0`.toUpperCase(),
+      statisticType: i
+    });
+  o.query = { outStatistics: m };
+  const y = s.series[0];
+  return y !== void 0 && (o.id = y.id, s.colorMatch || (k(y) && k(o) ? o.fillSymbol = y.fillSymbol : (w(o) && w(y) || C(o) && C(y)) && (o.lineSymbol = y.lineSymbol, o.markerSymbol = y.markerSymbol), r = !0), o.id = y.id, y.name !== n.name && (o.name = y.name)), s.series.length === 1 && !s.colorMatch && (k(o) ? o.fillSymbol = s.series[0].fillSymbol : (w(o) || C(o)) && (o.lineSymbol = s.series[0].lineSymbol, o.markerSymbol = s.series[0].markerSymbol), r = !0), s.colorMatch = !r, [o];
+}
+async function Se(t) {
+  const { numericFields: e, aggregationType: i, config: s, layerInfo: a } = t, { layerFieldsInfo: r, objectIdField: n } = a, l = [];
+  let o = !1;
+  const m = e.map((y, c) => `${i}_${y}_${c}`.toUpperCase());
+  for (let y = 0; y < e.length; y += 1) {
+    const c = await X({
+      config: s,
+      layerInfo: a,
+      seriesIndex: y
+    }), b = m[y].toUpperCase(), g = e[y];
+    let u = {
+      ...c,
+      query: {
+        ...c.query
+      }
+    };
+    g !== n && (u = {
+      ...u,
+      id: g,
+      name: j(r, g)
+    });
+    let x = g;
+    u.query !== void 0 && (i !== h.NoAggregation ? (x = b, u.query.outStatistics = [
+      {
+        ...c.query?.outStatistics?.[0] ?? {},
+        onStatisticField: g,
+        outStatisticFieldName: b,
+        statisticType: i
+      }
+    ]) : delete u.query.outStatistics), u.y = x;
+    const p = s.series.find(
+      (F) => F.query?.outStatistics?.[0]?.onStatisticField === g && F.query.where === void 0
+    );
+    if (p !== void 0 && typeof p.y == "string" && p.y.trim() !== "") {
+      s.colorMatch || (k(u) && k(p) ? u.fillSymbol = p.fillSymbol : (w(u) && w(p) || C(u) && C(p)) && (u.lineSymbol = p.lineSymbol, u.markerSymbol = p.markerSymbol), o = !0);
+      const F = await X({
+        config: s,
+        layerInfo: a,
+        seriesIndex: y
+      });
+      u.id = p.id, p.id !== F.id && p.name !== F.name && (u.id = p.id, u.name = p.name);
+    }
+    l.push(u);
+  }
+  return s.series.length === 1 && l.length === 1 && !s.colorMatch && (k(s.series[0]) && k(l[0]) ? l[0].fillSymbol = s.series[0].fillSymbol : (w(s.series[0]) && w(l[0]) || C(s.series[0]) && C(l[0])) && (l[0].lineSymbol = s.series[0].lineSymbol, l[0].markerSymbol = s.series[0].markerSymbol), o = !0), s.colorMatch = !o, l;
+}
+async function yt(t) {
+  const { splitByField: e, numericFields: i, aggregationType: s, config: a, layerInfo: r } = t, { layer: n, layerFieldsInfo: l } = r, { fetchNullValues: o } = a?.series?.[0]?.query ?? {}, m = P(a), y = m !== W ? m : void 0, { categoriesArray: c, fieldName: b, splitByFieldType: g, numericalField: u } = await lt({
+    config: a,
+    layer: n,
+    layerFieldsInfo: l,
+    xAxisField: y,
+    aggregationFields: i,
+    aggregationType: s,
+    splitByField: e,
+    fetchNullValues: o
+  });
+  let x = [], p = !1;
+  if (c.length === 0) {
+    x = await Se({
+      numericFields: i,
+      aggregationType: s,
+      config: a,
+      layerInfo: r
+    });
+    for (const F of x)
+      F.query && (F.query.where = `${e}=''`);
+  } else
+    for (let F = 0; F < c.length; F += 1) {
+      const A = c[F], f = `${b}_${F}`.toUpperCase(), T = await X({
+        config: a,
+        layerInfo: r,
+        seriesIndex: F
+      }), be = {
+        fieldName: e,
+        fieldValueToMatch: A ?? "",
+        subtypeInfo: Z(r.layer),
+        fieldList: r.layerFieldsInfo
+      }, xe = ee(be), J = `${A}`, B = {
+        ...T,
+        id: J,
+        name: xe ?? J,
+        y: f,
+        query: {
+          ...T.query,
+          where: `${e}=${g === ne.String && A !== null ? `'${A}'` : A}`,
+          outStatistics: s !== h.NoAggregation ? [
+            {
+              ...T.query?.outStatistics?.[0] ?? {},
+              onStatisticField: u,
+              outStatisticFieldName: f,
+              statisticType: s
+            }
+          ] : void 0
+        }
+      };
+      s === h.NoAggregation && (B.query !== void 0 && (delete B.query.outStatistics, delete B.query.groupByFieldsForStatistics), B.y = u);
+      const V = a.series.find(
+        (Ae) => String(fe(Ae)).trim().replace(/'/gu, "") === J
+      );
+      V !== void 0 && (a.colorMatch || (k(B) && k(V) ? B.fillSymbol = V.fillSymbol : (w(B) && w(V) || C(B) && C(V)) && (B.lineSymbol = V.lineSymbol, B.markerSymbol = V.markerSymbol), p = !0), B.id = V.id, B.name = V.name), x.push(B);
+    }
+  return a.colorMatch = !p, x;
+}
+const ae = async (t) => {
+  const { splitByField: e, numericFields: i, aggregationType: s, config: a, layerInfo: r } = t, { x: n } = a.series[0], l = z(a.series);
+  e === "" || i.length > 1 ? n === W || n === void 0 || n.trim() === "" || l === $.BarAndLineFromFields ? a.series = await dt({
+    config: a,
+    layerInfo: r,
+    numericFields: i,
+    aggregationType: s
+  }) : a.series = await Se({
+    config: a,
+    layerInfo: r,
+    numericFields: i,
+    aggregationType: s
+  }) : a.series = await yt({
+    config: a,
+    layerInfo: r,
+    splitByField: e,
+    numericFields: i,
+    aggregationType: s
+  });
+}, zt = (t) => {
+  const { config: e, seriesIndex: i, layerInfo: s, commonStrings: a } = t, r = e.series?.[i], n = E(e);
+  let l;
+  if (z(e.series) === $.BarAndLineFromFields)
+    l = a.axisLabels.values;
+  else if (Le(n)) {
+    const m = r.query?.outStatistics?.[0]?.onStatisticField;
+    m !== void 0 && m !== s.objectIdField && (l = j(s.layerFieldsInfo, m));
+  } else {
+    const m = String(fe(r)).trim().replace(/'/gu, ""), y = {
+      fieldName: E(e),
+      fieldValueToMatch: m ?? "",
+      subtypeInfo: Z(s.layer),
+      fieldList: s.layerFieldsInfo
+    };
+    l = ee(y) ?? m;
+  }
+  return l ?? r.id;
+}, Yt = (t, e) => {
+  e.orderOptions ??= {};
+  const i = e.orderOptions?.data?.orderType;
+  ct(e) === S.customSort && i === L.Category && (e.orderOptions.data = {
+    orderType: L.Category,
+    orderBy: [...t]
+  });
+}, _t = (t) => t.dataFilters, Ht = (t, e) => {
+  t !== void 0 ? e.dataFilters = t : delete e.dataFilters;
+}, Gt = async (t, e) => {
+  const i = P(t), s = Ge(t)?.type, a = v(t), r = z(t.series);
+  let n = [];
+  return s === U.CategoryAxisFormat && (r === $.BarAndLineFromFields || i === W ? n = a.map((l) => j(e?.layerFieldsInfo, l)) : i.trim() !== "" && i !== W && e !== void 0 && (n = await ot({
+    layerInfo: e,
+    config: t,
+    category: i
+  }))), n;
+}, Jt = (t, e) => {
+  e.series.forEach((i) => {
+    i.query && (i.query.fetchNullValues = t);
+  });
+}, Qt = (t) => t.series.some((e) => e.query?.fetchNullValues), Zt = (t) => (
+  // TODO: Look into split-by values gotchas cases once done
+  t.series.map((e) => String(te({ where: e.query?.where }))).filter((e) => e !== void 0 && e.trim() !== "")
+);
+export {
+  jt as A,
+  st as B,
+  Ut as C,
+  at as D,
+  rt as E,
+  $t as F,
+  Xt as G,
+  nt as H,
+  Wt as I,
+  Rt as J,
+  _t as K,
+  Ht as L,
+  ct as M,
+  Gt as N,
+  qt as O,
+  Dt as P,
+  Yt as Q,
+  ae as R,
+  Jt as S,
+  Qt as T,
+  vt as U,
+  It as V,
+  kt as W,
+  Nt as X,
+  Vt as Y,
+  Ot as Z,
+  _e as a,
+  M as b,
+  q as c,
+  zt as d,
+  Pt as e,
+  ie as f,
+  Y as g,
+  Et as h,
+  Kt as i,
+  Je as j,
+  Ge as k,
+  ot as l,
+  lt as m,
+  oe as n,
+  P as o,
+  D as p,
+  v as q,
+  Zt as r,
+  He as s,
+  E as t,
+  R as u,
+  et as v,
+  Fe as w,
+  tt as x,
+  Mt as y,
+  it as z
+};