udp-stencil-component-library 1.0.0

package/dist/components/p-9eJD5PYE.js

@@ -0,0 +1,558 @@
+import { p as proxyCustomElement, H, h } from './p-DPon6DDX.js';
+import Map from 'ol/Map';
+import View from 'ol/View';
+import TileLayer from 'ol/layer/Tile';
+import OSM from 'ol/source/OSM';
+import VectorLayer from 'ol/layer/Vector';
+import VectorSource from 'ol/source/Vector';
+import { Zoom, FullScreen } from 'ol/control';
+import proj4 from 'proj4';
+import { register } from 'ol/proj/proj4';
+import { defaults, DragRotateAndZoom } from 'ol/interaction';
+import { Overlay } from 'ol';
+import { a as getFilteredData, b as getMapFeatures, c as getFilteredLayerOptionsByRole, h as hasStyles, d as getLayer, e as getLayerStringArrayFromArray, s as setSelectedLayersList } from './p-_3wImzvq.js';
+import { g as getSelectInteraction } from './p-Dp267u3c.js';
+import { Point, LineString, Polygon } from 'ol/geom';
+import { D as DrawBaseLayerId, P as PopoverOverlayId } from './p-CwN0FuAf.js';
+import { debounce } from 'lodash';
+import { d as defineCustomElement$a } from './p-DamSevQs.js';
+import { d as defineCustomElement$9 } from './p-CbqpSujm.js';
+import { d as defineCustomElement$8 } from './p-hRee3qYx.js';
+import { d as defineCustomElement$7 } from './p-BGjVmQGN.js';
+import { d as defineCustomElement$6 } from './p-ZeWoGdjP.js';
+import { d as defineCustomElement$5 } from './p-C-wDzVCk.js';
+import { d as defineCustomElement$4 } from './p-D_p1JpLt.js';
+import { d as defineCustomElement$3 } from './p-2iPr7Wvy.js';
+import { d as defineCustomElement$2 } from './p-CpGuVcRn.js';
+import { d as defineCustomElement$1 } from './p-DkppmXNM.js';
+
+const udpMapCss = ":host{display:block}.zoomControl{left:'auto';right:'20';top:'20'}.iconButtonWrapper{padding:var(--spacing-04)}#featureDetailsPopOverContainer{position:absolute;z-index:1000}.hidden-controls .ol-zoom,.hidden-controls .ol-attribution{display:none}.ol-control{width:fit-content !important}";
+
+const MapComponent = /*@__PURE__*/ proxyCustomElement(class MapComponent extends H {
+    constructor() {
+        super();
+        this.__registerHost();
+        this.__attachShadow();
+        this.data = []; //Feature data (in either Geo-JSON format or not). Geo-JSON format :  [{type: string, id: string, geometry: { type: 'Point' | 'LineString' | 'Polygon',coordinates: Coordinate},properties: any}]
+        this.isGeoJsonFormat = true; //Boolean stating if the data is in Geo-JSON format
+        this.enableZoom = true; //Allow Zoom
+        this.mapZoom = 17; //Default map zoom
+        this.mapCenter = [0, 0]; //Default map center
+        this.mapHeight = '80vh';
+        this.mapProjection = ''; //Map feature projection used
+        this.filterPanel = ''; //Custom filter panel
+        this.enableTileSelection = true; //Allows selecting tile layer
+        this.tileLayersOptions = []; //List of tile layers visible on the map
+        this.defaultTileOptionName = ''; //Default tile layer name
+        this.layerOptions = []; //List of options for vector layers
+        this.initialSelectedLayers = []; //Vector layers selected in the layer filter on initital map load
+        this.bulkSelectedFeaturesActionPanel = ''; //Custom action panel for selected features
+        this.filterLayersByRole = false; //Enable filtering layers by role
+        this.layerKeySeparator = ''; //Layerkey seperator to get the current feature layer when adding layers with features to the map
+        this.filteredLayerOptionsByRole = []; //Filtered layer options by role
+        this.readOnlyMap = false; //Map is read only (Setting true removes the add, edit, delete functionality)
+        this.enableViewFeature = true; //Enables viewing a selected feature
+        this.bulkSelectionActive = false; //State - if bulk selection is active
+        this.splitActive = false; //State - if bulk split is active
+        this.enableDragBox = false; //State - if dragbox is active
+        this.enableAddNewFeature = true;
+        this.readOnlyLayers = []; //List of layers that are read only
+        this.popoverPrimaryActions = [];
+        this.popoverMoreIconButtonActions = [];
+        this.hideMessageIconPopover = false;
+        this.popoverCardConfig = {};
+        this.minZoom = 0; //Min zoom of the map view
+        this.maxZoom = 28; //Max zoom of the map view
+        this.definedProjection = false;
+        this.anchorElement = null;
+        this.showPopOver = false;
+        this.isReadOnlyFeature = false;
+        this.mapFeatures = [];
+        this.initializeMap = (popOverElement, mapElement) => {
+            var _a;
+            this.definedProjection = this.registerProjection(this.crs);
+            this.filterLayerOptions();
+            let allLayers = [];
+            if (this.tileLayersOptions && ((_a = this.tileLayersOptions) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+                for (let option of this.tileLayersOptions) {
+                    const tileLayer = new TileLayer({
+                        source: option === null || option === void 0 ? void 0 : option.source,
+                        properties: { value: option === null || option === void 0 ? void 0 : option.name, isBaseTile: true },
+                        visible: this.defaultTileOptionName ? (option === null || option === void 0 ? void 0 : option.name) === this.defaultTileOptionName : true,
+                    });
+                    allLayers[allLayers.length] = tileLayer;
+                }
+            }
+            else {
+                const openStreetMapTileLayer = new TileLayer({ source: new OSM(), properties: { value: 'Open Street Map', isBaseTile: true }, visible: true });
+                allLayers[allLayers.length] = openStreetMapTileLayer;
+            }
+            //Adding base layer for drawing new features
+            allLayers.push(new VectorLayer({
+                source: new VectorSource({}),
+                properties: { id: DrawBaseLayerId },
+            }));
+            this.anchorElement = mapElement;
+            const mapView = new View({ center: this.mapCenter, zoom: this.mapZoom, projection: this.mapProjection, minZoom: this.minZoom, maxZoom: this.maxZoom });
+            this.mapInstance = new Map({
+                target: mapElement,
+                layers: allLayers,
+                view: mapView,
+                interactions: defaults().extend([new DragRotateAndZoom()]),
+                controls: [new Zoom(), new FullScreen()],
+                overlays: [new Overlay({ element: popOverElement, autoPan: { animation: { duration: 250 } }, id: PopoverOverlayId })],
+            });
+            this.mapInstance.on('moveend', debounce(() => {
+                this.getMapExtentAndZoom();
+            }, 500));
+            this.setVectorLayers();
+            this.addSelectInteraction();
+            if (this.handleSetMapComponent) {
+                this.handleSetMapComponent(this.mapInstance);
+            }
+        };
+        ///////////////////////////////////////////////////METHODS//////////////////////////////////////////////////////////////////
+        this.setVectorLayers = () => {
+            let filteredData = getFilteredData(this.data, this.isGeoJsonFormat, this.geoJsonMappingConfig, this.filterPanel, this.filterPanelCallback);
+            this.mapFeatures = getMapFeatures(filteredData, this.crs, this.definedProjection, this.mapProjection, this.mapDataProjection, this.getFilteredMapData);
+            let visibleLayersOnLoad = this.getVisibleLayersOnLoad(this.layerOptions);
+            this.addVectorLayersToMap(this.mapFeatures, visibleLayersOnLoad);
+            this.updateIntialSelectedLayersVisibility();
+        };
+        this.clearVectorLayers = () => {
+            var _a, _b, _c;
+            const layers = (_c = (_b = (_a = this.mapInstance) === null || _a === void 0 ? void 0 : _a.getLayers()) === null || _b === void 0 ? void 0 : _b.getArray()) !== null && _c !== void 0 ? _c : [];
+            layers.forEach((layer) => {
+                if (layer instanceof VectorLayer && layer.get('id') !== DrawBaseLayerId) {
+                    // Remove only vector layers that are not the draw base layer
+                    this.mapInstance.removeLayer(layer);
+                }
+            });
+        };
+        //================================================REGISTER PROJECTION=========================================
+        this.registerProjection = (crs) => {
+            if ((crs === null || crs === void 0 ? void 0 : crs.length) > 0) {
+                proj4.defs(crs);
+                register(proj4);
+                return true;
+            }
+            return false;
+        };
+        //===========================ADDING VECTOR LAYERS AND LAYER VISIBILITY=========================================
+        this.filterLayerOptions = () => {
+            let options = this.filterLayersByRole ? getFilteredLayerOptionsByRole(this.user, this.layerRoles, this.layerOptions) : this.layerOptions;
+            this.handleSetFilteredLayerOptionsByRole(options);
+        };
+        this.addVectorLayersToMap = (features, layersToAddToMap) => {
+            var _a;
+            if (features && this.mapInstance) {
+                if (this.getVectorLayerSources) {
+                    (_a = this.getVectorLayerSources(layersToAddToMap, features)) === null || _a === void 0 ? void 0 : _a.forEach((layerObj) => {
+                        var _a;
+                        const src = new VectorSource({ features: (_a = layerObj === null || layerObj === void 0 ? void 0 : layerObj.features) !== null && _a !== void 0 ? _a : [] });
+                        const vectorLayer = new VectorLayer({
+                            source: src,
+                            properties: { value: layerObj === null || layerObj === void 0 ? void 0 : layerObj.layer },
+                            style: this.getFeatureStyles,
+                        });
+                        this.mapInstance.addLayer(vectorLayer);
+                    });
+                }
+                else {
+                    for (let layer of layersToAddToMap) {
+                        const layerFeatures = features === null || features === void 0 ? void 0 : features.filter(feature => {
+                            const featureProperties = feature.getProperties();
+                            if (this.getFeatureStyles) {
+                                let style = this.getFeatureStyles(feature);
+                                if (hasStyles(style)) {
+                                    feature.setStyle(style);
+                                }
+                            }
+                            const currentFeatureLayer = getLayer(this.layerKeys, this.layerKeySeparator, featureProperties);
+                            return layer === currentFeatureLayer;
+                        });
+                        const src = new VectorSource({ features: layerFeatures });
+                        const vectorLayer = new VectorLayer({ source: src, properties: { value: layer } });
+                        this.mapInstance.addLayer(vectorLayer);
+                    }
+                }
+            }
+        };
+        this.getVisibleLayersOnLoad = (layerOptions) => {
+            const filteredLayersByRole = this.filterLayersByRole ? getFilteredLayerOptionsByRole(this.user, this.layerRoles, layerOptions) : layerOptions;
+            const visibleLayersOnLoad = getLayerStringArrayFromArray(filteredLayersByRole);
+            return visibleLayersOnLoad;
+        };
+        this.updateLayerVisibility = (visibleLayerNames, changeTileLayer = false) => {
+            var _a, _b;
+            let type = changeTileLayer ? TileLayer : VectorLayer;
+            (_b = (_a = this.mapInstance) === null || _a === void 0 ? void 0 : _a.getLayers()) === null || _b === void 0 ? void 0 : _b.forEach(layer => {
+                if (layer instanceof type) {
+                    visibleLayerNames.includes(layer.get('value')) || layer.get('id') === DrawBaseLayerId ? layer.setVisible(true) : layer.setVisible(false);
+                }
+            });
+        };
+        //=============================================FEATURE STYLES======================================================
+        this.insertFeatureStyles = () => {
+            if (this.getFeatureStyles) {
+                this.mapInstance.getLayers().forEach(layer => {
+                    if (layer instanceof VectorLayer) {
+                        let src = layer.getSource();
+                        src.getFeatures().forEach(feature => {
+                            let style = this.getFeatureStyles(feature);
+                            if (hasStyles(style)) {
+                                feature.setStyle(style);
+                            }
+                        });
+                    }
+                });
+            }
+        };
+        //=============================================FEATURE SELECTION=======================================================
+        this.addSelectInteraction = () => {
+            getSelectInteraction(this.splitActive, this.handleSetCurrentSelectedFeature, this.handleSetSelectedFeatureProperties, this.handleSetShowPopOver, this.handleSetSelectedFeatureOnSelect, this.showPopper, this.getSelectedFeatureStyles, this.handleAddInteraction, this.enableDragBox, this.handleUpdateSelectInteraction, this.handleGetAdditionalFeaturePropertiesOnSelect);
+        };
+        this.handleUpdateSelectInteraction = (value) => {
+            this.selectInteraction = value;
+        };
+        this.handleSetCurrentSelectedFeature = (value) => {
+            this.currentSelectedFeature = value;
+        };
+        this.handleSetShowPopOver = (show) => {
+            this.showPopOver = show;
+        };
+        this.showPopper = (feature) => {
+            if (!this.enableDragBox && !this.enableAddNewFeature && !this.splitActive && feature) {
+                const popoverOverlay = this.mapInstance.getOverlayById(PopoverOverlayId);
+                if (popoverOverlay) {
+                    if (feature.getGeometry() instanceof Point) {
+                        popoverOverlay.setPosition(feature.getGeometry().getCoordinates());
+                    }
+                    else if (feature.getGeometry() instanceof LineString) {
+                        popoverOverlay.setPosition(feature.getGeometry().getCoordinates()[0]);
+                    }
+                    else if (feature.getGeometry() instanceof Polygon) {
+                        popoverOverlay.setPosition(feature.getGeometry().getCoordinates()[0][0]);
+                    }
+                }
+                this.showPopOver = true;
+            }
+        };
+        this.handleOnCloseFeaturePopover = (event) => {
+            if (this.additionalOnclosePopover) {
+                this.additionalOnclosePopover(event);
+            }
+            if (this.setSelectedFeatureIdExternal) {
+                this.setSelectedFeatureIdExternal(null);
+            }
+            this.showPopOver = false;
+        };
+        this.handleAddInteraction = interaction => {
+            this.mapInstance.addInteraction(interaction);
+        };
+        this.handleShowMarkerFromExternal = (featureId) => {
+            var _a, _b;
+            if (featureId && this.mapFeatures && this.selectInteraction) {
+                const featureToSelect = (_a = this.mapFeatures) === null || _a === void 0 ? void 0 : _a.find(feature => (feature === null || feature === void 0 ? void 0 : feature.getId()) === featureId);
+                const featureProperties = featureToSelect === null || featureToSelect === void 0 ? void 0 : featureToSelect.getProperties();
+                if (featureToSelect) {
+                    this.handleSetSelectedFeatureProperties(featureToSelect);
+                    const layer = getLayer(this.layerKeys, this.layerKeySeparator, featureProperties);
+                    //select the layer if not already selected
+                    const filteredLayerStrings = getLayerStringArrayFromArray(this.filteredLayerOptionsByRole);
+                    if (!((_b = this.selectedLayers) === null || _b === void 0 ? void 0 : _b.includes(layer)) && (filteredLayerStrings === null || filteredLayerStrings === void 0 ? void 0 : filteredLayerStrings.includes(layer)) && this.handleSetSelectedLayers) {
+                        const newSelectedLayers = [...this.selectedLayers, layer];
+                        this.handleSetSelectedLayers(newSelectedLayers);
+                        this.updateLayerVisibility(newSelectedLayers);
+                    }
+                    const selectedFeatures = this.selectInteraction.getFeatures();
+                    // Get previously selected features (to handle deselection)
+                    const previouslySelected = selectedFeatures.getArray().slice();
+                    // Clear existing selection
+                    selectedFeatures.clear();
+                    // Select the new feature
+                    selectedFeatures.push(featureToSelect);
+                    // Manually trigger the select event
+                    this.selectInteraction.dispatchEvent({
+                        type: 'select',
+                        selected: [featureToSelect], // New selected feature
+                        deselected: previouslySelected, // Previously selected features
+                        mapBrowserEvent: null, // No actual map event
+                    });
+                    // TODO: handle when no feature on the map to select by showing alert
+                }
+            }
+        };
+    }
+    //////////////////////////////////////////////////////////INITIALIZE MAP/////////////////////////////////////////////////////
+    componentDidLoad() {
+        requestAnimationFrame(() => {
+            const popOverElement = this.el.shadowRoot.querySelector('#featureDetailsPopOverContainer');
+            const mapElement = this.el.shadowRoot.querySelector('#map');
+            if (popOverElement && mapElement) {
+                this.initializeMap(popOverElement, mapElement);
+            }
+        });
+    }
+    /////////////////////////////////////////////////////////////WATCHERS////////////////////////////////////////////////////////
+    reinitializeMap() {
+        this.clearVectorLayers();
+        this.setVectorLayers();
+    }
+    resetPopover() {
+        this.showPopOver = false; // Reset popover visibility when data changes
+    }
+    updateProjection() {
+        if (this.crs) {
+            this.definedProjection = this.registerProjection(this.crs);
+        }
+    }
+    updateFilteredLayerOptions() {
+        this.filterLayerOptions();
+    }
+    handleSelectFeatureOnMap() {
+        var _a;
+        if (this.selectedFeatureIdExternal && ((_a = this.selectInteraction) === null || _a === void 0 ? void 0 : _a.getActive())) {
+            this.handleShowMarkerFromExternal(this.selectedFeatureIdExternal);
+        }
+        else if (this.selectedFeatureIdExternal && this.setSelectedFeatureIdExternal) {
+            // When the select interaction is not activated, let's reset this value so that
+            // when the feature is selected again, it will be handled properly
+            this.setSelectedFeatureIdExternal(null);
+        }
+    }
+    updateReadOnlyLayers() {
+        var _a;
+        if (this.selectedFeatureProperties) {
+            const layer = getLayer(this.layerKeys, this.layerKeySeparator, this.selectedFeatureProperties);
+            this.isReadOnlyFeature = (_a = this.readOnlyLayers) === null || _a === void 0 ? void 0 : _a.includes(layer);
+        }
+    }
+    handleUpdateInitialSelectedLayersVisibility() {
+        this.updateIntialSelectedLayersVisibility();
+    }
+    updateMapView() {
+        if (this.mapInstance) {
+            const currentCenter = this.mapInstance.getView().getCenter();
+            const currentZoom = this.mapInstance.getView().getZoom();
+            this.mapInstance.setView(new View({
+                center: currentCenter,
+                zoom: currentZoom,
+                projection: this.mapProjection,
+            }));
+        }
+    }
+    updateMapCenter() {
+        var _a;
+        if (this.mapInstance && this.mapCenter) {
+            (_a = this.mapInstance.getView()) === null || _a === void 0 ? void 0 : _a.setCenter(this.mapCenter);
+        }
+    }
+    updateFeatureStyles() {
+        if (this.mapInstance) {
+            this.insertFeatureStyles();
+        }
+    }
+    updateMinZoom() {
+        var _a, _b;
+        if (this.mapInstance && this.minZoom) {
+            (_b = (_a = this.mapInstance) === null || _a === void 0 ? void 0 : _a.getView()) === null || _b === void 0 ? void 0 : _b.setMinZoom(this.minZoom);
+        }
+    }
+    updateMaxZoom() {
+        var _a, _b;
+        if (this.mapInstance && this.maxZoom) {
+            (_b = (_a = this.mapInstance) === null || _a === void 0 ? void 0 : _a.getView()) === null || _b === void 0 ? void 0 : _b.setMaxZoom(this.maxZoom);
+        }
+    }
+    getMapExtentAndZoom() {
+        if (this.handleGetZoomExtent) {
+            const extent = this.mapInstance.getView().calculateExtent(this.mapInstance.getSize());
+            const zoom = this.mapInstance.getView().getZoom();
+            this.handleGetZoomExtent(zoom, extent);
+        }
+    }
+    updateIntialSelectedLayersVisibility() {
+        let currentSelectedLayers = setSelectedLayersList(this.filteredLayerOptionsByRole, this.initialSelectedLayers);
+        this.updateLayerVisibility(currentSelectedLayers);
+        if (this.handleSetSelectedLayers) {
+            this.handleSetSelectedLayers(currentSelectedLayers);
+        }
+    }
+    //////////////////////////////////////////////////////////RENDER/////////////////////////////////////////////////////
+    render() {
+        return (h("div", { key: '931d1aad100ff110d19fd1c85b1b7ecd1ba18c23' }, h("div", { key: '5e159392b3417ebd435056ccb7c7149418591405', id: "map", style: { height: this.mapHeight, width: '100%', overflow: 'hidden' } }, h("slot", { key: '6f6d1af49d66c4cfe106942b915bbc3f1d03775b' })), h("div", { key: '8caf1fb6099581a3df3690f780a11f2600f2ac1e', id: "featureDetailsPopOverContainer" }, h("feature-details-popup", { key: 'd1269ca5fa1198220e46cd27938f520509599a9a', currentSelectedFeature: this.currentSelectedFeature, data: this.selectedFeatureProperties, coordinates: this.selectedFeatureCoordinates, enableViewFeature: this.enableViewFeature, handleViewFeature: this.handleViewFeature, popOverAnchorElement: this.anchorElement, showPopOver: this.showPopOver, isReadOnly: this.isReadOnlyFeature, additionalOnclosePopover: this.handleOnCloseFeaturePopover, primaryActions: this.popoverPrimaryActions, moreIconActions: this.popoverMoreIconButtonActions, getMessage: this.getMessagePopover, getMessageIcon: this.getMessageIconPopover, hideMessageIcon: this.hideMessageIconPopover, cardConfig: this.popoverCardConfig, popoverWidth: this.popoverWidth }))));
+    }
+    get el() { return this; }
+    static get watchers() { return {
+        "data": ["reinitializeMap", "resetPopover"],
+        "layerOptions": ["reinitializeMap", "updateFilteredLayerOptions"],
+        "mapDataProjection": ["reinitializeMap"],
+        "mapProjection": ["reinitializeMap", "updateMapView"],
+        "crs": ["updateProjection"],
+        "layerRoles": ["updateFilteredLayerOptions"],
+        "user": ["updateFilteredLayerOptions"],
+        "selectedFeatureIdExternal": ["handleSelectFeatureOnMap"],
+        "readOnlyLayers": ["updateReadOnlyLayers"],
+        "selectedFeatureProperties": ["updateReadOnlyLayers"],
+        "initialSelectedLayers": ["handleUpdateInitialSelectedLayersVisibility"],
+        "mapCenter": ["updateMapCenter"],
+        "getMapStyles": ["updateFeatureStyles"],
+        "minZoom": ["updateMinZoom"],
+        "maxZoom": ["updateMaxZoom"]
+    }; }
+    static get style() { return udpMapCss; }
+}, [1, "map-component", {
+        "handleSetMapComponent": [8, "handle-set-map-component"],
+        "data": [16],
+        "isGeoJsonFormat": [4, "is-geo-json-format"],
+        "geoJsonMappingConfig": [8, "geo-json-mapping-config"],
+        "enableZoom": [4, "enable-zoom"],
+        "mapZoom": [2, "map-zoom"],
+        "mapCenter": [8, "map-center"],
+        "mapHeight": [1, "map-height"],
+        "crs": [8],
+        "mapProjection": [1, "map-projection"],
+        "mapDataProjection": [1, "map-data-projection"],
+        "getFilteredMapData": [8, "get-filtered-map-data"],
+        "getVectorLayerSources": [8, "get-vector-layer-sources"],
+        "getFeatureStyles": [8, "get-feature-styles"],
+        "getSelectedFeatureStyles": [8, "get-selected-feature-styles"],
+        "filterPanel": [1, "filter-panel"],
+        "filterPanelCallback": [8, "filter-panel-callback"],
+        "enableTileSelection": [4, "enable-tile-selection"],
+        "tileLayersOptions": [16, "tile-layers-options"],
+        "defaultTileOptionName": [1, "default-tile-option-name"],
+        "layerOptions": [16, "layer-options"],
+        "initialSelectedLayers": [16, "initial-selected-layers"],
+        "bulkSelectedFeaturesActionPanel": [1, "bulk-selected-features-action-panel"],
+        "handleSetSelectedFeaturesOnBulkSelect": [8, "handle-set-selected-features-on-bulk-select"],
+        "handleSetSelectedFeatureOnSelect": [8, "handle-set-selected-feature-on-select"],
+        "filterLayersByRole": [4, "filter-layers-by-role"],
+        "layerKeys": [16, "layer-keys"],
+        "layerKeySeparator": [1, "layer-key-separator"],
+        "user": [8],
+        "layerRoles": [8, "layer-roles"],
+        "filteredLayerOptionsByRole": [16, "filtered-layer-options-by-role"],
+        "handleSetFilteredLayerOptionsByRole": [8, "handle-set-filtered-layer-options-by-role"],
+        "readOnlyMap": [4, "read-only-map"],
+        "enableViewFeature": [4, "enable-view-feature"],
+        "handleViewFeature": [8, "handle-view-feature"],
+        "bulkSelectionActive": [4, "bulk-selection-active"],
+        "splitActive": [4, "split-active"],
+        "enableDragBox": [4, "enable-drag-box"],
+        "selectFeatureInteraction": [8, "select-feature-interaction"],
+        "handleSetSelectedFeatureProperties": [8, "handle-set-selected-feature-properties"],
+        "selectedFeatureCoordinates": [16, "selected-feature-coordinates"],
+        "selectedFeatureProperties": [8, "selected-feature-properties"],
+        "enableAddNewFeature": [4, "enable-add-new-feature"],
+        "selectedFeatureIdExternal": [8, "selected-feature-id-external"],
+        "setSelectedFeatureIdExternal": [16, "set-selected-feature-id-external"],
+        "readOnlyLayers": [16, "read-only-layers"],
+        "additionalOnclosePopover": [8, "additional-onclose-popover"],
+        "popoverPrimaryActions": [16, "popover-primary-actions"],
+        "popoverMoreIconButtonActions": [16, "popover-more-icon-button-actions"],
+        "getMessagePopover": [16, "get-message-popover"],
+        "getMessageIconPopover": [16, "get-message-icon-popover"],
+        "hideMessageIconPopover": [4, "hide-message-icon-popover"],
+        "popoverCardConfig": [8, "popover-card-config"],
+        "popoverWidth": [1, "popover-width"],
+        "handleGetZoomExtent": [8, "handle-get-zoom-extent"],
+        "selectedLayers": [16, "selected-layers"],
+        "handleSetSelectedLayers": [8, "handle-set-selected-layers"],
+        "handleGetAdditionalFeaturePropertiesOnSelect": [16, "handle-get-additional-feature-properties-on-select"],
+        "minZoom": [2, "min-zoom"],
+        "maxZoom": [2, "max-zoom"],
+        "currentSelectedFeature": [32],
+        "definedProjection": [32],
+        "anchorElement": [32],
+        "showPopOver": [32],
+        "isReadOnlyFeature": [32],
+        "selectInteraction": [32],
+        "mapFeatures": [32],
+        "mapInstance": [32]
+    }, undefined, {
+        "data": ["reinitializeMap", "resetPopover"],
+        "layerOptions": ["reinitializeMap", "updateFilteredLayerOptions"],
+        "mapDataProjection": ["reinitializeMap"],
+        "mapProjection": ["reinitializeMap", "updateMapView"],
+        "crs": ["updateProjection"],
+        "layerRoles": ["updateFilteredLayerOptions"],
+        "user": ["updateFilteredLayerOptions"],
+        "selectedFeatureIdExternal": ["handleSelectFeatureOnMap"],
+        "readOnlyLayers": ["updateReadOnlyLayers"],
+        "selectedFeatureProperties": ["updateReadOnlyLayers"],
+        "initialSelectedLayers": ["handleUpdateInitialSelectedLayersVisibility"],
+        "mapCenter": ["updateMapCenter"],
+        "getMapStyles": ["updateFeatureStyles"],
+        "minZoom": ["updateMinZoom"],
+        "maxZoom": ["updateMaxZoom"]
+    }]);
+function defineCustomElement() {
+    if (typeof customElements === "undefined") {
+        return;
+    }
+    const components = ["map-component", "feature-details-card", "feature-details-popup", "stencil-icon-button", "udp-adornment", "udp-ambient-tool-tip", "udp-badge", "udp-icon", "udp-menu-item", "udp-pop-over", "unity-typography"];
+    components.forEach(tagName => { switch (tagName) {
+        case "map-component":
+            if (!customElements.get(tagName)) {
+                customElements.define(tagName, MapComponent);
+            }
+            break;
+        case "feature-details-card":
+            if (!customElements.get(tagName)) {
+                defineCustomElement$a();
+            }
+            break;
+        case "feature-details-popup":
+            if (!customElements.get(tagName)) {
+                defineCustomElement$9();
+            }
+            break;
+        case "stencil-icon-button":
+            if (!customElements.get(tagName)) {
+                defineCustomElement$8();
+            }
+            break;
+        case "udp-adornment":
+            if (!customElements.get(tagName)) {
+                defineCustomElement$7();
+            }
+            break;
+        case "udp-ambient-tool-tip":
+            if (!customElements.get(tagName)) {
+                defineCustomElement$6();
+            }
+            break;
+        case "udp-badge":
+            if (!customElements.get(tagName)) {
+                defineCustomElement$5();
+            }
+            break;
+        case "udp-icon":
+            if (!customElements.get(tagName)) {
+                defineCustomElement$4();
+            }
+            break;
+        case "udp-menu-item":
+            if (!customElements.get(tagName)) {
+                defineCustomElement$3();
+            }
+            break;
+        case "udp-pop-over":
+            if (!customElements.get(tagName)) {
+                defineCustomElement$2();
+            }
+            break;
+        case "unity-typography":
+            if (!customElements.get(tagName)) {
+                defineCustomElement$1();
+            }
+            break;
+    } });
+}
+
+export { MapComponent as M, defineCustomElement as d };
+//# sourceMappingURL=p-9eJD5PYE.js.map
+
+//# sourceMappingURL=p-9eJD5PYE.js.map