@arcgis/map-components 5.2.0-next.14 → 5.2.0-next.140

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

@@ -0,0 +1,86 @@
+/// <reference path="../../index.d.ts" />
+import type TraceResult from "@arcgis/core/rest/networks/support/TraceResult.js";
+import type { PublicLitElement as LitElement } from "@arcgis/lumina";
+import type { UtilityNetworkTraceResultItemState } from "../arcgis-utility-network-trace-analysis/types.js";
+import type { T9nMeta } from "@arcgis/lumina/controllers";
+
+/**
+ * Trace result item for displaying [function](https://developers.arcgis.com/javascript/latest/references/core/rest/networks/support/TraceResult/#globalFunctionResults) results from a trace.
+ *
+ * @since 5.2
+ * @see [Set up functions](https://doc.esri.com/en/arcgis-pro/latest/help/data/utility-network/configure-a-trace.html#CBB)
+ */
+export abstract class ArcgisUtilityNetworkTraceFunctionsResultItem extends LitElement {
+  /** @internal */
+  protected _messages: {
+      componentLabel: string;
+      functions: string;
+      labels: { functionResults: string; };
+  } & T9nMeta<{
+      componentLabel: string;
+      functions: string;
+      labels: { functionResults: 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-functions-result-item/#destroy) method when you are done to
+   * prevent memory leaks.
+   *
+   * @default false
+   * @example
+   * ```html
+   * <arcgis-utility-network-trace-functions-result-item auto-destroy-disabled></arcgis-utility-network-trace-functions-result-item>
+   * ```
+   *
+   * ```js
+   * utilityNetworkTraceFunctionsResultItemElement.autoDestroyDisabled = true;
+   * ```
+   * 
+   */
+  accessor autoDestroyDisabled: boolean;
+  /**
+   * Whether the component emits event [@arcgisResultReady](https://developers.arcgis.com/javascript/latest/references/map-components/components/arcgis-utility-network-trace-functions-result-item/#event-arcgisResultReady).
+   * This property is always `true` for [arcgis-utility-network-trace-functions-result-item](https://developers.arcgis.com/javascript/latest/references/map-components/components/arcgis-utility-network-trace-functions-result-item/).
+   *
+   * @default false
+   */
+  get emitsArcgisResultReady(): true;
+  /** The heading displayed above the result item. */
+  accessor heading: string | undefined;
+  /**
+   * Replace localized message strings with your own strings.
+   *
+   * _**Note**: Individual message keys may change between releases._
+   */
+  accessor messageOverrides: {
+      componentLabel?: string | undefined;
+      functions?: string | undefined;
+      labels?: { functionResults?: string | undefined; } | undefined;
+  };
+  /**
+   * @default "ready"
+   * @internal
+   */
+  get state(): UtilityNetworkTraceResultItemState;
+  /** The trace result containing the function results to render. */
+  get traceResult(): TraceResult | undefined;
+  /**
+   * Clears the result item.
+   * This result item has no side effects to clear.
+   *
+   * @internal
+   */
+  clearResult(): void;
+  /** Permanently destroy the component. */
+  destroy(): Promise<void>;
+  /** 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"; }>;
+  /** Fires when the component is finished rendering its results. */
+  readonly arcgisResultReady: import("@arcgis/lumina").TargetedEvent<this, void>;
+  readonly "@eventTypes": {
+    arcgisPropertyChange: ArcgisUtilityNetworkTraceFunctionsResultItem["arcgisPropertyChange"]["detail"];
+    arcgisResultReady: ArcgisUtilityNetworkTraceFunctionsResultItem["arcgisResultReady"]["detail"];
+  };
+}

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

@@ -0,0 +1,76 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/6.0/LICENSE.txt */
+import { c as g } from "../../chunks/runtime.js";
+import { LitElement as d, createEvent as R } from "@arcgis/lumina";
+import { usePropertyChange as f, bypassReadOnly as a } from "@arcgis/lumina/controllers";
+import { log as i, composeEmptyPropertyMessage as p } from "@arcgis/toolkit/log";
+import { css as b, html as l } from "lit";
+import { u as y } from "../../chunks/useT9n.js";
+import { i as c } from "../../chunks/utils5.js";
+const w = b`calcite-table{--calcite-table-border-color: none}calcite-table-row{--calcite-table-row-border-color: var(--calcite-color-border-3)}.functions-heading{margin:0 0 var(--calcite-spacing-xxs);font-weight:var(--calcite-font-weight-medium);font-size:var(--calcite-font-size);color:var(--calcite-color-text-1)}`;
+class v extends d {
+  constructor() {
+    super(...arguments), this._messages = y({ blocking: !0 }), this.autoDestroyDisabled = !1, this.emitsArcgisResultReady = !0, this.state = "ready", this.arcgisPropertyChange = f()("state"), this.arcgisResultReady = R();
+  }
+  static {
+    this.properties = { autoDestroyDisabled: 5, emitsArcgisResultReady: 32, heading: 1, messageOverrides: 0, state: 32, traceResult: 32 };
+  }
+  static {
+    this.styles = w;
+  }
+  get #t() {
+    const { parentElement: t } = this.el;
+    if (t && c(t))
+      return t;
+    const e = this.el.getRootNode();
+    if (e instanceof ShadowRoot && c(e.host))
+      return e.host;
+  }
+  clearResult() {
+  }
+  async destroy() {
+    await this.manager.destroy();
+  }
+  load() {
+    this.manager.onLifecycle(() => {
+      const t = this.#t;
+      if (!t) {
+        i("warn", this, "This component must be used as a child of `arcgis-utility-network-trace-results`.");
+        return;
+      }
+      const e = (r) => this.#s(r);
+      return t.addEventListener("arcgisPropertyChange", e), a(() => {
+        this.traceResult = t.traceResult;
+      }), () => {
+        t.removeEventListener("arcgisPropertyChange", e);
+      };
+    }), this.traceResult && this.#e();
+  }
+  willUpdate(t) {
+    t.has("traceResult") && this.#e();
+  }
+  loaded() {
+    this.traceResult && !this.traceResult.globalFunctionResults.length && i("warn", this, p("traceResult.globalFunctionResults"));
+  }
+  #s(t) {
+    if (t.target !== this.#t)
+      return;
+    const { target: e } = t;
+    t.detail.name === "traceResult" && a(() => this.traceResult = e.traceResult);
+  }
+  #e() {
+    a(() => this.state = "ready"), this.arcgisResultReady.emit();
+  }
+  render() {
+    if (!this.traceResult?.globalFunctionResults.length)
+      return null;
+    const { heading: t, _messages: e } = this, { globalFunctionResults: r } = this.traceResult;
+    return l`<div class="functions-heading">${t || e.functions}</div><calcite-table .caption=${e.labels.functionResults}>${r.filter((s) => s.networkAttributeName != null && s.result != null && s.functionType != null).map((s) => {
+      const { functionName: o, networkAttributeName: n, functionType: u, result: h } = s, m = o || `${n} ${u}`;
+      return l`<calcite-table-row><calcite-table-cell>${m}</calcite-table-cell><calcite-table-cell>${h}</calcite-table-cell></calcite-table-row>`;
+    })}</calcite-table>`;
+  }
+}
+g("arcgis-utility-network-trace-functions-result-item", v);
+export {
+  v as ArcgisUtilityNetworkTraceFunctionsResultItem
+};

package/dist/components/arcgis-utility-network-trace-functions-result-item/index.d.ts

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

package/dist/components/arcgis-utility-network-trace-functions-result-item/index.js

@@ -0,0 +1,4 @@
+import "@esri/calcite-components/components/calcite-table";
+import "@esri/calcite-components/components/calcite-table-row";
+import "@esri/calcite-components/components/calcite-table-cell";
+export * from "./customElement.js";

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

@@ -6,19 +6,19 @@ import type UtilityNetwork from "@arcgis/core/networks/UtilityNetwork.js";
 import type TraceLocation from "@arcgis/core/rest/networks/support/TraceLocation.js";
 import type MapView from "@arcgis/core/views/MapView.js";
 import type { PublicLitElement as LitElement } from "@arcgis/lumina";
+import type { ArcgisFeaturesNext } from "../arcgis-features-next/customElement.js";
+import type { ArcgisUtilityNetworkPicker } from "../arcgis-utility-network-picker/customElement.js";
 import type { ArcgisReferenceElement } from "../types.js";
 import type { UtilityNetworkTraceAnalysisDisplayMode } from "../arcgis-utility-network-trace-analysis/types.js";
-import type { FlagInfo, SelectStartPayload } from "../arcgis-utility-network-trace-location/customElement.js";
+import type { ArcgisUtilityNetworkTraceConfigurationPicker } from "../arcgis-utility-network-trace-configuration-picker/customElement.js";
+import type { ArcgisUtilityNetworkTraceLocations, TraceLocationDetails, SelectStartPayload } from "../arcgis-utility-network-trace-locations/customElement.js";
 import type { T9nMeta } from "@arcgis/lumina/controllers";
 
 /**
  * This is a sub-component used by the **ArcgisUtilityNetworkTraceAnalysis** component.
- *
- * This sub-component takes a map view as an input.
  * It allows users to select utility networks, trace configurations, and input features for tracing.
  *
- * @since 4.34
- * @internal
+ * @since 5.2
  */
 export abstract class ArcgisUtilityNetworkTraceInputs extends LitElement {
   /** @internal */
@@ -28,42 +28,25 @@ export abstract class ArcgisUtilityNetworkTraceInputs extends LitElement {
           cancel: string;
       };
       componentLabel: string;
-      errors: {
-          noCompatibleSubnetworks: string;
-          noNamedTraceConfigurations: string;
-          noTraceConfiguration: string;
-          noUtilityNetwork: string;
-          noView: string;
-          utilityNetworkLoadFailed: string;
-      };
-      instructions: {
-          addSpatial: {
-              selectAssociatedFeature: {
-                  heading: string;
-                  subheading: string;
-              };
-              selectFeature: {
-                  heading: string;
-                  subheading: string;
-              };
+      errors: { noView: string; };
+      instructions: { addSpatial: {
+          selectAssociatedFeature: {
+              heading: string;
+              subheading: string;
           };
-          enterSubnetworkName: string;
-      };
+          selectFeature: {
+              heading: string;
+              subheading: string;
+          };
+      }; };
       labels: {
           addSpatial: {
               barrier: string;
               startingPoint: string;
               stoppingPoint: string;
           };
-          featureList: string;
-          subnetworkInfo: string;
-          subnetworkName: string;
-          tooManySubnetworks: string;
-          traceConfiguration: string;
           traceInputs: string;
-          utilityNetwork: string;
       };
-      unknown: string;
       warnings: { exceededDisplayLimit: string; };
   } & T9nMeta<{
       buttons: {
@@ -71,42 +54,25 @@ export abstract class ArcgisUtilityNetworkTraceInputs extends LitElement {
           cancel: string;
       };
       componentLabel: string;
-      errors: {
-          noCompatibleSubnetworks: string;
-          noNamedTraceConfigurations: string;
-          noTraceConfiguration: string;
-          noUtilityNetwork: string;
-          noView: string;
-          utilityNetworkLoadFailed: string;
-      };
-      instructions: {
-          addSpatial: {
-              selectAssociatedFeature: {
-                  heading: string;
-                  subheading: string;
-              };
-              selectFeature: {
-                  heading: string;
-                  subheading: string;
-              };
+      errors: { noView: string; };
+      instructions: { addSpatial: {
+          selectAssociatedFeature: {
+              heading: string;
+              subheading: string;
           };
-          enterSubnetworkName: string;
-      };
+          selectFeature: {
+              heading: string;
+              subheading: string;
+          };
+      }; };
       labels: {
           addSpatial: {
               barrier: string;
               startingPoint: string;
               stoppingPoint: string;
           };
-          featureList: string;
-          subnetworkInfo: string;
-          subnetworkName: string;
-          tooManySubnetworks: string;
-          traceConfiguration: string;
           traceInputs: string;
-          utilityNetwork: string;
       };
-      unknown: string;
       warnings: { exceededDisplayLimit: string; };
   }>;
   /**
@@ -117,73 +83,106 @@ export abstract class ArcgisUtilityNetworkTraceInputs extends LitElement {
    * prevent memory leaks.
    *
    * @default false
-   */
-  accessor autoDestroyDisabled: boolean;
-  /**
-   * A function to run before trace location selection starts.
+   * @example
+   * ```html
+   * <arcgis-utility-network-trace-inputs auto-destroy-disabled></arcgis-utility-network-trace-inputs>
+   * ```
    *
-   * @internal
+   * ```js
+   * utilityNetworkTraceInputsElement.autoDestroyDisabled = true;
+   * ```
+   * 
    */
-  accessor beforeTraceLocationSelectStart: (() => Promise<void>) | undefined;
+  accessor autoDestroyDisabled: boolean;
+  /** A function to run before trace location selection starts. */
+  accessor beforeMapInteraction: (() => Promise<void>) | undefined;
   /**
    * @default false
    * @internal
    */
-  accessor hideActionBar: boolean;
+  accessor hideFeaturesActionBar: boolean;
   /**
+   * Whether a the user has selected a named trace configuration that executes a
+   * subnetwork trace with a specified subnetwork name.
+   *
    * @default false
    * @internal
    */
   get isSubnetworkNameTraceSelected(): boolean;
+  /**
+   * Replace localized message strings with your own strings.
+   *
+   * _**Note**: Individual message keys may change between releases._
+   */
+  accessor messageOverrides: NonNullable<ArcgisFeaturesNext["messageOverrides"]> & NonNullable<ArcgisUtilityNetworkPicker["messageOverrides"]> & NonNullable<ArcgisUtilityNetworkTraceConfigurationPicker["messageOverrides"]> & NonNullable<ArcgisUtilityNetworkTraceLocations["messageOverrides"]> & {
+      buttons?: {
+          add?: string | undefined;
+          cancel?: string | undefined;
+      } | undefined;
+      componentLabel?: string | undefined;
+      errors?: { noView?: string | undefined; } | undefined;
+      instructions?: { addSpatial?: {
+          selectAssociatedFeature?: {
+              heading?: string | undefined;
+              subheading?: string | undefined;
+          } | undefined;
+          selectFeature?: {
+              heading?: string | undefined;
+              subheading?: string | undefined;
+          } | undefined;
+      } | undefined; } | undefined;
+      labels?: {
+          addSpatial?: {
+              barrier?: string | undefined;
+              startingPoint?: string | undefined;
+              stoppingPoint?: string | undefined;
+          } | undefined;
+          traceInputs?: string | undefined;
+      } | undefined;
+      warnings?: { exceededDisplayLimit?: string | undefined; } | undefined;
+  };
   /** @default "default" */
   accessor mode: UtilityNetworkTraceAnalysisDisplayMode;
+  /**
+   * By assigning the `id` attribute of the Map or Scene component to this property, you can position a child component anywhere in the DOM while still maintaining a connection to the Map or Scene.
+   *
+   * @see [Associate components with a Map or Scene component](https://developers.arcgis.com/javascript/latest/programming-patterns/#associate-components-with-a-map-or-scene-component)
+   */
   accessor referenceElement: ArcgisReferenceElement | string | undefined;
   accessor selectedNamedTraceConfiguration: NamedTraceConfiguration | undefined;
   accessor selectedUtilityNetwork: UtilityNetwork | undefined;
+  /**
+   * A clone of the utility network trace configuration associated with
+   * the selected named trace configuration. Updates on this object are
+   * used to reflect the user's changes to the named trace configuration.
+   */
+  get traceConfiguration(): UNTraceConfiguration | undefined;
   /**
    * Supplementary information about the points selected on the map to run the trace.
    * I.e., feature title, terminal configuration, selected terminals, and spatial properties.
    *
    * @internal
    */
-  get traceLocationFlagInfos(): Collection<FlagInfo>;
+  get traceLocationDetails(): Collection<TraceLocationDetails>;
   get traceLocations(): TraceLocation[];
   /**
-   * A clone of the utility network trace configuration associated with
-   * the selected named trace configuration. Updates on this object are
-   * used to reflect the user's changes to the named trace configuration.
+   * 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-inputs component will be associated with a map or scene component rather than using the `view` property.
    */
-  get unTraceConfiguration(): UNTraceConfiguration | undefined;
-  /** @required */
   accessor view: MapView | undefined;
   /** Permanently destroy the component. */
   destroy(): Promise<void>;
-  readonly arcgisPropertyChange: import("@arcgis/lumina").TargetedEvent<this, { name: "mode"; }>;
-  /** Fires when the user changes the selected named trace configuration. */
-  readonly arcgisSelectedNamedTraceConfigurationChange: import("@arcgis/lumina").TargetedEvent<this, void>;
-  /** There will be more added to this event as we increase the functionality of this component */
-  readonly arcgisTraceInputsChange: import("@arcgis/lumina").TargetedEvent<this, void>;
-  /**
-   * Fires when the user completes the selection of a trace location.
-   *
-   * @internal
-   */
+  readonly arcgisPropertyChange: import("@arcgis/lumina").TargetedEvent<this, { name: "mode" | "selectedNamedTraceConfiguration" | "selectedUtilityNetwork" | "traceLocations"; }>;
+  /** Fires when the user completes the selection of a trace location. */
   readonly arcgisTraceLocationSelectEnd: import("@arcgis/lumina").TargetedEvent<this, void>;
   /**
    * Fires when the user begins selection of a trace location.
    * Can be prevented to stop the selection.
-   *
-   * @internal
    */
   readonly arcgisTraceLocationSelectStart: import("@arcgis/lumina").TargetedEvent<this, SelectStartPayload>;
-  /** This will be fired less often than above, only when the utility network changes */
-  readonly arcgisUtilityNetworkChange: import("@arcgis/lumina").TargetedEvent<this, void>;
   readonly "@eventTypes": {
     arcgisPropertyChange: ArcgisUtilityNetworkTraceInputs["arcgisPropertyChange"]["detail"];
-    arcgisSelectedNamedTraceConfigurationChange: ArcgisUtilityNetworkTraceInputs["arcgisSelectedNamedTraceConfigurationChange"]["detail"];
-    arcgisTraceInputsChange: ArcgisUtilityNetworkTraceInputs["arcgisTraceInputsChange"]["detail"];
     arcgisTraceLocationSelectEnd: ArcgisUtilityNetworkTraceInputs["arcgisTraceLocationSelectEnd"]["detail"];
     arcgisTraceLocationSelectStart: ArcgisUtilityNetworkTraceInputs["arcgisTraceLocationSelectStart"]["detail"];
-    arcgisUtilityNetworkChange: ArcgisUtilityNetworkTraceInputs["arcgisUtilityNetworkChange"]["detail"];
   };
 }