@geoscene/charts-components 5.0.19

package/dist/cdn/YIZBXVJZ.js

@@ -0,0 +1,493 @@
+/* COPYRIGHT  - https://js.geoscene.cn/5.0/LICENSE.txt */
+import f from "./AULQDYOE.js";
+import e from "./V3CSEWPF.js";
+import d from "./DKENL7TV.js";
+import c from "./ISWZQ6CS.js";
+import b from "./P5SSZWMH.js";
+import a from "./A7YNU2NS.js";
+import { g as _ } from "./4B3QBH5T.js";
+import { j as u } from "./KUVOINJC.js";
+import { p as h } from "./NKG4FLLR.js";
+export default $geoscene.t(
+  ([
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    { R: l },
+    { c: p, d: d, h: e, i: m, j: b, k: I, l: A, m: L, q: v },
+    { c: r },
+    { a: C, b: V, c: S, d: T, e: B, f: O, g: M, h: z },
+    D,
+    { c: G, d: k, e: y },
+  ]) => {
+    var F = (o) => {
+        for (let i of o.axes ?? []) if (i?.grid !== void 0) return i.grid;
+      },
+      H = (o, i, s) => {
+        let t = i.axes;
+        s.forEach((c) => {
+          t?.[c] !== void 0 && (t[c].grid = _(o));
+        });
+      },
+      N = (o, i) => i.axes?.[o]?.visible ?? !0,
+      Z = (o, i, s) => {
+        let t = s.axes?.[i];
+        t !== void 0 && (t.visible = o);
+      },
+      j = (o, i) => o.axes?.[i]?.displayZeroLine ?? !1,
+      w = (o, i, s) => {
+        o.axes?.[s] !== void 0 && (o.axes[s].displayZeroLine = i);
+      },
+      P = (o, i) => o.axes?.[i]?.displayCursorTooltip ?? !1,
+      U = (o) => {
+        let { config: i, displayCursorTooltip: s, axisIndex: t } = o;
+        i.axes?.[t] !== void 0 && (i.axes[t].displayCursorTooltip = s);
+      },
+      E = (o, i) => o.axes?.[i]?.buffer ?? !1,
+      R = (o) => {
+        let { config: i, buffer: s, axisIndex: t } = o,
+          c = i.axes?.[t];
+        c !== void 0 && (c.buffer = s);
+      },
+      W = (o, i) => o.axes?.[i]?.tickSpacing,
+      X = (o) => {
+        let { config: i, tickSpacing: s, axisIndex: t } = o;
+        i.axes?.[t] !== void 0 && (i.axes[t].tickSpacing = s);
+      },
+      q = (o, i) => o.axes?.[i]?.integerOnlyValues ?? !1,
+      J = (o) => {
+        let { config: i, integerOnlyValues: s, axisIndex: t } = o;
+        i.axes?.[t] !== void 0 && (i.axes[t].integerOnlyValues = s);
+      },
+      K = (o) => o.horizontalAxisLabelsBehavior ?? h.Rotate,
+      Q = (o, i) => {
+        i.horizontalAxisLabelsBehavior = o;
+      },
+      $ = (o) => o.verticalAxisLabelsBehavior ?? h.Wrap,
+      ii = (o, i) => {
+        i.verticalAxisLabelsBehavior = o;
+      },
+      si = (o) => o.cursorCrosshair?.horizontalLineVisible ?? !1,
+      oi = (o, i) => {
+        i.cursorCrosshair === void 0 && (i.cursorCrosshair = l()),
+          (i.cursorCrosshair.horizontalLineVisible = o);
+      },
+      ti = (o) => o.cursorCrosshair?.verticalLineVisible ?? !1,
+      ei = (o, i) => {
+        i.cursorCrosshair === void 0 && (i.cursorCrosshair = l()),
+          (i.cursorCrosshair.verticalLineVisible = o);
+      },
+      ri = (o) => o.cursorCrosshair?.style,
+      ni = (o, i) => {
+        i.cursorCrosshair === void 0 && (i.cursorCrosshair = l()),
+          (i.cursorCrosshair.style = o);
+      },
+      ai = (o) => o.cursorCrosshair,
+      ci = (o, i) => {
+        i.cursorCrosshair = o;
+      },
+      gi = Object.defineProperty,
+      fi = Object.getOwnPropertyDescriptor,
+      a = (o, i, s, t) => {
+        for (var c = fi(i, s), g = o.length - 1, f; g >= 0; g--)
+          (f = o[g]) && (c = f(i, s, c) || c);
+        return c && gi(i, s, c), c;
+      },
+      n = class extends D {
+        getAxisTitleText(i) {
+          return (
+            e({
+              config: this._config,
+              axisIndex: i,
+              func: (s) => S(s, this._config),
+            }) ?? ""
+          );
+        }
+        setAxisTitleText(i, s) {
+          e({
+            config: this._config,
+            axisIndex: s,
+            func: (t) => {
+              T(i, t, this._config);
+            },
+          });
+        }
+        getAxisVisibility(i) {
+          return (
+            e({
+              config: this._config,
+              axisIndex: i,
+              func: (s) => N(s, this._config),
+            }) ?? !0
+          );
+        }
+        setAxisVisibility(i, s) {
+          this.guardSetterFromAsyncOverwrite(() => {
+            e({
+              config: this._config,
+              axisIndex: s,
+              func: (t) => {
+                Z(i, t, this._config),
+                  this.emitConfigUpdate("setAxisVisibility");
+              },
+            });
+          });
+        }
+        getAxisLabelsVisibility(i) {
+          return (
+            e({
+              config: this._config,
+              axisIndex: i,
+              func: (s) => C(s, this._config),
+            }) ?? !0
+          );
+        }
+        setAxisLabelsVisibility(i, s) {
+          this.guardSetterFromAsyncOverwrite(() => {
+            e({
+              config: this._config,
+              axisIndex: s,
+              func: (t) => {
+                V(i, t, this._config),
+                  this.emitConfigUpdate("setAxisLabelsVisibility");
+              },
+            });
+          });
+        }
+        getAxisTitleVisibility(i) {
+          return (
+            e({
+              config: this._config,
+              axisIndex: i,
+              func: (s) => B(s, this._config),
+            }) ?? !1
+          );
+        }
+        setAxisTitleVisibility(i, s) {
+          e({
+            config: this._config,
+            axisIndex: s,
+            func: (t) => {
+              O(i, t, this._config);
+            },
+          });
+        }
+        getMaxBound(i) {
+          return (
+            e({
+              config: this._config,
+              axisIndex: i,
+              func: (s) => p({ config: this._config, axisIndex: s, isMax: !0 }),
+            }) ?? Number.NaN
+          );
+        }
+        setMaxBound(i, s) {
+          e({
+            config: this._config,
+            axisIndex: s,
+            func: (t) => {
+              d({ config: this._config, value: i, axisIndex: t, isMax: !0 });
+            },
+          });
+        }
+        getMinBound(i) {
+          return (
+            e({
+              config: this._config,
+              axisIndex: i,
+              func: (s) => p({ config: this._config, axisIndex: s, isMax: !1 }),
+            }) ?? Number.NaN
+          );
+        }
+        setMinBound(i, s) {
+          e({
+            config: this._config,
+            axisIndex: s,
+            func: (t) => {
+              d({ config: this._config, value: i, axisIndex: t, isMax: !1 });
+            },
+          });
+        }
+        getAxisValueFormat(i) {
+          return e({
+            config: this._config,
+            axisIndex: i,
+            func: (s) => m(s, this._config),
+          });
+        }
+        setAxisValueFormat(i, s) {
+          e({
+            config: this._config,
+            axisIndex: i,
+            func: (t) => {
+              b({
+                config: this._config,
+                valueFormat: s,
+                axisIndex: t,
+                commonStrings: this.commonStrings,
+              });
+            },
+          });
+        }
+        getLogarithmic(i) {
+          return (
+            e({
+              config: this._config,
+              axisIndex: i,
+              func: (s) => I(this._config, s),
+            }) ?? !1
+          );
+        }
+        setLogarithmic(i, s) {
+          e({
+            config: this._config,
+            axisIndex: s,
+            func: (t) => {
+              A({ config: this._config, isLogarithmic: i, axisIndex: t });
+            },
+          });
+        }
+        getAxisScrollbar(i) {
+          return e({
+            config: this._config,
+            axisIndex: i,
+            func: (s) => this._config.axes?.[s]?.scrollbar,
+          });
+        }
+        setAxisScrollbar(i, s) {
+          e({
+            config: this._config,
+            axisIndex: s,
+            func: (t) => {
+              L({ config: this._config, scrollbar: i, axisIndex: t });
+            },
+          });
+        }
+        getAxisTitleSymbol(i) {
+          return e({
+            config: this._config,
+            axisIndex: i,
+            func: (s) => M(this._config, s),
+          });
+        }
+        setAxisTitleSymbol(i, s) {
+          e({
+            config: this._config,
+            axisIndex: s,
+            func: (t) => {
+              z({ symbol: i, config: this._config, axisIndex: t });
+            },
+          });
+        }
+        getHorizontalAxisLabelsBehavior() {
+          return K(this._config);
+        }
+        setHorizontalAxisLabelsBehavior(i) {
+          Q(i, this._config);
+        }
+        getVerticalAxisLabelsBehavior() {
+          return $(this._config);
+        }
+        setVerticalAxisLabelsBehavior(i) {
+          ii(i, this._config);
+        }
+        getGridLinesSymbol() {
+          return F(this._config);
+        }
+        setGridLinesSymbol(i, s) {
+          Array.isArray(s) && H(i, this._config, s);
+        }
+        getDefaultXAxisTitleText() {
+          return this.commonStrings.utilsStrings.statistics.count;
+        }
+        getDisplayZeroLine(i) {
+          return (
+            e({
+              config: this._config,
+              axisIndex: i,
+              func: (s) => j(this._config, s),
+            }) ?? !1
+          );
+        }
+        setDisplayZeroLine(i, s) {
+          e({
+            config: this._config,
+            axisIndex: s,
+            func: (t) => {
+              w(this._config, i, t);
+            },
+          });
+        }
+        getDisplayCursorTooltip(i) {
+          return (
+            e({
+              config: this._config,
+              axisIndex: i,
+              func: (s) => P(this._config, s),
+            }) ?? !1
+          );
+        }
+        setDisplayCursorTooltip(i, s) {
+          e({
+            config: this._config,
+            axisIndex: s,
+            func: (t) => {
+              U({
+                config: this._config,
+                displayCursorTooltip: i,
+                axisIndex: t,
+              });
+            },
+          });
+        }
+        getBuffer(i) {
+          return (
+            e({
+              config: this._config,
+              axisIndex: i,
+              func: (s) => E(this._config, s),
+            }) ?? !1
+          );
+        }
+        setBuffer(i, s) {
+          e({
+            config: this._config,
+            axisIndex: s,
+            func: (t) => {
+              R({ config: this._config, buffer: i, axisIndex: t });
+            },
+          });
+        }
+        getTickSpacing(i) {
+          return W(this._config, i);
+        }
+        setTickSpacing(i, s) {
+          e({
+            config: this._config,
+            axisIndex: s,
+            func: (t) => {
+              X({ config: this._config, tickSpacing: i, axisIndex: t });
+            },
+          });
+        }
+        getIntegerOnlyValues(i) {
+          return (
+            e({
+              config: this._config,
+              axisIndex: i,
+              func: (s) => q(this._config, s),
+            }) ?? !1
+          );
+        }
+        setIntegerOnlyValues(i, s) {
+          e({
+            config: this._config,
+            axisIndex: s,
+            func: (t) => {
+              J({ config: this._config, integerOnlyValues: i, axisIndex: t });
+            },
+          });
+        }
+        get cursorCrosshairHorizontalLineVisibility() {
+          return si(this._config);
+        }
+        set cursorCrosshairHorizontalLineVisibility(i) {
+          oi(i, this._config);
+        }
+        get cursorCrosshairVerticalLineVisibility() {
+          return ti(this._config);
+        }
+        set cursorCrosshairVerticalLineVisibility(i) {
+          ei(i, this._config);
+        }
+        get cursorCrosshairStyle() {
+          return ri(this._config);
+        }
+        set cursorCrosshairStyle(i) {
+          i && ni(i, this._config);
+        }
+        get cursorCrosshair() {
+          return ai(this._config);
+        }
+        set cursorCrosshair(i) {
+          i && ci(i, this._config);
+        }
+      };
+    a([r], n.prototype, "setAxisTitleText");
+    a([r], n.prototype, "setAxisTitleVisibility");
+    a([r], n.prototype, "setMaxBound");
+    a([r], n.prototype, "setMinBound");
+    a([r], n.prototype, "setAxisValueFormat");
+    a([r], n.prototype, "setLogarithmic");
+    a([r], n.prototype, "setAxisScrollbar");
+    a([r], n.prototype, "setAxisTitleSymbol");
+    a([r], n.prototype, "setHorizontalAxisLabelsBehavior");
+    a([r], n.prototype, "setVerticalAxisLabelsBehavior");
+    a([r], n.prototype, "setGridLinesSymbol");
+    a([r], n.prototype, "setDisplayZeroLine");
+    a([r], n.prototype, "setDisplayCursorTooltip");
+    a([r], n.prototype, "setBuffer");
+    a([r], n.prototype, "setTickSpacing");
+    a([r], n.prototype, "setIntegerOnlyValues");
+    a([r], n.prototype, "cursorCrosshairHorizontalLineVisibility");
+    a([r], n.prototype, "cursorCrosshairVerticalLineVisibility");
+    a([r], n.prototype, "cursorCrosshairStyle");
+    a([r], n.prototype, "cursorCrosshair");
+    var xi = Object.defineProperty,
+      li = Object.getOwnPropertyDescriptor,
+      Y = (o, i, s, t) => {
+        for (var c = li(i, s), g = o.length - 1, f; g >= 0; g--)
+          (f = o[g]) && (c = f(i, s, c) || c);
+        return c && xi(i, s, c), c;
+      },
+      x = class extends y {
+        getYGuidesLength() {
+          return this._config.axes?.[1]?.guides?.length;
+        }
+        addYAxisGuide(i, s) {
+          G({ config: this._config, name: i, index: s, orientation: u.Y });
+        }
+        deleteYAxisGuide(i) {
+          k({ config: this._config, index: i, orientation: u.Y });
+        }
+      };
+    Y([r], x.prototype, "addYAxisGuide");
+    Y([r], x.prototype, "deleteYAxisGuide");
+    var hi = [y];
+    v(x, hi);
+    return { a: n, b: x };
+  },
+  "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
+);

package/dist/cdn/YOQQ22ZG.js

@@ -0,0 +1,209 @@
+/* COPYRIGHT  - https://js.geoscene.cn/5.0/LICENSE.txt */
+import "./OR4HXHSY.js";
+var a = {
+  _decimalSeparator: ",",
+  _thousandSeparator: ".",
+  _percentPrefix: null,
+  _percentSuffix: "%",
+  _big_number_suffix_3: "k",
+  _big_number_suffix_6: "M",
+  _big_number_suffix_9: "G",
+  _big_number_suffix_12: "T",
+  _big_number_suffix_15: "P",
+  _big_number_suffix_18: "E",
+  _big_number_suffix_21: "Z",
+  _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_second: "HH:mm:ss",
+  _date_minute: "HH:mm",
+  _date_hour: "HH:mm",
+  _date_day: "MMM dd",
+  _date_week: "ww",
+  _date_month: "MMM",
+  _date_year: "yyyy",
+  _duration_millisecond: "SSS",
+  _duration_millisecond_second: "ss.SSS",
+  _duration_millisecond_minute: "mm:ss SSS",
+  _duration_millisecond_hour: "hh:mm:ss SSS",
+  _duration_millisecond_day: "d'd' mm:ss SSS",
+  _duration_millisecond_week: "d'd' mm:ss SSS",
+  _duration_millisecond_month: "M'm' dd'd' mm:ss SSS",
+  _duration_millisecond_year: "y'y' MM'm' dd'd' mm:ss SSS",
+  _duration_second: "ss",
+  _duration_second_minute: "mm:ss",
+  _duration_second_hour: "hh:mm:ss",
+  _duration_second_day: "d'd' hh:mm:ss",
+  _duration_second_week: "d'd' hh:mm:ss",
+  _duration_second_month: "M'm' dd'd' hh:mm:ss",
+  _duration_second_year: "y'y' MM'm' dd'd' hh:mm:ss",
+  _duration_minute: "mm",
+  _duration_minute_hour: "hh:mm",
+  _duration_minute_day: "d'd' hh:mm",
+  _duration_minute_week: "d'd' hh:mm",
+  _duration_minute_month: "M'm' dd'd' hh:mm",
+  _duration_minute_year: "y'y' MM'm' dd'd' hh:mm",
+  _duration_hour: "hh'h'",
+  _duration_hour_day: "d'd' hh'h'",
+  _duration_hour_week: "d'd' hh'h'",
+  _duration_hour_month: "M'm' dd'd' hh'h'",
+  _duration_hour_year: "y'y' MM'm' dd'd' hh'h'",
+  _duration_day: "d'd'",
+  _duration_day_week: "d'd'",
+  _duration_day_month: "M'm' dd'd'",
+  _duration_day_year: "y'y' MM'm' dd'd'",
+  _duration_week: "w'w'",
+  _duration_week_month: "w'w'",
+  _duration_week_year: "w'w'",
+  _duration_month: "M'm'",
+  _duration_month_year: "y'y' MM'm'",
+  _duration_year: "y'y'",
+  _era_ad: "e.Kr.",
+  _era_bc: "f.Kr.",
+  A: "a",
+  P: "p",
+  AM: "AM",
+  PM: "PM",
+  "A.M.": "AM",
+  "P.M.": "PM",
+  January: "januar",
+  February: "februar",
+  March: "marts",
+  April: "april",
+  May: "maj",
+  June: "juni",
+  July: "juli",
+  August: "august",
+  September: "september",
+  October: "oktober",
+  November: "november",
+  December: "december",
+  Jan: "jan.",
+  Feb: "feb.",
+  Mar: "mar.",
+  Apr: "apr.",
+  "May(short)": "maj",
+  Jun: "jun.",
+  Jul: "jul.",
+  Aug: "aug.",
+  Sep: "sep.",
+  Oct: "okt.",
+  Nov: "nov.",
+  Dec: "dec.",
+  Sunday: "s\xF8ndag",
+  Monday: "mandag",
+  Tuesday: "tirsdag",
+  Wednesday: "onsdag",
+  Thursday: "torsdag",
+  Friday: "fredag",
+  Saturday: "l\xF8rdag",
+  Sun: "s\xF8n.",
+  Mon: "man.",
+  Tue: "tir.",
+  Wed: "ons.",
+  Thu: "tor.",
+  Fri: "fre.",
+  Sat: "l\xF8r.",
+  _dateOrd: function (r) {
+    var e = "th";
+    if (r < 11 || r > 13)
+      switch (r % 10) {
+        case 1:
+          e = "st";
+          break;
+        case 2:
+          e = "nd";
+          break;
+        case 3:
+          e = "rd";
+          break;
+      }
+    return e;
+  },
+  "Zoom Out": "Zoom",
+  Play: "Afspil",
+  Stop: "Stop",
+  Legend: "Signaturforklaring",
+  "Click, tap or press ENTER to toggle": "",
+  Loading: "Indl\xE6ser",
+  Home: "Hjem",
+  Chart: "",
+  "Serial chart": "",
+  "X/Y chart": "",
+  "Pie chart": "",
+  "Gauge chart": "",
+  "Radar chart": "",
+  "Sankey diagram": "",
+  "Flow diagram": "",
+  "Chord diagram": "",
+  "TreeMap chart": "",
+  "Sliced chart": "",
+  Series: "",
+  "Candlestick Series": "",
+  "OHLC Series": "",
+  "Column Series": "",
+  "Line Series": "",
+  "Pie Slice Series": "",
+  "Funnel Series": "",
+  "Pyramid Series": "",
+  "X/Y Series": "",
+  Map: "",
+  "Press ENTER to zoom in": "",
+  "Press ENTER to zoom out": "",
+  "Use arrow keys to zoom in and out": "",
+  "Use plus and minus keys on your keyboard to zoom in and out": "",
+  Export: "Udskriv",
+  Image: "Billede",
+  Data: "Data",
+  Print: "Udskriv",
+  "Click, tap or press ENTER to open": "",
+  "Click, tap or press ENTER to print.": "",
+  "Click, tap or press ENTER to export as %1.": "",
+  'To save the image, right-click this link and choose "Save picture as..."':
+    "",
+  'To save the image, right-click thumbnail on the left and choose "Save picture as..."':
+    "",
+  "(Press ESC to close this message)": "",
+  "Image Export Complete": "",
+  "Export operation took longer than expected. Something might have gone wrong.":
+    "",
+  "Saved from": "",
+  PNG: "",
+  JPG: "",
+  GIF: "",
+  SVG: "",
+  PDF: "",
+  JSON: "",
+  CSV: "",
+  XLSX: "",
+  "Use TAB to select grip buttons or left and right arrows to change selection":
+    "",
+  "Use left and right arrows to move selection": "",
+  "Use left and right arrows to move left selection": "",
+  "Use left and right arrows to move right selection": "",
+  "Use TAB select grip buttons or up and down arrows to change selection": "",
+  "Use up and down arrows to move selection": "",
+  "Use up and down arrows to move lower selection": "",
+  "Use up and down arrows to move upper selection": "",
+  "From %1 to %2": "Fra %1 til %2",
+  "From %1": "Fra %1",
+  "To %1": "Til %1",
+  "No parser available for file: %1": "",
+  "Error parsing file: %1": "",
+  "Unable to load file: %1": "",
+  "Invalid date": "",
+};
+export { a as default };