@geoscene/charts-components 5.0.19

package/dist/cdn/L2JT5DRD.js

@@ -0,0 +1,706 @@
+/* COPYRIGHT  - https://js.geoscene.cn/5.0/LICENSE.txt */
+import l from "./ED7V65WK.js";
+import k from "./AENRD2JF.js";
+import j from "./BZA7GDEH.js";
+import i from "./A6QBN7CC.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 { B as h, g as x } from "./4B3QBH5T.js";
+import "./XLDY6CTA.js";
+import { e as u, f as g } from "./KUVOINJC.js";
+import { a as p } from "./NKG4FLLR.js";
+import { k as I } from "./KRZ433BT.js";
+import "./OR4HXHSY.js";
+export default $geoscene.t(
+  ([
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    { Aa: T, D: y, Nc: F, Wd: N, Z: _, aa: f, gd: S, ra: b, ta: V, yb: m },
+    { p: M, q: O, r: w },
+    { c: s },
+    ,
+    ,
+    j,
+    { b: q },
+    { a: U, b: K, c: D, d: X },
+    ,
+    { a: L, b: A, c: G, d: k, e: W, f: B, g: z, h: E, i: R, j: v, k: C },
+  ]) => {
+    var $ = (i) => i.legend?.displayNumericValue ?? !1,
+      ee = (i, e) => {
+        e.series[0]?.type === p.PieSeries &&
+          (e.legend === void 0 && (e.legend = f()),
+          (e.legend.displayNumericValue = i));
+      },
+      ie = (i) => i.legend?.displayCategory ?? !1,
+      te = (i, e) => {
+        e.series[0]?.type === p.PieSeries &&
+          (e.legend === void 0 && (e.legend = f()),
+          (e.legend.displayCategory = i));
+      },
+      se = (i) => i.legend?.displayPercentage ?? !1,
+      re = (i, e) => {
+        e.series[0]?.type === p.PieSeries &&
+          (e.legend === void 0 && (e.legend = f()),
+          (e.legend.displayPercentage = i));
+      },
+      oe = (i) => i.legend?.labelMaxWidth ?? 200,
+      ae = (i, e) => {
+        e.series[0]?.type === p.PieSeries &&
+          (e.legend === void 0 && (e.legend = f()),
+          (e.legend.labelMaxWidth = i));
+      },
+      ne = (i) => i.legend?.valueLabelMaxWidth ?? 200,
+      le = (i, e) => {
+        e.series[0]?.type === p.PieSeries &&
+          (e.legend === void 0 && (e.legend = f()),
+          (e.legend.valueLabelMaxWidth = i));
+      },
+      ge = Object.defineProperty,
+      ce = Object.getOwnPropertyDescriptor,
+      P = (i, e, t, a) => {
+        for (var n = ce(e, t), l = i.length - 1, c; l >= 0; l--)
+          (c = i[l]) && (n = c(e, t, n) || n);
+        return n && ge(e, t, n), n;
+      },
+      d = class extends D {
+        getDisplayNumericValue() {
+          return $(this._config);
+        }
+        setDisplayNumericValue(e) {
+          ee(e, this._config);
+        }
+        getDisplayPercentage() {
+          return se(this._config);
+        }
+        setDisplayPercentage(e) {
+          re(e, this._config);
+        }
+        getLabelMaxWidth() {
+          return oe(this._config);
+        }
+        setLabelMaxWidth(e) {
+          ae(e, this._config);
+        }
+        get valueLabelMaxWidth() {
+          return ne(this._config);
+        }
+        set valueLabelMaxWidth(e) {
+          le(e, this._config), this.emitConfigUpdate("valueLabelMaxWidth");
+        }
+        get displayCategory() {
+          return ie(this._config);
+        }
+        set displayCategory(e) {
+          te(e, this._config), this.emitConfigUpdate("displayCategory");
+        }
+      };
+    P([s], d.prototype, "setDisplayNumericValue");
+    P([s], d.prototype, "setDisplayPercentage");
+    P([s], d.prototype, "setLabelMaxWidth");
+    var pe = [D];
+    O(d, pe);
+    var de = (i) => i.series?.[0]?.innerRadius,
+      fe = (i, e) => {
+        e.series?.[0] && (e.series[0].innerRadius = i);
+      },
+      he = (i) => i.series?.[0]?.dataLabelsCharacterLimit,
+      me = (i, e) => {
+        e.series?.[0] && (e.series[0].dataLabelsCharacterLimit = i);
+      },
+      H = (i) => i.series[0]?.startAngle,
+      ue = (i, e) => {
+        e.series?.[0] && (e.series[0].startAngle = i);
+      },
+      ye = (i, e) => {
+        e.series?.[0] && (e.series[0].endAngle = i);
+      },
+      _e = (i) => i.series?.[0]?.displayCategoryOnTooltip ?? !0,
+      be = (i) => i.series?.[0]?.displayCategoryOnDataLabel ?? !0,
+      Se = (i) => i.series?.[0]?.displayNumericValueOnDataLabel ?? !0,
+      Oe = (i) => i.series?.[0]?.displayPercentageOnDataLabel ?? !1,
+      Le = (i) => i.series?.[0]?.displayNumericValueOnTooltip ?? !0,
+      ve = (i) => i.series?.[0]?.displayPercentageOnTooltip ?? !0,
+      Ce = (i, e) => {
+        e.series[0] && (e.series[0].displayPercentageOnTooltip = i);
+      },
+      De = (i) => i.series?.[0]?.valuePrefix,
+      Pe = (i, e) => {
+        e.series?.[0] && (e.series[0].valuePrefix = i);
+      },
+      Ie = (i) => i.series?.[0]?.valueSuffix,
+      xe = (i, e) => {
+        e.series?.[0] && (e.series[0].valueSuffix = i);
+      },
+      Ve = (i) => i.series?.[0]?.percentagePrefix,
+      Te = (i, e) => {
+        e.series?.[0] && (e.series[0].percentagePrefix = i);
+      },
+      Fe = (i) => i.series?.[0]?.percentageSuffix,
+      Ne = (i, e) => {
+        e.series?.[0] && (e.series[0].percentageSuffix = i);
+      },
+      Me = (i) => {
+        let e,
+          t = i.series?.[0];
+        return (
+          t?.displayNumericValueOnDataLabel === !0 &&
+          t?.displayPercentageOnDataLabel === !0
+            ? (e = g.Both)
+            : t?.displayNumericValueOnDataLabel === !0
+            ? (e = g.Value)
+            : (e = g.Percentage),
+          e
+        );
+      },
+      we = (i, e) => {
+        let t = i === g.Value || i === g.Both,
+          a = i === g.Percentage || i === g.Both;
+        e.series?.[0] &&
+          ((e.series[0].displayNumericValueOnDataLabel = t),
+          (e.series[0].displayPercentageOnDataLabel = a)),
+          e.legend &&
+            (e.legend = {
+              ...e.legend,
+              displayNumericValue: t,
+              displayPercentage: a,
+            });
+      },
+      Ae = (i) => i.series?.[0]?.alignDataLabels ?? !1,
+      Ge = (i, e) => {
+        e.series[0] && (e.series[0].alignDataLabels = i);
+      },
+      ke = (i) => i.series?.[0]?.dataLabelsInside ?? !1,
+      We = (i, e) => {
+        e.series[0] && (e.series[0].dataLabelsInside = i);
+      },
+      Be = (i) => i.series?.[0]?.dataLabelsOffset ?? 10,
+      ze = (i, e) => {
+        e.series[0] && (e.series[0].dataLabelsOffset = i);
+      },
+      Ee = (i) =>
+        i.series?.[0]?.numericValueFormat?.intlOptions?.minimumFractionDigits,
+      Re = (i, e) => {
+        e.series?.[0] &&
+          ((e.series[0].numericValueFormat ??= _()),
+          (e.series[0].numericValueFormat.intlOptions.minimumFractionDigits =
+            i),
+          (e.series[0].numericValueFormat.intlOptions.maximumFractionDigits =
+            i),
+          (e.series[0].percentValueFormat ??= _()),
+          (e.series[0].percentValueFormat.intlOptions.minimumFractionDigits =
+            i),
+          (e.series[0].percentValueFormat.intlOptions.maximumFractionDigits =
+            i));
+      },
+      je = (i) => i.series?.[0]?.optimizeDataLabelsOverlapping ?? !1,
+      Ue = (i, e) => {
+        e.series[0] && (e.series[0].optimizeDataLabelsOverlapping = i);
+      },
+      Ke = (i) => i.series[0]?.ticks?.visible ?? !1,
+      Xe = (i, e) => {
+        e.series?.[0] &&
+          ((e.series[0].ticks ??= b()), (e.series[0].ticks.visible = i));
+      },
+      qe = (i) => i.series[0]?.ticks?.lineSymbol,
+      He = (i, e) => {
+        i &&
+          e.series?.[0] &&
+          ((e.series[0].ticks ??= b()), (e.series[0].ticks.lineSymbol = x(i)));
+      },
+      Je = (i, e) => e.series?.[0]?.slices?.[i]?.originalLabel,
+      Qe = (i, e) => e.series?.[0]?.slices?.[i]?.label,
+      Ye = (i, e, t) => {
+        t.series?.[0]?.slices?.[e] && (t.series[0].slices[e].label = i);
+      },
+      Ze = (i, e) => e.series?.[0]?.slices?.[i]?.fillSymbol?.color,
+      $e = (i, e, t) => {
+        let a = t.series?.[0]?.slices?.[e]?.fillSymbol;
+        a !== void 0
+          ? ((a.color = i),
+            a.outline !== void 0
+              ? (a.outline.color = i)
+              : (a.outline = { type: h.SLS, color: i }))
+          : t.series?.[0]?.slices?.[e] !== void 0 &&
+            (t.series[0].slices[e].fillSymbol = {
+              type: h.SFS,
+              color: i,
+              outline: { type: h.SLS, color: i },
+            });
+      },
+      ei = (i) => i.series?.[0]?.slices?.map((e) => e.sliceId),
+      J = (i, e) => {
+        e.series?.[0]?.slices?.sort(
+          (t, a) =>
+            i.findIndex((n) => t.sliceId === n) -
+            i.findIndex((n) => a.sliceId === n)
+        );
+      },
+      ii = (i) => i.series?.[0]?.sliceGrouping,
+      Q = (i, e) => {
+        e.series?.[0] && (e.series[0].sliceGrouping = i);
+      },
+      Y = (i) => i.series?.[0]?.sliceGrouping?.percentageThreshold,
+      ti = (i, e) => {
+        e.series?.[0]?.sliceGrouping !== void 0
+          ? (e.series[0].sliceGrouping.percentageThreshold = i)
+          : (e.series[0].sliceGrouping = {
+              sliceId: y.defaultGroupOfSlicesId,
+              percentageThreshold: i,
+            });
+      },
+      si = (i) => i.series?.[0]?.slices,
+      Z = (i, e) => {
+        e.series?.[0] && (e.series[0].slices = i);
+      },
+      ri = (i) => {
+        Z(void 0, i),
+          Q(
+            {
+              sliceId: y.defaultGroupOfSlicesId,
+              percentageThreshold: Y(i) ?? 0,
+            },
+            i
+          );
+      },
+      oi = (i, e) => e.series[0]?.slices?.[i]?.sliceId,
+      ai = (i, e) => e.series[0]?.slices?.findIndex((t) => t.sliceId === i),
+      ni = (i) => i.series[0]?.slices?.length ?? 0,
+      li = Object.defineProperty,
+      gi = Object.getOwnPropertyDescriptor,
+      o = (i, e, t, a) => {
+        for (var n = gi(e, t), l = i.length - 1, c; l >= 0; l--)
+          (c = i[l]) && (n = c(e, t, n) || n);
+        return n && li(e, t, n), n;
+      },
+      r = class extends j {
+        constructor() {
+          super(...arguments),
+            (this._chartType = p.PieSeries),
+            (this._mode = u.Category),
+            (this._groupedSliceIds = []);
+        }
+        async setup(e) {
+          await this.loadConfigFromLayer(e);
+          let { config: t } = e;
+          if (t !== void 0) {
+            let a = S(t.series);
+            this._mode = a !== m.PieFromFields ? u.Category : u.Fields;
+          }
+          typeof this.resolveSetup == "function" && this.resolveSetup();
+        }
+        get category() {
+          return L(this._config);
+        }
+        set category(e) {
+          (!N(this._config) || e.trim() !== "") &&
+            (z({
+              newCategory: e,
+              config: this._config,
+              layerInfo: this.layerInfo,
+              commonStrings: this.commonStrings,
+              mode: this._mode,
+            }),
+            this.dispatchEvent(
+              new CustomEvent("geosceneChartsModelDataChange")
+            ));
+        }
+        get numericFields() {
+          return G(this._config);
+        }
+        set numericFields(e) {
+          typeof e == "string" && (e = [e]),
+            this.layerInfo === void 0 || M(this.layerInfo.layerFieldsInfo, e)
+              ? (R({
+                  newNumericFields: e,
+                  config: this._config,
+                  layerInfo: this.layerInfo,
+                  commonStrings: this.commonStrings,
+                  mode: this._mode,
+                }),
+                this.dispatchEvent(
+                  new CustomEvent("geosceneChartsModelDataChange")
+                ))
+              : I("error", "pie-chart-model", "Invalid `numericFields`");
+        }
+        get aggregationType() {
+          return k(this._config, this._mode);
+        }
+        set aggregationType(e) {
+          E({
+            newAggregationType: e,
+            config: this._config,
+            layerInfo: this.layerInfo,
+            commonStrings: this.commonStrings,
+            mode: this._mode,
+          }),
+            this.dispatchEvent(
+              new CustomEvent("geosceneChartsModelDataChange")
+            );
+        }
+        getSortOrder() {
+          return A(this._config, this._mode);
+        }
+        setSortOrder(e, t) {
+          B({ newSortOrderKind: e, config: this._config, orderByList: t });
+        }
+        get orderByList() {
+          return v(this._config, this._mode);
+        }
+        set orderByList(e) {
+          C({ values: e, config: this._config, mode: this._mode });
+        }
+        get mode() {
+          return this._mode;
+        }
+        set mode(e) {
+          this._mode = e;
+        }
+        async getCustomSortValues() {
+          let e = L(this._config),
+            t = S(this._config.series),
+            a = [];
+          return (
+            t === m.PieFromFields
+              ? (a = this.numericFields)
+              : e.trim() !== "" &&
+                t === m.PieFromCategory &&
+                (a = await w({
+                  category: e,
+                  config: this._config,
+                  layerInfo: this.layerInfo,
+                })),
+            a
+          );
+        }
+        moveCustomSortValuesInOrderByList(e, t) {
+          let a = v(this._config, this._mode),
+            [n] = a.splice(e, 1);
+          a.splice(t, 0, n),
+            C({ values: a, config: this._config, mode: this._mode });
+        }
+        get ticksSymbol() {
+          return qe(this._config);
+        }
+        set ticksSymbol(e) {
+          He(e, this._config);
+        }
+        get slices() {
+          return si(this._config);
+        }
+        set slices(e) {
+          Z(e, this._config);
+        }
+        get groupedSliceIds() {
+          return this._groupedSliceIds;
+        }
+        set groupedSliceIds(e) {
+          this._groupedSliceIds = e;
+        }
+        get sliceGrouping() {
+          return ii(this._config);
+        }
+        set sliceGrouping(e) {
+          Q(e, this._config);
+        }
+        get innerRadiusSize() {
+          return de(this._config) ?? 0;
+        }
+        set innerRadiusSize(e) {
+          fe(e, this._config);
+        }
+        get groupingThreshold() {
+          return Y(this._config) ?? 0;
+        }
+        set groupingThreshold(e) {
+          ti(e, this._config);
+        }
+        get labelCharacterLimit() {
+          return he(this._config) ?? null;
+        }
+        set labelCharacterLimit(e) {
+          me(e, this._config);
+        }
+        get decimalPlaces() {
+          return Ee(this._config) ?? 1;
+        }
+        set decimalPlaces(e) {
+          Re(e, this._config);
+        }
+        get displayType() {
+          return Me(this._config);
+        }
+        set displayType(e) {
+          we(e, this._config);
+        }
+        generateDefaultConfig() {
+          let e = T(this.commonStrings);
+          return (
+            (e.series = [
+              V(this.commonStrings, F(this.layerInfo.layer).idField),
+            ]),
+            e
+          );
+        }
+        getOriginalSliceName(e) {
+          return Je(e, this._config);
+        }
+        getSliceName(e) {
+          return Qe(e, this._config);
+        }
+        setSliceName(e, t) {
+          Ye(e, t, this._config);
+        }
+        getSliceColor(e) {
+          return Ze(e, this._config);
+        }
+        setSliceColor(e, t) {
+          $e(e, t, this._config);
+        }
+        get orderOfSlices() {
+          return ei(this._config);
+        }
+        set orderOfSlices(e) {
+          e !== void 0 && J(e, this._config);
+        }
+        moveSeries(e, t) {
+          let a = this.orderOfSlices;
+          if (a !== void 0) {
+            let [n] = a.splice(e, 1);
+            a.splice(t, 0, n), J(a, this._config);
+          }
+        }
+        getSliceId(e) {
+          return oi(e, this._config);
+        }
+        getSliceIndex(e) {
+          return ai(e, this._config);
+        }
+        getSlicesLength() {
+          return ni(this._config);
+        }
+        resetSlices() {
+          ri(this._config);
+        }
+        resetAvailable() {
+          let e = !this.colorMatch,
+            t = !1,
+            a = this.slices?.length ?? 0;
+          for (let n = 0; n < a; n += 1) {
+            let l = this.getOriginalSliceName(n),
+              c = this.getSliceName(n);
+            if (l !== void 0 && l?.toString() !== c?.toString()) {
+              t = !0;
+              break;
+            }
+          }
+          return (
+            this.sliceGrouping?.originalLabel !== void 0 &&
+              this.sliceGrouping?.label !== this.sliceGrouping.originalLabel &&
+              (t = !0),
+            e || t
+          );
+        }
+        get ticksVisibility() {
+          return Ke(this._config);
+        }
+        set ticksVisibility(e) {
+          Xe(e, this._config);
+        }
+        get startAngle() {
+          return H(this._config);
+        }
+        set startAngle(e) {
+          ue(e, this._config);
+        }
+        get endAngle() {
+          return H(this._config);
+        }
+        set endAngle(e) {
+          ye(e, this._config);
+        }
+        get displayCategoryOnDataLabel() {
+          return be(this._config);
+        }
+        set displayCategoryOnDataLabel(e) {
+          this.guardSetterFromAsyncOverwrite(() => {
+            (this._config.series[0].displayCategoryOnDataLabel = e),
+              this.emitConfigUpdate("displayCategoryOnDataLabel");
+          });
+        }
+        get displayCategoryValueOnTooltip() {
+          return _e(this._config);
+        }
+        set displayCategoryValueOnTooltip(e) {
+          this._config.series[0].displayCategoryOnTooltip = e;
+        }
+        get displayNumericValueOnDataLabel() {
+          return Se(this._config);
+        }
+        set displayNumericValueOnDataLabel(e) {
+          this.guardSetterFromAsyncOverwrite(() => {
+            (this._config.series[0].displayNumericValueOnDataLabel = e),
+              this.emitConfigUpdate("displayNumericValueOnDataLabel");
+          });
+        }
+        get displayPercentageOnDataLabel() {
+          return Oe(this._config);
+        }
+        set displayPercentageOnDataLabel(e) {
+          this.guardSetterFromAsyncOverwrite(() => {
+            (this._config.series[0].displayPercentageOnDataLabel = e),
+              this.emitConfigUpdate("displayPercentageOnDataLabel");
+          });
+        }
+        get displayNumericValueOnTooltip() {
+          return Le(this._config);
+        }
+        set displayNumericValueOnTooltip(e) {
+          this._config.series[0].displayNumericValueOnTooltip = e;
+        }
+        get displayPercentageOnTooltip() {
+          return ve(this._config);
+        }
+        set displayPercentageOnTooltip(e) {
+          Ce(e, this._config);
+        }
+        get valuePrefix() {
+          return De(this._config);
+        }
+        set valuePrefix(e) {
+          Pe(e, this._config);
+        }
+        get valueSuffix() {
+          return Ie(this._config);
+        }
+        set valueSuffix(e) {
+          xe(e, this._config);
+        }
+        get percentagePrefix() {
+          return Ve(this._config);
+        }
+        set percentagePrefix(e) {
+          Te(e, this._config);
+        }
+        get percentageSuffix() {
+          return Fe(this._config);
+        }
+        set percentageSuffix(e) {
+          Ne(e, this._config);
+        }
+        get dataLabelsOffset() {
+          return Be(this._config);
+        }
+        set dataLabelsOffset(e) {
+          ze(e, this._config);
+        }
+        get alignDataLabels() {
+          return Ae(this._config);
+        }
+        set alignDataLabels(e) {
+          Ge(e, this._config);
+        }
+        get dataLabelsInside() {
+          return ke(this._config);
+        }
+        set dataLabelsInside(e) {
+          We(e, this._config);
+        }
+        get optimizeDataLabelsOverlapping() {
+          return je(this._config);
+        }
+        set optimizeDataLabelsOverlapping(e) {
+          Ue(e, this._config);
+        }
+        generateChartTitle() {
+          return W({
+            config: this._config,
+            layerInfo: this.layerInfo,
+            commonStrings: this.commonStrings,
+            mode: this._mode,
+          });
+        }
+      };
+    o([s], r.prototype, "category");
+    o([s], r.prototype, "numericFields");
+    o([s], r.prototype, "aggregationType");
+    o([s], r.prototype, "setSortOrder");
+    o([s], r.prototype, "orderByList");
+    o([s], r.prototype, "mode");
+    o([s], r.prototype, "moveCustomSortValuesInOrderByList");
+    o([s], r.prototype, "ticksSymbol");
+    o([s], r.prototype, "slices");
+    o([s], r.prototype, "groupedSliceIds");
+    o([s], r.prototype, "sliceGrouping");
+    o([s], r.prototype, "innerRadiusSize");
+    o([s], r.prototype, "groupingThreshold");
+    o([s], r.prototype, "labelCharacterLimit");
+    o([s], r.prototype, "decimalPlaces");
+    o([s], r.prototype, "displayType");
+    o([s], r.prototype, "setSliceName");
+    o([s], r.prototype, "setSliceColor");
+    o([s], r.prototype, "orderOfSlices");
+    o([s], r.prototype, "moveSeries");
+    o([s], r.prototype, "resetSlices");
+    o([s], r.prototype, "ticksVisibility");
+    o([s], r.prototype, "startAngle");
+    o([s], r.prototype, "endAngle");
+    o([s], r.prototype, "displayCategoryValueOnTooltip");
+    o([s], r.prototype, "displayNumericValueOnTooltip");
+    o([s], r.prototype, "displayPercentageOnTooltip");
+    o([s], r.prototype, "valuePrefix");
+    o([s], r.prototype, "valueSuffix");
+    o([s], r.prototype, "percentagePrefix");
+    o([s], r.prototype, "percentageSuffix");
+    o([s], r.prototype, "dataLabelsOffset");
+    o([s], r.prototype, "alignDataLabels");
+    o([s], r.prototype, "dataLabelsInside");
+    o([s], r.prototype, "optimizeDataLabelsOverlapping");
+    var ci = [d, X, U, K, q];
+    O(r, ci);
+    return r;
+  },
+  "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,
+  d,
+  e,
+  f,
+  i,
+  j,
+  k,
+  l
+);