@geoscene/map-components 4.33.18

package/dist/components/geoscene-utility-network-validate-topology/index.js

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

package/dist/components/geoscene-value-picker/customElement.d.ts

@@ -0,0 +1,151 @@
+/// <reference types="@geoscene/core/interfaces.d.ts" />
+/// <reference types="../../index.d.ts" />
+import { Use } from '@arcgis/lumina/controllers';
+import { default as ValuePicker } from '@geoscene/core/widgets/ValuePicker.js';
+import { PublicLitElement as LitElement, TargetedEvent } from '@arcgis/lumina';
+import { GeosceneReferenceElement } from '../../utils/component-utils';
+
+declare const useValuePickerWidget: (component: LitElement & Pick<ValuePicker, "icon" | "label" | "component" | "values" | "caption" | "layout" | "canNext" | "canPlay" | "canPrevious" | "loop" | "playRate"> & {
+    state?: unknown;
+    viewModel?: unknown;
+    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>;
+}) => ValuePicker;
+/**
+ * [Read more...](https://doc.geoscene.cn/javascript/4.33/references/map-components/geoscene-value-picker/)
+ *
+ * @internal
+ */
+export declare class GeosceneValuePicker 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-value-picker/#destroy) method when you are done to
+     * prevent memory leaks.
+     *
+     * @default false
+     */
+    autoDestroyDisabled: boolean;
+    /**
+     * Returns `true` if the ValuePicker can be advanced to the next position.
+     *
+     * [Read more...](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-widgets-ValuePicker.html#canNext)
+     *
+     * @default false
+     */
+    canNext: boolean;
+    /**
+     * Returns `true` if the ValuePicker can be played.
+     *
+     * [Read more...](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-widgets-ValuePicker.html#canPlay)
+     *
+     * @default false
+     */
+    canPlay: boolean;
+    /**
+     * Returns `true` if the ValuePicker can moved to the previous item.
+     *
+     * [Read more...](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-widgets-ValuePicker.html#canPrevious)
+     *
+     * @default false
+     */
+    canPrevious: boolean;
+    /**
+     * An optional caption that appears on the ValuePicker widget to give context for the user.
+     *
+     * @default null
+     */
+    caption: string | nullish;
+    /**
+     * An optional component for presenting and managing data.
+     *
+     * @default null
+     */
+    component: nullish | __geoscene.ValuePickerCollection | __geoscene.ValuePickerCombobox | __geoscene.ValuePickerLabel | __geoscene.ValuePickerSlider;
+    /** @default false */
+    hideNextButton: boolean | undefined;
+    /** @default false */
+    hidePlayButton: boolean | undefined;
+    /** @default false */
+    hidePreviousButton: boolean | undefined;
+    /**
+     * 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 "list-rectangle"
+     */
+    icon: string;
+    /**
+     * The widget's label.
+     *
+     * [Read more...](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-widgets-Widget.html#label)
+     */
+    label: string | nullish;
+    /**
+     * Indicates if the widget should be orientated horizontally (default) or vertically.
+     *
+     * @default "horizontal"
+     */
+    layout: "vertical" | "horizontal";
+    /**
+     * If true, playback will restart when it reaches the end.
+     *
+     * @default false
+     */
+    loop: boolean;
+    /**
+     * The pause, in milliseconds between playback advancement.
+     *
+     * @default 1000
+     */
+    playRate: number;
+    /** @default "bottom-left" */
+    position: __geoscene.UIPosition;
+    /**
+     * By assigning the `id` attribute of the Map or Scene component to this property, you can position a child component anywhere in the DOM while still maintaining a connection to the Map or Scene.
+     *
+     * @see [Associate components with a Map or Scene component](https://doc.geoscene.cn/javascript/4.33/programming-patterns/#associate-components-with-a-map-or-scene-component)
+     */
+    referenceElement?: GeosceneReferenceElement | string;
+    /**
+     * The current value of the ValuePicker.
+     *
+     * @default null
+     */
+    values: any[] | nullish | number[] | string[];
+    /** Permanently destroy the component. */
+    destroy(): Promise<void>;
+    next(): Promise<void>;
+    pause(): Promise<void>;
+    play(): Promise<void>;
+    previous(): Promise<void>;
+    readonly geosceneAnimate: TargetedEvent<this, __geoscene.ValuePickerAnimateEvent>;
+    readonly geosceneNext: TargetedEvent<this, __geoscene.ValuePickerNextEvent>;
+    readonly geoscenePause: TargetedEvent<this, __geoscene.ValuePickerPauseEvent>;
+    readonly geoscenePlay: TargetedEvent<this, __geoscene.ValuePickerPlayEvent>;
+    readonly geoscenePrevious: TargetedEvent<this, __geoscene.ValuePickerPreviousEvent>;
+    /** Emitted when the value of a property is changed. Use this to listen to changes to properties. */
+    readonly geoscenePropertyChange: TargetedEvent<this, {
+        name: "values";
+    }>;
+    /** Emitted when the component associated with a map or scene view is is ready to be interacted with. */
+    readonly geosceneReady: TargetedEvent<this, void>;
+}
+export {};

package/dist/components/geoscene-value-picker/customElement.js

@@ -0,0 +1,44 @@
+import { c as i } from "../../chunks/runtime.js";
+import { usePropertyChange as e } from "@arcgis/lumina/controllers";
+import { reEmitEvent as t } from "@arcgis/lumina/controllers/accessor";
+import s from "@geoscene/core/widgets/ValuePicker.js";
+import { LitElement as a, createEvent as o, noShadowRoot as n } from "@arcgis/lumina";
+import { m as h } from "../../chunks/useWidget.js";
+import { css as r } 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 l = r`@layer{geoscene-value-picker{display:block}}`, c = h(s);
+class u extends a {
+  constructor() {
+    super(...arguments), this.widget = c(this), this.autoDestroyDisabled = !1, this.canNext = this.widget.canNext, this.canPlay = this.widget.canPlay, this.canPrevious = this.widget.canPrevious, this.caption = this.widget.caption, this.component = this.widget.component, this.hideNextButton = this.widget.visibleElements.nextButton, this.hidePlayButton = this.widget.visibleElements.playButton, this.hidePreviousButton = this.widget.visibleElements.previousButton, this.icon = this.widget.icon, this.label = this.widget.label, this.layout = this.widget.layout, this.loop = this.widget.loop, this.playRate = this.widget.playRate, this.position = "bottom-left", this.values = this.widget.values, this.geosceneAnimate = t(() => this.widget, "animate"), this.geosceneNext = t(() => this.widget, "next"), this.geoscenePause = t(() => this.widget, "pause"), this.geoscenePlay = t(() => this.widget, "play"), this.geoscenePrevious = t(() => this.widget, "previous"), this.geoscenePropertyChange = e()("values"), this.geosceneReady = o();
+  }
+  static {
+    this.properties = { autoDestroyDisabled: 5, canNext: 7, canPlay: 7, canPrevious: 7, caption: 1, component: 0, hideNextButton: 5, hidePlayButton: 5, hidePreviousButton: 5, icon: 1, label: 1, layout: 1, loop: 5, playRate: 9, position: 1, referenceElement: 1, values: 0 };
+  }
+  static {
+    this.shadowRootOptions = n;
+  }
+  static {
+    this.styles = l;
+  }
+  async destroy() {
+    await this.manager.destroy();
+  }
+  async next() {
+    this.widget?.next();
+  }
+  async pause() {
+    this.widget?.pause();
+  }
+  async play() {
+    this.widget?.play();
+  }
+  async previous() {
+    this.widget?.previous();
+  }
+}
+i("geoscene-value-picker", u);
+export {
+  u as GeosceneValuePicker
+};

package/dist/components/geoscene-value-picker/index.d.ts

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

package/dist/components/geoscene-value-picker/index.js

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

package/dist/components/geoscene-version-management/customElement.d.ts

@@ -0,0 +1,184 @@
+/// <reference types="@geoscene/core/interfaces.d.ts" />
+/// <reference types="../../index.d.ts" />
+import { Use } from '@arcgis/lumina/controllers';
+import { default as VersionManagementViewModel } from '@geoscene/core/widgets/VersionManagement/VersionManagementViewModel.js';
+import { JsxNode, ToEvents, PublicLitElement as LitElement, TargetedEvent } from '@arcgis/lumina';
+import { GeosceneReferenceElement } from '../../utils/component-utils';
+import { GeosceneVersionManagementServiceItem } from '../geoscene-version-management-service-item/customElement.js';
+
+declare const useVersionManagementViewModel: (component: LitElement & Pick<VersionManagementViewModel, never> & import('../../controllers/useViewModel').ViewModelControllerUses<VersionManagementViewModel>) => VersionManagementViewModel;
+type VersioningStateEventType = "version-changed" | "version-created" | "version-deleted" | "version-switched";
+export interface VersioningStateEvent {
+    type?: VersioningStateEventType;
+    versionIdentifier?: __geoscene.VersionInfoVersionIdentifier;
+    versioningState?: __geoscene.VersioningState;
+}
+export type InitialVersionInfo = {
+    url: string;
+    name: string;
+};
+/**
+ * The Version Management component allows users to view available versions, change versions, delete versions, and alter versions.
+ * The [View](https://doc.geoscene.cn/javascript/4.33/api-reference/geoscene-views-View.html) will update to match the features on the selected version.
+ * To learn more about version management please visit the [versioning guide doc](https://doc.geoscene.cn/javascript/4.33/utility-network/version-management-service/).
+ *
+ * > The Version Management component does not support proxied feature services or feature services that utilize stored credentials.
+ *
+ * Note: Sign in to access the data in this sample, U/P: `viewer01`/`I68VGU^nMurF`
+ *
+ * [Read more...](https://doc.geoscene.cn/javascript/4.33/references/map-components/geoscene-version-management/)
+ */
+export declare class GeosceneVersionManagement extends LitElement {
+    /** @default false */
+    allowEditingDisabled: boolean;
+    /**
+     * 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-version-management/#destroy) method when you are done to
+     * prevent memory leaks.
+     *
+     * @default false
+     */
+    autoDestroyDisabled: boolean;
+    /** @default false */
+    closable: boolean;
+    /**
+     * The `initialVersionInfos` property enables users to initialize the Version Management component with a predefined set of versions.
+     * By providing an array of `InitialVersionInfo`, the component displays a specified version for each feature service upon initialization.
+     */
+    get initialVersionInfos(): InitialVersionInfo[];
+    set initialVersionInfos(value: InitialVersionInfo[]);
+    icon?: string;
+    label?: string;
+    /**
+     * Replace localized message strings with your own strings.
+     *
+     * _**Note**: Individual message keys may change between releases._
+     */
+    messageOverrides?: typeof this.messages._overrides;
+    mode?: string;
+    /**
+     * Specifies the number of versions displayed on each page of the Version Management component.
+     *
+     * @default 5
+     */
+    pageSize: number;
+    /** @default "top-right" */
+    position: __geoscene.UIPosition;
+    /**
+     * By assigning the `id` attribute of the Map or Scene component to this property, you can position a child component anywhere in the DOM while still maintaining a connection to the Map or Scene.
+     *
+     * @see [Associate components with a Map or Scene component](https://doc.geoscene.cn/javascript/4.33/programming-patterns/#associate-components-with-a-map-or-scene-component)
+     */
+    referenceElement?: GeosceneReferenceElement | string;
+    /** The current state of the component. */
+    readonly state: "ready" | "loading" | "disabled" | "executing" | "failed" | "success";
+    /**
+     * This class provides functionality for managing versions in a versioned geodatabase.
+     * In the event that the Version Management component is destroyed, the VersioningStates can be utilized to maintain the current state of the Version Management component.
+     * The Version Management component can be reinitialized using a `Collection<VersioningState>`, or a predefined `Collection<VersioningState>` can be provided during the initial instantiation of the Version Management component.
+     */
+    versioningStates: __geoscene.Collection<__geoscene.VersioningState>;
+    /** Permanently destroy the component. */
+    destroy(): Promise<void>;
+    /** Emitted when the component associated with a map or scene view is is ready to be interacted with. */
+    readonly geosceneReady: TargetedEvent<this, void>;
+    readonly geosceneVersioningStateChanged: TargetedEvent<this, VersioningStateEvent>;
+    private messages: {
+        label: string;
+        actions: {
+            cancelSave: string;
+            deleteVersion: string;
+            editVersion: string;
+            newVersion: string;
+            refreshVersions: string;
+            saveVersion: string;
+            searchVersions: string;
+            switchToVersion: string;
+        };
+        accessLevels: {
+            private: string;
+            protected: string;
+            public: string;
+        };
+        executionErrors: {
+            invalidVersionName: string;
+            noAdvancedEditingUserTypeExtension: string;
+            noFeatureServiceFound: string;
+            notValidEnterpriseVersion: string;
+            noVersionManagementServiceFound: string;
+        };
+        headers: {
+            currentVersion: string;
+            manageVersions: string;
+            filterVersions: string;
+            versionProperties: string;
+            invalidInitialVersion: string;
+            invalidInitialFeatureService: string;
+        };
+        input: {
+            versionAccess: string;
+            versionDescription: string;
+            versionName: string;
+            versionOwner: string;
+        };
+        labels: {
+            versionList: string;
+        };
+        loadErrors: {
+            invalidInitialVersion: string;
+            invalidInitialFeatureService: string;
+            noFeatureServices: string;
+            noViewProperty: string;
+        };
+    } & import('@arcgis/lumina/controllers').T9nMeta<{
+        label: string;
+        actions: {
+            cancelSave: string;
+            deleteVersion: string;
+            editVersion: string;
+            newVersion: string;
+            refreshVersions: string;
+            saveVersion: string;
+            searchVersions: string;
+            switchToVersion: string;
+        };
+        accessLevels: {
+            private: string;
+            protected: string;
+            public: string;
+        };
+        executionErrors: {
+            invalidVersionName: string;
+            noAdvancedEditingUserTypeExtension: string;
+            noFeatureServiceFound: string;
+            notValidEnterpriseVersion: string;
+            noVersionManagementServiceFound: string;
+        };
+        headers: {
+            currentVersion: string;
+            manageVersions: string;
+            filterVersions: string;
+            versionProperties: string;
+            invalidInitialVersion: string;
+            invalidInitialFeatureService: string;
+        };
+        input: {
+            versionAccess: string;
+            versionDescription: string;
+            versionName: string;
+            versionOwner: string;
+        };
+        labels: {
+            versionList: string;
+        };
+        loadErrors: {
+            invalidInitialVersion: string;
+            invalidInitialFeatureService: string;
+            noFeatureServices: string;
+            noViewProperty: string;
+        };
+    }>;
+}
+export {};

package/dist/components/geoscene-version-management/customElement.js

@@ -0,0 +1,238 @@
+import { c as L } from "../../chunks/runtime.js";
+import { once as P, watch as _ } from "@geoscene/core/core/reactiveUtils.js";
+import C from "@geoscene/core/widgets/VersionManagement/VersionManagementViewModel.js";
+import { LitElement as N, createEvent as u, noShadowRoot as y, safeClassMap as M } from "@arcgis/lumina";
+import { render as F, html as m } from "lit-html";
+import { createRef as k, ref as b } from "lit-html/directives/ref.js";
+import { u as $ } from "../../chunks/useT9n.js";
+import { m as A } from "../../chunks/useViewModel.js";
+import { css as T } 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 O = T`@layer{.geoscene-version-management{.component-container-flow{width:300px}.invalid-initial-version-notice{margin-bottom:1rem}.service-items-panel{z-index:unset!important}calcite-block{margin:0}}}`, R = A(C), I = "map-components:version-management";
+class U extends N {
+  constructor() {
+    super(...arguments), this.flowElement = k(), this.messages = $({ blocking: !0 }), this.viewModel = R(this), this._isInitialVersionInvalid = /* @__PURE__ */ new Map(), this._initialVersionInfos = [], this._showInvalidFeatureServiceNotice = !1, this.allowEditingDisabled = !1, this.autoDestroyDisabled = !1, this.closable = !1, this.pageSize = 5, this.position = "top-right", this.state = this.viewModel.state, this.versioningStates = this.viewModel.versioningStates, this.geosceneReady = u(), this.geosceneVersioningStateChanged = u();
+  }
+  static {
+    this.properties = { versionList: 16, _showInvalidFeatureServiceNotice: 16, allowEditingDisabled: 5, autoDestroyDisabled: 5, closable: 7, initialVersionInfos: 0, icon: 1, label: 3, messageOverrides: 0, mode: 1, pageSize: 9, position: 1, referenceElement: 1, state: 3, versioningStates: 0 };
+  }
+  static {
+    this.styles = O;
+  }
+  static {
+    this.shadowRootOptions = y;
+  }
+  get initialVersionInfos() {
+    return this._initialVersionInfos;
+  }
+  set initialVersionInfos(e) {
+    this._initialVersionInfos = e.map((i) => ({
+      ...i,
+      url: this._removeTrailingSlash(i.url)
+    }));
+  }
+  async destroy() {
+    await this.manager.destroy();
+  }
+  async load() {
+    P(() => this.viewModel.state === "ready").then(() => {
+      this.initialVersionInfos.forEach((e) => {
+        try {
+          this._changeToInitialVersion(e);
+        } catch (i) {
+          console.error(i);
+        }
+      });
+    }), this.manager.onLifecycle(() => [
+      _(() => this.viewModel.state, (e) => {
+        const { flowElement: { value: i }, versionList: s } = this, t = i?.getElementsByTagName("geoscene-version-management-version-properties")[0];
+        if (e === "disabled" && i) {
+          t && this._removeVersionPropertiesFlowItem(i), s && this._removeVersionListFlowItem(i);
+          return;
+        }
+        s && (s.versionListElementProps = {
+          ...s.versionListElementProps,
+          executionError: this.viewModel.executionError
+        }, s.versionListElementProps = { ...s.versionListElementProps, state: e }), t && (t.versionPropertiesElementProps = {
+          ...t.versionPropertiesElementProps,
+          state: e
+        });
+      })
+    ]);
+  }
+  disconnectedCallback() {
+    super.disconnectedCallback(), this.versionPropertiesContainer?.remove();
+  }
+  _removeTrailingSlash(e) {
+    return e.replace(/\/+$/u, "");
+  }
+  _createVersionPropertiesFlowItem(e, i) {
+    const { closable: s, viewModel: t, viewModel: { state: n } } = this, o = {
+      closable: s,
+      currentUser: t.userLookup.get(e),
+      isVersionAdministrator: t.versionAdministratorLookup.get(e),
+      serviceUrl: e,
+      state: n,
+      strings: this.messages,
+      versionInfo: i
+    };
+    this.versionPropertiesContainer = document.createElement("div");
+    const r = F(m`<geoscene-version-management-version-properties .versionPropertiesElementProps=${o} selected show-back-button></geoscene-version-management-version-properties>`, this.versionPropertiesContainer), a = Array.from(r.parentNode.childNodes).find((c) => c.nodeName.toUpperCase() === "GEOSCENE-VERSION-MANAGEMENT-VERSION-PROPERTIES");
+    return this.listenOn(a, "geosceneFlowItemBack", () => {
+      this._removeVersionPropertiesFlowItem(this.flowElement.value);
+    }), this.listenOn(a, "calciteFlowItemBack", (c) => {
+      c.preventDefault(), this._removeVersionPropertiesFlowItem(this.flowElement.value), this.versionList && (this.versionList.selected = !0);
+    }), this.listenOn(a, "calciteFlowItemClose", this._handleFlowItemClose), this.listenOn(a, "geosceneCreateVersion", this._handleCreateVersion), this.listenOn(a, "geosceneAlterVersion", this._handleAlterVersion), a;
+  }
+  _getLoadError(e) {
+    const { messages: i } = this;
+    switch (e) {
+      case "no-feature-services":
+        return i.loadErrors.noFeatureServices;
+      case "no-view-property":
+        return i.loadErrors.noViewProperty;
+      default:
+        return e;
+    }
+  }
+  async _handleAlterVersion(e) {
+    const { flowElement: { value: i }, viewModel: s } = this, { alterVersionParameters: t } = e.detail;
+    await s.alterVersion(t).then(async (n) => {
+      n && this.geosceneVersioningStateChanged.emit({
+        type: "version-changed",
+        versionIdentifier: t.versionIdentifier,
+        versioningState: s.versioningStateLookup.get(t.featureServerUrl)
+      }), await this._refreshVersionList(t.featureServerUrl);
+    }).finally(() => {
+      i && this._removeVersionPropertiesFlowItem(i);
+    });
+  }
+  _handleCreateVersion(e) {
+    const { flowElement: { value: i }, viewModel: s } = this, { createVersionParameters: t, switchToVersion: n } = e.detail;
+    s.createVersion(t).then(async (o) => {
+      o && this.geosceneVersioningStateChanged.emit({
+        type: "version-created",
+        versionIdentifier: o.versionIdentifier,
+        versioningState: s.versioningStateLookup.get(t.featureServerUrl)
+      }), n && await this.viewModel.changeVersion(t.featureServerUrl, o.versionIdentifier.name, o.versionIdentifier.guid).then((r) => {
+        r && this.geosceneVersioningStateChanged.emit({
+          type: "version-switched",
+          versionIdentifier: o.versionIdentifier,
+          versioningState: s.versioningStateLookup.get(t.featureServerUrl)
+        });
+      }), await this._refreshVersionList(t.featureServerUrl);
+    }).finally(() => {
+      i && this._removeVersionPropertiesFlowItem(i);
+    });
+  }
+  _changeToInitialVersion(e) {
+    const { _isInitialVersionInvalid: i, viewModel: s } = this, { url: t, name: n } = e, o = s.versioningStateLookup.get(t);
+    if (!o)
+      throw this._showInvalidFeatureServiceNotice = !0, new Error(`${I} - no versioning state found for feature service ${t}`);
+    const r = o?.versionInfos.find((h) => h.versionIdentifier.name === n);
+    if (!r)
+      throw i.set(t, !0), new Error(`${I} - version ${n} not found in the versioning state for feature service ${t}`);
+    const a = r.versionIdentifier, c = o?.currentVersionInfo?.versionIdentifier;
+    a.guid !== c?.guid && s.changeVersion(t, a.name, a.guid);
+  }
+  _handleFlowItemClose() {
+    const e = document.querySelector("geoscene-version-management");
+    e.parentElement?.removeChild(e);
+  }
+  async _handleNewVersionAction(e) {
+    const i = this._createVersionPropertiesFlowItem(e.detail.serviceUrl, void 0);
+    this.flowElement.value?.appendChild(i), this.versionList && (this.versionList.selected = !1);
+  }
+  async _handleManageVersionAction(e) {
+    const { actionType: i, serviceUrl: s, versionInfo: t } = e.detail, { viewModel: n, flowElement: o } = this;
+    switch (i) {
+      case "changeVersion": {
+        n.changeVersion(s, t.versionIdentifier.name, t.versionIdentifier.guid).then((r) => {
+          r && this.geosceneVersioningStateChanged.emit({
+            type: "version-switched",
+            versionIdentifier: t.versionIdentifier,
+            versioningState: n.versioningStateLookup.get(s)
+          });
+          const { versionList: a } = this;
+          a && (a.versionListElementProps = {
+            ...a.versionListElementProps,
+            currentVersionIdentifier: n.versioningStateLookup.get(s).currentVersionInfo.versionIdentifier
+          });
+        });
+        break;
+      }
+      case "deleteVersion": {
+        n.deleteVersion(s, t.versionIdentifier.name, t.versionIdentifier.guid).then(async (r) => {
+          r && this.geosceneVersioningStateChanged.emit({
+            type: "version-deleted",
+            versionIdentifier: t.versionIdentifier,
+            versioningState: n.versioningStateLookup.get(s)
+          }), await this._refreshVersionList(s);
+        });
+        break;
+      }
+      case "editVersion": {
+        const r = this._createVersionPropertiesFlowItem(s, t);
+        o.value?.appendChild(r), this.versionList && (this.versionList.selected = !1);
+        break;
+      }
+    }
+  }
+  async _refreshVersionList(e) {
+    const { flowElement: { value: i }, versionList: s, viewModel: t } = this;
+    if (i) {
+      const n = await t.getVersionInfos(e), o = i.getElementsByTagName("geoscene-version-management-service-item");
+      for (const r of o)
+        r.serviceItemElementProps.serviceUrl === e && (r.serviceItemElementProps = { ...r.serviceItemElementProps, versionInfos: n });
+      s && (s.versionListElementProps = {
+        ...s.versionListElementProps,
+        currentVersionIdentifier: t.versioningStateLookup.get(e).currentVersionInfo.versionIdentifier,
+        versionInfos: n
+      });
+    }
+  }
+  _removeVersionListFlowItem(e) {
+    for (const i of e.childNodes)
+      i.nodeName.toUpperCase() === "GEOSCENE-VERSION-MANAGEMENT-VERSION-LIST" && (e.removeChild(i), this.versionList = void 0), i.nodeName.toUpperCase() === "CALCITE-FLOW-ITEM" && (i.hidden = !1);
+  }
+  _removeVersionPropertiesFlowItem(e) {
+    for (const i of e.childNodes)
+      i.nodeName.toUpperCase() === "GEOSCENE-VERSION-MANAGEMENT-VERSION-PROPERTIES" && e.removeChild(i);
+  }
+  render() {
+    const { allowEditingDisabled: e, closable: i, flowElement: { value: s }, initialVersionInfos: t, _isInitialVersionInvalid: n, label: o, messages: r, mode: a, pageSize: c, versionList: h, viewModel: v, viewModel: { loadError: p, state: d } } = this, w = Array.from(v.serviceNameLookup, ([l, g]) => ({ url: l, name: g })), V = d !== "disabled" ? w.map((l) => {
+      const g = {
+        allowEditing: !e,
+        closable: i,
+        currentUser: v.userLookup.get(l.url),
+        currentVersionIdentifier: v.versioningStateLookup.get(l.url).currentVersionInfo.versionIdentifier,
+        executionError: void 0,
+        flowElement: s,
+        heading: o,
+        initialVersionInfos: t,
+        isInitialVersionInvalid: n,
+        isVersionAdministrator: v.versionAdministratorLookup.get(l.url),
+        isVersioningApiAvailable: (v.serverVersionLookup.get(l.url) ?? 0) >= 11.2,
+        mode: a,
+        pageSize: c,
+        serviceName: l.name,
+        state: d,
+        serviceUrl: l.url,
+        strings: r,
+        versionInfos: v.versioningStateLookup.get(l.url)?.versionInfos ?? []
+      };
+      return m`<geoscene-version-management-service-item .serviceItemElementProps=${g} @geosceneFlowItemBack=${() => {
+        s && (this._removeVersionListFlowItem(s), this.versionList = void 0);
+      }} @geosceneFlowItemClose=${() => this._handleFlowItemClose()} @geosceneGetVersions=${async (f) => {
+        await this._refreshVersionList(f.detail.serviceUrl);
+      }} @geosceneManageVersion=${this._handleManageVersionAction} @geosceneNewVersion=${this._handleNewVersionAction} @geosceneCreateVersionList=${(f) => this.versionList = f.detail}></geoscene-version-management-service-item>`;
+    }) : void 0, E = d === "disabled" && p != null ? m`<calcite-notice class="notice" kind=warning open scale=s slot=footer width=full><div slot=message>${this._getLoadError(p)}</div></calcite-notice>` : void 0, S = this._showInvalidFeatureServiceNotice ? m`<calcite-notice closable kind=warning open scale=s slot=content-top width=full icon @calciteNoticeClose=${() => this._showInvalidFeatureServiceNotice = !1}><div slot=title>${r.headers.invalidInitialFeatureService}</div><div slot=message>${r.loadErrors.invalidInitialFeatureService}</div></calcite-notice>` : void 0;
+    return m`<div class="geoscene-version-management"><calcite-flow custom-item-selectors="geoscene-version-management-version-list, geoscene-version-management-version-properties" class=${M(this.mode === "dialog" ? "" : "component-container-flow")} ${b(this.flowElement)}><calcite-flow-item .closable=${this.closable} .heading=${o ?? void 0} @calciteFlowItemClose=${() => this._handleFlowItemClose()} .selected=${!h}>${S}<calcite-panel class="service-items-panel" .loading=${d === "loading" || d === "executing"}>${V}${E}</calcite-panel></calcite-flow-item></calcite-flow></div>`;
+  }
+}
+L("geoscene-version-management", U);
+export {
+  U as GeosceneVersionManagement
+};

package/dist/components/geoscene-version-management/index.d.ts

@@ -0,0 +1,7 @@
+import "../geoscene-version-management-version-properties/index.js";
+import "../geoscene-version-management-service-item/index.js";
+import "@esri/calcite-components/components/calcite-notice";
+import "@esri/calcite-components/components/calcite-flow";
+import "@esri/calcite-components/components/calcite-flow-item";
+import "@esri/calcite-components/components/calcite-panel";
+export * from "./customElement.js";

package/dist/components/geoscene-version-management/index.js

@@ -0,0 +1,7 @@
+import "../geoscene-version-management-version-properties/index.js";
+import "../geoscene-version-management-service-item/index.js";
+import "@esri/calcite-components/components/calcite-notice";
+import "@esri/calcite-components/components/calcite-flow";
+import "@esri/calcite-components/components/calcite-flow-item";
+import "@esri/calcite-components/components/calcite-panel";
+export * from "./customElement.js";