@arcgis/map-components 4.33.0-next.13 → 4.33.0-next.132

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

@@ -1,74 +1,96 @@
 /// <reference types="@arcgis/core/interfaces.d.ts" />
 /// <reference types="../../index.d.ts" />
-import { Use } from '@arcgis/components-controllers';
+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: import('@arcgis/components-controllers').StencilLifecycles & {
-    manager: import('@arcgis/components-controllers').ControllerManager;
-    el: HTMLElement;
-    autoDestroyDisabled?: boolean;
-    destroy?: () => Promise<void>;
-} & Pick<Slice, never> & {
-    reactiveUtils?: typeof __esri.reactiveUtils;
-    state?: unknown;
-    viewModel?: __esri.SliceViewModel | undefined;
-    icon: Nil | string;
-    label: Nil | string;
-    referenceElement: ArcgisReferenceElement | Nil | string;
-    position: __esri.UIPosition;
-    arcgisReady: import('@arcgis/components-controllers').EventEmitter;
-    arcgisPropertyChange: import('@arcgis/components-controllers').EventEmitter<{
-        name: string;
-    }> | undefined;
-    el: HTMLElement & {
-        childElem?: HTMLElement & {
-            ownedBy?: HTMLElement;
-        };
-        view?: __esri.MapView | __esri.SceneView | Nil;
-    };
-    autoDestroyDisabled: boolean;
-    destroy: () => Promise<void>;
-}, options?: {
-    editConstructorProperties(props: __esri.SliceProperties | undefined): __esri.SliceProperties | Promise<__esri.SliceProperties | undefined> | undefined;
-} | undefined) => Slice;
-/** Slice component is a 3D analysis tool that can be used to reveal occluded content in a [SceneView](https://developers.arcgis.com/javascript/latest/api-reference/esri-views-SceneView.html).
+declare const useSliceViewModel: (component: LitElement & Pick<SliceViewModel, never> & import('../../controllers/useViewModel').ViewModelControllerUses<SliceViewModel>) => SliceViewModel;
+/**
+ * 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).
+ *
+ * [Read more...](https://developers.arcgis.com/javascript/latest/references/map-components/arcgis-slice/)
  */
 export declare class ArcgisSlice extends LitElement {
-    readonly analysis: __esri.SliceAnalysis;
+    /** Analysis data object. */
+    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;
+    /** @default false */
+    get hasVoxelLayers(): boolean;
     /**
      * 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"] | Nil;
     /** The component's default label. */
-    label: string;
+    label: string | undefined;
+    /** Replace localized message strings with your own strings. */
+    messageOverrides?: typeof this._messages._overrides;
+    /** @default "bottom-left" */
     position: __esri.UIPosition;
     referenceElement: ArcgisReferenceElement | Nil | string;
+    /**
+     * The shape used to slice elements in a 3D scene.
+     * Currently the only supported shape is a plane.
+     */
     shape: nullish | __esri.SlicePlane;
-    readonly state: "ready" | "disabled" | "slicing" | "sliced";
+    /**
+     * The view model's state.
+     *
+     * Value | Description
+     * ------------|-------------
+     * disabled | not ready yet
+     * ready | ready for slicing
+     * slicing | currently slicing
+     * sliced | finished slicing
+     */
+    state: "ready" | "disabled" | "excludingLayer" | "sliced" | "slicing";
+    /**
+     * Enable tilting the slice shape. If set to true, the slice shape will orient itself as best as
+     * possible to the surface under the cursor when first placing the shape. If set to false, the slice shape is
+     * restricted to be either horizontal or vertical.
+     *
+     * @default false
+     */
     tiltEnabled: boolean;
     clear(): Promise<void>;
-    /** Permanently destroy the component */
+    /** Permanently destroy the component. */
     destroy(): Promise<void>;
     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/components-controllers";
-import s from "@arcgis/core/widgets/Slice.js";
-import { LitElement as i, createEvent as a, noShadowRoot as o } from "@arcgis/lumina";
-import { m as l } from "../../chunks/useWidget.js";
-import { css as r } from "@lit/reactive-element/css-tag.js";
+import { c as w } from "../../chunks/runtime.js";
+import { html as r } from "lit-html";
+import { usePropertyChange as $ } from "@arcgis/lumina/controllers";
+import { LitElement as L, createEvent as b, noShadowRoot as M, safeClassMap as a } from "@arcgis/lumina";
+import { css as S } from "@lit/reactive-element/css-tag.js";
+import { m as E } from "../../chunks/useViewModel.js";
+import { A as C } from "../../chunks/AnalysisViewModel.js";
+import k from "@arcgis/core/analysis/SliceAnalysis.js";
+import { property as d, subclass as V } from "@arcgis/core/core/accessorSupport/decorators.js";
+import { u as G } from "../../chunks/useT9n.js";
+import { ignoreAbortErrors as A } from "@arcgis/core/core/promiseUtils.js";
+import { H as T } from "../../chunks/heading.js";
+import { g as x } from "../../chunks/globalCss.js";
+import { watch as D } 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.13 */
-const d = r`@layer{arcgis-slice{display:block}}`, h = l(s);
-class c extends i {
+v4.33.0-next.132 */
+const H = S`@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 O = Object.defineProperty, B = Object.getOwnPropertyDescriptor, o = (e, i, t, u) => {
+  for (var c = u > 1 ? void 0 : u ? B(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 && O(i, t, c), c;
+};
+const g = /* @__PURE__ */ new Set();
+let n = class extends C {
+  constructor(e) {
+    super(e), this._exludingLayers = null, this.supportedViewType = "3d", this.unsupportedErrorMessage = "SliceViewModel is only supported in 3D views.", g.add(this);
+  }
+  async pickLayerToExclude() {
+    const e = this.analysisView;
+    if (e) {
+      const i = super.start((t) => e.pickLayerToExclude(t));
+      return this._exludingLayers = i, i.finally(() => {
+        this._exludingLayers === i && (this._exludingLayers = null);
+      }), void await i.catch();
+    }
+  }
+  async place(e) {
+    return await this.analysisView?.place(e);
+  }
+  clearAnalysis() {
+    this.analysis.shape = null;
+  }
+  destroy() {
+    g.delete(this);
+  }
+  get state() {
+    return this.disabled || !this.ready ? "disabled" : this.operationState === "active" ? "slicing" : this.layersMode === "exclude" ? "excludingLayer" : this.analysis.valid ? "sliced" : "ready";
+  }
+  get shape() {
+    return this.analysis.shape;
+  }
+  set shape(e) {
+    this.analysis.shape = e;
+  }
+  get tiltEnabled() {
+    return this.analysis.tiltEnabled;
+  }
+  set tiltEnabled(e) {
+    this.analysis.tiltEnabled = e;
+  }
+  get layersMode() {
+    return this._exludingLayers ? "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;
+  }
+  /**
+   * Starts the interactive creation of a new slice, clearing the previous [shape](#shape).
+   */
+  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 k();
+  }
+};
+o([
+  d()
+], n.prototype, "_exludingLayers", 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([
+  V("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`
+}, P = E(n);
+class I extends L {
   constructor() {
-    super(...arguments), this.widget = h(this), this.viewModel = this.widget.viewModel, this.analysis = this.widget.analysis, this.autoDestroyDisabled = !1, this.excludeGroundSurface = this.viewModel.excludeGroundSurface, this.excludedLayers = this.viewModel.excludedLayers, this.headingLevel = this.widget.headingLevel, this.icon = this.widget.icon, this.label = this.widget.label, this.position = "bottom-left", this.shape = this.viewModel.shape, this.state = this.viewModel.state, this.tiltEnabled = this.viewModel.tiltEnabled, this.arcgisPropertyChange = t()("analysis", "state"), this.arcgisReady = a();
+    super(...arguments), this.viewModel = P(this), this._messages = G(), this._onNewSliceClick = () => {
+      A(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 = { analysis: 0, autoDestroyDisabled: 5, excludeGroundSurface: 5, excludedLayers: 0, headingLevel: 9, hasVoxelLayers: 32, icon: 3, label: 1, messageOverrides: 0, position: 1, referenceElement: 1, shape: 0, state: 3, tiltEnabled: 5 };
   }
   static {
-    this.shadowRootOptions = o;
+    this.shadowRootOptions = M;
   }
   static {
-    this.styles = d;
+    this.styles = H;
+  }
+  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(() => [
+      D(() => this._renderContainerNode(), () => this.requestUpdate())
+    ]);
+  }
+  render() {
+    return r`<div class=${a({
+      [s.base]: !0,
+      [x.widget]: !0,
+      [x.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, v = 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 && v ? r`<div class=${a(s.layerList)}>${T({ class: s.layerListHeading, level: this.headingLevel, children: i.excludedLayers })}${N({ layers: h.toArray(), excludeGroundSurface: f, onLayerClick: (_) => {
+      this.excludedLayers.remove(_);
+    }, 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 m(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}></calcite-action></calcite-list-item>`;
+}
+function N(e) {
+  const i = e.layers.map((t) => m({ uid: t.uid, title: t.title, onClick: () => e.onLayerClick(t), actionLabel: e.layerActionLabel }));
+  return e.excludeGroundSurface && i.push(m({ 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", I);
 export {
-  c as ArcgisSlice
+  I 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";

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

@@ -1,40 +1,35 @@
 /// <reference types="@arcgis/core/interfaces.d.ts" />
 /// <reference types="../../index.d.ts" />
-import { Use } from '@arcgis/components-controllers';
+import { Use } from '@arcgis/lumina/controllers';
 import { Nil } from '@arcgis/components-utils';
 import { default as Slider } from '@arcgis/core/widgets/Slider.js';
 import { PublicLitElement as LitElement, TargetedEvent } from '@arcgis/lumina';
 import { ArcgisReferenceElement } from '../../utils/component-utils';
 
-declare const useSliderWidget: (component: import('@arcgis/components-controllers').StencilLifecycles & {
-    manager: import('@arcgis/components-controllers').ControllerManager;
-    el: HTMLElement;
-    autoDestroyDisabled?: boolean;
-    destroy?: () => Promise<void>;
-} & Pick<Slider, never> & {
-    reactiveUtils?: typeof __esri.reactiveUtils;
+declare const useSliderWidget: (component: LitElement & Pick<Slider, "icon" | "label" | "viewModel" | "values" | "layout" | "tickConfigs" | "draggableSegmentsEnabled" | "effectiveMax" | "effectiveMin" | "labelInputsEnabled" | "max" | "min" | "precision" | "rangeLabelInputsEnabled" | "snapOnClickEnabled" | "steps" | "syncedSegmentsEnabled" | "thumbsConstrained"> & {
     state?: "ready" | "disabled" | "editing" | "dragging" | undefined;
     viewModel?: __esri.SliderViewModel | undefined;
+    closed?: boolean;
     icon: Nil | string;
     label: Nil | string;
     referenceElement: ArcgisReferenceElement | Nil | string;
     position: __esri.UIPosition;
-    arcgisReady: import('@arcgis/components-controllers').EventEmitter;
-    arcgisPropertyChange: import('@arcgis/components-controllers').EventEmitter<{
+    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;
+        view?: __esri.LinkChartView | __esri.MapView | __esri.SceneView | Nil;
     };
     autoDestroyDisabled: boolean;
     destroy: () => Promise<void>;
-}, options?: {
-    editConstructorProperties(props: __esri.SliderProperties | undefined): __esri.SliderProperties | Promise<__esri.SliderProperties | undefined> | undefined;
-} | undefined) => Slider;
+}) => Slider;
 /**
+ * [Read more...](https://developers.arcgis.com/javascript/latest/references/map-components/arcgis-slider/)
+ *
  * @internal
  */
 export declare class ArcgisSlider extends LitElement {
@@ -42,55 +37,199 @@ export declare class ArcgisSlider extends LitElement {
      * 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-slider/#destroy) method when you are done to
+     * prevent memory leaks.
+     *
+     * @default false
      */
     autoDestroyDisabled: boolean;
+    /**
+     * Indicates if the user can drag the segment between thumbs
+     * to update thumb positions.
+     *
+     * @default true
+     */
     draggableSegmentsEnabled: boolean;
+    /**
+     * When set, the user is restricted from moving slider thumbs to positions higher than
+     * this value.
+     *
+     * [Read more...](https://developers.arcgis.com/javascript/latest/api-reference/esri-widgets-Slider.html#effectiveMax)
+     */
     effectiveMax: number | nullish;
+    /**
+     * When set, the user is restricted from moving slider thumbs to positions less than
+     * this value.
+     *
+     * [Read more...](https://developers.arcgis.com/javascript/latest/api-reference/esri-widgets-Slider.html#effectiveMin)
+     */
     effectiveMin: number | nullish;
+    /**
+     * The HTML Element nodes representing the slider segment between the [min](https://developers.arcgis.com/javascript/latest/api-reference/esri-widgets-Slider.html#min) and [effectiveMin](https://developers.arcgis.com/javascript/latest/api-reference/esri-widgets-Slider.html#effectiveMin), and the segment between the
+     * [effectiveMax](https://developers.arcgis.com/javascript/latest/api-reference/esri-widgets-Slider.html#effectiveMax) and [max](https://developers.arcgis.com/javascript/latest/api-reference/esri-widgets-Slider.html#max).
+     *
+     * [Read more...](https://developers.arcgis.com/javascript/latest/api-reference/esri-widgets-Slider.html#effectiveSegmentElements)
+     */
     readonly effectiveSegmentElements: __esri.Collection<HTMLElement>;
     /**
-     * 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.
+     * Icon displayed in the widget's button.
+     *
+     * @see [Calcite Icons](https://developers.arcgis.com/calcite-design-system/icons/)
+     * @default "caret-double-horizontal"
      */
     icon: string;
-    /** The component's default label. */
+    /**
+     * The widget's default label.
+     *
+     * [Read more...](https://developers.arcgis.com/javascript/latest/api-reference/esri-widgets-Slider.html#label)
+     */
     label: string;
+    /**
+     * The HTML Element nodes representing [labels](https://developers.arcgis.com/javascript/latest/api-reference/esri-widgets-Slider.html#labels) attached to slider thumbs.
+     *
+     * [Read more...](https://developers.arcgis.com/javascript/latest/api-reference/esri-widgets-Slider.html#labelElements)
+     */
     readonly labelElements: __esri.Collection<HTMLElement>;
+    /**
+     * Indicates whether to enable editing input values via keyboard input
+     * when the user clicks a label.
+     *
+     * @default false
+     */
     labelInputsEnabled: boolean;
+    /**
+     * An array of strings associated with 'values' generated using an internal label formatter or
+     * the values returned from [labelFormatFunction](https://developers.arcgis.com/javascript/latest/api-reference/esri-widgets-Slider.html#labelFormatFunction).
+     *
+     * [Read more...](https://developers.arcgis.com/javascript/latest/api-reference/esri-widgets-Slider.html#labels)
+     */
     readonly labels: __esri.LabelInfos;
+    /**
+     * Determines the layout/orientation of the Slider widget.
+     *
+     * @default "horizontal"
+     */
     layout: "vertical" | "horizontal" | "horizontal-reversed" | "vertical-reversed";
+    /**
+     * The maximum possible data/thumb value of the slider.
+     *
+     * [Read more...](https://developers.arcgis.com/javascript/latest/api-reference/esri-widgets-Slider.html#max)
+     */
     max: number | nullish;
+    /**
+     * The HTML Element node representing the [max](https://developers.arcgis.com/javascript/latest/api-reference/esri-widgets-Slider.html#max) value label.
+     *
+     * [Read more...](https://developers.arcgis.com/javascript/latest/api-reference/esri-widgets-Slider.html#maxLabelElement)
+     */
     readonly maxLabelElement: HTMLElement | nullish;
+    /**
+     * The minimum possible data/thumb value of the slider.
+     *
+     * [Read more...](https://developers.arcgis.com/javascript/latest/api-reference/esri-widgets-Slider.html#min)
+     */
     min: number | nullish;
+    /**
+     * The HTML Element node representing the [min](https://developers.arcgis.com/javascript/latest/api-reference/esri-widgets-Slider.html#min) value label.
+     *
+     * [Read more...](https://developers.arcgis.com/javascript/latest/api-reference/esri-widgets-Slider.html#minLabelElement)
+     */
     readonly minLabelElement: HTMLElement | nullish;
+    /** @default "bottom-left" */
     position: __esri.UIPosition;
+    /**
+     * Defines how slider thumb values should be rounded.
+     *
+     * @default 4
+     */
     precision: number;
+    /**
+     * Indicates whether to enable editing range values via keyboard input
+     * when the user clicks a [min](https://developers.arcgis.com/javascript/latest/api-reference/esri-widgets-Slider.html#min) or [max](https://developers.arcgis.com/javascript/latest/api-reference/esri-widgets-Slider.html#max) label.
+     *
+     * @default false
+     */
     rangeLabelInputsEnabled: boolean;
     referenceElement: ArcgisReferenceElement | Nil | string;
+    /**
+     * The HTML Element nodes representing interactive slider segments.
+     *
+     * [Read more...](https://developers.arcgis.com/javascript/latest/api-reference/esri-widgets-Slider.html#segmentElements)
+     */
     readonly segmentElements: __esri.Collection<HTMLElement>;
+    /**
+     * Indicates if the closest thumb will snap to the clicked location on the track.
+     *
+     * @default true
+     */
     snapOnClickEnabled: boolean;
+    /**
+     * The current state of the widget.
+     *
+     * [Read more...](https://developers.arcgis.com/javascript/latest/api-reference/esri-widgets-Slider.html#state)
+     */
     readonly state: "ready" | "disabled" | "editing" | "dragging";
+    /**
+     * Sets steps, or intervals, on the slider that restrict user
+     * input to specific values.
+     *
+     * [Read more...](https://developers.arcgis.com/javascript/latest/api-reference/esri-widgets-Slider.html#steps)
+     */
     steps: number | nullish | number[];
+    /**
+     * When `true`, all segments will sync together in updating thumb values when the user drags any segment.
+     *
+     * @default false
+     */
     syncedSegmentsEnabled: boolean;
+    /**
+     * The HTML Element nodes representing slider thumbs.
+     *
+     * [Read more...](https://developers.arcgis.com/javascript/latest/api-reference/esri-widgets-Slider.html#thumbElements)
+     */
     readonly thumbElements: __esri.Collection<HTMLElement>;
+    /**
+     * When `false`, the user can freely move any slider thumb to any
+     * position along the track.
+     *
+     * @default true
+     */
     thumbsConstrained: boolean;
+    /**
+     * When set, renders ticks along the slider track.
+     *
+     * [Read more...](https://developers.arcgis.com/javascript/latest/api-reference/esri-widgets-Slider.html#tickConfigs)
+     */
     tickConfigs: __esri.TickConfig[];
+    /**
+     * The HTML Element nodes representing slider ticks and their associated labels.
+     *
+     * [Read more...](https://developers.arcgis.com/javascript/latest/api-reference/esri-widgets-Slider.html#tickElements)
+     */
     readonly tickElements: __esri.Collection<__esri.Collection<__esri.TickElementGroup>>;
+    /**
+     * The HTML Element node representing the slider track.
+     *
+     * [Read more...](https://developers.arcgis.com/javascript/latest/api-reference/esri-widgets-Slider.html#trackElement)
+     */
     readonly trackElement: HTMLElement | nullish;
+    /**
+     * An array of numbers representing absolute thumb positions on the slider.
+     *
+     * [Read more...](https://developers.arcgis.com/javascript/latest/api-reference/esri-widgets-Slider.html#values)
+     */
     values: nullish | number[];
-    /** Permanently destroy the component */
+    /** Permanently destroy the component. */
     destroy(): Promise<void>;
     readonly arcgisMaxChange: TargetedEvent<this, __esri.SliderMaxChangeEvent>;
     readonly arcgisMaxClick: TargetedEvent<this, __esri.SliderMaxClickEvent>;
     readonly arcgisMinChange: TargetedEvent<this, __esri.SliderMinChangeEvent>;
     readonly arcgisMinClick: TargetedEvent<this, __esri.SliderMinClickEvent>;
+    /** Emitted when the value of a property is changed. Use this to listen to changes to properties. */
     readonly arcgisPropertyChange: TargetedEvent<this, {
         name: "state";
     }>;
-    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>;
     readonly arcgisSegmentClick: TargetedEvent<this, __esri.SliderSegmentClickEvent>;
     readonly arcgisSegmentDrag: TargetedEvent<this, __esri.SliderSegmentDragEvent>;
     readonly arcgisThumbChange: TargetedEvent<this, __esri.SliderThumbChangeEvent>;

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

@@ -1,13 +1,13 @@
 import { c as i } from "../../chunks/runtime.js";
-import { usePropertyChange as s } from "@arcgis/components-controllers";
-import { reEmitEvent as t } from "@arcgis/components-controllers/accessor";
+import { usePropertyChange as s } from "@arcgis/lumina/controllers";
+import { reEmitEvent as t } from "@arcgis/lumina/controllers/accessor";
 import n from "@arcgis/core/widgets/Slider.js";
 import { LitElement as a, createEvent as l, noShadowRoot as h } from "@arcgis/lumina";
 import { m as g } from "../../chunks/useWidget.js";
 import { css as m } from "@lit/reactive-element/css-tag.js";
 /*! All material copyright Esri, All Rights Reserved, unless otherwise specified.
 See https://js.arcgis.com/4.33/esri/copyright.txt for details.
-v4.33.0-next.13 */
+v4.33.0-next.132 */
 const c = m`@layer{arcgis-slider{min-width:200px;min-height:25px}}`, r = g(n);
 class d extends a {
   constructor() {
@@ -22,9 +22,6 @@ class d extends a {
   static {
     this.styles = c;
   }
-  // #endregion
-  // #region Public Methods
-  /** Permanently destroy the component */
   async destroy() {
     await this.manager.destroy();
   }