@arcgis/map-components 4.33.0-next.99 → 4.34.0-next.1

package/dist/components/arcgis-legend/customElement.d.ts

@@ -1,17 +1,17 @@
 /// <reference types="@arcgis/core/interfaces.d.ts" />
 /// <reference types="../../index.d.ts" />
 import { Use } from '@arcgis/lumina/controllers';
-import { Nil } from '@arcgis/components-utils';
 import { default as Legend } from '@arcgis/core/widgets/Legend.js';
 import { PublicLitElement as LitElement, TargetedEvent } from '@arcgis/lumina';
 import { ArcgisReferenceElement } from '../../utils/component-utils';
 
-declare const useLegendWidget: (component: LitElement & Pick<Legend, never> & {
+declare const useLegendWidget: (component: LitElement & Pick<Legend, "icon" | "label" | "viewModel" | "headingLevel" | "activeLayerInfos" | "basemapLegendVisible" | "hideLayersNotInCurrentView" | "layerInfos" | "respectLayerDefinitionExpression"> & {
     state?: unknown;
     viewModel?: __esri.LegendViewModel | undefined;
-    icon: Nil | string;
-    label: Nil | string;
-    referenceElement: ArcgisReferenceElement | Nil | string;
+    closed?: boolean;
+    icon: import('@arcgis/components-utils').Nil | string;
+    label: import('@arcgis/components-utils').Nil | string;
+    referenceElement?: ArcgisReferenceElement | string;
     position: __esri.UIPosition;
     arcgisReady: import('@arcgis/lumina').EventEmitter;
     arcgisPropertyChange: import('@arcgis/lumina').EventEmitter<{
@@ -21,49 +21,115 @@ declare const useLegendWidget: (component: LitElement & Pick<Legend, never> & {
         childElem?: HTMLElement & {
             ownedBy?: HTMLElement;
         };
-        view?: __esri.MapView | __esri.SceneView | Nil;
+        view?: __esri.LinkChartView | __esri.MapView | __esri.SceneView;
     };
     autoDestroyDisabled: boolean;
     destroy: () => Promise<void>;
-}, options?: {
-    editConstructorProperties(props: __esri.LegendProperties | undefined): __esri.LegendProperties | Promise<__esri.LegendProperties | undefined> | undefined;
-} | undefined) => Legend;
-/** The Legend component describes the symbols used to represent layers in a map.
+}) => Legend;
+/**
+ * The Legend component describes the symbols used to represent layers in a map.
+ *
+ * [Read more...](https://developers.arcgis.com/javascript/latest/references/map-components/arcgis-legend/)
  */
 export declare class ArcgisLegend extends LitElement {
+    /**
+     * Collection of [ActiveLayerInfo](https://developers.arcgis.com/javascript/latest/api-reference/esri-widgets-Legend-support-ActiveLayerInfo.html) objects used by the legend view to
+     * display data in the legend.
+     *
+     * [Read more...](https://developers.arcgis.com/javascript/latest/api-reference/esri-widgets-Legend.html#activeLayerInfos)
+     */
     activeLayerInfos: __esri.Collection<__esri.ActiveLayerInfo>;
     /**
      * 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\` method when you are done to prevent
-     * memory leaks.
+     * is set, make sure to call the [destroy](https://developers.arcgis.com/javascript/latest/references/map-components/arcgis-legend/#destroy) method when you are done to
+     * prevent memory leaks.
+     *
+     * @default false
      */
     autoDestroyDisabled: boolean;
+    /**
+     * Indicates whether to show the [Basemap](https://developers.arcgis.com/javascript/latest/api-reference/esri-Basemap.html) layers in the Legend.
+     *
+     * @default false
+     */
     basemapLegendVisible: boolean;
+    /**
+     * Indicates the heading level to use for the legend title.
+     *
+     * @default 3
+     */
     headingLevel: number;
+    /**
+     * When `true`, layers will only be shown in the legend if
+     * they are visible in the view's extent.
+     *
+     * @default false
+     */
     hideLayersNotInCurrentView: boolean;
     /**
-     * Icon which represents the component.
-     * Typically used when the component is controlled by another component (e.g. by the Expand component).
-     * Search [Calcite Icons](https://developers.arcgis.com/calcite-design-system/icons/) for possible values.
+     * Icon which represents the widget.
+     *
+     * @see [Calcite Icons](https://developers.arcgis.com/calcite-design-system/icons/)
+     * @default "legend"
      */
     icon: string;
-    /** The component's default label. */
+    /**
+     * The widget's default label.
+     *
+     * [Read more...](https://developers.arcgis.com/javascript/latest/api-reference/esri-widgets-Legend.html#label)
+     */
     label: string;
+    /**
+     * Specifies a subset of the layers to display in the legend.
+     *
+     * [Read more...](https://developers.arcgis.com/javascript/latest/api-reference/esri-widgets-Legend.html#layerInfos)
+     */
     layerInfos: __esri.LegendLayerInfos[];
+    /**
+     * Indicates the style of the legend.
+     *
+     * [Read more...](https://developers.arcgis.com/javascript/latest/api-reference/esri-widgets-Legend.html#style)
+     *
+     * @default "classic"
+     */
     legendStyle: string | __esri.LegendStyle;
+    /** @default "bottom-left" */
     position: __esri.UIPosition;
-    referenceElement: ArcgisReferenceElement | Nil | string;
+    referenceElement?: ArcgisReferenceElement | string;
+    /**
+     * If a layer uses a unique value render, only features that satisfy the layer's
+     * [definition expression](https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-FeatureLayer.html#definitionExpression)
+     * will be displayed in the legend when set to true.
+     *
+     * @default false
+     */
     respectLayerDefinitionExpression: boolean;
-    /** @default false */
+    /**
+     * Determines whether to respect the properties of the layers in the map that
+     * control the legend's visibility (`minScale`, `maxScale`, `legendEnabled`).
+     *
+     * [Read more...](https://developers.arcgis.com/javascript/latest/api-reference/esri-widgets-Legend.html#respectLayerVisibility)
+     *
+     * @default false
+     */
     respectLayerVisibilityDisabled: boolean;
+    /**
+     * The view model's state.
+     *
+     * [Read more...](https://developers.arcgis.com/javascript/latest/api-reference/esri-widgets-Legend-LegendViewModel.html#state)
+     *
+     * @default "disabled"
+     */
     readonly state: "ready" | "disabled";
-    /** Permanently destroy the component */
+    /** 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: TargetedEvent<this, {
         name: "state";
     }>;
-    readonly arcgisReady: TargetedEvent<this, undefined>;
+    /** Emitted when the component associated with a map or scene view is is ready to be interacted with. */
+    readonly arcgisReady: TargetedEvent<this, void>;
 }
 export {};

package/dist/components/arcgis-legend/customElement.js

@@ -5,8 +5,8 @@ import { LitElement as s, createEvent as r, noShadowRoot as a } from "@arcgis/lu
 import { m as o } from "../../chunks/useWidget.js";
 import { css as n } from "@lit/reactive-element/css-tag.js";
 /*! All material copyright Esri, All Rights Reserved, unless otherwise specified.
-See https://js.arcgis.com/4.33/esri/copyright.txt for details.
-v4.33.0-next.99 */
+See https://js.arcgis.com/4.34/esri/copyright.txt for details.
+v4.34.0-next.1 */
 const l = n`@layer{arcgis-legend{display:block}}`, d = o(i);
 class h extends s {
   constructor() {
@@ -21,9 +21,6 @@ class h extends s {
   static {
     this.styles = l;
   }
-  //#endregion
-  //#region Public Methods
-  /** Permanently destroy the component */
   async destroy() {
     await this.manager.destroy();
   }

package/dist/components/arcgis-line-of-sight/LineOfSightViewModel.d.ts

@@ -0,0 +1,15 @@
+import { AnalysisViewModel, ConstructProperties } from '../../support/AnalysisViewModel';
+import { default as SceneView } from '@arcgis/core/views/SceneView';
+import { default as LineOfSightAnalysis } from '@arcgis/core/analysis/LineOfSightAnalysis.js';
+declare class LineOfSightViewModel extends AnalysisViewModel<SceneView, LineOfSightAnalysis> implements ConstructProperties<SceneView, LineOfSightAnalysis> {
+    constructor(properties?: Partial<ConstructProperties<SceneView, LineOfSightAnalysis>>);
+    get state(): "created" | "creating" | "disabled" | "ready";
+    protected readonly supportedViewType = "3d";
+    protected readonly unsupportedErrorMessage = "The Line Of Sight component is only supported in 3D views.";
+    protected constructAnalysis(): LineOfSightAnalysis;
+    protected clearAnalysis(): void;
+    place(options: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+}
+export default LineOfSightViewModel;

package/dist/components/arcgis-line-of-sight/css.d.ts

@@ -0,0 +1,9 @@
+export declare const css: {
+    readonly base: "arcgis-line-of-sight";
+    readonly actions: "arcgis-line-of-sight__actions";
+    readonly container: "arcgis-line-of-sight__container";
+    readonly error: "arcgis-line-of-sight__error";
+    readonly hint: "arcgis-line-of-sight__hint";
+    readonly hintText: "arcgis-line-of-sight__hint-text";
+    readonly newAnalysisButton: "arcgis-line-of-sight__new-analysis-button";
+};

package/dist/components/arcgis-line-of-sight/customElement.d.ts

@@ -1,65 +1,93 @@
 /// <reference types="@arcgis/core/interfaces.d.ts" />
 /// <reference types="../../index.d.ts" />
 import { Use } from '@arcgis/lumina/controllers';
-import { Nil } from '@arcgis/components-utils';
-import { default as LineOfSight } from '@arcgis/core/widgets/LineOfSight.js';
-import { PublicLitElement as LitElement, TargetedEvent } from '@arcgis/lumina';
+import { default as LineOfSightAnalysis } from '@arcgis/core/analysis/LineOfSightAnalysis.js';
+import { PublicLitElement as LitElement, JsxNode, TargetedEvent } from '@arcgis/lumina';
 import { ArcgisReferenceElement } from '../../utils/component-utils';
+import { default as LineOfSightViewModel } from './LineOfSightViewModel';
 
-declare const useLineOfSightWidget: (component: LitElement & Pick<LineOfSight, never> & {
-    state?: unknown;
-    viewModel?: __esri.LineOfSightViewModel | undefined;
-    icon: Nil | string;
-    label: Nil | string;
-    referenceElement: ArcgisReferenceElement | Nil | string;
-    position: __esri.UIPosition;
-    arcgisReady: import('@arcgis/lumina').EventEmitter;
-    arcgisPropertyChange: import('@arcgis/lumina').EventEmitter<{
-        name: string;
-    }> | undefined;
-    el: HTMLElement & {
-        childElem?: HTMLElement & {
-            ownedBy?: HTMLElement;
-        };
-        view?: __esri.MapView | __esri.SceneView | Nil;
-    };
-    autoDestroyDisabled: boolean;
-    destroy: () => Promise<void>;
-}, options?: {
-    editConstructorProperties(props: __esri.LineOfSightProperties | undefined): __esri.LineOfSightProperties | Promise<__esri.LineOfSightProperties | undefined> | undefined;
-} | undefined) => LineOfSight;
-/** LineOfSight component is a 3D analysis tool that allows you to perform visibility analysis in a [SceneView](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-SceneView.html).
+declare const useViewModel: (component: LitElement & Pick<LineOfSightViewModel, never> & import('../../controllers/useViewModel').ViewModelControllerUses<LineOfSightViewModel>) => LineOfSightViewModel;
+/**
+ * The Line Of Sight component is a 3D analysis tool that allows you to perform
+ * [line of sight visibility analysis](https://developers.arcgis.com/javascript/latest/api-reference/esri-analysis-LineOfSightAnalysis.html)
+ * in a 3D view. Visibility between a given observer and multiple target points is calculated against the currently
+ * displayed content in the view, including ground, integrated meshes, and 3D objects such as buildings or trees.
+ *
+ * The results from the analysis are displayed as lines, where the visible part, indicating what the observer can see,
+ * is colored green. Visible targets are displayed with a green sphere and a fully green line of sight.
+ * The spheres marking occluded targets are displayed red, as are the occluded parts of the lines of sight.
+ * When the line of sight cannot be calculated, it will be displayed with a gray color. This may happen if either
+ * the target or the observer is not in the view.
+ *
+ * When creating a new line of sight analysis with the component, the first click in the scene creates the
+ * [observer](https://developers.arcgis.com/javascript/latest/api-reference/esri-analysis-LineOfSightAnalysisObserver.html)
+ * and any further clicks place the [targets](https://developers.arcgis.com/javascript/latest/api-reference/esri-analysis-LineOfSightAnalysisTarget.html).
+ * Both, observer and target points, can be moved by dragging them. Additionally, the target points can be removed with a right click.
+ *
+ * [Read more...](https://developers.arcgis.com/javascript/latest/references/map-components/arcgis-line-of-sight/)
  */
 export declare class ArcgisLineOfSight extends LitElement {
-    readonly analysis: __esri.LineOfSightAnalysis;
+    /**
+     * The [line of sight analysis](https://developers.arcgis.com/javascript/latest/api-reference/esri-analysis-LineOfSightAnalysis.html)
+     * object being created by the component.
+     */
+    get analysis(): LineOfSightAnalysis;
     /**
      * 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\` method when you are done to prevent
-     * memory leaks.
+     * is set, make sure to call the [destroy](https://developers.arcgis.com/javascript/latest/references/map-components/arcgis-line-of-sight/#destroy) method when you are done to
+     * prevent memory leaks.
+     *
+     * @default false
      */
     autoDestroyDisabled: boolean;
     /**
      * Icon which represents the component.
      * Typically used when the component is controlled by another component (e.g. by the Expand component).
-     * Search [Calcite Icons](https://developers.arcgis.com/calcite-design-system/icons/) for possible values.
+     *
+     * @see [Calcite Icons](https://developers.arcgis.com/calcite-design-system/icons/)
+     * @default "line-of-sight"
      */
-    icon: string;
+    icon?: HTMLCalciteIconElement["icon"];
     /** The component's default label. */
-    label: string;
+    label?: string;
+    /** Replace localized message strings with your own strings. **Warning**: individual message keys may change between releases. */
+    messageOverrides?: typeof this._messages._overrides;
+    /** @default "bottom-left" */
     position: __esri.UIPosition;
-    referenceElement: ArcgisReferenceElement | Nil | string;
-    readonly state: "ready" | "disabled" | "creating" | "created";
+    referenceElement?: ArcgisReferenceElement | string;
+    /**
+     * The component's state. The values mean the following:
+     *
+     * * `disabled` -  not ready yet
+     * * `ready` - ready for analysis
+     * * `creating` - observer/target points are being placed
+     * * `created` - finished analysis
+     */
+    get state(): "created" | "creating" | "disabled" | "ready";
+    /** Clear the current analysis results. After calling this method, the user can set a new observer and targets. */
     clear(): Promise<void>;
+    /**
+     * After [stop()](https://developers.arcgis.com/javascript/latest/references/map-components/arcgis-line-of-sight/#stop)
+     * was called, this method allows to continue the line of sight analysis and add more targets.
+     */
     continue(): Promise<void>;
-    /** Permanently destroy the component */
+    /** Permanently destroy the component. */
     destroy(): Promise<void>;
+    /** Start a new line of sight analysis. */
     start(): Promise<void>;
+    /**
+     * Stop the current line of sight analysis, keeping the results in the view.
+     * Users can still interact with existing targets and the observer but they cannot place new target points.
+     */
     stop(): Promise<void>;
+    /** Emitted when the value of a property is changed. Use this to listen to changes to properties. */
     readonly arcgisPropertyChange: TargetedEvent<this, {
         name: "state" | "analysis";
     }>;
-    readonly arcgisReady: TargetedEvent<this, undefined>;
+    /** Emitted when the component associated with a map or scene view is is ready to be interacted with. */
+    readonly arcgisReady: TargetedEvent<this, void>;
+    private _messages;
 }
 export {};

package/dist/components/arcgis-line-of-sight/customElement.js

@@ -1,46 +1,116 @@
-import { c as t } from "../../chunks/runtime.js";
-import { usePropertyChange as s } from "@arcgis/lumina/controllers";
-import i from "@arcgis/core/widgets/LineOfSight.js";
-import { LitElement as e, createEvent as o, noShadowRoot as a } from "@arcgis/lumina";
-import { m as r } from "../../chunks/useWidget.js";
-import { css as n } from "@lit/reactive-element/css-tag.js";
+import { c as f } from "../../chunks/runtime.js";
+import { html as l } from "lit-html";
+import { usePropertyChange as y } from "@arcgis/lumina/controllers";
+import { LitElement as m, createEvent as v, noShadowRoot as _, safeClassMap as n } from "@arcgis/lumina";
+import { css as w } from "@lit/reactive-element/css-tag.js";
+import { g } from "../../chunks/globalCss.js";
+import { u as $ } from "../../chunks/useT9n.js";
+import { m as b } from "../../chunks/useViewModel.js";
+import { A as M } from "../../chunks/AnalysisViewModel.js";
+import x from "@arcgis/core/analysis/LineOfSightAnalysis.js";
+import { property as O, subclass as A } from "@arcgis/core/core/accessorSupport/decorators.js";
 /*! All material copyright Esri, All Rights Reserved, unless otherwise specified.
-See https://js.arcgis.com/4.33/esri/copyright.txt for details.
-v4.33.0-next.99 */
-const l = n`@layer{arcgis-line-of-sight{display:block}}`, h = r(i);
-class c extends e {
+See https://js.arcgis.com/4.34/esri/copyright.txt for details.
+v4.34.0-next.1 */
+const C = w`@layer{arcgis-line-of-sight{display:block}.arcgis-line-of-sight__container{display:flex;position:relative;flex-flow:column;gap:var(--calcite-spacing-md);padding:var(--esri-widget-padding);overflow-y:auto}.arcgis-line-of-sight__error{color:var(--calcite-color-status-danger)}.arcgis-line-of-sight__hint{display:flex;flex-direction:column;gap:var(--calcite-spacing-md)}.arcgis-line-of-sight__error,.arcgis-line-of-sight__hint{overflow:hidden;animation:arcgis-line-of-sight-fade-in .25s ease-in-out;p{margin:0;padding:0}}.arcgis-line-of-sight__actions{display:flex;flex-flow:column;gap:var(--calcite-spacing-xxs);justify-content:center}@keyframes arcgis-line-of-sight-fade-in{0%{opacity:0}25%{opacity:0}to{opacity:1}}}`, a = "arcgis-line-of-sight", r = {
+  base: a,
+  actions: `${a}__actions`,
+  container: `${a}__container`,
+  error: `${a}__error`,
+  hint: `${a}__hint`,
+  hintText: `${a}__hint-text`,
+  newAnalysisButton: `${a}__new-analysis-button`
+};
+var S = Object.defineProperty, D = Object.getOwnPropertyDescriptor, u = (s, e, i, o) => {
+  for (var t = o > 1 ? void 0 : o ? D(e, i) : e, d = s.length - 1, p; d >= 0; d--)
+    (p = s[d]) && (t = (o ? p(e, i, t) : p(t)) || t);
+  return o && t && S(e, i, t), t;
+};
+let c = class extends M {
+  constructor(s) {
+    super(s), this.supportedViewType = "3d", this.unsupportedErrorMessage = "The Line Of Sight component is only supported in 3D views.";
+  }
+  get state() {
+    return this.disabled || !this.ready ? "disabled" : this.operationState === "active" ? "creating" : this.analysis.valid ? "created" : "ready";
+  }
+  constructAnalysis() {
+    return new x();
+  }
+  clearAnalysis() {
+    this.analysis.observer = null, this.analysis.targets.removeAll();
+  }
+  async place(s) {
+    return await this.analysisView?.place(s);
+  }
+};
+u([
+  O({ readOnly: !0 })
+], c.prototype, "state", 1);
+c = u([
+  A("esri.components.LineOfSight.LineOfSightViewModel")
+], c);
+const L = b(c);
+class V extends m {
   constructor() {
-    super(...arguments), this.widget = h(this), this.viewModel = this.widget.viewModel, this.analysis = this.widget.analysis, this.autoDestroyDisabled = !1, this.icon = this.widget.icon, this.label = this.widget.label, this.position = "bottom-left", this.state = this.viewModel.state, this.arcgisPropertyChange = s()("analysis", "state"), this.arcgisReady = o();
+    super(...arguments), this.viewModel = L(this), this._messages = $({ blocking: !0 }), this.view = this.viewModel.view, this.autoDestroyDisabled = !1, this.icon = "line-of-sight", this.position = "bottom-left", this.arcgisPropertyChange = y()("analysis", "state"), this.arcgisReady = v();
   }
   static {
-    this.properties = { analysis: 0, autoDestroyDisabled: 5, icon: 1, label: 1, position: 1, referenceElement: 1, state: 3 };
+    this.properties = { analysis: 32, autoDestroyDisabled: 5, icon: 3, label: 1, messageOverrides: 0, position: 1, referenceElement: 1, state: 32, _supported: 16 };
   }
   static {
-    this.shadowRootOptions = a;
+    this.shadowRootOptions = _;
   }
   static {
-    this.styles = l;
+    this.styles = C;
+  }
+  get analysis() {
+    return this.viewModel.analysis;
+  }
+  get state() {
+    return this.viewModel.state;
+  }
+  get _supported() {
+    return this.view == null || this.view.type === "3d";
   }
-  //#endregion
-  //#region Public Methods
   async clear() {
-    this.widget?.viewModel.clear();
+    this.viewModel.clear();
   }
   async continue() {
-    this.widget?.viewModel.continue();
+    this.viewModel.start();
   }
-  /** Permanently destroy the component */
   async destroy() {
     await this.manager.destroy();
   }
   async start() {
-    this.widget?.viewModel.start();
+    this.viewModel.startNewAnalysis();
   }
   async stop() {
-    this.widget?.viewModel.stop();
+    this.viewModel.stop();
   }
+  render() {
+    return l`<div class=${n({
+      [r.base]: !0,
+      [g.widget]: !0,
+      [g.panel]: !0
+    })} role=presentation>${this._renderContainerNode()}</div>`;
+  }
+  _renderContainerNode() {
+    if (!this._supported)
+      return l`<div class=${n(r.error)}><p>${this._messages.unsupported}</p></div>`;
+    const e = this.viewModel.state, i = e === "creating";
+    return l`<div class=${n(r.container)}>${i ? l`<div class=${n(r.hint)}><p class=${n(r.hintText)}>${this._messages.hint}</p></div>` : null}<div class=${n(r.actions)}>${e === "creating" ? h({ onClick: () => {
+      this.stop();
+    }, children: this._messages.done }) : null}${e === "created" ? h({ onClick: () => {
+      this.continue();
+    }, children: this._messages.continueAnalysis }) : null}${h({ className: r.newAnalysisButton, onClick: () => {
+      this.start();
+    }, primary: !0, disabled: e === "disabled", children: this._messages.newAnalysis })}</div></div>`;
+  }
+}
+function h({ className: s, onClick: e, primary: i, disabled: o, children: t }) {
+  return l`<calcite-button .appearance=${i ? "solid" : "outline-fill"} class=${n(s)} .disabled=${o} @click=${e}>${t}</calcite-button>`;
 }
-t("arcgis-line-of-sight", c);
+f("arcgis-line-of-sight", V);
 export {
-  c as ArcgisLineOfSight
+  V as ArcgisLineOfSight
 };

package/dist/components/arcgis-line-of-sight/index.d.ts

@@ -1 +1,2 @@
+import "@esri/calcite-components/components/calcite-button";
 export * from "./customElement.js";

package/dist/components/arcgis-line-of-sight/index.js

@@ -1 +1,2 @@
+import "@esri/calcite-components/components/calcite-button";
 export * from "./customElement.js";