@arcgis/map-components 4.33.0-next.117 → 4.33.0-next.119

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

@@ -1,43 +1,365 @@
-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 A } from "../../chunks/runtime.js";
+import { html as y } from "lit-html";
+import { usePropertyChange as $ } from "@arcgis/lumina/controllers";
+import { LitElement as C, createEvent as M, noShadowRoot as T, safeClassMap as d } from "@arcgis/lumina";
+import { css as U } from "@lit/reactive-element/css-tag.js";
+import { g as v } from "../../chunks/globalCss.js";
+import { u as x } from "../../chunks/useT9n.js";
+import { watch as w, whenOnce as S } from "@arcgis/core/core/reactiveUtils.js";
+import { m as F } from "../../chunks/useViewModel.js";
+import { c as g, a as R, t as I, i as k } from "../../chunks/async-utils.js";
+import { property as r, subclass as b } from "@arcgis/core/core/accessorSupport/decorators.js";
+import E from "@arcgis/core/core/Accessor.js";
+import { a as u, r as m } from "../../chunks/maybe.js";
+import { forceInteractive as D } from "@arcgis/core/applications/Components/analysisUtils.js";
+import H from "@arcgis/core/analysis/LineOfSightAnalysis.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.117 */
-const l = n`@layer{arcgis-line-of-sight{display:block}}`, h = r(i);
-class c extends e {
+v4.33.0-next.119 */
+const P = U`@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}}}`, h = "arcgis-line-of-sight", p = {
+  base: h,
+  actions: `${h}__actions`,
+  container: `${h}__container`,
+  error: `${h}__error`,
+  hint: `${h}__hint`,
+  hintText: `${h}__hint-text`,
+  newAnalysisButton: `${h}__new-analysis-button`
+};
+var N = Object.defineProperty, L = Object.getOwnPropertyDescriptor, o = (e, t, s, a) => {
+  for (var i = a > 1 ? void 0 : a ? L(t, s) : t, l = e.length - 1, c; l >= 0; l--)
+    (c = e[l]) && (i = (a ? c(t, s, i) : c(i)) || i);
+  return a && i && N(t, s, i), i;
+};
+let n = class extends E {
+  constructor(e = {}) {
+    super(e), this._loggedUnsupportedErrorMessage = !1, this.view = null, this._analysisView = null, this._reconnectViewTask = null, this._forceInteractiveHandle = null, this._operationState = "inactive", this._unsupportedErrorMessage = !1, this._parentChangeFromReconnect = !1, this._startUserOperation = null;
+    const t = e?.analysis;
+    t != null ? this.analysis = t : (this._set("analysis", this.constructAnalysis()), this._set("isAnalysisOwner", !0)), e?.visible != null && (this.visible = e.visible);
+  }
+  // @ts-expect-error TODO - ignore
+  normalizeCtorArgs(e) {
+    const { analysis: t, ...s } = e;
+    return s;
+  }
+  initialize() {
+    this.addHandles([
+      w(
+        () => ({ readyAndNotSupported: this.view != null && this.view.ready && !this.supported }),
+        ({ readyAndNotSupported: e }) => {
+          e && !this._loggedUnsupportedErrorMessage && console.error(this._unsupportedErrorMessage);
+        },
+        { sync: !0, initial: !0 }
+      ),
+      w(
+        () => (
+          // @ts-expect-error TODO - expose parent
+          this.analysis?.parent
+        ),
+        (e) => {
+          !this._parentChangeFromReconnect && e !== this.view && this._set("isAnalysisOwner", !1);
+          const t = !this._parentChangeFromReconnect;
+          this._parentChangeFromReconnect = !1, t && this._scheduleViewReconnect();
+        },
+        { sync: !0 }
+      ),
+      w(
+        () => ({
+          view: this.view,
+          ready: !!this.view?.ready,
+          supported: this.supported
+        }),
+        ({ view: e }, t) => {
+          const s = t?.view;
+          e !== s && (this._startUserOperation = u(this._startUserOperation), this._disconnectFromView(s)), this._scheduleViewReconnect();
+        },
+        { sync: !0, initial: !0 }
+      )
+    ]);
+  }
+  destroy() {
+    this._reconnectViewTask = u(this._reconnectViewTask), this._startUserOperation = u(this._startUserOperation), this._analysisView != null && (this._analysisView.visible = void 0), this._disconnectFromView(this.view), this._set("view", null), this.analysis != null && this.isAnalysisOwner && (this.analysis.destroy(), this._set("analysis", null));
+  }
+  get supported() {
+    return this.view == null || this.view.type === this.supportedViewType;
+  }
+  set visible(e) {
+    this._set("visible", e), this._analysisView != null && (this._analysisView.visible = e);
+  }
+  get active() {
+    return this._startUserOperation?.state === 2;
+  }
+  get disabled() {
+    return this.view == null || !this.view.ready || !this.supported;
+  }
+  set analysis(e) {
+    e !== this._get("analysis") && (this._startUserOperation = u(this._startUserOperation), this._disconnectFromView(this.view), this._setExternalAnalysis(e), this._scheduleViewReconnect());
+  }
+  get analysisView() {
+    return this._analysisView;
+  }
+  get ready() {
+    return this._analysisView != null && !this.connectingToView;
+  }
+  get connectingToView() {
+    return this._reconnectViewTask != null;
+  }
+  get isAnalysisOwner() {
+    return this._get("isAnalysisOwner");
+  }
+  get operationState() {
+    return this._operationState;
+  }
+  /**
+   * Removes the tool and clears the analysis by resetting its inputs.
+   */
+  clear() {
+    this.clearAnalysis(), this._startUserOperation = u(this._startUserOperation), this._resetInteractiveCreationState();
+  }
+  /**
+   * If analysis has unset inputs, start() will kick off the user operation to specify those inputs.
+   */
+  async start() {
+    if (!this.visible) {
+      console.warn("Cannot start analysis when not visible");
+      return;
+    }
+    const e = {
+      task: null,
+      abort: null,
+      state: 0
+      /* PENDING */
+    }, t = g(async (s) => {
+      if (e.state = 1, await S(() => this.ready, s), e.state = 2, !(this._analysisView == null || this.view == null))
+        return this._operationState = "active", void await this.place({ signal: s });
+    });
+    return t.promise.finally(() => {
+      this._operationState = "inactive";
+    }), e.task = t, e.abort = () => t.abort(), this._startUserOperation = e, void await t.promise;
+  }
+  startNewAnalysis() {
+    return this.clear(), this.start();
+  }
+  continue() {
+    return this.start();
+  }
+  stop() {
+    this._startUserOperation?.abort();
+  }
+  /**
+   * A callback used by view models that manage an analysis belonging to an Layer.
+   *
+   * The function will be called each time the view becomes ready, the internal Layer of
+   * the view model has been added to the map and the analysis view of the analysis has been created.
+   */
+  onConnectToAnalysisView(e) {
+  }
+  /**
+   * A callback used by view models that manage an analysis.
+   *
+   * The function will be called each time the view becomes unready and the internal analysis
+   * has been removed the map or analyses.
+   */
+  onDisconnectFromAnalysisView() {
+  }
+  _scheduleViewReconnect() {
+    this._reconnectViewTask = u(this._reconnectViewTask);
+    const e = g(async (t) => {
+      try {
+        await this._reconnectView(t);
+      } catch (s) {
+        if (I(t), !k(s)) {
+          console.warn("Failed to use analysis in view model", s);
+          return;
+        }
+        throw s;
+      } finally {
+        e === this._reconnectViewTask && (this._reconnectViewTask = null);
+      }
+    });
+    this._reconnectViewTask = e;
+  }
+  async _reconnectView(e) {
+    const { view: t } = this, s = t != null && t.ready && this.supported, a = this.analysis;
+    if (this._startUserOperation = V(this._startUserOperation), this._disconnectFromView(t), !s || t == null || a == null)
+      return;
+    if (this.isAnalysisOwner) {
+      if (a.parent != null) {
+        console.error("expected owned analysis to have null parent when connecting to view");
+        return;
+      }
+      this._parentChangeFromReconnect = !0, t.analyses.add(a);
+    }
+    const i = await t.whenAnalysisView(a);
+    if (this._analysisView = i, R(e)) {
+      this._startUserOperation = V(this._startUserOperation);
+      return;
+    }
+    i.visible = this.visible, this._forceInteractiveHandle = D(i), this.addHandles(this._forceInteractiveHandle), this.onConnectToAnalysisView(i);
+  }
+  _disconnectFromView(e) {
+    e != null && this.isAnalysisOwner && e.analyses.includes(this.analysis) && (this._parentChangeFromReconnect = !0, this.analysis.clear(), e.analyses.remove(this.analysis)), this.onDisconnectFromAnalysisView(), this._forceInteractiveHandle = m(this._forceInteractiveHandle), this._analysisView = null;
+  }
+  _setExternalAnalysis(e) {
+    this._analysisView != null && !this.isAnalysisOwner && (this._analysisView.visible = void 0, this._forceInteractiveHandle = m(this._forceInteractiveHandle)), this._analysisView = null, this._set("isAnalysisOwner", !1), this._set("analysis", e), this._parentChangeFromReconnect = !1;
+  }
+  /**
+   * Reset the analysis and tool to a state that will allow the interactive creation of a fresh analysis.
+   * The 'start()' method uses 'tool.created' to determine when the tool can be deactivated, so we must
+   * also reset that property here.
+   *
+   * In the future this should happen in the creation methods on analysis views:
+   *   https://devtopia.esri.com/WebGIS/arcgis-js-api/issues/43397
+   */
+  _resetInteractiveCreationState() {
+    this._analysisView?.tool?.resetCreated();
+  }
+};
+o([
+  r()
+], n.prototype, "supported", 1);
+o([
+  r()
+], n.prototype, "view", 2);
+o([
+  r({ type: Boolean, value: !0 })
+], n.prototype, "visible", 1);
+o([
+  r()
+], n.prototype, "active", 1);
+o([
+  r()
+], n.prototype, "disabled", 1);
+o([
+  r({ nonNullable: !0 })
+], n.prototype, "analysis", 1);
+o([
+  r()
+], n.prototype, "_analysisView", 2);
+o([
+  r()
+], n.prototype, "analysisView", 1);
+o([
+  r()
+], n.prototype, "ready", 1);
+o([
+  r()
+], n.prototype, "connectingToView", 1);
+o([
+  r({ readOnly: !0 })
+], n.prototype, "isAnalysisOwner", 1);
+o([
+  r()
+], n.prototype, "_reconnectViewTask", 2);
+o([
+  r()
+], n.prototype, "_forceInteractiveHandle", 2);
+o([
+  r()
+], n.prototype, "_operationState", 2);
+o([
+  r()
+], n.prototype, "operationState", 1);
+n = o([
+  b("esri.widgets.support.AnalysisViewModel")
+], n);
+function V(e) {
+  return e != null && e.state >= 2 ? (e.abort(), null) : e;
+}
+var j = Object.defineProperty, B = Object.getOwnPropertyDescriptor, O = (e, t, s, a) => {
+  for (var i = a > 1 ? void 0 : a ? B(t, s) : t, l = e.length - 1, c; l >= 0; l--)
+    (c = e[l]) && (i = (a ? c(t, s, i) : c(i)) || i);
+  return a && i && j(t, s, i), i;
+};
+let _ = class extends n {
+  constructor(e) {
+    super(e), this.supportedViewType = "3d", this.unsupportedErrorMessage = "LineOfSightViewModel 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 H();
+  }
+  clearAnalysis() {
+    this.analysis.observer = null, this.analysis.targets.removeAll();
+  }
+  async place(e) {
+    return await this.analysisView?.place(e);
+  }
+};
+O([
+  r({ readOnly: !0 })
+], _.prototype, "state", 1);
+_ = O([
+  b("esri.widgets.LineOfSight.LineOfSightViewModel")
+], _);
+const z = F(_);
+class q extends C {
   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 = z(this), this._messages = x(), this.view = this.viewModel.view, this.autoDestroyDisabled = !1, this.icon = "line-of-sight", this.position = "bottom-left", this.arcgisPropertyChange = $()("analysis", "state"), this.arcgisReady = M();
   }
   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, position: 1, referenceElement: 1, state: 32, supported: 32 };
   }
   static {
-    this.shadowRootOptions = a;
+    this.shadowRootOptions = T;
   }
   static {
-    this.styles = l;
+    this.styles = P;
+  }
+  get analysis() {
+    return this.viewModel.analysis;
+  }
+  get state() {
+    return this.viewModel.state;
+  }
+  get supported() {
+    return this.view == null || this.view.type === "3d";
   }
   async clear() {
-    this.widget?.viewModel.clear();
+    this.viewModel.clear();
   }
   async continue() {
-    this.widget?.viewModel.continue();
+    this.viewModel.start();
   }
   async destroy() {
     await this.manager.destroy();
   }
   async start() {
-    this.widget?.viewModel.start();
+    this.viewModel.startNewAnalysis();
   }
   async stop() {
-    this.widget?.viewModel.stop();
+    this.viewModel.stop();
+  }
+  load() {
+    this.manager.onLifecycle(() => [
+      w(() => this._renderContainerNode(), () => this.requestUpdate())
+    ]);
+  }
+  render() {
+    return y`<div class=${d({
+      [p.base]: !0,
+      [v.widget]: !0,
+      [v.panel]: !0
+    })} role=presentation>${this._renderContainerNode()}</div>`;
   }
+  _renderContainerNode() {
+    if (!this.supported)
+      return y`<div class=${d(p.error)}><p>${this._messages.unsupported}</p></div>`;
+    const t = this.viewModel.state, s = t === "creating";
+    return y`<div class=${d(p.container)}>${s ? y`<div class=${d(p.hint)}><p class=${d(p.hintText)}>${this._messages.hint}</p></div>` : null}<div class=${d(p.actions)}>${t === "creating" ? f({ onClick: () => {
+      this.stop();
+    }, children: this._messages.done }) : null}${t === "created" ? f({ onClick: () => {
+      this.continue();
+    }, children: this._messages.continueAnalysis }) : null}${f({ className: p.newAnalysisButton, onClick: () => {
+      this.start();
+    }, primary: !0, disabled: t === "disabled", children: this._messages.newAnalysis })}</div></div>`;
+  }
+}
+function f({ className: e, onClick: t, primary: s, disabled: a, children: i }) {
+  return y`<calcite-button .appearance=${s ? "solid" : "outline-fill"} class=${d(e)} .disabled=${a} @click=${t}>${i}</calcite-button>`;
 }
-t("arcgis-line-of-sight", c);
+A("arcgis-line-of-sight", q);
 export {
-  c as ArcgisLineOfSight
+  q 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";

package/dist/components/arcgis-link-chart/customElement.d.ts

@@ -277,14 +277,14 @@ export declare class ArcgisLinkChart extends LitElement {
     set zoom(newValue: number);
     /**
      * @deprecated
-     * **Deprecated** since 4.33. Use `element.map.add(layer)` instead.
+     * since 4.33. Use `element.map.add(layer)` instead.
      *
      * Adds a layer to the map layers collection.
      */
     addLayer(layer: __esri.Layer | Promise<any>, index?: number): Promise<void>;
     /**
      * @deprecated
-     * **Deprecated** since 4.33. Use `element.map.addMany([layer])` instead.
+     * since 4.33. Use `element.map.addMany([layer])` instead.
      *
      * Adds a layer or array of layers to the map layers collection.
      */

package/dist/components/arcgis-link-chart/customElement.js

@@ -8,7 +8,7 @@ import { c as r, i as g } from "../../chunks/component-utils.js";
 import { css as y } 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.117 */
+v4.33.0-next.119 */
 const u = y`@layer{arcgis-link-chart{display:block;height:100%;.esri-view{height:100%;width:100%}}}`, f = h(
   n,
   /**

package/dist/components/arcgis-link-chart-layout-switcher/customElement.js

@@ -5,13 +5,13 @@ import { g as e } from "../../chunks/globalCss.js";
 import h from "@arcgis/core/widgets/LinkChartLayoutSwitcher/LinkChartLayoutSwitcherViewModel.js";
 import { usePropertyChange as d } from "@arcgis/lumina/controllers";
 import { m } from "../../chunks/useViewModel.js";
-import { u as g } from "../../chunks/useView.js";
+import { u as g } from "../../chunks/useT9n.js";
 import { reEmitEvent as u } from "@arcgis/lumina/controllers/accessor";
 import { LitElement as p, createEvent as y, noShadowRoot as w, safeClassMap as a } from "@arcgis/lumina";
 import { css as f } 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.117 */
+v4.33.0-next.119 */
 const b = f`@layer{arcgis-link-chart-layout-switcher{display:block}}`, k = {
   basicLayoutCategory: [
     "basic-grid"