@theseam/ui-common 0.3.0 → 0.3.3

package/esm2015/google-maps/google-maps.service.js

@@ -0,0 +1,344 @@
+import { __awaiter } from "tslib";
+import { Injectable, NgZone, ViewContainerRef } from '@angular/core';
+import { BehaviorSubject, from, Subject } from 'rxjs';
+import { switchMap, takeUntil, tap } from 'rxjs/operators';
+import { isNullOrUndefined, notNullOrUndefined } from '@theseam/ui-common/utils';
+import { GoogleMapsContextMenu } from './google-maps-contextmenu';
+import { addInnerFeatureCutoutToExteriorFeature, createDataFeatureFromPolygon, createFeatureChangeObservable, getBoundsWithAllFeatures, getFeatureCenter, getFeaturesCount, getPossibleExteriorFeature, isFeatureSelected, removeAllFeatures, setFeatureSelected, stripAppFeaturePropertiesFromJson, } from './google-maps-feature-helpers';
+import { MapValueManagerService, MapValueSource } from './map-value-manager.service';
+const DEFAULT_POLYGON_OPTIONS = {
+    clickable: true,
+    draggable: true,
+    editable: true,
+    // fillColor: 'rgba(60,150,60,1)',
+    // strokeColor: 'rgba(155,255,0,1)'
+};
+const DEFAULT_DRAWING_MANAGER_OPTIONS = () => ({
+    drawingControl: true,
+    drawingControlOptions: {
+        drawingModes: [
+            google.maps.drawing.OverlayType.POLYGON
+        ]
+    },
+    polygonOptions: DEFAULT_POLYGON_OPTIONS,
+    drawingMode: null
+});
+const ɵ0 = DEFAULT_DRAWING_MANAGER_OPTIONS;
+const FEATURE_STYLE_OPTIONS_DEFAULT = {
+    clickable: true,
+    visible: true,
+    // zIndex?: number;
+    // cursor?: string;
+    draggable: false,
+    editable: false,
+    fillColor: 'teal',
+    fillOpacity: 0.3,
+    strokeColor: 'blue',
+    strokeOpacity: 1,
+    strokeWeight: 2,
+};
+const FEATURE_STYLE_OPTIONS_SELECTED = Object.assign(Object.assign({}, FEATURE_STYLE_OPTIONS_DEFAULT), { draggable: true, editable: true, fillColor: 'green', fillOpacity: 0.7, strokeColor: 'limegreen', strokeOpacity: 1, strokeWeight: 2 });
+export class GoogleMapsService {
+    constructor(_mapValueManager, _ngZone, _vcr) {
+        this._mapValueManager = _mapValueManager;
+        this._ngZone = _ngZone;
+        this._vcr = _vcr;
+        this._ngUnsubscribe = new Subject();
+        this._mapReadySubject = new BehaviorSubject(false);
+        this._featureContextMenu = null;
+        this._activeContextMenu = null;
+        this._allowDrawingHoleInPolygon = false;
+        this.mapReady$ = this._mapReadySubject.asObservable();
+    }
+    get mapReady() { return this._mapReadySubject.value; }
+    ngOnDestroy() {
+        this._ngUnsubscribe.next();
+        this._ngUnsubscribe.complete();
+    }
+    setMap(map) {
+        this.googleMap = map;
+        this._mapReadySubject.next(true);
+        this._initDrawingManager();
+        this._initFeatureStyling();
+        this._initFeatureChangeListeners();
+    }
+    setBaseLatLng(lat, lng) {
+        this._baseLatLng = { lat, lng };
+    }
+    // TODO: Refactor out of the service meant to just wrap the google maps api.
+    setFeatureContextMenu(menu) {
+        this._featureContextMenu = menu;
+    }
+    getDiv() {
+        this._assertInitialized();
+        return this.googleMap.getDiv();
+    }
+    fitBounds(bounds, padding) {
+        this._assertInitialized();
+        this.googleMap.fitBounds(bounds, padding);
+    }
+    /**
+     * Iterates the map's features and removes any that are selected.
+     */
+    deleteSelection() {
+        this._assertInitialized();
+        const mapData = this.googleMap.data;
+        mapData.forEach(f => {
+            if (isFeatureSelected(f)) {
+                mapData.remove(f);
+            }
+        });
+    }
+    /**
+     * Stops the current drawing.
+     */
+    stopDrawing() {
+        this._ngZone.runOutsideAngular(() => {
+            if (isNullOrUndefined(this._drawingManager) || this._drawingManager.getDrawingMode() === null) {
+                return;
+            }
+            // Listening for the completion event of the overlay currently being drawn
+            // and removing it. I haven't found a way to cancel the current drawing,
+            // without this hack that assumes our listeners will not run into a race
+            // condition.
+            const listener = google.maps.event.addListener(this._drawingManager, 'overlaycomplete', (event) => {
+                event.overlay.setMap(null);
+                listener.remove();
+            });
+            // To fake canceling the current drawing, without disabling the drawing
+            // mode, the drawin mode is being unset then immediately set back. When
+            // the mode is unset the 'overlaycomplete' event will fire, which will
+            // give a reference to the current overlay to remove, then it is set back
+            // to the mode the user was using. To the user is should just seem like
+            // the current drawing was canceled and they can start drawing again.
+            const mode = this._drawingManager.getDrawingMode();
+            this._drawingManager.setDrawingMode(null);
+            this._drawingManager.setDrawingMode(mode);
+            // 'overlaycomplete' should fire immediately, unless an overlay hadn't
+            // started drawing. This timeout will make sure the listener gets removed.
+            setTimeout(() => {
+                listener.remove();
+            });
+        });
+    }
+    _initDrawingManager() {
+        if (notNullOrUndefined(this._drawingManager)) {
+            throw Error(`DrawingManager is already initialized.`);
+        }
+        this._assertInitialized();
+        const options = DEFAULT_DRAWING_MANAGER_OPTIONS();
+        const drawingManager = new google.maps.drawing.DrawingManager(options);
+        drawingManager.setMap(this.googleMap);
+        this._drawingManager = drawingManager;
+        this._drawingManager.addListener('drawingmode_changed', event => {
+            var _a;
+            if (((_a = this._drawingManager) === null || _a === void 0 ? void 0 : _a.getDrawingMode()) !== null) {
+                this._assertInitialized();
+                this.googleMap.data.forEach(f => {
+                    if (isFeatureSelected(f)) {
+                        setFeatureSelected(f, false);
+                    }
+                });
+            }
+        });
+    }
+    addControl(element, position) {
+        this._assertInitialized();
+        this.googleMap.controls[position].push(element);
+    }
+    setData(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._assertInitialized();
+            removeAllFeatures(this.googleMap.data);
+            this.googleMap.data.addGeoJson(data);
+            this.googleMap.fitBounds(getBoundsWithAllFeatures(this.googleMap.data));
+        });
+    }
+    // TODO: Refactor out of the service meant to just wrap the google maps api.
+    reCenterOnFeatures() {
+        this._assertInitialized();
+        if (getFeaturesCount(this.googleMap.data) === 0) {
+            if (!this._baseLatLng) {
+                return;
+            }
+            this.googleMap.panTo(this._baseLatLng);
+            return;
+        }
+        this.googleMap.fitBounds(getBoundsWithAllFeatures(this.googleMap.data));
+        // TODO: Fix to pan to center. Currently fitBounds results in the expected
+        // result, but pantToBounds animates.
+        // this.googleMap.panToBounds(getBoundsWithAllFeatures(this.googleMap.data))
+    }
+    allowDrawingHoleInPolygon(allow) {
+        this._allowDrawingHoleInPolygon = allow;
+    }
+    setFileInputHandler(handler) {
+        this._fileInputHandler;
+    }
+    getFileInputHandler() {
+        return this._fileInputHandler;
+    }
+    _initFeatureStyling() {
+        this._assertInitialized();
+        // Disable any selection when clicking the map.
+        //
+        // TODO: There may be a better way to do this that would be more accurate or
+        // additional events that should be listened to, such as the disabling
+        // selection when the map looses focus.
+        this.googleMap.addListener('click', (even) => {
+            this._assertInitialized();
+            this.googleMap.data.forEach(f => setFeatureSelected(f, false));
+        });
+        // Determine what the style of the features are.
+        this.googleMap.data.setStyle((feature) => {
+            if (isFeatureSelected(feature)) {
+                return FEATURE_STYLE_OPTIONS_SELECTED;
+            }
+            return FEATURE_STYLE_OPTIONS_DEFAULT;
+        });
+        // Select a feature when clicked.
+        this.googleMap.data.addListener('click', (event) => {
+            this._assertInitialized();
+            setFeatureSelected(event.feature, true);
+            this.googleMap.data.forEach(f => {
+                if (f !== event.feature && isFeatureSelected(f)) {
+                    setFeatureSelected(f, false);
+                }
+            });
+        });
+        // Set a style on hovered features that can be selected.
+        this.googleMap.data.addListener('mouseover', (event) => {
+            this._assertInitialized();
+            this.googleMap.data.revertStyle();
+            if (!this.isDrawing() && !isFeatureSelected(event.feature)) {
+                this.googleMap.data.overrideStyle(event.feature, { strokeWeight: 4 });
+            }
+        });
+        // Remove any hover styles when mouse moves away.
+        this.googleMap.data.addListener('mouseout', (event) => {
+            this._assertInitialized();
+            this.googleMap.data.revertStyle();
+        });
+    }
+    _initFeatureChangeListeners() {
+        this._assertInitialized();
+        createFeatureChangeObservable(this.googleMap.data, this._ngZone).pipe(switchMap(() => from(this.getGeoJson()).pipe(tap(geoJson => this._mapValueManager.setValue(geoJson, MapValueSource.FeatureChange)))), takeUntil(this._ngUnsubscribe)).subscribe();
+        this.googleMap.data.addListener('contextmenu', (event) => {
+            if (!isFeatureSelected(event.feature)) {
+                return;
+            }
+            this._openContextMenuForFeature(event.feature, event.latLng);
+        });
+        if (notNullOrUndefined(this._drawingManager)) {
+            google.maps.event.addListener(this._drawingManager, 'polygoncomplete', (polygon) => {
+                var _a;
+                // The DrawingManager doesn't seem to have a way to access the overlays,
+                // so if the map is not set then it shouldn'y be considered a successful
+                // completion. I am canceling the active drawing by disabling drawing
+                // mode and setting the map null in the 'overlaycomplete' event, which
+                // fires before the 'polygoncomplete' event.
+                if (isNullOrUndefined(polygon.getMap())) {
+                    return;
+                }
+                this._assertInitialized();
+                // Create a map feature of the drawn polygon.
+                const feature = createDataFeatureFromPolygon(polygon);
+                // Remove the drawn polygon.
+                polygon.setMap(null);
+                // Stop drawing.
+                (_a = this._drawingManager) === null || _a === void 0 ? void 0 : _a.setDrawingMode(null);
+                // Check if the feature should be used as a cutout to an existing
+                // feature or added as it's own feature.
+                const exteriorPolygonFeature = this._allowDrawingHoleInPolygon
+                    ? getPossibleExteriorFeature(this.googleMap.data, feature)
+                    : undefined;
+                if (exteriorPolygonFeature) {
+                    addInnerFeatureCutoutToExteriorFeature(exteriorPolygonFeature, feature);
+                    setFeatureSelected(exteriorPolygonFeature, true);
+                }
+                else {
+                    this.googleMap.data.add(feature);
+                    setFeatureSelected(feature, true);
+                }
+            });
+        }
+    }
+    isDrawing() {
+        if (isNullOrUndefined(this._drawingManager)) {
+            return true;
+        }
+        return this._drawingManager.getDrawingMode() !== null;
+    }
+    // TODO: Refactor out of the service meant to just wrap the google maps api.
+    hasSelectedFeature() {
+        this._assertInitialized();
+        let isSelected = false;
+        this.googleMap.data.forEach(f => {
+            if (isFeatureSelected(f)) {
+                isSelected = true;
+            }
+        });
+        return isSelected;
+    }
+    // TODO: Refactor out of the service meant to just wrap the google maps api.
+    getSelectedFeature() {
+        this._assertInitialized();
+        let feature = null;
+        this.googleMap.data.forEach(f => {
+            if (isFeatureSelected(f)) {
+                feature = f;
+            }
+        });
+        return feature;
+    }
+    // TODO: Refactor out of the service meant to just wrap the google maps api.
+    openContextMenu() {
+        const feature = this.getSelectedFeature();
+        if (feature) {
+            this._openContextMenuForFeature(feature);
+        }
+    }
+    // TODO: Refactor out of the service meant to just wrap the google maps api.
+    _openContextMenuForFeature(feature, position) {
+        if (this._activeContextMenu) {
+            this._activeContextMenu.close();
+            this._activeContextMenu = null;
+        }
+        this._assertInitialized();
+        let _position = position;
+        if (!_position) {
+            _position = getFeatureCenter(feature);
+        }
+        if (this._featureContextMenu) {
+            this._activeContextMenu = new GoogleMapsContextMenu(this.googleMap, this._featureContextMenu, _position, this._vcr, this._ngZone, this.googleMap.data, feature);
+        }
+    }
+    getGeoJson(removeAppProperties = true) {
+        return new Promise((resolve, reject) => {
+            this._assertInitialized();
+            this.googleMap.data.toGeoJson(f => {
+                if (removeAppProperties) {
+                    stripAppFeaturePropertiesFromJson(f);
+                }
+                resolve(f);
+            });
+        });
+    }
+    /** Asserts that the map has been initialized. */
+    _assertInitialized() {
+        if (!this.googleMap && (typeof ngDevMode === 'undefined' || ngDevMode)) {
+            throw Error('Cannot access Google Map information before the API has been initialized. ' +
+                'Please wait for the API to load before trying to interact with it.');
+        }
+    }
+}
+GoogleMapsService.decorators = [
+    { type: Injectable }
+];
+GoogleMapsService.ctorParameters = () => [
+    { type: MapValueManagerService },
+    { type: NgZone },
+    { type: ViewContainerRef }
+];
+export { ɵ0 };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"google-maps.service.js","sourceRoot":"","sources":["../../../../projects/ui-common/google-maps/google-maps.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, NgZone, OnDestroy, ViewContainerRef } from '@angular/core'\nimport { BehaviorSubject, from, Observable, Subject } from 'rxjs'\nimport { switchMap, takeUntil, tap } from 'rxjs/operators'\n\nimport { MenuComponent } from '@theseam/ui-common/menu'\nimport { isNullOrUndefined, notNullOrUndefined } from '@theseam/ui-common/utils'\n\nimport { GoogleMapsContextMenu } from './google-maps-contextmenu'\nimport {\n  addInnerFeatureCutoutToExteriorFeature,\n  createDataFeatureFromPolygon,\n  createFeatureChangeObservable,\n  getBoundsWithAllFeatures,\n  getFeatureCenter,\n  getFeaturesCount,\n  getPossibleExteriorFeature,\n  isFeatureSelected,\n  removeAllFeatures,\n  setFeatureSelected,\n  stripAppFeaturePropertiesFromJson,\n} from './google-maps-feature-helpers'\nimport { MapValueManagerService, MapValueSource } from './map-value-manager.service'\n\ndeclare const ngDevMode: boolean | undefined\n\nconst DEFAULT_POLYGON_OPTIONS: google.maps.PolygonOptions = {\n  clickable: true,\n  draggable: true,\n  editable: true,\n  // fillColor: 'rgba(60,150,60,1)',\n  // strokeColor: 'rgba(155,255,0,1)'\n}\n\nconst DEFAULT_DRAWING_MANAGER_OPTIONS: (() => google.maps.drawing.DrawingManagerOptions) = () => ({\n  drawingControl: true,\n  drawingControlOptions: {\n    drawingModes: [\n      google.maps.drawing.OverlayType.POLYGON\n    ]\n  },\n  polygonOptions: DEFAULT_POLYGON_OPTIONS,\n  drawingMode: null\n})\n\nconst FEATURE_STYLE_OPTIONS_DEFAULT: google.maps.Data.StyleOptions = {\n  clickable: true,\n  visible: true,\n  // zIndex?: number;\n\n  // cursor?: string;\n  draggable: false,\n  editable: false,\n  fillColor: 'teal',\n  fillOpacity: 0.3,\n  strokeColor: 'blue',\n  strokeOpacity: 1,\n  strokeWeight: 2,\n}\n\nconst FEATURE_STYLE_OPTIONS_SELECTED: google.maps.Data.StyleOptions = {\n  ...FEATURE_STYLE_OPTIONS_DEFAULT,\n  draggable: true,\n  editable: true,\n  fillColor: 'green',\n  fillOpacity: 0.7,\n  strokeColor: 'limegreen',\n  strokeOpacity: 1,\n  strokeWeight: 2,\n}\n\ntype WithRequired<T, K extends keyof T> = T & { [P in K]-?: T[P] }\n\n@Injectable()\nexport class GoogleMapsService implements OnDestroy {\n  private readonly _ngUnsubscribe = new Subject<void>()\n\n  private readonly _mapReadySubject = new BehaviorSubject<boolean>(false)\n\n  private _drawingManager?: google.maps.drawing.DrawingManager\n  private _featureContextMenu: MenuComponent | null = null\n  private _activeContextMenu: GoogleMapsContextMenu | null = null\n  private _baseLatLng?: google.maps.LatLngLiteral\n\n  private _allowDrawingHoleInPolygon: boolean = false\n\n  // TODO: Move to a better place than the map wrapper service.\n  private _fileInputHandler: ((file: File) => void) | undefined | null\n\n  public googleMap?: google.maps.Map\n\n  public readonly mapReady$: Observable<boolean>\n\n  public get mapReady(): boolean { return this._mapReadySubject.value }\n\n  constructor(\n    private readonly _mapValueManager: MapValueManagerService,\n    private readonly _ngZone: NgZone,\n    private readonly _vcr: ViewContainerRef,\n  ) {\n    this.mapReady$ = this._mapReadySubject.asObservable()\n  }\n\n  ngOnDestroy(): void {\n    this._ngUnsubscribe.next()\n    this._ngUnsubscribe.complete()\n  }\n\n  public setMap(map: google.maps.Map): void {\n    this.googleMap = map\n    this._mapReadySubject.next(true)\n    this._initDrawingManager()\n    this._initFeatureStyling()\n    this._initFeatureChangeListeners()\n  }\n\n  public setBaseLatLng(lat: number, lng: number): void {\n    this._baseLatLng = { lat, lng }\n  }\n\n  // TODO: Refactor out of the service meant to just wrap the google maps api.\n  public setFeatureContextMenu(menu: MenuComponent | null): void {\n    this._featureContextMenu = menu\n  }\n\n  public getDiv(): HTMLDivElement {\n    this._assertInitialized()\n    return this.googleMap.getDiv() as HTMLDivElement\n  }\n\n  public fitBounds(bounds: google.maps.LatLngBounds | google.maps.LatLngBoundsLiteral, padding?: number | google.maps.Padding): void {\n    this._assertInitialized()\n    this.googleMap.fitBounds(bounds, padding)\n  }\n\n  /**\n   * Iterates the map's features and removes any that are selected.\n   */\n  public deleteSelection(): void {\n    this._assertInitialized()\n    const mapData = this.googleMap.data\n    mapData.forEach(f => {\n      if (isFeatureSelected(f)) {\n        mapData.remove(f)\n      }\n    })\n  }\n\n  /**\n   * Stops the current drawing.\n   */\n  public stopDrawing(): void {\n    this._ngZone.runOutsideAngular(() => {\n      if (isNullOrUndefined(this._drawingManager) || this._drawingManager.getDrawingMode() === null) {\n        return\n      }\n\n      // Listening for the completion event of the overlay currently being drawn\n      // and removing it. I haven't found a way to cancel the current drawing,\n      // without this hack that assumes our listeners will not run into a race\n      // condition.\n      const listener = google.maps.event.addListener(\n        this._drawingManager,\n        'overlaycomplete',\n        (event: google.maps.drawing.OverlayCompleteEvent) => {\n          event.overlay.setMap(null)\n          listener.remove()\n        }\n      )\n\n      // To fake canceling the current drawing, without disabling the drawing\n      // mode, the drawin mode is being unset then immediately set back. When\n      // the mode is unset the 'overlaycomplete' event will fire, which will\n      // give a reference to the current overlay to remove, then it is set back\n      // to the mode the user was using. To the user is should just seem like\n      // the current drawing was canceled and they can start drawing again.\n      const mode = this._drawingManager.getDrawingMode()\n      this._drawingManager.setDrawingMode(null)\n      this._drawingManager.setDrawingMode(mode)\n\n      // 'overlaycomplete' should fire immediately, unless an overlay hadn't\n      // started drawing. This timeout will make sure the listener gets removed.\n      setTimeout(() => {\n        listener.remove()\n      })\n\n    })\n  }\n\n  private _initDrawingManager(): void {\n    if (notNullOrUndefined(this._drawingManager)) {\n      throw Error(`DrawingManager is already initialized.`)\n    }\n\n    this._assertInitialized()\n\n    const options = DEFAULT_DRAWING_MANAGER_OPTIONS()\n\n    const drawingManager = new google.maps.drawing.DrawingManager(options)\n    drawingManager.setMap(this.googleMap)\n\n    this._drawingManager = drawingManager\n\n    this._drawingManager.addListener('drawingmode_changed', event => {\n      if (this._drawingManager?.getDrawingMode() !== null) {\n        this._assertInitialized()\n        this.googleMap.data.forEach(f => {\n          if (isFeatureSelected(f)) {\n            setFeatureSelected(f, false)\n          }\n        })\n      }\n    })\n  }\n\n  public addControl(element: HTMLElement, position: google.maps.ControlPosition): void {\n    this._assertInitialized()\n    this.googleMap.controls[position].push(element)\n  }\n\n  public async setData(data: any): Promise<void> {\n    this._assertInitialized()\n    removeAllFeatures(this.googleMap.data)\n    this.googleMap.data.addGeoJson(data)\n    this.googleMap.fitBounds(getBoundsWithAllFeatures(this.googleMap.data))\n  }\n\n  // TODO: Refactor out of the service meant to just wrap the google maps api.\n  public reCenterOnFeatures(): void {\n    this._assertInitialized()\n    if (getFeaturesCount(this.googleMap.data) === 0) {\n      if (!this._baseLatLng) {\n        return\n      }\n\n      this.googleMap.panTo(this._baseLatLng)\n      return\n    }\n    this.googleMap.fitBounds(getBoundsWithAllFeatures(this.googleMap.data))\n\n    // TODO: Fix to pan to center. Currently fitBounds results in the expected\n    // result, but pantToBounds animates.\n    // this.googleMap.panToBounds(getBoundsWithAllFeatures(this.googleMap.data))\n  }\n\n  public allowDrawingHoleInPolygon(allow: boolean): void {\n    this._allowDrawingHoleInPolygon = allow\n  }\n\n  public setFileInputHandler(handler: ((file: File) => void) | undefined | null): void {\n    this._fileInputHandler\n  }\n\n  public getFileInputHandler(): ((file: File) => void) | undefined | null {\n    return this._fileInputHandler\n  }\n\n  private _initFeatureStyling(): void {\n    this._assertInitialized()\n\n    // Disable any selection when clicking the map.\n    //\n    // TODO: There may be a better way to do this that would be more accurate or\n    // additional events that should be listened to, such as the disabling\n    // selection when the map looses focus.\n    this.googleMap.addListener('click', (even: google.maps.MapMouseEvent | google.maps.IconMouseEvent) => {\n      this._assertInitialized()\n      this.googleMap.data.forEach(f => setFeatureSelected(f, false))\n    })\n\n    // Determine what the style of the features are.\n    this.googleMap.data.setStyle((feature) => {\n      if (isFeatureSelected(feature)) {\n        return FEATURE_STYLE_OPTIONS_SELECTED\n      }\n\n      return FEATURE_STYLE_OPTIONS_DEFAULT\n    })\n\n    // Select a feature when clicked.\n    this.googleMap.data.addListener('click', (event: google.maps.Data.MouseEvent) => {\n      this._assertInitialized()\n\n      setFeatureSelected(event.feature, true)\n      this.googleMap.data.forEach(f => {\n        if (f !== event.feature && isFeatureSelected(f)) {\n          setFeatureSelected(f, false)\n        }\n      })\n    })\n\n    // Set a style on hovered features that can be selected.\n    this.googleMap.data.addListener('mouseover', (event: google.maps.Data.MouseEvent) => {\n      this._assertInitialized()\n      this.googleMap.data.revertStyle()\n      if (!this.isDrawing() && !isFeatureSelected(event.feature)) {\n        this.googleMap.data.overrideStyle(event.feature, { strokeWeight: 4 })\n      }\n    })\n\n    // Remove any hover styles when mouse moves away.\n    this.googleMap.data.addListener('mouseout', (event: google.maps.Data.MouseEvent) => {\n      this._assertInitialized()\n      this.googleMap.data.revertStyle()\n    })\n  }\n\n  private _initFeatureChangeListeners(): void {\n    this._assertInitialized()\n\n    createFeatureChangeObservable(this.googleMap.data, this._ngZone).pipe(\n      switchMap(() => from(this.getGeoJson()).pipe(\n        tap(geoJson => this._mapValueManager.setValue(geoJson, MapValueSource.FeatureChange)),\n      )),\n      takeUntil(this._ngUnsubscribe),\n    ).subscribe()\n\n    this.googleMap.data.addListener('contextmenu', (event: google.maps.Data.MouseEvent) => {\n      if (!isFeatureSelected(event.feature)) {\n        return\n      }\n\n      this._openContextMenuForFeature(event.feature, event.latLng)\n    })\n\n    if (notNullOrUndefined(this._drawingManager)) {\n      google.maps.event.addListener(this._drawingManager, 'polygoncomplete', (polygon: google.maps.Polygon) => {\n        // The DrawingManager doesn't seem to have a way to access the overlays,\n        // so if the map is not set then it shouldn'y be considered a successful\n        // completion. I am canceling the active drawing by disabling drawing\n        // mode and setting the map null in the 'overlaycomplete' event, which\n        // fires before the 'polygoncomplete' event.\n        if (isNullOrUndefined(polygon.getMap())) {\n          return\n        }\n\n        this._assertInitialized()\n\n        // Create a map feature of the drawn polygon.\n        const feature = createDataFeatureFromPolygon(polygon)\n        // Remove the drawn polygon.\n        polygon.setMap(null)\n\n        // Stop drawing.\n        this._drawingManager?.setDrawingMode(null)\n\n        // Check if the feature should be used as a cutout to an existing\n        // feature or added as it's own feature.\n        const exteriorPolygonFeature = this._allowDrawingHoleInPolygon\n          ? getPossibleExteriorFeature(this.googleMap.data, feature)\n          : undefined\n        if (exteriorPolygonFeature) {\n          addInnerFeatureCutoutToExteriorFeature(exteriorPolygonFeature, feature)\n          setFeatureSelected(exteriorPolygonFeature, true)\n        } else {\n          this.googleMap.data.add(feature)\n          setFeatureSelected(feature, true)\n        }\n      })\n    }\n  }\n\n  public isDrawing(): boolean {\n    if (isNullOrUndefined(this._drawingManager)) {\n      return true\n    }\n\n    return this._drawingManager.getDrawingMode() !== null\n  }\n\n  // TODO: Refactor out of the service meant to just wrap the google maps api.\n  public hasSelectedFeature(): boolean {\n    this._assertInitialized()\n    let isSelected = false\n    this.googleMap.data.forEach(f => {\n      if (isFeatureSelected(f)) {\n        isSelected = true\n      }\n    })\n    return isSelected\n  }\n\n  // TODO: Refactor out of the service meant to just wrap the google maps api.\n  public getSelectedFeature(): google.maps.Data.Feature | null {\n    this._assertInitialized()\n    let feature: google.maps.Data.Feature | null = null\n    this.googleMap.data.forEach(f => {\n      if (isFeatureSelected(f)) {\n        feature = f\n      }\n    })\n    return feature\n  }\n\n  // TODO: Refactor out of the service meant to just wrap the google maps api.\n  public openContextMenu(): void {\n    const feature = this.getSelectedFeature()\n    if (feature) {\n      this._openContextMenuForFeature(feature)\n    }\n  }\n\n  // TODO: Refactor out of the service meant to just wrap the google maps api.\n  private _openContextMenuForFeature(feature: google.maps.Data.Feature, position?: google.maps.LatLng) {\n    if (this._activeContextMenu) {\n      this._activeContextMenu.close()\n      this._activeContextMenu = null\n    }\n\n    this._assertInitialized()\n\n    let _position = position\n    if (!_position) {\n      _position = getFeatureCenter(feature)\n    }\n    if (this._featureContextMenu) {\n      this._activeContextMenu = new GoogleMapsContextMenu(\n        this.googleMap,\n        this._featureContextMenu,\n        _position,\n        this._vcr,\n        this._ngZone,\n        this.googleMap.data,\n        feature,\n      )\n    }\n  }\n\n  public getGeoJson(removeAppProperties: boolean = true): Promise<object> {\n    return new Promise((resolve, reject) => {\n      this._assertInitialized()\n      this.googleMap.data.toGeoJson(f => {\n        if (removeAppProperties) {\n          stripAppFeaturePropertiesFromJson(f)\n        }\n        resolve(f)\n      })\n    })\n  }\n\n  /** Asserts that the map has been initialized. */\n  private _assertInitialized(): asserts this is WithRequired<GoogleMapsService, 'googleMap'> {\n    if (!this.googleMap && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n      throw Error(\n        'Cannot access Google Map information before the API has been initialized. ' +\n          'Please wait for the API to load before trying to interact with it.',\n      )\n    }\n  }\n}\n"]}

package/esm2015/google-maps/map-control.component.js

@@ -0,0 +1,65 @@
+import { ChangeDetectionStrategy, Component, Inject, Input, } from '@angular/core';
+import { Subject } from 'rxjs';
+import { takeUntil, tap } from 'rxjs/operators';
+import { GoogleMapsControlsService } from './google-maps-controls.service';
+import { GoogleMapsService } from './google-maps.service';
+import { MAP_CONTROLS_SERVICE } from './map-controls-service';
+export class TheSeamMapsControlComponent {
+    constructor(_googleMaps, _googleMapsControls) {
+        this._googleMaps = _googleMaps;
+        this._googleMapsControls = _googleMapsControls;
+        this._ngUnsubscribe = new Subject();
+    }
+    set def(value) {
+        if (value !== this._def) {
+            this._remove();
+            this._def = value;
+        }
+    }
+    /** @ignore */
+    ngOnInit() {
+        this._googleMaps.mapReady$.pipe(tap(ready => {
+            if (ready) {
+                this._add();
+            }
+            else {
+                this._remove();
+            }
+        }), takeUntil(this._ngUnsubscribe)).subscribe();
+    }
+    /** @ignore */
+    ngOnDestroy() {
+        this._remove();
+        this._ngUnsubscribe.next();
+        this._ngUnsubscribe.complete();
+    }
+    _add() {
+        if (this._controlRef) {
+            return;
+        }
+        if (this._def === null || this._def === undefined) {
+            return;
+        }
+        this._controlRef = this._googleMapsControls.add(this._def);
+    }
+    _remove() {
+        var _a;
+        (_a = this._controlRef) === null || _a === void 0 ? void 0 : _a.destroy();
+        this._controlRef = undefined;
+    }
+}
+TheSeamMapsControlComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'seam-map-control',
+                template: '',
+                changeDetection: ChangeDetectionStrategy.OnPush
+            },] }
+];
+TheSeamMapsControlComponent.ctorParameters = () => [
+    { type: GoogleMapsService },
+    { type: GoogleMapsControlsService, decorators: [{ type: Inject, args: [MAP_CONTROLS_SERVICE,] }] }
+];
+TheSeamMapsControlComponent.propDecorators = {
+    def: [{ type: Input }]
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/google-maps/map-controls-service.js

@@ -0,0 +1,4 @@
+import { InjectionToken } from '@angular/core';
+export const MAP_CONTROLS_SERVICE = new InjectionToken('MAP_CONTROLS_SERVICE');
+export const MAP_CONTROL_DATA = new InjectionToken('MAP_CONTROL_DATA');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWFwLWNvbnRyb2xzLXNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy91aS1jb21tb24vZ29vZ2xlLW1hcHMvbWFwLWNvbnRyb2xzLXNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGVBQWUsQ0FBQTtBQWM5QyxNQUFNLENBQUMsTUFBTSxvQkFBb0IsR0FBRyxJQUFJLGNBQWMsQ0FBcUIsc0JBQXNCLENBQUMsQ0FBQTtBQUVsRyxNQUFNLENBQUMsTUFBTSxnQkFBZ0IsR0FBRyxJQUFJLGNBQWMsQ0FBTSxrQkFBa0IsQ0FBQyxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0aW9uVG9rZW4gfSBmcm9tICdAYW5ndWxhci9jb3JlJ1xuXG5pbXBvcnQgeyBDb21wb25lbnRUeXBlIH0gZnJvbSAnQHRoZXNlYW0vdWktY29tbW9uL21vZGVscydcblxuZXhwb3J0IGludGVyZmFjZSBNYXBDb250cm9sPFREYXRhID0gYW55PiB7XG4gIGNvbXBvbmVudDogQ29tcG9uZW50VHlwZTxhbnk+XG4gIGRhdGE/OiBURGF0YVxuICBwb3NpdGlvbj86IGdvb2dsZS5tYXBzLkNvbnRyb2xQb3NpdGlvblxufVxuXG5leHBvcnQgaW50ZXJmYWNlIE1hcENvbnRyb2xzU2VydmljZSB7XG4gIGFkZChjb250cm9sOiBNYXBDb250cm9sKTogdm9pZFxufVxuXG5leHBvcnQgY29uc3QgTUFQX0NPTlRST0xTX1NFUlZJQ0UgPSBuZXcgSW5qZWN0aW9uVG9rZW48TWFwQ29udHJvbHNTZXJ2aWNlPignTUFQX0NPTlRST0xTX1NFUlZJQ0UnKVxuXG5leHBvcnQgY29uc3QgTUFQX0NPTlRST0xfREFUQSA9IG5ldyBJbmplY3Rpb25Ub2tlbjxhbnk+KCdNQVBfQ09OVFJPTF9EQVRBJylcbiJdfQ==

package/esm2015/google-maps/map-file-drop/map-file-drop.component.js

@@ -0,0 +1,135 @@
+import { ChangeDetectionStrategy, Component, ElementRef, NgZone, Renderer2, } from '@angular/core';
+import { Subject } from 'rxjs';
+import { takeUntil, tap } from 'rxjs/operators';
+import { readGeoFile } from '@theseam/ui-common/utils';
+import { GoogleMapsService } from '../google-maps.service';
+import { MapValueManagerService, MapValueSource } from '../map-value-manager.service';
+/**
+ *
+ */
+export class TheSeamMapFileDropComponent {
+    constructor(_elementRef, _ngZone, _googleMaps, _mapValueManager, _renderer) {
+        this._elementRef = _elementRef;
+        this._ngZone = _ngZone;
+        this._googleMaps = _googleMaps;
+        this._mapValueManager = _mapValueManager;
+        this._renderer = _renderer;
+        this._ngUnsubscribe = new Subject();
+        this._listeners = [];
+        this._globalDragInProgress = false;
+        this._handleDragOverEvent = (event) => {
+            if (!this._dropAllowed()) {
+                return;
+            }
+            if (!this._isSupportedDataTransferTypes(event.dataTransfer)) {
+                return;
+            }
+            event.preventDefault();
+            event.dataTransfer.dropEffect = 'copy';
+        };
+        this._handleDropEvent = (event) => {
+            if (!this._dropAllowed()) {
+                return;
+            }
+            event.preventDefault();
+            event.stopPropagation();
+            this._renderer.setStyle(this._elementRef.nativeElement, 'display', 'none');
+            // TODO: Show error if multiple files?
+            if (!this._isSupportedDataTransfer(event.dataTransfer)) {
+                return;
+            }
+            const item = event.dataTransfer.items[0];
+            const file = item.getAsFile();
+            readGeoFile(file).then(json => {
+                this._mapValueManager.setValue(json, MapValueSource.Input);
+            });
+        };
+        this._handleDragEnterEvent = (event) => {
+            if (!this._dropAllowed()) {
+                return;
+            }
+            if (!this._isSupportedDataTransferTypes(event.dataTransfer)) {
+                return;
+            }
+            this._renderer.setStyle(this._elementRef.nativeElement, 'display', 'block');
+        };
+        this._handleDragLeaveEvent = (event) => {
+            if (!this._dropAllowed()) {
+                return;
+            }
+            this._renderer.setStyle(this._elementRef.nativeElement, 'display', 'none');
+        };
+    }
+    /** @ignore */
+    ngOnInit() {
+        this._googleMaps.mapReady$.pipe(tap(ready => {
+            if (ready) {
+                this._enableFileDrop();
+            }
+            else {
+                this._disableFileDrop();
+            }
+        }), takeUntil(this._ngUnsubscribe)).subscribe();
+    }
+    /** @ignore */
+    ngOnDestroy() {
+        this._disableFileDrop();
+        this._ngUnsubscribe.next();
+        this._ngUnsubscribe.complete();
+    }
+    _enableFileDrop() {
+        const divElement = this._googleMaps.getDiv();
+        if (this._mapDiv === divElement) {
+            return;
+        }
+        if (this._mapDiv !== undefined) {
+            // Disable file drop on previous map div.
+            this._disableFileDrop();
+        }
+        this._mapDiv = divElement;
+        this._ngZone.runOutsideAngular(() => {
+            this._listeners.push(this._renderer.listen('document', 'dragstart', (event) => {
+                this._globalDragInProgress = true;
+            }));
+            this._listeners.push(this._renderer.listen('document', 'dragend', (event) => {
+                this._globalDragInProgress = false;
+            }));
+            this._listeners.push(this._renderer.listen(divElement, 'dragover', this._handleDragOverEvent));
+            this._listeners.push(this._renderer.listen(this._elementRef.nativeElement, 'dragover', this._handleDragOverEvent));
+            this._listeners.push(this._renderer.listen(this._elementRef.nativeElement, 'drop', this._handleDropEvent));
+            this._listeners.push(this._renderer.listen(divElement, 'dragenter', this._handleDragEnterEvent));
+            this._listeners.push(this._renderer.listen(this._elementRef.nativeElement, 'dragleave', this._handleDragLeaveEvent));
+        });
+    }
+    _disableFileDrop() {
+        if (this._listeners.length > 0) {
+            this._listeners.forEach(l => l());
+            this._listeners = [];
+        }
+    }
+    _dropAllowed() {
+        return !this._globalDragInProgress;
+    }
+    _isSupportedDataTransfer(dataTransfer) {
+        return dataTransfer.files.length === 1 && dataTransfer.types[0] === 'Files';
+    }
+    _isSupportedDataTransferTypes(dataTransfer) {
+        return dataTransfer.types[0] === 'Files';
+    }
+}
+TheSeamMapFileDropComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'seam-map-file-drop',
+                template: "",
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                styles: [":host{display:none;position:absolute;top:0;left:0;width:100%;height:100%;z-index:9999!important;background-color:#1e1e1eb3}\n"]
+            },] }
+];
+TheSeamMapFileDropComponent.ctorParameters = () => [
+    { type: ElementRef },
+    { type: NgZone },
+    { type: GoogleMapsService },
+    { type: MapValueManagerService },
+    { type: Renderer2 }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"map-file-drop.component.js","sourceRoot":"","sources":["../../../../../projects/ui-common/google-maps/map-file-drop/map-file-drop.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectionStrategy,\n  Component,\n  ElementRef,\n  NgZone,\n  OnDestroy,\n  OnInit,\n  Renderer2,\n} from '@angular/core'\nimport { Subject } from 'rxjs'\nimport { takeUntil, tap } from 'rxjs/operators'\n\nimport { readGeoFile } from '@theseam/ui-common/utils'\n\nimport { GoogleMapsService } from '../google-maps.service'\nimport { MapValueManagerService, MapValueSource } from '../map-value-manager.service'\n\n/**\n *\n */\n@Component({\n  selector: 'seam-map-file-drop',\n  templateUrl: './map-file-drop.component.html',\n  styleUrls: ['./map-file-drop.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class TheSeamMapFileDropComponent implements OnInit, OnDestroy {\n\n  private readonly _ngUnsubscribe = new Subject<void>()\n\n  /**\n   * Map element drag events added to.\n   */\n  private _mapDiv: HTMLDivElement | undefined\n\n  private _listeners: (() => void)[]  = []\n\n  private _globalDragInProgress: boolean = false\n\n  constructor(\n    private readonly _elementRef: ElementRef,\n    private readonly _ngZone: NgZone,\n    private readonly _googleMaps: GoogleMapsService,\n    private readonly _mapValueManager: MapValueManagerService,\n    private readonly _renderer: Renderer2\n  ) { }\n\n  /** @ignore */\n  ngOnInit() {\n    this._googleMaps.mapReady$.pipe(\n      tap(ready => {\n        if (ready) {\n          this._enableFileDrop()\n        } else {\n          this._disableFileDrop()\n        }\n      }),\n      takeUntil(this._ngUnsubscribe)\n    ).subscribe()\n  }\n\n  /** @ignore */\n  ngOnDestroy() {\n    this._disableFileDrop()\n\n    this._ngUnsubscribe.next()\n    this._ngUnsubscribe.complete()\n  }\n\n  private _enableFileDrop(): void {\n    const divElement = this._googleMaps.getDiv()\n    if (this._mapDiv === divElement) {\n      return\n    }\n\n    if (this._mapDiv !== undefined) {\n      // Disable file drop on previous map div.\n      this._disableFileDrop()\n    }\n\n    this._mapDiv = divElement\n    this._ngZone.runOutsideAngular(() => {\n      this._listeners.push(this._renderer.listen('document', 'dragstart', (event: Event) => {\n        this._globalDragInProgress = true\n      }))\n\n      this._listeners.push(this._renderer.listen('document', 'dragend', (event: Event) => {\n        this._globalDragInProgress = false\n      }))\n\n      this._listeners.push(this._renderer.listen(divElement, 'dragover', this._handleDragOverEvent))\n      this._listeners.push(this._renderer.listen(this._elementRef.nativeElement, 'dragover', this._handleDragOverEvent))\n      this._listeners.push(this._renderer.listen(this._elementRef.nativeElement, 'drop', this._handleDropEvent))\n      this._listeners.push(this._renderer.listen(divElement, 'dragenter', this._handleDragEnterEvent))\n      this._listeners.push(this._renderer.listen(this._elementRef.nativeElement, 'dragleave', this._handleDragLeaveEvent))\n    })\n  }\n\n  private _disableFileDrop(): void {\n    if (this._listeners.length > 0) {\n      this._listeners.forEach(l => l())\n      this._listeners = []\n    }\n  }\n\n  private readonly _handleDragOverEvent = (event: any) => {\n    if (!this._dropAllowed()) {\n      return\n    }\n\n    if (!this._isSupportedDataTransferTypes(event.dataTransfer)) {\n      return\n    }\n\n    event.preventDefault()\n    event.dataTransfer.dropEffect = 'copy'\n  }\n\n  private readonly _handleDropEvent = (event: any) => {\n    if (!this._dropAllowed()) {\n      return\n    }\n\n    event.preventDefault()\n    event.stopPropagation()\n    this._renderer.setStyle(this._elementRef.nativeElement, 'display', 'none')\n\n    // TODO: Show error if multiple files?\n    if (!this._isSupportedDataTransfer(event.dataTransfer)) {\n      return\n    }\n\n    const item = event.dataTransfer.items[0]\n    const file = item.getAsFile()\n    readGeoFile(file).then(json => {\n      this._mapValueManager.setValue(json, MapValueSource.Input)\n    })\n  }\n\n  private readonly _handleDragEnterEvent = (event: any) => {\n    if (!this._dropAllowed()) {\n      return\n    }\n\n    if (!this._isSupportedDataTransferTypes(event.dataTransfer)) {\n      return\n    }\n\n    this._renderer.setStyle(this._elementRef.nativeElement, 'display', 'block')\n  }\n\n  private readonly _handleDragLeaveEvent = (event: any) => {\n    if (!this._dropAllowed()) {\n      return\n    }\n\n    this._renderer.setStyle(this._elementRef.nativeElement, 'display', 'none')\n  }\n\n  private _dropAllowed(): boolean {\n    return !this._globalDragInProgress\n  }\n\n  private _isSupportedDataTransfer(dataTransfer: DataTransfer): boolean {\n    return dataTransfer.files.length === 1 && dataTransfer.types[0] === 'Files'\n  }\n\n  private _isSupportedDataTransferTypes(dataTransfer: DataTransfer): boolean {\n    return dataTransfer.types[0] === 'Files'\n  }\n\n}\n"]}