@geoscene/charts-components 5.0.19

package/dist/cdn/XOBTD5MM.js

@@ -0,0 +1,371 @@
+/* COPYRIGHT  - https://js.geoscene.cn/5.0/LICENSE.txt */
+import { a as B } from "./7I5Y5NSS.js";
+import { a as u } from "./HAGP76HP.js";
+import { b as T, c as w } from "./FEJD2JHY.js";
+import h from "./5752NFTR.js";
+import { k as o } from "./DPJE33GY.js";
+import { a as D } from "./VAB3BCTX.js";
+import e from "./P5SSZWMH.js";
+import "./UG7LOBJE.js";
+import a from "./A7YNU2NS.js";
+import { v as b } from "./4B3QBH5T.js";
+import "./XLDY6CTA.js";
+import { b as n } from "./KUVOINJC.js";
+import "./NKG4FLLR.js";
+import {
+  A as c,
+  B as y,
+  D as P,
+  F as L,
+  g as k,
+  h as l,
+  m as f,
+  x as g,
+  y as d,
+  z as $,
+} from "./KRZ433BT.js";
+import "./OR4HXHSY.js";
+export default $geoscene.t(
+  ([
+    ,
+    ,
+    ,
+    { substitute: O },
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    { Gb: F, Oc: x, Qc: C, ce: I },
+    ,
+    { a: m, l: h, p: S, s: E },
+  ]) => {
+    var a = {
+        jsAppFlyout: "js-app-flyout",
+        name: "bar-chart-data-popover",
+        numericFieldPickList: "bar-chart-data-numeric-fields-pick-list",
+        header: "header",
+        fab: "fab",
+        pickListItemLabel: "pick-list-item-label",
+        sortMean: "sort-mean",
+        sortMedian: "sort-median",
+        sortOrderPickList: "sort-order-pick-list",
+        panel: "panel",
+      },
+      z = k`.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)}.name{display:flex;flex-direction:column;margin:.5rem;padding:.5rem;background:#fff;min-width:250px}.header{margin:0;font-weight:bolder}.fab{display:flex;justify-content:stretch}.pick-list-item-label{font-size:small}.sort-icon-color{color:#000}.sort-mean,.sort-median{transform:rotate(90deg)}.sort-order-pick-list{overflow-y:hidden}.panel{max-height:60vh}`,
+      v = class extends $ {
+        constructor() {
+          super(...arguments),
+            (this._messages = D()),
+            (this.picklist = g()),
+            (this.placement = "leading"),
+            (this.popoverElement = g()),
+            (this.offsetDistance = -200),
+            (this.pickListHasChanged = !1),
+            (this.layerFieldsInfo = []),
+            (this.isCustomSortDisabled = !1),
+            (this.geosceneChartsConfigBoxPlotDataPopoverChange = f()),
+            (this.geosceneChartsConfigPopoverClose = f());
+        }
+        static {
+          this.properties = {
+            messageOverrides: 0,
+            headingTitle: 1,
+            referenceElement: 0,
+            open: 5,
+            contentKind: 1,
+            layerFieldsInfo: 0,
+            isCustomSortDisabled: 5,
+            selectedContent: 1,
+          };
+        }
+        static {
+          this.styles = z;
+        }
+        async reposition() {
+          await this.popoverElement.value?.reposition();
+        }
+        willUpdate(e) {
+          e.has("selectedContent") &&
+            this.selectedContentChange(
+              this.selectedContent,
+              e.get("selectedContent")
+            );
+        }
+        updated() {
+          setTimeout(() => {
+            typeof this.picklist.value?.setFocus == "function" &&
+              this.picklist.value?.setFocus();
+          }, m.PopoverTimer),
+            T(this.popoverElement.value, this.open),
+            this.hasUpdated ||
+              setTimeout(() => {
+                this.popoverElement.value?.reposition();
+              }, m.PopoverTimer);
+        }
+        selectedContentChange(e, t) {
+          this.pickListHasChanged = w(e, t);
+        }
+        closePopover() {
+          if (this.contentKind === o.numericFields && this.pickListHasChanged) {
+            let e = {
+              pickListElement: this.picklist.value,
+              eventEmitter: this.geosceneChartsConfigBoxPlotDataPopoverChange,
+              contentKind: this.contentKind,
+            };
+            S(e);
+          }
+          (this.open = !1), this.geosceneChartsConfigPopoverClose.emit();
+        }
+        onDataContentTypeChange(e) {
+          this.pickListHasChanged = !0;
+          let t = e.target.selectedItems;
+          this.geosceneChartsConfigBoxPlotDataPopoverChange.emit({
+            contentKind: this.contentKind,
+            value: t.map((i) => i.value),
+          }),
+            (this.open = !1);
+        }
+        buildPickListItem(e) {
+          return u(
+            e.name,
+            l`<calcite-list-item .label=${F(
+              this.layerFieldsInfo,
+              e.name
+            )} .value=${e.name} .selected=${h(
+              e.name,
+              this.selectedContent
+            )}></calcite-list-item>`
+          );
+        }
+        buildPickListItems(e) {
+          let t = this.layerFieldsInfo?.length ?? 0,
+            i = [];
+          switch (e) {
+            case o.numericFields: {
+              for (let s = 0; s < t; s += 1) {
+                let r = this.layerFieldsInfo[s];
+                x(r) && i.push(this.buildPickListItem(r));
+              }
+              break;
+            }
+            case o.category: {
+              let s = u(
+                " ",
+                l`<calcite-list-item label=" " value=" " .selected=${h(
+                  "",
+                  this.selectedContent
+                )}></calcite-list-item>`
+              );
+              i.push(s);
+              for (let r = 0; r < t; r += 1) {
+                let p = this.layerFieldsInfo[r];
+                (C(p) || p.type === b.String) &&
+                  i.push(this.buildPickListItem(p));
+              }
+              break;
+            }
+            case o.splitByField: {
+              let s = u(
+                " ",
+                l`<calcite-list-item label=" " value=" " .selected=${h(
+                  "",
+                  this.selectedContent
+                )}></calcite-list-item>`
+              );
+              i.push(s);
+              for (let r = 0; r < t; r += 1) {
+                let p = this.layerFieldsInfo[r];
+                (C(p) || p.type === b.String) &&
+                  i.push(this.buildPickListItem(p));
+              }
+              break;
+            }
+          }
+          return i;
+        }
+        onNumericFieldsChange(e) {
+          e.target !== null &&
+            (this.selectedContent = e.target.selectedItems.map((t) => t.value));
+        }
+        buildSortOrder() {
+          let e = Object.keys(n),
+            t;
+          return B(
+            e,
+            (i) => i,
+            (i) => {
+              let s = "";
+              switch (i) {
+                case n.xAxisAsc: {
+                  t = "a-z-down";
+                  break;
+                }
+                case n.xAxisDesc: {
+                  t = "a-z-up";
+                  break;
+                }
+                case n.meanAsc:
+                  (t = "sort-descending"), (s = a.sortMean);
+                  break;
+                case n.meanDesc: {
+                  (t = "sort-ascending"), (s = a.sortMean);
+                  break;
+                }
+                case n.medianAsc: {
+                  (t = "sort-descending"), (s = a.sortMedian);
+                  break;
+                }
+                case n.medianDesc: {
+                  (t = "sort-ascending"), (s = a.sortMedian);
+                  break;
+                }
+                case n.customSort: {
+                  t = "arrow-up-down";
+                  break;
+                }
+              }
+              return l`<calcite-list-item .disabled=${
+                this.isCustomSortDisabled && i === n.customSort
+              } .label=${this._messages[i]} .selected=${
+                this.selectedContent === i
+              } .value=${n[i]} @mouseover=${this.createTooltip} @mouseout=${
+                this.destroyTooltip
+              }><calcite-icon class=${`sort-icon-color ${s}`} slot=content-start .icon=${t}></calcite-icon></calcite-list-item>`;
+            }
+          );
+        }
+        onNumericFieldSelectionDone() {
+          this.pickListHasChanged && this.closePopover();
+        }
+        createTooltip(e) {
+          if (
+            e.target?.label === this._messages.customSort &&
+            this.isCustomSortDisabled
+          ) {
+            let t = e.target,
+              i = I(t),
+              s = new Intl.NumberFormat(i).format(m.customSortLimit),
+              r = O(this._messages.customSortLimit ?? "", { totalLimit: s });
+            (this.tooltip = P(
+              l`<calcite-tooltip style=${y({
+                opacity: 1,
+                zIndex: "var(--calcite-floating-ui-z-index)",
+              })} .referenceElement=${t} open placement=top>${r}</calcite-tooltip>`
+            )),
+              document.body.appendChild(this.tooltip);
+          }
+        }
+        destroyTooltip() {
+          E(this.tooltip);
+        }
+        renderCategory() {
+          let e = this.buildPickListItems(o.category);
+          return l`<calcite-list label class=${c(
+            a.pickListItemLabel
+          )} selection-mode=single selection-appearance=border filter-enabled @calciteListChange=${
+            this.onDataContentTypeChange
+          } ${d(this.picklist)}>${e}</calcite-list>`;
+        }
+        renderNumericFields() {
+          let e = this.buildPickListItems(o.numericFields);
+          return l`<calcite-list label class=${c(
+            a.numericFieldPickList
+          )} selection-mode=multiple filter-enabled @calciteListChange=${
+            this.onNumericFieldsChange
+          } ${d(this.picklist)}>${e}</calcite-list>`;
+        }
+        renderSplitByField() {
+          let e = this.buildPickListItems(o.splitByField);
+          return l`<calcite-list label class=${c(
+            a.pickListItemLabel
+          )} selection-mode=single selection-appearance=border filter-enabled @calciteListChange=${
+            this.onDataContentTypeChange
+          } ${d(this.picklist)}>${e}</calcite-list>`;
+        }
+        renderSortOrder() {
+          let e = this.buildSortOrder();
+          return l`<calcite-list label class=${c(
+            a.sortOrderPickList
+          )} selection-mode=single selection-appearance=border @calciteListChange=${
+            this.onDataContentTypeChange
+          }>${e}</calcite-list>`;
+        }
+        renderPopoverInfo() {
+          let e;
+          switch (this.contentKind) {
+            case o.category:
+              e = this.renderCategory();
+              break;
+            case o.numericFields:
+              e = this.renderNumericFields();
+              break;
+            case o.splitByField:
+              e = this.renderSplitByField();
+              break;
+            case o.sortOrder:
+              e = this.renderSortOrder();
+              break;
+          }
+          return e;
+        }
+        render() {
+          let e;
+          return (
+            this.contentKind === o.numericFields &&
+              (e = l`<div slot=footer><calcite-fab class=${c(
+                a.fab
+              )} appearance=outline-fill kind=neutral .icon=${void 0} .label=${
+                this._messages.selectionDone
+              } scale=s text-enabled .text=${
+                this._messages.selectionDone
+              } @click=${
+                this.onNumericFieldSelectionDone
+              }></calcite-fab></div>`),
+            l`<div class=${c(a.jsAppFlyout)}><calcite-popover class=${c(
+              a.name
+            )} .referenceElement=${
+              this.referenceElement ?? document.body
+            } .placement=${this.placement} .offsetDistance=${
+              this.offsetDistance
+            } .open=${this.open} @calcitePopoverClose=${
+              this.closePopover
+            } label auto-close ${d(
+              this.popoverElement
+            )}><calcite-panel class=${c(a.panel)} closable .closed=${!this
+              .open} @calcitePanelClose=${
+              this.closePopover
+            }><div slot=header-content class=${c(a.header)}>${
+              this.headingTitle ?? ""
+            }</div>${this.renderPopoverInfo()}${e}</calcite-panel></calcite-popover></div>`
+          );
+        }
+      };
+    L("geoscene-charts-config-box-plot-popover", v);
+    return v;
+  },
+  "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,
+  h
+);

package/dist/cdn/XQXY7DRO.js

@@ -0,0 +1,268 @@
+/* COPYRIGHT  - https://js.geoscene.cn/5.0/LICENSE.txt */
+import { a as k } from "./HAGP76HP.js";
+import { a as E } from "./FEJD2JHY.js";
+import { h as a } from "./DPJE33GY.js";
+import { a as F } from "./VAB3BCTX.js";
+import e from "./AENRD2JF.js";
+import c from "./A7YNU2NS.js";
+import "./4B3QBH5T.js";
+import "./XLDY6CTA.js";
+import { e as g } from "./KUVOINJC.js";
+import { b as y } from "./NKG4FLLR.js";
+import {
+  A as o,
+  D as b,
+  F as v,
+  g as C,
+  h as s,
+  m as d,
+  x as n,
+  y as h,
+  z as u,
+} from "./KRZ433BT.js";
+import "./OR4HXHSY.js";
+export default $geoscene.t(
+  ([, , , , , , , , , , , , , , , { Gb: m, Nc: $, d: c }, { h: P }]) => {
+    var l = { label: "label", fieldList: "field-list", fab: "fab" },
+      w = C`: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:var(--geoscene-charts-config-margin-minor);margin-right:var(--geoscene-charts-config-margin-minor);margin-bottom:var(--geoscene-charts-config-margin-minor);justify-content:space-between}.field-list{max-height:50vh;overflow-y:auto}.disabled-label{pointer-events:none}.fab{display:flex;margin-left:var(--geoscene-charts-config-margin-minor);margin-right:var(--geoscene-charts-config-margin-minor);margin-bottom:1.5rem;justify-content:center}`,
+      p = class extends u {
+        constructor() {
+          super(...arguments),
+            (this._messages = F()),
+            (this.pieChartPopover = null),
+            (this.sortOrderElement = n()),
+            (this.categoryElement = n()),
+            (this.numericFieldsElement = n()),
+            (this.onPieChartDataChange = (e) => {
+              try {
+                if (e.detail !== null && e.detail?.value !== void 0) {
+                  let { contentKind: t } = e.detail,
+                    i = [...e.detail.value];
+                  switch (t) {
+                    case a.aggregation:
+                      this.model.aggregationType =
+                        i[0] !== y.NoAggregation ? i[0] : "";
+                      break;
+                    case a.category: {
+                      let r = i[0]?.trim() || "";
+                      this.updateMode(r);
+                      let f = this.model.numericFields;
+                      f.length > 1 &&
+                        r !== c &&
+                        (this.model.numericFields = [f[0]]),
+                        (this.model.category = r),
+                        (this.model.colorMatch = !0);
+                      break;
+                    }
+                    case a.numericFields:
+                      i.length > 1 &&
+                        (this.updateMode(c), (this.model.category = c)),
+                        (this.model.numericFields = i);
+                      break;
+                    case a.sortOrder:
+                      this.model.setSortOrder(i[0]);
+                      break;
+                    default:
+                      break;
+                  }
+                }
+              } catch (t) {
+                throw (
+                  (t instanceof Error &&
+                    this.geosceneChartsConfigDataChangeError.emit({
+                      error: t,
+                      model: this.model,
+                    }),
+                  t)
+                );
+              }
+              this.requestUpdate();
+            }),
+            (this.onModelConfigChange = () => {
+              this.requestUpdate();
+            }),
+            (this.popoverClose = (e) => {
+              this.pieChartPopover === e?.target &&
+                this.removePieChartDataPopover();
+            }),
+            (this.layerFieldsInfo = []),
+            (this.geosceneChartsConfigDataChangeError = d()),
+            (this.geosceneChartsConfigPieChartDataNumericFieldValidate = d());
+        }
+        static {
+          this.properties = {
+            messageOverrides: 0,
+            model: 0,
+            layerFieldsInfo: 0,
+          };
+        }
+        static {
+          this.styles = w;
+        }
+        load() {
+          this.modelChange(this.model), this.onModelConfigChange();
+        }
+        willUpdate(e) {
+          e.has("model") && this.modelChange(this.model, e.get("model"));
+        }
+        disconnectedCallback() {
+          super.disconnectedCallback(),
+            this.removePieChartDataPopover(),
+            this.model.removeEventListener(
+              "geosceneChartsModelConfigChange",
+              this.onModelConfigChange
+            );
+        }
+        modelChange(e, t) {
+          t?.removeEventListener(
+            "geosceneChartsModelConfigChange",
+            this.onModelConfigChange
+          ),
+            e?.addEventListener(
+              "geosceneChartsModelConfigChange",
+              this.onModelConfigChange
+            );
+        }
+        buildNumericFieldItem(e) {
+          return k(
+            e,
+            s`<calcite-list-item .label=${m(
+              this.layerFieldsInfo,
+              e
+            )} .value=${e} closable @calciteListItemClose=${
+              this.onRemoveNumericField
+            }></calcite-list-item>`
+          );
+        }
+        onSortOrderSelect(e) {
+          (this.contentKind = a.sortOrder), this.setupPopover(e);
+        }
+        onCategorySelect(e) {
+          (this.contentKind = a.category), this.setupPopover(e);
+        }
+        onAddNumericFields(e) {
+          (this.contentKind = a.numericFields), this.setupPopover(e);
+        }
+        onRemoveNumericField(e) {
+          let t = e.target.value;
+          this.model.numericFields = this.model.numericFields.filter(
+            (i) => i !== t
+          );
+        }
+        onShowDataLabelsChange(e) {
+          this.model.dataLabelsVisibility = e.target.checked;
+        }
+        updateMode(e) {
+          let t = e !== c && e.trim() !== "";
+          this.model.mode = t ? g.Category : g.Fields;
+        }
+        setupPopover(e) {
+          e.stopImmediatePropagation(), this.removePieChartDataPopover();
+          let t, i, r;
+          switch (this.contentKind) {
+            case a.category:
+              (t = this.categoryElement.value),
+                (i = this._messages.categoryHeader),
+                (r = this.model.category);
+              break;
+            case a.numericFields:
+              (t = this.numericFieldsElement.value),
+                (i = this._messages.numericFieldsMultipleHeader),
+                (r = this.model.numericFields);
+              break;
+            case a.sortOrder:
+              (t = this.sortOrderElement.value),
+                (i = this._messages.sortOrderHeader),
+                (r = this.model.getSortOrder());
+              break;
+          }
+          (this.pieChartPopover = b(
+            s`<geoscene-charts-config-pie-chart-popover .headingTitle=${i} .referenceElement=${t} open .contentKind=${this.contentKind} .layerFieldsInfo=${this.layerFieldsInfo} .selectedContent=${r} @geosceneChartsConfigPieChartDataPopoverChange=${this.onPieChartDataChange} @geosceneChartsConfigPopoverClose=${this.popoverClose}></geoscene-charts-config-pie-chart-popover>`
+          )),
+            !document.body.contains(this.pieChartPopover) &&
+              this.pieChartPopover !== null &&
+              document.body.appendChild(this.pieChartPopover);
+        }
+        getCorrectedCategoryValue() {
+          return P({
+            fieldName: this.model.category,
+            fieldList: this.layerFieldsInfo,
+          })
+            ? ""
+            : m(this.layerFieldsInfo, this.model.category);
+        }
+        removePieChartDataPopover() {
+          this.pieChartPopover !== null &&
+            ((this.pieChartPopover.open = !1),
+            (this.pieChartPopover = E(this.pieChartPopover)));
+        }
+        renderSorting() {
+          return s`<geoscene-charts-config-field-select .label=${
+            this._messages[this.model.getSortOrder()]
+          } @click=${this.onSortOrderSelect} ${h(
+            this.sortOrderElement
+          )}></geoscene-charts-config-field-select>`;
+        }
+        renderCategory() {
+          let e = this.getCorrectedCategoryValue();
+          return s`<geoscene-charts-config-field-select .label=${e} @click=${
+            this.onCategorySelect
+          } ${h(this.categoryElement)}></geoscene-charts-config-field-select>`;
+        }
+        renderNumericFields(e) {
+          let t = $(this.model.layer).idField,
+            i = [];
+          for (let r of e) r !== t && i.push(this.buildNumericFieldItem(r));
+          return s`<calcite-list label class=${o(l.fieldList)} ${h(
+            this.numericFieldsElement
+          )}>${i}</calcite-list>`;
+        }
+        render() {
+          let e = this.renderCategory(),
+            t = this.renderSorting(),
+            i = this.renderNumericFields([...this.model.numericFields]);
+          return s`<calcite-label class=${o(l.label)}>${
+            this._messages.category
+          }${e}</calcite-label>${[
+            s`<calcite-label class=${o(l.label)}>${
+              this._messages.numericFields
+            }${i}</calcite-label>`,
+            s`<div class=${o(
+              l.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=${o(l.label)} layout=inline-space-between>${
+            this._messages.showDataLabels
+          }<calcite-switch .checked=${
+            this.model.dataLabelsVisibility
+          } @calciteSwitchChange=${
+            this.onShowDataLabelsChange
+          }></calcite-switch></calcite-label><calcite-label class=${o(
+            l.label
+          )}>${this._messages.sortOrder}${t}</calcite-label>`;
+        }
+      };
+    v("geoscene-charts-config-pie-chart-data", p);
+    return p;
+  },
+  "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",
+  c,
+  e
+);