@geoscene/charts-components 5.0.19

package/dist/cdn/ED7V65WK.js

@@ -0,0 +1,471 @@
+/* COPYRIGHT  - https://js.geoscene.cn/5.0/LICENSE.txt */
+import g from "./AENRD2JF.js";
+import e from "./P4UNBBUE.js";
+import c from "./DKENL7TV.js";
+import b from "./P5SSZWMH.js";
+import a from "./A7YNU2NS.js";
+import { B as z, d as $, g as E, m as R, q as _ } from "./4B3QBH5T.js";
+import { d, e as m } from "./KUVOINJC.js";
+import { a as j, b as u, h as F, v as f } from "./NKG4FLLR.js";
+export default $geoscene.t(
+  ([
+    ,
+    ,
+    ,
+    { substitute: A },
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    { Gb: N, Ia: U, Nc: O, Wd: w, aa: G, d: T, e: B, ta: K },
+    { a: h, b: L },
+    { c: k },
+    { a: Y },
+    { g: X },
+  ]) => {
+    function x(r) {
+      let { config: t, layerInfo: e, mode: o, commonStrings: i } = r,
+        a =
+          e !== void 0
+            ? q({ config: t, layerInfo: e, commonStrings: i, mode: o })
+            : "",
+        g = Y(t),
+        l = w(t);
+      return a === g || l;
+    }
+    function V(r) {
+      let { config: t, layerInfo: e, mode: o, commonStrings: i } = r,
+        a =
+          e !== void 0
+            ? L({
+                config: t,
+                layerInfo: e,
+                commonStrings: i,
+                numericFields: S(t),
+                aggregationType: b(t, o),
+              })
+            : "",
+        g = k(1, t),
+        l = w(t);
+      return a === g || l;
+    }
+    var P = (r) => r.series?.[0]?.x ?? "";
+    function W(r, t) {
+      let e = r.series?.[0];
+      return [`${t === m.Category ? e.y : B} ${F.Descending}`];
+    }
+    var H = (r, t) => {
+        let e = d.valueDesc,
+          o = r.orderOptions?.data?.orderType ?? W(r, t),
+          i =
+            r.orderOptions?.data && "orderBy" in r.orderOptions.data
+              ? r.orderOptions.data.orderBy
+              : F.Descending;
+        return (
+          o === f.Category && Array.isArray(i)
+            ? (e = d.customSort)
+            : o === f.Category
+            ? i === F.Ascending
+              ? (e = d.labelAsc)
+              : (e = d.labelDesc)
+            : i === F.Ascending
+            ? (e = d.valueAsc)
+            : (e = d.valueDesc),
+          e
+        );
+      },
+      S = $(
+        (r) => {
+          let t = [];
+          return (
+            (t = r.series?.[0]?.query?.outStatistics?.map(
+              (e) => e.onStatisticField
+            ) ?? [r.series?.[0]?.y ?? ""]),
+            [...new Set(t.filter((e) => e !== ""))]
+          );
+        },
+        (r) => r.series
+      ),
+      b = (r, t) => {
+        let e = S(r),
+          o;
+        return (
+          t === m.Fields && e.length === 0
+            ? (o = u.Sum)
+            : (o =
+                r.series?.[0]?.query?.outStatistics?.[0]?.statisticType ??
+                u.NoAggregation),
+          o
+        );
+      };
+    function J(r) {
+      let { config: t, layerInfo: e, mode: o, commonStrings: i } = r,
+        a = O(e?.layer).idField,
+        g = K(i, a),
+        l = P(t),
+        c = t.series[0]?.dataLabels,
+        n = {
+          ...g,
+          x: o === m.Category ? l : T,
+          slices: t.series?.[0]?.slices,
+          dataLabels: {
+            ...g.dataLabels,
+            type: g.dataLabels?.type ?? j.Text,
+            content: { ...g.dataLabels?.content, ...c?.content, type: z.TS },
+            visible: c?.visible ?? !1,
+          },
+          innerRadiusSize: t.series?.[0]?.innerRadius,
+          sliceGrouping: t.series?.[0]?.sliceGrouping,
+          dataLabelsCharacterLimit: t.series?.[0]?.dataLabelsCharacterLimit,
+          numericValueFormat: t.series?.[0]?.numericValueFormat,
+          percentValueFormat: t.series?.[0]?.percentValueFormat,
+          displayCategoryOnDataLabel: t.series?.[0]?.displayCategoryOnDataLabel,
+          displayNumericValueOnDataLabel:
+            t.series?.[0]?.displayNumericValueOnDataLabel,
+          displayPercentageOnDataLabel:
+            t.series?.[0]?.displayPercentageOnDataLabel,
+        },
+        s = b(t, o);
+      if (s !== u.NoAggregation && a !== void 0) {
+        let y = `${s}_${a}_0`.toUpperCase();
+        (n.y = o === m.Category ? y : B),
+          (n.query = {
+            outStatistics:
+              o === m.Category
+                ? [
+                    {
+                      statisticType: s,
+                      onStatisticField: a,
+                      outStatisticFieldName: y,
+                    },
+                  ]
+                : [],
+          });
+      }
+      return (
+        o === m.Category && n.query !== void 0
+          ? (n.query.groupByFieldsForStatistics = [l])
+          : delete n.query?.groupByFieldsForStatistics,
+        E(n)
+      );
+    }
+    function q(r) {
+      let { config: t, layerInfo: e, mode: o, commonStrings: i } = r,
+        { layerFieldsInfo: a } = e,
+        { idField: g, isTraditionalTypeOID: l } = O(e.layer),
+        c = P(t),
+        n = S(t),
+        s = b(t, o),
+        y = l && (n.length === 0 || n.includes(g)),
+        p = U(s, i),
+        D = y ? "" : n.map((Q) => N(a ?? [], Q)).join(", "),
+        I = N(a ?? [], c),
+        C = "",
+        v;
+      return (
+        o === m.Fields ? (v = n.length === 0) : (v = c === ""),
+        v
+          ? (C = i.utilsStrings.chartType.pieChart)
+          : s === u.NoAggregation
+          ? (C = A(i.titleLabels.aggrFieldsByCategory, {
+              aggregationFields: y ? g : D,
+              category: I,
+            }))
+          : s === u.Count
+          ? (C = A(i.titleLabels.aggrTypeCategory, {
+              aggregationType: p,
+              category: I,
+            }))
+          : n.length > 0 &&
+            (I === T || R(I) || _(I)
+              ? (C = A(i.titleLabels.aggrTypeOfAggrFields, {
+                  aggregationType: p,
+                  aggregationFields: D,
+                }))
+              : (C = A(i.titleLabels.aggrTypeOfAggrFieldsByCategory, {
+                  aggregationType: p,
+                  aggregationFields: D,
+                  category: I,
+                }))),
+        C
+      );
+    }
+    var Ae = (r) => {
+        let { newSortOrderKind: t, config: e, orderByList: o } = r;
+        (e.orderOptions ??= {}),
+          t === d.customSort && o !== void 0
+            ? (e.orderOptions.data = { orderType: f.Category, orderBy: [...o] })
+            : (e.orderOptions.data = {
+                orderType:
+                  t === d.labelAsc || t === d.labelDesc ? f.Category : f.YValue,
+                orderBy:
+                  t === d.labelAsc || t === d.valueAsc
+                    ? F.Ascending
+                    : F.Descending,
+              });
+      },
+      qe = (r) => {
+        let {
+            newCategory: t,
+            config: e,
+            layerInfo: o,
+            mode: i,
+            commonStrings: a,
+          } = r,
+          g = e.series?.length ?? 0,
+          l = x({ config: e, layerInfo: o, commonStrings: a, mode: i }),
+          c = V({ config: e, layerInfo: o, commonStrings: a, mode: i });
+        if (
+          (e.series.forEach((n) => {
+            (n.x = i === m.Category ? t : T),
+              n.query !== void 0 && t !== T
+                ? (n.query.groupByFieldsForStatistics = [t])
+                : delete n.query?.groupByFieldsForStatistics;
+          }),
+          g === 0)
+        ) {
+          let n = [J({ config: e, layerInfo: o, mode: i, commonStrings: a })];
+          e.series = n;
+        }
+        if (o !== void 0) {
+          if (c) {
+            let s = L({
+              config: e,
+              layerInfo: o,
+              numericFields: S(e),
+              aggregationType: b(e, i),
+              commonStrings: a,
+            });
+            h(e, 1, s);
+          }
+          e.title &&
+            l &&
+            (e.title.content.text = q({
+              config: e,
+              layerInfo: o,
+              commonStrings: a,
+              mode: i,
+            }));
+          let n =
+            i === m.Fields
+              ? S(e).filter((s) => s !== O(o.layer).idField)
+              : S(e);
+          Z({
+            newNumericFields: n,
+            config: e,
+            layerInfo: o,
+            mode: i,
+            commonStrings: a,
+          });
+        }
+      };
+    function M(r) {
+      let {
+          numericFields: t,
+          aggregationType: e,
+          config: o,
+          layerInfo: i,
+          mode: a,
+          commonStrings: g,
+        } = r,
+        { layerFieldsInfo: l } = i,
+        c = [],
+        n = J({ config: o, layerInfo: i, mode: a, commonStrings: g }),
+        s = { ...n, query: { ...n.query } };
+      t.length <= 1 ? (s.query.where = n.query?.where) : delete s.query.where;
+      let y = X({
+        config: o,
+        xAxisField: P(o),
+        numericFields: t,
+        aggregationType: e,
+        mode: a,
+        layer: i.layer,
+        fieldList: l,
+      }).name;
+      if (e !== u.NoAggregation)
+        if (a === m.Category) {
+          if (t.length > 0) {
+            let p = t[0];
+            s.query.outStatistics = [
+              {
+                ...(n.query?.outStatistics?.[0] ?? {}),
+                onStatisticField: p,
+                outStatisticFieldName: y,
+                statisticType: e,
+              },
+            ];
+          }
+        } else
+          for (let p of t)
+            s.query.outStatistics?.push({
+              onStatisticField: p,
+              outStatisticFieldName: p,
+              statisticType: e,
+            });
+      else s.query = {};
+      (s.y = y), c.push(s), (o.series = c);
+    }
+    var De = (r) => {
+        let {
+            newAggregationType: t,
+            config: e,
+            layerInfo: o,
+            mode: i,
+            commonStrings: a,
+          } = r,
+          g = S(e),
+          l = x({ config: e, layerInfo: o, commonStrings: a, mode: i }),
+          c = V({ config: e, layerInfo: o, commonStrings: a, mode: i });
+        if (
+          (M({
+            config: e,
+            layerInfo: o,
+            numericFields: g,
+            aggregationType: t,
+            commonStrings: a,
+            mode: i,
+          }),
+          c)
+        ) {
+          let p = L({
+            config: e,
+            layerInfo: o,
+            commonStrings: a,
+            numericFields: S(e),
+            aggregationType: b(e, i),
+          });
+          h(e, 1, p);
+        }
+        e.title &&
+          l &&
+          (e.title.content.text = q({
+            config: e,
+            layerInfo: o,
+            commonStrings: a,
+            mode: i,
+          }));
+        let n = e.series?.[0]?.displayCategoryOnDataLabel,
+          s = e.series?.[0]?.displayNumericValueOnDataLabel,
+          y = e.series?.[0]?.displayPercentageOnDataLabel;
+        e.legend = {
+          ...(e.legend ?? G()),
+          displayNumericValue: s,
+          displayPercentage: y,
+          displayCategory: n,
+        };
+      },
+      Z = (r) => {
+        let { newNumericFields: t } = r,
+          { config: e, layerInfo: o, mode: i, commonStrings: a } = r,
+          g = O(o?.layer).idField,
+          l = b(e, i),
+          c = x({ config: e, layerInfo: o, commonStrings: a, mode: i }),
+          n = V({ config: e, layerInfo: o, commonStrings: a, mode: i });
+        if (
+          ((t = t === "" ? [] : t),
+          (t = typeof t == "string" ? [t] : t),
+          g !== void 0 &&
+            (t.length === 0 && i === m.Category
+              ? (t.push(g), (l = u.Count))
+              : l === u.Count &&
+                t.length >= 1 &&
+                !t.includes(g) &&
+                (l = u.Sum)),
+          o !== void 0)
+        ) {
+          if (
+            (M({
+              config: e,
+              layerInfo: o,
+              commonStrings: a,
+              numericFields: t,
+              aggregationType: l,
+              mode: i,
+            }),
+            n)
+          ) {
+            let s = L({
+              config: e,
+              layerInfo: o,
+              commonStrings: a,
+              numericFields: S(e),
+              aggregationType: b(e, i),
+            });
+            h(e, 1, s);
+          }
+          e.title &&
+            c &&
+            (e.title.content.text = q({
+              config: e,
+              layerInfo: o,
+              commonStrings: a,
+              mode: i,
+            }));
+        } else
+          e.series.forEach((s) => {
+            delete s.query, (s.y = t[0]);
+          });
+      },
+      ve = (r, t) => {
+        let e = [],
+          o = r.orderOptions?.data?.orderType,
+          i = H(r, t),
+          a =
+            r.orderOptions?.data && "orderBy" in r.orderOptions.data
+              ? r.orderOptions.data.orderBy
+              : void 0;
+        return (
+          i === d.customSort && o === f.Category && Array.isArray(a) && (e = a),
+          e
+        );
+      },
+      Be = (r) => {
+        let { values: t, config: e, mode: o } = r;
+        e.orderOptions ??= {};
+        let i = e.orderOptions?.data?.orderType;
+        H(e, o) === d.customSort &&
+          i === f.Category &&
+          (e.orderOptions.data = { orderType: f.Category, orderBy: [...t] });
+      };
+    return {
+      a: P,
+      b: H,
+      c: S,
+      d: b,
+      e: q,
+      f: Ae,
+      g: qe,
+      h: De,
+      i: Z,
+      j: ve,
+      k: Be,
+    };
+  },
+  "Graphic",
+  "renderers/support/jsonUtils",
+  "symbols/support/symbolUtils",
+  "intl",
+  "layers/support/FeatureFilter",
+  "smartMapping/statistics/histogram",
+  "smartMapping/statistics/summaryStatistics",
+  "request",
+  "core/sql",
+  "AttributeBinsGraphic",
+  "geometry/support/jsonUtils",
+  "rest/support/AttributeBinsQuery",
+  "rest/support/StatisticDefinition",
+  "time/TimeExtent",
+  "core/promiseUtils",
+  a,
+  b,
+  c,
+  e,
+  g
+);

package/dist/cdn/EEARIV73.js

@@ -0,0 +1,211 @@
+/* COPYRIGHT  - https://js.geoscene.cn/5.0/LICENSE.txt */
+import n from "./IJUDK7C2.js";
+import m from "./YIZBXVJZ.js";
+import l from "./BZA7GDEH.js";
+import k from "./A6QBN7CC.js";
+import j from "./AULQDYOE.js";
+import i from "./AQMOKQMS.js";
+import g from "./KP4ZXQIA.js";
+import f from "./V3CSEWPF.js";
+import e from "./P4UNBBUE.js";
+import d from "./DKENL7TV.js";
+import c from "./ISWZQ6CS.js";
+import b from "./P5SSZWMH.js";
+import "./UG7LOBJE.js";
+import a from "./A7YNU2NS.js";
+import "./4B3QBH5T.js";
+import "./XLDY6CTA.js";
+import "./IHRGRUHQ.js";
+import "./KUVOINJC.js";
+import { a as h } from "./NKG4FLLR.js";
+import "./KRZ433BT.js";
+import "./OR4HXHSY.js";
+export default $geoscene.t(
+  ([
+    { Ha: g },
+    { q: y },
+    { c: e },
+    ,
+    ,
+    z,
+    { b: X, d: Y, f: Z },
+    { b: K, d: Q, f: R },
+    { a: U, b: V },
+    { b: J },
+    { a: A, b: L, c: B, d: G },
+    { a: $, b: tt },
+    {
+      A: q,
+      a: p,
+      b: f,
+      c: c,
+      d: l,
+      e: d,
+      f: u,
+      g: v,
+      h: b,
+      i: _,
+      j: S,
+      k: w,
+      l: O,
+      m: D,
+      n: C,
+      o: M,
+      p: T,
+      q: E,
+      r: W,
+      s: F,
+      t: j,
+      u: x,
+      v: I,
+      w: N,
+      x: H,
+      y: P,
+      z: k,
+    },
+  ]) => {
+    var st = Object.defineProperty,
+      et = Object.getOwnPropertyDescriptor,
+      o = (a, t, i, rt) => {
+        for (var r = et(t, i), n = a.length - 1, m; n >= 0; n--)
+          (m = a[n]) && (r = m(t, i, r) || r);
+        return r && st(t, i, r), r;
+      },
+      s = class extends z {
+        constructor() {
+          super(...arguments), (this._chartType = h.HistogramSeries);
+        }
+        async setup(t) {
+          await this.loadConfigFromLayer(t),
+            typeof this.resolveSetup == "function" && this.resolveSetup();
+        }
+        get numericField() {
+          return f(this._config);
+        }
+        set numericField(t) {
+          c({
+            numericField: t,
+            config: this._config,
+            layerInfo: this.layerInfo,
+            commonStrings: this.commonStrings,
+          }),
+            this.dispatchEvent(
+              new CustomEvent("geosceneChartsModelDataChange")
+            );
+        }
+        get binCount() {
+          return u(this._config);
+        }
+        set binCount(t) {
+          v(t, this._config),
+            this.dispatchEvent(
+              new CustomEvent("geosceneChartsModelDataChange")
+            );
+        }
+        get binSymbol() {
+          return b(this._config);
+        }
+        set binSymbol(t) {
+          _(t, this._config);
+        }
+        get dataTransformationType() {
+          return l(this._config);
+        }
+        set dataTransformationType(t) {
+          d(t, this._config),
+            this.dispatchEvent(
+              new CustomEvent("geosceneChartsModelDataChange")
+            );
+        }
+        get meanSymbol() {
+          return O(this._config);
+        }
+        set meanSymbol(t) {
+          D(t, this._config);
+        }
+        get medianSymbol() {
+          return C(this._config);
+        }
+        set medianSymbol(t) {
+          M(t, this._config);
+        }
+        get normalDistSymbol() {
+          return S(this._config);
+        }
+        set normalDistSymbol(t) {
+          w(t, this._config);
+        }
+        get standardDevSymbol() {
+          return T(this._config);
+        }
+        set standardDevSymbol(t) {
+          E(t, this._config);
+        }
+        get showNormalDistOverlay() {
+          return W(this._config);
+        }
+        set showNormalDistOverlay(t) {
+          F(t, this._config);
+        }
+        get showMeanOverlay() {
+          return j(this._config);
+        }
+        set showMeanOverlay(t) {
+          x(t, this._config);
+        }
+        get showMedianOverlay() {
+          return I(this._config);
+        }
+        set showMedianOverlay(t) {
+          N(t, this._config);
+        }
+        get showStandardDevOverlay() {
+          return H(this._config);
+        }
+        set showStandardDevOverlay(t) {
+          P(t, this._config);
+        }
+        get seriesOverlays() {
+          return k(this._config);
+        }
+        set seriesOverlays(t) {
+          q(t, this._config);
+        }
+        generateChartTitle() {
+          return p(this._config, this.layerInfo, this.commonStrings);
+        }
+        generateDefaultConfig() {
+          return g(this.commonStrings);
+        }
+      };
+    o([e], s.prototype, "numericField");
+    o([e], s.prototype, "binCount");
+    o([e], s.prototype, "binSymbol");
+    o([e], s.prototype, "dataTransformationType");
+    o([e], s.prototype, "meanSymbol");
+    o([e], s.prototype, "medianSymbol");
+    o([e], s.prototype, "normalDistSymbol");
+    o([e], s.prototype, "standardDevSymbol");
+    o([e], s.prototype, "showNormalDistOverlay");
+    o([e], s.prototype, "showMeanOverlay");
+    o([e], s.prototype, "showMedianOverlay");
+    o([e], s.prototype, "showStandardDevOverlay");
+    o([e], s.prototype, "seriesOverlays");
+    var ot = [$, B, G, A, L, J, tt, X, V, Y, U, K, Q, R, Z];
+    y(s, ot);
+    return s;
+  },
+  a,
+  b,
+  c,
+  d,
+  e,
+  f,
+  g,
+  i,
+  j,
+  k,
+  l,
+  m,
+  n
+);