@geoscene/charts-components 5.0.19

package/dist/cdn/FZD6CNIZ.js

@@ -0,0 +1,399 @@
+/* COPYRIGHT  - https://js.geoscene.cn/5.0/LICENSE.txt */
+import r from "./V2OPADQU.js";
+import q from "./UNHONDOG.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 "./AULQDYOE.js";
+import j from "./AQMOKQMS.js";
+import i 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 { i as h } from "./UG7LOBJE.js";
+import a from "./A7YNU2NS.js";
+import "./4B3QBH5T.js";
+import "./XLDY6CTA.js";
+import "./IHRGRUHQ.js";
+import { b as W } from "./KUVOINJC.js";
+import { a as x } from "./NKG4FLLR.js";
+import { k as g } from "./KRZ433BT.js";
+import "./OR4HXHSY.js";
+export default $geoscene.t(
+  ([
+    { B: p, C: f, E: y, P: O, Pa: d, qa: P, xa: D, z: A },
+    { o: U, p: N, q: R },
+    { c: r },
+    ,
+    ,
+    as,
+    { b: Ss, d: _s, f: Ls },
+    { b: fs, d: ys, f: ds },
+    { a: ms, b: us },
+    { b: ps },
+    { a: hs, b: cs, c: ls, d: gs },
+    { a: Fs, b: ws },
+    ,
+    { b: E },
+    { a: os, b: M, c: ns, d: I },
+    {
+      A: B,
+      B: v,
+      C: is,
+      D: rs,
+      a: V,
+      b: m,
+      c: z,
+      d: j,
+      e: u,
+      f: S,
+      g: k,
+      h: T,
+      i: q,
+      j: J,
+      k: Y,
+      l: G,
+      m: H,
+      n: _,
+      o: K,
+      p: Q,
+      q: X,
+      r: L,
+      s: Z,
+      t: $,
+      u: ss,
+      v: F,
+      w: w,
+      x: es,
+      y: ts,
+      z: C,
+    },
+  ]) => {
+    var Ms = Object.defineProperty,
+      Is = Object.getOwnPropertyDescriptor,
+      n = (l, s, e, i) => {
+        for (var o = Is(s, e), a = l.length - 1, c; a >= 0; a--)
+          (c = l[a]) && (o = c(s, e, o) || o);
+        return o && Ms(s, e, o), o;
+      },
+      t = class extends as {
+        constructor() {
+          super(...arguments),
+            (this._chartType = x.BoxPlotSeries),
+            (this._category = y),
+            (this._splitByField = ""),
+            (this._numericFields = []);
+        }
+        async setup(s) {
+          await this.loadConfigFromLayer(s),
+            this.setupLocalProps(),
+            s.config !== void 0 && (await this.updateSeriesFromLayerFilter()),
+            typeof this.resolveSetup == "function" && this.resolveSetup();
+        }
+        get category() {
+          return this._category;
+        }
+        set category(s) {
+          let e = s.trim() === "";
+          (this._category = e ? y : s),
+            this.dirtyAsyncSetters.push("category"),
+            this.processSeriesRebuild();
+        }
+        get numericFields() {
+          return this._numericFields;
+        }
+        set numericFields(s) {
+          let { layerFieldsInfo: e } = this.layerInfo;
+          typeof s == "string" && (s = [s]),
+            N(e, s)
+              ? ((this._numericFields = s),
+                this.dirtyAsyncSetters.push("numericFields"),
+                is(this._category, this._numericFields) &&
+                  ((this._splitByField = ""),
+                  this.dirtyAsyncSetters.push("splitByField")),
+                this.processSeriesRebuild())
+              : g("error", "box-plot-model", "Invalid `numericFields`");
+        }
+        get splitByField() {
+          return this._splitByField;
+        }
+        set splitByField(s) {
+          U(this.layerInfo.layerFieldsInfo, s)
+            ? ((this._splitByField = s),
+              this.dirtyAsyncSetters.push("splitByField"),
+              this.processSeriesRebuild())
+            : g("error", "box-plot-model", "Invalid `splitByField`");
+        }
+        get showOutliers() {
+          return Z(this._config);
+        }
+        set showOutliers(s) {
+          $({
+            newShowOutliers: s,
+            config: this._config,
+            layerInfo: this.layerInfo,
+            commonStrings: this.commonStrings,
+          }),
+            this.dispatchEvent(
+              new CustomEvent("geosceneChartsModelDataChange")
+            );
+        }
+        get standardizeValues() {
+          return K(this._config);
+        }
+        set standardizeValues(s) {
+          ss({
+            newStandardizeValues: s,
+            config: this._config,
+            layerInfo: this.layerInfo,
+            commonStrings: this.commonStrings,
+          }),
+            this.dispatchEvent(
+              new CustomEvent("geosceneChartsModelDataChange")
+            );
+        }
+        getSortOrder() {
+          return F(this._config);
+        }
+        setSortOrder(s, e) {
+          w(s, this._config, e);
+        }
+        async getCustomSortValues() {
+          return await v(this._config, this.layerInfo);
+        }
+        async setDataFilters(s) {
+          super.setDataFilters(s);
+          let e = F(this._config);
+          if (e === W.customSort) {
+            this.startAsyncUpdate();
+            let i = await v(this._config, this.layerInfo);
+            w(e, this._config, i), this.finishAsyncUpdate();
+          }
+          this.dispatchEvent(new CustomEvent("geosceneChartsModelDataChange"));
+        }
+        get orderByList() {
+          return C(this._config);
+        }
+        set orderByList(s) {
+          B(s, this._config);
+        }
+        async updateSeriesFromLayerFilter() {
+          this.dirtyAsyncSetters.push("updateSeriesFromLayerFilter"),
+            await this.processSeriesRebuild();
+        }
+        get showMeanLines() {
+          return es(this._config);
+        }
+        set showMeanLines(s) {
+          let { previousMeanLinesBoxColor: e } = ts({
+            newShowMeanLines: s,
+            config: this._config,
+            commonStrings: this.commonStrings,
+            previousMeanLinesBoxColor: this.previousMeanLinesBoxColor,
+          });
+          this.previousMeanLinesBoxColor = e;
+        }
+        get meanLinesBoxColor() {
+          return j(this._config);
+        }
+        set meanLinesBoxColor(s) {
+          u(s, this._config);
+        }
+        setupLocalProps() {
+          (this._category = Y(this._config)),
+            (this._splitByField = G(this._config)),
+            (this._numericFields = H(this._config));
+        }
+        generateDefaultConfig() {
+          let s = D(this.commonStrings);
+          return (s.series = [P(this.commonStrings)]), s;
+        }
+        resetConfig() {
+          let s = this._config.id;
+          (this._config = this.generateDefaultConfig()),
+            (this._config.id = s),
+            this.setupLocalProps(),
+            this.dispatchEvent(
+              new CustomEvent("geosceneChartsModelDataChange")
+            );
+        }
+        canUseSynchronousSeriesRebuild() {
+          return !rs(this.category, this.numericFields, this.splitByField);
+        }
+        async processSeriesRebuild() {
+          if (this.layerInfo !== void 0) {
+            let s = this.dirtyAsyncSetters[this.dirtyAsyncSetters.length - 1];
+            if (this.canUseSynchronousSeriesRebuild())
+              (this.dirtyAsyncSetters = []), _(this.getBuildNewSeriesProps());
+            else if (!this.asyncConfigUpdateInProgress) {
+              for (this.startAsyncUpdate(); this.dirtyAsyncSetters.length > 0; )
+                (this.dirtyAsyncSetters = []),
+                  await _(this.getBuildNewSeriesProps());
+              this.finishAsyncUpdate();
+            }
+            this.setupLocalProps(),
+              this.dispatchEvent(
+                new CustomEvent("geosceneChartsModelDataChange")
+              ),
+              this.emitConfigUpdate(s);
+          }
+        }
+        getBuildNewSeriesProps() {
+          return {
+            category: this.category,
+            splitByField: this.splitByField,
+            numericFields: this.numericFields,
+            config: this._config,
+            layerInfo: this.layerInfo,
+            commonStrings: this.commonStrings,
+          };
+        }
+        getSeriesName(s) {
+          return V(s, this._config);
+        }
+        setSeriesName(s, e) {
+          m(s, e, this._config);
+        }
+        getSeriesColor(s) {
+          return z(s, this._config);
+        }
+        setSeriesColor(s, e) {
+          S(s, e, this._config);
+        }
+        getSeriesLineStyle(s) {
+          let e = this._config.series[s];
+          if (this.showMeanLines === !0 && h(e)) return os(e);
+        }
+        setSeriesLineStyle(s, e) {
+          let i = this._config.series[e];
+          this.showMeanLines === !0 && h(i) && M(s, i);
+        }
+        getSeriesLineWidth(s) {
+          let e = this._config.series[s];
+          if (this.showMeanLines === !0 && h(e)) return ns(e);
+        }
+        setSeriesLineWidth(s, e) {
+          let i = this._config.series[e];
+          this.showMeanLines === !0 && h(i) && I(s, i);
+        }
+        get orderOfSeries() {
+          return k(this._config);
+        }
+        set orderOfSeries(s) {
+          T(s, this._config);
+        }
+        moveSeries(s, e) {
+          q(s, e, this._config);
+        }
+        get boxPlotSeriesIndexWhenMeanLinesShown() {
+          return J(this._config);
+        }
+        moveCustomSortValuesInOrderByList(s, e) {
+          let i = C(this._config),
+            [o] = i.splice(s, 1);
+          i.splice(e, 0, o), B(i, this._config);
+        }
+        generateChartTitle() {
+          return X(this._config, this.layerInfo, this.commonStrings);
+        }
+        generateYAxisTitle() {
+          return Q(this._config, this.layerInfo, this.commonStrings);
+        }
+        resetSeriesStyling() {
+          for (
+            let s = this.showMeanLines === !0 ? 1 : 0;
+            s < this.seriesLength;
+            s += 1
+          ) {
+            let e = this.getSeriesId(s),
+              i = O({ colorIndex: s, opacity: A }),
+              o = this._config.series[s];
+            S(i, s, this._config);
+            let a = L({
+              series: o,
+              splitByField: this._splitByField,
+              layerInfo: this.layerInfo,
+              commonStrings: this.commonStrings,
+            });
+            m(a ?? e, s, this._config),
+              this.showMeanLines === !0 && h(o) && (M(p, o), I(f, o));
+          }
+          this.showMeanLines === !0 && u(d, this._config),
+            (this._config.colorMatch = !0);
+        }
+        resetAvailable() {
+          let s = !this.colorMatch,
+            e = this.showMeanLines === !0 && this.meanLinesBoxColor !== d,
+            i = !1,
+            o = !1;
+          if (!s)
+            for (
+              let a = this.showMeanLines === !0 ? 1 : 0;
+              a < this.seriesLength;
+              a += 1
+            ) {
+              let c = this._config.series[a],
+                b = L({
+                  series: c,
+                  splitByField: this._splitByField,
+                  layerInfo: this.layerInfo,
+                  commonStrings: this.commonStrings,
+                }),
+                Cs = this.getSeriesName(a);
+              if (b !== void 0 && b !== Cs) {
+                i = !0;
+                break;
+              }
+              if (this.showMeanLines === !0 && h(c)) {
+                let Bs = this.getSeriesLineStyle(a),
+                  vs = this.getSeriesLineWidth(a);
+                if (Bs !== p || vs !== f) {
+                  o = !0;
+                  break;
+                }
+              }
+            }
+          return s || e || i || o;
+        }
+      };
+    n([r], t.prototype, "showOutliers");
+    n([r], t.prototype, "standardizeValues");
+    n([r], t.prototype, "setSortOrder");
+    n([r], t.prototype, "setDataFilters");
+    n([r], t.prototype, "orderByList");
+    n([r], t.prototype, "showMeanLines");
+    n([r], t.prototype, "meanLinesBoxColor");
+    n([r], t.prototype, "resetConfig");
+    n([r], t.prototype, "setSeriesName");
+    n([r], t.prototype, "setSeriesColor");
+    n([r], t.prototype, "setSeriesLineStyle");
+    n([r], t.prototype, "setSeriesLineWidth");
+    n([r], t.prototype, "orderOfSeries");
+    n([r], t.prototype, "moveSeries");
+    n([r], t.prototype, "moveCustomSortValuesInOrderByList");
+    n([r], t.prototype, "resetSeriesStyling");
+    var bs = [Fs, ls, gs, hs, E, cs, ps, ws, Ss, us, _s, ms, fs, ys, ds, Ls];
+    R(t, bs);
+    return t;
+  },
+  a,
+  b,
+  c,
+  d,
+  e,
+  f,
+  i,
+  j,
+  k,
+  l,
+  m,
+  n,
+  o,
+  p,
+  q,
+  r
+);

package/dist/cdn/G4MCRK6N.js

@@ -0,0 +1,162 @@
+/* COPYRIGHT  - https://js.geoscene.cn/5.0/LICENSE.txt */
+import "./OR4HXHSY.js";
+var r = {
+  _decimalSeparator: ",",
+  _thousandSeparator: ".",
+  _percentPrefix: null,
+  _percentSuffix: "%",
+  _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 - d MMM",
+  _date_hour: "HH:mm",
+  _date_hour_short: "HH",
+  _date_hour_full: "HH:mm - d MMM",
+  _date_day: "d MMM",
+  _date_day_full: "d MMM",
+  _date_week: "ww",
+  _date_week_full: "d MMM",
+  _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: "AD",
+  _era_bc: "v.C.",
+  A: "A",
+  P: "P",
+  AM: "AM",
+  PM: "PM",
+  "A.M.": "a.m.",
+  "P.M.": "p.m.",
+  January: "januari",
+  February: "februari",
+  March: "maart",
+  April: "april",
+  May: "mei",
+  June: "juni",
+  July: "juli",
+  August: "augustus",
+  September: "september",
+  October: "oktober",
+  November: "november",
+  December: "december",
+  Jan: "jan",
+  Feb: "feb",
+  Mar: "mrt",
+  Apr: "apr",
+  "May(short)": "mei",
+  Jun: "jun",
+  Jul: "jul",
+  Aug: "aug",
+  Sep: "sep",
+  Oct: "okt",
+  Nov: "nov",
+  Dec: "dec",
+  Sunday: "zondag",
+  Monday: "maandag",
+  Tuesday: "dinsdag",
+  Wednesday: "woensdag",
+  Thursday: "donderdag",
+  Friday: "vrijdag",
+  Saturday: "zaterdag",
+  Sun: "Zo",
+  Mon: "Ma",
+  Tue: "Di",
+  Wed: "Wo",
+  Thu: "Do",
+  Fri: "Vr",
+  Sat: "Za",
+  _dateOrd: function (e) {
+    let t = "de";
+    return (e == 1 || e == 8 || e > 19) && (t = "ste"), t;
+  },
+  "Zoom Out": "Uitzoomen",
+  Play: "Afspelen",
+  Stop: "Stoppen",
+  Legend: "Legenda",
+  "Press ENTER to toggle": "Klik, tik of druk op Enter om aan of uit te zetten",
+  Loading: "Laden",
+  Home: "Home",
+  Chart: "Grafiek",
+  "Serial chart": "Periodieke grafiek",
+  "X/Y chart": "X-Y grafiek",
+  "Pie chart": "Taartdiagram",
+  "Gauge chart": "Meterdiagram",
+  "Radar chart": "Radardiagram",
+  "Sankey diagram": "Sankey-diagram",
+  "Chord diagram": "Chord-diagram",
+  "Flow diagram": "Flow-diagram",
+  "TreeMap chart": "Treemap-grafiek",
+  Series: "Reeks",
+  "Candlestick Series": "Candlestick-reeks",
+  "Column Series": "Kolomreeks",
+  "Line Series": "Lijnreeks",
+  "Pie Slice Series": "Taartpuntreeks",
+  "X/Y Series": "XY reeks",
+  Map: "Kaart",
+  "Press ENTER to zoom in": "Druk op Enter om in te zoomen",
+  "Press ENTER to zoom out": "Druk op Enter om uit te zoomen",
+  "Use arrow keys to zoom in and out": "Zoom in of uit met de pijltjestoetsen",
+  "Use plus and minus keys on your keyboard to zoom in and out":
+    "Zoom in of uit met de plus- en minustoetsen",
+  Export: "Exporteren",
+  Image: "Afbeelding",
+  Data: "Data",
+  Print: "Printen",
+  "Press ENTER to open": "Klik, tik of druk op Enter om te openen",
+  "Press ENTER to print.": "Klik, tik of druk op Enter om te printen",
+  "Press ENTER to export as %1.":
+    "Klik, tik of druk op Enter om te exporteren als %1",
+  "(Press ESC to close this message)":
+    "(Druk op ESC om dit bericht te sluiten)",
+  "Image Export Complete": "Afbeelding exporteren gereed",
+  "Export operation took longer than expected. Something might have gone wrong.":
+    "Exportproces duurt langer dan verwacht. Er is misschien iets fout gegaan.",
+  "Saved from": "Opgeslagen via:",
+  PNG: "PNG",
+  JPG: "JPG",
+  GIF: "GIF",
+  SVG: "SVG",
+  PDF: "PDF",
+  JSON: "JSON",
+  CSV: "CSV",
+  XLSX: "XLSX",
+  HTML: "",
+  "Use TAB to select grip buttons or left and right arrows to change selection":
+    "Gebruik Tab om de hendels te selecteren of linker- en rechterpijltje om de selectie te veranderen",
+  "Use left and right arrows to move selection":
+    "Gebruik linker- en rechterpijltje om de selectie te verplaatsen",
+  "Use left and right arrows to move left selection":
+    "Gebruik linker- en rechterpijltje om de linkerselectie te verplaatsen",
+  "Use left and right arrows to move right selection":
+    "Gebruik linker- en rechterpijltje om de rechterselectie te verplaatsen",
+  "Use TAB select grip buttons or up and down arrows to change selection":
+    "Gebruik Tab om de hendels te selecteren of pijltje omhoog en omlaag om de selectie te veranderen",
+  "Use up and down arrows to move selection":
+    "Gebruik pijltje omhoog en omlaag om de selectie te verplaatsen",
+  "Use up and down arrows to move lower selection":
+    "Gebruik pijltje omhoog en omlaag om de onderste selectie te verplaatsen",
+  "Use up and down arrows to move upper selection":
+    "Gebruik pijltje omhoog en omlaag om de bovenste selectie te verplaatsen",
+  "From %1 to %2": "Van %1 tot %2",
+  "From %1": "Van %1",
+  "To %1": "Tot %1",
+  "No parser available for file: %1":
+    "Geen data-parser beschikbaar voor dit bestand: %1",
+  "Error parsing file: %1": "Fout tijdens parsen van bestand: %1",
+  "Unable to load file: %1": "Kan bestand niet laden: %1",
+  "Invalid date": "Ongeldige datum",
+  Close: "",
+  Minimize: "",
+  Confirm: "",
+};
+export { r as default };