@geoscene/charts-components 5.0.19

package/dist/cdn/FL37YOHH.js

@@ -0,0 +1,217 @@
+/* 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: "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_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 - MMM dd, yyyy",
+  _date_hour: "HH:mm",
+  _date_hour_short: "HH",
+  _date_hour_full: "HH:mm - MMM dd, yyyy",
+  _date_day: "MMM dd",
+  _date_day_full: "MMM dd, yyyy",
+  _date_week: "ww",
+  _date_week_full: "MMM dd, yyyy",
+  _date_month: "MMM",
+  _date_month_full: "MMM, yyyy",
+  _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: "d.Hr.",
+  _era_bc: "\xEE.Hr.",
+  A: "a.m.",
+  P: "p.m.",
+  AM: "a.m.",
+  PM: "p.m.",
+  "A.M.": "a.m.",
+  "P.M.": "p.m.",
+  January: "ianuarie",
+  February: "februarie",
+  March: "martie",
+  April: "aprilie",
+  May: "mai",
+  June: "iunie",
+  July: "iulie",
+  August: "august",
+  September: "septembrie",
+  October: "octombrie",
+  November: "noiembrie",
+  December: "decembrie",
+  Jan: "ian.",
+  Feb: "feb.",
+  Mar: "mar.",
+  Apr: "apr.",
+  "May(short)": "mai",
+  Jun: "iun.",
+  Jul: "iul.",
+  Aug: "aug.",
+  Sep: "sept.",
+  Oct: "oct.",
+  Nov: "nov.",
+  Dec: "dec.",
+  Sunday: "duminic\u0103",
+  Monday: "luni",
+  Tuesday: "mar\u021Bi",
+  Wednesday: "miercuri",
+  Thursday: "joi",
+  Friday: "vineri",
+  Saturday: "s\xE2mb\u0103t\u0103",
+  Sun: "dum.",
+  Mon: "lun.",
+  Tue: "mar.",
+  Wed: "mie.",
+  Thu: "joi",
+  Fri: "vin.",
+  Sat: "s\xE2m.",
+  _dateOrd: function (_) {
+    let e = "th";
+    if (_ < 11 || _ > 13)
+      switch (_ % 10) {
+        case 1:
+          e = "st";
+          break;
+        case 2:
+          e = "nd";
+          break;
+        case 3:
+          e = "rd";
+          break;
+      }
+    return e;
+  },
+  "Zoom Out": "Zoom",
+  Play: "Redare",
+  Stop: "Oprire",
+  Legend: "Legend\u0103",
+  "Press ENTER to toggle": "",
+  Loading: "Se \xEEncarc\u0103",
+  Home: "Pagina principal\u0103",
+  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: "Imprimare",
+  Image: "Imagine",
+  Data: "Date",
+  Print: "Imprimare",
+  "Press ENTER to open": "",
+  "Press ENTER to print.": "",
+  "Press ENTER to export as %1.": "",
+  "(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: "",
+  HTML: "",
+  "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": "Din %1 la %2",
+  "From %1": "Din %1",
+  "To %1": "La %1",
+  "No parser available for file: %1": "",
+  "Error parsing file: %1": "",
+  "Unable to load file: %1": "",
+  "Invalid date": "",
+  Close: "",
+  Minimize: "",
+  Confirm: "",
+};
+export { r as default };

package/dist/cdn/FPSTP5OC.js

@@ -0,0 +1,392 @@
+/* COPYRIGHT  - https://js.geoscene.cn/5.0/LICENSE.txt */
+import { a as b } from "./KJHME2ZX.js";
+import { a as I, b as E } from "./ZLQXY2BV.js";
+import e from "./5752NFTR.js";
+import "./DPJE33GY.js";
+import { a as c } from "./VAB3BCTX.js";
+import d from "./P5SSZWMH.js";
+import "./UG7LOBJE.js";
+import a from "./A7YNU2NS.js";
+import { i as m } from "./4B3QBH5T.js";
+import "./XLDY6CTA.js";
+import "./KUVOINJC.js";
+import { a as l } from "./NKG4FLLR.js";
+import {
+  A as o,
+  D as v,
+  F as C,
+  g as N,
+  h as n,
+  x as h,
+  y as r,
+  z as f,
+} from "./KRZ433BT.js";
+import "./OR4HXHSY.js";
+export default $geoscene.t(
+  ([, , { a: M, g: g, h: x, i: B, j: a }]) => {
+    var u = { linkContainer: "link-container", label: "label", mb2: "mb-2" },
+      L = N`.hide{visibility:hidden}.am5-html-container{z-index:101!important}.am5-layer-1000{z-index:1000!important}.am5-layer-30{z-index:100!important}.show{display:block}.notifyPanel{flex:0 1 auto}.disable-interactions{pointer-events:none}.dim-text{color:var(--geoscene-charts-dim-text)}calcite-block{width:var(--geoscene-charts-config-calcite-block-width, var(--geoscene-charts-config-calcite-block-default-width));height:var(--geoscene-charts-config-calcite-block-height, var(--geoscene-charts-config-calcite-block-default-height));border:0px;-webkit-box-shadow:0 0 0 0;box-shadow:0 0}.label{display:flex;justify-content:space-between}.mb-2{margin-bottom:var(--geoscene-charts-config-margin-minor)}.link-container{display:flex;justify-content:flex-end;margin-top:-.75rem}`,
+      p = class extends f {
+        constructor() {
+          super(...arguments),
+            (this._messages = c()),
+            (this.commonStrings = c({ name: "common", blocking: !0 })),
+            (this.axisModel = new b()),
+            (this.minBoundInputElement = h()),
+            (this.maxBoundInputElement = h()),
+            (this.showLogScaleSwitch = h()),
+            (this.defaultMinBound = Number.NaN),
+            (this.defaultMaxBound = Number.NaN),
+            (this.onMaxBoundsChange = () => {
+              let e = this.maxBoundInputElement.value?.value,
+                t = this.maxBoundInputElement.value?.status;
+              if (e !== void 0 && e !== "") {
+                let s =
+                    this.maxBoundInputElement.value?.min === void 0
+                      ? this.axisModel.getMinBound()
+                      : Math.max(
+                          this.maxBoundInputElement.value.min,
+                          this.axisModel.getMinBound()
+                        ),
+                  i = Number.parseFloat(e);
+                if (
+                  i !== this.axisModel.getMinBound() &&
+                  g(i, s, this.maxBoundInputElement.value?.max)
+                ) {
+                  if (i !== this.axisModel.getMaxBound()) {
+                    this.axisModel.setMaxBound(i);
+                    let d = this.getAxisBoundsFromStateStore();
+                    d && (d.currMaxBound = i);
+                  }
+                  t = a.IDLE;
+                } else t = a.INVALID;
+              } else t = a.IDLE;
+              this.maxBoundInputElement.value &&
+                B({ inputElement: this.maxBoundInputElement.value, status: t }),
+                t !== a.INVALID &&
+                  this.minBoundInputElement.value?.status === a.INVALID &&
+                  this.onMinBoundsChange(),
+                this.requestUpdate();
+            }),
+            (this.onMaxBoundsChangeDebounced = m(
+              this.onMaxBoundsChange,
+              M.DebounceTimer
+            )),
+            (this.onMinBoundsChange = () => {
+              let e = this.minBoundInputElement.value?.value,
+                t = this.minBoundInputElement.value?.status;
+              if (e !== void 0 && e !== "") {
+                let s =
+                    this.minBoundInputElement.value?.max === void 0
+                      ? this.axisModel.getMaxBound()
+                      : Math.min(
+                          this.minBoundInputElement.value.max,
+                          this.axisModel.getMaxBound()
+                        ),
+                  i = Number.parseFloat(e);
+                if (
+                  i !== this.axisModel.getMaxBound() &&
+                  g(i, this.minBoundInputElement.value?.min, s)
+                ) {
+                  if (i !== this.axisModel.getMinBound()) {
+                    this.axisModel.setMinBound(i);
+                    let d = this.getAxisBoundsFromStateStore();
+                    d && (d.currMinBound = i);
+                  }
+                  t = a.IDLE;
+                } else t = a.INVALID;
+              } else t = a.IDLE;
+              this.minBoundInputElement.value &&
+                B({ inputElement: this.minBoundInputElement.value, status: t }),
+                t !== a.INVALID &&
+                  this.maxBoundInputElement.value?.status === a.INVALID &&
+                  this.onMaxBoundsChange(),
+                this.updateEnableLogarithmic(
+                  this.axisModel.getLogarithmic() &&
+                    (this.dataMinValue ?? Number.NaN) > 0
+                ),
+                this.requestUpdate();
+            }),
+            (this.onMinBoundsChangeDebounced = m(
+              this.onMinBoundsChange,
+              M.DebounceTimer
+            )),
+            (this.onModelConfigChange = () => {
+              this.requestUpdate();
+            }),
+            (this.disableMaxBoundResetBtn = !0),
+            (this.disableMinBoundResetBtn = !0),
+            (this.isXAxis = !1),
+            (this.axisTitle = "");
+        }
+        static {
+          this.properties = {
+            disableMaxBoundResetBtn: 16,
+            disableMinBoundResetBtn: 16,
+            messageOverrides: 0,
+            model: 0,
+            isXAxis: 5,
+            axisTitle: 1,
+            maxBoundMaxLimit: 9,
+            maxBoundMinLimit: 9,
+            minBoundMinLimit: 9,
+            minBoundMaxLimit: 9,
+            showMaxBoundOption: 5,
+            showMinBoundOption: 5,
+            showEnableLogOption: 5,
+            dataMaxValue: 9,
+            dataMinValue: 9,
+            initialMaxBound: 9,
+            initialMinBound: 9,
+          };
+        }
+        static {
+          this.styles = L;
+        }
+        load() {
+          this.modelChange(this.model),
+            this.dataMinValue !== void 0 &&
+              this.dataMinValueChange(this.dataMinValue, Number.NaN),
+            this.dataMaxValue !== void 0 &&
+              this.dataMaxValueChange(this.dataMaxValue, Number.NaN);
+        }
+        willUpdate(e) {
+          e.has("model") && this.modelChange(this.model, e.get("model")),
+            e.has("dataMinValue") &&
+              this.dataMinValueChange(
+                this.dataMinValue ?? Number.NaN,
+                e.get("dataMinValue")
+              ),
+            e.has("dataMaxValue") &&
+              this.dataMaxValueChange(
+                this.dataMaxValue ?? Number.NaN,
+                e.get("dataMaxValue")
+              ),
+            e.has("initialMaxBound") && this.initialMaxBoundChange(),
+            e.has("initialMinBound") && this.initialMinBoundChange();
+        }
+        updated() {
+          this.disableResetButtons();
+        }
+        disconnectedCallback() {
+          super.disconnectedCallback(),
+            this.model.removeEventListener(
+              "geosceneChartsModelConfigChange",
+              this.onModelConfigChange
+            );
+        }
+        modelChange(e, t) {
+          (this.axisModel = new b(this.model, this.isXAxis)),
+            t?.removeEventListener(
+              "geosceneChartsModelConfigChange",
+              this.onModelConfigChange
+            ),
+            e?.addEventListener(
+              "geosceneChartsModelConfigChange",
+              this.onModelConfigChange
+            );
+        }
+        dataMinValueChange(e, t) {
+          Number.isNaN(t) && !Number.isNaN(e) && (this.defaultMinBound = e);
+        }
+        dataMaxValueChange(e, t) {
+          Number.isNaN(t) && !Number.isNaN(e) && (this.defaultMaxBound = e);
+        }
+        initialMaxBoundChange() {
+          Number.isNaN(this.axisModel.getMaxBound()) ||
+            this.axisModel.setMaxBound(this.axisModel.getMaxBound());
+        }
+        initialMinBoundChange() {
+          Number.isNaN(this.axisModel.getMinBound()) ||
+            this.axisModel.setMinBound(this.axisModel.getMinBound());
+        }
+        getAxisBoundsFromStateStore() {
+          let e,
+            t = I.chartAxesBoundDataMap,
+            s = this.model.chartId;
+          if (s) {
+            let i = E({
+              chartId: s,
+              isXAxis: this.isXAxis,
+              isLogarithmic: this.axisModel.getLogarithmic(),
+            });
+            e = t[s]?.[i];
+          }
+          return e;
+        }
+        disableResetButtons() {
+          let e = this.getAxisBoundsFromStateStore();
+          e &&
+            ((this.disableMaxBoundResetBtn =
+              e.defaultMaxBound === e.currMaxBound),
+            (this.disableMinBoundResetBtn =
+              e.defaultMinBound === e.currMinBound));
+        }
+        onShowLogScaleMouseEnter() {
+          this.showLogScaleTooltip?.remove(),
+            this.showLogScaleSwitch.value?.disabled &&
+              ((this.showLogScaleTooltip = v(
+                n`<calcite-tooltip .referenceElement=${
+                  this.showLogScaleSwitch.value ?? document.body
+                } open>${
+                  this.commonStrings.utilsStrings.tooltips?.logDisabled ?? ""
+                }</calcite-tooltip>`
+              )),
+              document.body.appendChild(this.showLogScaleTooltip));
+        }
+        onShowLogScaleMouseLeave() {
+          this.showLogScaleTooltip?.remove();
+        }
+        onCategoryFormatChange(e) {
+          this.axisModel.setValueFormat(e.target.categoryFormat);
+        }
+        updateEnableLogarithmic(e) {
+          e !== this.axisModel.getLogarithmic() &&
+            (this.axisModel.setLogarithmic(e), this.requestUpdate());
+        }
+        onNumberFormatChange(e) {
+          this.axisModel.setValueFormat({
+            type: l.NumberAxisFormat,
+            intlOptions: e.detail,
+          }),
+            this.requestUpdate();
+        }
+        onRevertMaxBoundsToDefault() {
+          if (
+            this.maxBoundInputElement.value?.status === a.INVALID ||
+            this.axisModel.getMaxBound() !== this.defaultMaxBound
+          ) {
+            let e = this.getAxisBoundsFromStateStore();
+            this.axisModel.getMinBound() > this.defaultMaxBound &&
+              this.axisModel.setMinBound(e?.defaultMinBound ?? Number.NaN),
+              this.axisModel.setMaxBound(e?.defaultMaxBound ?? Number.NaN),
+              this.requestUpdate();
+          }
+        }
+        onRevertMinBoundsToDefault() {
+          (this.minBoundInputElement.value?.status === a.INVALID ||
+            this.axisModel.getMinBound() !== this.defaultMinBound) &&
+            (this.axisModel.getMaxBound() < this.defaultMinBound &&
+              this.axisModel.setMaxBound(Number.NaN),
+            this.axisModel.setMinBound(Number.NaN),
+            this.requestUpdate());
+        }
+        enableLogScale(e) {
+          let { checked: t } = e.target;
+          this.axisModel.setLogarithmic(
+            t && (this.dataMinValue ?? Number.NaN) > 0
+          ),
+            this.requestUpdate();
+        }
+        render() {
+          return n`<calcite-block .hidden=${
+            this.axisModel.getValueFormat()?.type === l.DateAxisFormat
+          } expanded .heading=${
+            this.axisTitle
+          }>${this.renderAxis()}</calcite-block>`;
+        }
+        renderAxis() {
+          let e = null,
+            t = { ...this.axisModel.getValueFormat() };
+          switch (this.axisModel.getValueFormat()?.type) {
+            case l.CategoryAxisFormat:
+              e = n`<geoscene-charts-config-category-format .categoryFormat=${t} @geosceneChartsConfigCategoryFormatChange=${this.onCategoryFormatChange}></geoscene-charts-config-category-format>`;
+              break;
+            case l.NumberAxisFormat:
+              e = n`<div>${this.renderShowLogScale()}${this.renderMinBound()}${this.renderMaxBound()}<geoscene-charts-config-number-format .numberFormat=${{
+                ...t.intlOptions,
+              }} @geosceneChartsConfigNumberFormatChange=${
+                this.onNumberFormatChange
+              }></geoscene-charts-config-number-format></div>`;
+              break;
+            case l.DateAxisFormat:
+              e = null;
+              break;
+          }
+          return e;
+        }
+        renderMaxBound() {
+          let e;
+          if (!this.showMaxBoundOption) e = null;
+          else {
+            let t = x(this.axisModel.getMaxBound(), this.initialMaxBound);
+            e = n`<div><calcite-label class=${o(u.label)}>${
+              this._messages.maxBounds
+            }<calcite-input type=number number-button-type=none .min=${
+              this.maxBoundMinLimit ?? Number.MIN_SAFE_INTEGER
+            } .max=${
+              this.maxBoundMaxLimit ?? Number.MAX_SAFE_INTEGER
+            } step=any .value=${t} @calciteInputInput=${
+              this.onMaxBoundsChangeDebounced
+            } ${r(
+              this.maxBoundInputElement
+            )}></calcite-input></calcite-label><div class=${o(
+              u.linkContainer
+            )}><calcite-button .disabled=${
+              this.disableMaxBoundResetBtn
+            } @click=${
+              this.onRevertMaxBoundsToDefault
+            } appearance=transparent icon-end=reset>${
+              this._messages.revertToDefault
+            }</calcite-button></div></div>`;
+          }
+          return e;
+        }
+        renderMinBound() {
+          let e;
+          if (!this.showMinBoundOption) e = null;
+          else {
+            let t = x(
+              this.axisModel.getMinBound(),
+              this.initialMinBound ?? void 0
+            );
+            e = n`<div><calcite-label class=${o(u.label)}>${
+              this._messages.minBounds
+            }<calcite-input type=number number-button-type=none .min=${
+              this.minBoundMinLimit ?? Number.MIN_SAFE_INTEGER
+            } .max=${
+              this.minBoundMaxLimit ?? Number.MAX_SAFE_INTEGER
+            } step=any .value=${t} @calciteInputInput=${
+              this.onMinBoundsChangeDebounced
+            } ${r(
+              this.minBoundInputElement
+            )}></calcite-input></calcite-label><div class=${o(
+              u.linkContainer
+            )}><calcite-button .disabled=${
+              this.disableMinBoundResetBtn
+            } appearance=transparent icon-end=reset @click=${
+              this.onRevertMinBoundsToDefault
+            }>${this._messages.revertToDefault}</calcite-button></div></div>`;
+          }
+          return e;
+        }
+        renderShowLogScale() {
+          let e;
+          return (
+            this.showEnableLogOption &&
+              (e = n`<calcite-label layout=inline-space-between class=${o({
+                [u.label]: !0,
+                [u.mb2]: !0,
+              })}>${this._messages.logScale}<div @mouseenter=${
+                this.onShowLogScaleMouseEnter
+              } @mouseleave=${
+                this.onShowLogScaleMouseLeave
+              }><calcite-switch .checked=${
+                this.axisModel.getLogarithmic() &&
+                (this.dataMinValue ?? Number.NaN) > 0
+              } .disabled=${
+                (this.dataMinValue ?? Number.NaN) <= 0
+              } @calciteSwitchChange=${this.enableLogScale} ${r(
+                this.showLogScaleSwitch
+              )}></calcite-switch></div></calcite-label>`),
+            e
+          );
+        }
+      };
+    C("geoscene-charts-config-axis", p);
+    return p;
+  },
+  a,
+  d,
+  e
+);