@theseam/ui-common 0.3.11 → 0.4.0-beta.0

package/esm2020/google-maps/google-maps/google-maps.component.mjs

@@ -0,0 +1,301 @@
+import { __decorate } from "tslib";
+import { coerceBooleanProperty, coerceNumberProperty } from '@angular/cdk/coercion';
+import { ChangeDetectionStrategy, Component, EventEmitter, forwardRef, HostBinding, Input, Output, ViewChild, } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { fromEvent, of, Subject } from 'rxjs';
+import { catchError, map, takeUntil, tap } from 'rxjs/operators';
+import { faCrosshairs, faFileImport } from '@fortawesome/free-solid-svg-icons';
+import { InputBoolean, InputNumber, mixinDisabled } from '@theseam/ui-common/core';
+import { MenuComponent } from '@theseam/ui-common/menu';
+import { GoogleMapsControlsService } from '../google-maps-controls.service';
+import { TheSeamGoogleMapsRecenterButtonControlComponent } from '../google-maps-recenter-button-control/google-maps-recenter-button-control.component';
+import { TheSeamGoogleMapsUploadButtonControlComponent } from '../google-maps-upload-button-control/google-maps-upload-button-control.component';
+import { GoogleMapsService } from '../google-maps.service';
+import { MAP_CONTROLS_SERVICE } from '../map-controls-service';
+import { MapValueManagerService, MapValueSource } from '../map-value-manager.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/a11y";
+import * as i2 from "../google-maps.service";
+import * as i3 from "../map-value-manager.service";
+import * as i4 from "../google-maps-api-loader/google-maps-api-loader";
+import * as i5 from "@angular/common";
+import * as i6 from "@theseam/ui-common/menu";
+import * as i7 from "@angular/google-maps";
+import * as i8 from "../map-file-drop/map-file-drop.component";
+import * as i9 from "../map-control.component";
+class TheSeamGoogleMapsComponentBase {
+    constructor(_elementRef) {
+        this._elementRef = _elementRef;
+    }
+}
+const _TheSeamGoogleMapsMixinBase = mixinDisabled(TheSeamGoogleMapsComponentBase);
+/**
+ * A wrapper for googlemap.
+ */
+export class TheSeamGoogleMapsComponent extends _TheSeamGoogleMapsMixinBase {
+    constructor(elementRef, _focusMonitor, _googleMaps, _mapValueManager, _googleMapsApiLoader) {
+        super(elementRef);
+        this._focusMonitor = _focusMonitor;
+        this._googleMaps = _googleMaps;
+        this._mapValueManager = _mapValueManager;
+        this._googleMapsApiLoader = _googleMapsApiLoader;
+        this._ngUnsubscribe = new Subject();
+        this._fileUploadControlDef = {
+            component: TheSeamGoogleMapsUploadButtonControlComponent,
+            data: { label: 'Import Geo File', icon: faFileImport },
+            position: 6 /* google.maps.ControlPosition.LEFT_BOTTOM */,
+        };
+        this._reCenterControlDef = {
+            component: TheSeamGoogleMapsRecenterButtonControlComponent,
+            data: { label: 'Center on Field', icon: faCrosshairs },
+            position: 9 /* google.maps.ControlPosition.RIGHT_BOTTOM */,
+        };
+        this._focusOrigin = null;
+        /**
+         * Set the tab index to `-1` to allow the root element of the
+         * component to receive `focus` event from javascript, but not get focused by
+         * keyboard navigation.
+         */
+        this._tabIndex = -1;
+        this.fileDropEnabled = true;
+        this.fileUploadControlEnabled = false;
+        this.fullscreenControlEnabled = true;
+        this.reCenterControlEnabled = true;
+        this.mapTypeControlEnabled = true;
+        this.streetViewControlEnabled = false;
+        this.allowDrawingHoleInPolygon = false;
+        this.zoom = 14;
+        this.longitude = -98.570209;
+        this.latitude = 37.633814;
+        this.mapReady = new EventEmitter();
+        this._options = {
+            mapTypeControl: true,
+            mapTypeId: 'hybrid',
+            streetViewControl: false,
+            fullscreenControl: this.fullscreenControlEnabled
+        };
+        this._focusMonitor.monitor(this._elementRef, true).pipe(tap(origin => this._focusOrigin = origin), takeUntil(this._ngUnsubscribe)).subscribe();
+        this._mapValueManager.valueChanged.pipe(tap(change => {
+            if (this.onChange) {
+                this.onChange(change.value);
+            }
+            if (this.onTouched) {
+                this.onTouched();
+            }
+        }), tap(changed => {
+            if (this._googleMaps.mapReady && changed.source !== MapValueSource.FeatureChange) {
+                this._googleMaps.setData(changed.value);
+            }
+        }), takeUntil(this._ngUnsubscribe)).subscribe();
+        this._googleMaps.setBaseLatLng(this.latitude, this.longitude);
+        this._gmApiLoaded = this._googleMapsApiLoader.load().pipe(map(() => true), catchError(() => of(false)));
+    }
+    set value(value) {
+        this._mapValueManager.setValue(value, MapValueSource.Input);
+    }
+    get value() {
+        return this._mapValueManager.value;
+    }
+    set tabIndex(value) { this._tabIndex = coerceNumberProperty(value); }
+    get tabIndex() { return this._tabIndex; }
+    set fileImportHandler(value) {
+        this._googleMaps.setFileInputHandler(value);
+    }
+    get _attrDisabled() { return this.disabled || null; }
+    get _attrTabIndex() { return this.disabled ? -1 : (this.tabIndex || 0); }
+    /** @ignore */
+    ngOnInit() {
+        this._googleMaps.setFeatureContextMenu(this.featureContextMenu);
+        fromEvent(window, 'keydown').pipe(tap((event) => {
+            switch (event.code) {
+                case 'Delete':
+                    this._googleMaps.deleteSelection();
+                    event.preventDefault();
+                    event.stopPropagation();
+                    break;
+                case 'Escape':
+                    this._googleMaps.stopDrawing();
+                    event.preventDefault();
+                    event.stopPropagation();
+                    break;
+                case 'ContextMenu':
+                    this._googleMaps.openContextMenu();
+                    event.preventDefault();
+                    event.stopPropagation();
+                    break;
+            }
+        }), takeUntil(this._ngUnsubscribe)).subscribe();
+    }
+    /** @ignore */
+    ngOnDestroy() {
+        this._focusMonitor.stopMonitoring(this._elementRef);
+        this._ngUnsubscribe.next();
+        this._ngUnsubscribe.complete();
+    }
+    /** @ignore */
+    ngAfterViewInit() { }
+    ngOnChanges(changes) {
+        let updateBase = false;
+        if (changes.hasOwnProperty('latitude')) {
+            this.latitude = changes['latitude'].currentValue;
+            updateBase = true;
+        }
+        if (changes.hasOwnProperty('longitude')) {
+            this.longitude = changes['longitude'].currentValue;
+            updateBase = true;
+        }
+        if (updateBase) {
+            this._googleMaps.setBaseLatLng(this.latitude, this.longitude);
+        }
+        if (changes.hasOwnProperty('allowDrawingHoleInPolygon')) {
+            this._googleMaps.allowDrawingHoleInPolygon(this.allowDrawingHoleInPolygon);
+        }
+        if (changes.hasOwnProperty('fullscreenControlEnabled')) {
+            const fullscreenControl = coerceBooleanProperty(changes['fullscreenControlEnabled'].currentValue);
+            if (fullscreenControl !== this._options.fullscreenControl) {
+                this._options = {
+                    ...this._options,
+                    fullscreenControl,
+                };
+            }
+        }
+    }
+    writeValue(value) {
+        this.value = value;
+    }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    setDisabledState(isDisabled) {
+        this.disabled = isDisabled;
+    }
+    fitBounds(bounds, padding) {
+        this._googleMaps.fitBounds(bounds, padding);
+    }
+    getGeoJson() {
+        return this._googleMaps.getGeoJson();
+    }
+    hasFocus() {
+        return this._focusOrigin !== null && this._focusOrigin !== undefined;
+    }
+    /** Focuses the button. */
+    focus() {
+        this._getHostElement().focus();
+    }
+    _getHostElement() {
+        return this._elementRef.nativeElement;
+    }
+    _onMapReady(theMap) {
+        this._googleMaps.setMap(theMap);
+        this._googleMaps.setData(this._mapValueManager.value);
+        // NOTE: AgmMap has a race condition problem that causes the input latitude,
+        // longitude, and zoom to get ignored, before googlemaps emits
+        // 'center_changed'. This should avoid the issue, until we stop using AgmMap
+        // or upgrade to a more recent version that may not have the issue anymore.
+        // TODO: Check if the switch to '@angular/google-maps' fixed this problem.
+        this._googleMaps.reCenterOnFeatures();
+        this._googleMaps.googleMap?.setZoom(this.zoom);
+    }
+    _onClickDeleteFeature() {
+        this._googleMaps.deleteSelection();
+    }
+}
+TheSeamGoogleMapsComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: TheSeamGoogleMapsComponent, deps: [{ token: i0.ElementRef }, { token: i1.FocusMonitor }, { token: i2.GoogleMapsService }, { token: i3.MapValueManagerService }, { token: i4.TheSeamGoogleMapsApiLoader }], target: i0.ɵɵFactoryTarget.Component });
+TheSeamGoogleMapsComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.3", type: TheSeamGoogleMapsComponent, selector: "seam-google-maps", inputs: { disabled: "disabled", value: "value", tabIndex: "tabIndex", fileDropEnabled: "fileDropEnabled", fileUploadControlEnabled: "fileUploadControlEnabled", fullscreenControlEnabled: "fullscreenControlEnabled", reCenterControlEnabled: "reCenterControlEnabled", mapTypeControlEnabled: "mapTypeControlEnabled", streetViewControlEnabled: "streetViewControlEnabled", allowDrawingHoleInPolygon: "allowDrawingHoleInPolygon", fileImportHandler: "fileImportHandler", zoom: "zoom", longitude: "longitude", latitude: "latitude" }, outputs: { mapReady: "mapReady" }, host: { properties: { "attr.disabled": "this._attrDisabled", "attr.tabindex": "this._attrTabIndex" } }, providers: [
+        MapValueManagerService,
+        GoogleMapsService,
+        { provide: MAP_CONTROLS_SERVICE, useClass: GoogleMapsControlsService },
+        {
+            provide: NG_VALUE_ACCESSOR,
+            // tslint:disable-next-line: no-use-before-declare
+            useExisting: forwardRef(() => TheSeamGoogleMapsComponent),
+            multi: true
+        }
+    ], viewQueries: [{ propertyName: "featureContextMenu", first: true, predicate: ["featureContextMenu"], descendants: true, read: MenuComponent, static: true }], exportAs: ["seamGoogleMaps"], usesInheritance: true, usesOnChanges: true, ngImport: i0, template: "<ng-container *ngIf=\"_gmApiLoaded | async\">\n  <google-map\n    height=\"100%\"\n    width=\"100%\"\n    [center]=\"{ lat: latitude, lng: longitude }\"\n    [zoom]=\"zoom\"\n    [options]=\"_options\"\n    (mapInitialized)=\"_onMapReady($any($event))\"\n    >\n  </google-map>\n</ng-container>\n<seam-menu #featureContextMenu>\n  <button seamMenuItem (click)=\"_onClickDeleteFeature()\">Delete</button>\n</seam-menu>\n<seam-map-file-drop *ngIf=\"fileDropEnabled\"></seam-map-file-drop>\n\n<seam-map-control *ngIf=\"fileUploadControlEnabled\" [def]=\"_fileUploadControlDef\"></seam-map-control>\n<seam-map-control *ngIf=\"reCenterControlEnabled\" [def]=\"_reCenterControlDef\"></seam-map-control>\n", styles: [":host{display:block;position:relative;height:400px;width:100%}:host.show-focus-border.cdk-focused{outline:0;box-shadow:0 0 0 .2rem #357ebd40}:host.show-focus-border[disabled]{opacity:.65}\n"], dependencies: [{ kind: "directive", type: i5.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i6.MenuComponent, selector: "seam-menu", inputs: ["menuClass", "baseWidth", "animationType"], outputs: ["closed"], exportAs: ["seamMenu"] }, { kind: "component", type: i6.MenuItemComponent, selector: "[seamMenuItem]", inputs: ["disabled", "role", "icon", "iconClass", "badgeText", "badgeTheme"], exportAs: ["seamMenuItem"] }, { kind: "component", type: i7.GoogleMap, selector: "google-map", inputs: ["height", "width", "mapTypeId", "center", "zoom", "options"], outputs: ["mapInitialized", "authFailure", "boundsChanged", "centerChanged", "mapClick", "mapDblclick", "mapDrag", "mapDragend", "mapDragstart", "headingChanged", "idle", "maptypeidChanged", "mapMousemove", "mapMouseout", "mapMouseover", "projectionChanged", "mapRightclick", "tilesloaded", "tiltChanged", "zoomChanged"], exportAs: ["googleMap"] }, { kind: "component", type: i8.TheSeamMapFileDropComponent, selector: "seam-map-file-drop" }, { kind: "component", type: i9.TheSeamMapsControlComponent, selector: "seam-map-control", inputs: ["def"] }, { kind: "pipe", type: i5.AsyncPipe, name: "async" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+__decorate([
+    InputBoolean()
+], TheSeamGoogleMapsComponent.prototype, "fileDropEnabled", void 0);
+__decorate([
+    InputBoolean()
+], TheSeamGoogleMapsComponent.prototype, "fileUploadControlEnabled", void 0);
+__decorate([
+    InputBoolean()
+], TheSeamGoogleMapsComponent.prototype, "fullscreenControlEnabled", void 0);
+__decorate([
+    InputBoolean()
+], TheSeamGoogleMapsComponent.prototype, "reCenterControlEnabled", void 0);
+__decorate([
+    InputBoolean()
+], TheSeamGoogleMapsComponent.prototype, "mapTypeControlEnabled", void 0);
+__decorate([
+    InputBoolean()
+], TheSeamGoogleMapsComponent.prototype, "streetViewControlEnabled", void 0);
+__decorate([
+    InputBoolean()
+], TheSeamGoogleMapsComponent.prototype, "allowDrawingHoleInPolygon", void 0);
+__decorate([
+    InputNumber()
+], TheSeamGoogleMapsComponent.prototype, "zoom", void 0);
+__decorate([
+    InputNumber()
+], TheSeamGoogleMapsComponent.prototype, "longitude", void 0);
+__decorate([
+    InputNumber()
+], TheSeamGoogleMapsComponent.prototype, "latitude", void 0);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: TheSeamGoogleMapsComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'seam-google-maps', inputs: [
+                        'disabled'
+                    ], providers: [
+                        MapValueManagerService,
+                        GoogleMapsService,
+                        { provide: MAP_CONTROLS_SERVICE, useClass: GoogleMapsControlsService },
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            // tslint:disable-next-line: no-use-before-declare
+                            useExisting: forwardRef(() => TheSeamGoogleMapsComponent),
+                            multi: true
+                        }
+                    ], changeDetection: ChangeDetectionStrategy.OnPush, exportAs: 'seamGoogleMaps', template: "<ng-container *ngIf=\"_gmApiLoaded | async\">\n  <google-map\n    height=\"100%\"\n    width=\"100%\"\n    [center]=\"{ lat: latitude, lng: longitude }\"\n    [zoom]=\"zoom\"\n    [options]=\"_options\"\n    (mapInitialized)=\"_onMapReady($any($event))\"\n    >\n  </google-map>\n</ng-container>\n<seam-menu #featureContextMenu>\n  <button seamMenuItem (click)=\"_onClickDeleteFeature()\">Delete</button>\n</seam-menu>\n<seam-map-file-drop *ngIf=\"fileDropEnabled\"></seam-map-file-drop>\n\n<seam-map-control *ngIf=\"fileUploadControlEnabled\" [def]=\"_fileUploadControlDef\"></seam-map-control>\n<seam-map-control *ngIf=\"reCenterControlEnabled\" [def]=\"_reCenterControlDef\"></seam-map-control>\n", styles: [":host{display:block;position:relative;height:400px;width:100%}:host.show-focus-border.cdk-focused{outline:0;box-shadow:0 0 0 .2rem #357ebd40}:host.show-focus-border[disabled]{opacity:.65}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.FocusMonitor }, { type: i2.GoogleMapsService }, { type: i3.MapValueManagerService }, { type: i4.TheSeamGoogleMapsApiLoader }]; }, propDecorators: { value: [{
+                type: Input
+            }], tabIndex: [{
+                type: Input
+            }], fileDropEnabled: [{
+                type: Input
+            }], fileUploadControlEnabled: [{
+                type: Input
+            }], fullscreenControlEnabled: [{
+                type: Input
+            }], reCenterControlEnabled: [{
+                type: Input
+            }], mapTypeControlEnabled: [{
+                type: Input
+            }], streetViewControlEnabled: [{
+                type: Input
+            }], allowDrawingHoleInPolygon: [{
+                type: Input
+            }], fileImportHandler: [{
+                type: Input
+            }], _attrDisabled: [{
+                type: HostBinding,
+                args: ['attr.disabled']
+            }], _attrTabIndex: [{
+                type: HostBinding,
+                args: ['attr.tabindex']
+            }], zoom: [{
+                type: Input
+            }], longitude: [{
+                type: Input
+            }], latitude: [{
+                type: Input
+            }], mapReady: [{
+                type: Output
+            }], featureContextMenu: [{
+                type: ViewChild,
+                args: ['featureContextMenu', { static: true, read: MenuComponent }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"google-maps.component.js","sourceRoot":"","sources":["../../../../../projects/ui-common/google-maps/google-maps/google-maps.component.ts","../../../../../projects/ui-common/google-maps/google-maps/google-maps.component.html"],"names":[],"mappings":"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","sourcesContent":["import { FocusMonitor, FocusOrigin } from '@angular/cdk/a11y'\nimport { BooleanInput, coerceBooleanProperty, coerceNumberProperty, NumberInput } from '@angular/cdk/coercion'\nimport {\n  AfterViewInit,\n  ChangeDetectionStrategy,\n  Component,\n  ElementRef,\n  EventEmitter,\n  forwardRef,\n  HostBinding,\n  Input,\n  OnChanges,\n  OnDestroy,\n  OnInit,\n  Output,\n  SimpleChanges,\n  ViewChild,\n} from '@angular/core'\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms'\nimport { fromEvent, Observable, of, Subject } from 'rxjs'\nimport { catchError, map, takeUntil, tap } from 'rxjs/operators'\n\nimport { faCrosshairs, faFileImport } from '@fortawesome/free-solid-svg-icons'\nimport { CanDisable, CanDisableCtor, InputBoolean, InputNumber, mixinDisabled } from '@theseam/ui-common/core'\nimport { MenuComponent } from '@theseam/ui-common/menu'\n\nimport { TheSeamGoogleMapsApiLoader } from '../google-maps-api-loader/google-maps-api-loader'\nimport { GoogleMapsControlsService } from '../google-maps-controls.service'\nimport { TheSeamGoogleMapsRecenterButtonControlComponent } from '../google-maps-recenter-button-control/google-maps-recenter-button-control.component'\nimport { TheSeamGoogleMapsUploadButtonControlComponent } from '../google-maps-upload-button-control/google-maps-upload-button-control.component'\nimport { GoogleMapsService } from '../google-maps.service'\nimport { MapControl, MAP_CONTROLS_SERVICE } from '../map-controls-service'\nimport { MapValue, MapValueManagerService, MapValueSource } from '../map-value-manager.service'\n\nclass TheSeamGoogleMapsComponentBase {\n  constructor(public _elementRef: ElementRef) {}\n}\n\nconst _TheSeamGoogleMapsMixinBase: CanDisableCtor &\n  typeof TheSeamGoogleMapsComponentBase =\n    mixinDisabled(TheSeamGoogleMapsComponentBase)\n\n/**\n * A wrapper for googlemap.\n */\n@Component({\n  selector: 'seam-google-maps',\n  templateUrl: './google-maps.component.html',\n  styleUrls: ['./google-maps.component.scss'],\n  inputs: [\n    'disabled'\n  ],\n  providers: [\n    MapValueManagerService,\n    GoogleMapsService,\n    { provide: MAP_CONTROLS_SERVICE, useClass: GoogleMapsControlsService },\n    {\n      provide: NG_VALUE_ACCESSOR,\n      // tslint:disable-next-line: no-use-before-declare\n      useExisting: forwardRef(() => TheSeamGoogleMapsComponent),\n      multi: true\n    }\n  ],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  exportAs: 'seamGoogleMaps'\n})\nexport class TheSeamGoogleMapsComponent extends _TheSeamGoogleMapsMixinBase\n  implements OnInit, AfterViewInit, OnDestroy, OnChanges, CanDisable, ControlValueAccessor {\n  static ngAcceptInputType_disabled: BooleanInput\n  static ngAcceptInputType_zoom: NumberInput\n  static ngAcceptInputType_longitude: NumberInput\n  static ngAcceptInputType_latitude: NumberInput\n  static ngAcceptInputType_fileDropEnabled: BooleanInput\n  static ngAcceptInputType_fileUploadControlEnabled: BooleanInput\n  static ngAcceptInputType_fullscreenControlEnabled: BooleanInput\n  static ngAcceptInputType_reCenterControlEnabled: BooleanInput\n  static ngAcceptInputType_mapTypeControlEnabled: BooleanInput\n  static ngAcceptInputType_streetViewControlEnabled: BooleanInput\n  static ngAcceptInputType_allowDrawingHoleInPolygon: BooleanInput\n\n  private readonly _ngUnsubscribe = new Subject<void>()\n\n  readonly _gmApiLoaded: Observable<boolean>\n\n  readonly _fileUploadControlDef: MapControl = {\n    component: TheSeamGoogleMapsUploadButtonControlComponent,\n    data: { label: 'Import Geo File', icon: faFileImport },\n    position: 6 /* google.maps.ControlPosition.LEFT_BOTTOM */,\n  }\n\n  readonly _reCenterControlDef: MapControl = {\n    component: TheSeamGoogleMapsRecenterButtonControlComponent,\n    data: { label: 'Center on Field', icon: faCrosshairs },\n    position: 9 /* google.maps.ControlPosition.RIGHT_BOTTOM */,\n  }\n\n  private _focusOrigin: FocusOrigin = null\n\n  @Input()\n  set value(value: MapValue) {\n    this._mapValueManager.setValue(value, MapValueSource.Input)\n  }\n  get value(): MapValue {\n    return this._mapValueManager.value\n  }\n\n  @Input()\n  set tabIndex(value: number) { this._tabIndex = coerceNumberProperty(value) }\n  get tabIndex(): number { return this._tabIndex }\n  /**\n   * Set the tab index to `-1` to allow the root element of the\n   * component to receive `focus` event from javascript, but not get focused by\n   * keyboard navigation.\n   */\n  private _tabIndex = -1\n\n  @Input() @InputBoolean() fileDropEnabled: boolean = true\n\n  @Input() @InputBoolean() fileUploadControlEnabled: boolean = false\n  @Input() @InputBoolean() fullscreenControlEnabled: boolean = true\n  @Input() @InputBoolean() reCenterControlEnabled: boolean = true\n  @Input() @InputBoolean() mapTypeControlEnabled: boolean = true\n  @Input() @InputBoolean() streetViewControlEnabled: boolean = false\n\n  @Input() @InputBoolean() allowDrawingHoleInPolygon: boolean = false\n\n  @Input()\n  set fileImportHandler(value: ((file: File) => void) | undefined | null) {\n    this._googleMaps.setFileInputHandler(value)\n  }\n\n  @HostBinding('attr.disabled')\n  get _attrDisabled() { return this.disabled || null }\n\n  @HostBinding('attr.tabindex')\n  get _attrTabIndex() { return this.disabled ? -1 : (this.tabIndex || 0) }\n\n  onChange: any\n  onTouched: any\n\n  @Input() @InputNumber() zoom: number = 14\n  @Input() @InputNumber() longitude: number = -98.570209\n  @Input() @InputNumber() latitude: number = 37.633814\n\n  @Output() mapReady = new EventEmitter<void>()\n\n  @ViewChild('featureContextMenu', { static: true, read: MenuComponent }) public featureContextMenu!: MenuComponent\n\n  _options = {\n    mapTypeControl: true,\n    mapTypeId: 'hybrid',\n    streetViewControl: false,\n    fullscreenControl: this.fullscreenControlEnabled\n  }\n\n  constructor(\n    elementRef: ElementRef,\n    private readonly _focusMonitor: FocusMonitor,\n    private readonly _googleMaps: GoogleMapsService,\n    private readonly _mapValueManager: MapValueManagerService,\n    private readonly _googleMapsApiLoader: TheSeamGoogleMapsApiLoader,\n  ) {\n    super(elementRef)\n\n    this._focusMonitor.monitor(this._elementRef, true).pipe(\n      tap(origin => this._focusOrigin = origin),\n      takeUntil(this._ngUnsubscribe),\n    ).subscribe()\n\n    this._mapValueManager.valueChanged.pipe(\n      tap(change => {\n        if (this.onChange) { this.onChange(change.value) }\n        if (this.onTouched) { this.onTouched() }\n      }),\n      tap(changed => {\n        if (this._googleMaps.mapReady && changed.source !== MapValueSource.FeatureChange) {\n          this._googleMaps.setData(changed.value)\n        }\n      }),\n      takeUntil(this._ngUnsubscribe),\n    ).subscribe()\n\n    this._googleMaps.setBaseLatLng(this.latitude, this.longitude)\n\n    this._gmApiLoaded = this._googleMapsApiLoader.load().pipe(\n      map(() => true),\n      catchError(() => of(false)),\n    )\n  }\n\n  /** @ignore */\n  ngOnInit() {\n    this._googleMaps.setFeatureContextMenu(this.featureContextMenu)\n\n    fromEvent<KeyboardEvent>(window, 'keydown').pipe(\n      tap((event: KeyboardEvent) => {\n        switch (event.code) {\n          case 'Delete': this._googleMaps.deleteSelection(); event.preventDefault(); event.stopPropagation(); break\n          case 'Escape': this._googleMaps.stopDrawing(); event.preventDefault(); event.stopPropagation();  break\n          case 'ContextMenu': this._googleMaps.openContextMenu(); event.preventDefault(); event.stopPropagation();  break\n        }\n      }),\n      takeUntil(this._ngUnsubscribe)\n    ).subscribe()\n  }\n\n  /** @ignore */\n  ngOnDestroy() {\n    this._focusMonitor.stopMonitoring(this._elementRef)\n\n    this._ngUnsubscribe.next()\n    this._ngUnsubscribe.complete()\n  }\n\n  /** @ignore */\n  ngAfterViewInit() { }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    let updateBase = false\n    if (changes.hasOwnProperty('latitude')) {\n      this.latitude = changes['latitude'].currentValue\n      updateBase = true\n    }\n    if (changes.hasOwnProperty('longitude')) {\n      this.longitude = changes['longitude'].currentValue\n      updateBase = true\n    }\n    if (updateBase) {\n      this._googleMaps.setBaseLatLng(this.latitude, this.longitude)\n    }\n\n    if (changes.hasOwnProperty('allowDrawingHoleInPolygon')) {\n      this._googleMaps.allowDrawingHoleInPolygon(this.allowDrawingHoleInPolygon)\n    }\n\n    if (changes.hasOwnProperty('fullscreenControlEnabled')) {\n      const fullscreenControl = coerceBooleanProperty(changes['fullscreenControlEnabled'].currentValue)\n      if (fullscreenControl !== this._options.fullscreenControl) {\n        this._options = {\n          ...this._options,\n          fullscreenControl,\n        }\n      }\n    }\n  }\n\n  writeValue(value: MapValue): void {\n    this.value = value\n  }\n\n  registerOnChange(fn: any): void {\n    this.onChange = fn\n  }\n\n  registerOnTouched(fn: any): void {\n    this.onTouched = fn\n  }\n\n  setDisabledState?(isDisabled: boolean): void {\n    this.disabled = isDisabled\n  }\n\n  public fitBounds(bounds: google.maps.LatLngBounds | google.maps.LatLngBoundsLiteral, padding?: number | google.maps.Padding): void {\n    this._googleMaps.fitBounds(bounds, padding)\n  }\n\n  public getGeoJson(): Promise<object> {\n    return this._googleMaps.getGeoJson()\n  }\n\n  public hasFocus(): boolean {\n    return this._focusOrigin !== null && this._focusOrigin !== undefined\n  }\n\n  /** Focuses the button. */\n  public focus(): void {\n    this._getHostElement().focus()\n  }\n\n  private _getHostElement() {\n    return this._elementRef.nativeElement\n  }\n\n  _onMapReady(theMap: google.maps.Map) {\n    this._googleMaps.setMap(theMap)\n    this._googleMaps.setData(this._mapValueManager.value)\n    // NOTE: AgmMap has a race condition problem that causes the input latitude,\n    // longitude, and zoom to get ignored, before googlemaps emits\n    // 'center_changed'. This should avoid the issue, until we stop using AgmMap\n    // or upgrade to a more recent version that may not have the issue anymore.\n    // TODO: Check if the switch to '@angular/google-maps' fixed this problem.\n    this._googleMaps.reCenterOnFeatures()\n    this._googleMaps.googleMap?.setZoom(this.zoom)\n  }\n\n  _onClickDeleteFeature() {\n    this._googleMaps.deleteSelection()\n  }\n}\n","<ng-container *ngIf=\"_gmApiLoaded | async\">\n  <google-map\n    height=\"100%\"\n    width=\"100%\"\n    [center]=\"{ lat: latitude, lng: longitude }\"\n    [zoom]=\"zoom\"\n    [options]=\"_options\"\n    (mapInitialized)=\"_onMapReady($any($event))\"\n    >\n  </google-map>\n</ng-container>\n<seam-menu #featureContextMenu>\n  <button seamMenuItem (click)=\"_onClickDeleteFeature()\">Delete</button>\n</seam-menu>\n<seam-map-file-drop *ngIf=\"fileDropEnabled\"></seam-map-file-drop>\n\n<seam-map-control *ngIf=\"fileUploadControlEnabled\" [def]=\"_fileUploadControlDef\"></seam-map-control>\n<seam-map-control *ngIf=\"reCenterControlEnabled\" [def]=\"_reCenterControlDef\"></seam-map-control>\n"]}

package/esm2020/google-maps/google-maps-api-loader/google-maps-api-loader.mjs

@@ -0,0 +1,3 @@
+export class TheSeamGoogleMapsApiLoader {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ29vZ2xlLW1hcHMtYXBpLWxvYWRlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3VpLWNvbW1vbi9nb29nbGUtbWFwcy9nb29nbGUtbWFwcy1hcGktbG9hZGVyL2dvb2dsZS1tYXBzLWFwaS1sb2FkZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsTUFBTSxPQUFnQiwwQkFBMEI7Q0FJL0MiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBPYnNlcnZhYmxlIH0gZnJvbSAncnhqcydcblxuZXhwb3J0IGFic3RyYWN0IGNsYXNzIFRoZVNlYW1Hb29nbGVNYXBzQXBpTG9hZGVyIHtcblxuICBhYnN0cmFjdCBsb2FkKCk6IE9ic2VydmFibGU8dm9pZD5cblxufVxuIl19

package/esm2020/google-maps/google-maps-controls.service.mjs

@@ -0,0 +1,67 @@
+import { Injectable, Injector } from '@angular/core';
+import { Subject } from 'rxjs';
+import { MAP_CONTROL_DATA } from './map-controls-service';
+import * as i0 from "@angular/core";
+import * as i1 from "./google-maps.service";
+export class MapControlRef {
+    constructor(_googleMaps, _componentFactoryResolver, _injector, _controlDef) {
+        this._googleMaps = _googleMaps;
+        this._componentFactoryResolver = _componentFactoryResolver;
+        this._injector = _injector;
+        this._controlDef = _controlDef;
+        this._destroyedSubject = new Subject();
+        this.destroyed = this._destroyedSubject.asObservable();
+        const component = this._controlDef.component;
+        const factory = this._componentFactoryResolver.resolveComponentFactory(component);
+        const providers = [];
+        if (this._controlDef.data) {
+            providers.push({
+                provide: MAP_CONTROL_DATA,
+                useValue: this._controlDef.data
+            });
+        }
+        const injector = Injector.create({
+            providers,
+            parent: this._injector,
+        });
+        this._componentRef = factory.create(injector);
+        this._componentRef.changeDetectorRef.detectChanges();
+        const position = this._controlDef.position ?? google.maps.ControlPosition.LEFT_BOTTOM;
+        this._googleMaps.addControl(this._componentRef.location.nativeElement, position);
+        this._addedAtPosition = position;
+    }
+    destroy() {
+        const googleMaps = this._googleMaps.googleMap;
+        if (googleMaps !== undefined) {
+            let idx = -1;
+            googleMaps.controls[this._addedAtPosition].forEach((elem, index) => {
+                if (elem === this._componentRef.location.nativeElement) {
+                    idx = index;
+                }
+            });
+            if (idx === -1) {
+                throw Error(`Unable to destroy control. Control not found.`);
+            }
+            googleMaps.controls[this._addedAtPosition].removeAt(idx);
+        }
+        this._componentRef.destroy();
+        this._destroyedSubject.next();
+        this._destroyedSubject.complete();
+    }
+}
+export class GoogleMapsControlsService {
+    constructor(_googleMaps, _componentFactoryResolver, _injector) {
+        this._googleMaps = _googleMaps;
+        this._componentFactoryResolver = _componentFactoryResolver;
+        this._injector = _injector;
+    }
+    add(control) {
+        return new MapControlRef(this._googleMaps, this._componentFactoryResolver, this._injector, control);
+    }
+}
+GoogleMapsControlsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: GoogleMapsControlsService, deps: [{ token: i1.GoogleMapsService }, { token: i0.ComponentFactoryResolver }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+GoogleMapsControlsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: GoogleMapsControlsService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: GoogleMapsControlsService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.GoogleMapsService }, { type: i0.ComponentFactoryResolver }, { type: i0.Injector }]; } });
+//# sourceMappingURL=data:application/json;base64,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