@arcgis/map-components 5.2.0-next.7 → 5.2.0-next.71

package/dist/components/arcgis-selection-toolbar/customElement.d.ts

@@ -0,0 +1,379 @@
+/// <reference path="../../index.d.ts" />
+import type SelectionOperation from "@arcgis/core/views/selection/SelectionOperation.js";
+import type SelectionManager from "@arcgis/core/views/SelectionManager.js";
+import type { SelectionOperationProperties } from "@arcgis/core/views/selection/SelectionOperation.js";
+import type { SelectionChangeEventInfo, SelectionCompleteEventInfo, SelectionOperationType, SelectionToolName, SelectableViewUnion, SelectionSource } from "@arcgis/core/views/selection/types.js";
+import type { PublicLitElement as LitElement } from "@arcgis/lumina";
+import type { SelectionToolbarBeforeActivateEvent } from "./types.js";
+import type { ArcgisReferenceElement, IconName } from "../types.js";
+import type { T9nMeta } from "@arcgis/lumina/controllers";
+import type { SelectionToolConfig } from "@arcgis/core/widgets/support/SelectionToolbar/types.js";
+import type { Action as Action } from "@esri/calcite-components/components/calcite-action";
+
+/**
+ * The selection toolbar component can be used to modify selected features on a provided view.
+ *
+ * @since 5.2
+ */
+export abstract class ArcgisSelectionToolbar extends LitElement {
+  /**
+   * A reference to the active selection operation. Only one selection operation can be active at a time.
+   *
+   * @since 5.2
+   */
+  get activeOperation(): SelectionOperation | null | undefined;
+  /**
+   * 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://developers.arcgis.com/javascript/latest/references/map-components/components/arcgis-selection-toolbar/#destroy) method when you are done to
+   * prevent memory leaks.
+   *
+   * @default false
+   */
+  accessor autoDestroyDisabled: boolean;
+  /**
+   * An array of operation type names that determines what operation types appear in the associated dropdown component.
+   *
+   * @since 5.2
+   */
+  accessor availableOperationTypes: SelectionOperationType[];
+  /**
+   * Determines if the selection toolbar should automatically reactivate a new selection operation
+   * after the completion of an active selection operation, using options from the previous operation.
+   * This only applies if the previous selection operation was completed, and not cancelled.
+   *
+   * @default false
+   * @since 5.2
+   */
+  accessor continuousSelectionEnabled: boolean;
+  /**
+   * The default configuration for the lasso tool.
+   *
+   * @since 5.2
+   */
+  accessor defaultLassoToolOptions: SelectionOperationProperties;
+  /**
+   * The default selection operation type to use when starting a new selection operation.
+   * This value can be changed via the selection operation type dropdown.
+   *
+   * @default "add"
+   * @since 5.2
+   */
+  accessor defaultOperationType: SelectionOperationType;
+  /**
+   * The default configuration for the point tool.
+   *
+   * @since 5.2
+   */
+  accessor defaultPointToolOptions: SelectionOperationProperties;
+  /**
+   * The default configuration for the rectangle tool.
+   *
+   * @since 5.2
+   */
+  accessor defaultRectangleToolOptions: SelectionOperationProperties;
+  /**
+   * When true, the component is visually withdrawn and cannot receive user interaction.
+   *
+   * @default false
+   */
+  accessor disabled: boolean;
+  /**
+   * A reference to the selection manager currently in use by the component.
+   *
+   * @since 5.2
+   */
+  get effectiveSelectionManager(): SelectionManager | null | undefined;
+  /**
+   * An array of validated selection sources. These sources will also include any relevant layer views
+   * that were found on the provided view if `layerViewPreferenceDisabled` is false.
+   *
+   * @since 5.2
+   */
+  get effectiveSources(): Array<SelectionSource>;
+  /**
+   * Indicates whether the selection count chip should be hidden. The chip shows the total count of
+   * selected features and a close button for clearing the selection.
+   *
+   * @default false
+   * @since 5.2
+   */
+  accessor hideChip: boolean;
+  /**
+   * Indicates whether the lasso tool should be hidden. The lasso tool allows for freehand selection of features.
+   *
+   * @default false
+   * @since 5.2
+   */
+  accessor hideLassoTool: boolean;
+  /**
+   * Indicates whether the selection operation type controls should be hidden. The operation type controls
+   * allow for changing the selection operation type (e.g., replace, add, remove).
+   *
+   * @default false
+   * @since 5.2
+   */
+  accessor hideOperationTypeControls: boolean;
+  /**
+   * Indicates whether the pan tool should be hidden. The pan tool allows for panning the view without
+   * performing a selection operation. This tool is the default when no selection operation is active.
+   *
+   * @default false
+   * @since 5.2
+   */
+  accessor hidePanTool: boolean;
+  /**
+   * Indicates whether the point tool should be hidden. The point tool allows for selecting features by clicking on them.
+   * The point tool will include all features that intersect the clicked point, not just the topmost feature.
+   *
+   * @default false
+   * @since 5.2
+   */
+  accessor hidePointTool: boolean;
+  /**
+   * Indicates whether the progress indicator should be hidden. The progress indicator shows when a selection
+   * operation is processing results. The processing time can vary depending on the potential number of selected
+   * features, or whether the selection operation is querying source layers or layer views for results.
+   *
+   * @default false
+   * @since 5.2
+   */
+  accessor hideProgress: boolean;
+  /**
+   * Indicates whether the rectangle tool should be hidden. The rectangle tool allows for selecting features by
+   * drawing a rectangle.
+   *
+   * @default false
+   * @since 5.2
+   */
+  accessor hideRectangleTool: boolean;
+  /**
+   * Icon which represents the component.
+   * Typically used when the component is controlled by another component (e.g. by the Expand component).
+   *
+   * @default "selection-set"
+   * @see [Calcite Icons](https://developers.arcgis.com/calcite-design-system/icons/)
+   */
+  accessor icon: IconName | undefined;
+  /** The component's default label. */
+  accessor label: string | undefined;
+  /**
+   * Indicates whether selection operations should always perform queries against source layers instead of
+   * preferring to query their associated layer views in order to determine selection results. Querying the
+   * layer may be required when up-to-date features are necessary. Changing this property while a selection
+   * operation is active will not have any effect on that operation, and will only affect subsequent operations.
+   *
+   * @default false
+   * @since 5.2
+   */
+  accessor layerViewPreferenceDisabled: boolean;
+  /**
+   * Controls the orientation of the component.
+   *
+   * @default "horizontal"
+   * @since 5.2
+   */
+  accessor layout: "horizontal" | "vertical";
+  /**
+   * Localized strings.
+   *
+   * @internal
+   */
+  protected messages: Partial<{
+      componentLabel: string;
+      add: string;
+      addToSelection: string;
+      clearSelection: string;
+      clearSelectionCount: string;
+      countTruncated: string;
+      lasso: string;
+      pan: string;
+      point: string;
+      processing: string;
+      rectangle: string;
+      remove: string;
+      removeFromSelection: string;
+      replace: string;
+      replaceSelection: string;
+      selectFeatures: string;
+      selectByLasso: string;
+      selectByPoint: string;
+      selectByRectangle: string;
+  }> & T9nMeta<{
+      componentLabel: string;
+      add: string;
+      addToSelection: string;
+      clearSelection: string;
+      clearSelectionCount: string;
+      countTruncated: string;
+      lasso: string;
+      pan: string;
+      point: string;
+      processing: string;
+      rectangle: string;
+      remove: string;
+      removeFromSelection: string;
+      replace: string;
+      replaceSelection: string;
+      selectFeatures: string;
+      selectByLasso: string;
+      selectByPoint: string;
+      selectByRectangle: 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)
+   */
+  accessor referenceElement: ArcgisReferenceElement | string | undefined;
+  /**
+   * Determines if selected features should be returned with fields necessary for displaying feature titles as
+   * defined by the WebMap.
+   *
+   * @default false
+   * @since 5.2
+   */
+  accessor returnFeatureTitleFields: boolean;
+  /**
+   * Indicates selected features returned by the selection operation should include their geometries.
+   * This may be leveraged to improve performance when geometries are not needed for the selection results.
+   *
+   * @default false
+   * @since 5.2
+   */
+  accessor returnGeometryDisabled: boolean;
+  /**
+   * A reference to a custom selection manager to use instead of the view's default selection manager.
+   *
+   * @since 5.2
+   */
+  accessor selectionManager: SelectionManager | null | undefined;
+  /**
+   * Indicates text labels should be displayed next to each tool.
+   *
+   * @default false
+   * @since 5.2
+   */
+  accessor showTextLabels: boolean;
+  /**
+   * An array of layer or layer views that selection is derived from.
+   *
+   * @since 5.2
+   */
+  accessor sources: Array<SelectionSource> | null | undefined;
+  /**
+   * The state of the component.
+   *
+   * @since 5.2
+   */
+  get state(): "active" | "disabled" | "ready";
+  /**
+   * Indicates whether new selection operation results should be synced with the associated selection
+   * manager automatically. Events emitted by the toolbar will still contain updated selection information but
+   * the changes will not be reflected by the selection manager when a selection operation completes.
+   *
+   * @default false
+   * @since 5.2
+   */
+  accessor syncResultsDisabled: boolean;
+  /**
+   * Indicates whether the selection operation should continuously determine the potential selection while
+   * the associated draw tool is active, which is reflected via events. Otherwise, a selection operation will
+   * only determine the selection a single time when a drawing has been completed. It is important to note that
+   * the potential selection is not saved or reflected via the associated selection manager. Set this property to true to
+   * enable constant updates to the working selection set, which can be useful in some cases e.g. highlighting potential
+   * features while drawing. This does not affect whether final selection results are stored by the selection manager, which
+   * can be controlled via the syncResultsDisabled property.
+   *
+   * @default false
+   * @since 5.2
+   */
+  accessor syncWhileDrawing: boolean;
+  /**
+   * An array of configurations for custom selection tools to display in the component UI.
+   *
+   * @since 5.2
+   * @internal
+   */
+  accessor toolConfigs: Array<SelectionToolConfig>;
+  /**
+   * The view associated with the component.
+   * > **Note:** The recommended approach is to fully migrate applications to use map and scene components and avoid using MapView and SceneView directly. However, if you are migrating a large application from widgets to components, you might prefer a more gradual transition. To support this use case, the SDK includes this `view` property which connects a component to a MapView or SceneView. Ultimately, once migration is complete, the arcgis-selection-toolbar component will be associated with a map or scene component rather than using the `view` property.
+   */
+  accessor view: SelectableViewUnion | null | undefined;
+  /**
+   * Controls the scale of any rendered Calcite elements.
+   *
+   * @default "m"
+   * @since 5.2
+   */
+  accessor visualScale: Action["scale"];
+  /**
+   * Activates a tool with the provided options. Cancels any currently active selection operation.
+   * This method has no effect if the toolbar is disabled.
+   *
+   * @param options - Optional tool and operation configuration.
+   * @returns A promise that resolves to the active selection operation, or `undefined` if activation was blocked.
+   * @since 5.2
+   */
+  activate(options?: SelectionOperationProperties): Promise<SelectionOperation | undefined>;
+  /**
+   * Activates a tool by name. Cancels any currently active selection operation.
+   * Custom tools should be pre-configured via the 'toolConfigs' property.
+   * This method has no effect if the toolbar is disabled.
+   *
+   * @param toolName - The name of the tool to activate.
+   * @returns A promise that resolves to the active selection operation, or `undefined` if activation was blocked.
+   * @since 5.2
+   */
+  activateTool(toolName: SelectionToolName): Promise<SelectionOperation | undefined>;
+  /**
+   * Cancels any active operation and, if applicable, triggers a 'complete' event.
+   * The 'complete' event indicates if the operation was cancelled via the 'aborted' property.
+   *
+   * @since 5.2
+   */
+  cancel(): Promise<void>;
+  /** Permanently destroy the component. */
+  destroy(): Promise<void>;
+  /**
+   * Convenience method for toggling the active state of a specific tool. If the provided tool is already active, it will be cancelled.
+   * If the provided tool is not active, it will be activated. Any currently active selection operation will also be cancelled before
+   * activating the new tool.
+   *
+   * @param toolName - The name of the tool to toggle.
+   * @returns A promise that resolves to the active selection operation if the associated tool was toggled on, or `undefined` if the tool was toggled off.
+   * @since 5.2
+   */
+  toggleTool(toolName: SelectionToolName): Promise<SelectionOperation | undefined>;
+  /**
+   * Fires before any selection operation is activated.
+   *
+   * @since 5.2
+   */
+  readonly arcgisBeforeActivate: import("@arcgis/lumina").TargetedEvent<this, SelectionToolbarBeforeActivateEvent>;
+  /**
+   * Fires when the selection operation is complete and results have been processed.
+   *
+   * @since 5.2
+   */
+  readonly arcgisComplete: import("@arcgis/lumina").TargetedEvent<this, SelectionCompleteEventInfo>;
+  /** Emitted when the value of a property is changed. Use this to listen to changes to properties. */
+  readonly arcgisPropertyChange: import("@arcgis/lumina").TargetedEvent<this, { name: "activeOperation" | "state"; }>;
+  /** Emitted when the component associated with a map or scene view is ready to be interacted with. */
+  readonly arcgisReady: import("@arcgis/lumina").TargetedEvent<this, void>;
+  /**
+   * Fires when the determined selection changes, including while drawing.
+   *
+   * @since 5.2
+   */
+  readonly arcgisSelectionChange: import("@arcgis/lumina").TargetedEvent<this, SelectionChangeEventInfo>;
+  readonly "@eventTypes": {
+    arcgisBeforeActivate: ArcgisSelectionToolbar["arcgisBeforeActivate"]["detail"];
+    arcgisComplete: ArcgisSelectionToolbar["arcgisComplete"]["detail"];
+    arcgisPropertyChange: ArcgisSelectionToolbar["arcgisPropertyChange"]["detail"];
+    arcgisReady: ArcgisSelectionToolbar["arcgisReady"]["detail"];
+    arcgisSelectionChange: ArcgisSelectionToolbar["arcgisSelectionChange"]["detail"];
+  };
+}

package/dist/components/arcgis-selection-toolbar/customElement.js

@@ -0,0 +1,191 @@
+/* COPYRIGHT Esri - https://js.arcgis.com/5.2/LICENSE.txt */
+import { c as g } from "../../chunks/runtime.js";
+import { css as v, html as a } from "lit";
+import { keyed as h } from "lit/directives/keyed.js";
+import { substitute as p, formatNumber as T } from "@arcgis/core/intl.js";
+import b from "@arcgis/core/widgets/support/SelectionToolbar/SelectionToolbarViewModel.js";
+import { LitElement as m, createEvent as r, nothing as n } from "@arcgis/lumina";
+import { usePropertyChange as y } from "@arcgis/lumina/controllers";
+import { u as w } from "../../chunks/useT9n.js";
+import { m as O } from "../../chunks/useViewModel.js";
+const M = v`:host{width:100%;display:flex;>*{align-items:center;align-self:center;height:100%;width:100%}}.root{display:flex;flex-direction:column}calcite-action-bar[layout=horizontal]{width:100%;calcite-chip{margin-inline-start:auto}}calcite-action-bar[layout=vertical]{height:100%;calcite-chip{margin-block-start:auto}}calcite-action-bar slot{align-items:center}calcite-dropdown:has(calcite-action:not([text-enabled])){align-self:center}calcite-action:not([text-enabled]){align-self:center}calcite-chip{display:flex;align-self:center;line-height:initial}calcite-dropdown{calcite-icon{margin-inline-start:var(--calcite-space-2xs)}}calcite-chip[closed]{display:inline-flex}calcite-progress{--calcite-progress-background-color: transparent}`, u = {
+  replace: "overwrite-features",
+  add: "cursor-plus",
+  remove: "cursor-minus"
+}, $ = O(b);
+class S extends m {
+  constructor() {
+    super(...arguments), this.viewModel = $(this), this.messages = w(), this.autoDestroyDisabled = !1, this.disabled = !1, this.icon = "selection-set", this.view = this.viewModel.view, this.activeOperation = this.viewModel.activeOperation, this.availableOperationTypes = ["replace", "add", "remove"], this.continuousSelectionEnabled = this.viewModel.continuousSelectionEnabled, this.defaultLassoToolOptions = this.viewModel.defaultLassoToolOptions, this.defaultOperationType = this.viewModel.defaultOperationType, this.defaultPointToolOptions = this.viewModel.defaultPointToolOptions, this.defaultRectangleToolOptions = this.viewModel.defaultRectangleToolOptions, this.effectiveSelectionManager = this.viewModel.effectiveSelectionManager, this.effectiveSources = this.viewModel.effectiveSources, this.hideChip = !1, this.hideLassoTool = !1, this.hideOperationTypeControls = !1, this.hidePanTool = !1, this.hidePointTool = !1, this.hideProgress = !1, this.hideRectangleTool = !1, this.layout = "horizontal", this.returnFeatureTitleFields = this.viewModel.returnFeatureTitleFields, this.selectionManager = this.viewModel.selectionManager, this.showTextLabels = !1, this.sources = this.viewModel.sources, this.toolConfigs = this.viewModel.toolConfigs, this.visualScale = "m", this.arcgisBeforeActivate = r(), this.arcgisComplete = r(), this.arcgisPropertyChange = y()("activeOperation", "state"), this.arcgisReady = r(), this.arcgisSelectionChange = r();
+  }
+  static {
+    this.properties = { _effectiveDisabled: 16, _effectiveOperationType: 16, _processing: 16, autoDestroyDisabled: 5, disabled: 7, icon: 1, label: 1, referenceElement: 1, view: 0, activeOperation: 32, availableOperationTypes: 0, continuousSelectionEnabled: 5, defaultLassoToolOptions: 0, defaultOperationType: 1, defaultPointToolOptions: 0, defaultRectangleToolOptions: 0, effectiveSelectionManager: 32, effectiveSources: 32, hideChip: 5, hideLassoTool: 5, hideOperationTypeControls: 5, hidePanTool: 5, hidePointTool: 5, hideProgress: 5, hideRectangleTool: 5, layerViewPreferenceDisabled: 5, layout: 1, returnFeatureTitleFields: 5, returnGeometryDisabled: 5, selectionManager: 0, showTextLabels: 5, sources: 0, state: 32, syncResultsDisabled: 5, syncWhileDrawing: 5, toolConfigs: 0, visualScale: 1 };
+  }
+  static {
+    this.styles = M;
+  }
+  get _effectiveDisabled() {
+    return this.disabled || this.state === "disabled";
+  }
+  get _effectiveOperationType() {
+    return this.activeOperation?.effectiveType || this.defaultOperationType;
+  }
+  get _processing() {
+    return !!this.activeOperation?.processingFinalSelection;
+  }
+  get layerViewPreferenceDisabled() {
+    return !this.viewModel.layerViewPreferenceEnabled;
+  }
+  set layerViewPreferenceDisabled(e) {
+    this.viewModel.layerViewPreferenceEnabled = !e;
+  }
+  get returnGeometryDisabled() {
+    return !this.viewModel.returnGeometry;
+  }
+  set returnGeometryDisabled(e) {
+    this.viewModel.returnGeometry = !e;
+  }
+  get state() {
+    return this.viewModel.state;
+  }
+  get syncResultsDisabled() {
+    return !this.viewModel.persistSelection;
+  }
+  set syncResultsDisabled(e) {
+    this.viewModel.persistSelection = !e;
+  }
+  get syncWhileDrawing() {
+    return !this.viewModel.selectOnComplete;
+  }
+  set syncWhileDrawing(e) {
+    this.viewModel.selectOnComplete = !e;
+  }
+  async activate(e) {
+    if (this.cancel(), !this._effectiveDisabled)
+      return this.viewModel.activate(e);
+  }
+  async activateTool(e) {
+    if (!this._effectiveDisabled)
+      return this.viewModel.activateTool(e);
+  }
+  async cancel() {
+    this.viewModel.cancel();
+  }
+  async destroy() {
+    this.viewModel?.destroy();
+  }
+  async toggleTool(e) {
+    if (!this._effectiveDisabled)
+      return this.viewModel.toggleTool(e);
+  }
+  _getLabelForSelectionOperationType(e) {
+    const { messages: t } = this;
+    switch (e) {
+      case "replace":
+        return t?.replaceSelection;
+      case "add":
+        return t?.addToSelection;
+      case "remove":
+        return t?.removeFromSelection;
+    }
+  }
+  _getTextForSelectionOperationType(e) {
+    const { messages: t } = this;
+    switch (e) {
+      case "replace":
+        return t?.replace;
+      case "add":
+        return t?.add;
+      case "remove":
+        return t?.remove;
+    }
+  }
+  _getTextForChip() {
+    const { effectiveSelectionManager: e, layout: t, messages: i, visualScale: o } = this, s = e?.count ?? 0, l = o === "l" ? 999 : 99;
+    return i.countTruncated && s > l && t === "vertical" ? p(i.countTruncated, {
+      count: l
+    }) : T(s);
+  }
+  #i() {
+    if (this.hideProgress)
+      return;
+    const e = this.messages.processing;
+    return a`<calcite-progress aria-label=${e ?? n} .label=${e} .type=${this._processing ? "indeterminate" : "determinate"}></calcite-progress>`;
+  }
+  #o() {
+    return h("tools-group", a`<calcite-action-group>${this.#s()}${this.#a()}</calcite-action-group>`);
+  }
+  #s() {
+    return [this.#l(), this.#n(), this.#d(), this.#c()];
+  }
+  #a() {
+    return this.toolConfigs.map(({ toolName: e, icon: t }) => this.#e(e, t));
+  }
+  #l() {
+    if (this.hidePanTool)
+      return;
+    const e = this.messages.pan ?? "";
+    return this.#t({
+      active: !this.activeOperation,
+      disabled: this._effectiveDisabled,
+      icon: "pan",
+      onclick: () => this.cancel(),
+      text: e,
+      title: e
+    });
+  }
+  #r() {
+    if (this.hideChip)
+      return;
+    const { effectiveSelectionManager: e, messages: t } = this, i = e?.count ?? 0, o = this._getTextForChip(), s = t.clearSelectionCount ? p(t.clearSelectionCount, { count: i }) : void 0;
+    return a`<calcite-chip appearance=outline .closable=${i > 0} .disabled=${this._effectiveDisabled || i === 0} .label=${o} .scale=${this.visualScale} title=${s ?? n} @calciteChipClose=${() => e?.clear()}>${o}</calcite-chip>`;
+  }
+  #n() {
+    if (this.hidePointTool)
+      return;
+    const { messages: e } = this;
+    return this.#e("point", "selection-set", e.point, e.selectByPoint);
+  }
+  #c() {
+    if (this.hideLassoTool)
+      return;
+    const { messages: e } = this;
+    return this.#e("lasso", "lasso-select", e.lasso, e.selectByLasso);
+  }
+  #d() {
+    if (this.hideRectangleTool)
+      return;
+    const { messages: e } = this;
+    return this.#e("rectangle", "cursor-marquee", e.rectangle, e.selectByRectangle);
+  }
+  #h() {
+    const { availableOperationTypes: e } = this;
+    if (this.hideOperationTypeControls || !e.length)
+      return;
+    const { _effectiveOperationType: t, showTextLabels: i, visualScale: o } = this, s = u[t], l = this._getTextForSelectionOperationType(t), c = this._getLabelForSelectionOperationType(t);
+    return h("toggle-group", a`<calcite-action-group><calcite-dropdown overlay-positioning=fixed placement=bottom-start .scale=${o}><calcite-action class=tool-button .disabled=${this._effectiveDisabled} .icon=${s} .scale=${o} slot=trigger .text=${l ?? ""} .textEnabled=${i} title=${c ?? n}><calcite-icon icon=chevron-down scale=s></calcite-icon></calcite-action><calcite-dropdown-group>${e.map((d) => this.#p(d))}</calcite-dropdown-group></calcite-dropdown></calcite-action-group>`);
+  }
+  #p(e) {
+    return a`<calcite-dropdown-item .iconStart=${u[e]} .selected=${this.defaultOperationType === e} @calciteDropdownItemSelect=${() => this.defaultOperationType = e}>${this._getLabelForSelectionOperationType(e)}</calcite-dropdown-item>`;
+  }
+  #e(e, t = "selection", i = e, o = i) {
+    return this.#t({
+      active: this.activeOperation?.toolName === e,
+      disabled: this._effectiveDisabled,
+      icon: t,
+      onclick: () => this.toggleTool(e),
+      text: i,
+      title: o
+    });
+  }
+  #t(e) {
+    const { active: t, disabled: i, icon: o, onclick: s, text: l, title: c } = e, { showTextLabels: d, visualScale: f } = this;
+    return a`<calcite-action .active=${t} class=tool-button .disabled=${i} .icon=${o} @click=${s} .text=${l} .textEnabled=${d} title=${c ?? n} .scale=${f}></calcite-action>`;
+  }
+  render() {
+    return a`<div><calcite-action-bar expand-disabled .layout=${this.layout} overflow-actions-disabled .scale=${this.visualScale}>${this.#h()}${this.#o()}${this.#r()}</calcite-action-bar>${this.#i()}</div>`;
+  }
+}
+g("arcgis-selection-toolbar", S);
+export {
+  S as ArcgisSelectionToolbar
+};

package/dist/components/arcgis-selection-toolbar/index.js

@@ -0,0 +1,10 @@
+import "@esri/calcite-components/components/calcite-progress";
+import "@esri/calcite-components/components/calcite-action-group";
+import "@esri/calcite-components/components/calcite-chip";
+import "@esri/calcite-components/components/calcite-dropdown";
+import "@esri/calcite-components/components/calcite-action";
+import "@esri/calcite-components/components/calcite-icon";
+import "@esri/calcite-components/components/calcite-dropdown-group";
+import "@esri/calcite-components/components/calcite-dropdown-item";
+import "@esri/calcite-components/components/calcite-action-bar";
+export * from "./customElement.js";

package/dist/components/arcgis-selection-toolbar/types.d.ts

@@ -0,0 +1,8 @@
+import type { SelectionToolName } from "@arcgis/core/views/selection/types.js";
+
+/**
+ * Event emitted before a selection operation activates.
+ *
+ * @since 5.2
+ */
+export type SelectionToolbarBeforeActivateEvent = CustomEvent<{ toolName: SelectionToolName | null; }>;

package/dist/components/arcgis-shadow-cast/customElement.d.ts

@@ -138,7 +138,7 @@ export abstract class ArcgisShadowCast extends LitElement {
    *
    * _See also_
    *
-   * * [Date](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/Date)
+   * * [Date](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Date/Date)
    */
   get date(): Date;
   set date(value: Date | number | string);
@@ -516,8 +516,8 @@ export abstract class ArcgisShadowCast extends LitElement {
    */
   accessor utcOffset: number | null | undefined;
   /**
-   * The view associated with the component. 
-   *   > **Note:** The recommended approach is to fully migrate applications to use map and scene components and avoid using MapView and SceneView directly. However, if you are migrating a large application from widgets to components, you might prefer a more gradual transition. To support this use case, the SDK includes this `view` property which connects a component to a MapView or SceneView. Ultimately, once migration is complete, the arcgis-shadow-cast component will be associated with a map or scene component rather than using the `view` property.
+   * The view associated with the component.
+   * > **Note:** The recommended approach is to fully migrate applications to use map and scene components and avoid using MapView and SceneView directly. However, if you are migrating a large application from widgets to components, you might prefer a more gradual transition. To support this use case, the SDK includes this `view` property which connects a component to a MapView or SceneView. Ultimately, once migration is complete, the arcgis-shadow-cast component will be associated with a map or scene component rather than using the `view` property.
    */
   accessor view: SceneView | undefined;
   /**