@arcgis/map-components 4.31.0-next.98 → 4.32.0-next.10

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

@@ -1,147 +0,0 @@
-/*!
- * All material copyright Esri, All Rights Reserved, unless otherwise specified.
- * See https://js.arcgis.com/4.31/esri/copyright.txt for details.
- * v4.31.0-next.98
- */
-import { r as registerInstance, c as createEvent, h, g as getElement } from './index-00ee3636.js';
-
-const ArcgisVersionManagementVersionItem = class {
-    constructor(hostRef) {
-        registerInstance(this, hostRef);
-        this.arcgisManageVersion = createEvent(this, "arcgisManageVersion", 7);
-        this.versionItemElementProps = undefined;
-    }
-    render() {
-        const { versionItemElementProps: { currentUser, currentVersionIdentifier, hasAdvEditingUte, isVersioningApiAvailable, serviceUrl, strings: { actions }, versionInfo, }, } = this;
-        const fullVersionName = versionInfo.versionIdentifier.name;
-        const versionName = fullVersionName.substring(fullVersionName.lastIndexOf(".") + 1); // label
-        const versionOwner = fullVersionName.substring(0, fullVersionName.lastIndexOf(".")); // description
-        const guid = versionInfo.versionIdentifier.guid;
-        const actionElementId = `actionSwitchToVersion_${guid}`;
-        const canEditVersion = versionOwner.toUpperCase() === currentUser.toUpperCase() && isVersioningApiAvailable && hasAdvEditingUte;
-        const isCurrentVersion = currentVersionIdentifier.guid === versionInfo.versionIdentifier.guid;
-        const startActionChangeVersion = (h("calcite-action", { key: 'a23d586f6b51a1fef1e4f9078e592dc1d058f555', disabled: isCurrentVersion, id: actionElementId, icon: "code-branch", text: "", onClick: () => {
-                this.arcgisManageVersion.emit({ actionType: "changeVersion", serviceUrl, versionInfo });
-            }, slot: "actions-start" }));
-        const startActionChangeVersionTooltip = !isCurrentVersion ? (h("calcite-tooltip", { "overlay-positioning": "fixed", referenceElement: actionElementId }, h("span", null, actions.switchToVersion))) : undefined;
-        return (h("calcite-list-item", { key: '7f15ceec0ab4e7320346e8bb53475ebcf17c9317', description: versionOwner, label: versionName, selected: false, value: guid }, startActionChangeVersion, startActionChangeVersionTooltip, h("calcite-action-menu", { key: 'baa224ed104a8ed33fac263c5ff8af566a018faa', "overlay-positioning": "fixed", slot: "actions-end", label: "" }, h("calcite-action", { key: '9d0efcfc68432513a3b7fd78da4b1832d9d63c41', disabled: isCurrentVersion, icon: "code-branch", onClick: () => {
-                this.arcgisManageVersion.emit({ actionType: "changeVersion", serviceUrl, versionInfo });
-            }, scale: "s", text: actions.switchToVersion, textEnabled: true }), h("calcite-action", { key: '35d6fe45c545b9418b08228da189dc4476260fc1', disabled: !canEditVersion || isCurrentVersion, icon: "code-branch-edit", onClick: () => {
-                this.arcgisManageVersion.emit({ actionType: "editVersion", serviceUrl, versionInfo });
-            }, scale: "s", text: actions.editVersion, textEnabled: true }), h("calcite-action", { key: '16fca39ec2ca22a8756a2ee048207d0d5e27a29c', disabled: !canEditVersion || (canEditVersion && isCurrentVersion), icon: "trash", onClick: () => {
-                this.arcgisManageVersion.emit({ actionType: "deleteVersion", serviceUrl, versionInfo });
-            }, scale: "s", text: actions.deleteVersion, textEnabled: true }))));
-    }
-    get el() { return getElement(this); }
-};
-
-const ArcgisVersionManagementVersionList = class {
-    constructor(hostRef) {
-        registerInstance(this, hostRef);
-        this.arcgisNewVersion = createEvent(this, "arcgisNewVersion", 7);
-        this.arcgisGetVersions = createEvent(this, "arcgisGetVersions", 7);
-        this.arcgisManageVersion = createEvent(this, "arcgisManageVersion", 7);
-        this._handleFilterChange = () => {
-            const { versionListElementProps: { versionInfos }, } = this;
-            const filterText = this._filterInputElement.value.toUpperCase();
-            this._filteredVersionInfos =
-                filterText === ""
-                    ? versionInfos
-                    : versionInfos.filter((version) => version.versionIdentifier.name.toUpperCase().includes(filterText) ||
-                        version.versionIdentifier.guid.toUpperCase().includes(filterText));
-            if (this._filteredVersionInfos.length) {
-                this.currentPage = 1;
-            }
-        };
-        this._handleNoticeClosed = () => {
-            this.versionListElementProps = {
-                ...this.versionListElementProps,
-                executionError: undefined,
-            };
-        };
-        this._handlePaginationChange = (event) => {
-            this.currentPage = event.target.startItem;
-        };
-        this.currentPage = 1;
-        this.versionListElementProps = undefined;
-        this._filteredVersionInfos = undefined;
-    }
-    propertiesChangeHandler(newValue, oldValue) {
-        if (oldValue.versionInfos !== newValue.versionInfos) {
-            this._filteredVersionInfos = this.versionListElementProps.versionInfos;
-            if (this._filterInputElement) {
-                this._handleFilterChange();
-            }
-        }
-    }
-    componentWillLoad() {
-        this._filteredVersionInfos = this.versionListElementProps.versionInfos;
-    }
-    componentDidRender() {
-        this._filterInputElement?.setFocus();
-    }
-    render() {
-        const { currentPage, versionListElementProps: { closable, currentUser, currentVersionIdentifier, executionError, hasAdvEditingUte, heading, isVersioningApiAvailable, pageSize, serviceName, serviceUrl, state, strings: { headers }, strings, versionInfos, }, } = this;
-        const currentVersionIdentifierBlock = (h("calcite-block", { heading: headers.currentVersion, description: currentVersionIdentifier.name, overlayPositioning: "fixed" }));
-        const actionRefreshVersions = (h("calcite-action", { id: "actionRefreshVersions", icon: "refresh", text: "", onClick: () => {
-                this.arcgisGetVersions.emit({
-                    serviceUrl,
-                });
-            }, slot: "header-actions-end" }, h("calcite-tooltip", { "overlay-positioning": "fixed", referenceElement: "actionRefreshVersions" }, h("span", null, strings.actions.refreshVersions))));
-        this._paginatedVersionInfos =
-            this._filteredVersionInfos.length > pageSize
-                ? this._paginate(this._filteredVersionInfos, pageSize, currentPage)
-                : this._filteredVersionInfos;
-        const pagination = this._filteredVersionInfos.length > pageSize ? (h("calcite-pagination", { onCalcitePaginationChange: this._handlePaginationChange, pageSize: 1, startItem: currentPage, totalItems: Math.ceil(this._filteredVersionInfos.length / pageSize) })) : undefined;
-        const versionItems = this._paginate(this._paginatedVersionInfos, pageSize, 1).map((versionInfo) => {
-            const versionItemElementProps = {
-                currentUser,
-                currentVersionIdentifier,
-                isCurrentVersionCard: false,
-                hasAdvEditingUte,
-                isVersioningApiAvailable,
-                serviceUrl,
-                strings,
-                versionInfo,
-            };
-            return (h("arcgis-version-management-version-item", { versionItemElementProps: versionItemElementProps }));
-        });
-        const versionFilter = versionInfos.length > pageSize ? (h("calcite-block", { heading: "", open: true }, h("calcite-input-text", { ref: (node) => {
-                this._filterInputElement = node;
-            }, clearable: true, icon: "search", onCalciteInputTextInput: this._handleFilterChange, placeholder: strings.actions.searchVersions }))) : undefined;
-        const versionList = h("calcite-list", null, versionItems);
-        const newVersionButton = isVersioningApiAvailable && hasAdvEditingUte ? (h("calcite-fab", { appearance: "outline-fill", slot: "fab", textEnabled: true, text: strings.actions.newVersion, onClick: () => {
-                this.arcgisNewVersion.emit({
-                    serviceUrl,
-                });
-            } })) : undefined;
-        const noticeError = executionError ? (h("calcite-notice", { onCalciteNoticeClose: this._handleNoticeClosed, class: "notice", closable: true, kind: "warning", open: true, scale: "s", slot: "footer", width: "full" }, h("div", { slot: "message" }, this._getExecutionError(executionError)))) : undefined;
-        return (h("calcite-flow-item", { closable: closable, description: serviceName, heading: heading }, h("calcite-panel", { loading: state === "executing" }, currentVersionIdentifierBlock, h("calcite-panel", { heading: this._filteredVersionInfos.length
-                ? `${strings.headers.manageVersions} (${this._filteredVersionInfos.length})`
-                : strings.headers.manageVersions }, actionRefreshVersions, versionFilter, versionList, newVersionButton), pagination, noticeError)));
-    }
-    _getExecutionError(executionError) {
-        const { versionListElementProps: { 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;
-        }
-    }
-    _paginate(versionInfos, pageSize, pageNumber) {
-        return versionInfos.slice((pageNumber - 1) * pageSize, pageNumber * pageSize);
-    }
-    get el() { return getElement(this); }
-    static get watchers() { return {
-        "versionListElementProps": ["propertiesChangeHandler"]
-    }; }
-};
-
-export { ArcgisVersionManagementVersionItem as arcgis_version_management_version_item, ArcgisVersionManagementVersionList as arcgis_version_management_version_list };

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

@@ -1,317 +0,0 @@
-/*!
- * All material copyright Esri, All Rights Reserved, unless otherwise specified.
- * See https://js.arcgis.com/4.31/esri/copyright.txt for details.
- * v4.31.0-next.98
- */
-import { r as registerInstance, c as createEvent, h, F as Fragment, g as getElement } from './index-00ee3636.js';
-import { l as load } from './index-880a56ef.js';
-import { i as importCoreReactiveUtils, al as newWidgetsVersionManagementVersionManagementViewModel } from './index-f390619b.js';
-import { u as useT9n, m as makeViewModelController } from './useViewModel-df2c0c4a.js';
-import { u as useControllerManager } from './index-7153e8fb.js';
-import './component-utils-fef50fe4.js';
-
-const versionManagementCss = ".calcite-flow-widget{width:350px}calcite-block{margin:0}calcite-pagination{justify-content:center}";
-const ArcgisVersionManagementStyle0 = versionManagementCss;
-
-const useVersionManagementViewModel = makeViewModelController(newWidgetsVersionManagementVersionManagementViewModel);
-const ArcgisVersionManagement = class {
-    constructor(hostRef) {
-        registerInstance(this, hostRef);
-        this.arcgisReady = createEvent(this, "arcgisReady", 7);
-        this.arcgisVersioningStateChanged = createEvent(this, "arcgisVersioningStateChanged", 7);
-        this.manager = useControllerManager(this);
-        this.reactiveUtils = load(importCoreReactiveUtils);
-        this.viewModel = useVersionManagementViewModel(this);
-        this.messages = useT9n({ blocking: true });
-        this.allowEditingDisabled = false;
-        this.autoDestroyDisabled = false;
-        this.closable = false;
-        this.icon = undefined;
-        this.label = undefined;
-        this.mode = undefined;
-        this.pageSize = 5;
-        this.position = "top-right";
-        this.referenceElement = undefined;
-        this.state = this.viewModel.state;
-        this.versioningStates = this.viewModel.versioningStates;
-        this.view = this.viewModel.view;
-    }
-    //--------------------------------------------------------------------------
-    //
-    //  Public Methods
-    //
-    //--------------------------------------------------------------------------
-    async componentWillLoad() {
-        const { watch } = this.reactiveUtils;
-        this.manager.onLifecycle(() => [
-            watch(() => this.viewModel.state, (state) => {
-                const { flowElement } = this;
-                const versionProperties = flowElement?.getElementsByTagName("arcgis-version-management-version-properties")[0];
-                const versionList = flowElement?.getElementsByTagName("arcgis-version-management-version-list")[0];
-                if (state === "disabled") {
-                    if (versionProperties) {
-                        this._removeVersionPropertiesFlowItem(flowElement);
-                    }
-                    if (versionList) {
-                        this._removeVersionListFlowItem(flowElement);
-                    }
-                    return;
-                }
-                if (versionList) {
-                    versionList.versionListElementProps = {
-                        ...versionList.versionListElementProps,
-                        executionError: this.viewModel.executionError,
-                    };
-                    versionList.versionListElementProps = {
-                        ...versionList.versionListElementProps,
-                        state,
-                    };
-                }
-                if (versionProperties) {
-                    versionProperties.versionPropertiesElementProps = {
-                        ...versionProperties.versionPropertiesElementProps,
-                        state,
-                    };
-                }
-            }),
-        ]);
-    }
-    /** Permanently destroy the component */
-    async destroy() {
-        await this.manager.destroy();
-    }
-    render() {
-        const { allowEditingDisabled, closable, flowElement, label, messages, pageSize, viewModel, viewModel: { loadError, state }, } = this;
-        const arrayServiceNames = Array.from(viewModel.serviceNameLookup, ([url, name]) => ({ url, name }));
-        const serviceItems = state !== "disabled" ? (h(Fragment, null, arrayServiceNames.map((service) => {
-            const serviceItemElementProps = {
-                allowEditing: !allowEditingDisabled,
-                closable,
-                currentUser: viewModel.userLookup.get(service.url),
-                currentVersionIdentifier: viewModel.versioningStateLookup.get(service.url).currentVersionInfo
-                    .versionIdentifier,
-                executionError: undefined,
-                flowElement: flowElement,
-                hasAdvEditingUte: viewModel.advancedEditingUserTypeExtensionLookup.get(service.url),
-                heading: label,
-                isVersioningApiAvailable: (viewModel.serverVersionLookup.get(service.url) ?? 0) >= 11.2,
-                pageSize,
-                serviceName: service.name,
-                state,
-                serviceUrl: service.url,
-                strings: messages,
-                versionInfos: viewModel.versioningStateLookup.get(service.url)?.versionInfos ?? [],
-            };
-            return (h("arcgis-version-management-service-item", { serviceItemElementProps: serviceItemElementProps, onArcgisGetVersions: async (event) => {
-                    await this._refreshVersionList(event.detail.serviceUrl);
-                }, onArcgisFlowItemBack: () => {
-                    this._removeVersionListFlowItem(flowElement);
-                }, onArcgisFlowItemClose: () => {
-                    this._handleFlowItemClose();
-                }, onArcgisManageVersion: (event) => {
-                    this._handleManageVersionAction(event, flowElement);
-                }, onArcgisNewVersion: (event) => {
-                    const versionPropertiesFlow = this._createVersionPropertiesFlowItem(event.detail.serviceUrl, undefined);
-                    flowElement?.appendChild(versionPropertiesFlow);
-                } }));
-        }))) : undefined;
-        const notice = state === "disabled" ? (h("calcite-notice", { class: "notice", closable: false, kind: "warning", open: true, scale: "s", slot: "footer", width: "full" }, h("div", { slot: "message" }, this._getLoadError(loadError)))) : undefined;
-        return (h("calcite-flow", { ref: (node) => {
-                this.flowElement = node;
-            }, class: this.mode === "dialog" ? "" : "calcite-flow-widget" }, h("calcite-flow-item", { closable: this.closable, heading: label ?? undefined, onCalciteFlowItemClose: () => {
-                this._handleFlowItemClose();
-            } }, h("calcite-panel", { loading: state === "loading" || state === "executing" }, serviceItems, notice))));
-    }
-    //--------------------------------------------------------------------------
-    //
-    //  Private Methods
-    //
-    //--------------------------------------------------------------------------
-    _createVersionPropertiesFlowItem(serviceUrl, versionInfo) {
-        const { closable, flowElement, viewModel, viewModel: { state }, } = this;
-        const versionProperties = document.createElement("arcgis-version-management-version-properties");
-        versionProperties.versionPropertiesElementProps = {
-            closable,
-            currentUser: viewModel.userLookup.get(serviceUrl),
-            hasAdvEditingUte: viewModel.advancedEditingUserTypeExtensionLookup.get(serviceUrl),
-            serviceUrl,
-            state,
-            strings: this.messages,
-            versionInfo,
-        };
-        versionProperties.addEventListener("arcgisCreateVersion", (event) => {
-            const { createVersionParameters, switchToVersion } = event.detail;
-            viewModel
-                .createVersion(createVersionParameters)
-                .then(async (createVersionResult) => {
-                if (createVersionResult) {
-                    this.arcgisVersioningStateChanged.emit({
-                        type: "version-created",
-                        versionIdentifier: createVersionResult.versionIdentifier,
-                        versioningState: viewModel.versioningStateLookup.get(serviceUrl),
-                    });
-                }
-                if (switchToVersion) {
-                    await this.viewModel
-                        .changeVersion(serviceUrl, createVersionResult.versionIdentifier.name, createVersionResult.versionIdentifier.guid)
-                        .then((changeVersionResult) => {
-                        if (changeVersionResult) {
-                            this.arcgisVersioningStateChanged.emit({
-                                type: "version-switched",
-                                versionIdentifier: createVersionResult.versionIdentifier,
-                                versioningState: viewModel.versioningStateLookup.get(serviceUrl),
-                            });
-                        }
-                    });
-                }
-                await this._refreshVersionList(serviceUrl);
-            })
-                .finally(() => {
-                this._removeVersionPropertiesFlowItem(flowElement);
-            });
-        });
-        versionProperties.addEventListener("arcgisAlterVersion", async (event) => {
-            const { flowElement } = this;
-            const { alterVersionParameters } = event.detail;
-            await viewModel
-                .alterVersion(alterVersionParameters)
-                .then(async (alterVersionResult) => {
-                if (alterVersionResult) {
-                    this.arcgisVersioningStateChanged.emit({
-                        type: "version-changed",
-                        versionIdentifier: alterVersionParameters.versionIdentifier,
-                        versioningState: viewModel.versioningStateLookup.get(serviceUrl),
-                    });
-                }
-                await this._refreshVersionList(serviceUrl);
-            })
-                .finally(() => {
-                this._removeVersionPropertiesFlowItem(flowElement);
-            });
-        });
-        versionProperties.addEventListener("arcgisFlowItemBack", () => {
-            this._removeVersionPropertiesFlowItem(this.flowElement);
-        });
-        versionProperties.addEventListener("calciteFlowItemBack", (event) => {
-            event.preventDefault();
-            this._removeVersionPropertiesFlowItem(this.flowElement);
-        });
-        versionProperties.addEventListener("calciteFlowItemClose", () => {
-            this._handleFlowItemClose();
-        });
-        return versionProperties;
-    }
-    _getLoadError(loadError) {
-        const { messages } = this;
-        switch (loadError) {
-            case "no-feature-services":
-                return messages.loadErrors.noFeatureServices;
-            case "no-view-property":
-                return messages.loadErrors.noViewProperty;
-            default:
-                return loadError;
-        }
-    }
-    _handleFlowItemClose() {
-        const versionManagementComponent = document.querySelector("arcgis-version-management");
-        const parentElement = versionManagementComponent.parentElement;
-        parentElement?.removeChild(versionManagementComponent);
-    }
-    async _handleManageVersionAction(e, flowElement) {
-        const { actionType, serviceUrl, versionInfo } = e.detail;
-        const { viewModel } = this;
-        switch (actionType) {
-            case "changeVersion": {
-                viewModel
-                    .changeVersion(serviceUrl, versionInfo.versionIdentifier.name, versionInfo.versionIdentifier.guid)
-                    .then((changeVersionResult) => {
-                    if (changeVersionResult) {
-                        this.arcgisVersioningStateChanged.emit({
-                            type: "version-switched",
-                            versionIdentifier: versionInfo.versionIdentifier,
-                            versioningState: viewModel.versioningStateLookup.get(serviceUrl),
-                        });
-                    }
-                    const versionList = flowElement?.getElementsByTagName("arcgis-version-management-version-list")[0];
-                    if (versionList) {
-                        if (versionList) {
-                            versionList.versionListElementProps = {
-                                ...versionList.versionListElementProps,
-                                currentVersionIdentifier: viewModel.versioningStateLookup.get(serviceUrl).currentVersionInfo.versionIdentifier,
-                            };
-                        }
-                    }
-                });
-                break;
-            }
-            case "deleteVersion": {
-                viewModel
-                    .deleteVersion(serviceUrl, versionInfo.versionIdentifier.name, versionInfo.versionIdentifier.guid)
-                    .then(async (deleteVersionResult) => {
-                    if (deleteVersionResult) {
-                        this.arcgisVersioningStateChanged.emit({
-                            type: "version-deleted",
-                            versionIdentifier: versionInfo.versionIdentifier,
-                            versioningState: viewModel.versioningStateLookup.get(serviceUrl),
-                        });
-                    }
-                    await this._refreshVersionList(serviceUrl);
-                });
-                break;
-            }
-            case "editVersion": {
-                const versionPropertiesFlow = this._createVersionPropertiesFlowItem(serviceUrl, versionInfo);
-                flowElement.appendChild(versionPropertiesFlow);
-                break;
-            }
-        }
-    }
-    async _refreshVersionList(serviceUrl) {
-        const { flowElement, viewModel } = this;
-        if (flowElement) {
-            const versionInfos = await viewModel.getVersionInfos(serviceUrl);
-            const serviceItemElements = flowElement.getElementsByTagName("arcgis-version-management-service-item");
-            for (const serviceItemElement of serviceItemElements) {
-                if (serviceItemElement.serviceItemElementProps.serviceUrl === serviceUrl) {
-                    serviceItemElement.serviceItemElementProps = {
-                        ...serviceItemElement.serviceItemElementProps,
-                        versionInfos,
-                    };
-                }
-            }
-            const versionListElement = flowElement.getElementsByTagName("arcgis-version-management-version-list")[0];
-            if (versionListElement) {
-                versionListElement.versionListElementProps = {
-                    ...versionListElement.versionListElementProps,
-                    currentVersionIdentifier: viewModel.versioningStateLookup.get(serviceUrl).currentVersionInfo.versionIdentifier,
-                    versionInfos,
-                };
-            }
-        }
-    }
-    _removeVersionListFlowItem(flowElement) {
-        for (const childNode of flowElement.childNodes) {
-            if (childNode.nodeName.toUpperCase() === "ARCGIS-VERSION-MANAGEMENT-VERSION-LIST") {
-                flowElement.removeChild(childNode);
-            }
-            if (childNode.nodeName.toUpperCase() === "CALCITE-FLOW-ITEM") {
-                childNode.hidden = false;
-            }
-        }
-    }
-    _removeVersionPropertiesFlowItem(flowElement) {
-        for (const childNode of flowElement.childNodes) {
-            if (childNode.nodeName.toUpperCase() === "ARCGIS-VERSION-MANAGEMENT-VERSION-PROPERTIES") {
-                flowElement.removeChild(childNode);
-            }
-            if (childNode.nodeName.toUpperCase() === "ARCGIS-VERSION-MANAGEMENT-VERSION-LIST") {
-                childNode.getElementsByTagName("calcite-flow-item")[0].hidden = false;
-            }
-        }
-    }
-    static get assetsDirs() { return ["assets"]; }
-    get el() { return getElement(this); }
-};
-ArcgisVersionManagement.style = ArcgisVersionManagementStyle0;
-
-export { ArcgisVersionManagement as arcgis_version_management };

package/dist/esm/arcgis-weather.entry.js

@@ -1,48 +0,0 @@
-/*!
- * All material copyright Esri, All Rights Reserved, unless otherwise specified.
- * See https://js.arcgis.com/4.31/esri/copyright.txt for details.
- * v4.31.0-next.98
- */
-import { r as registerInstance, c as createEvent, g as getElement } from './index-00ee3636.js';
-import { am as newWidgetsWeather } from './index-f390619b.js';
-import { u as usePropertyChange } from './index-880a56ef.js';
-import { m as makeWidgetController } from './useWidget-747e5aa5.js';
-import { u as useControllerManager } from './index-7153e8fb.js';
-import './component-utils-fef50fe4.js';
-
-const weatherCss = "";
-const ArcgisWeatherStyle0 = weatherCss;
-
-const useWeatherWidget = makeWidgetController(newWidgetsWeather);
-const ArcgisWeather = class {
-    constructor(hostRef) {
-        registerInstance(this, hostRef);
-        this.arcgisReady = createEvent(this, "arcgisReady", 7);
-        this.arcgisPropertyChange = createEvent(this, "arcgisPropertyChange", 7);
-        this.manager = useControllerManager(this);
-        this.widget = useWeatherWidget(this);
-        this.viewModel = this.widget.viewModel;
-        this.arcgisPropertyChange = usePropertyChange()("state");
-        this.autoDestroyDisabled = false;
-        this.referenceElement = undefined;
-        this.icon = this.widget.icon;
-        this.label = this.widget.label;
-        this.headingLevel = this.widget.headingLevel;
-        this.hideHeader = this.widget.visibleElements.header;
-        this.position = "bottom-left";
-        this.state = this.viewModel.state;
-    }
-    //--------------------------------------------------------------------------
-    //
-    //  Methods
-    //
-    //--------------------------------------------------------------------------
-    /** Permanently destroy the component */
-    async destroy() {
-        await this.manager.destroy();
-    }
-    get el() { return getElement(this); }
-};
-ArcgisWeather.style = ArcgisWeatherStyle0;
-
-export { ArcgisWeather as arcgis_weather };

package/dist/esm/arcgis-zoom.entry.js

@@ -1,87 +0,0 @@
-/*!
- * All material copyright Esri, All Rights Reserved, unless otherwise specified.
- * See https://js.arcgis.com/4.31/esri/copyright.txt for details.
- * v4.31.0-next.98
- */
-import { r as registerInstance, c as createEvent, h, g as getElement } from './index-00ee3636.js';
-import { u as usePropertyChange } from './index-880a56ef.js';
-import { t as classes, an as newWidgetsZoomZoomViewModel } from './index-f390619b.js';
-import { u as useT9n, m as makeViewModelController } from './useViewModel-df2c0c4a.js';
-import { g as globalCss } from './globalCss-94641557.js';
-import { u as useControllerManager } from './index-7153e8fb.js';
-import './component-utils-fef50fe4.js';
-
-const css = {
-    base: "esri-zoom",
-    horizontalLayout: "esri-zoom--horizontal",
-};
-
-const zoomCss = ".esri-zoom{display:flex;flex-flow:column nowrap}.esri-zoom .esri-widget--button{box-shadow:none}.esri-zoom .esri-widget--button:first-child{margin-bottom:0}.esri-zoom .esri-widget--button:last-child{border-top:solid 1px var(--calcite-color-border-1)}.esri-zoom.esri-zoom--horizontal{flex-flow:row-reverse nowrap}.esri-zoom.esri-zoom--horizontal .esri-widget--button:last-child{border-top:none}.esri-zoom.esri-zoom--horizontal .esri-widget--button:first-child{border-left:solid 1px var(--calcite-color-border-1)}[dir=\"rtl\"] .esri-zoom.esri-zoom--horizontal .esri-widget--button:first-child{border-top:none}[dir=\"rtl\"] .esri-zoom.esri-zoom--horizontal .esri-widget--button:last-child{border-left:solid 1px var(--calcite-color-border-1)}";
-const ArcgisZoomStyle0 = zoomCss;
-
-const useZoomViewModel = makeViewModelController(newWidgetsZoomZoomViewModel);
-const ArcgisZoom = class {
-    constructor(hostRef) {
-        registerInstance(this, hostRef);
-        this.arcgisPropertyChange = createEvent(this, "arcgisPropertyChange", 7);
-        this.arcgisReady = createEvent(this, "arcgisReady", 7);
-        //--------------------------------------------------------------------------
-        //
-        //  Controllers
-        //
-        //--------------------------------------------------------------------------
-        this.manager = useControllerManager(this);
-        this.messages = useT9n({});
-        this.viewModel = useZoomViewModel(this);
-        //--------------------------------------------------------------------------
-        //
-        //  Events
-        //
-        //--------------------------------------------------------------------------
-        this.arcgisPropertyChange = usePropertyChange()("state");
-        this.autoDestroyDisabled = false;
-        this.icon = "magnifying-glass-plus";
-        this.label = undefined;
-        this.layout = "vertical";
-        this.messageOverrides = undefined;
-        this.position = "top-left";
-        this.referenceElement = undefined;
-        this.state = this.viewModel.state;
-        this.canZoomIn = this.viewModel.canZoomIn;
-        this.canZoomOut = this.viewModel.canZoomOut;
-    }
-    //--------------------------------------------------------------------------
-    //
-    //  Public Methods
-    //
-    //--------------------------------------------------------------------------
-    /** Permanently destroy the component */
-    async destroy() {
-        await this.manager.destroy();
-    }
-    /**
-     * Zooms the view in by an LOD factor of 0.5.
-     */
-    async zoomIn() {
-        this.viewModel.zoomIn();
-    }
-    /**
-     * Zooms the view out by an LOD factor of 2.
-     */
-    async zoomOut() {
-        this.viewModel.zoomOut();
-    }
-    render() {
-        const rootClasses = {
-            [css.horizontalLayout]: this.layout === "horizontal",
-        };
-        const { canZoomIn, canZoomOut } = this.viewModel;
-        const { zoomIn, zoomOut } = this.messages;
-        return (h("div", { key: '1669be1a2b0018a4efa0009cf4a465339801af84', class: classes(css.base, globalCss.widget, rootClasses) }, h("calcite-button", { key: 'e283c90ad1ab58d6fc6d87b7eb79f87b8642e418', class: globalCss.widgetButton, disabled: !canZoomIn, iconStart: "plus", kind: "neutral", label: zoomIn, onClick: this.zoomIn.bind(this), title: zoomIn }), h("calcite-button", { key: '1a47a30cb4cf74f4ffc3c8e7d159f32c08c410f6', class: globalCss.widgetButton, disabled: !canZoomOut, iconStart: "minus", kind: "neutral", label: zoomOut, onClick: this.zoomOut.bind(this), title: zoomOut })));
-    }
-    static get assetsDirs() { return ["assets"]; }
-    get el() { return getElement(this); }
-};
-ArcgisZoom.style = ArcgisZoomStyle0;
-
-export { ArcgisZoom as arcgis_zoom };