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

package/dist/components/version-management-service-item.js

@@ -0,0 +1,115 @@
+/*!
+ * All material copyright Esri, All Rights Reserved, unless otherwise specified.
+ * See https://js.arcgis.com/4.29/esri/copyright.txt for details.
+ * v4.29.0
+ */
+import { proxyCustomElement, HTMLElement, createEvent, h, Host } from '@stencil/core/internal/client';
+import { i as importCoreReactiveUtils } from './index2.js';
+import '@esri/calcite-components/dist/components/calcite-panel.js';
+import '@esri/calcite-components/dist/components/calcite-action.js';
+import '@esri/calcite-components/dist/components/calcite-tooltip.js';
+import { d as defineCustomElement$2 } from './version-management-version-item.js';
+import { d as defineCustomElement$1 } from './version-management-version-list.js';
+
+const ArcgisVersionManagementServiceItem = /*@__PURE__*/ proxyCustomElement(class ArcgisVersionManagementServiceItem extends HTMLElement {
+    constructor() {
+        super();
+        this.__registerHost();
+        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 this; }
+}, [0, "arcgis-version-management-service-item", {
+        "flowElement": [16],
+        "heading": [1],
+        "serviceUrl": [1, "service-url"],
+        "strings": [16],
+        "viewModel": [16],
+        "state": [32]
+    }]);
+function defineCustomElement() {
+    if (typeof customElements === "undefined") {
+        return;
+    }
+    const components = ["arcgis-version-management-service-item", "arcgis-version-management-version-item", "arcgis-version-management-version-list"];
+    components.forEach(tagName => { switch (tagName) {
+        case "arcgis-version-management-service-item":
+            if (!customElements.get(tagName)) {
+                customElements.define(tagName, ArcgisVersionManagementServiceItem);
+            }
+            break;
+        case "arcgis-version-management-version-item":
+            if (!customElements.get(tagName)) {
+                defineCustomElement$2();
+            }
+            break;
+        case "arcgis-version-management-version-list":
+            if (!customElements.get(tagName)) {
+                defineCustomElement$1();
+            }
+            break;
+    } });
+}
+defineCustomElement();
+
+export { ArcgisVersionManagementServiceItem as A, defineCustomElement as d };

package/dist/components/version-management-version-item.js

@@ -0,0 +1,59 @@
+/*!
+ * All material copyright Esri, All Rights Reserved, unless otherwise specified.
+ * See https://js.arcgis.com/4.29/esri/copyright.txt for details.
+ * v4.29.0
+ */
+import { proxyCustomElement, HTMLElement, createEvent, h, Host } from '@stencil/core/internal/client';
+import '@esri/calcite-components/dist/components/calcite-list-item.js';
+import '@esri/calcite-components/dist/components/calcite-action.js';
+import '@esri/calcite-components/dist/components/calcite-tooltip.js';
+import '@esri/calcite-components/dist/components/calcite-action-menu.js';
+
+const ArcgisVersionManagementVersionItem = /*@__PURE__*/ proxyCustomElement(class ArcgisVersionManagementVersionItem extends HTMLElement {
+    constructor() {
+        super();
+        this.__registerHost();
+        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 this; }
+}, [0, "arcgis-version-management-version-item", {
+        "strings": [16],
+        "hasAdvEditingUte": [4, "has-adv-editing-ute"],
+        "isVersioningApiAvailable": [4, "is-versioning-api-available"],
+        "versionInfo": [16]
+    }]);
+function defineCustomElement() {
+    if (typeof customElements === "undefined") {
+        return;
+    }
+    const components = ["arcgis-version-management-version-item"];
+    components.forEach(tagName => { switch (tagName) {
+        case "arcgis-version-management-version-item":
+            if (!customElements.get(tagName)) {
+                customElements.define(tagName, ArcgisVersionManagementVersionItem);
+            }
+            break;
+    } });
+}
+defineCustomElement();
+
+export { ArcgisVersionManagementVersionItem as A, defineCustomElement as d };

package/dist/components/version-management-version-list.js

@@ -0,0 +1,96 @@
+/*!
+ * All material copyright Esri, All Rights Reserved, unless otherwise specified.
+ * See https://js.arcgis.com/4.29/esri/copyright.txt for details.
+ * v4.29.0
+ */
+import { proxyCustomElement, HTMLElement, createEvent, h, Host } from '@stencil/core/internal/client';
+import { i as importCoreReactiveUtils } from './index2.js';
+import '@esri/calcite-components/dist/components/calcite-flow-item.js';
+import '@esri/calcite-components/dist/components/calcite-panel.js';
+import '@esri/calcite-components/dist/components/calcite-action.js';
+import '@esri/calcite-components/dist/components/calcite-tooltip.js';
+import '@esri/calcite-components/dist/components/calcite-list.js';
+import '@esri/calcite-components/dist/components/calcite-fab.js';
+import { d as defineCustomElement$1 } from './version-management-version-item.js';
+
+const ArcgisVersionManagementVersionList = /*@__PURE__*/ proxyCustomElement(class ArcgisVersionManagementVersionList extends HTMLElement {
+    constructor() {
+        super();
+        this.__registerHost();
+        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 this; }
+}, [0, "arcgis-version-management-version-list", {
+        "heading": [1],
+        "serviceName": [1, "service-name"],
+        "serviceUrl": [1, "service-url"],
+        "strings": [16],
+        "userHasAdvancedEditingUserTypeExtension": [4, "user-has-advanced-editing-user-type-extension"],
+        "versionInfos": [1040],
+        "viewModel": [16],
+        "state": [32]
+    }]);
+function defineCustomElement() {
+    if (typeof customElements === "undefined") {
+        return;
+    }
+    const components = ["arcgis-version-management-version-list", "arcgis-version-management-version-item"];
+    components.forEach(tagName => { switch (tagName) {
+        case "arcgis-version-management-version-list":
+            if (!customElements.get(tagName)) {
+                customElements.define(tagName, ArcgisVersionManagementVersionList);
+            }
+            break;
+        case "arcgis-version-management-version-item":
+            if (!customElements.get(tagName)) {
+                defineCustomElement$1();
+            }
+            break;
+    } });
+}
+defineCustomElement();
+
+export { ArcgisVersionManagementVersionList as A, defineCustomElement as d };

package/dist/components/version-management-version-properties.js

@@ -0,0 +1,114 @@
+/*!
+ * All material copyright Esri, All Rights Reserved, unless otherwise specified.
+ * See https://js.arcgis.com/4.29/esri/copyright.txt for details.
+ * v4.29.0
+ */
+import { proxyCustomElement, HTMLElement, createEvent, h, Host } from '@stencil/core/internal/client';
+import { i as importCoreReactiveUtils } from './index2.js';
+import '@esri/calcite-components/dist/components/calcite-flow-item.js';
+import '@esri/calcite-components/dist/components/calcite-panel.js';
+import '@esri/calcite-components/dist/components/calcite-label.js';
+import '@esri/calcite-components/dist/components/calcite-input-text.js';
+import '@esri/calcite-components/dist/components/calcite-text-area.js';
+import '@esri/calcite-components/dist/components/calcite-chip-group.js';
+import '@esri/calcite-components/dist/components/calcite-chip.js';
+import '@esri/calcite-components/dist/components/calcite-button.js';
+import '@esri/calcite-components/dist/components/calcite-notice.js';
+
+const ArcgisVersionManagementVersionProperties = /*@__PURE__*/ proxyCustomElement(class ArcgisVersionManagementVersionProperties extends HTMLElement {
+    constructor() {
+        super();
+        this.__registerHost();
+        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 this; }
+}, [0, "arcgis-version-management-version-properties", {
+        "flowElement": [16],
+        "serviceUrl": [1, "service-url"],
+        "strings": [16],
+        "versionInfo": [16],
+        "viewModel": [16],
+        "executionError": [32],
+        "state": [32]
+    }]);
+function defineCustomElement() {
+    if (typeof customElements === "undefined") {
+        return;
+    }
+    const components = ["arcgis-version-management-version-properties"];
+    components.forEach(tagName => { switch (tagName) {
+        case "arcgis-version-management-version-properties":
+            if (!customElements.get(tagName)) {
+                customElements.define(tagName, ArcgisVersionManagementVersionProperties);
+            }
+            break;
+    } });
+}
+defineCustomElement();
+
+export { ArcgisVersionManagementVersionProperties as A, defineCustomElement as d };

package/dist/esm/arcgis-area-measurement-2d.entry.js

@@ -0,0 +1,112 @@
+/*!
+ * All material copyright Esri, All Rights Reserved, unless otherwise specified.
+ * See https://js.arcgis.com/4.29/esri/copyright.txt for details.
+ * v4.29.0
+ */
+import { r as registerInstance, c as createEvent, h, g as getElement } from './index-ee66e916.js';
+import { c as newWidgetsAreaMeasurement2D, i as importCoreReactiveUtils } from './index-94c85b30.js';
+import { r as referenceElementHelper, c as checkForView, a as addHandles } from './component-utils-352c412f.js';
+import { o as onDisconnectedHelper } from './disconnected-3f01362d.js';
+
+const areaMeasurement2dCss = "";
+
+const ArcgisAreaMeasurement2d = class {
+    constructor(hostRef) {
+        registerInstance(this, hostRef);
+        this.arcgisAreaMeasurement2dReady = createEvent(this, "arcgisAreaMeasurement2dReady", 7);
+        this._watchHandles = [];
+        this.referenceElement = undefined;
+        this.icon = undefined;
+        this.unit = undefined;
+        this.unitOptions = undefined;
+        this.position = "bottom-left";
+        this.view = undefined;
+        this.widget = undefined;
+    }
+    referenceElementWatcher(value) {
+        void referenceElementHelper(this, value);
+    }
+    iconWatcher(value) {
+        if (this.widget) {
+            this.widget.icon = value;
+            this.widget.iconClass = value;
+        }
+    }
+    unitWatcher(value) {
+        if (this.widget) {
+            this.widget.unit = value;
+        }
+    }
+    positionWatcher(value) {
+        if (value !== undefined && this.widget) {
+            this.view.ui.move(this.childElem, value);
+        }
+    }
+    viewWatcher(value) {
+        if (value !== undefined && this.widget) {
+            this.widget.view = value;
+        }
+    }
+    //--------------------------------------------------------------------------
+    //
+    //  Lifecycle
+    //
+    //--------------------------------------------------------------------------
+    async componentDidLoad() {
+        const params = this._createParams();
+        const widget = await newWidgetsAreaMeasurement2D(params);
+        this.widget = widget;
+        await this._addWatchers();
+        this.arcgisAreaMeasurement2dReady.emit();
+        checkForView(this);
+    }
+    disconnectedCallback() {
+        onDisconnectedHelper(this);
+    }
+    render() {
+        return h("div", { ref: (el) => (this.childElem = el) });
+    }
+    //--------------------------------------------------------------------------
+    //
+    //  Private Methods
+    //
+    //--------------------------------------------------------------------------
+    async _addWatchers() {
+        const { watch, whenOnce } = await importCoreReactiveUtils();
+        addHandles(this, watch(() => this.widget.unit, (value) => (this.unit = value), {
+            initial: true
+        }));
+        await whenOnce(() => this.widget.unitOptions);
+        this.unitOptions = this.widget.unitOptions;
+    }
+    _createParams() {
+        const params = {
+            container: this.childElem
+        };
+        if (this.icon) {
+            params.icon = this.icon;
+            params.iconClass = this.icon;
+        }
+        if (this.view) {
+            params.view = this.view;
+        }
+        if (this.unit) {
+            params.unit = this.unit;
+        }
+        if (this.unitOptions) {
+            params.unitOptions = this.unitOptions;
+        }
+        return params;
+    }
+    get el() { return getElement(this); }
+    static get watchers() { return {
+        "referenceElement": ["referenceElementWatcher"],
+        "icon": ["iconWatcher"],
+        "unit": ["unitWatcher"],
+        "position": ["positionWatcher"],
+        "view": ["viewWatcher"]
+    }; }
+};
+ArcgisAreaMeasurement2d.style = areaMeasurement2dCss;
+
+export { ArcgisAreaMeasurement2d as arcgis_area_measurement_2d };

package/dist/esm/arcgis-area-measurement-3d.entry.js

@@ -0,0 +1,120 @@
+/*!
+ * All material copyright Esri, All Rights Reserved, unless otherwise specified.
+ * See https://js.arcgis.com/4.29/esri/copyright.txt for details.
+ * v4.29.0
+ */
+import { r as registerInstance, c as createEvent, h, g as getElement } from './index-ee66e916.js';
+import { d as newWidgetsAreaMeasurement3D, i as importCoreReactiveUtils } from './index-94c85b30.js';
+import { r as referenceElementHelper, c as checkForView, a as addHandles } from './component-utils-352c412f.js';
+import { o as onDisconnectedHelper } from './disconnected-3f01362d.js';
+
+const areaMeasurement3dCss = "";
+
+const ArcgisAreaMeasurement3d = class {
+    constructor(hostRef) {
+        registerInstance(this, hostRef);
+        this.arcgisAreaMeasurement3dReady = createEvent(this, "arcgisAreaMeasurement3dReady", 7);
+        this._watchHandles = [];
+        this.referenceElement = undefined;
+        this.analysis = undefined;
+        this.icon = undefined;
+        this.unit = undefined;
+        this.unitOptions = undefined;
+        this.position = "bottom-left";
+        this.view = undefined;
+        this.widget = undefined;
+    }
+    referenceElementWatcher(value) {
+        void referenceElementHelper(this, value);
+    }
+    iconWatcher(value) {
+        if (this.widget) {
+            this.widget.icon = value;
+            this.widget.iconClass = value;
+        }
+    }
+    unitWatcher(value) {
+        if (this.widget) {
+            this.widget.unit = value;
+        }
+    }
+    positionWatcher(value) {
+        if (value !== undefined && this.widget) {
+            this.view.ui.move(this.childElem, value);
+        }
+    }
+    viewWatcher(value) {
+        if (value !== undefined && this.widget) {
+            this.widget.view = value;
+        }
+    }
+    //--------------------------------------------------------------------------
+    //
+    //  Methods
+    //
+    //--------------------------------------------------------------------------
+    async clear() {
+        this.widget?.viewModel.clear();
+    }
+    async start() {
+        this.widget?.viewModel.start();
+    }
+    //--------------------------------------------------------------------------
+    //
+    //  Lifecycle
+    //
+    //--------------------------------------------------------------------------
+    async componentDidLoad() {
+        const params = this._createParams();
+        const widget = await newWidgetsAreaMeasurement3D(params);
+        this.widget = widget;
+        await this._addWatchers();
+        this.arcgisAreaMeasurement3dReady.emit();
+        checkForView(this);
+    }
+    disconnectedCallback() {
+        onDisconnectedHelper(this);
+    }
+    render() {
+        return h("div", { ref: (el) => (this.childElem = el) });
+    }
+    //--------------------------------------------------------------------------
+    //
+    //  Private Methods
+    //
+    //--------------------------------------------------------------------------
+    async _addWatchers() {
+        const { watch, whenOnce } = await importCoreReactiveUtils();
+        addHandles(this, [
+            watch(() => this.widget.analysis, (value) => (this.analysis = value))
+        ]);
+        await whenOnce(() => this.widget.unitOptions);
+        this.unitOptions = this.widget.unitOptions;
+    }
+    _createParams() {
+        const params = {
+            container: this.childElem
+        };
+        if (this.view) {
+            params.view = this.view;
+        }
+        if (this.unit) {
+            params.unit = this.unit;
+        }
+        if (this.unitOptions) {
+            params.unitOptions = this.unitOptions;
+        }
+        return params;
+    }
+    get el() { return getElement(this); }
+    static get watchers() { return {
+        "referenceElement": ["referenceElementWatcher"],
+        "icon": ["iconWatcher"],
+        "unit": ["unitWatcher"],
+        "position": ["positionWatcher"],
+        "view": ["viewWatcher"]
+    }; }
+};
+ArcgisAreaMeasurement3d.style = areaMeasurement3dCss;
+
+export { ArcgisAreaMeasurement3d as arcgis_area_measurement_3d };