@theseam/ui-common 0.3.0 → 0.3.3

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

@@ -0,0 +1,261 @@
+import { __decorate } from "tslib";
+import { FocusMonitor } from '@angular/cdk/a11y';
+import { coerceNumberProperty } from '@angular/cdk/coercion';
+import { ChangeDetectionStrategy, Component, ElementRef, EventEmitter, forwardRef, HostBinding, Input, Output, ViewChild, } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { fromEvent, Subject } from 'rxjs';
+import { takeUntil, tap } from 'rxjs/operators';
+import { AgmMap } from '@agm/core';
+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';
+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) {
+        super(elementRef);
+        this._focusMonitor = _focusMonitor;
+        this._googleMaps = _googleMaps;
+        this._mapValueManager = _mapValueManager;
+        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._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);
+    }
+    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);
+        }
+    }
+    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) {
+        var _a;
+        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.
+        this._googleMaps.reCenterOnFeatures();
+        (_a = this._googleMaps.googleMap) === null || _a === void 0 ? void 0 : _a.setZoom(this.zoom);
+    }
+    _onClickDeleteFeature() {
+        this._googleMaps.deleteSelection();
+    }
+}
+TheSeamGoogleMapsComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'seam-google-maps',
+                template: "<agm-map\n  [latitude]=\"latitude\"\n  [longitude]=\"longitude\"\n  [zoom]=\"zoom\"\n  [mapTypeControl]=\"true\"\n  mapTypeId=\"hybrid\"\n  [streetViewControl]=\"false\"\n  (mapReady)=\"_onMapReady($event)\"\n  [fullscreenControl]=\"$any(fullscreenControlEnabled)\">\n</agm-map>\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",
+                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',
+                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}agm-map{height:inherit;width:inherit}\n"]
+            },] }
+];
+TheSeamGoogleMapsComponent.ctorParameters = () => [
+    { type: ElementRef },
+    { type: FocusMonitor },
+    { type: GoogleMapsService },
+    { type: MapValueManagerService }
+];
+TheSeamGoogleMapsComponent.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 }],
+    agmMap: [{ type: ViewChild, args: [AgmMap, { static: true },] }],
+    featureContextMenu: [{ type: ViewChild, args: ['featureContextMenu', { static: true, read: MenuComponent },] }],
+    agmMapTpl: [{ type: ViewChild, args: [AgmMap, { static: true, read: ElementRef },] }]
+};
+__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);
+//# 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"],"names":[],"mappings":"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","sourcesContent":["import { FocusMonitor, FocusOrigin } from '@angular/cdk/a11y'\nimport { BooleanInput, 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, Subject } from 'rxjs'\nimport { takeUntil, tap } from 'rxjs/operators'\n\nimport { AgmMap } from '@agm/core'\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 { FeatureCollection } from 'geojson'\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 _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(AgmMap, { static: true }) public agmMap!: AgmMap\n  @ViewChild('featureContextMenu', { static: true, read: MenuComponent }) public featureContextMenu!: MenuComponent\n\n  @ViewChild(AgmMap, { static: true, read: ElementRef }) public agmMapTpl!: ElementRef<HTMLElement>\n\n  constructor(\n    elementRef: ElementRef,\n    private readonly _focusMonitor: FocusMonitor,\n    private readonly _googleMaps: GoogleMapsService,\n    private readonly _mapValueManager: MapValueManagerService,\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\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\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    this._googleMaps.reCenterOnFeatures()\n    this._googleMaps.googleMap?.setZoom(this.zoom)\n  }\n\n  _onClickDeleteFeature() {\n    this._googleMaps.deleteSelection()\n  }\n}\n"]}

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

@@ -0,0 +1,113 @@
+import { ESCAPE } from '@angular/cdk/keycodes';
+import { fromEvent, Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import { isFeatureSelected } from './google-maps-feature-helpers';
+// TODO: Close on map losing focus.
+export class GoogleMapsContextMenu {
+    constructor(_map, _menu, _position, _vcr, _ngZone, _data, _feature) {
+        this._map = _map;
+        this._menu = _menu;
+        this._vcr = _vcr;
+        this._ngZone = _ngZone;
+        this._data = _data;
+        this._feature = _feature;
+        const tplRef = this._menu.templateRef;
+        if (tplRef === undefined || tplRef === null) {
+            throw Error(`Menu template is not defined.`);
+        }
+        const ref = this._vcr.createEmbeddedView(tplRef);
+        ref.detectChanges();
+        const listeners = [];
+        const ngUnsubscribe = new Subject();
+        // TODO: Fix the initial focus. setTimeout avoids the wrong contextmenu
+        // getting triggered, but the first item flashes and looks off this way.
+        setTimeout(() => {
+            this._menu.focusFirstItem('program');
+        });
+        this._menu.closed.pipe(takeUntil(ngUnsubscribe)).subscribe(v => {
+            this.close();
+        });
+        fromEvent(document, 'keydown').pipe(takeUntil(ngUnsubscribe)).subscribe((event) => {
+            if (event.keyCode === ESCAPE) {
+                this.close();
+            }
+        });
+        const __cleanup = () => this._cleanupFn();
+        class GoogleMapsContextMenuOverlayView extends google.maps.OverlayView {
+            constructor(position, content) {
+                super();
+                this.position = position;
+                this.position = position;
+                this.containerDiv = document.createElement('div');
+                this.containerDiv.style.cursor = 'auto';
+                this.containerDiv.style.height = '0',
+                    this.containerDiv.style.position = 'absolute';
+                this.containerDiv.appendChild(content);
+                // Optionally stop clicks, etc., from bubbling up to the map.
+                GoogleMapsContextMenuOverlayView.preventMapHitsAndGesturesFrom(this.containerDiv);
+            }
+            /** Called when the view is added to the map. */
+            onAdd() {
+                // tslint:disable-next-line: no-non-null-assertion
+                this.getPanes().floatPane.appendChild(this.containerDiv);
+            }
+            /** Called when the view is removed from the map. */
+            onRemove() {
+                if (this.containerDiv.parentElement) {
+                    this.containerDiv.parentElement.removeChild(this.containerDiv);
+                }
+                __cleanup();
+            }
+            /** Called each frame when the view needs to draw itself. */
+            draw() {
+                // tslint:disable-next-line: no-non-null-assertion
+                const divPosition = this.getProjection().fromLatLngToDivPixel(this.position);
+                // Hide the popup when it is far out of view.
+                const display = Math.abs(divPosition.x) < 4000 && Math.abs(divPosition.y) < 4000
+                    ? 'block'
+                    : 'none';
+                if (display === 'block') {
+                    this.containerDiv.style.left = divPosition.x + 'px';
+                    this.containerDiv.style.top = divPosition.y + 'px';
+                }
+                if (this.containerDiv.style.display !== display) {
+                    this.containerDiv.style.display = display;
+                }
+            }
+        }
+        this._overlayView = new GoogleMapsContextMenuOverlayView(_position, ref.rootNodes[0]);
+        this._overlayView.setMap(this._map);
+        this._ngZone.runOutsideAngular(() => {
+            listeners.push(this._data.addListener('removefeature', (event) => {
+                if (event.feature === this._feature) {
+                    this._ngZone.run(() => { this.close(); });
+                }
+            }));
+            listeners.push(this._data.addListener('setproperty', (event) => {
+                if (event.feature === this._feature && !isFeatureSelected(this._feature)) {
+                    this._ngZone.run(() => { this.close(); });
+                }
+            }));
+            listeners.push(this._data.addListener('removeproperty', (event) => {
+                if (event.feature === this._feature && !isFeatureSelected(this._feature)) {
+                    this._ngZone.run(() => { this.close(); });
+                }
+            }));
+            listeners.push(this._map.addListener('click', (event) => {
+                this._ngZone.run(() => { this.close(); });
+            }));
+            listeners.push(this._data.addListener('click', (event) => {
+                this._ngZone.run(() => { this.close(); });
+            }));
+        });
+        this._cleanupFn = () => {
+            ngUnsubscribe.next();
+            ngUnsubscribe.complete();
+            listeners.forEach(google.maps.event.removeListener);
+        };
+    }
+    close() {
+        this._overlayView.setMap(null);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"google-maps-contextmenu.js","sourceRoot":"","sources":["../../../../projects/ui-common/google-maps/google-maps-contextmenu.ts"],"names":[],"mappings":"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","sourcesContent":["import { ESCAPE } from '@angular/cdk/keycodes'\nimport { NgZone, ViewContainerRef } from '@angular/core'\nimport { fromEvent, Subject } from 'rxjs'\nimport { takeUntil } from 'rxjs/operators'\n\nimport { MenuComponent } from '@theseam/ui-common/menu'\n\nimport { isFeatureSelected } from './google-maps-feature-helpers'\n\n// TODO: Close on map losing focus.\n\nexport class GoogleMapsContextMenu {\n\n  private readonly _overlayView: google.maps.OverlayView\n  private readonly _cleanupFn: () => void\n\n  constructor(\n    private readonly _map: google.maps.Map,\n    private readonly _menu: MenuComponent,\n    _position: google.maps.LatLng,\n    private readonly _vcr: ViewContainerRef,\n    private readonly _ngZone: NgZone,\n    private readonly _data: google.maps.Data,\n    private readonly _feature: google.maps.Data.Feature,\n  ) {\n    const tplRef = this._menu.templateRef\n    if (tplRef === undefined || tplRef === null) {\n      throw Error(`Menu template is not defined.`)\n    }\n\n    const ref = this._vcr.createEmbeddedView(tplRef)\n    ref.detectChanges()\n\n    const listeners: google.maps.MapsEventListener[] = []\n    const ngUnsubscribe = new Subject<void>()\n\n    // TODO: Fix the initial focus. setTimeout avoids the wrong contextmenu\n    // getting triggered, but the first item flashes and looks off this way.\n    setTimeout(() => {\n      this._menu.focusFirstItem('program')\n    })\n    this._menu.closed.pipe(\n      takeUntil(ngUnsubscribe)\n    ).subscribe(v => {\n      this.close()\n    })\n\n    fromEvent(document, 'keydown').pipe(\n      takeUntil(ngUnsubscribe)\n    ).subscribe((event: any) => {\n      if (event.keyCode === ESCAPE) {\n        this.close()\n      }\n    })\n\n    const __cleanup = () => this._cleanupFn()\n    class GoogleMapsContextMenuOverlayView extends google.maps.OverlayView {\n      public containerDiv: HTMLDivElement\n\n      constructor(\n        public position: google.maps.LatLng,\n        content: HTMLElement\n      ) {\n        super()\n        this.position = position\n\n        this.containerDiv = document.createElement('div')\n        this.containerDiv.style.cursor = 'auto'\n        this.containerDiv.style.height = '0',\n        this.containerDiv.style.position = 'absolute'\n        this.containerDiv.appendChild(content)\n\n        // Optionally stop clicks, etc., from bubbling up to the map.\n        GoogleMapsContextMenuOverlayView.preventMapHitsAndGesturesFrom(this.containerDiv)\n      }\n\n      /** Called when the view is added to the map. */\n      onAdd() {\n        // tslint:disable-next-line: no-non-null-assertion\n        this.getPanes()!.floatPane.appendChild(this.containerDiv)\n      }\n\n      /** Called when the view is removed from the map. */\n      onRemove() {\n        if (this.containerDiv.parentElement) {\n          this.containerDiv.parentElement.removeChild(this.containerDiv)\n        }\n        __cleanup()\n      }\n\n      /** Called each frame when the view needs to draw itself. */\n      draw() {\n        // tslint:disable-next-line: no-non-null-assertion\n        const divPosition = this.getProjection().fromLatLngToDivPixel(this.position)!\n\n        // Hide the popup when it is far out of view.\n        const display =\n          Math.abs(divPosition.x) < 4000 && Math.abs(divPosition.y) < 4000\n            ? 'block'\n            : 'none'\n\n        if (display === 'block') {\n          this.containerDiv.style.left = divPosition.x + 'px'\n          this.containerDiv.style.top = divPosition.y + 'px'\n        }\n\n        if (this.containerDiv.style.display !== display) {\n          this.containerDiv.style.display = display\n        }\n      }\n    }\n\n    this._overlayView = new GoogleMapsContextMenuOverlayView(_position, ref.rootNodes[0])\n    this._overlayView.setMap(this._map)\n\n    this._ngZone.runOutsideAngular(() => {\n      listeners.push(this._data.addListener('removefeature', (event: google.maps.Data.RemoveFeatureEvent) => {\n        if (event.feature === this._feature) {\n          this._ngZone.run(() => { this.close() })\n        }\n      }))\n\n      listeners.push(this._data.addListener('setproperty', (event: google.maps.Data.SetPropertyEvent) => {\n        if (event.feature === this._feature && !isFeatureSelected(this._feature)) {\n          this._ngZone.run(() => { this.close() })\n        }\n      }))\n\n      listeners.push(this._data.addListener('removeproperty', (event: google.maps.Data.RemovePropertyEvent) => {\n        if (event.feature === this._feature && !isFeatureSelected(this._feature)) {\n          this._ngZone.run(() => { this.close() })\n        }\n      }))\n\n      listeners.push(this._map.addListener('click', (event: google.maps.MapMouseEvent | google.maps.IconMouseEvent) => {\n        this._ngZone.run(() => { this.close() })\n      }))\n\n      listeners.push(this._data.addListener('click', (event: google.maps.Data.MouseEvent) => {\n        this._ngZone.run(() => { this.close() })\n      }))\n    })\n\n    this._cleanupFn = () => {\n      ngUnsubscribe.next()\n      ngUnsubscribe.complete()\n      listeners.forEach(google.maps.event.removeListener)\n    }\n  }\n\n  public close(): void {\n    this._overlayView.setMap(null)\n  }\n\n}\n"]}

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

@@ -0,0 +1,70 @@
+import { ComponentFactoryResolver, Injectable, Injector } from '@angular/core';
+import { Subject } from 'rxjs';
+import { GoogleMapsService } from './google-maps.service';
+import { MAP_CONTROL_DATA } from './map-controls-service';
+export class MapControlRef {
+    constructor(_googleMaps, _componentFactoryResolver, _injector, _controlDef) {
+        var _a;
+        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 = (_a = this._controlDef.position) !== null && _a !== void 0 ? _a : 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.decorators = [
+    { type: Injectable }
+];
+GoogleMapsControlsService.ctorParameters = () => [
+    { type: GoogleMapsService },
+    { type: ComponentFactoryResolver },
+    { type: Injector }
+];
+//# sourceMappingURL=data:application/json;base64,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