@geoscene/charts-components 5.0.19

package/dist/cdn/W2ZT3M5X.js

@@ -0,0 +1,477 @@
+/* COPYRIGHT  - https://js.geoscene.cn/5.0/LICENSE.txt */
+import { a as w } from "./HAGP76HP.js";
+import { a as N } from "./FEJD2JHY.js";
+import { a as u, c as P, d as T, f as _ } from "./ZLQXY2BV.js";
+import { f as l } from "./DPJE33GY.js";
+import { a as C } from "./VAB3BCTX.js";
+import e from "./AENRD2JF.js";
+import a from "./A7YNU2NS.js";
+import { n as I } from "./4B3QBH5T.js";
+import "./XLDY6CTA.js";
+import "./KUVOINJC.js";
+import { b as h, k as b, n as d } from "./NKG4FLLR.js";
+import {
+  A as s,
+  D as x,
+  F as A,
+  g as y,
+  h as r,
+  m as g,
+  x as c,
+  y as m,
+  z as F,
+} from "./KRZ433BT.js";
+import "./OR4HXHSY.js";
+export default $geoscene.t(
+  ([
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    { Gb: p, Ia: B, Ja: k, Lb: S, Nc: f, Pc: E },
+    { h: L },
+  ]) => {
+    var z = y`.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)}:host{display:flex;flex-direction:column;width:var(--geoscene-charts-config-calcite-block-default-width);margin:var(--geoscene-charts-config-calcite-block-default-margin);margin-top:var(--geoscene-charts-top-section-margin)}.label,.disabled-label{display:flex;margin-left:.5rem;margin-right:.5rem;margin-bottom:.5rem;justify-content:space-between}.time-binning-header{display:flex;font-weight:700;margin-left:.5rem;margin-right:.5rem;justify-content:space-between}.field-list{max-height:50vh;overflow-y:auto}.disabled-label{pointer-events:none}.fab{display:flex;margin-left:.5rem;margin-right:.5rem;margin-bottom:1.5rem;justify-content:center}.link-container{display:flex;justify-content:flex-end}`,
+      n = {
+        label: "label",
+        fieldList: "field-list",
+        fab: "fab",
+        timeBinningHeader: "time-binning-header",
+        linkContainer: "link-container",
+        dimText: "dim-text",
+      },
+      $ = class extends F {
+        constructor() {
+          super(...arguments),
+            (this._messages = C()),
+            (this.commonStrings = C({ name: "common", blocking: !0 })),
+            (this.lineChartPopover = null),
+            (this.aggregationElement = c()),
+            (this.xAxisFieldElement = c()),
+            (this.numericFieldsElement = c()),
+            (this.splitByFieldElement = c()),
+            (this.intervalAlignmentElement = c()),
+            (this.intervalElement = c()),
+            (this.onLineChartDataChange = (e) => {
+              try {
+                if (e.detail !== null && e.detail?.value !== void 0) {
+                  let { contentKind: t } = e.detail,
+                    i = [...e.detail.value];
+                  switch ((P(u), t)) {
+                    case l.aggregation:
+                      this.model.aggregationType =
+                        i[0] !== h.NoAggregation ? i[0] : h.NoAggregation;
+                      break;
+                    case l.xAxisField: {
+                      let a = i[0]?.trim() || "";
+                      (this.model.xAxisField = a),
+                        this.geosceneChartsConfigResetTimeInterval.emit();
+                      break;
+                    }
+                    case l.numericFields:
+                      (this.model.numericFields = i),
+                        this.model.numericFields.length > 0 &&
+                          this.model.aggregationType === h.Count &&
+                          this.model.numericFields[0] !==
+                            f(this.model.layer).idField &&
+                          (this.model.aggregationType = h.Sum);
+                      break;
+                    case l.splitByField: {
+                      let a = i[0]?.trim() || "";
+                      (this.model.splitByField = a),
+                        (this.model.colorMatch = !0);
+                      break;
+                    }
+                    case l.interval:
+                      (this.model.temporalBinningSize = i[0]?.intervalSize),
+                        (this.model.temporalBinningUnit = i[0]?.intervalUnits),
+                        this.geosceneChartsConfigCustomizedTimeInterval.emit();
+                      break;
+                    case l.intervalAlignment:
+                      this.model.timeAggregationType = i[0] ?? "";
+                      break;
+                    default:
+                      break;
+                  }
+                  t !== l.interval && t !== l.intervalAlignment && _(u);
+                }
+              } catch (t) {
+                throw (
+                  (t instanceof Error &&
+                    this.geosceneChartsConfigDataChangeError.emit({
+                      error: t,
+                      model: this.model,
+                    }),
+                  t)
+                );
+              }
+              this.removeLineChartDataPopover(), this.requestUpdate();
+            }),
+            (this.onModelConfigChange = () => {
+              this.requestUpdate();
+            }),
+            (this.popoverClose = (e) => {
+              this.lineChartPopover === e?.target &&
+                this.removeLineChartDataPopover();
+            }),
+            (this.layerFieldsInfo = []),
+            (this.geosceneChartsConfigCustomizedTimeInterval = g()),
+            (this.geosceneChartsConfigDataChangeError = g()),
+            (this.geosceneChartsConfigLineChartDataNumericFieldValidate = g()),
+            (this.geosceneChartsConfigResetTimeInterval = g());
+        }
+        static {
+          this.properties = {
+            aggregationLabel: 16,
+            timeAggregationLabel: 16,
+            disableSplitBy: 16,
+            messageOverrides: 0,
+            model: 0,
+            resetTimeInterval: 0,
+            layerFieldsInfo: 0,
+          };
+        }
+        static {
+          this.styles = z;
+        }
+        load() {
+          this.modelChange(this.model), this.onModelConfigChange();
+        }
+        willUpdate(e) {
+          e.has("model") && this.modelChange(this.model, e.get("model")),
+            (this.aggregationLabel = B(
+              this.model.aggregationType,
+              this.commonStrings
+            ));
+          let t = this.model.timeAggregationType;
+          t !== void 0 &&
+            (this.timeAggregationLabel = k(t, this.commonStrings)),
+            (this.disableSplitBy = this.model.numericFields.length > 1);
+        }
+        disconnectedCallback() {
+          super.disconnectedCallback(),
+            this.removeLineChartDataPopover(),
+            this.model.removeEventListener(
+              "geosceneChartsModelConfigChange",
+              this.onModelConfigChange
+            );
+        }
+        modelChange(e, t) {
+          t?.removeEventListener(
+            "geosceneChartsModelConfigChange",
+            this.onModelConfigChange
+          ),
+            e?.addEventListener(
+              "geosceneChartsModelConfigChange",
+              this.onModelConfigChange
+            );
+        }
+        buildNumericFieldItem(e) {
+          return w(
+            e,
+            r`<calcite-list-item .label=${p(
+              this.layerFieldsInfo,
+              e
+            )} .value=${e} closable @calciteListItemClose=${
+              this.onRemoveNumericField
+            }></calcite-list-item>`
+          );
+        }
+        resetTimeIntervalOriginal(e) {
+          this.popoverClose(e),
+            this.model.resetTimeInterval !== void 0 &&
+              (this.model.resetTimeInterval(),
+              this.geosceneChartsConfigResetTimeInterval.emit());
+        }
+        onAggregationSelect(e) {
+          (this.contentKind = l.aggregation), this.setupPopover(e);
+        }
+        onXAxisFieldSelect(e) {
+          (this.contentKind = l.xAxisField), this.setupPopover(e);
+        }
+        onSplitBySelect(e) {
+          this.splitByFieldElement.value &&
+            !this.splitByFieldElement.value.disabled &&
+            ((this.contentKind = l.splitByField), this.setupPopover(e));
+        }
+        onAddNumericFields(e) {
+          (this.contentKind = l.numericFields), this.setupPopover(e);
+        }
+        onRemoveNumericField(e) {
+          let t = e.target.value;
+          this.model.numericFields = this.model.numericFields.filter(
+            (i) => i !== t
+          );
+        }
+        onIntervalAlignmentSelect(e) {
+          this.intervalAlignmentElement.value &&
+            !this.intervalAlignmentElement.value.disabled &&
+            ((this.contentKind = l.intervalAlignment), this.setupPopover(e));
+        }
+        onIntervalSelect(e) {
+          this.intervalElement.value &&
+            !this.intervalElement.value.disabled &&
+            ((this.contentKind = l.interval), this.setupPopover(e));
+        }
+        getCorrectedSplitByValue() {
+          return this.model.splitByField === "" ||
+            this.model.numericFields.length > 1
+            ? ""
+            : p(this.layerFieldsInfo, this.model.splitByField);
+        }
+        getCorrectedXAxisValue() {
+          return L({
+            fieldName: this.model.xAxisField,
+            fieldList: this.layerFieldsInfo,
+          })
+            ? ""
+            : p(this.layerFieldsInfo, this.model.xAxisField);
+        }
+        onShowDataLabelsChange(e) {
+          this.model.dataLabelsVisibility = e.target.checked;
+        }
+        onTrimIncompleteIntervalChange(e) {
+          this.model.trimIncompleteTimeInterval = e.target.checked;
+        }
+        onNullPolicyChange(e) {
+          this.model.nullPolicy = e.target.selectedItem.value;
+        }
+        shouldShowTimeBinning() {
+          let e = this.layerFieldsInfo.find(
+              (i) => i.name === this.model.xAxisField
+            ),
+            t = this.model.aggregationType !== h.NoAggregation;
+          return e !== void 0 && E(e) && t;
+        }
+        setupPopover(e) {
+          e.stopImmediatePropagation(), this.removeLineChartDataPopover();
+          let t = {
+              size: this.model.temporalBinningSize ?? 1,
+              unit: this.model.temporalBinningUnit ?? b.Second,
+            },
+            i,
+            a,
+            o;
+          switch (this.contentKind) {
+            case l.aggregation:
+              (i = this.aggregationElement.value),
+                (a = this._messages.aggregationHeader),
+                (o = this.model.aggregationType);
+              break;
+            case l.xAxisField:
+              (i = this.xAxisFieldElement.value),
+                (a = this._messages.xAxisFieldHeader),
+                (o = this.model.xAxisField);
+              break;
+            case l.numericFields:
+              (i = this.numericFieldsElement.value),
+                (a = this._messages.numericFieldsHeader),
+                (o = this.model.numericFields);
+              break;
+            case l.splitByField:
+              (i = this.splitByFieldElement.value),
+                (a = this._messages.splitByFieldHeader),
+                (o = this.model.splitByField);
+              break;
+            case l.interval:
+              (i = this.intervalElement.value),
+                (a = this._messages.editInterval),
+                (o = t);
+              break;
+            case l.intervalAlignment:
+              (i = this.intervalAlignmentElement.value),
+                (a = this._messages.intervalAlignment),
+                (o = this.model.timeAggregationType ?? "");
+              break;
+          }
+          (this.lineChartPopover = x(
+            r`<geoscene-charts-config-line-chart-popover .headingTitle=${a} .referenceElement=${i} open .contentKind=${this.contentKind} .layerFieldsInfo=${this.layerFieldsInfo} .selectedContent=${o} @geosceneChartsConfigLineChartDataPopoverChange=${this.onLineChartDataChange} @geosceneChartsConfigLineChartPopoverClose=${this.popoverClose}></geoscene-charts-config-line-chart-popover>`
+          )),
+            !document.body.contains(this.lineChartPopover) &&
+              this.lineChartPopover !== null &&
+              document.body.appendChild(this.lineChartPopover);
+        }
+        removeLineChartDataPopover() {
+          this.lineChartPopover !== null &&
+            ((this.lineChartPopover.open = !1),
+            (this.lineChartPopover = N(this.lineChartPopover)));
+        }
+        renderAggregation() {
+          return r`<geoscene-charts-config-field-select .label=${
+            this.model.aggregationType === h.NoAggregation
+              ? this._messages.noAggregation
+              : this.aggregationLabel
+          } @click=${this.onAggregationSelect} ${m(
+            this.aggregationElement
+          )}></geoscene-charts-config-field-select>`;
+        }
+        renderXAxisField() {
+          let e = this.getCorrectedXAxisValue();
+          return r`<geoscene-charts-config-field-select .label=${e} @click=${
+            this.onXAxisFieldSelect
+          } ${m(
+            this.xAxisFieldElement
+          )}></geoscene-charts-config-field-select>`;
+        }
+        renderSplitBy() {
+          let e = this.getCorrectedSplitByValue();
+          return r`<geoscene-charts-config-field-select .label=${e} .disabled=${
+            this.disableSplitBy
+          } @click=${this.onSplitBySelect} ${m(
+            this.splitByFieldElement
+          )}></geoscene-charts-config-field-select>`;
+        }
+        renderNumericFields(e) {
+          let t = f(this.model.layer).idField,
+            i = [];
+          for (let a of e) a !== t && i.push(this.buildNumericFieldItem(a));
+          return r`<calcite-list label class=${s(n.fieldList)} ${m(
+            this.numericFieldsElement
+          )}>${i}</calcite-list>`;
+        }
+        renderInterval() {
+          let e = (this.model.temporalBinningSize ?? 0) <= 0,
+            t = this.model.temporalBinningSize ?? "",
+            i =
+              S(this.model.temporalBinningUnit ?? b.Second, this._messages) ??
+              "",
+            a = T(u),
+            o = {
+              size: this.model.temporalBinningSize,
+              unit: this.model.temporalBinningUnit,
+            },
+            v = I(o, a);
+          return [
+            r`<calcite-list label selection-appearance=border><calcite-list-item .value=${
+              e ? "" : `${t} ${i}`
+            } .label=${e ? "" : `${t} ${i}`} @click=${
+              e ? () => {} : this.onIntervalSelect
+            } ${m(
+              this.intervalElement
+            )}><calcite-icon slot=content-end icon=pencil></calcite-icon></calcite-list-item></calcite-list>`,
+            r`<div class=${s(
+              n.linkContainer
+            )}><calcite-button .disabled=${v} appearance=transparent scale=s icon-end=reset @click=${
+              this.resetTimeIntervalOriginal
+            }>${this._messages.reset}</calcite-button></div>`,
+          ];
+        }
+        renderIntervalAlignment() {
+          return r`<geoscene-charts-config-field-select .label=${
+            this.timeAggregationLabel
+          } @click=${this.onIntervalAlignmentSelect} ${m(
+            this.intervalAlignmentElement
+          )}></geoscene-charts-config-field-select>`;
+        }
+        renderEmptyBins() {
+          return r`<calcite-radio-button-group name=empty-bins layout=vertical @calciteRadioButtonGroupChange=${
+            this.onNullPolicyChange
+          }><calcite-label layout=inline><calcite-radio-button .value=${
+            d.Zero
+          } .checked=${
+            this.model.nullPolicy === d.Zero
+          }></calcite-radio-button>${
+            this._messages.treatAsZero
+          }</calcite-label><calcite-label layout=inline><calcite-radio-button .value=${
+            d.Interpolate
+          } .checked=${
+            this.model.nullPolicy === d.Interpolate
+          }></calcite-radio-button>${
+            this._messages.connectLine
+          }</calcite-label><calcite-label layout=inline><calcite-radio-button .value=${
+            d.Null
+          } .checked=${
+            this.model.nullPolicy === d.Null
+          }></calcite-radio-button>${
+            this._messages.breakLine
+          }</calcite-label></calcite-radio-button-group>`;
+        }
+        render() {
+          let e = this.renderAggregation(),
+            t = this.renderXAxisField(),
+            i = this.renderSplitBy(),
+            a = this.renderNumericFields([...this.model.numericFields]),
+            o = this.renderInterval(),
+            v = this.renderIntervalAlignment(),
+            D = this.renderEmptyBins();
+          return r`<calcite-label class=${s(n.label)}>${
+            this._messages.xAxisField
+          }${t}</calcite-label><calcite-label class=${s(n.label)}>${
+            this._messages.aggregation
+          }${e}</calcite-label><calcite-label class=${s(n.label)}>${
+            this._messages.numericFields
+          }${a}</calcite-label><div class=${s(
+            n.fab
+          )}><calcite-fab appearance=outline-fill kind=neutral scale=m .label=${
+            this._messages.selectNumericFields
+          } text-enabled .text=${
+            this._messages.selectNumericFields
+          } icon=plus @click=${
+            this.onAddNumericFields
+          }></calcite-fab></div><calcite-label class=${s(
+            n.label
+          )}><span class=${s(this.disableSplitBy ? n.dimText : "")}>${
+            this._messages.splitBy
+          }</span>${i}</calcite-label><div .hidden=${!this.shouldShowTimeBinning()}><h3 class=${s(
+            n.timeBinningHeader
+          )}>${this._messages.timeBinningOptions}</h3><calcite-label class=${s(
+            n.label
+          )}>${
+            this._messages.interval
+          }${o}</calcite-label><calcite-label class=${s(n.label)}>${
+            this._messages.intervalAlignment
+          }${v}</calcite-label><calcite-label class=${s(
+            n.label
+          )} layout=inline-space-between>${
+            this._messages.trimIncompleteInterval
+          }<calcite-switch .checked=${
+            this.model.trimIncompleteTimeInterval
+          } @calciteSwitchChange=${
+            this.onTrimIncompleteIntervalChange
+          }></calcite-switch></calcite-label><calcite-label class=${s(
+            n.label
+          )}>${
+            this._messages.emptyBins
+          }${D}</calcite-label></div><calcite-label class=${s(
+            n.label
+          )} layout=inline-space-between>${
+            this._messages.showDataLabels
+          }<calcite-switch .checked=${
+            this.model.dataLabelsVisibility
+          } @calciteSwitchChange=${
+            this.onShowDataLabelsChange
+          }></calcite-switch></calcite-label>`;
+        }
+      };
+    A("geoscene-charts-config-line-chart-data", $);
+    return $;
+  },
+  "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,
+  e
+);