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

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

@@ -1,45 +1,41 @@
-import { c as s } from "../../chunks/runtime.js";
+import { c as l } from "../../chunks/runtime.js";
 import { usePropertyChange as o } from "@arcgis/lumina/controllers";
-import { reEmitEvent as t } from "@arcgis/lumina/controllers/accessor";
-import l from "@arcgis/core/layers/GraphicsLayer.js";
+import { reEmitEvent as i } from "@arcgis/lumina/controllers/accessor";
+import a from "@arcgis/core/layers/GraphicsLayer.js";
 import n from "@arcgis/core/widgets/Sketch.js";
-import { LitElement as a, createEvent as d, noShadowRoot as h } from "@arcgis/lumina";
-import { m as r } from "../../chunks/useWidget.js";
-import { css as g } from "@lit/reactive-element/css-tag.js";
+import { LitElement as h, createEvent as d, noShadowRoot as r } from "@arcgis/lumina";
+import { m as g } from "../../chunks/useWidget.js";
+import { css as p } from "@lit/reactive-element/css-tag.js";
+import { watch as c } 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.99 */
-const p = g`@layer{arcgis-sketch{display:block}}`, c = r(n);
-class m extends a {
-  //#endregion
-  //#region Lifecycle
+v4.33.0 */
+const m = p`@layer{arcgis-sketch{display:block}}`, y = g(n);
+class w extends h {
   constructor() {
-    super(), this.widget = c(this, { editConstructorProperties: this._editConstructorProperties }), this.viewModel = this.widget.viewModel, this.activeTool = this.widget.activeTool, this.autoDestroyDisabled = !1, this.availableCreateTools = this.widget.availableCreateTools, this.createGraphic = this.widget.createGraphic, this.creationMode = this.widget.creationMode, this.defaultCreateOptions = this.widget.defaultCreateOptions, this.defaultGraphicsLayerDisabled = !1, this.defaultUpdateOptions = this.widget.defaultUpdateOptions, this.hideCreateToolsCircle = this.widget.visibleElements.createTools.circle, this.hideCreateToolsPoint = this.widget.visibleElements.createTools.point, this.hideCreateToolsPolygon = this.widget.visibleElements.createTools.polygon, this.hideCreateToolsPolyline = this.widget.visibleElements.createTools.polyline, this.hideCreateToolsRectangle = this.widget.visibleElements.createTools.rectangle, this.hideDuplicateButton = this.widget.visibleElements.duplicateButton, this.hideDeleteButton = this.widget.visibleElements.deleteButton, this.hideSelectionCountLabel = this.widget.visibleElements.selectionCountLabel, this.hideLabelsToggle = this.widget.visibleElements.labelsToggle, this.hideSelectionToolsLassoSelection = this.widget.visibleElements.selectionTools["lasso-selection"], this.hideSelectionToolsRectangleSelection = this.widget.visibleElements.selectionTools["rectangle-selection"], this.hideSettingsMenu = this.widget.visibleElements.settingsMenu, this.hideSnappingControls = this.widget.visibleElements.snappingControls, this.hideSnappingControlsElementsEnabledToggle = this.widget.visibleElements.snappingControlsElements.enabledToggle, this.hideSnappingControlsElementsFeatureEnabledToggle = this.widget.visibleElements.snappingControlsElements.featureEnabledToggle, this.hideSnappingControlsElementsLayerList = this.widget.visibleElements.snappingControlsElements.layerList, this.hideSnappingControlsElementsSelfEnabledToggle = this.widget.visibleElements.snappingControlsElements.selfEnabledToggle, this.hideTooltipsToggle = this.widget.visibleElements.tooltipsToggle, this.hideUndoRedoMenu = this.widget.visibleElements.undoRedoMenu, this.icon = this.widget.icon, this.label = this.widget.label, this.labelOptions = this.widget.labelOptions, this.layer = this.widget.layer, this.layout = this.widget.layout, this.pointSymbol = this.viewModel.pointSymbol, this.polygonSymbol = this.viewModel.polygonSymbol, this.polylineSymbol = this.viewModel.polylineSymbol, this.position = "bottom-left", this.scale = this.widget.scale, this.toolbarKind = this.widget.toolbarKind, this.showSnappingControlsElementsHeader = this.widget.visibleElements.snappingControlsElements.header, this.snappingOptions = this.widget.snappingOptions, this.state = this.widget.state, this.tooltipOptions = this.widget.tooltipOptions, this.updateGraphics = this.widget.updateGraphics, this.arcgisCreate = t(() => this.widget, "create"), this.arcgisDelete = t(() => this.widget, "delete"), this.arcgisPropertyChange = o()("state"), this.arcgisReady = d(), this.arcgisRedo = t(() => this.widget, "redo"), this.arcgisUndo = t(() => this.widget, "undo"), this.arcgisUpdate = t(() => this.widget, "update"), this.listen("arcgisReady", this._arcgisReadyHandler);
+    super(), this.widget = y(this), this.viewModel = this.widget.viewModel, this._defaultGraphicsLayer = null, this.activeTool = this.widget.activeTool, this.autoDestroyDisabled = !1, this.availableCreateTools = this.widget.availableCreateTools, this.createGraphic = this.widget.createGraphic, this.creationMode = this.widget.creationMode, this.defaultCreateOptions = this.widget.defaultCreateOptions, this.defaultGraphicsLayerDisabled = !1, this.defaultUpdateOptions = this.widget.defaultUpdateOptions, this.hideCreateToolsCircle = this.widget.visibleElements.createTools.circle, this.hideCreateToolsPoint = this.widget.visibleElements.createTools.point, this.hideCreateToolsPolygon = this.widget.visibleElements.createTools.polygon, this.hideCreateToolsPolyline = this.widget.visibleElements.createTools.polyline, this.hideCreateToolsRectangle = this.widget.visibleElements.createTools.rectangle, this.hideDuplicateButton = this.widget.visibleElements.duplicateButton, this.hideDeleteButton = this.widget.visibleElements.deleteButton, this.hideSelectionCountLabel = this.widget.visibleElements.selectionCountLabel, this.hideLabelsToggle = this.widget.visibleElements.labelsToggle, this.hideSelectionToolsLassoSelection = this.widget.visibleElements.selectionTools["lasso-selection"], this.hideSelectionToolsRectangleSelection = this.widget.visibleElements.selectionTools["rectangle-selection"], this.hideSettingsMenu = this.widget.visibleElements.settingsMenu, this.hideSnappingControls = this.widget.visibleElements.snappingControls, this.hideSnappingControlsElementsEnabledToggle = this.widget.visibleElements.snappingControlsElements.enabledToggle, this.hideSnappingControlsElementsFeatureEnabledToggle = this.widget.visibleElements.snappingControlsElements.featureEnabledToggle, this.hideSnappingControlsElementsLayerList = this.widget.visibleElements.snappingControlsElements.layerList, this.hideSnappingControlsElementsSelfEnabledToggle = this.widget.visibleElements.snappingControlsElements.selfEnabledToggle, this.hideTooltipsToggle = this.widget.visibleElements.tooltipsToggle, this.hideUndoRedoMenu = this.widget.visibleElements.undoRedoMenu, this.icon = this.widget.icon, this.label = this.widget.label, this.labelOptions = this.widget.labelOptions, this.layer = this.widget.layer, this.layout = this.widget.layout, this.pointSymbol = this.viewModel.pointSymbol, this.polygonSymbol = this.viewModel.polygonSymbol, this.polylineSymbol = this.viewModel.polylineSymbol, this.position = "bottom-left", this.scale = this.widget.scale, this.toolbarKind = this.widget.toolbarKind, this.showSnappingControlsElementsHeader = this.widget.visibleElements.snappingControlsElements.header, this.snappingOptions = this.widget.snappingOptions, this.state = this.widget.state, this.tooltipOptions = this.widget.tooltipOptions, this.updateGraphics = this.widget.updateGraphics, this.arcgisCreate = i(() => this.widget, "create"), this.arcgisDelete = i(() => this.widget, "delete"), this.arcgisPropertyChange = o()("state"), this.arcgisReady = d(), this.arcgisRedo = i(() => this.widget, "redo"), this.arcgisUndo = i(() => this.widget, "undo"), this.arcgisUpdate = i(() => this.widget, "update"), this.listen("arcgisReady", this._arcgisReadyHandler);
   }
   static {
     this.properties = { activeTool: 3, autoDestroyDisabled: 5, availableCreateTools: 0, createGraphic: 0, creationMode: 1, defaultCreateOptions: 0, defaultGraphicsLayerDisabled: 5, defaultUpdateOptions: 0, hideCreateToolsCircle: 5, hideCreateToolsPoint: 5, hideCreateToolsPolygon: 5, hideCreateToolsPolyline: 5, hideCreateToolsRectangle: 5, hideDuplicateButton: 5, hideDeleteButton: 5, hideSelectionCountLabel: 5, hideLabelsToggle: 5, hideSelectionToolsLassoSelection: 5, hideSelectionToolsRectangleSelection: 5, hideSettingsMenu: 5, hideSnappingControls: 5, hideSnappingControlsElementsEnabledToggle: 5, hideSnappingControlsElementsFeatureEnabledToggle: 5, hideSnappingControlsElementsLayerList: 5, hideSnappingControlsElementsSelfEnabledToggle: 5, hideTooltipsToggle: 5, hideUndoRedoMenu: 5, icon: 1, label: 1, labelOptions: 0, layer: 0, layout: 1, pointSymbol: 0, polygonSymbol: 0, polylineSymbol: 0, position: 1, referenceElement: 1, scale: 1, toolbarKind: 1, showSnappingControlsElementsHeader: 5, snappingOptions: 0, state: 3, tooltipOptions: 0, updateGraphics: 0 };
   }
   static {
-    this.shadowRootOptions = h;
+    this.shadowRootOptions = r;
   }
   static {
-    this.styles = p;
+    this.styles = m;
   }
-  //#endregion
-  //#region Public Methods
   async cancel() {
     this.widget?.cancel();
   }
   async complete() {
     this.widget?.complete();
   }
-  async create(e, i) {
-    await this.widget?.create(e, i);
+  async create(t, e) {
+    await this.widget?.create(t, e);
   }
   async delete() {
     this.widget?.delete();
   }
-  /** Permanently destroy the component */
   async destroy() {
     await this.manager.destroy();
   }
@@ -49,22 +45,24 @@ class m extends a {
   async redo() {
     this.widget?.redo();
   }
-  async triggerUpdate(e, i) {
-    this.widget?.update(e, i);
+  async triggerUpdate(t, e) {
+    this.widget?.update(t, e);
   }
   async undo() {
     this.widget?.undo();
   }
-  //#endregion
-  //#region Private Methods
   _arcgisReadyHandler() {
-    this.defaultGraphicsLayerDisabled || this.el.view?.map.add(this.widget.layer);
-  }
-  async _editConstructorProperties(e) {
-    return this.defaultGraphicsLayerDisabled || (e.layer ??= new l({ title: "Sketch Layer" })), e;
+    this.defaultGraphicsLayerDisabled || (this._defaultGraphicsLayer = new a({ title: "Sketch Layer" }), this.widget.layer = this._defaultGraphicsLayer, this.el.view?.map?.add(this.widget.layer), this.manager.onLifecycle(() => c(() => this.el.view?.map, (t, e) => {
+      if (this.widget.layer !== this._defaultGraphicsLayer)
+        return;
+      const s = this._defaultGraphicsLayer;
+      e?.allLayers.includes(s) && e.allLayers.remove(s), t?.add(s);
+    })), this.manager.onDestroy(() => {
+      this._defaultGraphicsLayer && this.el.view?.map?.allLayers.includes(this._defaultGraphicsLayer) && this.el.view?.map?.remove(this._defaultGraphicsLayer), this._defaultGraphicsLayer?.destroy(), this._defaultGraphicsLayer = null;
+    }));
   }
 }
-s("arcgis-sketch", m);
+l("arcgis-sketch", w);
 export {
-  m as ArcgisSketch
+  w as ArcgisSketch
 };

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

@@ -0,0 +1,52 @@
+/// <reference types="@arcgis/core/interfaces.d.ts" />
+import { AnalysisViewModel } from '../../support/AnalysisViewModel';
+import { default as SceneView } from '@arcgis/core/views/SceneView';
+import { default as SliceAnalysis } from '@arcgis/core/analysis/SliceAnalysis.js';
+import { default as Layer } from '@arcgis/core/layers/Layer';
+import { default as Collection } from '@arcgis/core/core/Collection.js';
+import { default as SliceAnalysisView3D } from '@arcgis/core/views/3d/analysis/SliceAnalysisView3D';
+export type SliceableLayer = __esri.BuildingComponentSublayer | Layer;
+export type LayersMode = "exclude" | "none";
+declare class SliceViewModel extends AnalysisViewModel<SceneView, SliceAnalysis> {
+    private _excludingLayers?;
+    pickLayerToExclude(): Promise<void>;
+    place(options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    protected clearAnalysis(): void;
+    protected initialize(): void;
+    destroy(): void;
+    get state(): "disabled" | "excludingLayer" | "ready" | "sliced" | "slicing";
+    /**
+     * The shape used to slice elements in a 3D scene.
+     * Currently the only supported shape is a plane.
+     */
+    get shape(): __esri.SlicePlane | nullish;
+    set shape(value: __esri.SlicePlane | nullish);
+    /**
+     * 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.
+     */
+    get tiltEnabled(): boolean;
+    set tiltEnabled(enabled: boolean);
+    get layersMode(): LayersMode;
+    /**
+     * 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
+     */
+    get excludedLayers(): Collection<SliceableLayer>;
+    set excludedLayers(value: Collection<SliceableLayer> | SliceableLayer[]);
+    /**
+     * Indicates whether the {@link https://developers.arcgis.com/javascript/latest/api-reference/esri-Ground.html Ground} and layers that
+     * are draped on the ground surface are excluded from the slice.
+     */
+    get excludeGroundSurface(): boolean;
+    set excludeGroundSurface(value: boolean);
+    protected readonly supportedViewType = "3d";
+    protected readonly unsupportedErrorMessage = "SliceViewModel is only supported in 3D views.";
+    start(): Promise<void>;
+    protected onConnectToAnalysisView(analysisView: SliceAnalysisView3D): void;
+    protected constructAnalysis(): SliceAnalysis;
+}
+export default SliceViewModel;

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

@@ -0,0 +1,14 @@
+export declare const css: {
+    readonly base: "arcgis-slice";
+    readonly actions: "arcgis-slice__actions";
+    readonly cancelButton: "arcgis-slice__cancel-button";
+    readonly container: "arcgis-slice__container";
+    readonly error: "arcgis-slice__error";
+    readonly excludeButton: "arcgis-slice__exclude-button";
+    readonly hint: "arcgis-slice__hint";
+    readonly hintText: "arcgis-slice__hint-text";
+    readonly layerItem: "arcgis-slice__layer-item";
+    readonly layerList: "arcgis-slice__layer-list";
+    readonly layerListHeading: "arcgis-slice__layer-list-title";
+    readonly newSliceButton: "arcgis-slice__clear-button";
+};

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

@@ -1,68 +1,185 @@
 /// <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 Slice } from '@arcgis/core/widgets/Slice.js';
-import { PublicLitElement as LitElement, TargetedEvent } from '@arcgis/lumina';
+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: LitElement & Pick<Slice, never> & {
-    state?: unknown;
-    viewModel?: __esri.SliceViewModel | 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.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
+ * [Scene](https://developers.arcgis.com/javascript/latest/references/map-components/arcgis-scene/). 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.
+ *
+ * [![slice](https://developers.arcgis.com/javascript/latest/assets/img/apiref/widgets/slice.gif)](https://developers.arcgis.com/javascript/latest/sample-code/building-scene-layer-slice/index.html)
+ *
+ * The slicing [shape](#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](#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](#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.
+ *
+ * [![slice-exclude](https://developers.arcgis.com/javascript/latest/assets/img/apiref/widgets/slice-exclude.png)](https://developers.arcgis.com/javascript/latest/sample-code/building-scene-layer-slice/index.html)
+ *
+ * Holding the `Shift` key while creating a new slice applies it vertically.
+ *
+ * **Known limitation**
+ *
+ * Slice is only supported in a 3D [Scene](https://developers.arcgis.com/javascript/latest/references/map-components/arcgis-scene/) component.
+ *
+ * **See also**
+ *
+ * - [SliceAnalysis](https://developers.arcgis.com/javascript/latest/api-reference/esri-analysis-SliceAnalysis.html)
+ * - [Sample - BuildingSceneLayer with Slice component](https://developers.arcgis.com/javascript/latest/sample-code/building-scene-layer-slice/)
+ * - [Sample - Analysis objects](https://developers.arcgis.com/javascript/latest/sample-code/analysis-objects/)
+ *
+ * [Read more...](https://developers.arcgis.com/javascript/latest/references/map-components/arcgis-slice/)
  */
 export declare class ArcgisSlice extends LitElement {
-    readonly analysis: __esri.SliceAnalysis;
+    /**
+     * The [SliceAnalysis](https://developers.arcgis.com/javascript/latest/api-reference/esri-analysis-SliceAnalysis.html)
+     * created or modified by the component.
+     *
+     * When connecting the Slice component to the [Scene](https://developers.arcgis.com/javascript/latest/references/map-components/arcgis-scene/)
+     * component, it automatically creates an empty analysis and adds it to the Scene's
+     * [analyses](https://developers.arcgis.com/javascript/latest/references/map-components/arcgis-scene/#analyses) collection.
+     * Whenever the component is destroyed, the analysis is automatically removed from the collection.
+     *
+     * Alternatively, a programmatically created analysis can be provided to the component.
+     * Then, the application itself needs to add it to and later remove it from the Scene's analyses collection.
+     *
+     * ```js
+     * // Create the analysis.
+     * const sliceAnalysis = new SliceAnalysis({
+     *    shape: new SlicePlane({
+     *      position: new Point({
+     *        spatialReference: { latestWkid: 3857, wkid: 102100 },
+     *        x: -13624925.727820931,
+     *        y: 4550341.695170021,
+     *        z: 56
+     *      }),
+     *      tilt: 270,
+     *      width: 310,
+     *      height: 190,
+     *      heading: 45
+     *    })
+     * });
+     * // Get the Scene and Slice component and wait until they are ready.
+     * const viewElement = document.querySelector("arcgis-scene");
+     * await viewElement.viewOnReady();
+     * const slice = document.querySelector("arcgis-slice");
+     * await slice.componentOnReady();
+     * // Add the analysis to the Scene component.
+     * viewElement.analyses.add(sliceAnalysis);
+     * // Connect the analysis to the slice component:
+     * slice.analysis = sliceAnalysis;
+     * ```
+     */
+    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.
+     *
+     * _**Note**: Individual message keys may change between releases._
+     */
+    messageOverrides?: typeof this._messages._overrides;
+    /** @default "bottom-left" */
     position: __esri.UIPosition;
-    referenceElement: ArcgisReferenceElement | Nil | string;
+    /**
+     * 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)
+     */
+    referenceElement?: ArcgisReferenceElement | string;
+    /**
+     * The shape used to slice elements in a 3D scene. Currently the only supported shape is a
+     * [plane](https://developers.arcgis.com/javascript/latest/api-reference/esri-analysis-SlicePlane.html).
+     *
+     * @example
+     * ```js
+     * // 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
+     */
+    readonly 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](#shape) of the slice, effectively removing it from the view. Other properties like [excludedLayers](#excludedLayers)
+     * and [excludeGroundSurface](#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](#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,198 @@
-import { c as e } from "../../chunks/runtime.js";
-import { usePropertyChange as t } from "@arcgis/lumina/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.99 */
-const d = r`@layer{arcgis-slice{display:block}}`, h = l(s);
-class c extends i {
+v4.33.0 */
+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() {
-    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.supportedViewType = "3d", this.unsupportedErrorMessage = "SliceViewModel is only supported in 3D views.";
+  }
+  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;
+  }
+  initialize() {
+    g.add(this);
+  }
+  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.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: 35, 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";