@geoscene/map-components 4.33.20 → 5.0.19

package/dist/components/geoscene-utility-network-aggregated-geometry/customElement.js

@@ -0,0 +1,106 @@
+/* COPYRIGHT GeoScene - https://js.geoscene.cn/5.0/LICENSE.txt */
+import { c as m } from "../../chunks/runtime.js";
+import p from "@geoscene/core/Color.js";
+import l from "@geoscene/core/Graphic.js";
+import g from "@geoscene/core/layers/GraphicsLayer.js";
+import y from "@geoscene/core/symbols/SimpleFillSymbol.js";
+import n from "@geoscene/core/symbols/SimpleLineSymbol.js";
+import d from "@geoscene/core/symbols/SimpleMarkerSymbol.js";
+import { LitElement as w, createEvent as _, nothing as f } from "@geoscene/lumina";
+import { log as s, composeMissingPropertyMessage as a } from "@geoscene/toolkit/log";
+import { css as G, html as u } from "lit";
+import { u as L } from "../../chunks/useT9n.js";
+import { i as v, a as o } from "../../chunks/layer-utils.js";
+const b = G`.loader-container{display:flex;justify-content:center;padding-bottom:var(--calcite-spacing-md)}`, h = 12;
+class S extends w {
+  constructor() {
+    super(...arguments), this._graphicsLayerName = "geoscene-utility-network-aggregated-geometry-graphics", this._messages = L({ blocking: !0 }), this._graphics = [], this._addAggregatedGeometryToView = () => {
+      const e = this.geometry, { line: i, multipoint: r, polygon: c } = e;
+      this._graphics = [i, r, c].filter((t) => t != null).map((t) => this._makeGraphicFromGeometry(t)), this._graphicsLayer.addMany(this._graphics);
+    }, this._createGraphicsLayer = () => {
+      const e = this.view.map, i = this._graphicsLayerName, r = e.findLayerById(i);
+      if (r && v(r)) {
+        this._graphicsLayer = r;
+        return;
+      }
+      this._graphicsLayer = new g({
+        id: i,
+        listMode: "hide",
+        title: i
+      }), o(this.view, this._graphicsLayer);
+    }, this.hideGraphics = !1, this.graphicsColor = new p([255, 255, 0, 0.6]), this.autoDestroyDisabled = !1, this.geosceneHideGraphicsChange = _();
+  }
+  static {
+    this.properties = { geometry: 0, hideGraphics: 5, graphicsColor: 0, view: 0, autoDestroyDisabled: 5 };
+  }
+  static {
+    this.styles = b;
+  }
+  async destroy() {
+    this.view?.map && this._graphicsLayer && this.view.map.remove(this._graphicsLayer), await this.manager.destroy();
+  }
+  connectedCallback() {
+    super.connectedCallback(), this.view && this._graphicsLayer && o(this.view, this._graphicsLayer);
+  }
+  load() {
+    !this.geometry || !this.view?.map || this._createGraphicsLayer();
+  }
+  willUpdate(e) {
+    if (e.has("graphicsColor") && this._updateGraphicSymbols(), e.has("geometry") && (this._graphicsLayer?.removeAll(), this._addAggregatedGeometryToView()), e.has("view")) {
+      const i = e.get("view");
+      i?.map && this._graphicsLayer && (i.map.remove(this._graphicsLayer), this._createGraphicsLayer(), this._addAggregatedGeometryToView());
+    }
+  }
+  loaded() {
+    this.geometry || s("error", this, a("geometry")), this.view ? this.view.map || s("error", this, a("The property `view` was provided, but `view.map` is null. Cannot draw aggregated geometry.")) : s("error", this, a("view"));
+  }
+  _handleShowGraphicsChange() {
+    this.hideGraphics = !this.hideGraphics, this.hideGraphics ? this._graphicsLayer?.removeAll() : this._graphicsLayer?.addMany(this._graphics), this.geosceneHideGraphicsChange.emit(this.hideGraphics);
+  }
+  _makeGraphicFromGeometry(e) {
+    return new l({
+      geometry: e,
+      symbol: this._makeSymbolForGeometry(e)
+    });
+  }
+  _makeSymbolForGeometry(e) {
+    const i = this.graphicsColor;
+    switch (e.type) {
+      case "multipoint":
+        return new d({
+          color: i,
+          size: h,
+          outline: {
+            color: i,
+            width: 0
+          }
+        });
+      case "polygon":
+        return new y({
+          color: i,
+          outline: {
+            color: i,
+            width: h
+          }
+        });
+      case "polyline":
+        return new n({
+          color: i,
+          width: h
+        });
+    }
+  }
+  _updateGraphicSymbols() {
+    this._graphicsLayer?.graphics.forEach((e) => {
+      const i = e.geometry;
+      e.symbol = this._makeSymbolForGeometry(i);
+    });
+  }
+  render() {
+    return u`<calcite-switch .checked=${!this.hideGraphics} .label=${this._messages.labels.showGraphicsToggle} label-text-end=${this._messages.showGraphics ?? f} @calciteSwitchChange=${this._handleShowGraphicsChange}></calcite-switch>`;
+  }
+}
+m("geoscene-utility-network-aggregated-geometry", S);
+export {
+  S as GeosceneUtilityNetworkAggregatedGeometry
+};

package/dist/components/geoscene-utility-network-aggregated-geometry/index.d.ts

@@ -0,0 +1 @@
+export * from "./customElement.js";

package/dist/components/geoscene-utility-network-aggregated-geometry/index.js

@@ -0,0 +1,2 @@
+import "@geoscene/calcite-components/components/calcite-switch";
+export * from "./customElement.js";

package/dist/components/geoscene-utility-network-association-list/customElement.js

@@ -0,0 +1,108 @@
+/* COPYRIGHT GeoScene - https://js.geoscene.cn/5.0/LICENSE.txt */
+import { c as r } from "../../chunks/runtime.js";
+import { html as o } from "lit";
+import { keyed as c } from "lit/directives/keyed.js";
+import { createReactiveMap as u } from "@geoscene/core/applications/Components/featureUtils.js";
+import { watch as l } from "@geoscene/core/core/reactiveUtils.js";
+import { substitute as d } from "@geoscene/core/intl.js";
+import { LitElement as h, safeClassMap as g } from "@geoscene/lumina";
+import { createRef as v, ref as m } from "lit/directives/ref.js";
+class F extends h {
+  constructor() {
+    super(...arguments), this._associationFeaturesIntersectionObserver = new IntersectionObserver(([t]) => {
+      t?.isIntersecting && this._increaseFeaturePage();
+    }, {
+      root: window.document
+    }), this._associationFeaturesIntersectionObserverNode = v(), this._currentFeaturePage = 1, this._increaseFeaturePage = () => {
+      const { state: t, showAllEnabled: e, associatedFeatureCount: i, featuresPerPage: s, currentFeaturePage: n } = this;
+      t === "ready" && e && i >= s * n && this.currentFeaturePage++;
+    }, this._isFeatureCountNoticeOpen = !0, this.associationViewModels = /* @__PURE__ */ new Map(), this.featuresPerPage = 50, this.maxFeatureCount = 1e3, this.showAllEnabled = !1, this.state = "ready", this.tooltipReferenceMap = u();
+  }
+  static {
+    this.properties = { associatedFeatureCount: 32, associationViewModels: 0, currentFeaturePage: 9, featuresPerPage: 9, maxFeatureCount: 9, messages: 0, parentFeatureViewModel: 0, selectedLayer: 0, showAllEnabled: 5, state: 1, tooltipReferenceMap: 0 };
+  }
+  get associatedFeatureCount() {
+    const t = this.associationViewModels, e = this.selectedLayer ? t.get(this.selectedLayer) : null;
+    return e ? e.length : 0;
+  }
+  get currentFeaturePage() {
+    return this._currentFeaturePage;
+  }
+  set currentFeaturePage(t) {
+    const { featuresPerPage: e, associatedFeatureCount: i } = this, s = Math.ceil(i / e) || 1, n = Math.max(Math.min(t, s), 1);
+    this._currentFeaturePage = n;
+  }
+  loaded() {
+    this.manager.onLifecycle(() => [
+      l(() => [this.state, this.showAllEnabled, this._associationFeaturesIntersectionObserverNode], () => {
+        this._handleAssociationFeaturesObserverChange();
+      }, { initial: !0 })
+    ]);
+  }
+  getConnectivityTooltip(t) {
+    const { messages: e } = this;
+    if (!e)
+      return "";
+    switch (t) {
+      case "connectivity":
+      case "junction-junction-connectivity":
+        return e.associationsJunctionJunction;
+      case "junction-edge-from-connectivity":
+        return e.associationsJunctionEdgeFrom;
+      case "junction-edge-midspan-connectivity":
+        return e.associationsJunctionEdgeMidspan;
+      case "junction-edge-to-connectivity":
+        return e.associationsJunctionEdgeTo;
+      default:
+        return "";
+    }
+  }
+  _handleAssociationFeaturesObserverChange() {
+    this._unobserveAssociationFeaturesObserver();
+    const { state: t, showAllEnabled: e } = this;
+    this._associationFeaturesIntersectionObserverNode.value && t === "ready" && e && this._associationFeaturesIntersectionObserver.observe(this._associationFeaturesIntersectionObserverNode.value);
+  }
+  _unobserveAssociationFeaturesObserver() {
+    this._associationFeaturesIntersectionObserverNode.value && this._associationFeaturesIntersectionObserver.unobserve(this._associationFeaturesIntersectionObserverNode.value);
+  }
+  _renderConnectivityIcon(t, e) {
+    const { tooltipReferenceMap: i } = this;
+    let s;
+    switch (t) {
+      case "junction-edge-from-connectivity":
+        s = "connection-end-left";
+        break;
+      case "junction-edge-to-connectivity":
+        s = "connection-end-right";
+        break;
+      case "junction-edge-midspan-connectivity":
+        s = "connection-middle";
+        break;
+      case "connectivity":
+      case "junction-junction-connectivity":
+      default:
+        s = "connection-to-connection";
+    }
+    return o`<calcite-icon .icon=${s} @pointerover=${(n) => {
+      i.set(e, n.currentTarget);
+    }} scale=s slot=content-start></calcite-icon>`;
+  }
+  _renderFeatureCountWarning() {
+    const { associatedFeatureCount: t, maxFeatureCount: e, messages: i } = this, s = d(i?.associationsLimitNoticeMessage ?? "", { number: e }), n = t > e, a = i?.associationsLimitNoticeTitle ?? "";
+    return n ? o`<calcite-notice class=${g(this._isFeatureCountNoticeOpen ? "notice-container" : "")} closable icon=information kind=info open scale=s width=full @calciteNoticeBeforeOpen=${() => this._isFeatureCountNoticeOpen = !0} @calciteNoticeClose=${() => this._isFeatureCountNoticeOpen = !1}><div slot=title>${a}</div><div slot=message>${s}</div></calcite-notice>` : null;
+  }
+  _renderFeatureObserver() {
+    return o`<div class="feature-observer" ${m(this._associationFeaturesIntersectionObserverNode)}></div>`;
+  }
+  _renderLoading() {
+    return c("loading-container", o`<div class="loading-container">${this._renderLoadingIcon()}</div>`);
+  }
+  _renderLoadingIcon() {
+    const t = this.messages?.loading ?? "";
+    return o`<calcite-loader inline .label=${t}></calcite-loader>`;
+  }
+}
+r("geoscene-utility-network-association-list", F);
+export {
+  F as GeosceneUtilityNetworkAssociationList
+};

package/dist/components/geoscene-utility-network-association-list/index.js

@@ -0,0 +1,4 @@
+import "@geoscene/calcite-components/components/calcite-icon";
+import "@geoscene/calcite-components/components/calcite-notice";
+import "@geoscene/calcite-components/components/calcite-loader";
+export * from "./customElement.js";