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

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

@@ -1,74 +1,126 @@
 /// <reference types="@arcgis/core/interfaces.d.ts" />
 /// <reference types="../../index.d.ts" />
-import { Use } from '@arcgis/components-controllers';
-import { Nil } from '@arcgis/components-utils';
-import { default as Slice } from '@arcgis/core/widgets/Slice.js';
-import { PublicLitElement as LitElement, TargetedEvent } from '@arcgis/lumina';
+import { Use } from '@arcgis/lumina/controllers';
+import { PublicLitElement as LitElement, JsxNode, TargetedEvent } from '@arcgis/lumina';
 import { ArcgisReferenceElement } from '../../utils/component-utils';
+import { default as SliceViewModel, SliceableLayer } from './SliceViewModel';
+import { HeadingLevel } from '../../support/heading';
 
-declare const useSliceWidget: (component: import('@arcgis/components-controllers').StencilLifecycles & {
-    manager: import('@arcgis/components-controllers').ControllerManager;
-    el: HTMLElement;
-    autoDestroyDisabled?: boolean;
-    destroy?: () => Promise<void>;
-} & Pick<Slice, never> & {
-    reactiveUtils?: typeof __esri.reactiveUtils;
-    state?: unknown;
-    viewModel?: __esri.SliceViewModel | undefined;
-    icon: Nil | string;
-    label: Nil | string;
-    referenceElement: ArcgisReferenceElement | Nil | string;
-    position: __esri.UIPosition;
-    arcgisReady: import('@arcgis/components-controllers').EventEmitter;
-    arcgisPropertyChange: import('@arcgis/components-controllers').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.SliceProperties | undefined): __esri.SliceProperties | Promise<__esri.SliceProperties | undefined> | undefined;
-} | undefined) => Slice;
-/** Slice component is a 3D analysis tool that can be used to reveal occluded content in a [SceneView](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-SceneView.html).
+declare const useSliceViewModel: (component: LitElement & Pick<SliceViewModel, never> & import('../../controllers/useViewModel').ViewModelControllerUses<SliceViewModel>) => SliceViewModel;
+/**
+ * The Slice component is a 3D analysis tool that can be used to reveal occluded content in a 3D view. It applies
+ * [slice analysis](https://developers.arcgis.com/javascript/latest/api-reference/esri-analysis-SliceAnalysis.html)
+ * to any layer type, making it possible to see inside buildings or to explore geological surfaces.
+ *
+ * The slicing [shape](https://developers.arcgis.com/javascript/latest/references/map-components/arcgis-slice/#shape)
+ * is always a [plane](https://developers.arcgis.com/javascript/latest/api-reference/esri-analysis-SlicePlane.html).
+ * By default, the plane is either horizontal or vertical. To allow a tilt angle for the plane, set
+ * [tiltEnabled](https://developers.arcgis.com/javascript/latest/references/map-components/arcgis-slice/#tiltEnabled)
+ * to `true`. The slice hides any content in front of the surface. The handles on the sides of the plane can be used to adjust
+ * the size, heading, tilt, and position of the slice plane.
+ * The [SlicePlane](https://developers.arcgis.com/javascript/latest/api-reference/esri-analysis-SlicePlane.html)
+ * can be set or retrieved using the [shape](https://developers.arcgis.com/javascript/latest/references/map-components/arcgis-slice/#shape) property.
+ *
+ * Once the slice plane is applied, layers can be excluded from the slicing. For example, by excluding the sublayers which include
+ * columns and floor slabs, the inner structure of a building can investigated.
+ *
+ * [Read more...](https://developers.arcgis.com/javascript/latest/references/map-components/arcgis-slice/)
  */
 export declare class ArcgisSlice extends LitElement {
-    readonly analysis: __esri.SliceAnalysis;
+    /**
+     * The [slice analysis](https://developers.arcgis.com/javascript/latest/api-reference/esri-analysis-SliceAnalysis.html)
+     * object being created by the component.
+     */
+    analysis: __esri.SliceAnalysis;
     /**
      * 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-slice/#destroy) method when you are done to
+     * prevent memory leaks.
+     *
+     * @default false
      */
     autoDestroyDisabled: boolean;
+    /**
+     * Indicates whether the [Ground](https://developers.arcgis.com/javascript/latest/api-reference/esri-Ground.html) and layers that
+     * are draped on the ground surface are excluded from the slice.
+     *
+     * @default false
+     */
     excludeGroundSurface: boolean;
-    excludedLayers: __esri.Collection<__esri.Layer | __esri.BuildingComponentSublayer>;
-    headingLevel: number;
+    /**
+     * Add layers to this collection to exclude them from the slice. Layers that
+     * are draped on the ground surface are not affected by this property
+     */
+    excludedLayers: __esri.Collection<SliceableLayer>;
+    /** @default 3 */
+    headingLevel: HeadingLevel;
     /**
      * 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 "slice"
      */
-    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;
+    referenceElement?: ArcgisReferenceElement | string;
+    /**
+     * The shape used to slice elements in a 3D scene. Currently the only supported shape is a plane.
+     * Example:
+     * ```
+     * // Clone the shape to modify its properties
+     * const shape = slice.shape.clone();
+     * // Set new values for heading and tilt
+     * shape.heading = 180;
+     * shape.tilt = 45;
+     * // Apply the new shape to the slice component's shape
+     * slice.shape = shape;
+     * ```
+     */
     shape: nullish | __esri.SlicePlane;
-    readonly state: "ready" | "disabled" | "slicing" | "sliced";
+    /**
+     * The component's state. The values mean the following:
+     *
+     * * `disabled` -  not ready yet
+     * * `ready` - ready for slicing
+     * * `slicing` - currently slicing
+     * * `sliced` - finished slicing
+     */
+    state: "ready" | "disabled" | "excludingLayer" | "sliced" | "slicing";
+    /**
+     * Enable tilting the slice shape. If set to true, the slice shape will orient itself as best as
+     * possible to the surface under the cursor when first placing the shape. If set to false, the slice shape is
+     * restricted to be either horizontal or vertical.
+     *
+     * @default false
+     */
     tiltEnabled: boolean;
+    /**
+     * Clear the [shape](https://developers.arcgis.com/javascript/latest/references/map-components/arcgis-slice/#shape) of the slice,
+     * effectively removing it from the view. Other properties like [excludedLayers](https://developers.arcgis.com/javascript/latest/references/map-components/arcgis-slice/#excludedLayers)
+     * and [excludeGroundSurface](https://developers.arcgis.com/javascript/latest/references/map-components/arcgis-slice/#excludeGroundSurface) are not modified.
+     */
     clear(): Promise<void>;
-    /** Permanently destroy the component */
+    /** Permanently destroy the component. */
     destroy(): Promise<void>;
+    /**
+     * Start the interactive creation of a new slice, clearing the previous
+     * [shape](https://developers.arcgis.com/javascript/latest/references/map-components/arcgis-slice/#shape).
+     */
     start(): 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-slice/customElement.js

@@ -1,40 +1,195 @@
-import { c as e } from "../../chunks/runtime.js";
-import { usePropertyChange as t } from "@arcgis/components-controllers";
-import s from "@arcgis/core/widgets/Slice.js";
-import { LitElement as i, createEvent as a, noShadowRoot as o } from "@arcgis/lumina";
-import { m as l } from "../../chunks/useWidget.js";
-import { css as r } from "@lit/reactive-element/css-tag.js";
+import { c as w } from "../../chunks/runtime.js";
+import { html as r } from "lit-html";
+import { usePropertyChange as $ } from "@arcgis/lumina/controllers";
+import { LitElement as L, createEvent as b, noShadowRoot as M, safeClassMap as a, nothing as S } from "@arcgis/lumina";
+import { css as E } from "@lit/reactive-element/css-tag.js";
+import { m as C } from "../../chunks/useViewModel.js";
+import { A as k } from "../../chunks/AnalysisViewModel.js";
+import V from "@arcgis/core/analysis/SliceAnalysis.js";
+import { property as d, subclass as G } from "@arcgis/core/core/accessorSupport/decorators.js";
+import { u as A } from "../../chunks/useT9n.js";
+import { ignoreAbortErrors as T } from "@arcgis/core/core/promiseUtils.js";
+import { H as D } from "../../chunks/heading.js";
+import { g as m } from "../../chunks/globalCss.js";
+import { watch as H } from "@arcgis/core/core/reactiveUtils.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.14 */
-const d = r`@layer{arcgis-slice{display:block}}`, h = l(s);
-class c extends i {
+v4.33.0-next.140 */
+const O = E`@layer{arcgis-slice{display:block}.arcgis-slice__container{display:flex;padding:var(--esri-widget-padding-y) var(--esri-widget-padding-x);overflow-y:auto;--layer-item-background: var(--calcite-color-foreground-2)}.arcgis-slice__error{color:var(--calcite-color-status-danger)}.arcgis-slice__container,.arcgis-slice__hint{display:flex;flex-direction:column;gap:var(--calcite-spacing-md)}.arcgis-slice__error,.arcgis-slice__hint{overflow:hidden;animation:arcgis-slice-fade-in .25s ease-in-out}.arcgis-slice__error p,.arcgis-slice__hint p{margin:0;padding:0}.arcgis-slice__hint:not(:has(*)){display:none}.arcgis-slice__layer-item{--calcite-color-foreground-2: var(--layer-item-background);--calcite-color-foreground-1: var(--layer-item-background)}.arcgis-slice__actions{display:flex;flex-flow:column;gap:var(--calcite-spacing-xxs);justify-content:center}.arcgis-slice__actions:not(:has(*)){display:none}@keyframes arcgis-slice-fade-in{0%{opacity:0}25%{opacity:0}to{opacity:1}}}`;
+var B = Object.defineProperty, P = Object.getOwnPropertyDescriptor, o = (e, i, t, u) => {
+  for (var c = u > 1 ? void 0 : u ? P(i, t) : i, y = e.length - 1, h; y >= 0; y--)
+    (h = e[y]) && (c = (u ? h(i, t, c) : h(c)) || c);
+  return u && c && B(i, t, c), c;
+};
+const g = /* @__PURE__ */ new Set();
+let n = class extends k {
+  constructor(e) {
+    super(e), this.supportedViewType = "3d", this.unsupportedErrorMessage = "SliceViewModel is only supported in 3D views.", g.add(this);
+  }
+  async pickLayerToExclude() {
+    const e = this.analysisView;
+    if (e) {
+      const i = super.start((t) => e.pickLayerToExclude(t));
+      this._excludingLayers = i, i.finally(() => {
+        this._excludingLayers === i && (this._excludingLayers = void 0);
+      }), await i.catch();
+    }
+  }
+  async place(e) {
+    await this.analysisView?.place(e);
+  }
+  clearAnalysis() {
+    this.analysis.shape = null;
+  }
+  destroy() {
+    g.delete(this);
+  }
+  get state() {
+    return this.disabled || !this.ready ? "disabled" : this.operationState === "active" ? "slicing" : this.layersMode === "exclude" ? "excludingLayer" : this.analysis.valid ? "sliced" : "ready";
+  }
+  get shape() {
+    return this.analysis.shape;
+  }
+  set shape(e) {
+    this.analysis.shape = e;
+  }
+  get tiltEnabled() {
+    return this.analysis.tiltEnabled;
+  }
+  set tiltEnabled(e) {
+    this.analysis.tiltEnabled = e;
+  }
+  get layersMode() {
+    return this._excludingLayers ? "exclude" : "none";
+  }
+  get excludedLayers() {
+    return this.analysis.excludedLayers;
+  }
+  set excludedLayers(e) {
+    this.analysis.excludedLayers = e;
+  }
+  get excludeGroundSurface() {
+    return this.analysis.excludeGroundSurface;
+  }
+  set excludeGroundSurface(e) {
+    this.analysis.excludeGroundSurface = e;
+  }
+  async start() {
+    g.forEach((e) => {
+      e.view === this.view && e !== this && e.clear();
+    }), this.clear(), await super.start();
+  }
+  onConnectToAnalysisView(e) {
+    e.active = !0;
+  }
+  constructAnalysis() {
+    return new V();
+  }
+};
+o([
+  d()
+], n.prototype, "_excludingLayers", 2);
+o([
+  d({ readOnly: !0 })
+], n.prototype, "state", 1);
+o([
+  d()
+], n.prototype, "shape", 1);
+o([
+  d()
+], n.prototype, "tiltEnabled", 1);
+o([
+  d()
+], n.prototype, "layersMode", 1);
+o([
+  d()
+], n.prototype, "excludedLayers", 1);
+o([
+  d()
+], n.prototype, "excludeGroundSurface", 1);
+n = o([
+  G("esri.components.Slice.SliceViewModel")
+], n);
+const l = "arcgis-slice", s = {
+  base: l,
+  actions: `${l}__actions`,
+  cancelButton: `${l}__cancel-button`,
+  container: `${l}__container`,
+  error: `${l}__error`,
+  excludeButton: `${l}__exclude-button`,
+  hint: `${l}__hint`,
+  hintText: `${l}__hint-text`,
+  layerItem: `${l}__layer-item`,
+  layerList: `${l}__layer-list`,
+  layerListHeading: `${l}__layer-list-title`,
+  newSliceButton: `${l}__clear-button`
+}, I = C(n);
+class N extends L {
   constructor() {
-    super(...arguments), this.widget = h(this), this.viewModel = this.widget.viewModel, this.analysis = this.widget.analysis, this.autoDestroyDisabled = !1, this.excludeGroundSurface = this.viewModel.excludeGroundSurface, this.excludedLayers = this.viewModel.excludedLayers, this.headingLevel = this.widget.headingLevel, this.icon = this.widget.icon, this.label = this.widget.label, this.position = "bottom-left", this.shape = this.viewModel.shape, this.state = this.viewModel.state, this.tiltEnabled = this.viewModel.tiltEnabled, this.arcgisPropertyChange = t()("analysis", "state"), this.arcgisReady = a();
+    super(...arguments), this.viewModel = I(this), this._messages = A(), this._onNewSliceClick = () => {
+      T(this.viewModel.start());
+    }, this.analysis = this.viewModel.analysis, this.autoDestroyDisabled = !1, this.excludeGroundSurface = this.viewModel.excludeGroundSurface, this.excludedLayers = this.viewModel.excludedLayers, this.headingLevel = 3, this.icon = "slice", this.position = "bottom-left", this.shape = this.viewModel.shape, this.state = this.viewModel.state, this.tiltEnabled = this.viewModel.tiltEnabled, this.arcgisPropertyChange = $()("analysis", "state"), this.arcgisReady = b();
   }
   static {
-    this.properties = { analysis: 0, autoDestroyDisabled: 5, excludeGroundSurface: 5, excludedLayers: 0, headingLevel: 9, icon: 1, label: 1, position: 1, referenceElement: 1, shape: 0, state: 3, tiltEnabled: 5 };
+    this.properties = { _hasVoxelLayers: 16, analysis: 0, autoDestroyDisabled: 5, excludeGroundSurface: 5, excludedLayers: 0, headingLevel: 9, icon: 3, label: 1, messageOverrides: 0, position: 1, referenceElement: 1, shape: 0, state: 3, tiltEnabled: 5 };
   }
   static {
-    this.shadowRootOptions = o;
+    this.shadowRootOptions = M;
   }
   static {
-    this.styles = d;
+    this.styles = O;
+  }
+  get _hasVoxelLayers() {
+    const i = this.viewModel?.view;
+    return i != null ? i.allLayerViews.some((t) => (
+      //@ts-expect-error type is missing on the base layerview interface
+      t.type === "voxel-3d"
+    )) : !1;
   }
-  // #endregion
-  // #region Public Methods
   async clear() {
-    this.widget?.viewModel.clear();
+    this.viewModel.clear();
   }
-  /** Permanently destroy the component */
   async destroy() {
     await this.manager.destroy();
   }
   async start() {
-    this.widget?.viewModel.start();
+    this.viewModel.start();
+  }
+  load() {
+    this.manager.onLifecycle(() => [
+      H(() => this._renderContainerNode(), () => this.requestUpdate())
+    ]);
+  }
+  render() {
+    return r`<div class=${a({
+      [s.base]: !0,
+      [m.widget]: !0,
+      [m.panel]: !0
+    })} role=presentation>${this._renderContainerNode()}</div>`;
   }
+  _renderContainerNode() {
+    const i = this._messages, { state: t, visible: u, supported: c } = this.viewModel, y = t === "slicing" || t === "excludingLayer";
+    if (!u || !c)
+      return null;
+    c || r`<div class=${a(s.container)}><div class=${a(s.error)}><p>${this._messages.unsupported}</p></div></div>`;
+    const { excludedLayers: h } = this.viewModel, f = this.excludeGroundSurface, _ = h.length > 0 || f, p = t === "disabled";
+    return r`<div class=${a(s.container)}><div class=${a(s.hint)}>${t === "excludingLayer" ? r`<p class=${a(s.hintText)}>${i.excludeHint}</p>` : null}${t === "slicing" ? r`<p class=${a(s.hintText)}>${this._hasVoxelLayers ? i.voxelHint : i.hint}</p><p class=${a(s.hintText)}>${i.verticalHint}</p>` : null}</div>${!y && _ ? r`<div class=${a(s.layerList)}>${D({ class: s.layerListHeading, level: this.headingLevel, children: i.excludedLayers })}${j({ layers: h.toArray(), excludeGroundSurface: f, onLayerClick: (v) => {
+      this.excludedLayers.remove(v);
+    }, onGroundClick: () => {
+      this.excludeGroundSurface = !1;
+    }, listLabel: i.excludedLayers, layerActionLabel: i.includeLayer, groundItemTitle: i.ground })}</div>` : null}<div class=${a(s.actions)}>${y ? null : r`<calcite-button class=${a(s.newSliceButton)} .disabled=${p} @click=${this._onNewSliceClick}>${i.newSlice}</calcite-button>`}${t === "sliced" ? r`<calcite-button appearance=outline-fill class=${a(s.excludeButton)} .disabled=${p} @click=${() => this.viewModel.pickLayerToExclude()}>${i.excludeLayer}</calcite-button>` : null}${t === "excludingLayer" ? r`<calcite-button appearance=outline-fill class=${a(s.cancelButton)} .disabled=${p} @click=${() => {
+      this.viewModel.layersMode === "exclude" && this.viewModel.stop();
+    }}>${i.cancel}</calcite-button>` : null}</div></div>`;
+  }
+}
+function x(e) {
+  return r`<calcite-list-item class=${a(s.layerItem)} data-testid=${`list-item-${e.uid}`} .label=${e.title ?? ""}><calcite-action icon=x @click=${e.onClick} scale=s slot=actions-end .text=${e.actionLabel} title=${e.actionLabel ?? S}></calcite-action></calcite-list-item>`;
+}
+function j(e) {
+  const i = e.layers.map((t) => x({ uid: t.uid, title: t.title ?? "", onClick: () => e.onLayerClick(t), actionLabel: e.layerActionLabel }));
+  return e.excludeGroundSurface && i.push(x({ uid: "ground", title: e.groundItemTitle, onClick: e.onGroundClick, actionLabel: e.layerActionLabel })), r`<calcite-list .label=${e.listLabel} selection-mode=none>${i}</calcite-list>`;
 }
-e("arcgis-slice", c);
+w("arcgis-slice", N);
 export {
-  c as ArcgisSlice
+  N as ArcgisSlice
 };

package/dist/components/arcgis-slice/index.d.ts

@@ -1 +1,5 @@
+import "@esri/calcite-components/components/calcite-button";
+import "@esri/calcite-components/components/calcite-list-item";
+import "@esri/calcite-components/components/calcite-action";
+import "@esri/calcite-components/components/calcite-list";
 export * from "./customElement.js";

package/dist/components/arcgis-slice/index.js

@@ -1 +1,5 @@
+import "@esri/calcite-components/components/calcite-button";
+import "@esri/calcite-components/components/calcite-list-item";
+import "@esri/calcite-components/components/calcite-action";
+import "@esri/calcite-components/components/calcite-list";
 export * from "./customElement.js";