@arcgis/map-components 5.2.0-next.12 → 5.2.0-next.120

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

@@ -1,74 +1,85 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
-import { c as r } from "../../chunks/runtime.js";
+import { c as u } from "../../chunks/runtime.js";
 import { html as o } from "lit";
-import { keyed as c } from "lit/directives/keyed.js";
-import { createReactiveMap as u } from "@arcgis/core/applications/Components/featureUtils.js";
-import { watch as l } from "@arcgis/core/core/reactiveUtils.js";
-import { substitute as d } from "@arcgis/core/intl.js";
-import { LitElement as h, safeClassMap as g } from "@arcgis/lumina";
-import { createRef as v, ref as m } from "lit/directives/ref.js";
-class F extends h {
+import { keyed as l } from "lit/directives/keyed.js";
+import { u as a } from "../../chunks/useT9n.js";
+import { createReactiveMap as d } from "@arcgis/core/applications/Components/featureUtils.js";
+import { watch as h } from "@arcgis/core/core/reactiveUtils.js";
+import { substitute as g } from "@arcgis/core/intl.js";
+import { LitElement as m, safeClassMap as f } from "@arcgis/lumina";
+import { createRef as v, ref as r } from "lit/directives/ref.js";
+class p extends m {
   constructor() {
-    super(...arguments), this._associationFeaturesIntersectionObserver = new IntersectionObserver(([t]) => {
-      t?.isIntersecting && this._increaseFeaturePage();
+    super(...arguments), this._associationFeaturesIntersectionObserver = new IntersectionObserver(([e]) => {
+      e?.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();
+      const { state: e, showAllEnabled: t, associatedFeatureCount: s, featuresPerPage: i, currentFeaturePage: n } = this;
+      e === "ready" && t && s >= i * n && this.currentFeaturePage++;
+    }, this._isFeatureCountNoticeOpen = !0, this._messages = a({ name: "utility-network-associations", blocking: !0 }), this._messagesCommon = a({ name: "common", blocking: !0 }), this._tooltipReferenceCallbacks = /* @__PURE__ */ new Map(), this.associationViewModels = /* @__PURE__ */ new Map(), this.featuresPerPage = 50, this.maxFeatureCount = 1e3, this.showAllEnabled = !1, this.state = "ready", this.tooltipReferenceMap = d();
   }
   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 };
+    this.properties = { associatedFeatureCount: 32, associationViewModels: 0, currentFeaturePage: 9, endIndex: 32, featuresPerPage: 9, maxFeatureCount: 9, 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;
+    const e = this.associationViewModels, t = this.selectedLayer ? e.get(this.selectedLayer) : null;
+    return t ? t.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);
+  set currentFeaturePage(e) {
+    const { featuresPerPage: t, associatedFeatureCount: s } = this, i = Math.ceil(s / t) || 1, n = Math.max(Math.min(e, i), 1);
     this._currentFeaturePage = n;
   }
+  get endIndex() {
+    const { currentFeaturePage: e, featuresPerPage: t, maxFeatureCount: s } = this;
+    return Math.min(e * t, s);
+  }
+  disconnectedCallback() {
+    this._associationFeaturesIntersectionObserver.disconnect(), this._tooltipReferenceCallbacks.clear(), this.tooltipReferenceMap.clear(), super.disconnectedCallback();
+  }
   loaded() {
     this.manager.onLifecycle(() => [
-      l(() => [this.state, this.showAllEnabled, this._associationFeaturesIntersectionObserverNode], () => {
+      h(() => [this.state, this.showAllEnabled, this._associationFeaturesIntersectionObserverNode], () => {
         this._handleAssociationFeaturesObserverChange();
       }, { initial: !0 })
     ]);
   }
-  getConnectivityTooltip(t) {
-    const { messages: e } = this;
-    if (!e)
-      return "";
-    switch (t) {
+  getConnectivityTooltip(e) {
+    const { _messages: t } = this;
+    switch (e) {
       case "connectivity":
       case "junction-junction-connectivity":
-        return e.associationsJunctionJunction;
+        return t.associationsJunctionJunction;
       case "junction-edge-from-connectivity":
-        return e.associationsJunctionEdgeFrom;
+        return t.associationsJunctionEdgeFrom;
       case "junction-edge-midspan-connectivity":
-        return e.associationsJunctionEdgeMidspan;
+        return t.associationsJunctionEdgeMidspan;
       case "junction-edge-to-connectivity":
-        return e.associationsJunctionEdgeTo;
+        return t.associationsJunctionEdgeTo;
       default:
         return "";
     }
   }
+  _getTooltipReferenceCallback(e) {
+    let t = this._tooltipReferenceCallbacks.get(e);
+    return t || (t = (s) => {
+      s ? this.tooltipReferenceMap.set(e, s) : (this.tooltipReferenceMap.delete(e), this._tooltipReferenceCallbacks.delete(e));
+    }, this._tooltipReferenceCallbacks.set(e, t)), t;
+  }
   _handleAssociationFeaturesObserverChange() {
     this._unobserveAssociationFeaturesObserver();
-    const { state: t, showAllEnabled: e } = this;
-    this._associationFeaturesIntersectionObserverNode.value && t === "ready" && e && this._associationFeaturesIntersectionObserver.observe(this._associationFeaturesIntersectionObserverNode.value);
+    const { state: e, showAllEnabled: t } = this;
+    this._associationFeaturesIntersectionObserverNode.value && e === "ready" && t && this._associationFeaturesIntersectionObserver.observe(this._associationFeaturesIntersectionObserverNode.value);
   }
   _unobserveAssociationFeaturesObserver() {
     this._associationFeaturesIntersectionObserverNode.value && this._associationFeaturesIntersectionObserver.unobserve(this._associationFeaturesIntersectionObserverNode.value);
   }
-  _renderConnectivityIcon(t, e) {
-    const { tooltipReferenceMap: i } = this;
+  _renderConnectivityIcon(e, t) {
     let s;
-    switch (t) {
+    switch (e) {
       case "junction-edge-from-connectivity":
         s = "connection-end-left";
         break;
@@ -81,26 +92,24 @@ class F extends h {
       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>`;
+    return o`<calcite-icon .icon=${s} scale=s slot=content-start ${r(this._getTooltipReferenceCallback(t))}></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;
+    const { _messages: e, associatedFeatureCount: t, maxFeatureCount: s } = this, i = g(e.associationsLimitNoticeMessage ?? "", { number: s }), n = t > s, c = e.associationsLimitNoticeTitle ?? "";
+    return n ? o`<calcite-notice class=${f(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>${c}</div><div slot=message>${i}</div></calcite-notice>` : null;
   }
   _renderFeatureObserver() {
-    return o`<div class="feature-observer" ${m(this._associationFeaturesIntersectionObserverNode)}></div>`;
+    return o`<div class="feature-observer" ${r(this._associationFeaturesIntersectionObserverNode)}></div>`;
   }
   _renderLoading() {
-    return c("loading-container", o`<div class="loading-container">${this._renderLoadingIcon()}</div>`);
+    return l("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>`;
+    const e = this._messagesCommon.loading ?? "";
+    return o`<calcite-loader inline .label=${e}></calcite-loader>`;
   }
 }
-r("arcgis-utility-network-association-list", F);
+u("arcgis-utility-network-association-list", p);
 export {
-  F as ArcgisUtilityNetworkAssociationList
+  p as ArcgisUtilityNetworkAssociationList
 };

package/dist/components/arcgis-utility-network-associations/customElement.d.ts

@@ -22,6 +22,15 @@ export abstract class ArcgisUtilityNetworkAssociations extends LitElement {
    * prevent memory leaks.
    *
    * @default false
+   * @example
+   * ```html
+   * <arcgis-utility-network-associations auto-destroy-disabled></arcgis-utility-network-associations>
+   * ```
+   *
+   * ```js
+   * utilityNetworkAssociationsElement.autoDestroyDisabled = true;
+   * ```
+   * 
    */
   accessor autoDestroyDisabled: boolean;
   /**
@@ -219,8 +228,8 @@ export abstract class ArcgisUtilityNetworkAssociations extends LitElement {
    */
   accessor utilityNetwork: UtilityNetwork | null | undefined;
   /**
-   * The view associated with the component. 
-   *   > **Note:** The recommended approach is to fully migrate applications to use map and scene components and avoid using MapView and SceneView directly. However, if you are migrating a large application from widgets to components, you might prefer a more gradual transition. To support this use case, the SDK includes this `view` property which connects a component to a MapView or SceneView. Ultimately, once migration is complete, the arcgis-utility-network-associations component will be associated with a map or scene component rather than using the `view` property.
+   * The view associated with the component.
+   * > **Note:** The recommended approach is to fully migrate applications to use map and scene components and avoid using MapView and SceneView directly. However, if you are migrating a large application from widgets to components, you might prefer a more gradual transition. To support this use case, the SDK includes this `view` property which connects a component to a MapView or SceneView. Ultimately, once migration is complete, the arcgis-utility-network-associations component will be associated with a map or scene component rather than using the `view` property.
    *
    * @since 4.26
    */
@@ -230,7 +239,7 @@ export abstract class ArcgisUtilityNetworkAssociations extends LitElement {
   "@setterTypes": {
     icon?: IconName;
   };
-  /** Emitted when the component associated with a map or scene view is ready to be interacted with. */
+  /** Emitted when the component associated with a map or scene view is ready for user interaction. */
   readonly arcgisReady: import("@arcgis/lumina").TargetedEvent<this, void>;
   readonly "@eventTypes": {
     arcgisReady: ArcgisUtilityNetworkAssociations["arcgisReady"]["detail"];

package/dist/components/arcgis-utility-network-picker/customElement.d.ts

@@ -0,0 +1,56 @@
+/// <reference path="../../index.d.ts" />
+import type UtilityNetwork from "@arcgis/core/networks/UtilityNetwork.js";
+import type MapView from "@arcgis/core/views/MapView.js";
+import type { PublicLitElement as LitElement } from "@arcgis/lumina";
+import type { T9nMeta } from "@arcgis/lumina/controllers";
+
+/**
+ * This is a sub-component used by the **ArcgisUtilityNetworkTraceAnalysis** component.
+ * It allows users to select utility networks from the map.
+ *
+ * @since 5.2
+ * @internal
+ */
+export abstract class ArcgisUtilityNetworkPicker extends LitElement {
+  /** @internal */
+  protected _messages: {
+      componentLabel: string;
+      errors: {
+          mapLoadFailed: string;
+          noUtilityNetwork: string;
+          noView: string;
+          utilityNetworkLoadFailed: string;
+      };
+      labels: { utilityNetwork: string; };
+  } & T9nMeta<{
+      componentLabel: string;
+      errors: {
+          mapLoadFailed: string;
+          noUtilityNetwork: string;
+          noView: string;
+          utilityNetworkLoadFailed: string;
+      };
+      labels: { utilityNetwork: string; };
+  }>;
+  accessor error: string | undefined;
+  accessor heading: string | undefined;
+  /** @default false */
+  accessor hideErrors: boolean;
+  /** @default false */
+  accessor hideLoader: boolean;
+  accessor selectedUtilityNetwork: UtilityNetwork | undefined;
+  /** @default "loading" */
+  accessor state: "error" | "loading" | "ready";
+  /**
+   * The view associated with the component.
+   * > **Note:** The recommended approach is to fully migrate applications to use map and scene components and avoid using MapView and SceneView directly. However, if you are migrating a large application from widgets to components, you might prefer a more gradual transition. To support this use case, the SDK includes this `view` property which connects a component to a MapView or SceneView. Ultimately, once migration is complete, the arcgis-utility-network-picker component will be associated with a map or scene component rather than using the `view` property.
+   */
+  accessor view: MapView | undefined;
+  /** Fires when an error occurs while loading the utility networks from the map. */
+  readonly arcgisError: import("@arcgis/lumina").TargetedEvent<this, void>;
+  readonly arcgisPropertyChange: import("@arcgis/lumina").TargetedEvent<this, { name: "selectedUtilityNetwork" | "state"; }>;
+  readonly "@eventTypes": {
+    arcgisError: ArcgisUtilityNetworkPicker["arcgisError"]["detail"];
+    arcgisPropertyChange: ArcgisUtilityNetworkPicker["arcgisPropertyChange"]["detail"];
+  };
+}

package/dist/components/arcgis-utility-network-picker/customElement.js

@@ -0,0 +1,94 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+import { c } from "../../chunks/runtime.js";
+import h from "@arcgis/core/core/Collection.js";
+import { watch as d } from "@arcgis/core/core/reactiveUtils.js";
+import { LitElement as n, createEvent as m } from "@arcgis/lumina";
+import { usePropertyChange as w } from "@arcgis/lumina/controllers";
+import { log as o } from "@arcgis/toolkit/log";
+import { css as y, html as s } from "lit";
+import { l } from "../../chunks/async-utils.js";
+import { u as g } from "../../chunks/useT9n.js";
+const k = y`:host{height:100%;flex-grow:1}calcite-block{--calcite-block-content-space: 0;--calcite-block-border-color: transparent;margin:0}calcite-block :is(calcite-combobox,calcite-label,calcite-notice){margin:0 var(--calcite-space-md) var(--calcite-space-md)}calcite-block :last-child{margin-bottom:0}calcite-notice{margin:var(--calcite-space-md)}`;
+class u extends n {
+  constructor() {
+    super(...arguments), this._messages = g({ blocking: !0 }), this.hideErrors = !1, this.hideLoader = !1, this.state = "loading", this.arcgisPropertyChange = w()("selectedUtilityNetwork", "state"), this.arcgisError = m();
+  }
+  static {
+    this.properties = { _utilityNetworks: 16, view: 0, hideErrors: 5, hideLoader: 5, state: 1, error: 1, selectedUtilityNetwork: 0, heading: 1 };
+  }
+  static {
+    this.styles = k;
+  }
+  load() {
+    this.#e(), this.manager.onLifecycle(() => [
+      d(() => this.view?.map, () => this.#e())
+    ]);
+  }
+  willUpdate(t) {
+    t.has("_utilityNetworks") && this.#s(), t.has("selectedUtilityNetwork") && this.#o();
+  }
+  #t(t) {
+    this.error = t, this.state = "error", this.arcgisError.emit();
+  }
+  #i() {
+    this.error = void 0, this.state = "ready";
+  }
+  #e() {
+    if (this.error = void 0, this.state = "loading", !this.view?.map) {
+      o("error", this, this._messages.errors.noView), this._utilityNetworks = void 0, this.#t(this._messages.errors.noView);
+      return;
+    }
+    const t = this.view.map;
+    this.#r(t);
+  }
+  async #r(t) {
+    try {
+      t.loaded || await t.load();
+    } catch (e) {
+      this.#t(this._messages.errors.mapLoadFailed), l(e, this, this._messages.errors.mapLoadFailed);
+    } finally {
+      this._utilityNetworks = t.utilityNetworks || new h();
+    }
+  }
+  #s() {
+    const { selectedUtilityNetwork: t, _utilityNetworks: e } = this;
+    e?.length ? (!t || !e.includes(t)) && (this.selectedUtilityNetwork = e.at(0), this.arcgisPropertyChange.emit({ name: "selectedUtilityNetwork" })) : (this.#t(this._messages.errors.noUtilityNetwork), o("error", this, this._messages.errors.noUtilityNetwork), this.selectedUtilityNetwork = void 0);
+  }
+  async #o() {
+    const { selectedUtilityNetwork: t } = this;
+    try {
+      t && !t.loaded && await t.load(), this.#i();
+    } catch (e) {
+      l(e, this, this._messages.errors.utilityNetworkLoadFailed), this.#t(this._messages.errors.utilityNetworkLoadFailed);
+    }
+  }
+  #l() {
+    return this.hideLoader ? null : s`<calcite-loader label=loading></calcite-loader>`;
+  }
+  #a(t, e = !1, i) {
+    return this.hideErrors ? null : s`<calcite-notice .closable=${e} kind=danger open scale=s width=auto .icon=${i}><div slot=message>${t}</div></calcite-notice>`;
+  }
+  #c() {
+    const t = this._messages.labels.utilityNetwork, e = this._utilityNetworks?.map((i) => s`<calcite-combobox-item .value=${i.id} .heading=${i.title || i.id} .selected=${i.id === this.selectedUtilityNetwork?.id}></calcite-combobox-item>`);
+    return s`<calcite-combobox .label=${t} selection-mode=single-persist @calciteComboboxChange=${({ currentTarget: i }) => {
+      const r = i.selectedItems[0]?.value;
+      this.selectedUtilityNetwork?.id !== r && (this.selectedUtilityNetwork = this._utilityNetworks?.find((a) => a.id === r));
+    }}>${e}</calcite-combobox>`;
+  }
+  #h() {
+    const { selectedUtilityNetwork: t } = this;
+    return s`<calcite-label>${t?.title}</calcite-label>`;
+  }
+  #d(t) {
+    const e = this._messages.labels.utilityNetwork, i = this.heading || e, r = this._utilityNetworks?.length ? this._utilityNetworks?.length === 1 ? this.#h() : this.#c() : void 0;
+    return s`<calcite-block .heading=${i} .label=${e} expanded>${r}${t}</calcite-block>`;
+  }
+  render() {
+    const { error: t, state: e, selectedUtilityNetwork: i } = this, r = e === "error" && t ? this.#a(t, !1, "exclamation-mark-triangle") : void 0;
+    return !r && !i?.loaded && !i?.loadError ? this.#l() : e === "error" && r && !this._utilityNetworks?.length ? r : this.#d(r);
+  }
+}
+c("arcgis-utility-network-picker", u);
+export {
+  u as ArcgisUtilityNetworkPicker
+};

package/dist/components/arcgis-utility-network-picker/index.d.ts

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

package/dist/components/arcgis-utility-network-picker/index.js

@@ -0,0 +1,7 @@
+import "@esri/calcite-components/components/calcite-loader";
+import "@esri/calcite-components/components/calcite-notice";
+import "@esri/calcite-components/components/calcite-combobox-item";
+import "@esri/calcite-components/components/calcite-combobox";
+import "@esri/calcite-components/components/calcite-label";
+import "@esri/calcite-components/components/calcite-block";
+export * from "./customElement.js";

package/dist/components/arcgis-utility-network-trace/customElement.d.ts

@@ -29,6 +29,15 @@ export abstract class ArcgisUtilityNetworkTrace extends LitElement {
    * prevent memory leaks.
    *
    * @default false
+   * @example
+   * ```html
+   * <arcgis-utility-network-trace auto-destroy-disabled></arcgis-utility-network-trace>
+   * ```
+   *
+   * ```js
+   * utilityNetworkTraceElement.autoDestroyDisabled = true;
+   * ```
+   * 
    */
   accessor autoDestroyDisabled: boolean;
   /**
@@ -45,7 +54,7 @@ export abstract class ArcgisUtilityNetworkTrace extends LitElement {
    */
   accessor defaultGraphicColor: GraphicColor;
   /**
-   * When true, the component is visually withdrawn and cannot receive user interaction.
+   * When true, the component is visually de-emphasized and does not accept user interaction.
    *
    * @default false
    * @since 4.22
@@ -121,7 +130,7 @@ export abstract class ArcgisUtilityNetworkTrace extends LitElement {
    */
   accessor referenceElement: ArcgisReferenceElement | string | undefined;
   /**
-   * The properties to determine the size and color of the result area convex hull or buffer, and determines if it displays on the map when the trace completes.
+   * These properties determine the size and color of the result area convex hull or buffer, and determine whether it displays on the map when the trace completes.
    *
    * @default
    * {
@@ -205,8 +214,8 @@ export abstract class ArcgisUtilityNetworkTrace extends LitElement {
    */
   get traceResults(): TraceResultExtend[];
   /**
-   * The view associated with the component. 
-   *   > **Note:** The recommended approach is to fully migrate applications to use map and scene components and avoid using MapView and SceneView directly. However, if you are migrating a large application from widgets to components, you might prefer a more gradual transition. To support this use case, the SDK includes this `view` property which connects a component to a MapView or SceneView. Ultimately, once migration is complete, the arcgis-utility-network-trace component will be associated with a map or scene component rather than using the `view` property.
+   * The view associated with the component.
+   * > **Note:** The recommended approach is to fully migrate applications to use map and scene components and avoid using MapView and SceneView directly. However, if you are migrating a large application from widgets to components, you might prefer a more gradual transition. To support this use case, the SDK includes this `view` property which connects a component to a MapView or SceneView. Ultimately, once migration is complete, the arcgis-utility-network-trace component will be associated with a map or scene component rather than using the `view` property.
    */
   accessor view: MapView | null | undefined;
   checkCanTrace(): Promise<void>;
@@ -222,7 +231,7 @@ export abstract class ArcgisUtilityNetworkTrace extends LitElement {
   readonly arcgisAddResultArea: import("@arcgis/lumina").TargetedEvent<this, UtilityNetworkTraceViewModelAddResultAreaEvent>;
   /** Emitted when the value of a property is changed. Use this to listen to changes to properties. */
   readonly arcgisPropertyChange: import("@arcgis/lumina").TargetedEvent<this, { name: "state" | "traceResults"; }>;
-  /** Emitted when the component associated with a map or scene view is ready to be interacted with. */
+  /** Emitted when the component associated with a map or scene view is ready for user interaction. */
   readonly arcgisReady: import("@arcgis/lumina").TargetedEvent<this, void>;
   readonly arcgisRemoveResultArea: import("@arcgis/lumina").TargetedEvent<this, UtilityNetworkTraceViewModelRemoveResultAreaEvent>;
   readonly "@eventTypes": {

package/dist/components/arcgis-utility-network-trace/customElement.js

@@ -1,7 +1,7 @@
 /* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
 import { c as t } from "../../chunks/runtime.js";
 import { usePropertyChange as i } from "@arcgis/lumina/controllers";
-import { reEmitEvent as e } from "@arcgis/lumina/controllers/accessor";
+import { reEmitEvent as e } from "@arcgis/lumina-toolkit/reEmitEvent";
 import r from "@arcgis/core/widgets/UtilityNetworkTrace.js";
 import { LitElement as o, createEvent as a } from "@arcgis/lumina";
 import { m as s } from "../../chunks/useWidget.js";

package/dist/components/arcgis-utility-network-trace-aggregated-geometry-result-item/customElement.d.ts

@@ -0,0 +1,115 @@
+/// <reference path="../../index.d.ts" />
+import type Color from "@arcgis/core/Color.js";
+import type Graphic from "@arcgis/core/Graphic.js";
+import type GraphicsLayer from "@arcgis/core/layers/GraphicsLayer.js";
+import type TraceResult from "@arcgis/core/rest/networks/support/TraceResult.js";
+import type MapView from "@arcgis/core/views/MapView.js";
+import type { PublicLitElement as LitElement } from "@arcgis/lumina";
+import type { T9nMeta } from "@arcgis/lumina/controllers";
+
+/**
+ * Trace result item for displaying [aggregated geometry](https://developers.arcgis.com/javascript/latest/references/core/rest/networks/support/TraceResult/#aggregatedGeometry) results from a trace.
+ *
+ * @internal
+ * @since 5.2
+ * @see [Result types](https://doc.esri.com/en/arcgis-pro/latest/help/data/utility-network/configure-a-trace.html#DA5)
+ */
+export abstract class ArcgisUtilityNetworkTraceAggregatedGeometryResultItem extends LitElement {
+  /** @internal */
+  protected _messages: {
+      headings: { setColor: string; };
+      labels: {
+          aggregatedGeometryGraphicsColor: string;
+          showGraphicsToggle: string;
+      };
+      showGraphics: string;
+  } & T9nMeta<{
+      headings: { setColor: string; };
+      labels: {
+          aggregatedGeometryGraphicsColor: string;
+          showGraphicsToggle: string;
+      };
+      showGraphics: string;
+  }>;
+  /**
+   * If true, the component will not be destroyed automatically when it is
+   * disconnected from the document. This is useful when you want to move the
+   * component to a different place on the page, or temporarily hide it. If this
+   * is set, make sure to call the [destroy()](https://developers.arcgis.com/javascript/latest/references/map-components/components/arcgis-utility-network-trace-aggregated-geometry-result-item/#destroy) method when you are done to
+   * prevent memory leaks.
+   *
+   * @default false
+   * @example
+   * ```html
+   * <arcgis-utility-network-trace-aggregated-geometry-result-item auto-destroy-disabled></arcgis-utility-network-trace-aggregated-geometry-result-item>
+   * ```
+   *
+   * ```js
+   * utilityNetworkTraceAggregatedGeometryResultItemElement.autoDestroyDisabled = true;
+   * ```
+   * 
+   */
+  accessor autoDestroyDisabled: boolean;
+  /**
+   * The size of the aggregated geometry graphics to render, in points.
+   *
+   * @default 12
+   */
+  accessor defaultSelectionSize: number;
+  /** The graphics which represent the aggregated geometry results from the trace. */
+  get geometryGraphics(): Graphic[];
+  /**
+   * The color used for the aggregated geometry graphics.
+   * Default value is #FFFF00.
+   */
+  accessor graphicsColor: Color;
+  /**
+   * The layer used to render the graphics which represent the aggregated geometry result.
+   * If this property is not specified, a new layer will be created on the map.
+   */
+  accessor graphicsLayer: GraphicsLayer | undefined;
+  /** The heading of the result item. */
+  accessor heading: string | undefined;
+  /**
+   * Whether to hide the aggregated geometry [graphics](https://developers.arcgis.com/javascript/latest/references/map-components/components/arcgis-utility-network-trace-aggregated-geometry-result-item/#geometryGraphics)
+   * from the map when the trace result contains aggregated geometry results.
+   *
+   * @default false
+   */
+  accessor hideGraphics: boolean;
+  /**
+   * The trace result containing the aggregated geometry result to render graphics for.
+   *
+   * @required
+   */
+  accessor traceResult: TraceResult | undefined;
+  /**
+   * The view associated with the component.
+   * > **Note:** The recommended approach is to fully migrate applications to use map and scene components and avoid using MapView and SceneView directly. However, if you are migrating a large application from widgets to components, you might prefer a more gradual transition. To support this use case, the SDK includes this `view` property which connects a component to a MapView or SceneView. Ultimately, once migration is complete, the arcgis-utility-network-trace-aggregated-geometry-result-item component will be associated with a map or scene component rather than using the `view` property.
+   *
+   * @required
+   */
+  accessor view: MapView | undefined;
+  /**
+   * Removes the [layer](https://developers.arcgis.com/javascript/latest/references/map-components/components/arcgis-utility-network-trace-aggregated-geometry-result-item/#graphicsLayer)
+   * containing the aggregated geometry graphics from the map.
+   */
+  clearResult(): void;
+  /** Permanently destroy the component. */
+  destroy(): Promise<void>;
+  readonly arcgisPropertyChange: import("@arcgis/lumina").TargetedEvent<this, { name: "defaultSelectionSize" | "geometryGraphics" | "hideGraphics" | "graphicsColor"; }>;
+  /**
+   * Fires when the component finishes processing the aggregated geometry results.
+   *
+   * If the component has a valid trace result with aggregated geometry results, this fires
+   * when the aggregated geometry graphics have been added to the map.
+   *
+   * If the component does not have a valid map or trace result, this fires when the
+   * component has finished loading.
+   */
+  readonly arcgisResultReady: import("@arcgis/lumina").TargetedEvent<this, void>;
+  readonly "@eventTypes": {
+    arcgisPropertyChange: ArcgisUtilityNetworkTraceAggregatedGeometryResultItem["arcgisPropertyChange"]["detail"];
+    arcgisResultReady: ArcgisUtilityNetworkTraceAggregatedGeometryResultItem["arcgisResultReady"]["detail"];
+  };
+}