@geoscene/charts-components 5.0.19

package/dist/cdn/2ZYMR3QH.js

@@ -0,0 +1,469 @@
+/* COPYRIGHT  - https://js.geoscene.cn/5.0/LICENSE.txt */
+import { a as C } from "./7I5Y5NSS.js";
+import { a as f } from "./HAGP76HP.js";
+import { b as U, c as M } from "./FEJD2JHY.js";
+import c from "./5752NFTR.js";
+import { g as l } from "./DPJE33GY.js";
+import { a as I } from "./VAB3BCTX.js";
+import b from "./P5SSZWMH.js";
+import "./UG7LOBJE.js";
+import a from "./A7YNU2NS.js";
+import { n as y, v as k } from "./4B3QBH5T.js";
+import "./XLDY6CTA.js";
+import { a as m } from "./KUVOINJC.js";
+import { b as T, k as p, o as u } from "./NKG4FLLR.js";
+import {
+  A as o,
+  B as x,
+  D,
+  F as A,
+  g as P,
+  h as s,
+  m as $,
+  x as g,
+  y as d,
+  z as F,
+} from "./KRZ433BT.js";
+import "./OR4HXHSY.js";
+export default $geoscene.t(
+  ([
+    { substitute: W },
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    { Gb: w, Ia: E, Ja: z, Lb: N, Oc: B, Pc: _, Qc: L, ce: K },
+    ,
+    { a: b, d: v, h: O, l: h, p: j, s: H },
+  ]) => {
+    var q = P`.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-y-axis{transform:rotate(90deg)}.sort-order-pick-list{overflow-y:hidden}.panel{max-height:60vh}.panel .size-section{width:19rem;margin:1rem 0;display:flex;flex-wrap:wrap;justify-content:space-evenly}.panel .size-section calcite-label{width:8rem;margin-bottom:.25rem}.panel .apply-button{width:17rem}`,
+      n = {
+        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",
+        rotateClass: "sort-y-axis",
+        sortOrderPickList: "sort-order-pick-list",
+        sizeSection: "size-section",
+        applyButton: "apply-button",
+        panel: "panel",
+      },
+      S = class extends F {
+        constructor() {
+          super(...arguments),
+            (this._messages = I()),
+            (this.commonStrings = I({ name: "common", blocking: !0 })),
+            (this.picklist = g()),
+            (this.intervalSizeElement = g()),
+            (this.intervalTypeElement = g()),
+            (this.popoverElement = g()),
+            (this.placement = "leading"),
+            (this.offsetDistance = -200),
+            (this.pickListHasChanged = !1),
+            (this.aggregationLabels = []),
+            (this.layerFieldsInfo = []),
+            (this.isCustomSortDisabled = !1),
+            (this.isNoAggregationDisabled = !1),
+            (this.geosceneChartsConfigBarChartDataPopoverChange = $()),
+            (this.geosceneChartsConfigPopoverClose = $());
+        }
+        static {
+          this.properties = {
+            aggregationLabels: 16,
+            timeAggregationLabels: 16,
+            messageOverrides: 0,
+            headingTitle: 1,
+            referenceElement: 0,
+            open: 5,
+            contentKind: 1,
+            layerFieldsInfo: 0,
+            selectedContent: 1,
+            isCustomSortDisabled: 5,
+            isNoAggregationDisabled: 5,
+          };
+        }
+        static {
+          this.styles = q;
+        }
+        async reposition() {
+          await this.popoverElement.value?.reposition();
+        }
+        willUpdate(e) {
+          e.has("selectedContent") &&
+            this.selectedContentChange(
+              this.selectedContent,
+              e.get("selectedContent")
+            );
+          let t = v.map((a) => E(a, this.commonStrings));
+          y(this.aggregationLabels, t) || (this.aggregationLabels = t);
+          let i = [u.Start, u.End].map((a) => z(a, this.commonStrings));
+          y(this.timeAggregationLabels, i) || (this.timeAggregationLabels = i);
+        }
+        updated() {
+          setTimeout(() => {
+            this.picklist.value?.setFocus();
+          }, b.PopoverTimer),
+            U(this.popoverElement.value, this.open),
+            this.hasUpdated ||
+              setTimeout(() => {
+                this.popoverElement.value?.reposition();
+              }, b.PopoverTimer);
+        }
+        selectedContentChange(e, t) {
+          this.pickListHasChanged = M(e, t);
+        }
+        buildAggregationListItems() {
+          let e = this.isNoAggregationDisabled
+            ? v.filter((t) => t !== T.NoAggregation)
+            : v;
+          return C(
+            e,
+            (t) => t,
+            (t, i) =>
+              s`<calcite-list-item .label=${
+                this.aggregationLabels[i]
+              } .value=${t} .selected=${h(
+                t,
+                this.selectedContent
+              )}></calcite-list-item>`
+          );
+        }
+        createTooltip(e) {
+          if (
+            e.target?.label === this._messages.customSort &&
+            this.isCustomSortDisabled
+          ) {
+            let t = e.target,
+              i = K(t),
+              a = new Intl.NumberFormat(i).format(b.customSortLimit),
+              r = W(this._messages.customSortLimit ?? "", { totalLimit: a });
+            (this.tooltip = D(
+              s`<calcite-tooltip style=${x({
+                opacity: 1,
+                zIndex: "var(--calcite-floating-ui-z-index)",
+              })} .referenceElement=${t} open placement=top>${r}</calcite-tooltip>`
+            )),
+              document.body.appendChild(this.tooltip);
+          }
+        }
+        destroyTooltip() {
+          H(this.tooltip);
+        }
+        buildSortOrder() {
+          let e = Object.keys(m),
+            t;
+          return C(
+            e,
+            (i) => i,
+            (i) => {
+              let a = "";
+              switch (i) {
+                case m.xAxisAsc: {
+                  t = "a-z-down";
+                  break;
+                }
+                case m.xAxisDesc: {
+                  t = "a-z-up";
+                  break;
+                }
+                case m.yAxisAsc: {
+                  (t = "sort-descending"), (a = n.rotateClass);
+                  break;
+                }
+                case m.yAxisDesc: {
+                  (t = "sort-ascending"), (a = n.rotateClass);
+                  break;
+                }
+                case m.customSort: {
+                  t = "arrow-up-down";
+                  break;
+                }
+              }
+              return s`<calcite-list-item .disabled=${
+                this.isCustomSortDisabled && i === m.customSort
+              } .label=${this._messages[i]} .selected=${
+                this.selectedContent === i
+              } .value=${m[i]} @mouseover=${this.createTooltip} @mouseout=${
+                this.destroyTooltip
+              }><calcite-icon class=${`sort-icon-color ${a}`} slot=content-start .icon=${t}></calcite-icon></calcite-list-item>`;
+            }
+          );
+        }
+        buildPickListItem(e) {
+          return f(
+            e.name,
+            s`<calcite-list-item .label=${w(
+              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 l.numericFields: {
+              for (let a = 0; a < t; a += 1) {
+                let r = this.layerFieldsInfo?.[a];
+                r && B(r) && i.push(this.buildPickListItem(r));
+              }
+              break;
+            }
+            case l.category: {
+              let a = f(
+                " ",
+                s`<calcite-list-item label=" " value=" " .selected=${h(
+                  "",
+                  this.selectedContent
+                )}></calcite-list-item>`
+              );
+              i.push(a);
+              for (let r = 0; r < t; r += 1) {
+                let c = this.layerFieldsInfo?.[r];
+                c &&
+                  (c.type === k.String || L(c) || _(c)) &&
+                  i.push(this.buildPickListItem(c));
+              }
+              break;
+            }
+            case l.splitByField: {
+              let a = f(
+                " ",
+                s`<calcite-list-item label=" " value=" " .selected=${h(
+                  "",
+                  this.selectedContent
+                )}></calcite-list-item>`
+              );
+              i.push(a);
+              for (let r = 0; r < t; r += 1) {
+                let c = this.layerFieldsInfo?.[r];
+                c &&
+                  (L(c) || c.type === k.String) &&
+                  i.push(this.buildPickListItem(c));
+              }
+              break;
+            }
+          }
+          return i;
+        }
+        closePopover() {
+          if (this.contentKind === l.numericFields && this.pickListHasChanged) {
+            let e = {
+              pickListElement: this.picklist.value,
+              eventEmitter: this.geosceneChartsConfigBarChartDataPopoverChange,
+              contentKind: this.contentKind,
+            };
+            j(e);
+          }
+          (this.open = !1), this.geosceneChartsConfigPopoverClose.emit();
+        }
+        onDataContentTypeChange(e) {
+          let t = e.target.selectedItems;
+          this.geosceneChartsConfigBarChartDataPopoverChange.emit({
+            contentKind: this.contentKind,
+            value: t.map((i) => i.value),
+          }),
+            (this.open = !1);
+        }
+        intervalChange() {
+          let e = Number.parseInt(this.intervalSizeElement.value?.value ?? ""),
+            t = this.intervalTypeElement.value?.selectedOption?.value;
+          !Number.isNaN(e) &&
+            e > 0 &&
+            this.geosceneChartsConfigBarChartDataPopoverChange.emit({
+              contentKind: this.contentKind,
+              value: [{ intervalSize: e, intervalUnits: t }],
+            }),
+            (this.open = !1);
+        }
+        onNumericFieldsChange(e) {
+          e.target !== null &&
+            (this.selectedContent = e.target.selectedItems.map((t) => t.value));
+        }
+        onNumericFieldSelectionDone() {
+          this.pickListHasChanged && this.closePopover();
+        }
+        buildIntervalAlignmentPickListItems() {
+          let e = [u.Start, u.End];
+          return C(
+            e,
+            (t) => t,
+            (t, i) =>
+              s`<calcite-list-item .label=${
+                this.timeAggregationLabels?.[i]
+              } .value=${t} .selected=${h(
+                t,
+                this.selectedContent
+              )}></calcite-list-item>`
+          );
+        }
+        renderAggregationType() {
+          let e = this.buildAggregationListItems();
+          return s`<calcite-list label class=${o(
+            n.pickListItemLabel
+          )} selection-mode=single selection-appearance=border @calciteListChange=${
+            this.onDataContentTypeChange
+          }>${e}</calcite-list>`;
+        }
+        renderCategory() {
+          let e = this.buildPickListItems(l.category);
+          return s`<calcite-list label class=${o(
+            n.pickListItemLabel
+          )} selection-mode=single selection-appearance=border filter-enabled @calciteListChange=${
+            this.onDataContentTypeChange
+          } ${d(this.picklist)}>${e}</calcite-list>`;
+        }
+        renderNumericFields() {
+          let e = this.buildPickListItems(l.numericFields);
+          return s`<calcite-list label class=${o(
+            n.numericFieldPickList
+          )} selection-mode=multiple filter-enabled @calciteListChange=${
+            this.onNumericFieldsChange
+          } ${d(this.picklist)}>${e}</calcite-list>`;
+        }
+        renderSortOrder() {
+          let e = this.buildSortOrder();
+          return s`<calcite-list label class=${o(
+            n.sortOrderPickList
+          )} selection-mode=single selection-appearance=border @calciteListChange=${
+            this.onDataContentTypeChange
+          }>${e}</calcite-list>`;
+        }
+        renderSplitByField() {
+          let e = this.buildPickListItems(l.splitByField);
+          return s`<calcite-list label class=${o(
+            n.pickListItemLabel
+          )} selection-mode=single selection-appearance=border filter-enabled @calciteListChange=${
+            this.onDataContentTypeChange
+          } ${d(this.picklist)}>${e}</calcite-list>`;
+        }
+        renderIntervalAlignment() {
+          let e = this.buildIntervalAlignmentPickListItems();
+          return s`<calcite-list label class=${o(
+            n.pickListItemLabel
+          )} selection-mode=single selection-appearance=border @calciteListChange=${
+            this.onDataContentTypeChange
+          }>${e}</calcite-list>`;
+        }
+        renderInterval() {
+          let e = this.selectedContent,
+            t = [p.Second, p.Minute, p.Hour, p.Day, p.Week, p.Month, p.Year];
+          return s`<div><div class=${o(n.sizeSection)}><calcite-label scale=m>${
+            this._messages.intervalSize
+          }<calcite-input type=number scale=m min=1 step=any .value=${O(
+            e?.size,
+            1
+          )} ${d(
+            this.intervalSizeElement
+          )}></calcite-input></calcite-label><calcite-label scale=m>${
+            this._messages.intervalType
+          }<calcite-select .label=${this._messages.intervalType ?? ""} ${d(
+            this.intervalTypeElement
+          )}>${t.map(
+            (i) =>
+              s`<calcite-option .value=${i} .label=${N(
+                i,
+                this._messages
+              )} .selected=${e?.unit === i}></calcite-option>`
+          )}</calcite-select></calcite-label><calcite-button class=${o(
+            n.applyButton
+          )} appearance=outline @click=${this.intervalChange}>${
+            this._messages.apply
+          }</calcite-button></div></div>`;
+        }
+        renderPopoverInfo() {
+          let e;
+          switch (this.contentKind) {
+            case l.aggregation:
+              e = this.renderAggregationType();
+              break;
+            case l.category:
+              e = this.renderCategory();
+              break;
+            case l.numericFields:
+              e = this.renderNumericFields();
+              break;
+            case l.splitByField:
+              e = this.renderSplitByField();
+              break;
+            case l.sortOrder:
+              e = this.renderSortOrder();
+              break;
+            case l.intervalAlignment:
+              e = this.renderIntervalAlignment();
+              break;
+            case l.interval:
+              e = this.renderInterval();
+              break;
+          }
+          return e;
+        }
+        render() {
+          let e;
+          return (
+            this.contentKind === l.numericFields &&
+              (e = s`<div slot=footer><calcite-fab class=${o(
+                n.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>`),
+            s`<div class=${o(n.jsAppFlyout)}><calcite-popover class=${o(
+              n.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=${o(n.panel)} closable .closed=${!this
+              .open} @calcitePanelClose=${
+              this.closePopover
+            }><div slot=header-content class=${o(n.header)}>${
+              this.headingTitle ?? ""
+            }</div>${this.renderPopoverInfo()}${e}</calcite-panel></calcite-popover></div>`
+          );
+        }
+      };
+    A("geoscene-charts-config-bar-chart-popover", S);
+    return S;
+  },
+  "intl",
+  "Graphic",
+  "renderers/support/jsonUtils",
+  "symbols/support/symbolUtils",
+  "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
+);

package/dist/cdn/346SLSRB.js

@@ -0,0 +1,117 @@
+/* COPYRIGHT  - https://js.geoscene.cn/5.0/LICENSE.txt */
+import f from "./5752NFTR.js";
+import "./DPJE33GY.js";
+import { a as b } from "./VAB3BCTX.js";
+import e from "./P5SSZWMH.js";
+import "./UG7LOBJE.js";
+import c from "./A7YNU2NS.js";
+import "./4B3QBH5T.js";
+import "./XLDY6CTA.js";
+import "./KUVOINJC.js";
+import "./NKG4FLLR.js";
+import {
+  A as a,
+  F as d,
+  g as l,
+  h as o,
+  m as u,
+  x as h,
+  y as g,
+  z as p,
+} from "./KRZ433BT.js";
+import "./OR4HXHSY.js";
+export default $geoscene.t(
+  ([, , { g: f, h: v, i: r, j: m }]) => {
+    var s = {
+        container: "container",
+        label: "label",
+        numberInput: "number-input",
+      },
+      x = l`.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)}.container{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));margin-top:.5rem}.container>.number-input{margin-bottom:.5rem;display:flex}.container>.number-input>div{width:100%}.label{display:flex;margin-bottom:.5rem;justify-content:space-between}`,
+      c = class extends p {
+        constructor() {
+          super(...arguments),
+            (this._messages = b()),
+            (this.decimalPlacesInputElement = h()),
+            (this.geosceneChartsConfigNumberFormatChange = u());
+        }
+        static {
+          this.properties = { messageOverrides: 0, numberFormat: 0 };
+        }
+        static {
+          this.styles = x;
+        }
+        onDecimalPlacesChange() {
+          let t = this.decimalPlacesInputElement.value?.value,
+            i = Math.floor(Number(t)),
+            n = i === Number(t) && i >= 0;
+          if (
+            t !== void 0 &&
+            n &&
+            f(
+              t,
+              this.decimalPlacesInputElement.value?.min,
+              this.decimalPlacesInputElement.value?.max
+            )
+          ) {
+            let F = Number.parseInt(t),
+              e = {
+                minimumFractionDigits: this.numberFormat?.minimumFractionDigits,
+                maximumFractionDigits: F,
+              };
+            e.maximumFractionDigits !== void 0 &&
+              e.minimumFractionDigits !== void 0 &&
+              e.minimumFractionDigits > e.maximumFractionDigits &&
+              (e.minimumFractionDigits = e.maximumFractionDigits);
+            let C = this.getUpdatedNumberFormat(e);
+            this.geosceneChartsConfigNumberFormatChange.emit(C),
+              this.decimalPlacesInputElement.value &&
+                r({
+                  inputElement: this.decimalPlacesInputElement.value,
+                  status: m.IDLE,
+                });
+          } else
+            this.decimalPlacesInputElement.value &&
+              r({
+                inputElement: this.decimalPlacesInputElement.value,
+                status: m.INVALID,
+              });
+        }
+        onShowThousandsSeparatorChange(t) {
+          let i = t.target.checked,
+            n = this.getUpdatedNumberFormat({ useGrouping: i });
+          this.geosceneChartsConfigNumberFormatChange.emit(n);
+        }
+        getUpdatedNumberFormat(t) {
+          return { ...this.numberFormat, ...t };
+        }
+        render() {
+          return o`<div class=${a(s.container)}><calcite-label class=${a(
+            s.label
+          )}>${
+            this._messages.decimalPlaces
+          }<calcite-input type=number class=${a(
+            s.numberInput
+          )} min=0 max=20 step=1 .value=${v(
+            this.numberFormat?.maximumFractionDigits,
+            2
+          )} @calciteInputInput=${this.onDecimalPlacesChange} ${g(
+            this.decimalPlacesInputElement
+          )}></calcite-input></calcite-label><calcite-label layout=inline-space-between class=${a(
+            s.label
+          )}>${
+            this._messages.showThousandSeparators
+          }<calcite-switch name=useGrouping .checked=${!!(
+            this.numberFormat?.useGrouping ?? !0
+          )} @calciteSwitchChange=${
+            this.onShowThousandsSeparatorChange
+          }></calcite-switch></calcite-label></div>`;
+        }
+      };
+    d("geoscene-charts-config-number-format", c);
+    return c;
+  },
+  c,
+  e,
+  f
+);