@theseam/ui-common 0.3.15-beta.0 → 0.3.15-beta.1

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

@@ -0,0 +1,114 @@
+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() {
+                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() {
+                const divPosition = this.getProjection().fromLatLngToDivPixel(this.position);
+                if (!divPosition) {
+                    return;
+                }
+                // 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        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        const divPosition = this.getProjection().fromLatLngToDivPixel(this.position)\n        if (!divPosition) {\n          return\n        }\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/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.9", 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.9", ngImport: i0, type: GoogleMapsControlsService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", 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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

package/esm2020/google-maps/google-maps-feature-helpers.mjs

@@ -0,0 +1,211 @@
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { Observable } from 'rxjs';
+import { notNullOrUndefined } from '@theseam/ui-common/utils';
+import booleanContains from '@turf/boolean-contains';
+import { multiPolygon as turfjsMultiPolygon, polygon as turfjsPolygon, } from '@turf/helpers';
+export var AppFeaturePropertyName;
+(function (AppFeaturePropertyName) {
+    AppFeaturePropertyName["IsSelected"] = "__app__isSelected";
+})(AppFeaturePropertyName || (AppFeaturePropertyName = {}));
+export function isAppFeatureProperty(propertyName) {
+    return Object.values(AppFeaturePropertyName)
+        .findIndex(value => value === propertyName) !== -1;
+}
+export function isFeatureSelected(feature) {
+    const isSelected = feature.getProperty(AppFeaturePropertyName.IsSelected);
+    return coerceBooleanProperty(isSelected);
+}
+export function setFeatureSelected(feature, isSelected) {
+    feature.setProperty(AppFeaturePropertyName.IsSelected, isSelected);
+}
+// TODO: Check performance of cloning a google.maps.Data instance, so the
+// properties can be removed with the google maps api, instead of on the
+// resulting json.
+export function stripAppFeaturePropertiesFromJson(json) {
+    if (notNullOrUndefined(json) && Array.isArray(json?.features)) {
+        for (const feature of json.features) {
+            if (notNullOrUndefined(feature?.properties)) {
+                for (const k of Object.keys(feature.properties)) {
+                    if (isAppFeatureProperty(k)) {
+                        feature.properties[k] = undefined;
+                        delete feature.properties[k];
+                    }
+                }
+            }
+        }
+    }
+}
+/**
+ * Searches for a Feature in Data that contains the provided Feature and can use
+ * it as a cutout area.
+ */
+export function getPossibleExteriorFeature(data, feature) {
+    let exteriorPolygonFeature;
+    data.forEach(f => {
+        if (f === feature) {
+            return;
+        }
+        const geometry = f.getGeometry();
+        if (geometry === null) {
+            throw Error(`Geometry not found.`);
+        }
+        if (geometry.getType() === 'Polygon' && featureContains(f, feature)) {
+            exteriorPolygonFeature = f;
+        }
+    });
+    return exteriorPolygonFeature;
+}
+export function addInnerFeatureCutoutToExteriorFeature(exteriorFeature, innerFeature) {
+    const exteriorGeometry = exteriorFeature.getGeometry();
+    if (exteriorGeometry === null) {
+        throw Error(`Geometry not found.`);
+    }
+    const innerGeometry = innerFeature.getGeometry();
+    if (innerGeometry === null) {
+        throw Error(`Geometry not found.`);
+    }
+    // NOTE: Other geometries may support cutouts, but our map shapes editor only
+    // supports polygons currently, so we will need to handle other geometry types
+    // here if we start allowing users to draw shapes other than polygon.
+    if (exteriorGeometry.getType() !== 'Polygon' || innerGeometry.getType() !== 'Polygon') {
+        throw Error(`Inner cutout is only supported by Polygon gemoetry.`);
+    }
+    const featurePolygon = innerGeometry;
+    const exteriorPolygon = exteriorGeometry;
+    exteriorFeature.setGeometry(new google.maps.Data.Polygon([
+        ...exteriorPolygon.getArray(),
+        featurePolygon.getAt(0).getArray().reverse()
+    ]));
+}
+/**
+ * Google maps paths don't always start and stop at the exact same position, so
+ * this will fix that for turfjs.
+ */
+export function fixPathDifferentStartingAndEndingPoint(coordinates) {
+    if (coordinates.length <= 1) {
+        return;
+    }
+    const start = coordinates[0];
+    const end = coordinates[coordinates.length - 1];
+    if (start[0] === end[0] && start[1] === end[1]) {
+        return;
+    }
+    coordinates.push(coordinates[0]);
+}
+export function polygonHasValidPathsLengths(polygon, minPointsInValidPath = 3) {
+    const paths = polygon.getPaths().getArray();
+    for (const path of paths) {
+        if (path.getLength() < minPointsInValidPath) {
+            return false;
+        }
+    }
+    return true;
+}
+export function polygonCoordinates(polygon) {
+    return polygon.getArray().map(linRing => {
+        const coords = linRing.getArray().map(x => [x.lng(), x.lat()]);
+        fixPathDifferentStartingAndEndingPoint(coords);
+        return coords;
+    });
+}
+export function multiPolygonCoordinates(multiPolygon) {
+    return multiPolygon.getArray().map(x => polygonCoordinates(x));
+}
+export function toTurfJsPolygon(polygon) {
+    return turfjsPolygon(polygonCoordinates(polygon));
+}
+export function toTurfJsMultiPolygon(multiPolygon) {
+    return turfjsMultiPolygon(multiPolygonCoordinates(multiPolygon));
+}
+export function toTurfJsFeature(googleFeature) {
+    const geometry = googleFeature.getGeometry();
+    if (geometry === null) {
+        throw Error(`Geometry not found.`);
+    }
+    if (geometry.getType() === 'Polygon') {
+        return toTurfJsPolygon(geometry);
+    }
+    else if (geometry.getType() === 'MultiPolygon') {
+        return toTurfJsMultiPolygon(geometry);
+    }
+    throw Error(`Unexpected geometry.`);
+}
+export function featureContains(featureA, featureB) {
+    const polygonA = toTurfJsFeature(featureA);
+    const polygonB = toTurfJsFeature(featureB);
+    return booleanContains(polygonA, polygonB);
+}
+export function createDataFeatureFromPolygon(polygon) {
+    const arr = polygon.getPaths().getArray().map(x => x.getArray());
+    return new google.maps.Data.Feature({
+        geometry: new google.maps.Data.Polygon(arr)
+    });
+}
+export function getBoundsWithAllFeatures(data) {
+    const bounds = new google.maps.LatLngBounds();
+    data.forEach(feature => {
+        const geometry = feature.getGeometry();
+        if (geometry === null) {
+            throw Error(`Geometry not found.`);
+        }
+        geometry.forEachLatLng(latLng => {
+            bounds.extend(latLng);
+        });
+    });
+    return bounds;
+}
+export function getFeatureBounds(feature) {
+    const bounds = new google.maps.LatLngBounds();
+    const geometry = feature.getGeometry();
+    if (geometry === null) {
+        throw Error(`Geometry not found.`);
+    }
+    geometry.forEachLatLng(latLng => {
+        bounds.extend(latLng);
+    });
+    return bounds;
+}
+export function getFeatureCenter(feature) {
+    return getFeatureBounds(feature).getCenter();
+}
+export function removeAllFeatures(data) {
+    data.forEach(f => data.remove(f));
+}
+export function getFeaturesCount(data) {
+    let count = 0;
+    data.forEach(() => count++);
+    return count;
+}
+/**
+ * NOTE: Original events are not emitted, because filtering may omit events.
+ */
+export function createFeatureChangeObservable(data, ngZone) {
+    return new Observable(subscriber => {
+        const listeners = [];
+        ngZone.runOutsideAngular(() => {
+            listeners.push(data.addListener('setgeometry', (event) => {
+                ngZone.run(() => { subscriber.next(undefined); });
+            }));
+            listeners.push(data.addListener('addfeature', (event) => {
+                ngZone.run(() => { subscriber.next(undefined); });
+            }));
+            listeners.push(data.addListener('removefeature', (event) => {
+                ngZone.run(() => { subscriber.next(undefined); });
+            }));
+            listeners.push(data.addListener('setproperty', (event) => {
+                if (!isAppFeatureProperty(event.name)) {
+                    ngZone.run(() => { subscriber.next(undefined); });
+                }
+            }));
+            listeners.push(data.addListener('removeproperty', (event) => {
+                if (!isAppFeatureProperty(event.name)) {
+                    ngZone.run(() => { subscriber.next(undefined); });
+                }
+            }));
+        });
+        return () => {
+            listeners.forEach(google.maps.event.removeListener);
+        };
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"google-maps-feature-helpers.js","sourceRoot":"","sources":["../../../../projects/ui-common/google-maps/google-maps-feature-helpers.ts"],"names":[],"mappings":"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","sourcesContent":["import { coerceBooleanProperty } from '@angular/cdk/coercion'\nimport { NgZone } from '@angular/core'\nimport { Observable } from 'rxjs'\n\nimport { notNullOrUndefined } from '@theseam/ui-common/utils'\nimport booleanContains from '@turf/boolean-contains'\nimport {\n  multiPolygon as turfjsMultiPolygon,\n  polygon as turfjsPolygon,\n} from '@turf/helpers'\n\nexport enum AppFeaturePropertyName {\n  IsSelected = `__app__isSelected`\n}\n\nexport function isAppFeatureProperty(propertyName: string): propertyName is AppFeaturePropertyName {\n  return Object.values(AppFeaturePropertyName)\n    .findIndex(value => value === propertyName) !== -1\n}\n\nexport function isFeatureSelected(feature: google.maps.Data.Feature): boolean {\n  const isSelected = feature.getProperty(AppFeaturePropertyName.IsSelected)\n  return coerceBooleanProperty(isSelected)\n}\n\nexport function setFeatureSelected(feature: google.maps.Data.Feature, isSelected: boolean): void {\n  feature.setProperty(AppFeaturePropertyName.IsSelected, isSelected)\n}\n\n// TODO: Check performance of cloning a google.maps.Data instance, so the\n// properties can be removed with the google maps api, instead of on the\n// resulting json.\nexport function stripAppFeaturePropertiesFromJson(json: any) {\n  if (notNullOrUndefined(json) && Array.isArray(json?.features)) {\n    for (const feature of json.features) {\n      if (notNullOrUndefined(feature?.properties)) {\n        for (const k of Object.keys(feature.properties)) {\n          if (isAppFeatureProperty(k)) {\n            feature.properties[k] = undefined\n            delete feature.properties[k]\n          }\n        }\n      }\n    }\n  }\n}\n\n/**\n * Searches for a Feature in Data that contains the provided Feature and can use\n * it as a cutout area.\n */\nexport function getPossibleExteriorFeature(\n  data: google.maps.Data,\n  feature: google.maps.Data.Feature\n): google.maps.Data.Feature | undefined {\n  let exteriorPolygonFeature: google.maps.Data.Feature | undefined\n  data.forEach(f => {\n    if (f === feature) {\n      return\n    }\n\n    const geometry = f.getGeometry()\n    if (geometry === null) {\n      throw Error(`Geometry not found.`)\n    }\n    if (geometry.getType() === 'Polygon' && featureContains(f, feature)) {\n      exteriorPolygonFeature = f\n    }\n  })\n  return exteriorPolygonFeature\n}\n\nexport function addInnerFeatureCutoutToExteriorFeature(\n  exteriorFeature: google.maps.Data.Feature,\n  innerFeature: google.maps.Data.Feature\n): void {\n  const exteriorGeometry = exteriorFeature.getGeometry()\n  if (exteriorGeometry === null) {\n    throw Error(`Geometry not found.`)\n  }\n  const innerGeometry = innerFeature.getGeometry()\n  if (innerGeometry === null) {\n    throw Error(`Geometry not found.`)\n  }\n  // NOTE: Other geometries may support cutouts, but our map shapes editor only\n  // supports polygons currently, so we will need to handle other geometry types\n  // here if we start allowing users to draw shapes other than polygon.\n  if (exteriorGeometry.getType() !== 'Polygon' || innerGeometry.getType() !== 'Polygon') {\n    throw Error(`Inner cutout is only supported by Polygon gemoetry.`)\n  }\n\n  const featurePolygon = innerGeometry as google.maps.Data.Polygon\n  const exteriorPolygon = exteriorGeometry as google.maps.Data.Polygon\n  exteriorFeature.setGeometry(new google.maps.Data.Polygon([\n    ...exteriorPolygon.getArray(),\n    featurePolygon.getAt(0).getArray().reverse()\n  ]))\n}\n\n/**\n * Google maps paths don't always start and stop at the exact same position, so\n * this will fix that for turfjs.\n */\nexport function fixPathDifferentStartingAndEndingPoint(coordinates: number[][]): void {\n  if (coordinates.length <= 1) {\n    return\n  }\n\n  const start = coordinates[0]\n  const end = coordinates[coordinates.length - 1]\n  if (start[0] === end[0] && start[1] === end[1]) {\n    return\n  }\n\n  coordinates.push(coordinates[0])\n}\n\nexport function polygonHasValidPathsLengths(polygon: google.maps.Polygon, minPointsInValidPath: number = 3): boolean {\n  const paths = polygon.getPaths().getArray()\n  for (const path of paths) {\n    if (path.getLength() < minPointsInValidPath) {\n      return false\n    }\n  }\n  return true\n}\n\nexport function polygonCoordinates(polygon: google.maps.Data.Polygon): number[][][] {\n  return polygon.getArray().map(linRing => {\n    const coords = linRing.getArray().map(x => [ x.lng(), x.lat() ])\n    fixPathDifferentStartingAndEndingPoint(coords)\n    return coords\n  })\n}\n\nexport function multiPolygonCoordinates(multiPolygon: google.maps.Data.MultiPolygon): number[][][][] {\n  return multiPolygon.getArray().map(x => polygonCoordinates(x))\n}\n\nexport function toTurfJsPolygon(polygon: google.maps.Data.Polygon) {\n  return turfjsPolygon(polygonCoordinates(polygon))\n}\n\nexport function toTurfJsMultiPolygon(multiPolygon: google.maps.Data.MultiPolygon) {\n  return turfjsMultiPolygon(multiPolygonCoordinates(multiPolygon))\n}\n\nexport function toTurfJsFeature(googleFeature: google.maps.Data.Feature) {\n  const geometry = googleFeature.getGeometry()\n  if (geometry === null) {\n    throw Error(`Geometry not found.`)\n  }\n  if (geometry.getType() === 'Polygon') {\n    return toTurfJsPolygon(geometry as google.maps.Data.Polygon)\n  } else if (geometry.getType() === 'MultiPolygon') {\n    return toTurfJsMultiPolygon(geometry as google.maps.Data.MultiPolygon)\n  }\n\n  throw Error(`Unexpected geometry.`)\n}\n\nexport function featureContains(featureA: google.maps.Data.Feature, featureB: google.maps.Data.Feature): boolean {\n  const polygonA = toTurfJsFeature(featureA)\n  const polygonB = toTurfJsFeature(featureB)\n  return booleanContains(polygonA, polygonB)\n}\n\nexport function createDataFeatureFromPolygon(polygon: google.maps.Polygon): google.maps.Data.Feature {\n  const arr = polygon.getPaths().getArray().map(x => x.getArray())\n  return new google.maps.Data.Feature({\n    geometry: new google.maps.Data.Polygon(arr)\n  })\n}\n\nexport function getBoundsWithAllFeatures(data: google.maps.Data): google.maps.LatLngBounds {\n  const bounds = new google.maps.LatLngBounds()\n\n  data.forEach(feature => {\n    const geometry = feature.getGeometry()\n    if (geometry === null) {\n      throw Error(`Geometry not found.`)\n    }\n    geometry.forEachLatLng(latLng => {\n      bounds.extend(latLng)\n    })\n  })\n\n  return bounds\n}\n\nexport function getFeatureBounds(feature: google.maps.Data.Feature): google.maps.LatLngBounds {\n  const bounds = new google.maps.LatLngBounds()\n\n  const geometry = feature.getGeometry()\n  if (geometry === null) {\n    throw Error(`Geometry not found.`)\n  }\n  geometry.forEachLatLng(latLng => {\n    bounds.extend(latLng)\n  })\n\n  return bounds\n}\n\nexport function getFeatureCenter(feature: google.maps.Data.Feature): google.maps.LatLng {\n  return getFeatureBounds(feature).getCenter()\n}\n\nexport function removeAllFeatures(data: google.maps.Data): void {\n  data.forEach(f => data.remove(f))\n}\n\nexport function getFeaturesCount(data: google.maps.Data): number {\n  let count = 0\n  data.forEach(() => count++)\n  return count\n}\n\n/**\n * NOTE: Original events are not emitted, because filtering may omit events.\n */\nexport function createFeatureChangeObservable(data: google.maps.Data, ngZone: NgZone): Observable<void> {\n  return new Observable<void>(subscriber => {\n    const listeners: google.maps.MapsEventListener[] = []\n\n    ngZone.runOutsideAngular(() => {\n      listeners.push(data.addListener('setgeometry', (event: google.maps.Data.SetGeometryEvent) => {\n        ngZone.run(() => { subscriber.next(undefined) })\n      }))\n\n      listeners.push(data.addListener('addfeature', (event: google.maps.Data.AddFeatureEvent) => {\n        ngZone.run(() => { subscriber.next(undefined) })\n      }))\n\n      listeners.push(data.addListener('removefeature', (event: google.maps.Data.RemoveFeatureEvent) => {\n        ngZone.run(() => { subscriber.next(undefined) })\n      }))\n\n      listeners.push(data.addListener('setproperty', (event: google.maps.Data.SetPropertyEvent) => {\n        if (!isAppFeatureProperty(event.name)) {\n          ngZone.run(() => { subscriber.next(undefined) })\n        }\n      }))\n\n      listeners.push(data.addListener('removeproperty', (event: google.maps.Data.RemovePropertyEvent) => {\n        if (!isAppFeatureProperty(event.name)) {\n          ngZone.run(() => { subscriber.next(undefined) })\n        }\n      }))\n    })\n\n    return () => {\n      listeners.forEach(google.maps.event.removeListener)\n    }\n  })\n}\n"]}