@geoscene/map-components 4.33.18

package/dist/components/geoscene-sketch/customElement.d.ts

@@ -0,0 +1,243 @@
+/// <reference types="@geoscene/core/interfaces.d.ts" />
+/// <reference types="../../index.d.ts" />
+import { Use } from '@arcgis/lumina/controllers';
+import { default as GraphicsLayer } from '@geoscene/core/layers/GraphicsLayer.js';
+import { default as Sketch } from '@geoscene/core/widgets/Sketch.js';
+import { PublicLitElement as LitElement, ToElement, TargetedEvent } from '@arcgis/lumina';
+import { GeosceneReferenceElement } from '../../utils/component-utils';
+
+declare const useSketchWidget: (component: LitElement & Pick<Sketch, "icon" | "label" | "viewModel" | "scale" | "layout" | "layer" | "availableCreateTools" | "creationMode" | "defaultCreateOptions" | "defaultUpdateOptions" | "labelOptions" | "toolbarKind" | "snappingOptions" | "tooltipOptions"> & {
+    state?: "ready" | "disabled" | "active" | undefined;
+    viewModel?: __geoscene.SketchViewModel | undefined;
+    closed?: boolean;
+    icon: import('@arcgis/components-utils').Nil | string;
+    label: import('@arcgis/components-utils').Nil | string;
+    referenceElement?: GeosceneReferenceElement | string;
+    position: __geoscene.UIPosition;
+    geosceneReady: import('@arcgis/lumina').EventEmitter;
+    geoscenePropertyChange: import('@arcgis/lumina').EventEmitter<{
+        name: string;
+    }> | undefined;
+    el: HTMLElement & {
+        childElem?: HTMLElement & {
+            ownedBy?: HTMLElement;
+        };
+        view?: __geoscene.LinkChartView | __geoscene.MapView | __geoscene.SceneView;
+    };
+    autoDestroyDisabled: boolean;
+    destroy: () => Promise<void>;
+}) => Sketch;
+/**
+ * The Sketch component provides a simple UI for creating and updating graphics on a [MapView](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-views-MapView.html) or a [SceneView](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-views-SceneView.html).
+ *
+ * [Read more...](https://doc.geoscene.cn/javascript/4.33/references/map-components/geoscene-sketch/)
+ */
+export declare class GeosceneSketch extends LitElement {
+    /**
+     * When creating new graphics (for example after [create()](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-widgets-Sketch.html#create) has been called),
+     * this property reflects the create tool being used.
+     *
+     * [Read more...](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-widgets-Sketch.html#activeTool)
+     */
+    readonly activeTool: nullish | "rectangle" | "polygon" | "point" | "move" | "circle" | "reshape" | "multipoint" | "polyline" | "mesh" | "transform" | "freehandPolyline" | "freehandPolygon" | "rectangle-selection" | "lasso-selection" | "custom-selection";
+    /**
+     * If true, the component will not be destroyed automatically when it is
+     * disconnected from the document. This is useful when you want to move the
+     * component to a different place on the page, or temporarily hide it. If this
+     * is set, make sure to call the [destroy](https://doc.geoscene.cn/javascript/4.33/references/map-components/geoscene-sketch/#destroy) method when you are done to
+     * prevent memory leaks.
+     *
+     * @default false
+     */
+    autoDestroyDisabled: boolean;
+    /**
+     * Property controlling the visibility and order of create tool buttons.
+     *
+     * @default ["point", "polyline", "polygon", "rectangle", "circle"]
+     */
+    availableCreateTools: nullish | ("rectangle" | "polygon" | "point" | "circle" | "multipoint" | "polyline" | "mesh" | "freehandPolyline" | "freehandPolygon")[];
+    /**
+     * The graphic that is being created.
+     *
+     * [Read more...](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-widgets-Sketch.html#createGraphic)
+     */
+    readonly createGraphic: nullish | __geoscene.Graphic;
+    /**
+     * Defines the default behavior once the [create](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-widgets-Sketch.html#create) operation is completed.
+     *
+     * @default "continuous"
+     */
+    creationMode: "update" | "single" | "continuous";
+    /**
+     * Default create options set for the Sketch widget.
+     *
+     * [Read more...](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-widgets-Sketch.html#defaultCreateOptions)
+     */
+    defaultCreateOptions: __geoscene.SketchDefaultCreateOptions;
+    /**
+     * By default, sketch will auto-create a new graphics layer if none was
+     * provided. Set this prop to true to disable this behavior.
+     *
+     * @default false
+     */
+    defaultGraphicsLayerDisabled: boolean;
+    /**
+     * Default update options set for the Sketch widget.
+     *
+     * [Read more...](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-widgets-Sketch.html#defaultUpdateOptions)
+     */
+    defaultUpdateOptions: __geoscene.SketchDefaultUpdateOptions;
+    /** @default false */
+    hideCreateToolsCircle: boolean;
+    /** @default false */
+    hideCreateToolsPoint: boolean;
+    /** @default false */
+    hideCreateToolsPolygon: boolean;
+    /** @default false */
+    hideCreateToolsPolyline: boolean;
+    /** @default false */
+    hideCreateToolsRectangle: boolean;
+    /** @default false */
+    hideDuplicateButton: boolean;
+    /** @default false */
+    hideDeleteButton: boolean;
+    /** @default false */
+    hideSelectionCountLabel: boolean;
+    /** @default false */
+    hideLabelsToggle: boolean;
+    /** @default false */
+    hideSelectionToolsLassoSelection: boolean;
+    /** @default false */
+    hideSelectionToolsRectangleSelection: boolean;
+    /** @default false */
+    hideSettingsMenu: boolean;
+    /** @default false */
+    hideSnappingControls: boolean;
+    /** @default false */
+    hideSnappingControlsElementsEnabledToggle: boolean;
+    /** @default false */
+    hideSnappingControlsElementsFeatureEnabledToggle: boolean;
+    /** @default false */
+    hideSnappingControlsElementsLayerList: boolean;
+    /** @default false */
+    hideSnappingControlsElementsSelfEnabledToggle: boolean;
+    /** @default false */
+    hideTooltipsToggle: boolean;
+    /** @default false */
+    hideUndoRedoMenu: boolean;
+    /**
+     * Icon which represents the component.
+     * Typically used when the component is controlled by another component (e.g. by the Expand component).
+     *
+     * @see [Calcite Icons](https://doc.geoscene.cn/calcite-design-system/icons/)
+     * @default "pencil"
+     */
+    icon: string;
+    /**
+     * The Sketch widget's default label.
+     *
+     * [Read more...](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-widgets-Sketch.html#label)
+     */
+    label: string;
+    /**
+     * Options to configure the sketch labels shown next to each segment of the geometry being created or updated.
+     *
+     * [Read more...](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-widgets-Sketch.html#labelOptions)
+     */
+    labelOptions: __geoscene.SketchLabelOptions;
+    /**
+     * The [GraphicsLayer](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-layers-GraphicsLayer.html) associated with the Sketch widget.
+     *
+     * [Read more...](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-widgets-Sketch.html#layer)
+     */
+    layer: GraphicsLayer;
+    /**
+     * Determines the layout/orientation of the Sketch widget.
+     *
+     * @default "horizontal"
+     */
+    layout: "vertical" | "horizontal";
+    /**
+     * A [SimpleMarkerSymbol](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-symbols-SimpleMarkerSymbol.html), [PointSymbol3D](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-symbols-PointSymbol3D.html), [TextSymbol](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-symbols-TextSymbol.html), [CIMSymbol](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-symbols-CIMSymbol.html), or [WebStyleSymbol](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-symbols-WebStyleSymbol.html) used for representing the point geometry that is being drawn.
+     *
+     * [Read more...](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-widgets-Sketch-SketchViewModel.html#pointSymbol)
+     */
+    pointSymbol: __geoscene.SimpleMarkerSymbol | __geoscene.PictureMarkerSymbol | __geoscene.PointSymbol3D | __geoscene.TextSymbol | __geoscene.CIMSymbol | __geoscene.WebStyleSymbol;
+    /**
+     * A [SimpleFillSymbol](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-symbols-SimpleFillSymbol.html), [PolygonSymbol3D](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-symbols-PolygonSymbol3D.html), or [CIMSymbol](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-symbols-CIMSymbol.html) used for representing the polygon geometry that is being drawn.
+     *
+     * [Read more...](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-widgets-Sketch-SketchViewModel.html#polygonSymbol)
+     */
+    polygonSymbol: __geoscene.CIMSymbol | __geoscene.SimpleFillSymbol | __geoscene.PolygonSymbol3D;
+    /**
+     * A [SimpleLineSymbol](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-symbols-SimpleLineSymbol.html), [LineSymbol3D](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-symbols-LineSymbol3D.html), or [CIMSymbol](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-symbols-CIMSymbol.html) used for representing the polyline geometry that is being drawn.
+     *
+     * [Read more...](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-widgets-Sketch-SketchViewModel.html#polylineSymbol)
+     */
+    polylineSymbol: __geoscene.SimpleLineSymbol | __geoscene.CIMSymbol | __geoscene.LineSymbol3D;
+    /** @default "bottom-left" */
+    position: __geoscene.UIPosition;
+    /**
+     * 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://doc.geoscene.cn/javascript/4.33/programming-patterns/#associate-components-with-a-map-or-scene-component)
+     */
+    referenceElement?: GeosceneReferenceElement | string;
+    /**
+     * Determines the size of widget elements.
+     *
+     * @default "m"
+     */
+    scale: "s" | "m" | "l";
+    /**
+     * Controls the appearance of the sketch widget, allowing
+     * the toolbar to adapt its appearance appropriately based on context.
+     *
+     * @default "floating"
+     */
+    toolbarKind: "floating" | "docked";
+    /** @default false */
+    showSnappingControlsElementsHeader: boolean;
+    /**
+     * The [SnappingOptions](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-views-interactive-snapping-SnappingOptions.html) for sketching.
+     *
+     * [Read more...](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-widgets-Sketch.html#snappingOptions)
+     */
+    snappingOptions: __geoscene.SnappingOptions;
+    /** The current state of the component. */
+    readonly state: "ready" | "disabled" | "active";
+    /**
+     * Options to configure the tooltip shown next to the cursor when creating or updating graphics.
+     *
+     * [Read more...](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-widgets-Sketch.html#tooltipOptions)
+     */
+    tooltipOptions: __geoscene.SketchTooltipOptions;
+    /**
+     * An array of [graphics](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-Graphic.html) that are being updated by the Sketch widget.
+     *
+     * [Read more...](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-widgets-Sketch.html#updateGraphics)
+     */
+    readonly updateGraphics: __geoscene.Collection<__geoscene.Graphic>;
+    cancel(): Promise<void>;
+    complete(): Promise<void>;
+    create(tool: "circle" | "point" | "polygon" | "polyline" | "rectangle", createOptions?: __geoscene.SketchViewModelCreateCreateOptions): Promise<void>;
+    delete(): Promise<void>;
+    /** Permanently destroy the component. */
+    destroy(): Promise<void>;
+    duplicate(): Promise<void>;
+    redo(): Promise<void>;
+    triggerUpdate(graphic: __geoscene.Graphic | __geoscene.Graphic[], updateOptions?: __geoscene.SketchViewModelUpdateUpdateOptions): Promise<void>;
+    undo(): Promise<void>;
+    readonly geosceneCreate: TargetedEvent<this, __geoscene.SketchCreateEvent>;
+    readonly geosceneDelete: TargetedEvent<this, __geoscene.SketchDeleteEvent>;
+    /** Emitted when the value of a property is changed. Use this to listen to changes to properties. */
+    readonly geoscenePropertyChange: TargetedEvent<this, {
+        name: "state";
+    }>;
+    /** Emitted when the component associated with a map or scene view is is ready to be interacted with. */
+    readonly geosceneReady: TargetedEvent<this, void>;
+    readonly geosceneRedo: TargetedEvent<this, __geoscene.SketchRedoEvent>;
+    readonly geosceneUndo: TargetedEvent<this, __geoscene.SketchUndoEvent>;
+    readonly geosceneUpdate: TargetedEvent<this, __geoscene.SketchUpdateEvent>;
+}
+export {};

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

@@ -0,0 +1,68 @@
+import { c as l } from "../../chunks/runtime.js";
+import { usePropertyChange as o } from "@arcgis/lumina/controllers";
+import { reEmitEvent as i } from "@arcgis/lumina/controllers/accessor";
+import a from "@geoscene/core/layers/GraphicsLayer.js";
+import n from "@geoscene/core/widgets/Sketch.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 "@geoscene/core/core/reactiveUtils.js";
+/*! All material copyright GeoScene, All Rights Reserved, unless otherwise specified.
+See https://js.geoscene.cn/4.33/geoscene/copyright.txt for details.
+v4.33.18 */
+const m = p`@layer{geoscene-sketch{display:block}}`, y = g(n);
+class w extends h {
+  constructor() {
+    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.geosceneCreate = i(() => this.widget, "create"), this.geosceneDelete = i(() => this.widget, "delete"), this.geoscenePropertyChange = o()("state"), this.geosceneReady = d(), this.geosceneRedo = i(() => this.widget, "redo"), this.geosceneUndo = i(() => this.widget, "undo"), this.geosceneUpdate = i(() => this.widget, "update"), this.listen("geosceneReady", this._geosceneReadyHandler);
+  }
+  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 = r;
+  }
+  static {
+    this.styles = m;
+  }
+  async cancel() {
+    this.widget?.cancel();
+  }
+  async complete() {
+    this.widget?.complete();
+  }
+  async create(t, e) {
+    await this.widget?.create(t, e);
+  }
+  async delete() {
+    this.widget?.delete();
+  }
+  async destroy() {
+    await this.manager.destroy();
+  }
+  async duplicate() {
+    this.widget?.duplicate();
+  }
+  async redo() {
+    this.widget?.redo();
+  }
+  async triggerUpdate(t, e) {
+    this.widget?.update(t, e);
+  }
+  async undo() {
+    this.widget?.undo();
+  }
+  _geosceneReadyHandler() {
+    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;
+    }));
+  }
+}
+l("geoscene-sketch", w);
+export {
+  w as GeosceneSketch
+};

package/dist/components/geoscene-sketch/index.d.ts

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

package/dist/components/geoscene-sketch/index.js

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

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

@@ -0,0 +1,51 @@
+/// <reference types="@geoscene/core/interfaces.d.ts" />
+import { AnalysisViewModel } from '../../support/AnalysisViewModel';
+import { default as SceneView } from '@geoscene/core/views/SceneView';
+import { default as SliceAnalysis } from '@geoscene/core/analysis/SliceAnalysis.js';
+import { default as Layer } from '@geoscene/core/layers/Layer';
+import { default as Collection } from '@geoscene/core/core/Collection.js';
+import { default as SliceAnalysisView3D } from '@geoscene/core/views/3d/analysis/SliceAnalysisView3D';
+export type SliceableLayer = __geoscene.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(): __geoscene.SlicePlane | nullish;
+    set shape(value: __geoscene.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);
+    /**
+     * 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://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-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/geoscene-slice/css.d.ts

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

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

@@ -0,0 +1,185 @@
+/// <reference types="@geoscene/core/interfaces.d.ts" />
+/// <reference types="../../index.d.ts" />
+import { Use } from '@arcgis/lumina/controllers';
+import { PublicLitElement as LitElement, JsxNode, TargetedEvent } from '@arcgis/lumina';
+import { GeosceneReferenceElement } from '../../utils/component-utils';
+import { default as SliceViewModel, SliceableLayer } from './SliceViewModel';
+import { HeadingLevel } from '../../support/heading';
+
+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://doc.geoscene.cn/javascript/4.33/references/map-components/geoscene-scene/). It applies
+ * [slice analysis](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-analysis-SliceAnalysis.html)
+ * to any layer type, making it possible to see inside buildings or to explore geological surfaces.
+ *
+ * [![slice](https://doc.geoscene.cn/javascript/4.33/assets/img/apiref/widgets/slice.gif)](https://doc.geoscene.cn/javascript/4.33/sample-code/building-scene-layer-slice/index.html)
+ *
+ * The slicing [shape](#shape)
+ * is always a [plane](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-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://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-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://doc.geoscene.cn/javascript/4.33/assets/img/apiref/widgets/slice-exclude.png)](https://doc.geoscene.cn/javascript/4.33/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://doc.geoscene.cn/javascript/4.33/references/map-components/geoscene-scene/) component.
+ *
+ * **See also**
+ *
+ * - [SliceAnalysis](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-analysis-SliceAnalysis.html)
+ * - [Sample - BuildingSceneLayer with Slice component](https://doc.geoscene.cn/javascript/4.33/sample-code/building-scene-layer-slice/)
+ * - [Sample - Analysis objects](https://doc.geoscene.cn/javascript/4.33/sample-code/analysis-objects/)
+ *
+ * [Read more...](https://doc.geoscene.cn/javascript/4.33/references/map-components/geoscene-slice/)
+ */
+export declare class GeosceneSlice extends LitElement {
+    /**
+     * The [SliceAnalysis](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-analysis-SliceAnalysis.html)
+     * created or modified by the component.
+     *
+     * When connecting the Slice component to the [Scene](https://doc.geoscene.cn/javascript/4.33/references/map-components/geoscene-scene/)
+     * component, it automatically creates an empty analysis and adds it to the Scene's
+     * [analyses](https://doc.geoscene.cn/javascript/4.33/references/map-components/geoscene-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("geoscene-scene");
+     * await viewElement.viewOnReady();
+     * const slice = document.querySelector("geoscene-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: __geoscene.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](https://doc.geoscene.cn/javascript/4.33/references/map-components/geoscene-slice/#destroy) method when you are done to
+     * prevent memory leaks.
+     *
+     * @default false
+     */
+    autoDestroyDisabled: boolean;
+    /**
+     * Indicates whether the [Ground](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-Ground.html) and layers that
+     * are draped on the ground surface are excluded from the slice.
+     *
+     * @default false
+     */
+    excludeGroundSurface: boolean;
+    /**
+     * 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: __geoscene.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).
+     *
+     * @see [Calcite Icons](https://doc.geoscene.cn/calcite-design-system/icons/)
+     * @default "slice"
+     */
+    icon?: HTMLCalciteIconElement["icon"];
+    /** The component's default label. */
+    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: __geoscene.UIPosition;
+    /**
+     * 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://doc.geoscene.cn/javascript/4.33/programming-patterns/#associate-components-with-a-map-or-scene-component)
+     */
+    referenceElement?: GeosceneReferenceElement | string;
+    /**
+     * The shape used to slice elements in a 3D scene. Currently the only supported shape is a
+     * [plane](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-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 | __geoscene.SlicePlane;
+    /**
+     * 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. */
+    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 geoscenePropertyChange: TargetedEvent<this, {
+        name: "state" | "analysis";
+    }>;
+    /** Emitted when the component associated with a map or scene view is is ready to be interacted with. */
+    readonly geosceneReady: TargetedEvent<this, void>;
+    private _messages;
+}
+export {};