@ohioepa/oepa-ui-lib 1.1.0

package/esm2022/lib/esri-map/esri-map.component.mjs

@@ -0,0 +1,416 @@
+/*
+  Copyright 2018 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.
+*/
+import { Component, ViewChild, Input, Output, EventEmitter } from '@angular/core';
+import { loadModules } from 'esri-loader';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class EsriMapComponent {
+    mapLoaded = new EventEmitter();
+    onNewCoordinates = new EventEmitter();
+    mapViewEl;
+    latLongSearchEl;
+    /**
+     * @private _zoom sets map zoom
+     * @private _center sets map center
+     * @private _basemap sets type of map
+     */
+    _zoom = 10;
+    _center = [0.1278, 51.5074];
+    _basemap = 'streets-vector';
+    currentMapView;
+    // private currentGraphic: esri.Graphic = null;
+    // private selectedPoint: esri.Point = null;
+    _currentLatLong;
+    set currentLatLong(currentLatLong) {
+        this._currentLatLong = currentLatLong;
+    }
+    get currentLatLong() {
+        return this._currentLatLong;
+    }
+    set zoom(zoom) {
+        this._zoom = zoom;
+    }
+    get zoom() {
+        return this._zoom;
+    }
+    set center(center) {
+        this._center = center;
+    }
+    get center() {
+        return this._center;
+    }
+    set basemap(basemap) {
+        this._basemap = basemap;
+    }
+    get basemap() {
+        return this._basemap;
+    }
+    showSearch = false;
+    constructor() { }
+    async initializeMap() {
+        // var mapView;
+        const [EsriMap, EsriMapView, EsriBasemapToggle, locator, Search] = await loadModules([
+            'esri/Map',
+            'esri/views/MapView',
+            "esri/widgets/BasemapToggle",
+            "esri/rest/locator",
+            "esri/widgets/Search"
+        ]);
+        const me = this;
+        // Set type of map
+        const mapProperties = {
+            basemap: this._basemap,
+        };
+        const map = new EsriMap(mapProperties);
+        // Set type of map view
+        const mapViewProperties = {
+            container: this.mapViewEl.nativeElement,
+            center: this._center,
+            zoom: this._zoom,
+            map: map,
+            popup: {
+                dockEnabled: false,
+                dockOptions: {
+                    buttonEnabled: false,
+                    breakpoint: false,
+                }
+            },
+        };
+        var mapView = new EsriMapView(mapViewProperties);
+        mapView.popup.actionsMenuEnabled = false;
+        mapView.popup._displayActionTextLimit = 0; // controls whether action button text is shown
+        this.currentMapView = mapView;
+        // All resources in the MapView and the map have loaded.
+        // Now execute additional processes
+        // this.currentMapView.when(() => {
+        //   this.mapLoaded.emit(true);
+        // });
+        // 1 - Create the widget
+        const toggle = new EsriBasemapToggle({
+            // 2 - Set properties
+            view: mapView, // view that provides access to the map's 'topo' basemap
+            nextBasemap: "hybrid" // allows for toggling to the 'hybrid' basemap
+        });
+        // Add widget to the top right corner of the view
+        mapView.ui.add(toggle, "bottom-right");
+        var updateLatLongAction = {
+            title: "Yes",
+            id: "update-lat-long",
+            // image: "Measure_Distance16.png",
+            className: "bi bi-hand-thumbs-up-fill"
+        };
+        var cancelUpdateAction = {
+            title: "No",
+            id: "cancel-update",
+            // image: "Measure_Distance16.png",
+            className: "bi bi-hand-thumbs-down-fill"
+        };
+        //this.currentMapView.popup.content = '{facilityName}';
+        // this.currentMapView.on("click", event => {
+        //   let clickSymbol: esri.SimpleMarkerSymbol = new SimpleMarkerSymbol({
+        //     type: 'simple-marker',
+        //     style: 'diamond',
+        //     color: 'red',
+        //     size: '20pt'
+        //   });
+        //   this.currentMapView.graphics.remove(this.currentGraphic);
+        //   this.currentGraphic = new Graphic({
+        //     geometry : event.mapPoint,
+        //     symbol : clickSymbol
+        //   })
+        //   this.addPoint(String(event.mapPoint.latitude), String(event.mapPoint.longitude));
+        // });
+        // var symbol = new SimpleMarkerSymbol(
+        //   SimpleMarkerSymbol.STYLE_CIRCLE,
+        //   12,
+        //   new SimpleLineSymbol(
+        //     SimpleLineSymbol.STYLE_NULL,
+        //     new Color([247, 34, 101, 0.9]),
+        //     1
+        //   ),
+        //   new Color([207, 34, 171, 0.5])
+        // );
+        // mapView.when(() => {
+        //   this.mapLoaded.emit(true);
+        //   mapView.on("click", function(event) {
+        //     // you must overwrite default click-for-popup
+        //     // behavior to display your own popup
+        //     // me.currentMapView.popup.autoOpenEnabled = false;
+        //     // Get the coordinates of the click on the view
+        //     var lat = Math.round(event.mapPoint.latitude * 1000) / 1000;
+        //     var lon = Math.round(event.mapPoint.longitude * 1000) / 1000;
+        //     var info = lat + ', ' + lon;
+        //     mapView.graphics.clear();
+        //     mapView.graphics.add(new Graphic(event.mapPoint, symbol));
+        //     map.infoWindow.setContent("X: " + event.mapPoint.x.toString() + ", <br>Y: " + event.mapPoint.y.toString());
+        //     mapView.infoWindow.show(event.mapPoint)
+        //     const poptest = new Popup({
+        //       title: "Reverse geocode: [" + lon + ", " + lat + "]",
+        //       location: event.mapPoint, // Set the location of the popup to the clicked location
+        //       content: "This is a point of interest"  // content displayed in the popup
+        //     })
+        //     mapView.popup.open({
+        //       // Set the popup's title to the coordinates of the location
+        //       title: "Reverse geocode: [" + lon + ", " + lat + "]",
+        //       location: event.mapPoint, // Set the location of the popup to the clicked location
+        //       content: "This is a point of interest"  // content displayed in the popup
+        //     });
+        //     // me.showPopup(info, event);
+        //    });
+        //   //  mapView.popup.on("trigger-action", function(evt){
+        //   //    if(evt.action.id === "more-details"){
+        //   //      // add graphic at view.popup.location
+        //   //    }
+        //   //  });
+        //   })
+        /*
+         * Create the Search Box widget used for address lookup. searchId is the id of the HTML tag (usually a DIV)
+         * that is the placeholder for the search box.
+         */
+        if (this.showSearch) {
+            var searchWidget = new Search({
+                view: mapView,
+                locationEnabled: false,
+                container: this.latLongSearchEl.nativeElement,
+                popupEnabled: false
+            });
+        }
+        mapView.when(function () {
+            if (me._currentLatLong &&
+                me._currentLatLong.latDecimal && me._currentLatLong.latDecimal !== '' &&
+                me._currentLatLong.longDecimal && me._currentLatLong.longDecimal !== '') {
+                me.addPoint(me._currentLatLong.latDecimal, me._currentLatLong.longDecimal, 'xxx');
+                me.zoomToFacility(me._currentLatLong.latDecimal, me._currentLatLong.longDecimal);
+            }
+        });
+        mapView.when(function () {
+            mapView.on("mouse-wheel", function (event) {
+                // prevents zooming with the mouse-wheel event
+                event.stopPropagation();
+            });
+        });
+        mapView.when(function () {
+            if (searchWidget) {
+                searchWidget.on("select-result", function (event) {
+                    showPopup("xxx", event.result.feature.geometry);
+                    // let newLatLong: LatLong = {
+                    //   latDecimal: mapView.popup.location.latitude,
+                    //   longDecimal: mapView.popup.location.longitude
+                    // }
+                    // me.onNewCoordinates.emit(newLatLong); // this updates lat/long fields as soon as you click selected address
+                });
+            }
+        });
+        mapView.when(function () {
+            mapView.popup.autoOpenEnabled = false;
+            mapView.on("click", function (event) {
+                searchWidget.clear();
+                mapView.popup.clear();
+                // Get the coordinates of the click on the view around the decimals to 3 decimals
+                // var lat = Math.round(event.mapPoint.latitude * 1000) / 1000;
+                // var lon = Math.round(event.mapPoint.longitude * 1000) / 1000;
+                // this.selectedPoint = event.mapPoint;
+                // mapView.popup.open({   //define
+                //   title: "<div style='font-size: 12px; font-family: Verdana, Geneva, Arial, Helvetica, sans-serif;'>Update Latitude and Longitude</div>",
+                //   content: 
+                //    "<div style='bold'>Address: </div>" + "<div>" + address + "</div>" +
+                //   "<input type='button' value=' Yes' id='" + options.mapId + "updateLatLong'>&nbsp;<input type='button' value='No' id='" + options.mapId + "cancelInfoWindow'>" ,
+                //   location: event.mapPoint,
+                //   actions: [updateLatLongAction, cancelUpdateAction],
+                // });
+                // Display the popup
+                // Execute a reverse geocode using the clicked location
+                locator.locationToAddress("https://geocode.arcgis.com/arcgis/rest/services/World/GeocodeServer", { location: event.mapPoint })
+                    .then(function (response) {
+                    // If an address is successfully found, show it in the popup's content
+                    mapView.popup.content = response.address;
+                    var address = response.address;
+                    showPopup(address, event.mapPoint);
+                })
+                    .catch(function (error) {
+                    // If the promise fails and no result is found, show a generic message
+                    mapView.popup.content = "No address was found for this location";
+                    showPopup("No address found.", event.mapPoint);
+                });
+                mapView.popup.visible = true;
+            });
+        });
+        mapView.when(function () {
+            mapView.popup.on("trigger-action", function (event) {
+                // Execute the measureThis() function if the measure-this action is clicked
+                if (event.action.id === "update-lat-long") {
+                    updateLatLong();
+                }
+                else if (event.action.id === "cancel-update") {
+                    cancelUpdate();
+                }
+            });
+        });
+        function showPopup(address, pt) {
+            mapView.popup.open({
+                title: "<div style='font-size: 12px; font-family: Verdana, Geneva, Arial, Helvetica, sans-serif;'>Update Latitude and Longitude?</div>",
+                content: 
+                //  "<div style='bold'>Address: </div>" + "<div>" + address + "</div>" +
+                "<div style='font-size: 12px; font-family: Verdana, Geneva, Arial, Helvetica, sans-serif;'><div>Would you like to update the latitude and longitude values as shown below?</div>" +
+                    '<br/>' +
+                    "<div>Latitude: " + Math.round(pt.latitude * 100000) / 100000 + "</div>" +
+                    "<div>Longitude: " + Math.round(pt.longitude * 100000) / 100000 + "</div></div>",
+                // "<input type='button' value=' Yes' id='" + options.mapId + "updateLatLong'>&nbsp;<input type='button' value='No' id='" + options.mapId + "cancelInfoWindow'>" ,
+                location: pt,
+                actions: [updateLatLongAction, cancelUpdateAction],
+                collapsed: true
+            });
+            // mapView.popup._displayActionTextLimit = 3; // controls whether action button text is shown
+        }
+        function updateLatLong() {
+            mapView.graphics.removeAll();
+            // mapView.graphics.add(new Graphic(event.mapPoint, symbol));
+            me.addPoint(mapView.popup.location.latitude, mapView.popup.location.longitude, 'xxx');
+            let newLatLong = {
+                latDecimal: mapView.popup.location.latitude,
+                longDecimal: mapView.popup.location.longitude
+            };
+            me.onNewCoordinates.emit(newLatLong);
+            cancelUpdate();
+            mapView.popup.close();
+            // console.log("updateLatLong called for lat: " + mapView.popup.location.latitude + ", long: " + mapView.popup.location.longitude);
+        }
+        function cancelUpdate() {
+            mapView.popup.close();
+            // console.log("cancelUpdate called");
+        }
+        //*** Add div element to show coordates ***//
+        var coordsWidget = document.createElement("div");
+        coordsWidget.id = "coordsWidget";
+        coordsWidget.className = "esri-widget esri-component";
+        coordsWidget.style.padding = "7px 15px 5px";
+        mapView.ui.add(coordsWidget, "bottom-right");
+        //*** Update lat, lon, zoom and scale ***//
+        function showCoordinates(pt) {
+            var coords = "Lat/Lon " + pt.latitude.toFixed(3) + " " + pt.longitude.toFixed(3) +
+                " | Scale 1:" + Math.round(mapView.scale * 1) / 1 +
+                " | Zoom " + mapView.zoom;
+            coordsWidget.innerHTML = coords;
+        }
+        //*** Add event and show center coordinates after the view is finished moving e.g. zoom, pan ***//
+        mapView.watch(["stationary"], function () {
+            showCoordinates(mapView.center);
+        });
+        //*** Add event to show mouse coordinates on click and move ***//
+        mapView.on(["pointer-down", "pointer-move"], function (evt) {
+            showCoordinates(mapView.toMap({ x: evt.x, y: evt.y }));
+        });
+    }
+    async resetMap() {
+        this.currentMapView.graphics.removeAll();
+        this.currentMapView.goTo({
+            target: this._center,
+            zoom: this._zoom
+        });
+        this.zoomToFacility;
+    }
+    async zoomToFacility(lat, long) {
+        const [Point] = await loadModules([
+            'esri/geometry/Point'
+        ]);
+        let point = new Point({
+            latitude: lat, //39.957767,
+            longitude: long //-82.994939
+        });
+        this.currentMapView.goTo({
+            target: point,
+            zoom: 16
+        });
+    }
+    // async removeSelectedPoint() {
+    //   if (this.currentGraphic) {
+    //     this.currentMapView.map.
+    //   }
+    // }
+    /**
+     * Adds a new point to the current map with the given lat/long values.
+     * @param lat
+     * @param long
+     */
+    async addPoint(lat, long, name) {
+        const [Point, Graphic, SimpleMarkerSymbol, ActionButton] = await loadModules([
+            'esri/geometry/Point',
+            'esri/Graphic',
+            'esri/symbols/SimpleMarkerSymbol',
+            'esri/support/actions/ActionButton'
+        ]);
+        let point = new Point({
+            latitude: lat, //39.957767,
+            longitude: long //-82.994939
+        });
+        let symbol = new SimpleMarkerSymbol({
+            // type: 'simple-marker',
+            style: 'circle',
+            color: 'blue',
+            size: '12px'
+        });
+        let actionButton = new ActionButton({
+            active: true,
+            visible: true,
+            disabled: false,
+            id: 'selectFacility',
+            title: 'Select Facility',
+            type: 'button'
+        });
+        let currentGraphic = new Graphic({
+            geometry: point,
+            symbol: symbol,
+            popupTemplate: {
+                title: name,
+                content: name,
+            },
+            actions: [actionButton]
+        });
+        this.currentMapView.graphics.add(currentGraphic);
+        this._currentLatLong = {
+            latDecimal: lat,
+            longDecimal: long
+        };
+        // console.log('Added point: ', lat, long);
+    }
+    ngOnInit() {
+        this.initializeMap();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: EsriMapComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: EsriMapComponent, selector: "oepa-esri-map", inputs: { currentLatLong: "currentLatLong", zoom: "zoom", center: "center", basemap: "basemap", showSearch: "showSearch" }, outputs: { mapLoaded: "mapLoaded", onNewCoordinates: "onNewCoordinates" }, viewQueries: [{ propertyName: "mapViewEl", first: true, predicate: ["mapViewNode"], descendants: true, static: true }, { propertyName: "latLongSearchEl", first: true, predicate: ["latLongSearchNode"], descendants: true }], ngImport: i0, template: "<!-- Here's the DIV that we inject the map into -->\n<div *ngIf=\"showSearch\" class=\"row\">\n  <div class=\"col-md-12\">\n    <div class=\"alert alert-success\">\n      <label>Search for Address:</label>\n      <div>Type an address in the input box below and select a match from the drop down list or select the\n        magnifying glass button to plot the address on the map.</div>\n      <div #latLongSearchNode></div>\n    </div>\n  </div>\n</div>\n<div #mapViewNode></div>", styles: ["@import\"https://js.arcgis.com/4.11/esri/css/main.css\";.esri-view{height:500px}.esri-view-width-less-than-large .esri-popup__action-text{display:block!important}\n"], dependencies: [{ kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: EsriMapComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'oepa-esri-map', template: "<!-- Here's the DIV that we inject the map into -->\n<div *ngIf=\"showSearch\" class=\"row\">\n  <div class=\"col-md-12\">\n    <div class=\"alert alert-success\">\n      <label>Search for Address:</label>\n      <div>Type an address in the input box below and select a match from the drop down list or select the\n        magnifying glass button to plot the address on the map.</div>\n      <div #latLongSearchNode></div>\n    </div>\n  </div>\n</div>\n<div #mapViewNode></div>", styles: ["@import\"https://js.arcgis.com/4.11/esri/css/main.css\";.esri-view{height:500px}.esri-view-width-less-than-large .esri-popup__action-text{display:block!important}\n"] }]
+        }], ctorParameters: () => [], propDecorators: { mapLoaded: [{
+                type: Output
+            }], onNewCoordinates: [{
+                type: Output
+            }], mapViewEl: [{
+                type: ViewChild,
+                args: ['mapViewNode', { static: true }]
+            }], latLongSearchEl: [{
+                type: ViewChild,
+                args: ['latLongSearchNode', { static: false }]
+            }], currentLatLong: [{
+                type: Input
+            }], zoom: [{
+                type: Input
+            }], center: [{
+                type: Input
+            }], basemap: [{
+                type: Input
+            }], showSearch: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"esri-map.component.js","sourceRoot":"","sources":["../../../../../projects/oepa-ui-lib/src/lib/esri-map/esri-map.component.ts","../../../../../projects/oepa-ui-lib/src/lib/esri-map/esri-map.component.html"],"names":[],"mappings":"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","sourcesContent":["/*\n  Copyright 2018 Esri\n  Licensed under the Apache License, Version 2.0 (the \"License\");\n  you may not use this file except in compliance with the License.\n  You may obtain a copy of the License at\n    http://www.apache.org/licenses/LICENSE-2.0\n  Unless required by applicable law or agreed to in writing, software\n  distributed under the License is distributed on an \"AS IS\" BASIS,\n  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n  See the License for the specific language governing permissions and\n  limitations under the License.\n*/\n\nimport { Component, OnInit, ViewChild, ElementRef, Input, Output, EventEmitter } from '@angular/core';\n\nimport { loadModules } from 'esri-loader';\nimport esri = __esri;\nimport { LatLong } from '@ohioepa/oepa-ebiz-lib';\n\n@Component({\n  selector: 'oepa-esri-map',\n  templateUrl: './esri-map.component.html',\n  styleUrls: ['./esri-map.component.css']\n})\nexport class EsriMapComponent implements OnInit {\n\n  @Output() mapLoaded = new EventEmitter<boolean>();\n  @Output() onNewCoordinates: EventEmitter<LatLong> = new EventEmitter<LatLong>();\n  @ViewChild('mapViewNode', { static: true }) private mapViewEl!: ElementRef;\n  @ViewChild('latLongSearchNode', { static: false }) latLongSearchEl!: ElementRef;\n\n  /**\n   * @private _zoom sets map zoom\n   * @private _center sets map center\n   * @private _basemap sets type of map\n   */\n  private _zoom: number = 10;\n  private _center: Array<number> = [0.1278, 51.5074];\n  private _basemap: string = 'streets-vector';\n\n  private currentMapView!: esri.MapView;\n  // private currentGraphic: esri.Graphic = null;\n  // private selectedPoint: esri.Point = null;\n  private _currentLatLong!: LatLong;\n\n  @Input()\n  set currentLatLong(currentLatLong: LatLong) {\n    this._currentLatLong = currentLatLong;\n  }\n\n  get currentLatLong(): LatLong {\n    return this._currentLatLong;\n  }\n\n  @Input()\n  set zoom(zoom: number) {\n    this._zoom = zoom;\n  }\n\n  get zoom(): number {\n    return this._zoom;\n  }\n\n  @Input()\n  set center(center: Array<number>) {\n    this._center = center;\n  }\n\n  get center(): Array<number> {\n    return this._center;\n  }\n\n  @Input()\n  set basemap(basemap: string) {\n    this._basemap = basemap;\n  }\n\n  get basemap(): string {\n    return this._basemap;\n  }\n\n  @Input() showSearch = false;\n\n  constructor() { }\n\n  async initializeMap() {\n    // var mapView;\n    const [EsriMap, EsriMapView, EsriBasemapToggle, locator , Search ] = await loadModules([\n      'esri/Map',\n      'esri/views/MapView',\n      \"esri/widgets/BasemapToggle\",\n      \"esri/rest/locator\",\n      \"esri/widgets/Search\"\n    ]);\n\n    const me = this;\n    // Set type of map\n    const mapProperties: esri.MapProperties = {\n      basemap: this._basemap,\n    };\n\n    const map: esri.Map = new EsriMap(mapProperties);\n\n    // Set type of map view\n    const mapViewProperties: esri.MapViewProperties = {\n      container: this.mapViewEl.nativeElement,\n      center: this._center,\n      zoom: this._zoom,\n      map: map,\n      popup: {\n        dockEnabled: false,\n        dockOptions: {\n          buttonEnabled: false,\n          breakpoint: false,\n        }\n      },\n    };\n\n    var mapView = new EsriMapView(mapViewProperties);\n    mapView.popup.actionsMenuEnabled = false;\n    mapView.popup._displayActionTextLimit = 0; // controls whether action button text is shown\n    this.currentMapView = mapView;\n\n    // All resources in the MapView and the map have loaded.\n    // Now execute additional processes\n    // this.currentMapView.when(() => {\n    //   this.mapLoaded.emit(true);\n    // });\n\n    // 1 - Create the widget\n    const toggle: esri.BasemapToggle = new EsriBasemapToggle({\n      // 2 - Set properties\n      view: mapView, // view that provides access to the map's 'topo' basemap\n      nextBasemap: \"hybrid\" // allows for toggling to the 'hybrid' basemap\n    });\n\n    // Add widget to the top right corner of the view\n    mapView.ui.add(toggle, \"bottom-right\");\n\n    var updateLatLongAction = {\n      title: \"Yes\",\n      id: \"update-lat-long\",\n      // image: \"Measure_Distance16.png\",\n      className: \"bi bi-hand-thumbs-up-fill\"\n    };\n\n    var cancelUpdateAction = {\n      title: \"No\",\n      id: \"cancel-update\",\n      // image: \"Measure_Distance16.png\",\n      className: \"bi bi-hand-thumbs-down-fill\"\n    };\n\n    //this.currentMapView.popup.content = '{facilityName}';\n\n    // this.currentMapView.on(\"click\", event => {\n    //   let clickSymbol: esri.SimpleMarkerSymbol = new SimpleMarkerSymbol({\n    //     type: 'simple-marker',\n    //     style: 'diamond',\n    //     color: 'red',\n    //     size: '20pt'\n    //   });\n    //   this.currentMapView.graphics.remove(this.currentGraphic);\n    //   this.currentGraphic = new Graphic({\n    //     geometry : event.mapPoint,\n    //     symbol : clickSymbol\n    //   })\n\n    //   this.addPoint(String(event.mapPoint.latitude), String(event.mapPoint.longitude));\n    // });\n\n    // var symbol = new SimpleMarkerSymbol(\n    //   SimpleMarkerSymbol.STYLE_CIRCLE,\n    //   12,\n    //   new SimpleLineSymbol(\n    //     SimpleLineSymbol.STYLE_NULL,\n    //     new Color([247, 34, 101, 0.9]),\n    //     1\n    //   ),\n    //   new Color([207, 34, 171, 0.5])\n    // );\n\n    // mapView.when(() => {\n    //   this.mapLoaded.emit(true);\n    //   mapView.on(\"click\", function(event) {\n    //     // you must overwrite default click-for-popup\n    //     // behavior to display your own popup\n    //     // me.currentMapView.popup.autoOpenEnabled = false;\n\n    //     // Get the coordinates of the click on the view\n    //     var lat = Math.round(event.mapPoint.latitude * 1000) / 1000;\n    //     var lon = Math.round(event.mapPoint.longitude * 1000) / 1000;\n    //     var info = lat + ', ' + lon;\n\n    //     mapView.graphics.clear();\n    //     mapView.graphics.add(new Graphic(event.mapPoint, symbol));\n    //     map.infoWindow.setContent(\"X: \" + event.mapPoint.x.toString() + \", <br>Y: \" + event.mapPoint.y.toString());\n    //     mapView.infoWindow.show(event.mapPoint)\n\n    //     const poptest = new Popup({\n    //       title: \"Reverse geocode: [\" + lon + \", \" + lat + \"]\",\n    //       location: event.mapPoint, // Set the location of the popup to the clicked location\n    //       content: \"This is a point of interest\"  // content displayed in the popup\n    //     })\n    //     mapView.popup.open({\n    //       // Set the popup's title to the coordinates of the location\n    //       title: \"Reverse geocode: [\" + lon + \", \" + lat + \"]\",\n    //       location: event.mapPoint, // Set the location of the popup to the clicked location\n    //       content: \"This is a point of interest\"  // content displayed in the popup\n    //     });\n    //     // me.showPopup(info, event);\n\n    //    });\n\n    //   //  mapView.popup.on(\"trigger-action\", function(evt){\n    //   //    if(evt.action.id === \"more-details\"){\n    //   //      // add graphic at view.popup.location\n    //   //    }\n    //   //  });\n\n    //   })\n\n    /*\n     * Create the Search Box widget used for address lookup. searchId is the id of the HTML tag (usually a DIV)\n     * that is the placeholder for the search box.\n     */\n    if (this.showSearch) {\n      var searchWidget = new Search({\n        view: mapView,\n        locationEnabled: false,\n        container: this.latLongSearchEl.nativeElement,\n        popupEnabled: false\n      });\n    }\n\n    mapView.when(function () {\n      if (me._currentLatLong &&\n          me._currentLatLong.latDecimal && me._currentLatLong.latDecimal !== '' &&\n          me._currentLatLong.longDecimal && me._currentLatLong.longDecimal !== '') {\n        me.addPoint(me._currentLatLong.latDecimal, me._currentLatLong.longDecimal, 'xxx');\n        me.zoomToFacility(me._currentLatLong.latDecimal, me._currentLatLong.longDecimal);\n      }\n    })\n\n    mapView.when(function () {\n      mapView.on(\"mouse-wheel\", function (event:any) {\n        // prevents zooming with the mouse-wheel event\n        event.stopPropagation();\n      });\n    })\n\n    mapView.when(function() {\n      if (searchWidget) {\n        searchWidget.on(\"select-result\", function (event:any) {\n          showPopup(\"xxx\", event.result.feature.geometry);\n  \n          // let newLatLong: LatLong = {\n          //   latDecimal: mapView.popup.location.latitude,\n          //   longDecimal: mapView.popup.location.longitude\n          // }\n          // me.onNewCoordinates.emit(newLatLong); // this updates lat/long fields as soon as you click selected address\n        });\n      }\n    })\n\n    mapView.when(function () {\n      mapView.popup.autoOpenEnabled = false;\n      mapView.on(\"click\", function (event:any) {\n        searchWidget.clear();\n        mapView.popup.clear();\n        // Get the coordinates of the click on the view around the decimals to 3 decimals\n        // var lat = Math.round(event.mapPoint.latitude * 1000) / 1000;\n        // var lon = Math.round(event.mapPoint.longitude * 1000) / 1000;\n        // this.selectedPoint = event.mapPoint;\n\n        // mapView.popup.open({   //define\n        //   title: \"<div style='font-size: 12px; font-family: Verdana, Geneva, Arial, Helvetica, sans-serif;'>Update Latitude and Longitude</div>\",\n        //   content: \n        //    \"<div style='bold'>Address: </div>\" + \"<div>\" + address + \"</div>\" +\n        //   \"<input type='button' value=' Yes' id='\" + options.mapId + \"updateLatLong'>&nbsp;<input type='button' value='No' id='\" + options.mapId + \"cancelInfoWindow'>\" ,\n        //   location: event.mapPoint,\n        //   actions: [updateLatLongAction, cancelUpdateAction],\n        // });\n        // Display the popup\n        // Execute a reverse geocode using the clicked location\n        locator.locationToAddress(\"https://geocode.arcgis.com/arcgis/rest/services/World/GeocodeServer\", { location: event.mapPoint })\n          .then(function (response:any) {\n            // If an address is successfully found, show it in the popup's content\n            mapView.popup.content = response.address;\n            var address = response.address;\n            showPopup(address, event.mapPoint);\n          })\n          .catch(function (error:any) {\n            // If the promise fails and no result is found, show a generic message\n            mapView.popup.content = \"No address was found for this location\";\n            showPopup(\"No address found.\", event.mapPoint);\n          });\n\n        mapView.popup.visible = true;\n      });\n    })\n\n    mapView.when(function () {\n      mapView.popup.on(\"trigger-action\", function (event:any) {\n        // Execute the measureThis() function if the measure-this action is clicked\n        if (event.action.id === \"update-lat-long\") {\n          updateLatLong();\n        } else if (event.action.id === \"cancel-update\") {\n          cancelUpdate();\n        }\n      });\n    })\n\n    function showPopup(address:any, pt:any) {\n      mapView.popup.open({\n        title: \"<div style='font-size: 12px; font-family: Verdana, Geneva, Arial, Helvetica, sans-serif;'>Update Latitude and Longitude?</div>\",\n        content:\n          //  \"<div style='bold'>Address: </div>\" + \"<div>\" + address + \"</div>\" +\n          \"<div style='font-size: 12px; font-family: Verdana, Geneva, Arial, Helvetica, sans-serif;'><div>Would you like to update the latitude and longitude values as shown below?</div>\" +\n          '<br/>' +\n          \"<div>Latitude: \" + Math.round(pt.latitude * 100000) / 100000 + \"</div>\" +\n          \"<div>Longitude: \" + Math.round(pt.longitude * 100000) / 100000 + \"</div></div>\",\n        // \"<input type='button' value=' Yes' id='\" + options.mapId + \"updateLatLong'>&nbsp;<input type='button' value='No' id='\" + options.mapId + \"cancelInfoWindow'>\" ,\n        location: pt,\n        actions: [updateLatLongAction, cancelUpdateAction],\n        collapsed: true\n      });\n      // mapView.popup._displayActionTextLimit = 3; // controls whether action button text is shown\n\n    }\n\n    function updateLatLong() {\n      mapView.graphics.removeAll();\n      // mapView.graphics.add(new Graphic(event.mapPoint, symbol));\n      me.addPoint(mapView.popup.location.latitude, mapView.popup.location.longitude, 'xxx');\n\n      let newLatLong: LatLong = {\n        latDecimal: mapView.popup.location.latitude,\n        longDecimal: mapView.popup.location.longitude\n      }\n      me.onNewCoordinates.emit(newLatLong);\n\n      cancelUpdate();\n      mapView.popup.close();\n      // console.log(\"updateLatLong called for lat: \" + mapView.popup.location.latitude + \", long: \" + mapView.popup.location.longitude);\n    }\n\n    function cancelUpdate() {\n      mapView.popup.close();\n      // console.log(\"cancelUpdate called\");\n    }\n\n    //*** Add div element to show coordates ***//\n    var coordsWidget = document.createElement(\"div\");\n    coordsWidget.id = \"coordsWidget\";\n    coordsWidget.className = \"esri-widget esri-component\";\n    coordsWidget.style.padding = \"7px 15px 5px\";\n    mapView.ui.add(coordsWidget, \"bottom-right\");\n\n    //*** Update lat, lon, zoom and scale ***//\n    function showCoordinates(pt:any) {\n      var coords = \"Lat/Lon \" + pt.latitude.toFixed(3) + \" \" + pt.longitude.toFixed(3) +\n        \" | Scale 1:\" + Math.round(mapView.scale * 1) / 1 +\n        \" | Zoom \" + mapView.zoom;\n      coordsWidget.innerHTML = coords;\n    }\n\n    //*** Add event and show center coordinates after the view is finished moving e.g. zoom, pan ***//\n    mapView.watch([\"stationary\"], function () {\n      showCoordinates(mapView.center);\n    });\n\n    //*** Add event to show mouse coordinates on click and move ***//\n    mapView.on([\"pointer-down\", \"pointer-move\"], function (evt:any) {\n      showCoordinates(mapView.toMap({ x: evt.x, y: evt.y }));\n    });\n\n  }\n\n  async resetMap() {\n    this.currentMapView.graphics.removeAll();\n    this.currentMapView.goTo({\n      target: this._center,\n      zoom: this._zoom\n    }\n    );\n    this.zoomToFacility\n  }\n\n  async zoomToFacility(lat: string, long: string) {\n    const [Point] = await loadModules([\n      'esri/geometry/Point'\n    ]);\n    let point: esri.Point = new Point({\n      latitude: lat, //39.957767,\n      longitude: long //-82.994939\n    });\n\n    this.currentMapView.goTo({\n      target: point,\n      zoom: 16\n    }\n    );\n  }\n\n  // async removeSelectedPoint() {\n  //   if (this.currentGraphic) {\n  //     this.currentMapView.map.\n  //   }\n  // }\n\n  /**\n   * Adds a new point to the current map with the given lat/long values.\n   * @param lat \n   * @param long \n   */\n  async addPoint(lat: string, long: string, name: string) {\n    const [Point, Graphic, SimpleMarkerSymbol, ActionButton] = await loadModules([\n      'esri/geometry/Point',\n      'esri/Graphic',\n      'esri/symbols/SimpleMarkerSymbol',\n      'esri/support/actions/ActionButton'\n    ]);\n\n    let point: esri.Point = new Point({\n      latitude: lat, //39.957767,\n      longitude: long //-82.994939\n    });\n\n    let symbol: esri.SimpleMarkerSymbol = new SimpleMarkerSymbol({\n      // type: 'simple-marker',\n      style: 'circle',\n      color: 'blue',\n      size: '12px'\n    });\n\n    let actionButton: esri.ActionButton = new ActionButton({\n      active: true,\n      visible: true,\n      disabled: false,\n      id: 'selectFacility',\n      title: 'Select Facility',\n      type: 'button'\n    });\n\n    let currentGraphic = new Graphic({\n      geometry: point,\n      symbol: symbol,\n      popupTemplate: {\n        title: name,\n        content: name,\n      },\n      actions: [actionButton]\n    });\n\n    this.currentMapView.graphics.add(currentGraphic);\n\n    this._currentLatLong = {\n      latDecimal: lat,\n      longDecimal: long\n    }\n    // console.log('Added point: ', lat, long);\n  }\n\n  ngOnInit() {\n    this.initializeMap();\n  }\n\n}","<!-- Here's the DIV that we inject the map into -->\n<div *ngIf=\"showSearch\" class=\"row\">\n  <div class=\"col-md-12\">\n    <div class=\"alert alert-success\">\n      <label>Search for Address:</label>\n      <div>Type an address in the input box below and select a match from the drop down list or select the\n        magnifying glass button to plot the address on the map.</div>\n      <div #latLongSearchNode></div>\n    </div>\n  </div>\n</div>\n<div #mapViewNode></div>"]}