@esri/solutions-components 0.8.3 → 0.8.4

package/dist/cjs/map-tools.cjs.entry.js

@@ -1,375 +0,0 @@
-/*!
- * Copyright 2022 Esri
- * Licensed under the Apache License, Version 2.0
- * http://www.apache.org/licenses/LICENSE-2.0
- */
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-const index = require('./index-b53bfd7c.js');
-const locale = require('./locale-42a9e623.js');
-const loadModules = require('./loadModules-b5f244cd.js');
-require('./esri-loader-5b8fbfa4.js');
-require('./_commonjsHelpers-ed90c4ad.js');
-
-const mapToolsCss = ":host{display:block}.display-none{display:none}.margin-top-1-2{margin-top:0.5rem}.square-32{width:32px;height:32px}.square-40{width:40px;height:40px}.square-48{width:48px;height:48px}.width-40{width:40px}.square-40-41{width:40px;height:41px}.border-bottom{border-bottom:1px solid var(--calcite-color-border-3)}.box-shadow{box-shadow:0 1px 2px rgba(0, 0, 0, 0.3)}.margin-bottom-1-2{margin-bottom:0.5rem}";
-
-const MapTools = class {
-    constructor(hostRef) {
-        index.registerInstance(this, hostRef);
-        /**
-         * string[]: List of widget names that have been added to the UI
-         * This prop is only used when enableSingleExpand is false
-         */
-        this._widgets = [];
-        this.basemapConfig = undefined;
-        this.enableLegend = undefined;
-        this.enableFloorFilter = undefined;
-        this.enableFullscreen = undefined;
-        this.enableSearch = undefined;
-        this.enableBasemap = undefined;
-        this.enableHome = undefined;
-        this.enableSingleExpand = undefined;
-        this.homeZoomToolsSize = "m";
-        this.layout = "vertical";
-        this.mapView = undefined;
-        this.mapWidgetsSize = "m";
-        this.position = "top-right";
-        this.searchConfiguration = undefined;
-        this.stackTools = true;
-        this.toolOrder = undefined;
-        this._hasFloorInfo = false;
-        this._translations = undefined;
-        this._showTools = true;
-        this._showBasemapWidget = false;
-        this._showFloorFilter = false;
-        this._showFullscreen = false;
-        this._showLegendWidget = false;
-        this._showSearchWidget = false;
-    }
-    //--------------------------------------------------------------------------
-    //
-    //  Watch handlers
-    //
-    //--------------------------------------------------------------------------
-    /**
-     * When the mapView loads check if it supports floor awareness
-     */
-    async mapViewWatchHandler() {
-        await this.mapView.when(() => {
-            var _a, _b;
-            this._hasFloorInfo = (_b = (_a = this.mapView) === null || _a === void 0 ? void 0 : _a.map) === null || _b === void 0 ? void 0 : _b.floorInfo;
-        });
-    }
-    /**
-     * When the _showBasemapWidget property is true display the basemap gallery
-     */
-    async _showBasemapWidgetWatchHandler(v) {
-        if (v) {
-            this.mapView.ui.add(this._basemapElement.basemapWidget, {
-                position: this.position,
-                index: 1
-            });
-        }
-        else {
-            this.mapView.ui.remove(this._basemapElement.basemapWidget);
-        }
-    }
-    /**
-     * When the _showBasemapWidget property is true display the basemap gallery
-     */
-    async _showFloorFilterWatchHandler(v) {
-        const widget = this._floorFilterElement.floorFilterWidget;
-        if (v) {
-            this.mapView.ui.add(widget, {
-                position: this.position,
-                index: 1
-            });
-        }
-        else {
-            this.mapView.ui.remove(widget);
-        }
-    }
-    /**
-     * When the _showFullscreen property is true the app will consume the full screen
-     */
-    async _showFullscreenWatchHandler(v) {
-        const fs = this._fullscreenElement.fullscreenWidget;
-        if (v) {
-            if (fs.viewModel.state === "ready") {
-                fs.viewModel.enter();
-            }
-        }
-        else {
-            if (fs.viewModel.state === "active") {
-                fs.viewModel.exit();
-            }
-        }
-    }
-    /**
-     * When the _showLegendWidget property is true display the search widget
-     */
-    async _showLegendWidgetWatchHandler(v) {
-        if (v) {
-            this.mapView.ui.add(this._legendElement.legendWidget, {
-                position: this.position,
-                index: 1
-            });
-        }
-        else {
-            this.mapView.ui.remove(this._legendElement.legendWidget);
-        }
-    }
-    /**
-     * When the _showSearchWidget property is true display the search widget
-     */
-    async _showSearchWidgetWatchHandler(v) {
-        if (v) {
-            this.mapView.ui.add(this._searchElement.searchWidget, {
-                position: this.position,
-                index: 1
-            });
-        }
-        else {
-            this.mapView.ui.remove(this._searchElement.searchWidget);
-        }
-    }
-    //--------------------------------------------------------------------------
-    //
-    //  Methods (public)
-    //
-    //--------------------------------------------------------------------------
-    //--------------------------------------------------------------------------
-    //
-    //  Events (public)
-    //
-    //--------------------------------------------------------------------------
-    //--------------------------------------------------------------------------
-    //
-    //  Functions (lifecycle)
-    //
-    //--------------------------------------------------------------------------
-    /**
-     * StencilJS: Called once just after the component is first connected to the DOM.
-     */
-    async componentWillLoad() {
-        await this._getTranslations();
-        await this._initModules();
-    }
-    /**
-     * StencilJS: Renders the component.
-     */
-    render() {
-        this._setZoomToolsSize();
-        const toggleIcon = this._showTools ? "chevrons-up" : "chevrons-down";
-        const toolsClass = this._showTools ? "" : "display-none";
-        const searchClass = this._showSearchWidget ? "" : "display-none";
-        const basemapClass = this._showBasemapWidget ? "" : "display-none";
-        const legendClass = this._showLegendWidget ? "" : "display-none";
-        const floorFilterClass = this._showFloorFilter ? "" : "display-none";
-        const fullscreenClass = this._showFullscreen ? "" : "display-none";
-        const expandTip = this._showTools ? this._translations.collapse : this._translations.expand;
-        const containerClass = !this.enableBasemap && !this.enableFullscreen && !this.enableLegend && !this.enableSearch ? "display-none" : "";
-        const toolMarginClass = this.enableSingleExpand ? "margin-top-1-2" : "";
-        const toolOrder = this.toolOrder ? this.toolOrder : ["legend", "search", "fullscreen", "floorfilter"];
-        const shadowClass = this.stackTools ? "box-shadow" : "";
-        return (index.h(index.Host, null, index.h("div", { class: containerClass }, this.enableSingleExpand ? (index.h("div", { class: "box-shadow" }, this._getActionGroup(toggleIcon, false, expandTip, () => this._toggleTools()))) : undefined, index.h("div", { class: `${toolMarginClass} ${shadowClass} ${toolsClass}` }, this._getMapWidgets(toolOrder))), index.h("basemap-gallery", { basemapConfig: this.basemapConfig, class: basemapClass, mapView: this.mapView, ref: (el) => { this._basemapElement = el; } }), index.h("map-search", { class: searchClass, mapView: this.mapView, ref: (el) => { this._searchElement = el; }, resultGraphicEnabled: true, searchConfiguration: this.searchConfiguration }), index.h("map-legend", { class: legendClass, mapView: this.mapView, ref: (el) => { this._legendElement = el; } }), index.h("map-fullscreen", { class: fullscreenClass, mapView: this.mapView, onFullscreenStateChange: (evt) => this._fullscreenStateChange(evt.detail), ref: (el) => { this._fullscreenElement = el; } }), index.h("floor-filter", { class: floorFilterClass, enabled: this.enableFloorFilter, mapView: this.mapView, ref: (el) => { this._floorFilterElement = el; } })));
-    }
-    //--------------------------------------------------------------------------
-    //
-    //  Functions (protected)
-    //
-    //--------------------------------------------------------------------------
-    /**
-     * Load esri javascript api modules
-     *
-     * @returns Promise resolving when function is done
-     *
-     * @protected
-     */
-    async _initModules() {
-        const [Expand] = await loadModules.loadModules([
-            "esri/widgets/Expand"
-        ]);
-        this.Expand = Expand;
-    }
-    /**
-     * Set the size of the zoom tools based on the user defined homeZoomToolsSize variable.
-     *
-     * @protected
-     */
-    _setZoomToolsSize() {
-        var _a, _b;
-        const zoomIn = (_a = document.getElementsByClassName("esri-zoom")[0]) === null || _a === void 0 ? void 0 : _a.children[0];
-        const zoomOut = (_b = document.getElementsByClassName("esri-zoom")[0]) === null || _b === void 0 ? void 0 : _b.children[1];
-        if (zoomIn && zoomOut) {
-            const size = this.homeZoomToolsSize === "s" ? "32px" : this.homeZoomToolsSize === "m" ? "40px" : "48px";
-            zoomIn.style.width = size;
-            zoomIn.style.height = size;
-            zoomOut.style.width = size;
-            zoomOut.style.height = size;
-        }
-    }
-    /**
-     * Get the map widgets considering the user defined enabled values and tool order
-     *
-     * @protected
-     */
-    _getMapWidgets(toolOrder) {
-        const fullscreenIcon = this._showFullscreen ? "full-screen-exit" : "full-screen";
-        const fullscreenTip = this._showFullscreen ? this._translations.exitFullscreen : this._translations.enterFullscreen;
-        return toolOrder.map(t => {
-            var _a, _b, _c, _d, _e;
-            switch (t) {
-                case "legend":
-                    return this.enableLegend && this.enableSingleExpand ?
-                        this._getActionGroup("legend", false, this._translations.legend, () => this._showLegend()) :
-                        this.enableLegend ? this._getWidget(t, (_a = this._legendElement) === null || _a === void 0 ? void 0 : _a.legendWidget, true) : undefined;
-                case "search":
-                    return this.enableSearch && this.enableSingleExpand ?
-                        this._getActionGroup("magnifying-glass", false, this._translations.search, () => this._search()) :
-                        this.enableSearch ? this._getWidget(t, (_b = this._searchElement) === null || _b === void 0 ? void 0 : _b.searchWidget, true) : undefined;
-                case "fullscreen":
-                    return this.enableFullscreen && this.enableSingleExpand ?
-                        this._getActionGroup(fullscreenIcon, false, fullscreenTip, () => this._expand()) :
-                        this.enableFullscreen ? this._getWidget(t, (_c = this._fullscreenElement) === null || _c === void 0 ? void 0 : _c.fullscreenWidget, false) : undefined;
-                case "basemap":
-                    return this.enableBasemap && this.enableSingleExpand ?
-                        this._getActionGroup("basemap", false, this._translations.basemap, () => this._toggleBasemapPicker()) :
-                        this.enableBasemap ? this._getWidget(t, (_d = this._basemapElement) === null || _d === void 0 ? void 0 : _d.basemapWidget, true) : undefined;
-                case "floorfilter":
-                    return this.enableFloorFilter && this._hasFloorInfo && this.enableSingleExpand ?
-                        this._getActionGroup("urban-model", false, this._translations.floorFilter, () => this._toggleFloorFilter()) :
-                        this.enableFloorFilter && this._hasFloorInfo ? this._getWidget(t, (_e = this._floorFilterElement) === null || _e === void 0 ? void 0 : _e.floorFilterWidget, true) : undefined;
-                default:
-                    break;
-            }
-        });
-    }
-    /**
-     * Respond to fullscreen state change and ensure our state var is in sync
-     *
-     * @param state The fullscreen view model's state.
-     *
-     * @protected
-     */
-    _fullscreenStateChange(state) {
-        if (state === "ready" && this._showFullscreen) {
-            this._showFullscreen = false;
-        }
-        else if (state === "active" && !this._showFullscreen) {
-            this._showFullscreen = true;
-        }
-    }
-    /**
-     * Get a calcite action group for the current action
-     *
-     * @param icon the icon to display for the current action
-     * @param disabled should the action be disabled
-     * @param tip information tip to display helpful details to end user
-     * @param func the associated onClick function to execute
-     *
-     * @returns the dom node for the action group
-     *
-     * @protected
-     */
-    _getActionGroup(icon, disabled, tip, func) {
-        const sizeClass = this.mapWidgetsSize === "s" ? "square-32" : this.mapWidgetsSize === "m" ? "square-40" : "square-48";
-        const stackClass = this.stackTools ? "" : "margin-bottom-1-2";
-        const shadowClass = this.stackTools ? "" : "box-shadow";
-        return (index.h("div", null, index.h("calcite-action", { alignment: "center", class: `${sizeClass} ${stackClass} border-bottom ${shadowClass}`, compact: false, disabled: disabled, icon: icon, id: icon, onClick: func, scale: "s", text: "" }, index.h("calcite-icon", { icon: "cheveron-up", scale: "s", slot: "icon" })), index.h("calcite-tooltip", { label: "", placement: "trailing", "reference-element": icon }, index.h("span", null, tip))));
-    }
-    /**
-     * Add the widget to the UI and optionally to an Expand widget
-     *
-     * @param name the icon to display for the current action
-     * @param content the widget to display
-     * @param internalExpand when true the widget will be added to an Expand widget
-     *
-     * @protected
-     */
-    _getWidget(name, content, internalExpand) {
-        if (this._widgets.indexOf(name) < 0 && this.mapView && content) {
-            const i = this.toolOrder.indexOf(name);
-            const exp = new this.Expand({
-                view: this.mapView,
-                content
-            });
-            const v = this.enableHome ? 2 : 1;
-            this.mapView.ui.add(internalExpand ? exp : content, {
-                position: this.position,
-                index: i > -1 ? i + v : 1
-            });
-            this._widgets.push(name);
-        }
-    }
-    /**
-     * Show/Hide the legend widget
-     */
-    _showLegend() {
-        this._showLegendWidget = !this._showLegendWidget;
-        this._showTools = false;
-    }
-    /**
-     * Show/Hide the search widget
-     */
-    _search() {
-        this._showSearchWidget = !this._showSearchWidget;
-        this._showTools = false;
-    }
-    /**
-     * Show/Hide the basemap picker
-     */
-    _toggleBasemapPicker() {
-        this._showBasemapWidget = !this._showBasemapWidget;
-        this._showTools = false;
-    }
-    /**
-     * Show/Hide the floor filter
-     */
-    _toggleFloorFilter() {
-        this._showFloorFilter = !this._showFloorFilter;
-        this._showTools = false;
-    }
-    /**
-     * Enter/Exit fullscreen mode
-     */
-    _expand() {
-        this._showFullscreen = !this._showFullscreen;
-    }
-    /**
-     * Show/Hide the map tools
-     */
-    _toggleTools() {
-        if (!this._showTools) {
-            this._showBasemapWidget = false;
-            this._showSearchWidget = false;
-            this._showLegendWidget = false;
-            this._showFloorFilter = false;
-        }
-        this._showTools = !this._showTools;
-    }
-    /**
-     * Fetches the component's translations
-     *
-     * @returns Promise when complete
-     * @protected
-     */
-    async _getTranslations() {
-        const messages = await locale.getLocaleComponentStrings(this.el);
-        this._translations = messages[0];
-    }
-    get el() { return index.getElement(this); }
-    static get watchers() { return {
-        "mapView": ["mapViewWatchHandler"],
-        "_showBasemapWidget": ["_showBasemapWidgetWatchHandler"],
-        "_showFloorFilter": ["_showFloorFilterWatchHandler"],
-        "_showFullscreen": ["_showFullscreenWatchHandler"],
-        "_showLegendWidget": ["_showLegendWidgetWatchHandler"],
-        "_showSearchWidget": ["_showSearchWidgetWatchHandler"]
-    }; }
-};
-MapTools.style = mapToolsCss;
-
-exports.map_tools = MapTools;

package/dist/cjs/mapViewUtils-6fa5bab1.js

@@ -1,271 +0,0 @@
-/*!
- * Copyright 2022 Esri
- * Licensed under the Apache License, Version 2.0
- * http://www.apache.org/licenses/LICENSE-2.0
- */
-'use strict';
-
-const queryUtils = require('./queryUtils-aba29fcf.js');
-const interfaces = require('./interfaces-7cd0a48a.js');
-
-/** @license
- * Copyright 2022 Esri
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-/**
- * Gets the layer names from the current map
- *
- * @param mapView the map view to fetch the layer names from
- * @param onlyShowUpdatableLayers when true only layers that support editing and updates will be returned
- *
- * @returns Promise resolving with an array of layer names
- *
- */
-async function getMapLayerHash(mapView, onlyShowUpdatableLayers) {
-    let layerHash;
-    await mapView.when(() => {
-        layerHash = mapView.map.allLayers.toArray().reduce((prev, cur) => {
-            if (cur.type === "feature") {
-                prev[cur.id] = {
-                    name: cur.title,
-                    supportsUpdate: undefined
-                };
-            }
-            return prev;
-        }, {});
-    });
-    return _getFinalHash(onlyShowUpdatableLayers, layerHash, mapView);
-}
-/**
- * Gets the table names from the current map
- *
- * @param mapView the map view to fetch the table names from
- * @param onlyShowUpdatableLayers when true only layers that support editing and updates will be returned
- *
- * @returns Promise resolving with an array of table names
- *
- */
-async function getMapTableHash(mapView, onlyShowUpdatableTables) {
-    let tableHash;
-    await mapView.when(() => {
-        tableHash = mapView.map.allTables.toArray().reduce((prev, cur) => {
-            prev[cur.id] = {
-                name: cur.title,
-                supportsUpdate: undefined
-            };
-            return prev;
-        }, {});
-    });
-    return _getFinalHash(onlyShowUpdatableTables, tableHash, mapView);
-}
-/**
- * Get the final hash
- *
- * @param onlyShowUpdatable boolean when true only layers that support editing and the update capability will be returned
- * @param hash IMapItemHash key: layer id, values: name, supportsUpdate
- * @param mapView the map view to fetch the layer from
- *
- * @returns Promise resolving with IMapItemHash
- *
- */
-async function _getFinalHash(onlyShowUpdatable, hash, mapView) {
-    if (onlyShowUpdatable) {
-        const editableHash = {};
-        const keys = Object.keys(hash);
-        for (let i = 0; i < keys.length; i++) {
-            const id = keys[i];
-            const layer = await getLayerOrTable(mapView, id);
-            await layer.load();
-            await layer.when();
-            editableHash[id] = {
-                name: hash[id].name,
-                supportsUpdate: layer.editingEnabled && layer.capabilities.operations.supportsUpdate
-            };
-        }
-        return editableHash;
-    }
-    else {
-        return hash;
-    }
-}
-/**
- * Get a layer view by id
- *
- * @param mapView the map view to fetch the layer from
- * @param id the id if the layer to fetch
- *
- * @returns Promise resolving with the fetched layer view
- *
- */
-async function getFeatureLayerView(mapView, id) {
-    const layer = await getLayerOrTable(mapView, id);
-    return layer ? await mapView.whenLayerView(layer) : undefined;
-}
-/**
- * Get a layer or table by id
- *
- * @param mapView the map view to fetch the layer from
- * @param id the id of the layer or table to fetch
- *
- * @returns Promise resolving with the fetched layer or table
- *
- */
-async function getLayerOrTable(mapView, id) {
-    let layers = [];
-    await mapView.when(() => {
-        layers = [
-            ...mapView.map.allLayers.toArray(),
-            ...mapView.map.allTables.toArray()
-        ].filter((l) => {
-            return l.id === id;
-        });
-    });
-    return layers.length > 0 ? layers[0] : undefined;
-}
-/**
- * Gets all of the layers from the current map when the map and their layerView is ready
- *
- * @param mapView the map view to fetch the layer names from
- *
- * @returns Promise resolving with an array of all layers
- *
- */
-async function getAllLayers(mapView) {
-    const layers = mapView.map.allLayers.toArray();
-    let layerViewPromises;
-    await mapView.when(() => {
-        layerViewPromises = layers.map(l => mapView.whenLayerView(l));
-    });
-    await Promise.allSettled(layerViewPromises);
-    return layers;
-}
-/**
- * Highlight features by OID
- *
- * @param ids the OIDs from the layer to highlight
- * @param layerView the layer view to highlight
- * @param mapView the map view used if updateExtent is true
- * @param updateExtent optional (default false) boolean to indicate if we should zoom to the extent
- *
- * @returns Promise resolving with the highlight handle
- */
-async function highlightFeatures(ids, layerView, mapView, updateExtent = false) {
-    if (updateExtent) {
-        await goToSelection(ids, layerView, mapView, false);
-        //wait for sometime to load the feature in layerView then only the highlight will work
-        await new Promise(resolve => setTimeout(resolve, 1000));
-    }
-    return layerView.highlight(ids);
-}
-/**
- * Highlights features from all sets including the refine set
- *
- * @param selectionSets The selection sets to highlight
- *
- * @returns Promise resolving with the highlight handles
- *
- */
-async function highlightAllFeatures(selectionSets) {
-    const highlightInfos = getIdSets(selectionSets);
-    return Object.keys(highlightInfos).reduce((prev, cur) => {
-        const highlightInfo = highlightInfos[cur];
-        prev.push(highlightInfo.layerView.highlight(highlightInfo.ids));
-        return prev;
-    }, []);
-}
-/**
- * Highlights features from all sets including the refine set
- *
- * @param selectionSets The selection sets to highlight
- *
- * @returns Promise resolving with the highlight handles
- *
- */
-function getIdSets(selectionSets) {
-    return selectionSets.reduce((prev, cur) => {
-        const lv = cur.layerView;
-        const id = lv === null || lv === void 0 ? void 0 : lv.layer.id;
-        if (id && Object.keys(prev).indexOf(id) > -1) {
-            prev[id].ids = [...new Set([
-                    ...cur.selectedIds,
-                    ...prev[id].ids
-                ])];
-        }
-        else if (id) {
-            prev[id] = {
-                layerView: lv,
-                ids: cur.selectedIds
-            };
-        }
-        if (cur.workflowType === interfaces.EWorkflowType.REFINE) {
-            Object.keys(cur.refineInfos).forEach(k => {
-                const refineInfo = cur.refineInfos[k];
-                if (Object.keys(prev).indexOf(k) > -1) {
-                    prev[k].ids = [...new Set([
-                            ...refineInfo.addIds,
-                            ...prev[k].ids
-                        ])];
-                    prev[k].ids = prev[k].ids.filter(_id => refineInfo.removeIds.indexOf(_id) < 0);
-                }
-            });
-        }
-        return prev;
-    }, {});
-}
-/**
- * Flash features by OID
- *
- * @param ids the OIDs from the layer to highlight
- * @param layerView the layer view to highlight
- *
- * @returns Promise resolving when the operation is complete
- *
- */
-async function flashSelection(ids, layerView, featureEffect) {
-    const filter = {
-        objectIds: ids
-    };
-    layerView.featureEffect = Object.assign(Object.assign({}, featureEffect), { filter });
-    setTimeout(() => {
-        layerView.featureEffect = undefined;
-    }, 1300);
-}
-/**
- * Zoom to features based on OID
- *
- * @param ids the OIDs from the layer to go to
- * @param layerView the layer view that contains the OIDs
- * @param mapView the map view to show the extent change
- * @param flashFeatures optional (default true) boolean to indicate if we should flash the features
- *
- * @returns Promise resolving when the operation is complete
- *
- */
-async function goToSelection(ids, layerView, mapView, flashFeatures = true, featureEffect = undefined) {
-    const result = await queryUtils.queryExtent(ids, layerView.layer);
-    await mapView.goTo(result.extent);
-    if (flashFeatures) {
-        await flashSelection(ids, layerView, featureEffect);
-    }
-}
-
-exports.getAllLayers = getAllLayers;
-exports.getFeatureLayerView = getFeatureLayerView;
-exports.getIdSets = getIdSets;
-exports.getLayerOrTable = getLayerOrTable;
-exports.getMapLayerHash = getMapLayerHash;
-exports.getMapTableHash = getMapTableHash;
-exports.goToSelection = goToSelection;
-exports.highlightAllFeatures = highlightAllFeatures;
-exports.highlightFeatures = highlightFeatures;