@angular/google-maps 13.0.0-next.7 → 13.0.0-rc.2

package/esm2020/map-info-window/map-info-window.mjs

@@ -0,0 +1,203 @@
+/// <reference types="google.maps" />
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+// Workaround for: https://github.com/bazelbuild/rules_nodejs/issues/1265
+/// <reference types="google.maps" />
+import { Directive, ElementRef, Input, NgZone, Output } from '@angular/core';
+import { BehaviorSubject, combineLatest, Observable, Subject } from 'rxjs';
+import { map, take, takeUntil } from 'rxjs/operators';
+import { GoogleMap } from '../google-map/google-map';
+import { MapEventManager } from '../map-event-manager';
+import * as i0 from "@angular/core";
+import * as i1 from "../google-map/google-map";
+/**
+ * Angular component that renders a Google Maps info window via the Google Maps JavaScript API.
+ *
+ * See developers.google.com/maps/documentation/javascript/reference/info-window
+ */
+export class MapInfoWindow {
+    constructor(_googleMap, _elementRef, _ngZone) {
+        this._googleMap = _googleMap;
+        this._elementRef = _elementRef;
+        this._ngZone = _ngZone;
+        this._eventManager = new MapEventManager(this._ngZone);
+        this._options = new BehaviorSubject({});
+        this._position = new BehaviorSubject(undefined);
+        this._destroy = new Subject();
+        /**
+         * See
+         * developers.google.com/maps/documentation/javascript/reference/info-window#InfoWindow.closeclick
+         */
+        this.closeclick = this._eventManager.getLazyEmitter('closeclick');
+        /**
+         * See
+         * developers.google.com/maps/documentation/javascript/reference/info-window
+         * #InfoWindow.content_changed
+         */
+        this.contentChanged = this._eventManager.getLazyEmitter('content_changed');
+        /**
+         * See
+         * developers.google.com/maps/documentation/javascript/reference/info-window#InfoWindow.domready
+         */
+        this.domready = this._eventManager.getLazyEmitter('domready');
+        /**
+         * See
+         * developers.google.com/maps/documentation/javascript/reference/info-window
+         * #InfoWindow.position_changed
+         */
+        this.positionChanged = this._eventManager.getLazyEmitter('position_changed');
+        /**
+         * See
+         * developers.google.com/maps/documentation/javascript/reference/info-window
+         * #InfoWindow.zindex_changed
+         */
+        this.zindexChanged = this._eventManager.getLazyEmitter('zindex_changed');
+    }
+    set options(options) {
+        this._options.next(options || {});
+    }
+    set position(position) {
+        this._position.next(position);
+    }
+    ngOnInit() {
+        if (this._googleMap._isBrowser) {
+            const combinedOptionsChanges = this._combineOptions();
+            combinedOptionsChanges.pipe(take(1)).subscribe(options => {
+                // Create the object outside the zone so its events don't trigger change detection.
+                // We'll bring it back in inside the `MapEventManager` only for the events that the
+                // user has subscribed to.
+                this._ngZone.runOutsideAngular(() => {
+                    this.infoWindow = new google.maps.InfoWindow(options);
+                });
+                this._eventManager.setTarget(this.infoWindow);
+            });
+            this._watchForOptionsChanges();
+            this._watchForPositionChanges();
+        }
+    }
+    ngOnDestroy() {
+        this._eventManager.destroy();
+        this._destroy.next();
+        this._destroy.complete();
+        // If no info window has been created on the server, we do not try closing it.
+        // On the server, an info window cannot be created and this would cause errors.
+        if (this.infoWindow) {
+            this.close();
+        }
+    }
+    /**
+     * See developers.google.com/maps/documentation/javascript/reference/info-window#InfoWindow.close
+     */
+    close() {
+        this._assertInitialized();
+        this.infoWindow.close();
+    }
+    /**
+     * See
+     * developers.google.com/maps/documentation/javascript/reference/info-window#InfoWindow.getContent
+     */
+    getContent() {
+        this._assertInitialized();
+        return this.infoWindow.getContent() || null;
+    }
+    /**
+     * See
+     * developers.google.com/maps/documentation/javascript/reference/info-window
+     * #InfoWindow.getPosition
+     */
+    getPosition() {
+        this._assertInitialized();
+        return this.infoWindow.getPosition() || null;
+    }
+    /**
+     * See
+     * developers.google.com/maps/documentation/javascript/reference/info-window#InfoWindow.getZIndex
+     */
+    getZIndex() {
+        this._assertInitialized();
+        return this.infoWindow.getZIndex();
+    }
+    /**
+     * Opens the MapInfoWindow using the provided anchor. If the anchor is not set,
+     * then the position property of the options input is used instead.
+     */
+    open(anchor) {
+        this._assertInitialized();
+        const anchorObject = anchor ? anchor.getAnchor() : undefined;
+        // Prevent the info window from initializing when trying to reopen on the same anchor.
+        // Note that when the window is opened for the first time, the anchor will always be
+        // undefined. If that's the case, we have to allow it to open in order to handle the
+        // case where the window doesn't have an anchor, but is placed at a particular position.
+        if (this.infoWindow.get('anchor') !== anchorObject || !anchorObject) {
+            this._elementRef.nativeElement.style.display = '';
+            this.infoWindow.open(this._googleMap.googleMap, anchorObject);
+        }
+    }
+    _combineOptions() {
+        return combineLatest([this._options, this._position]).pipe(map(([options, position]) => {
+            const combinedOptions = {
+                ...options,
+                position: position || options.position,
+                content: this._elementRef.nativeElement,
+            };
+            return combinedOptions;
+        }));
+    }
+    _watchForOptionsChanges() {
+        this._options.pipe(takeUntil(this._destroy)).subscribe(options => {
+            this._assertInitialized();
+            this.infoWindow.setOptions(options);
+        });
+    }
+    _watchForPositionChanges() {
+        this._position.pipe(takeUntil(this._destroy)).subscribe(position => {
+            if (position) {
+                this._assertInitialized();
+                this.infoWindow.setPosition(position);
+            }
+        });
+    }
+    _assertInitialized() {
+        if (typeof ngDevMode === 'undefined' || ngDevMode) {
+            if (!this._googleMap.googleMap) {
+                throw Error('Cannot access Google Map information before the API has been initialized. ' +
+                    'Please wait for the API to load before trying to interact with it.');
+            }
+            if (!this.infoWindow) {
+                throw Error('Cannot interact with a Google Map Info Window before it has been ' +
+                    'initialized. Please wait for the Info Window to load before trying to interact with ' +
+                    'it.');
+            }
+        }
+    }
+}
+MapInfoWindow.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: MapInfoWindow, deps: [{ token: i1.GoogleMap }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Directive });
+MapInfoWindow.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.0-next.15", type: MapInfoWindow, selector: "map-info-window", inputs: { options: "options", position: "position" }, outputs: { closeclick: "closeclick", contentChanged: "contentChanged", domready: "domready", positionChanged: "positionChanged", zindexChanged: "zindexChanged" }, host: { styleAttribute: "display: none" }, exportAs: ["mapInfoWindow"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: MapInfoWindow, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'map-info-window',
+                    exportAs: 'mapInfoWindow',
+                    host: { 'style': 'display: none' },
+                }]
+        }], ctorParameters: function () { return [{ type: i1.GoogleMap }, { type: i0.ElementRef }, { type: i0.NgZone }]; }, propDecorators: { options: [{
+                type: Input
+            }], position: [{
+                type: Input
+            }], closeclick: [{
+                type: Output
+            }], contentChanged: [{
+                type: Output
+            }], domready: [{
+                type: Output
+            }], positionChanged: [{
+                type: Output
+            }], zindexChanged: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"map-info-window.js","sourceRoot":"","sources":["../../../../../../src/google-maps/map-info-window/map-info-window.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n// Workaround for: https://github.com/bazelbuild/rules_nodejs/issues/1265\n/// <reference types=\"google.maps\" />\n\nimport {Directive, ElementRef, Input, NgZone, OnDestroy, OnInit, Output} from '@angular/core';\nimport {BehaviorSubject, combineLatest, Observable, Subject} from 'rxjs';\nimport {map, take, takeUntil} from 'rxjs/operators';\n\nimport {GoogleMap} from '../google-map/google-map';\nimport {MapEventManager} from '../map-event-manager';\nimport {MapAnchorPoint} from '../map-anchor-point';\n\n/**\n * Angular component that renders a Google Maps info window via the Google Maps JavaScript API.\n *\n * See developers.google.com/maps/documentation/javascript/reference/info-window\n */\n@Directive({\n  selector: 'map-info-window',\n  exportAs: 'mapInfoWindow',\n  host: {'style': 'display: none'},\n})\nexport class MapInfoWindow implements OnInit, OnDestroy {\n  private _eventManager = new MapEventManager(this._ngZone);\n  private readonly _options = new BehaviorSubject<google.maps.InfoWindowOptions>({});\n  private readonly _position = new BehaviorSubject<\n    google.maps.LatLngLiteral | google.maps.LatLng | undefined\n  >(undefined);\n  private readonly _destroy = new Subject<void>();\n\n  /**\n   * Underlying google.maps.InfoWindow\n   *\n   * See developers.google.com/maps/documentation/javascript/reference/info-window#InfoWindow\n   */\n  infoWindow?: google.maps.InfoWindow;\n\n  @Input()\n  set options(options: google.maps.InfoWindowOptions) {\n    this._options.next(options || {});\n  }\n\n  @Input()\n  set position(position: google.maps.LatLngLiteral | google.maps.LatLng) {\n    this._position.next(position);\n  }\n\n  /**\n   * See\n   * developers.google.com/maps/documentation/javascript/reference/info-window#InfoWindow.closeclick\n   */\n  @Output() readonly closeclick: Observable<void> =\n    this._eventManager.getLazyEmitter<void>('closeclick');\n\n  /**\n   * See\n   * developers.google.com/maps/documentation/javascript/reference/info-window\n   * #InfoWindow.content_changed\n   */\n  @Output() readonly contentChanged: Observable<void> =\n    this._eventManager.getLazyEmitter<void>('content_changed');\n\n  /**\n   * See\n   * developers.google.com/maps/documentation/javascript/reference/info-window#InfoWindow.domready\n   */\n  @Output() readonly domready: Observable<void> =\n    this._eventManager.getLazyEmitter<void>('domready');\n\n  /**\n   * See\n   * developers.google.com/maps/documentation/javascript/reference/info-window\n   * #InfoWindow.position_changed\n   */\n  @Output() readonly positionChanged: Observable<void> =\n    this._eventManager.getLazyEmitter<void>('position_changed');\n\n  /**\n   * See\n   * developers.google.com/maps/documentation/javascript/reference/info-window\n   * #InfoWindow.zindex_changed\n   */\n  @Output() readonly zindexChanged: Observable<void> =\n    this._eventManager.getLazyEmitter<void>('zindex_changed');\n\n  constructor(\n    private readonly _googleMap: GoogleMap,\n    private _elementRef: ElementRef<HTMLElement>,\n    private _ngZone: NgZone,\n  ) {}\n\n  ngOnInit() {\n    if (this._googleMap._isBrowser) {\n      const combinedOptionsChanges = this._combineOptions();\n\n      combinedOptionsChanges.pipe(take(1)).subscribe(options => {\n        // Create the object outside the zone so its events don't trigger change detection.\n        // We'll bring it back in inside the `MapEventManager` only for the events that the\n        // user has subscribed to.\n        this._ngZone.runOutsideAngular(() => {\n          this.infoWindow = new google.maps.InfoWindow(options);\n        });\n\n        this._eventManager.setTarget(this.infoWindow);\n      });\n\n      this._watchForOptionsChanges();\n      this._watchForPositionChanges();\n    }\n  }\n\n  ngOnDestroy() {\n    this._eventManager.destroy();\n    this._destroy.next();\n    this._destroy.complete();\n\n    // If no info window has been created on the server, we do not try closing it.\n    // On the server, an info window cannot be created and this would cause errors.\n    if (this.infoWindow) {\n      this.close();\n    }\n  }\n\n  /**\n   * See developers.google.com/maps/documentation/javascript/reference/info-window#InfoWindow.close\n   */\n  close() {\n    this._assertInitialized();\n    this.infoWindow.close();\n  }\n\n  /**\n   * See\n   * developers.google.com/maps/documentation/javascript/reference/info-window#InfoWindow.getContent\n   */\n  getContent(): string | Node | null {\n    this._assertInitialized();\n    return this.infoWindow.getContent() || null;\n  }\n\n  /**\n   * See\n   * developers.google.com/maps/documentation/javascript/reference/info-window\n   * #InfoWindow.getPosition\n   */\n  getPosition(): google.maps.LatLng | null {\n    this._assertInitialized();\n    return this.infoWindow.getPosition() || null;\n  }\n\n  /**\n   * See\n   * developers.google.com/maps/documentation/javascript/reference/info-window#InfoWindow.getZIndex\n   */\n  getZIndex(): number {\n    this._assertInitialized();\n    return this.infoWindow.getZIndex();\n  }\n\n  /**\n   * Opens the MapInfoWindow using the provided anchor. If the anchor is not set,\n   * then the position property of the options input is used instead.\n   */\n  open(anchor?: MapAnchorPoint) {\n    this._assertInitialized();\n    const anchorObject = anchor ? anchor.getAnchor() : undefined;\n\n    // Prevent the info window from initializing when trying to reopen on the same anchor.\n    // Note that when the window is opened for the first time, the anchor will always be\n    // undefined. If that's the case, we have to allow it to open in order to handle the\n    // case where the window doesn't have an anchor, but is placed at a particular position.\n    if (this.infoWindow.get('anchor') !== anchorObject || !anchorObject) {\n      this._elementRef.nativeElement.style.display = '';\n      this.infoWindow.open(this._googleMap.googleMap, anchorObject);\n    }\n  }\n\n  private _combineOptions(): Observable<google.maps.InfoWindowOptions> {\n    return combineLatest([this._options, this._position]).pipe(\n      map(([options, position]) => {\n        const combinedOptions: google.maps.InfoWindowOptions = {\n          ...options,\n          position: position || options.position,\n          content: this._elementRef.nativeElement,\n        };\n        return combinedOptions;\n      }),\n    );\n  }\n\n  private _watchForOptionsChanges() {\n    this._options.pipe(takeUntil(this._destroy)).subscribe(options => {\n      this._assertInitialized();\n      this.infoWindow.setOptions(options);\n    });\n  }\n\n  private _watchForPositionChanges() {\n    this._position.pipe(takeUntil(this._destroy)).subscribe(position => {\n      if (position) {\n        this._assertInitialized();\n        this.infoWindow.setPosition(position);\n      }\n    });\n  }\n\n  private _assertInitialized(): asserts this is {infoWindow: google.maps.InfoWindow} {\n    if (typeof ngDevMode === 'undefined' || ngDevMode) {\n      if (!this._googleMap.googleMap) {\n        throw Error(\n          'Cannot access Google Map information before the API has been initialized. ' +\n            'Please wait for the API to load before trying to interact with it.',\n        );\n      }\n      if (!this.infoWindow) {\n        throw Error(\n          'Cannot interact with a Google Map Info Window before it has been ' +\n            'initialized. Please wait for the Info Window to load before trying to interact with ' +\n            'it.',\n        );\n      }\n    }\n  }\n}\n"]}

package/esm2020/map-kml-layer/map-kml-layer.mjs

@@ -0,0 +1,170 @@
+/// <reference types="google.maps" />
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+// Workaround for: https://github.com/bazelbuild/rules_nodejs/issues/1265
+/// <reference types="google.maps" />
+import { Directive, Input, NgZone, Output } from '@angular/core';
+import { BehaviorSubject, combineLatest, Observable, Subject } from 'rxjs';
+import { map, take, takeUntil } from 'rxjs/operators';
+import { GoogleMap } from '../google-map/google-map';
+import { MapEventManager } from '../map-event-manager';
+import * as i0 from "@angular/core";
+import * as i1 from "../google-map/google-map";
+/**
+ * Angular component that renders a Google Maps KML Layer via the Google Maps JavaScript API.
+ *
+ * See developers.google.com/maps/documentation/javascript/reference/kml#KmlLayer
+ */
+export class MapKmlLayer {
+    constructor(_map, _ngZone) {
+        this._map = _map;
+        this._ngZone = _ngZone;
+        this._eventManager = new MapEventManager(this._ngZone);
+        this._options = new BehaviorSubject({});
+        this._url = new BehaviorSubject('');
+        this._destroyed = new Subject();
+        /**
+         * See developers.google.com/maps/documentation/javascript/reference/kml#KmlLayer.click
+         */
+        this.kmlClick = this._eventManager.getLazyEmitter('click');
+        /**
+         * See
+         * developers.google.com/maps/documentation/javascript/reference/kml
+         * #KmlLayer.defaultviewport_changed
+         */
+        this.defaultviewportChanged = this._eventManager.getLazyEmitter('defaultviewport_changed');
+        /**
+         * See developers.google.com/maps/documentation/javascript/reference/kml#KmlLayer.status_changed
+         */
+        this.statusChanged = this._eventManager.getLazyEmitter('status_changed');
+    }
+    set options(options) {
+        this._options.next(options || {});
+    }
+    set url(url) {
+        this._url.next(url);
+    }
+    ngOnInit() {
+        if (this._map._isBrowser) {
+            this._combineOptions()
+                .pipe(take(1))
+                .subscribe(options => {
+                // Create the object outside the zone so its events don't trigger change detection.
+                // We'll bring it back in inside the `MapEventManager` only for the events that the
+                // user has subscribed to.
+                this._ngZone.runOutsideAngular(() => (this.kmlLayer = new google.maps.KmlLayer(options)));
+                this._assertInitialized();
+                this.kmlLayer.setMap(this._map.googleMap);
+                this._eventManager.setTarget(this.kmlLayer);
+            });
+            this._watchForOptionsChanges();
+            this._watchForUrlChanges();
+        }
+    }
+    ngOnDestroy() {
+        this._eventManager.destroy();
+        this._destroyed.next();
+        this._destroyed.complete();
+        if (this.kmlLayer) {
+            this.kmlLayer.setMap(null);
+        }
+    }
+    /**
+     * See
+     * developers.google.com/maps/documentation/javascript/reference/kml#KmlLayer.getDefaultViewport
+     */
+    getDefaultViewport() {
+        this._assertInitialized();
+        return this.kmlLayer.getDefaultViewport();
+    }
+    /**
+     * See developers.google.com/maps/documentation/javascript/reference/kml#KmlLayer.getMetadata
+     */
+    getMetadata() {
+        this._assertInitialized();
+        return this.kmlLayer.getMetadata();
+    }
+    /**
+     * See developers.google.com/maps/documentation/javascript/reference/kml#KmlLayer.getStatus
+     */
+    getStatus() {
+        this._assertInitialized();
+        return this.kmlLayer.getStatus();
+    }
+    /**
+     * See developers.google.com/maps/documentation/javascript/reference/kml#KmlLayer.getUrl
+     */
+    getUrl() {
+        this._assertInitialized();
+        return this.kmlLayer.getUrl();
+    }
+    /**
+     * See developers.google.com/maps/documentation/javascript/reference/kml#KmlLayer.getZIndex
+     */
+    getZIndex() {
+        this._assertInitialized();
+        return this.kmlLayer.getZIndex();
+    }
+    _combineOptions() {
+        return combineLatest([this._options, this._url]).pipe(map(([options, url]) => {
+            const combinedOptions = {
+                ...options,
+                url: url || options.url,
+            };
+            return combinedOptions;
+        }));
+    }
+    _watchForOptionsChanges() {
+        this._options.pipe(takeUntil(this._destroyed)).subscribe(options => {
+            if (this.kmlLayer) {
+                this._assertInitialized();
+                this.kmlLayer.setOptions(options);
+            }
+        });
+    }
+    _watchForUrlChanges() {
+        this._url.pipe(takeUntil(this._destroyed)).subscribe(url => {
+            if (url && this.kmlLayer) {
+                this._assertInitialized();
+                this.kmlLayer.setUrl(url);
+            }
+        });
+    }
+    _assertInitialized() {
+        if (typeof ngDevMode === 'undefined' || ngDevMode) {
+            if (!this._map.googleMap) {
+                throw Error('Cannot access Google Map information before the API has been initialized. ' +
+                    'Please wait for the API to load before trying to interact with it.');
+            }
+            if (!this.kmlLayer) {
+                throw Error('Cannot interact with a Google Map KmlLayer before it has been ' +
+                    'initialized. Please wait for the KmlLayer to load before trying to interact with it.');
+            }
+        }
+    }
+}
+MapKmlLayer.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: MapKmlLayer, deps: [{ token: i1.GoogleMap }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Directive });
+MapKmlLayer.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.0-next.15", type: MapKmlLayer, selector: "map-kml-layer", inputs: { options: "options", url: "url" }, outputs: { kmlClick: "kmlClick", defaultviewportChanged: "defaultviewportChanged", statusChanged: "statusChanged" }, exportAs: ["mapKmlLayer"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: MapKmlLayer, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'map-kml-layer',
+                    exportAs: 'mapKmlLayer',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.GoogleMap }, { type: i0.NgZone }]; }, propDecorators: { options: [{
+                type: Input
+            }], url: [{
+                type: Input
+            }], kmlClick: [{
+                type: Output
+            }], defaultviewportChanged: [{
+                type: Output
+            }], statusChanged: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"map-kml-layer.js","sourceRoot":"","sources":["../../../../../../src/google-maps/map-kml-layer/map-kml-layer.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n// Workaround for: https://github.com/bazelbuild/rules_nodejs/issues/1265\n/// <reference types=\"google.maps\" />\n\nimport {Directive, Input, NgZone, OnDestroy, OnInit, Output} from '@angular/core';\nimport {BehaviorSubject, combineLatest, Observable, Subject} from 'rxjs';\nimport {map, take, takeUntil} from 'rxjs/operators';\n\nimport {GoogleMap} from '../google-map/google-map';\nimport {MapEventManager} from '../map-event-manager';\n\n/**\n * Angular component that renders a Google Maps KML Layer via the Google Maps JavaScript API.\n *\n * See developers.google.com/maps/documentation/javascript/reference/kml#KmlLayer\n */\n@Directive({\n  selector: 'map-kml-layer',\n  exportAs: 'mapKmlLayer',\n})\nexport class MapKmlLayer implements OnInit, OnDestroy {\n  private _eventManager = new MapEventManager(this._ngZone);\n  private readonly _options = new BehaviorSubject<google.maps.KmlLayerOptions>({});\n  private readonly _url = new BehaviorSubject<string>('');\n\n  private readonly _destroyed = new Subject<void>();\n\n  /**\n   * The underlying google.maps.KmlLayer object.\n   *\n   * See developers.google.com/maps/documentation/javascript/reference/kml#KmlLayer\n   */\n  kmlLayer?: google.maps.KmlLayer;\n\n  @Input()\n  set options(options: google.maps.KmlLayerOptions) {\n    this._options.next(options || {});\n  }\n\n  @Input()\n  set url(url: string) {\n    this._url.next(url);\n  }\n\n  /**\n   * See developers.google.com/maps/documentation/javascript/reference/kml#KmlLayer.click\n   */\n  @Output() readonly kmlClick: Observable<google.maps.KmlMouseEvent> =\n    this._eventManager.getLazyEmitter<google.maps.KmlMouseEvent>('click');\n\n  /**\n   * See\n   * developers.google.com/maps/documentation/javascript/reference/kml\n   * #KmlLayer.defaultviewport_changed\n   */\n  @Output() readonly defaultviewportChanged: Observable<void> =\n    this._eventManager.getLazyEmitter<void>('defaultviewport_changed');\n\n  /**\n   * See developers.google.com/maps/documentation/javascript/reference/kml#KmlLayer.status_changed\n   */\n  @Output() readonly statusChanged: Observable<void> =\n    this._eventManager.getLazyEmitter<void>('status_changed');\n\n  constructor(private readonly _map: GoogleMap, private _ngZone: NgZone) {}\n\n  ngOnInit() {\n    if (this._map._isBrowser) {\n      this._combineOptions()\n        .pipe(take(1))\n        .subscribe(options => {\n          // Create the object outside the zone so its events don't trigger change detection.\n          // We'll bring it back in inside the `MapEventManager` only for the events that the\n          // user has subscribed to.\n          this._ngZone.runOutsideAngular(() => (this.kmlLayer = new google.maps.KmlLayer(options)));\n          this._assertInitialized();\n          this.kmlLayer.setMap(this._map.googleMap!);\n          this._eventManager.setTarget(this.kmlLayer);\n        });\n\n      this._watchForOptionsChanges();\n      this._watchForUrlChanges();\n    }\n  }\n\n  ngOnDestroy() {\n    this._eventManager.destroy();\n    this._destroyed.next();\n    this._destroyed.complete();\n    if (this.kmlLayer) {\n      this.kmlLayer.setMap(null);\n    }\n  }\n\n  /**\n   * See\n   * developers.google.com/maps/documentation/javascript/reference/kml#KmlLayer.getDefaultViewport\n   */\n  getDefaultViewport(): google.maps.LatLngBounds | null {\n    this._assertInitialized();\n    return this.kmlLayer.getDefaultViewport();\n  }\n\n  /**\n   * See developers.google.com/maps/documentation/javascript/reference/kml#KmlLayer.getMetadata\n   */\n  getMetadata(): google.maps.KmlLayerMetadata | null {\n    this._assertInitialized();\n    return this.kmlLayer.getMetadata();\n  }\n\n  /**\n   * See developers.google.com/maps/documentation/javascript/reference/kml#KmlLayer.getStatus\n   */\n  getStatus(): google.maps.KmlLayerStatus {\n    this._assertInitialized();\n    return this.kmlLayer.getStatus();\n  }\n\n  /**\n   * See developers.google.com/maps/documentation/javascript/reference/kml#KmlLayer.getUrl\n   */\n  getUrl(): string {\n    this._assertInitialized();\n    return this.kmlLayer.getUrl();\n  }\n\n  /**\n   * See developers.google.com/maps/documentation/javascript/reference/kml#KmlLayer.getZIndex\n   */\n  getZIndex(): number {\n    this._assertInitialized();\n    return this.kmlLayer.getZIndex();\n  }\n\n  private _combineOptions(): Observable<google.maps.KmlLayerOptions> {\n    return combineLatest([this._options, this._url]).pipe(\n      map(([options, url]) => {\n        const combinedOptions: google.maps.KmlLayerOptions = {\n          ...options,\n          url: url || options.url,\n        };\n        return combinedOptions;\n      }),\n    );\n  }\n\n  private _watchForOptionsChanges() {\n    this._options.pipe(takeUntil(this._destroyed)).subscribe(options => {\n      if (this.kmlLayer) {\n        this._assertInitialized();\n        this.kmlLayer.setOptions(options);\n      }\n    });\n  }\n\n  private _watchForUrlChanges() {\n    this._url.pipe(takeUntil(this._destroyed)).subscribe(url => {\n      if (url && this.kmlLayer) {\n        this._assertInitialized();\n        this.kmlLayer.setUrl(url);\n      }\n    });\n  }\n\n  private _assertInitialized(): asserts this is {kmlLayer: google.maps.KmlLayer} {\n    if (typeof ngDevMode === 'undefined' || ngDevMode) {\n      if (!this._map.googleMap) {\n        throw Error(\n          'Cannot access Google Map information before the API has been initialized. ' +\n            'Please wait for the API to load before trying to interact with it.',\n        );\n      }\n      if (!this.kmlLayer) {\n        throw Error(\n          'Cannot interact with a Google Map KmlLayer before it has been ' +\n            'initialized. Please wait for the KmlLayer to load before trying to interact with it.',\n        );\n      }\n    }\n  }\n}\n"]}