@arcgis/map-components 4.29.0-test.0 → 4.29.1

package/dist/esm/arcgis-value-picker.entry.js

@@ -0,0 +1,176 @@
+/*!
+ * All material copyright Esri, All Rights Reserved, unless otherwise specified.
+ * See https://js.arcgis.com/4.29/esri/copyright.txt for details.
+ * v4.29.1
+ */
+import { r as registerInstance, c as createEvent, h, g as getElement } from './index-afe1b299.js';
+import { a2 as newWidgetsValuePicker, i as importCoreReactiveUtils } from './index-508eea52.js';
+import { c as checkForView, a as addHandles } from './component-utils-a1b18b71.js';
+import { o as onDisconnectedHelper } from './disconnected-a67fc7e0.js';
+
+const valuePickerCss = "arcgis-value-picker{}";
+
+const ArcgisValuePicker = class {
+    constructor(hostRef) {
+        registerInstance(this, hostRef);
+        this.arcgisValuePickerReady = createEvent(this, "arcgisValuePickerReady", 7);
+        this.arcgisValuePickerValuesChange = createEvent(this, "arcgisValuePickerValuesChange", 7);
+        this.valuePickerAnimate = createEvent(this, "valuePickerAnimate", 7);
+        this.valuePickerNext = createEvent(this, "valuePickerNext", 7);
+        this.valuePickerPause = createEvent(this, "valuePickerPause", 7);
+        this.valuePickerPlay = createEvent(this, "valuePickerPlay", 7);
+        this.valuePickerPrevious = createEvent(this, "valuePickerPrevious", 7);
+        this._watchHandles = [];
+        this.referenceElement = undefined;
+        this.view = undefined;
+        this.position = "bottom-left";
+        this.widget = undefined;
+        this.canNext = undefined;
+        this.canPlay = undefined;
+        this.canPrevious = undefined;
+        this.caption = undefined;
+        this.component = undefined;
+        this.layout = undefined;
+        this.loop = undefined;
+        this.playRate = undefined;
+        this.visibleElements = undefined;
+        this.values = undefined;
+    }
+    positionWatcher(newValue) {
+        if (newValue !== undefined && this.widget) {
+            this.view.ui.move(this.childElem, newValue);
+        }
+    }
+    captionWatcher(newValue) {
+        this.widget.caption = newValue;
+    }
+    componentWatcher(newValue) {
+        if (this.widget) {
+            this.widget.component = newValue;
+        }
+    }
+    layoutWatcher(newValue) {
+        if (this.widget) {
+            this.widget.layout = newValue;
+        }
+    }
+    loopWatcher(newValue) {
+        if (newValue !== undefined && this.widget) {
+            this.widget.loop = newValue;
+        }
+    }
+    playRateWatcher(newValue) {
+        if (newValue !== undefined && this.widget) {
+            this.widget.playRate = newValue;
+        }
+    }
+    visibleElementsWatcher(newValue) {
+        if (this.widget) {
+            this.widget.visibleElements = newValue;
+        }
+    }
+    //--------------------------------------------------------------------------
+    //
+    //  Methods
+    //
+    //--------------------------------------------------------------------------
+    async next() {
+        this.widget?.next();
+    }
+    async pause() {
+        this.widget?.pause();
+    }
+    async play() {
+        this.widget?.play();
+    }
+    async previous() {
+        this.widget?.previous();
+    }
+    //--------------------------------------------------------------------------
+    //
+    //  Lifecycle
+    //
+    //--------------------------------------------------------------------------
+    async componentDidLoad() {
+        const params = this._createParams();
+        const widget = await newWidgetsValuePicker(params);
+        this.widget = widget;
+        await this._addWatchers();
+        this._proxyEvents();
+        this.arcgisValuePickerReady.emit();
+        checkForView(this);
+    }
+    disconnectedCallback() {
+        onDisconnectedHelper(this);
+    }
+    render() {
+        return h("div", { ref: (el) => (this.childElem = el) });
+    }
+    //--------------------------------------------------------------------------
+    //
+    //  Private Interal Methods
+    //
+    //--------------------------------------------------------------------------
+    async _addWatchers() {
+        const { watch } = await importCoreReactiveUtils();
+        addHandles(this, watch(() => this.widget.canNext, (value) => (this.canNext = value), {
+            initial: true
+        }));
+        addHandles(this, watch(() => this.widget.canPlay, (value) => (this.canPlay = value), {
+            initial: true
+        }));
+        addHandles(this, watch(() => this.widget.canPrevious, (value) => (this.canPrevious = value), {
+            initial: true
+        }));
+        addHandles(this, watch(() => this.widget.values, (value) => {
+            this.values = value;
+            this.arcgisValuePickerValuesChange.emit();
+        }, {
+            initial: true
+        }));
+    }
+    _createParams() {
+        const params = {
+            container: this.childElem
+        };
+        if (this.caption) {
+            params.caption = this.caption;
+        }
+        if (this.component) {
+            params.component = this.component;
+        }
+        if (this.layout) {
+            params.layout = this.layout;
+        }
+        if (this.loop !== undefined) {
+            params.loop = this.loop;
+        }
+        if (this.playRate !== undefined) {
+            params.playRate = this.playRate;
+        }
+        if (this.visibleElements) {
+            params.visibleElements = this.visibleElements;
+        }
+        return params;
+    }
+    _proxyEvents() {
+        this.widget.on("animate", (e) => this.valuePickerAnimate.emit(e));
+        this.widget.on("next", (e) => this.valuePickerNext.emit(e));
+        this.widget.on("pause", (e) => this.valuePickerPause.emit(e));
+        this.widget.on("play", (e) => this.valuePickerPlay.emit(e));
+        this.widget.on("previous", (e) => this.valuePickerPrevious.emit(e));
+    }
+    get el() { return getElement(this); }
+    static get watchers() { return {
+        "position": ["positionWatcher"],
+        "caption": ["captionWatcher"],
+        "component": ["componentWatcher"],
+        "layout": ["layoutWatcher"],
+        "loop": ["loopWatcher"],
+        "playRate": ["playRateWatcher"],
+        "visibleElements": ["visibleElementsWatcher"]
+    }; }
+};
+ArcgisValuePicker.style = valuePickerCss;
+
+export { ArcgisValuePicker as arcgis_value_picker };

package/dist/esm/arcgis-version-management-service-item_2.entry.js

@@ -0,0 +1,151 @@
+/*!
+ * All material copyright Esri, All Rights Reserved, unless otherwise specified.
+ * See https://js.arcgis.com/4.29/esri/copyright.txt for details.
+ * v4.29.1
+ */
+import { r as registerInstance, c as createEvent, h, H as Host, g as getElement } from './index-afe1b299.js';
+import { i as importCoreReactiveUtils } from './index-508eea52.js';
+
+const ArcgisVersionManagementServiceItem = class {
+    constructor(hostRef) {
+        registerInstance(this, hostRef);
+        this.versionItemActionClickedEventWithServiceUrl = createEvent(this, "versionItemActionClickedEventWithServiceUrl", 7);
+        this.versionListActionClickedEvent = createEvent(this, "versionListActionClickedEvent", 7);
+        this._versionListEventListeners = new Map();
+        this._watchHandles = [];
+        this._versionItemActionClickedEventWithServiceUrl = (e) => {
+            this.versionItemActionClickedEventWithServiceUrl.emit(e.detail);
+        };
+        this._versionListActionClickedEvent = (e) => {
+            this.versionListActionClickedEvent.emit(e.detail);
+        };
+        this.flowElement = undefined;
+        this.heading = undefined;
+        this.serviceUrl = undefined;
+        this.strings = undefined;
+        this.viewModel = undefined;
+        this.state = undefined;
+    }
+    async componentDidLoad() {
+        const { watch } = await importCoreReactiveUtils();
+        this._watchHandles.push(watch(() => this.viewModel.state, (state) => {
+            this.state = state;
+        }));
+    }
+    async componentWillLoad() {
+        this.state = this.viewModel.state;
+    }
+    disconnectedCallback() {
+        this._watchHandles.forEach((handle) => {
+            handle.remove();
+        });
+        this._watchHandles = [];
+        this._removeVersionListEventListeners(this._versionList);
+    }
+    render() {
+        const { flowElement, heading, serviceUrl, strings, viewModel } = this;
+        let { _versionList } = this;
+        const serviceName = viewModel.serviceNames.get(serviceUrl);
+        return (h(Host, null, h("calcite-panel", { heading: serviceName }, h("calcite-action", { id: `actionManageVersions_${serviceName}`, icon: "list", scale: "s", slot: "header-actions-end", onclick: async () => {
+                _versionList = document.createElement("arcgis-version-management-version-list");
+                _versionList.heading = heading;
+                _versionList.serviceUrl = serviceUrl;
+                _versionList.serviceName = serviceName;
+                _versionList.strings = strings;
+                _versionList.userHasAdvancedEditingUserTypeExtension =
+                    viewModel.advancedEditingUserTypeExtensionForUrl.get(serviceUrl);
+                await viewModel.getVersionInfos(serviceUrl, false);
+                _versionList.versionInfos = viewModel.versionInfos.get(serviceUrl);
+                _versionList.viewModel = viewModel;
+                this._addVersionListEventListeners(_versionList);
+                flowElement.append(_versionList);
+            } }), h("calcite-tooltip", { "overlay-positioning": "fixed", referenceElement: `actionManageVersions_${serviceName}` }, h("span", null, strings.headers.manageVersions)))));
+    }
+    _addVersionListEventListeners(versionList) {
+        versionList.addEventListener("versionItemActionClickedEventWithServiceUrl", this._versionItemActionClickedEventWithServiceUrl);
+        this._versionListEventListeners.set("versionItemActionClickedEventWithServiceUrl", this._versionItemActionClickedEventWithServiceUrl);
+        versionList.addEventListener("versionListActionClickedEvent", this._versionListActionClickedEvent);
+        this._versionListEventListeners.set("versionListActionClickedEvent", this._versionListActionClickedEvent);
+    }
+    _removeVersionListEventListeners(versionList) {
+        for (const [type, listener] of this._versionListEventListeners) {
+            versionList.removeEventListener(type, listener);
+        }
+    }
+    get _hostElement() { return getElement(this); }
+};
+
+const ArcgisVersionManagementVersionProperties = class {
+    constructor(hostRef) {
+        registerInstance(this, hostRef);
+        this.versionPropertiesSaveClickedEvent = createEvent(this, "versionPropertiesSaveClickedEvent", 7);
+        this._watchHandles = [];
+        this.flowElement = undefined;
+        this.serviceUrl = undefined;
+        this.strings = undefined;
+        this.versionInfo = undefined;
+        this.viewModel = undefined;
+        this.executionError = undefined;
+        this.state = undefined;
+    }
+    async componentDidLoad() {
+        await this.viewModel.getVersionInfos(this.serviceUrl, false);
+    }
+    async componentWillLoad() {
+        const { watch } = await importCoreReactiveUtils();
+        this._watchHandles.push(watch(() => this.viewModel.state, (state) => {
+            this.state = state;
+        }));
+    }
+    disconnectedCallback() {
+        this._watchHandles.forEach((handle) => {
+            handle.remove();
+        });
+        this._watchHandles = [];
+    }
+    render() {
+        const { serviceUrl, strings, versionInfo } = this;
+        const { viewModel: { executionError } } = this;
+        return (h(Host, null, h("calcite-flow-item", { description: versionInfo ? versionInfo.versionIdentifier.name : "", heading: versionInfo ? strings.actions.editVersion : strings.actions.newVersion }, h("calcite-panel", { loading: this.state === "executing" }, h("div", { class: "div-content" }, h("calcite-label", null, strings.input.versionName, h("calcite-input-text", { id: "inputName", maxLength: 62, value: versionInfo ? versionInfo.versionIdentifier.name.split(".")[1] : "" })), h("calcite-label", null, strings.input.versionDescription, h("calcite-text-area", { id: "inputDescription", resize: "vertical", value: versionInfo ? versionInfo.description : "" })), h("calcite-label", null, strings.input.versionAccess, h("calcite-chip-group", { id: "chipGroupAccessLevel", selectionMode: "single" }, h("calcite-chip", { selected: versionInfo?.access === "public", value: "public" }, strings.accessLevels.public), h("calcite-chip", { selected: versionInfo?.access === "protected", value: "protected" }, strings.accessLevels.protected), h("calcite-chip", { selected: versionInfo?.access === "private" || !versionInfo, value: "private" }, strings.accessLevels.private))), h("calcite-label", null, strings.input.versionOwner, h("calcite-input-text", { id: "inputOwner", disabled: !this.viewModel.advancedEditingUserTypeExtensionForUrl.get(serviceUrl), value: versionInfo
+                ? versionInfo.versionIdentifier.name.split(".")[0]
+                : this.viewModel.userForUrl.get(serviceUrl)?.toUpperCase() })), h("calcite-button", { appearance: "outline", slot: "footer", width: "half", onClick: () => {
+                void this.flowElement.back();
+            } }, strings.actions.cancelSave), h("calcite-button", { slot: "footer", width: "half", onClick: async () => {
+                const textInputs = Array.from(this._hostElement.getElementsByTagName("calcite-input-text"));
+                const inputDescription = this._hostElement.getElementsByTagName("calcite-text-area")[0];
+                const inputName = textInputs.find((input) => input.id === "inputName");
+                const inputOwner = textInputs.find((input) => input.id === "inputOwner");
+                const chipGroupAccessLevel = Array.from(this._hostElement.getElementsByTagName("calcite-chip-group"))[0];
+                const info = {
+                    access: chipGroupAccessLevel.selectedItems[0].value,
+                    description: inputDescription.value,
+                    versionIdentifier: {
+                        name: inputOwner.value !== "" ? `${inputOwner.value}.${inputName.value}` : inputName.value,
+                        guid: versionInfo ? versionInfo.versionIdentifier.guid : ""
+                    }
+                };
+                this.versionPropertiesSaveClickedEvent.emit({
+                    serviceUrl,
+                    versionInfo: info
+                });
+            } }, strings.actions.saveVersion)), this.state === "failed" ? (h("calcite-notice", { class: "notice", closable: true, kind: "warning", open: true, scale: "s", slot: "footer" }, h("div", { slot: "message" }, this._getExecutionError(executionError)))) : undefined))));
+    }
+    _getExecutionError(executionError) {
+        const { strings: { executionErrors } } = this;
+        switch (executionError) {
+            case "no-advanced-editing-user-type-extension":
+                return executionErrors.noAdvancedEditingUserTypeExtension;
+            case "no-feature-service-found":
+                return executionErrors.noFeatureServiceFound;
+            case "no-valid-enterprise-version":
+                return executionErrors.notValidEnterpriseVersion;
+            case "no-valid-version-name":
+                return executionErrors.invalidVersionName;
+            default:
+                return executionError;
+        }
+    }
+    get _hostElement() { return getElement(this); }
+};
+
+export { ArcgisVersionManagementServiceItem as arcgis_version_management_service_item, ArcgisVersionManagementVersionProperties as arcgis_version_management_version_properties };

package/dist/esm/arcgis-version-management-version-item_2.entry.js

@@ -0,0 +1,87 @@
+/*!
+ * All material copyright Esri, All Rights Reserved, unless otherwise specified.
+ * See https://js.arcgis.com/4.29/esri/copyright.txt for details.
+ * v4.29.1
+ */
+import { r as registerInstance, c as createEvent, h, H as Host, g as getElement } from './index-afe1b299.js';
+import { i as importCoreReactiveUtils } from './index-508eea52.js';
+
+const ArcgisVersionManagementVersionItem = class {
+    constructor(hostRef) {
+        registerInstance(this, hostRef);
+        this.versionItemActionClickedEvent = createEvent(this, "versionItemActionClickedEvent", 7);
+        this.strings = undefined;
+        this.hasAdvEditingUte = undefined;
+        this.isVersioningApiAvailable = undefined;
+        this.versionInfo = undefined;
+    }
+    render() {
+        const { strings: { actions }, versionInfo } = this;
+        const fullVersionName = versionInfo.versionIdentifier.name;
+        const guid = versionInfo.versionIdentifier.guid;
+        const actionElementId = `actionSwitchToVersion_${guid}`;
+        return (h(Host, null, h("calcite-list-item", { description: fullVersionName.split(".")[0], label: fullVersionName.split(".")[1], value: guid }, h("calcite-action", { id: actionElementId, icon: "switch", onclick: () => {
+                this.versionItemActionClickedEvent.emit({ actionType: "changeVersion", versionInfo });
+            }, slot: "actions-start" }), h("calcite-tooltip", { "overlay-positioning": "fixed", referenceElement: actionElementId }, h("span", null, actions.switchToVersion)), h("calcite-action-menu", { "overlay-positioning": "fixed", slot: "actions-end" }, h("calcite-action", { icon: "switch", onclick: () => {
+                this.versionItemActionClickedEvent.emit({ actionType: "changeVersion", versionInfo });
+            }, scale: "s", text: actions.switchToVersion, textEnabled: true }), h("calcite-action", { disabled: fullVersionName.toUpperCase() === "SDE.DEFAULT" ||
+                !this.hasAdvEditingUte ||
+                !this.isVersioningApiAvailable, icon: "edit-attributes", onclick: () => {
+                this.versionItemActionClickedEvent.emit({ actionType: "editVersion", versionInfo });
+            }, scale: "s", text: actions.editVersion, textEnabled: true })))));
+    }
+    get _hostElement() { return getElement(this); }
+};
+
+const ArcgisVersionManagementVersionList = class {
+    constructor(hostRef) {
+        registerInstance(this, hostRef);
+        this.versionItemActionClickedEventWithServiceUrl = createEvent(this, "versionItemActionClickedEventWithServiceUrl", 7);
+        this.versionListActionClickedEvent = createEvent(this, "versionListActionClickedEvent", 7);
+        this._watchHandles = [];
+        this.heading = undefined;
+        this.serviceName = undefined;
+        this.serviceUrl = undefined;
+        this.strings = undefined;
+        this.userHasAdvancedEditingUserTypeExtension = undefined;
+        this.versionInfos = undefined;
+        this.viewModel = undefined;
+        this.state = undefined;
+    }
+    async componentDidLoad() {
+        const { watch } = await importCoreReactiveUtils();
+        this._watchHandles.push(watch(() => this.versionInfos, (versionInfos) => {
+            this.versionInfos = versionInfos;
+        }), watch(() => this.viewModel.state, (state) => {
+            this.state = state;
+        }));
+    }
+    async componentWillLoad() {
+        this.state = this.viewModel.state;
+    }
+    disconnectedCallback() {
+        this._watchHandles.forEach((handle) => {
+            handle.remove();
+        });
+        this._watchHandles = [];
+    }
+    render() {
+        const { heading, serviceName, serviceUrl, state, strings, versionInfos, viewModel } = this;
+        return (h(Host, null, h("calcite-flow-item", { heading: heading, description: serviceName }, h("calcite-panel", { loading: state === "executing", class: "panel-versions", heading: `${strings.headers.manageVersions} (${versionInfos.length})` }, h("calcite-action", { id: "actionRefreshVersions", icon: "refresh", onclick: () => {
+                this.versionListActionClickedEvent.emit({
+                    actionType: "refreshVersions",
+                    serviceUrl
+                });
+            }, slot: "header-actions-end" }), h("calcite-tooltip", { "overlay-positioning": "fixed", referenceElement: "actionRefreshVersions" }, h("span", null, strings.actions.refreshVersions)), h("calcite-list", { class: "version-list", filterEnabled: true }, versionInfos.map((versionInfo) => (h("arcgis-version-management-version-item", { strings: strings, hasAdvEditingUte: viewModel.advancedEditingUserTypeExtensionForUrl.get(serviceUrl), isVersioningApiAvailable: (viewModel.serverVersionForUrl.get(serviceUrl) ?? 0) >= 11.2, versionInfo: versionInfo, onVersionItemActionClickedEvent: (e) => {
+                this.versionItemActionClickedEventWithServiceUrl.emit({ ...e.detail, serviceUrl });
+            } })))), h("calcite-fab", { appearance: "outline-fill", slot: "fab", textEnabled: true, text: strings.actions.newVersion, onclick: () => {
+                this.versionListActionClickedEvent.emit({
+                    actionType: "newVersion",
+                    serviceUrl
+                });
+            } })))));
+    }
+    get _hostElement() { return getElement(this); }
+};
+
+export { ArcgisVersionManagementVersionItem as arcgis_version_management_version_item, ArcgisVersionManagementVersionList as arcgis_version_management_version_list };

package/dist/esm/arcgis-version-management.entry.js

@@ -0,0 +1,166 @@
+/*!
+ * All material copyright Esri, All Rights Reserved, unless otherwise specified.
+ * See https://js.arcgis.com/4.29/esri/copyright.txt for details.
+ * v4.29.1
+ */
+import { r as registerInstance, a as getAssetPath, h, H as Host, g as getElement } from './index-afe1b299.js';
+import { i as importCoreReactiveUtils, a3 as newWidgetsVersionManagementVersionManagementViewModel } from './index-508eea52.js';
+
+function S(e,t){let n=e;for(;n;){if(n===t)return !0;if(!n.parentNode)return !1;n.parentNode instanceof ShadowRoot?n=n.parentNode.host:n=n.parentNode;}return !1}function x(e,t,n=()=>{}){if(!t||t.length<=0)return;let r=new MutationObserver(o=>{for(let s of o)S(e,s.target)&&n();});return r.observe(document.documentElement,{attributes:!0,attributeFilter:t,subtree:!0}),r}function T(e,t){let n=e;for(;n;){let r=n.closest(t);if(r)return r;let o=n.getRootNode();if(o===document)return null;n=o.host;}return null}function f(e,t,n){return T(e,`[${t}]`)?.getAttribute(t)??n}var E=new Set(["ar","bg","bs","ca","cs","da","de","el","en","es","et","fi","fr","he","hr","hu","id","it","ja","ko","lt","lv","nl","nb","pl","pt-BR","pt-PT","ro","ru","sk","sl","sr","sv","th","tr","uk","vi","zh-CN","zh-HK","zh-TW"]),a=new Map;async function v(e,t,n=""){let r=`${t}/${n}${e}.json`;if(a.has(r))return a.get(r);try{let o=await fetch(r);if(o.ok){let i=await o.json();return a.set(r,i),i}if(e==="en"){a.set(r,void 0);return}let s=await v("en",t,n);return a.set(r,s),s}catch{a.set(r,void 0);return}}function _(e){let t=f(e,"lang",navigator.language||"en");if(E.has(t))return {lang:t,t9nLocale:t};let n=t.slice(0,2);return {lang:t,t9nLocale:E.has(n)?n:"en"}}var p=new WeakMap,m=new WeakMap,C=new WeakMap;async function B(e,t,n){m.set(e,t),p.set(e,x(e._hostElement,["lang"],()=>{b(e,n).catch(console.error);})),await b(e,n);}function q(e){p.get(e)?.disconnect(),p.delete(e),m.delete(e);}async function b(e,t){let{lang:n,t9nLocale:r}=_(e._hostElement);if(n===e._lang&&r===e._t9nLocale||(n!==e._lang&&(e._lang=n),r===e._t9nLocale))return;let o=C.get(e);if(!o){let s=m.get(e)??"",i=e._hostElement.tagName.toLowerCase().replace("arcgis-",""),l=`${s}/${i}/t9n`,u=`${i}.t9n.`;o=await v(r,l,u);}r!==e._t9nLocale&&(e._t9nLocale=r,e._t9nStrings=o,await t?.call(e));}
+
+const versionManagementCss = ".div-content{background-color:var(--calcite-ui-foreground-1);padding:0.75rem}.flow-main{width:330px}.notice{width:-webkit-fill-available}.panel-services{max-height:400px}.panel-versions{max-height:400px}";
+
+const ArcgisVersionManagement = class {
+    constructor(hostRef) {
+        registerInstance(this, hostRef);
+        this._watchHandles = [];
+        this.label = undefined;
+        this.position = "top-right";
+        this.view = undefined;
+        this._lang = "";
+        this._t9nLocale = "";
+        this._t9nStrings = undefined;
+        this.state = undefined;
+    }
+    positionWatcher(newValue) {
+        if (newValue !== undefined && this.viewModel) {
+            this.view.ui.move(this._hostElement, newValue);
+        }
+    }
+    async componentDidLoad() {
+        const { watch } = await importCoreReactiveUtils();
+        this._watchHandles.push(watch(() => this.viewModel.state, (state) => {
+            this.state = state;
+        }));
+    }
+    async componentWillLoad() {
+        await B(this, getAssetPath("./assets"));
+        await this._checkForView();
+        this.viewModel = await newWidgetsVersionManagementVersionManagementViewModel({
+            layers: this.view.map.layers
+        });
+        this.label = this.label ? this.label : this._t9nStrings.label;
+    }
+    disconnectedCallback() {
+        q(this);
+        this._watchHandles.forEach((handle) => {
+            handle.remove();
+        });
+        this._watchHandles = [];
+    }
+    render() {
+        const { _t9nStrings, label, viewModel, viewModel: { state, loadError } } = this;
+        const arrayServiceNames = Array.from(this.viewModel.serviceNames, ([url, name]) => ({ url, name }));
+        return (h(Host, null, h("calcite-flow", { ref: (node) => {
+                this.flowElement = node;
+            }, class: "flow-main" }, h("calcite-flow-item", { heading: label }, h("calcite-panel", { class: "panel-services", loading: state === "loading" }, arrayServiceNames.map((service) => (h("arcgis-version-management-service-item", { flowElement: this.flowElement, heading: label, serviceUrl: service.url, strings: _t9nStrings, viewModel: viewModel, onVersionItemActionClickedEventWithServiceUrl: (e) => {
+                this._handleVersionItemActionClick(e, this.flowElement);
+            }, onVersionListActionClickedEvent: (e) => {
+                this._handleVersionListActionClick(e, this.flowElement);
+            } }))), state === "disabled" ? (h("calcite-notice", { class: "notice", closable: false, kind: "warning", open: true, scale: "s", slot: "footer" }, h("div", { slot: "message" }, this._getLoadError(loadError)))) : undefined)))));
+    }
+    //--------------------------------------------------------------------------
+    //
+    //  Private Methods
+    //
+    //--------------------------------------------------------------------------
+    async _checkForView() {
+        const viewRef = this._hostElement.closest("arcgis-map");
+        if (viewRef?.view) {
+            await viewRef.view.map.load();
+            this.view = viewRef.view;
+            this.view.ui.add(this._hostElement, this.position);
+        }
+    }
+    _createVersionPropertiesFlow(serviceUrl, versionInfo) {
+        const { flowElement, viewModel } = this;
+        const versionPropertiesFlow = document.createElement("arcgis-version-management-version-properties");
+        versionPropertiesFlow.flowElement = flowElement;
+        versionPropertiesFlow.serviceUrl = serviceUrl;
+        versionPropertiesFlow.strings = this._t9nStrings;
+        versionPropertiesFlow.versionInfo = versionInfo;
+        versionPropertiesFlow.viewModel = viewModel;
+        versionPropertiesFlow.addEventListener("versionPropertiesSaveClickedEvent", async (e) => {
+            const { serviceUrl, versionInfo } = e.detail;
+            const fullVersionName = versionInfo.versionIdentifier.name;
+            const versionName = fullVersionName.split(".").length > 1 ? fullVersionName.split(".")[1] : fullVersionName;
+            const ownerName = fullVersionName.split(".").length > 1 ? fullVersionName.split(".")[0] : viewModel.userForUrl.get(serviceUrl);
+            if (versionInfo.versionIdentifier.guid === "") {
+                await viewModel.createVersion({
+                    access: versionInfo.access,
+                    description: versionInfo.description,
+                    featureServerUrl: serviceUrl,
+                    ownerName,
+                    versionName
+                });
+            }
+            else {
+                await viewModel.alterVersion({
+                    access: versionInfo.access,
+                    description: versionInfo.description,
+                    featureServerUrl: serviceUrl,
+                    ownerName,
+                    versionIdentifier: {
+                        name: "",
+                        guid: versionInfo.versionIdentifier.guid
+                    },
+                    versionName
+                });
+            }
+            if (viewModel.state === "ready") {
+                await viewModel.getVersionInfos(serviceUrl, true);
+                const versionInfos = viewModel.versionInfos.get(serviceUrl);
+                flowElement.getElementsByTagName("arcgis-version-management-version-list")[0].versionInfos = versionInfos;
+                await flowElement.back();
+            }
+        });
+        return versionPropertiesFlow;
+    }
+    _getLoadError(loadError) {
+        const { _t9nStrings } = this;
+        switch (loadError) {
+            case "no-feature-services":
+                return _t9nStrings.loadErrors.noFeatureServices;
+            case "no-layers-property":
+                return _t9nStrings.loadErrors.noLayersProperty;
+            default:
+                return loadError;
+        }
+    }
+    async _handleVersionItemActionClick(e, flowElement) {
+        const { actionType, serviceUrl, versionInfo } = e.detail;
+        switch (actionType) {
+            case "changeVersion":
+                await this._switchToVersion(serviceUrl, versionInfo.versionIdentifier.name, versionInfo.versionIdentifier.guid);
+                break;
+            case "editVersion":
+                flowElement.append(this._createVersionPropertiesFlow(serviceUrl, versionInfo));
+                break;
+        }
+    }
+    async _handleVersionListActionClick(e, flowElement) {
+        const { actionType, serviceUrl } = e.detail;
+        switch (actionType) {
+            case "newVersion": {
+                flowElement.append(this._createVersionPropertiesFlow(serviceUrl, undefined));
+                break;
+            }
+            case "refreshVersions": {
+                const versionInfos = await this.viewModel.getVersionInfos(serviceUrl, true);
+                this.flowElement.getElementsByTagName("arcgis-version-management-version-list")[0].versionInfos = versionInfos;
+                break;
+            }
+        }
+    }
+    async _switchToVersion(featureServerUrl, toVersionName, toVersionGuid) {
+        await this.viewModel.changeVersion(featureServerUrl, toVersionName, toVersionGuid);
+    }
+    static get assetsDirs() { return ["assets"]; }
+    get _hostElement() { return getElement(this); }
+    static get watchers() { return {
+        "position": ["positionWatcher"]
+    }; }
+};
+ArcgisVersionManagement.style = versionManagementCss;
+
+export { ArcgisVersionManagement as arcgis_version_management };