@geoscene/charts-components 5.0.19

package/dist/cdn/WKARMQOX.js

@@ -0,0 +1,416 @@
+/* COPYRIGHT  - https://js.geoscene.cn/5.0/LICENSE.txt */
+import s from "./27RSUS44.js";
+import q from "./ZLRKGGOO.js";
+import p from "./NSSG3EFV.js";
+import o from "./AENRD2JF.js";
+import n from "./YIZBXVJZ.js";
+import m from "./BZA7GDEH.js";
+import l from "./A6QBN7CC.js";
+import k from "./YYJQDF23.js";
+import j from "./AULQDYOE.js";
+import i from "./AQMOKQMS.js";
+import h from "./KP4ZXQIA.js";
+import g from "./V3CSEWPF.js";
+import f from "./P4UNBBUE.js";
+import e from "./DKENL7TV.js";
+import d 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 { c as r } from "./KUVOINJC.js";
+import { a as u, b as c } from "./NKG4FLLR.js";
+import "./KRZ433BT.js";
+import "./OR4HXHSY.js";
+export default $geoscene.t(
+  ([
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    { Da: _, Kb: S, Nc: m },
+    ,
+    { c: i },
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    { e: l },
+    ,
+    {
+      $: tt,
+      A: w,
+      B: D,
+      C: I,
+      D: B,
+      E: P,
+      F: k,
+      G: R,
+      H: W,
+      I: U,
+      J: E,
+      K: M,
+      L: y,
+      M: h,
+      N: G,
+      O: H,
+      P: N,
+      Q: Y,
+      R: j,
+      S: V,
+      T: X,
+      U: q,
+      V: z,
+      W: J,
+      X: K,
+      Y: Q,
+      Z: Z,
+      _: $,
+      aa: et,
+      ba: it,
+      ca: ot,
+      da: st,
+      ha: f,
+      r: C,
+      s: T,
+      t: A,
+      u: O,
+      v: x,
+      w: F,
+      x: b,
+      y: v,
+      z: L,
+    },
+    { a: rt, b: nt, d: at },
+  ]) => {
+    var gt = Object.defineProperty,
+      pt = Object.getOwnPropertyDescriptor,
+      o = (p, t, s, a) => {
+        for (var n = pt(t, s), g = p.length - 1, d; g >= 0; g--)
+          (d = p[g]) && (n = d(t, s, n) || n);
+        return n && gt(t, s, n), n;
+      },
+      e = class extends at {
+        constructor() {
+          super(...arguments), (this._chartType = u.HeatSeries);
+        }
+        generateChartTitle() {
+          return this.layerInfo !== void 0
+            ? st(this._config, this.layerInfo, this.commonStrings)
+            : "";
+        }
+        generateYAxisTitle() {
+          let t = this.yTemporalBinning?.unit;
+          return t !== void 0
+            ? this.commonStrings.utilsStrings.heatChartCalendarDatePartsUnits[t]
+            : "";
+        }
+        async setup(t) {
+          await this.loadConfigFromLayer(t),
+            this.setupLocalProps(),
+            typeof this.resolveSetup == "function" && this.resolveSetup();
+        }
+        get yAxisField() {
+          return v(this._config);
+        }
+        set yAxisField(t) {
+          b({ yField: t, config: this._config, layerInfo: this.layerInfo });
+        }
+        get viewType() {
+          return K(this._config);
+        }
+        set viewType(t) {
+          this.guardSetterFromAsyncOverwrite(() => {
+            Q(t, this._config), this.emitConfigUpdate("heatChartViewType");
+          });
+        }
+        get xTemporalBinning() {
+          return w(this._config);
+        }
+        set xTemporalBinning(t) {
+          L({
+            commonStrings: this.commonStrings,
+            binning: t,
+            config: this._config,
+          });
+        }
+        get yTemporalBinning() {
+          return I(this._config);
+        }
+        set yTemporalBinning(t) {
+          D({
+            commonStrings: this.commonStrings,
+            binning: t,
+            config: this._config,
+          });
+        }
+        get breaksCount() {
+          return Z(this._config);
+        }
+        set breaksCount(t) {
+          this.guardSetterFromAsyncOverwrite(() => {
+            $(t, this._config), this.emitConfigUpdate("breaksCount");
+          });
+        }
+        get classificationMethod() {
+          return tt(this._config);
+        }
+        set classificationMethod(t) {
+          this.guardSetterFromAsyncOverwrite(() => {
+            t &&
+              (et(t, this._config),
+              this.emitConfigUpdate("classificationMethod"));
+          });
+        }
+        get hideEmptyRowsAndColumns() {
+          return C(this._config);
+        }
+        set hideEmptyRowsAndColumns(t) {
+          T(this._config, t);
+        }
+        get gridLineWidth() {
+          return P(this._config);
+        }
+        set gridLineWidth(t) {
+          B(t, this._config);
+        }
+        get gridLineColor() {
+          return R(this._config);
+        }
+        set gridLineColor(t) {
+          k(t, this._config);
+        }
+        get seriesName() {
+          return rt(0, this._config);
+        }
+        set seriesName(t) {
+          typeof t == "string" && nt(t, 0, this._config);
+        }
+        get heatRulesType() {
+          return O(this._config);
+        }
+        set heatRulesType(t) {
+          A(this._config, t);
+        }
+        get gradientRules() {
+          return F(this._config);
+        }
+        set gradientRules(t) {
+          x(this._config, t);
+        }
+        getGridLinesSymbol() {
+          return this._config.series?.[0]?.gridLine;
+        }
+        setGridLinesSymbol(t) {
+          this._config.series?.[0] && (this._config.series[0].gridLine = t);
+        }
+        get numericFields() {
+          let t = E(this._config);
+          return t !== void 0 ? [t] : [];
+        }
+        set numericFields(t) {
+          let { idField: s } = m(this.layerInfo.layer),
+            a = S(t[0]),
+            n = a ? s : t[0];
+          M({
+            field: n,
+            config: this._config,
+            layerInfo: this.layerInfo,
+            commonStrings: this.commonStrings,
+          });
+          let g = y(this._config);
+          a &&
+            g !== c.Count &&
+            h({
+              aggregationType: c.Count,
+              config: this._config,
+              layerInfo: this.layerInfo,
+              commonStrings: this.commonStrings,
+            });
+        }
+        get aggregationType() {
+          return y(this._config);
+        }
+        set aggregationType(t) {
+          h({
+            aggregationType: t,
+            config: this._config,
+            layerInfo: this.layerInfo,
+            commonStrings: this.commonStrings,
+          });
+        }
+        get splitByField() {
+          return "";
+        }
+        set splitByField(t) {}
+        get legendPosition() {
+          return U(this._config);
+        }
+        set legendPosition(t) {
+          W(t, this._config);
+        }
+        get nullPolicy() {
+          return G(this._config);
+        }
+        set nullPolicy(t) {
+          H(t, this._config);
+        }
+        get emptyCell() {
+          return N(this._config);
+        }
+        set emptyCell(t) {
+          this.guardSetterFromAsyncOverwrite(() => {
+            Y(t, this._config), this.emitConfigUpdate("emptyCell");
+          });
+        }
+        getSortOrder() {
+          return r.Asc;
+        }
+        setSortOrder(t, s) {}
+        getXAxisSortOrder() {
+          let t = f(this._config)[0];
+          return t === r.Asc || t === r.Desc || t === r.customSort ? t : r.Asc;
+        }
+        setXAxisSortOrder(t, s) {
+          l(t, this._config, s);
+        }
+        getYAxisSortOrder() {
+          let t = f(this._config)[1];
+          return t === r.Asc || t === r.Desc || t === r.customSort ? t : r.Asc;
+        }
+        setYAxisSortOrder(t, s) {
+          l(t, this._config, s, !0);
+        }
+        get emptyCellText() {
+          return j(this._config);
+        }
+        set emptyCellText(t) {
+          V(t, this._config);
+        }
+        get includeLeapDay() {
+          return X(this._config);
+        }
+        set includeLeapDay(t) {
+          this.guardSetterFromAsyncOverwrite(() => {
+            q(t, this._config), this.emitConfigUpdate("includeLeapDay");
+          });
+        }
+        get firstDayOfWeek() {
+          return ot(this._config);
+        }
+        set firstDayOfWeek(t) {
+          this.guardSetterFromAsyncOverwrite(() => {
+            it(t, this._config), this.emitConfigUpdate("firstDayOfWeek");
+          });
+        }
+        get emptyCellSymbol() {
+          return z(this._config);
+        }
+        set emptyCellSymbol(t) {
+          J(t, this._config);
+        }
+        get rotatedState() {
+          return !1;
+        }
+        set rotatedState(t) {}
+        setAssignToSecondValueAxis(t, s) {}
+        set stackedType(t) {}
+        set binTemporalData(t) {}
+        set nullCategory(t) {}
+        generateDefaultConfig() {
+          let t = _(this.commonStrings, m(this.layerInfo.layer).idField);
+          return (
+            t.axes?.forEach((s, a) => {
+              s &&
+                (s.valueFormat = {
+                  intlOptions: {
+                    timeZone: void 0,
+                    dateStyle: a > 0 ? "long" : "medium",
+                  },
+                  type: "date",
+                });
+            }),
+            t
+          );
+        }
+      };
+    o([i], e.prototype, "yAxisField");
+    o([i], e.prototype, "xTemporalBinning");
+    o([i], e.prototype, "yTemporalBinning");
+    o([i], e.prototype, "hideEmptyRowsAndColumns");
+    o([i], e.prototype, "gridLineWidth");
+    o([i], e.prototype, "gridLineColor");
+    o([i], e.prototype, "seriesName");
+    o([i], e.prototype, "heatRulesType");
+    o([i], e.prototype, "gradientRules");
+    o([i], e.prototype, "setGridLinesSymbol");
+    o([i], e.prototype, "numericFields");
+    o([i], e.prototype, "aggregationType");
+    o([i], e.prototype, "splitByField");
+    o([i], e.prototype, "legendPosition");
+    o([i], e.prototype, "nullPolicy");
+    o([i], e.prototype, "setSortOrder");
+    o([i], e.prototype, "setXAxisSortOrder");
+    o([i], e.prototype, "setYAxisSortOrder");
+    o([i], e.prototype, "emptyCellText");
+    o([i], e.prototype, "firstDayOfWeek");
+    o([i], e.prototype, "emptyCellSymbol");
+    o([i], e.prototype, "rotatedState");
+    o([i], e.prototype, "setAssignToSecondValueAxis");
+    o([i], e.prototype, "stackedType");
+    o([i], e.prototype, "binTemporalData");
+    o([i], e.prototype, "nullCategory");
+    return e;
+  },
+  "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,
+  d,
+  e,
+  f,
+  g,
+  h,
+  i,
+  j,
+  k,
+  l,
+  m,
+  n,
+  o,
+  p,
+  q,
+  s
+);

package/dist/cdn/WSH74NNB.js

@@ -0,0 +1,184 @@
+/* COPYRIGHT  - https://js.geoscene.cn/5.0/LICENSE.txt */
+import "./OR4HXHSY.js";
+var r = {
+  _decimalSeparator: ",",
+  _thousandSeparator: ".",
+  _percentPrefix: null,
+  _percentSuffix: "%",
+  _big_number_suffix_3: "K",
+  _big_number_suffix_6: "Mio",
+  _big_number_suffix_9: "Mrd",
+  _big_number_suffix_12: "Bio",
+  _big_number_suffix_15: "Brd",
+  _big_number_suffix_18: "Trill",
+  _big_number_suffix_21: "Trd",
+  _big_number_suffix_24: "Y",
+  _small_number_suffix_3: "m",
+  _small_number_suffix_6: "\u03BC",
+  _small_number_suffix_9: "n",
+  _small_number_suffix_12: "p",
+  _small_number_suffix_15: "f",
+  _small_number_suffix_18: "a",
+  _small_number_suffix_21: "z",
+  _small_number_suffix_24: "y",
+  _byte_suffix_B: "B",
+  _byte_suffix_KB: "KB",
+  _byte_suffix_MB: "MB",
+  _byte_suffix_GB: "GB",
+  _byte_suffix_TB: "TB",
+  _byte_suffix_PB: "PB",
+  _date_millisecond: "mm:ss SSS",
+  _date_millisecond_full: "HH:mm:ss SSS",
+  _date_second: "HH:mm:ss",
+  _date_second_full: "HH:mm:ss",
+  _date_minute: "HH:mm",
+  _date_minute_full: "HH:mm - dd. MMM, yyyy",
+  _date_hour: "HH:mm",
+  _date_hour_short: "HH",
+  _date_hour_full: "HH:mm - dd. MMM, yyyy",
+  _date_day: "dd. MMM",
+  _date_day_full: "dd. MMM, yyyy",
+  _date_week: "ww",
+  _date_week_full: "dd. MMM, yyyy",
+  _date_month: "MMM",
+  _date_month_full: "MMM, yyyy",
+  _date_year: "yyyy",
+  _duration_millisecond: "SSS",
+  _duration_second: "ss",
+  _duration_minute: "mm",
+  _duration_hour: "hh",
+  _duration_day: "dd",
+  _duration_week: "ww",
+  _duration_month: "MM",
+  _duration_year: "yyyy",
+  _era_ad: "v. Chr.",
+  _era_bc: "n. Chr.",
+  A: "",
+  P: "",
+  AM: "",
+  PM: "",
+  "A.M.": "",
+  "P.M.": "",
+  January: "Januar",
+  February: "Februar",
+  March: "M\xE4rz",
+  April: "April",
+  May: "Mai",
+  June: "Juni",
+  July: "Juli",
+  August: "August",
+  September: "September",
+  October: "Oktober",
+  November: "November",
+  December: "Dezember",
+  Jan: "Jan.",
+  Feb: "Febr.",
+  Mar: "M\xE4rz",
+  Apr: "Apr.",
+  "May(short)": "Mai",
+  Jun: "Juni",
+  Jul: "Juli",
+  Aug: "Aug.",
+  Sep: "Sept.",
+  Oct: "Okt.",
+  Nov: "Nov.",
+  Dec: "Dez.",
+  Sunday: "Sonntag",
+  Monday: "Montag",
+  Tuesday: "Dienstag",
+  Wednesday: "Mittwoch",
+  Thursday: "Donnerstag",
+  Friday: "Freitag",
+  Saturday: "Samstag",
+  Sun: "So.",
+  Mon: "Mo.",
+  Tue: "Di.",
+  Wed: "Mi.",
+  Thu: "Do.",
+  Fri: "Fr.",
+  Sat: "Sa.",
+  _dateOrd: function (e) {
+    return e + ".";
+  },
+  "Zoom Out": "Herauszoomen",
+  Play: "Abspielen",
+  Stop: "Stop",
+  Legend: "Legende",
+  "Press ENTER to toggle":
+    "Klicken, tippen oder ENTER dr\xFCcken zum Umschalten",
+  Loading: "Wird geladen",
+  Home: "Home",
+  Chart: "Diagramm",
+  "Serial chart": "Seriendiagramm",
+  "X/Y chart": "X-Y-Diagramm",
+  "Pie chart": "Kreisdiagramm",
+  "Gauge chart": "Messdiagramm",
+  "Radar chart": "Netzdiagramm",
+  "Sankey diagram": "Sankey-Diagramm",
+  "Chord diagram": "",
+  "Flow diagram": "Flussdiagramm",
+  "TreeMap chart": "Baumdiagramm",
+  Series: "Serie",
+  "Candlestick Series": "Kerzendiagramm",
+  "Column Series": "Balkendiagramm",
+  "Line Series": "Liniendiagramm",
+  "Pie Slice Series": "Kreisdiagramm",
+  "X/Y Series": "Punktdiagramm",
+  Map: "Karte",
+  "Press ENTER to zoom in": "Dr\xFCcke ENTER zum Hereinzoomen",
+  "Press ENTER to zoom out": "Dr\xFCcke ENTER zum Herauszoomen",
+  "Use arrow keys to zoom in and out": "Benutze die Pfeiltasten zum Zoomen",
+  "Use plus and minus keys on your keyboard to zoom in and out":
+    "Benutze Plus- und Minustasten zum Zoomen",
+  Export: "Export",
+  Image: "Bild",
+  Data: "Daten",
+  Print: "Drucken",
+  "Press ENTER to open": "Zum \xD6ffnen klicken, tippen oder ENTER dr\xFCcken",
+  "Press ENTER to print.": "Zum Drucken klicken, tippen oder ENTER dr\xFCcken.",
+  "Press ENTER to export as %1.":
+    "Klicken, tippen oder ENTER dr\xFCcken um als %1 zu exportieren",
+  "(Press ESC to close this message)":
+    "ESC dr\xFCcken um diese Nachricht zu schlie\xDFen",
+  "Image Export Complete": "Bildexport komplett",
+  "Export operation took longer than expected. Something might have gone wrong.":
+    "Der Export dauert l\xE4nger als geplant. Vielleicht ist etwas schiefgelaufen.",
+  "Saved from": "Gespeichert von",
+  PNG: "",
+  JPG: "",
+  GIF: "",
+  SVG: "",
+  PDF: "",
+  JSON: "",
+  CSV: "",
+  XLSX: "",
+  HTML: "",
+  "Use TAB to select grip buttons or left and right arrows to change selection":
+    "TAB nutzen, um Ankerpunkte auszuw\xE4hlen oder linke und rechte Pfeiltaste um die Auswahl zu \xE4ndern",
+  "Use left and right arrows to move selection":
+    "Linke und rechte Pfeiltaste nutzen um die Auswahl zu verschieben",
+  "Use left and right arrows to move left selection":
+    "Linke und rechte Pfeiltaste nutzen um die linke Auswahl zu verschieben",
+  "Use left and right arrows to move right selection":
+    "Linke und rechte Pfeiltaste nutzen um die rechte Auswahl zu verschieben",
+  "Use TAB select grip buttons or up and down arrows to change selection":
+    "TAB nutzen, um Ankerpunkte auszuw\xE4hlen oder Pfeiltaste nach oben und unten dr\xFCcken, um die Auswahl zu \xE4ndern",
+  "Use up and down arrows to move selection":
+    "Pfeiltaste nach oben und unten dr\xFCcken, um die Auswahl zu verschieben",
+  "Use up and down arrows to move lower selection":
+    "Pfeiltaste nach oben und unten dr\xFCcken, um die untere Auswahl zu verschieben",
+  "Use up and down arrows to move upper selection":
+    "Pfeiltaste nach oben und unten dr\xFCcken, um die obere Auswahl zu verschieben",
+  "From %1 to %2": "Von %1 bis %2",
+  "From %1": "Von %1",
+  "To %1": "Bis %1",
+  "No parser available for file: %1":
+    "Kein Parser f\xFCr Datei %1 verf\xFCgbar",
+  "Error parsing file: %1": "Fehler beim Parsen von Datei %1",
+  "Unable to load file: %1": "Datei %1 konnte nicht geladen werden",
+  "Invalid date": "Kein Datum",
+  Close: "",
+  Minimize: "",
+  Confirm: "",
+};
+export { r as default };