@geoscene/map-components 4.33.18

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

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

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

@@ -0,0 +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/geoscene-slice/index.js

@@ -0,0 +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/geoscene-slider/customElement.d.ts

@@ -0,0 +1,242 @@
+/// <reference types="@geoscene/core/interfaces.d.ts" />
+/// <reference types="../../index.d.ts" />
+import { Use } from '@arcgis/lumina/controllers';
+import { default as Slider } from '@geoscene/core/widgets/Slider.js';
+import { PublicLitElement as LitElement, TargetedEvent } from '@arcgis/lumina';
+import { GeosceneReferenceElement } from '../../utils/component-utils';
+
+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?: __geoscene.SliderViewModel | 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>;
+}) => Slider;
+/**
+ * [Read more...](https://doc.geoscene.cn/javascript/4.33/references/map-components/geoscene-slider/)
+ *
+ * @internal
+ */
+export declare class GeosceneSlider 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](https://doc.geoscene.cn/javascript/4.33/references/map-components/geoscene-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://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-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://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-widgets-Slider.html#effectiveMin)
+     */
+    effectiveMin: number | nullish;
+    /**
+     * The HTML Element nodes representing the slider segment between the [min](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-widgets-Slider.html#min) and [effectiveMin](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-widgets-Slider.html#effectiveMin), and the segment between the
+     * [effectiveMax](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-widgets-Slider.html#effectiveMax) and [max](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-widgets-Slider.html#max).
+     *
+     * [Read more...](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-widgets-Slider.html#effectiveSegmentElements)
+     */
+    readonly effectiveSegmentElements: __geoscene.Collection<HTMLElement>;
+    /**
+     * 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 "caret-double-horizontal"
+     */
+    icon: string;
+    /**
+     * The widget's default label.
+     *
+     * [Read more...](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-widgets-Slider.html#label)
+     */
+    label: string;
+    /**
+     * The HTML Element nodes representing [labels](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-widgets-Slider.html#labels) attached to slider thumbs.
+     *
+     * [Read more...](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-widgets-Slider.html#labelElements)
+     */
+    readonly labelElements: __geoscene.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://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-widgets-Slider.html#labelFormatFunction).
+     *
+     * [Read more...](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-widgets-Slider.html#labels)
+     */
+    readonly labels: __geoscene.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://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-widgets-Slider.html#max)
+     */
+    max: number | nullish;
+    /**
+     * The HTML Element node representing the [max](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-widgets-Slider.html#max) value label.
+     *
+     * [Read more...](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-widgets-Slider.html#maxLabelElement)
+     */
+    readonly maxLabelElement: HTMLElement | nullish;
+    /**
+     * The minimum possible data/thumb value of the slider.
+     *
+     * [Read more...](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-widgets-Slider.html#min)
+     */
+    min: number | nullish;
+    /**
+     * The HTML Element node representing the [min](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-widgets-Slider.html#min) value label.
+     *
+     * [Read more...](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-widgets-Slider.html#minLabelElement)
+     */
+    readonly minLabelElement: HTMLElement | nullish;
+    /** @default "bottom-left" */
+    position: __geoscene.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://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-widgets-Slider.html#min) or [max](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-widgets-Slider.html#max) label.
+     *
+     * @default false
+     */
+    rangeLabelInputsEnabled: boolean;
+    /**
+     * 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 HTML Element nodes representing interactive slider segments.
+     *
+     * [Read more...](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-widgets-Slider.html#segmentElements)
+     */
+    readonly segmentElements: __geoscene.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 component. */
+    readonly state: "ready" | "disabled" | "editing" | "dragging";
+    /**
+     * Sets steps, or intervals, on the slider that restrict user
+     * input to specific values.
+     *
+     * [Read more...](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-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://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-widgets-Slider.html#thumbElements)
+     */
+    readonly thumbElements: __geoscene.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://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-widgets-Slider.html#tickConfigs)
+     */
+    tickConfigs: __geoscene.TickConfig[];
+    /**
+     * The HTML Element nodes representing slider ticks and their associated labels.
+     *
+     * [Read more...](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-widgets-Slider.html#tickElements)
+     */
+    readonly tickElements: __geoscene.Collection<__geoscene.Collection<__geoscene.TickElementGroup>>;
+    /**
+     * The HTML Element node representing the slider track.
+     *
+     * [Read more...](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-widgets-Slider.html#trackElement)
+     */
+    readonly trackElement: HTMLElement | nullish;
+    /**
+     * An array of numbers representing absolute thumb positions on the slider.
+     *
+     * [Read more...](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-widgets-Slider.html#values)
+     */
+    values: nullish | number[];
+    /** Permanently destroy the component. */
+    destroy(): Promise<void>;
+    readonly geosceneMaxChange: TargetedEvent<this, __geoscene.SliderMaxChangeEvent>;
+    readonly geosceneMaxClick: TargetedEvent<this, __geoscene.SliderMaxClickEvent>;
+    readonly geosceneMinChange: TargetedEvent<this, __geoscene.SliderMinChangeEvent>;
+    readonly geosceneMinClick: TargetedEvent<this, __geoscene.SliderMinClickEvent>;
+    /** 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 geosceneSegmentClick: TargetedEvent<this, __geoscene.SliderSegmentClickEvent>;
+    readonly geosceneSegmentDrag: TargetedEvent<this, __geoscene.SliderSegmentDragEvent>;
+    readonly geosceneThumbChange: TargetedEvent<this, __geoscene.SliderThumbChangeEvent>;
+    readonly geosceneThumbClick: TargetedEvent<this, __geoscene.SliderThumbClickEvent>;
+    readonly geosceneThumbDrag: TargetedEvent<this, __geoscene.SliderThumbDragEvent>;
+    readonly geosceneTickClick: TargetedEvent<this, __geoscene.SliderTickClickEvent>;
+    readonly geosceneTrackClick: TargetedEvent<this, __geoscene.SliderTrackClickEvent>;
+}
+export {};

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

@@ -0,0 +1,32 @@
+import { c as i } from "../../chunks/runtime.js";
+import { usePropertyChange as s } from "@arcgis/lumina/controllers";
+import { reEmitEvent as t } from "@arcgis/lumina/controllers/accessor";
+import n from "@geoscene/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 GeoScene, All Rights Reserved, unless otherwise specified.
+See https://js.geoscene.cn/4.33/geoscene/copyright.txt for details.
+v4.33.18 */
+const c = m`@layer{geoscene-slider{min-width:200px;min-height:25px}}`, r = g(n);
+class d extends a {
+  constructor() {
+    super(...arguments), this.widget = r(this), this.viewModel = this.widget.viewModel, this.autoDestroyDisabled = !1, this.draggableSegmentsEnabled = this.widget.draggableSegmentsEnabled, this.effectiveMax = this.widget.effectiveMax, this.effectiveMin = this.widget.effectiveMin, this.effectiveSegmentElements = this.widget.effectiveSegmentElements, this.icon = this.widget.icon, this.label = this.widget.label, this.labelElements = this.widget.labelElements, this.labelInputsEnabled = this.widget.labelInputsEnabled, this.labels = this.widget.labels, this.layout = this.widget.layout, this.max = this.widget.max, this.maxLabelElement = this.widget.maxLabelElement, this.min = this.widget.min, this.minLabelElement = this.widget.minLabelElement, this.position = "bottom-left", this.precision = this.widget.precision, this.rangeLabelInputsEnabled = this.widget.rangeLabelInputsEnabled, this.segmentElements = this.widget.segmentElements, this.snapOnClickEnabled = this.widget.snapOnClickEnabled, this.state = this.widget.state, this.steps = this.widget.steps, this.syncedSegmentsEnabled = this.widget.syncedSegmentsEnabled, this.thumbElements = this.widget.thumbElements, this.thumbsConstrained = this.widget.thumbsConstrained, this.tickConfigs = this.widget.tickConfigs, this.tickElements = this.widget.tickElements, this.trackElement = this.widget.trackElement, this.values = this.widget.values, this.geosceneMaxChange = t(() => this.widget, "max-change"), this.geosceneMaxClick = t(() => this.widget, "max-click"), this.geosceneMinChange = t(() => this.widget, "min-change"), this.geosceneMinClick = t(() => this.widget, "min-click"), this.geoscenePropertyChange = s()("state"), this.geosceneReady = l(), this.geosceneSegmentClick = t(() => this.widget, "segment-click"), this.geosceneSegmentDrag = t(() => this.widget, "segment-drag"), this.geosceneThumbChange = t(() => this.widget, "thumb-change"), this.geosceneThumbClick = t(() => this.widget, "thumb-click"), this.geosceneThumbDrag = t(() => this.widget, "thumb-drag"), this.geosceneTickClick = t(() => this.widget, "tick-click"), this.geosceneTrackClick = t(() => this.widget, "track-click");
+  }
+  static {
+    this.properties = { autoDestroyDisabled: 5, draggableSegmentsEnabled: 5, effectiveMax: 9, effectiveMin: 9, effectiveSegmentElements: 0, icon: 1, label: 1, labelElements: 0, labelInputsEnabled: 5, labels: 0, layout: 1, max: 9, maxLabelElement: 0, min: 9, minLabelElement: 0, position: 1, precision: 9, rangeLabelInputsEnabled: 5, referenceElement: 1, segmentElements: 0, snapOnClickEnabled: 5, state: 3, steps: [9, { converter: (e) => typeof e == "string" ? e.split(",").map(Number) : e }], syncedSegmentsEnabled: 5, thumbElements: 0, thumbsConstrained: 5, tickConfigs: 0, tickElements: 0, trackElement: 0, values: [1, { converter: (e) => typeof e == "string" ? e.split(",").map(Number) : e }] };
+  }
+  static {
+    this.shadowRootOptions = h;
+  }
+  static {
+    this.styles = c;
+  }
+  async destroy() {
+    await this.manager.destroy();
+  }
+}
+i("geoscene-slider", d);
+export {
+  d as GeosceneSlider
+};

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

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

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

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

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

@@ -0,0 +1,122 @@
+/// <reference types="@geoscene/core/interfaces.d.ts" />
+/// <reference types="../../index.d.ts" />
+import { Use } from '@arcgis/lumina/controllers';
+import { default as SwipeViewModel } from '@geoscene/core/widgets/Swipe/SwipeViewModel.js';
+import { JsxNode, PublicLitElement as LitElement, TargetedEvent } from '@arcgis/lumina';
+import { GeosceneReferenceElement } from '../../utils/component-utils';
+
+declare const useSwipeViewModel: (component: LitElement & Pick<SwipeViewModel, never> & import('../../controllers/useViewModel').ViewModelControllerUses<SwipeViewModel>) => SwipeViewModel;
+/**
+ * The Swipe component provides a tool to show a portion of a layer or layers
+ * on top of a map. Layers can be swiped vertically or horizontally to easily
+ * compare two layers or see what is underneath a layer.
+ *
+ * To use the Swipe component, set the `leadingLayers` and `trailingLayers`
+ * properties to determine what will be compared on either side of the component. If one of these properties
+ * is not set, then the Swipe component will overlay the existing map.
+ *
+ * **Known limitations**
+ *
+ * - This component is not currently supported within a Scene component.
+ *
+ * [Read more...](https://doc.geoscene.cn/javascript/4.33/references/map-components/geoscene-swipe/)
+ */
+export declare class GeosceneSwipe 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](https://doc.geoscene.cn/javascript/4.33/references/map-components/geoscene-swipe/#destroy) method when you are done to
+     * prevent memory leaks.
+     *
+     * @default false
+     */
+    autoDestroyDisabled: boolean;
+    /**
+     * The direction the Swipe component moves across the view.
+     * If `"horizontal"`, the component will move left and right and
+     * if `"vertical"`, the component will move up and down.
+     *
+     * @default "horizontal"
+     */
+    direction: "vertical" | "horizontal";
+    /**
+     * When `true`, sets the component to a disabled state so the user cannot interact with it.
+     *
+     * @default false
+     */
+    disabled: boolean;
+    /**
+     * When `true`, the divider between the leading and trailing layers will be hidden.
+     *
+     * @default false
+     */
+    hideDivider: boolean;
+    /**
+     * When `true`, the handle from which you drag the component will be hidden.
+     *
+     * @default false
+     */
+    hideHandle: 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 "compare"
+     */
+    icon?: string;
+    /**
+     * The component's default label.
+     *
+     * @default "Swipe"
+     */
+    label?: string;
+    /** A collection of layers that will show on the left or top side of the Swipe component. */
+    leadingLayers: __geoscene.Collection<__geoscene.Layer>;
+    /**
+     * Replace localized message strings with your own strings.
+     *
+     * _**Note**: Individual message keys may change between releases._
+     */
+    messageOverrides?: typeof this.messages._overrides;
+    /** @default "manual" */
+    position: __geoscene.UIPosition;
+    /**
+     * The position of the Swipe component. This determines what percentage
+     * of the view will be taken up by the [leadingLayers](#leadingLayers).
+     *
+     * @default 25
+     */
+    swipePosition: number;
+    /**
+     * 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 current state of the component.
+     *
+     * @default "disabled"
+     */
+    readonly state: "ready" | "disabled";
+    /** A collection of layers that will show on the right or bottom side of the Swipe component. */
+    trailingLayers: __geoscene.Collection<__geoscene.Layer>;
+    /** Permanently destroy the component. */
+    destroy(): 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";
+    }>;
+    /** 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: Partial<{
+        componentLabel: string;
+        dragLabel: string;
+    }> & import('@arcgis/lumina/controllers').T9nMeta<{
+        componentLabel: string;
+        dragLabel: string;
+    }>;
+}
+export {};